Guia de Trabajo POO

Guia de Trabajo POO-
Ej1-Utilizando POO elabore una calculadora básica que pida el tipo de operación y dos números para operarlos.
public class Calculadora {

//atributos
double resultado;
//metodos
public double operacion(int opcion, double numero1, double numero2) {
switch(opcion) {
case 1:
this.resultado = numero1 + numero2;
break;
case 2:
this.resultado = numero1 - numero2;
break;
case 3:
this.resultado = numero1 * numero2;
break;
case 4:
this.resultado = numero1 / numero2;
break;
}
return this.resultado;
}
Clase Ejecutable
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner lectura = new Scanner(System.in);

// se crea objeto para llamar funciones de la clase Calculadora
Calculadora calculadora = new Calculadora();
int opcion;
double numero1, numero2, resultado;
do {
System.out.println("------------MENÚ DEL SISTEMA---------------");
System.out.println("Presione - 1 - Para hacer una Suma");
System.out.println("Presione - 2 - Para hacer una Resta");
System.out.println("Presione - 3 - Para hacer una Multiplicación");
System.out.println("Presione - 4 - Para hacer una División");
System.out.println("Presione - 0 - Para Salir");
//se captura datos introducido por el usuario y se convierte al tipo de dato de la variable.
opcion = lectura.nextInt();
if (opcion != 0) {
System.out.println("Ingrese el primer número");
numero1 = lectura.nextDouble();
System.out.println("Ingrese el segundo número");
numero2 = lectura.nextDouble();
// se manda a llamar el metodo o funcion operacion para realizar la operación solicitada

resultado= calculadora.operacion(opcion, numero1, numero2);
System.out.println("El resultado de la operación es " + resultado);

}
}while(opcion !=0);
Ej2- Utilizando POO elabore un programa que calcule el perímetro de un cuadro, triángulo equilátero y círculo. Para
esto debe pedir la figura geométrica y los valores apropiados para cada tipo. (Debe utilizar herencia)
package perimetroFigurasGeometricas;
//clase padre o superclase

public class figuraGeometrica {
//Atributos
String nombre;
double perimetro;
// métodos set y get para cada atributo

public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public double getPerimetro() {
return perimetro;
}
public void setPerimetro(double perimetro) {
this.perimetro = perimetro;
}
//
public void calcularPerimetro() {
// aplicar herencia de la superclase figurasGeometricas con la palabra extends
public class Circulo extends figuraGeometrica {

//atributos
private double diametro;
// Anulación, Sobreescritura o Overriding es una característica que permite que una subclase o clase secundaria
proporcione una implementación específica de un método que ya está provisto por una de sus superclases o clases padre.
@Override
// TODO Auto-generated method stub
this.perimetro=Math.PI * diametro;
}
public double getDiametro() {
return diametro;
}
public void setDiametro(double diametro) {

this.diametro = diametro;
}
public class Cuadrado extends figuraGeometrica{

//atributos
private double lado;
public double getLado() {

return lado;
}
public void setLado(double lado) {

this.lado = lado;
}
// Anulación, Sobreescritura o Overriding es una característica que permite que una subclase o clase secundaria
proporcione una implementación específica de un método que ya está provisto por una de sus superclases o clases padre.
@Override
this.perimetro = lado * 4;
}
}
public class Triangulo extends figuraGeometrica {

//atributos
private double lado;
public double getLado() {
return lado;
}
public void setLado(double lado) {

this.lado = lado;
}
/*Anulación, Sobreescritura o Overriding es una característica que permite que una subclase o clase secundaria
proporcione una implementación específica de un método que ya está provisto por una de sus superclases o clases
padre.*/
@Override
this.perimetro = lado * 3;
}
}
Clase Ejecutable
public class Main {

Scanner lectura = new Scanner (System.in);
// se crea un objeto por cada clase
Circulo figuraCirculo = new Circulo();
Cuadrado figuraCuadrado = new Cuadrado();
Triangulo figuraTriangulo = new Triangulo();
int opcion;
do {
System.out.println("");
System.out.println("MENÚ DE SISTEMA");
System.out.println("Seleccione el número de la opción que desea:");
System.out.println("1 - Para calcular el área de un circulo");
System.out.println("2 - Para calcular el área de un cuadrado");
System.out.println("3 - Para calcular el área de un triangulo");
System.out.println("0 - Para salir");
switch (opcion) {
case 1:
figuraCirculo.nombre ="circulo";
System.out.println("Introduzca el diametro del circulo");
figuraCirculo.setDiametro(lectura.nextDouble());
figuraCirculo.calcularPerimetro();
System.out.println("El perimetro del " + figuraCirculo.nombre + " es " +
figuraCirculo.getPerimetro());
break;
case 2:
figuraCuadrado.nombre ="cuadrado";
System.out.println("Introduzca el lado del cuadrado");
figuraCuadrado.setLado(lectura.nextDouble());
figuraCuadrado.calcularPerimetro();
System.out.println("El perimetro del " + figuraCuadrado.nombre + " es " +
figuraCuadrado.getPerimetro());
break;
case 3:
figuraTriangulo.nombre ="triangulo equilatero";
System.out.println("Introduzca el lado del triangulo equilatero");
figuraTriangulo.setLado(lectura.nextDouble());
figuraTriangulo.calcularPerimetro();
System.out.println("El perimetro del " + figuraTriangulo.nombre + " es " +
figuraTriangulo.getPerimetro());
break;
}
} while (opcion != 0);
}
Ej3- Utilizando POO y ArrayList elabore un programa que solicite N notas de examen y luego indique cual es la cantidad
de aprobados y reprobados
public class Notas {

//atributos
double nota;

public double getNota() {
return nota;
}
public void setNota(double nota) {

this.nota = nota;
}
// método que retornara un valor booleano falso o verdadero

public boolean notaAprobada() {
if (this.nota>= 6) {
return true;
}else {
return false;
}
}
Clase Ejecutable
import java.util.ArrayList;
public class Main {

Scanner lectura = new Scanner (System.in);
ArrayList<Notas> examenes = new ArrayList<Notas>();
int opcion, contadorAprobados, contadorReprobados;
do {
System.out.println("");
System.out.println("MENÚ DE SISTEMA");
System.out.println("Seleccione el número de la opción que desea:");
System.out.println("1 - Para agregar una nota");
System.out.println("2 - Para ver las estadisticas de las notas ingresadas");
System.out.println("0 - Para salir");
switch (opcion) {
case 1:
System.out.println("Introduzca la nota del examen");
Notas nota = new Notas();
nota.setNota(lectura.nextDouble());
examenes.add(nota);
break;
case 2:
contadorAprobados=0;
contadorReprobados=0;
for (int i = 0; i < examenes.size() ; i ++) {
if (examenes.get(i).notaAprobada()==true) {
contadorAprobados=contadorAprobados+1;
} else {
contadorReprobados=contadorReprobados+1;
}
}
System.out.println("Cantidad de examenes: " + examenes.size());

System.out.println("Cantidad de examenes aprobados: " + contadorAprobados);
System.out.println("Cantidad de examenes reprobados: " + contadorReprobados);
break;
}
} while (opcion != 0);

}
Ej4- Haciendo uso de POO Crear una clase Libro que contenga los siguientes atributos: ISBN, Título, Autor y Número de
páginas. Crear sus respectivos métodos get y set correspondientes para cada atributo. Crear el método toString() para
mostrar la información relativa al libro con el siguiente formato: “El libro con ISBN creado por el autor tiene páginas” En
la clase ejecutable, crear 2 objetos Libro (los valores que se quieran) y mostrarlos por pantalla. Por último, indicar cuál
de los 2 tiene más páginas.
https://youtu.be/eul9fP98XhI
public class Libro {
/*Atributos*/
private int ISBN;
private String titulo;
private String autor;
private int numPaginas;
/*Constructores*/
public Libro(int pISBN, String pTitulo, String pAutor, int pNumPaginas){
ISBN=pISBN;
titulo=pTitulo;
autor=pAutor;
numPaginas=pNumPaginas;
/*Metodos*/
public int getISBN() {

return ISBN;
}
public void setISBN(int ISBN) {

this.ISBN = ISBN;
}
public String getTitulo() {

return titulo;
}
public void setTitulo(String titulo) {

this.titulo = titulo;
}
public String getAutor() {

return autor;
}
public void setAutor(String autor) {

this.autor = autor;
}
public int getNumPaginas() {

return numPaginas;
}
public void setNumPaginas(int numPaginas) {

this.numPaginas = numPaginas;
}
/*El método Java toString() es de los métodos más utilizados de la clase object cuando estamos trabajando en el día a
día. ¿Para qué sirve este método? . Realmente su uso esta muy orientado a presentarnos una información legible del
objeto con el que en un momento estamos trabajando. Para ello siempre tendremos que sobre escribirlo y definir el tipo
de implementación que más nos encaje*/
@Override
public String toString(){
return "El libro "+titulo+" con ISBN "+ISBN+""
+ " creado por el autor "+autor
+ " tiene "+numPaginas+" páginas";
}
}
Clase Ejecutable
public class Main {

//Creamos los objetos

Libro libro1=new Libro(1111111111, "titulo1", "autor1", 30);
Libro libro2=new Libro(1111111112, "titulo2", "autor2", 60);
//Mostramos su estado
System.out.println(libro1.toString());
System.out.println(libro2.toString());
//Modificamos el atributo numPaginas del libro1

libro1.setNumPaginas(70);
//Comparamos quien tiene mas paginas

if(libro1.getNumPaginas()>libro2.getNumPaginas()){
System.out.println(libro1.getTitulo()+" tiene más páginas");
}else{
System.out.println(libro2.getTitulo()+" tiene más páginas");
}
}
}
Ej5- Haciendo uso de POO crear un programa que representen los valores de las raíces de una ecuación de 2º grado. Se
tendrá 3 coeficientes como atributos, se pueden llamar a, b y c. Se deben insertar estos 3 valores para construir el
objeto. Las operaciones que se podrán hacer son las siguientes:
obtenerRaices(): imprime las 2 posibles soluciones

obtenerRaiz(): imprime única raíz, que será cuando solo tenga una solución posible.
getDiscriminante(): devuelve el valor del discriminante (double), el discriminante tiene la siguiente formula, (b^2)-4*a*c
tieneRaices(): devuelve un booleano indicando si tiene dos soluciones, para que esto ocurra, el discriminante debe ser
mayor o igual que 0.
tieneRaiz(): devuelve un booleano indicando si tiene una única solución, para que esto ocurra, el discriminante debe ser
igual que 0.
calcular(): mostrará por consola las posibles soluciones que tiene nuestra ecuación, en caso de no existir solución,
mostrarlo también.
Formula ecuación 2º grado: (-b±√((b^2)-(4*a*c)))/(2*a)
https://youtu.be/M35_PFdLITs
public class Raices {
/*Atributos*/
private double a;
private double b;
private double c;
/**
* Ecuacion de 2º grado
* @param a
* @param b
* @param c
*/
public Raices(double a, double b, double c){
this.a=a;
this.b=b;
this.c=c;
}
/**
* Metodos para obtener las raices cuando hay 2 soluciones posibles
*/
private void obtenerRaices(){
double x1=(-b+Math.sqrt(getDiscriminante()))/(2*a);
double x2=(-b-Math.sqrt(getDiscriminante()))/(2*a);
System.out.println("Solucion X1");
System.out.println(x1);
System.out.println("Solucion X2");
System.out.println(x2);
}
/**
* Obtiene una unica raiz, cuando solo tiene la posibilidad de tener una solucion
*/
private void obtenerRaiz(){
double x=(-b)/(2*a);
System.out.println("Unica solucion");
System.out.println(x);
/**
* Nos devuelve el valor del discriminante,
* @return
*/
private double getDiscriminante(){
return Math.pow(b, 2)-(4*a*c);
}
/**
* Si el discriminante es mayor que 0 tiene mas de una raiz
* (No hemos puesto >= ya que puede confundirse con una solucion)
* @return
*/
private boolean tieneRaices(){
return getDiscriminante()>0;
}
/**
* Si el discriminante es igual a cero tiene una sola raiz
* @return
*/
private boolean tieneRaiz(){
return getDiscriminante()==0;
}
/**
* Nos permite calcular las raices de una ecuacion de 2º grado
*/
public void calcular(){
if(tieneRaices()){
obtenerRaices();
}else if(tieneRaiz()){
obtenerRaiz();
}else{
System.out.println("No tiene soluciones");
}
Clase Ejecutable
public class Main {

Raices ecuacion=new Raices(1,4,4); //creamos el objeto
ecuacion.calcular(); //Calculamos
}
}
Ej6- Crear una lista de a lo más 20 números decimales, los valores de la lista deberán estar entre 1 y 100, mostrar el
promedio de los números mayores a 25.4
//Importamos la utilidad Arraylist para poder usarla

//importamos la utilidad Iterator para mostrar una forma diferente de imprimir la lista
import java.util.Iterator;
public class tarea {
//Declaramos el Arraylist que contendra los numeros aleatorios
ArrayList lista;
//Declaramos un Array para almacenar los numeros mayores a 24.5
ArrayList filtro;
//Declaramos un número decimal aleatorio
private Double aleatorio;
//constructor de la Clase tarea
public tarea (){
//Creamos los arraylist los cuales se iniciaran con un valor por defecto de 10
this.lista = new ArrayList<Double> ();
this.filtro = new ArrayList<Double>();
//Creo un metodo para llenar los Arraylist
//Este método lo explicare con detalle ,ya que es aquí donde se encuentra la lógica del programa
public void llenarlista ()
/*Este ciclo es una de las formas de setear el tamaño de una lista para agregar un valor cada vez que se cree un
espacio de almacenamiento en esta, se crea un entero i de valor que se irá incrementando mientras sea menor o igual a
20 */
for(int i = 0;i<=20;i++)
{ /*cada vez que el valor i se incrementa, creo el decimal aleatorio de rango entre 1 y 100
aleatorio = Math.random()*99 + 1;
//agrego el número aleatorio a la lista
lista.add(aleatorio);
//uso el ciclo(for) y pregunto si alguno de los números generados es mayor a 24.5
if (aleatorio >25.4){
//de ser asi lo agrego a la segunda lista que cree la cual almacena los números mayores a 24.5
filtro.add (aleatorio);
//Imprimo la lista que contiene todos los numero aleatorios generados usando iterator
System.out.println("********Recorriendo el Arreglo*********") ;
Iterator it = lista.iterator();
while(it.hasNext ())
System.out.println("Elemento del arreglo: " + it.next());
//imprimo la lista usando herencia(sobreescritura del método toString de la clase arrayList)
System.out.println ("******** Elementos mayores a 25.4**************");
System.out.println("Lista:" + filtro);
//PARA sacar EL PROMEDIO/////
//Creo un número decimal (auxiliar)
Double x = 0.0;
//Recorro el arreglo de numeros mayores a 24.5 y obtengo el total de la suma de los numero de la lista filtro
for (int i = O; i<filtro.size(); i++){
x= (Double) filtro.get (1) + x;
//seteo el valor de x.... ahora será la suma de todos los números dividido por la cantidad de elementos del arreglo
x= x/(filtro.size()-1);
//Imprimo el promedio y lo redondeo ,porque es un promedio.
System.out.Print ("***********Promedio*********");
System.out.println (Math.round(x));
Clase Ejecutable
public class Maintarea {
//Creo la tarea y llamo al metodo llenarlista

public static void main(String[] args)
{
tarea t = new tarea();
t.llenarlista ();
}
}
Ej7- Se desea manejar una lista de robots. Cada robot tiene un número y un porcentaje de vida. El número de
elementos de la lista será un valor aleatorio entre 5 y 10. El porcentaje de vida de cada ROBOT será un valor aleatorio
entre 1 y 100.
Se pide construir una aplicación en java que permita cumplir con la siguiente funcionalidad:
● Imprimir la lista de robot ordenada por porcentaje de vida de los robots. Al principio de la lista DEBEN estar los
robots con menos porcentaje de vida.
● Imprimir la cantidad de robot que tienen más del 50% de vida.
● Imprimir el número de los TRES robots que tienen mayor porcentaje de vida.
Clase Ejecutable
import java.util.*;
public class Main {
public static void main(String[] args)
{//ArrayList de Robot
ArrayList<Robot> lista = new Arraylist<Robot> ();
int intervalo =(int) (Math.random()*(10-5+1)+5);

for (int x=0;x<intervalo;x++){
//Agregamos nuevos robots con un numero y un porcentajes de vida entre 1 y 100
lista.add(new Robot (x, (int) (Math.random()*(100-1+1)+1)));
//ordenamos la lista de robots con Collections.sort usara el metoso sobreescrito en la clase Robot
Collections.sort(lista) ;
//imprimimos la lista y llamamos al método toString() el cual esta sobreescrito en la clase Robot
System.out.println (lista.toString());
//recorremos la lista de robot y por cada porcentaje de vida mayor a 50% la variable cantidad aumenta en 1
int cantidad =0;
for(int x=0;x<lista.size();x++)
if (lista.get(x).getPorcentajeVida()>50)
cantidad++;
//imprimimos por consola la cantidad de robot que tienen vida superior a 50
System.out.println("Vida superior al 50%"+cantidad);
//imprimimos los números de los ultimos 3 robot con mayor porcentaje de vida
System.out.println(lista.get(lista.size()-1).getNumero() +"-"+lista.get(lista.size()-2).getNumero()+"-"+lista.get(lista.size()-
3).getNumero());
****************************************************************
//Implementaremos la interfaz comparable
public class Robot implements Comparable {
private int numero;
private int porcentajeVida;
public Robot (int numero,int porcentajeVida){
this.numero = numero;
this.porcentajeVida = porcentajeVida;
public int getNumero() {
return numero;
public int getPorcentajeVida () {
return porcentajeVida;
@Override
public String toString(){
return "Numero: " + this.numero + "Porcentaje Vida :" + this.porcentajeVida;
@Override //sobreescribiremos el metodo compareTo
public int compareTo (Object t) {
Robot ro = (Robot)t;
return this.getPorcentajeVida() - ro.getPorcentajeVida ();
Ej8- Crear una lista de números enteros, la cantidad de elementos de la lista

Debe ser un número aleatorio dentro del intervalo [10; 20].
Los valores que se agregan a la lista DEBEN ser números enteros dentro del intervalo [10; 100]
Se pide una aplicación en Java que permita cumplir con los siguientes requerimientos:
● Imprimir la lista de números generados
● Imprimir la suma de los números PARES que fueron generados
● Imprimir la cantidad de números impares que fueron generados.
import java.util.*;
public class Main {
public static void main(String[]args)
{//Creamos un ArrayList de enteros
ArrayList<Integer> lista = new ArrayList<Integer>();
//Declaramos una variable de tipo Int la cual contendra la cantidad de elementos que agregaremos a la lista
int intervalo=(int) (Math.random()* (20-10+1)+10);
//El ciclo for agregara nuevos numeros aleatorios entre [10;100] a la lista
for(int x=0;x<intervalo;x++){
lista.add( (int) (Math.random() * (100-10+1)+10));
}
//Mostramos la lista
System.out.println (lista);
//Declaramos 2 variables auxiliares totalPares llevará la suma de nuner|

//TotalImpares llevará la cuenta de numeros impares
int totalPares = 0;
int totalImpares = 0;|
for(int x=0;x<lista.size();x++){
//Cuando se divide un número por 2 su diferencia dependiendo si es par o impar sera 1 o 0.
if(lista.get(x) % 2 ==0){
totalPares = lista.get(x) + totalPares;
}else{
totalImpares++;
}
}
//Procederemos a imprimir los resultados

System.out.println("Total Suma Pares: "+ totalPares);
System.out.println("Total Impares: "+ totalImpares) ;
}
}
Ej9- Elaborar una clase que permita leer diez números en un arreglo de elementos de tipo entero, utilizar un método
que capture los datos, un método que calcule la media aritmética y otro método que imprima el resultado.
public class Arreglo {

int longitud = 10;
//se inicializa un objeto a partir de ArrayList como parámetro la clase Integer
ArrayList<Integer> lista = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
//método para capturar datos

public void IngresarDatos() {
for (int i = 0; i < longitud; i++) {
System.out.println("Ingrese el elemento " + (i + 1));
lista.add(scanner.nextInt());
}
}
// método para calcular la media aritmética
public double CalcularMediaAritmetica() {
double mediaAritmetica = 0;
int sumatoria = 0;
int posicion = 0;
while (posicion < longitud) {
sumatoria += lista.get(posicion);
posicion++;
}
mediaAritmetica = sumatoria / longitud;
return mediaAritmetica;
}
//metodo para imprimir valores del arreglo
public void Imprimir() {

System.out.println("Los valores introducidos son los siguientes:");
for (int i = 0; i < longitud; i++) {
System.out.print(lista.get(i) + " ");
}
System.out.println("La Media Aritmética de la serie de datos es: " + CalcularMediaAritmetica());
}
}
Clase Ejecutable
public class Principal {

Arreglo objArreglo = new Arreglo();
objArreglo.IngresarDatos();
objArreglo.Imprimir();
}
}
Ej10- Una Tienda de Calzado brinda un bono a sus empleados por logro de metas de ventas mensuales, si se logra al
menos 60% de la meta, el bono es del 10% del salario, si la venta mensual es mayor al 80% se obtiene el 20% de
bonificación y el 30% si se logra sobrepasar dicha meta.
Utilizando el concepto de Herencia, modelar una clase llamada Vendedor que hereda de la clase llamada Persona,
escribir los métodos necesarios para calcular el salario a pagar a final de mes.
public class Persona {

//atributos
private String nombres;
private String apellidos;
// constructor
Persona(String _nombres, String _apellidos){
this.nombres=_nombres;
this.apellidos=_apellidos;
}
/*El método Java toString() es de los métodos más utilizados de la clase object cuando estamos trabajando en el día a día.
¿Para qué sirve este método? . Realmente su uso esta muy orientado a presentarnos una información legible del objeto
con el que en un momento estamos trabajando. Para ello siempre tendremos que sobre escribirlo y definir el tipo de
implementación que más nos encaje*/
@Override
public String toString() {
return (nombres.toUpperCase()+" "+apellidos.toUpperCase());
}
}
public class Vendedor extends Persona {

//atributos
private float sueldo;
private float metaMensual;
private float ventaMensual;
public float getSueldo() {

return sueldo;
}
public void setSueldo(float sueldo) {
this.sueldo = sueldo;
}
public float getMetaMensual() {
return metaMensual;
}
public void setMetaMensual(float metaMensual) {
this.metaMensual = metaMensual;
}
public float getVentaMensual() {
return ventaMensual;
}
public void setVentaMensual(float ventaMensual) {
this.ventaMensual = ventaMensual;
}
/*constructor. super se puede usar para acceder al constructor de la clase padre. Una cosa más importante es que ”super”
puede llamar constructores tanto con parámetros como sin parámetros dependiendo de la situación
Vendedor(String _nombres, String _apellidos, float _sueldo, float _meta){

super(_nombres,_apellidos);
this.sueldo=_sueldo;
this.metaMensual=_meta;
}
Vendedor(String _nombres, String _apellidos){

super(_nombres, _apellidos);
}
public float CalcularBono() {

float bono=0;
int porcentajeVenta= Math.round((this.ventaMensual/this.metaMensual)*100) ;
if((this.ventaMensual>this.metaMensual)|| porcentajeVenta>80 ) {
bono= (float) 0.30;
}else if(porcentajeVenta>60 && porcentajeVenta<=80) {
bono=(float) 0.20;
}else if(porcentajeVenta==60){
bono=(float) 0.10;
}
return this.sueldo*bono+this.sueldo;
}
}
Clase Ejecutable
public class Inicio {

Scanner entrada = new Scanner(System.in);
String nombres;
String apellidos;
System.out.println("******BIENVENIDO******");
System.out.println("Introduzca Sus Nombres:");
nombres= entrada.nextLine();
System.out.println("Introduzca Sus Apellidos:");
apellidos=entrada.nextLine();
Vendedor objVendedor = new Vendedor(nombres, apellidos);
System.out.println("Introduzca Su Sueldo Mensual:");
objVendedor.setSueldo(entrada.nextFloat());
System.out.println("Introduzca El Total de Ventas Mensual:");
objVendedor.setVentaMensual(entrada.nextFloat());
System.out.println("Introduzca La Meta de Ventas:");
objVendedor.setMetaMensual(entrada.nextFloat());
System.out.println("++++Calculando Bonificacion++++");
System.out.println("Vendedor: "+objVendedor.toString());
System.out.println("El Sueldo a Pagar es de: $"+ objVendedor.CalcularBono());
entrada.close();
}
Ej11-Cree las clases necesarias para gestión de productos, cumpliendo los siguientes requisitos.
➔ Los productos tienen los siguientes atributos:
◆ Nombre
◆ Precio
➔ Tenemos dos tipos de productos:
◆ Perecedero: tiene un atributo llamado días a caducar.
◆ No perecedero: tiene un atributo llamado categoría.
➔ Tendremos una función llamada calcular, que según cada clase hará una cosa u otra, a esta función le
pasaremos un número siendo la cantidad de productos:
◆ En Producto, simplemente sería multiplicar el precio por la cantidad de productos pasados.
◆ En Perecedero, aparte de lo que hace producto, el precio se reducirá según los días a caducar:
● Si le queda 1 día para caducar, se reducirá 4 veces el precio final.
● Si le quedan 2 días para caducar, se reducirá 3 veces el precio final.
● Si le quedan 3 días para caducar, se reducirá a la mitad de su precio final.
◆ En NoPerecedero, hace lo mismo que en el producto.
➔ Sobreescribir el método toString() en cada producto para que muestre un resumen de la información.
Cree una clase ejecutable y crea un array de productos y muestra el precio total de vender 5 productos de cada uno.
Crea tú mismo los elementos del array.
https://youtu.be/pGPBaNxjeU0
public class Producto {
//Atributos
private String nombre;
private double precio;
//Constructores
public Producto(String nombre, double precio) {
this.precio = precio;
}
//Metodos
return nombre;
}

}
public double getPrecio() {

return precio;
}
public void setPrecio(double precio) {

this.precio = precio;
}
@Override
return "nombre=" + nombre + ", precio=" + precio +", ";
}
/**
* Indica el precio total segun una cantidad
* @param cantidad
* @return
*/
public double calcular(int cantidad){
return precio*cantidad;
}
public class Perecedero extends Producto {

//Atributos
private int dias_a_caducar;
//Constructores
public Perecedero(int dias_a_caducar, String nombre, double precio) {
super(nombre, precio);
this.dias_a_caducar = dias_a_caducar;
}
//Metodos
public int getDias_a_caducar() {
return dias_a_caducar;
}
public void setDias_a_caducar(int dias_a_caducar) {

this.dias_a_caducar = dias_a_caducar;
}
@Override
return super.toString() + " dias_a_caducar=" + dias_a_caducar;
}
/**
* Calcula el precio segun una cantidad,
* tambien segun los dias que le queden al prodcuto,
* se reducira el precio.
* <ul>
* <li>1: 4 veces menos</li>
* </ul>
* @param cantidad
* @return
*/
@Override
public double calcular(int cantidad) {
double precioFinal = super.calcular(cantidad);
switch (dias_a_caducar) {
case 1:
precioFinal /= 4;
break;
case 2:
precioFinal /= 3;
break;
case 3:
precioFinal /= 2;
break;
}
return precioFinal;
}
public class NoPerecedero extends Producto{
//Atributos
private String tipo;
//constructores
public NoPerecedero(String tipo, String nombre, double precio) {
super(nombre, precio);
this.tipo = tipo;
}
//Metodos
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {

this.tipo = tipo;
}
@Override
return super.toString() + " tipo=" + tipo + '}';
}
Clase Ejecutable
//Creo que array de productos

Producto[] productos = new Producto[3];
//Creo los elementos

productos[0] = new Producto("producto 1", 10);
productos[1] = new Perecedero(1, "producto 2", 20);
productos[2] = new NoPerecedero("tipo 1", "producto 3", 5);
//Calculo el precio
double total=0;
for(int i=0;i<productos.length;i++){
total += productos[i].calcular(5); //Polimorfismo
}
//Muestro el total
System.out.println("el total es "+total);
}
Ej12- Elaborar una clase y su respectiva implementación, que permita leer una frase u oración y que imprima si es un
palíndromo o no. Un palíndromo es una frase que se lee igual de izquierda a derecha que de derecha a izquierda .
Por ejemplo: RADAR se lee igual de izquierda a derecha que de derecha a izquierda.
public class Palindromo {

// atributos
private String frase;
private String fraseInvertida;
public String getFrase() {

return frase;
}
public void setFrase(String frase) {

this.frase = frase;
}
// constructor
Palindromo(String _frase) {
this.frase = _frase;
this.fraseInvertida = "";
}
public boolean esPalindromo() {

boolean resultado = false;
char caracter;
int contador;
for (contador = frase.length() - 1; contador >= 0; contador--) {
/*El método de charAt devuelve el carácter en el índice definido. En este método, el valor del índice
debe estar entre 0 y la longitud de la cadena menos 1*/
caracter = frase.charAt(contador);
/* método concat () se utiliza para especificar los parámetros de la cadena de conexión a la cadena.*/
fraseInvertida = fraseInvertida.concat(String.valueOf(caracter));
}
/* El método compareTo () se usa para realizar una ordenación natural en una cadena. Clasificación natural
significa el orden de clasificación que se aplica al objeto, por ejemplo, orden léxico para Cadena, orden numérico para
ordenar enteros, etc.
El orden léxico no es más que orden alfabético. compareTo methods hace una comparación secuencial de letras en la
cadena que tienen la misma posición. */
if (frase.compareTo(fraseInvertida) == 0) {
resultado = true;
}
return resultado;
}
}
Clase Ejecutable
public class Implementacion {

Scanner entrada = new Scanner(System.in);
String frase;
System.out.println("\nDADA UNA FRASE, DICE SI ES UN PALINDROMO");

System.out.println("ES DECIR, SE LEE IGUAL EN LOS DOS SENTIDOS\n");
System.out.println("------------ Lectura del dato ------------");

System.out.print("Teclee frase: ");
frase = entrada.nextLine();
Palindromo objPalindromo= new Palindromo(frase);
System.out.println("\n--------------- Resultado ----------------");
if(objPalindromo.esPalindromo()) {
System.out.println("Es un palindromo");}
else {
System.out.println("No es un palindromo");
}
entrada.close();
Ej13- Desarrolla una clase Cafetera con atributos _capacidadMaxima (la cantidad máxima de café que puede contener
la cafetera) y _cantidadActual (la cantidad actual de café que hay en la cafetera).
Implementa, al menos, los siguientes métodos:

● Constructor predeterminado: establece la capacidad máxima en 1000 (c.c.) y la actual en cero (cafetera vacía).
● Constructor con la capacidad máxima de la cafetera; inicializa la cantidad actual de café igual a la capacidad
máxima.
● Constructor con la capacidad máxima y la cantidad actual. Si la cantidad actual es mayor que la capacidad
máxima de la cafetera, la ajustará al máximo.
● Getters y Setters.
● llenarCafetera(): pues eso, hace que la cantidad actual sea igual a la capacidad.
● servirTaza(int): simula la acción de servir una taza con la capacidad indicada. Si la cantidad actual de café “no
alcanza” para llenar la taza, se sirve lo que quede.
● vaciarCafetera(): pone la cantidad de café actual en cero.
● agregarCafe(int): añade a la cafetera la cantidad de café indicada.
public class Cafetera {
//atributos
private int capacidadMaxima;
private int cantidadActual;
//constructores
public Cafetera() {
capacidadMaxima=1000;
cantidadActual=capacidadMaxima;
}
public Cafetera(int capacidadMaxima) {

this.capacidadMaxima = capacidadMaxima;
this.cantidadActual = capacidadMaxima;
}
// metodos get y set de los atributos

public int getCapacidadMaxima() {
return capacidadMaxima;
}
public void setCapacidadMaxima(int capacidadMaxima) {

this.capacidadMaxima = capacidadMaxima;
}
public int getCantidadActual() {

return cantidadActual;
}
public void setCantidadActual(int cantidadActual) {

this.cantidadActual = cantidadActual;
}
public void llenarCafetera() {

cantidadActual=capacidadMaxima;
}
public void servirTaza(int taza) {
if (taza>cantidadActual) {
taza=taza-cantidadActual;
cantidadActual=0;
}
else {
cantidadActual=cantidadActual-taza;
}
}
public void vaciarCafetera() {
cantidadActual=0;
}
public void agregarCafe(int Coffe) {
cantidadActual=cantidadActual+Coffe;
}
}
Clase Ejecutable
public class cafeteraOperaciones {
Scanner Entrada=new Scanner(System.in);

//se crea objeto de la clase cafetera
Cafetera cafe1=new Cafetera();
int pedidoCafe;
do {
System.out.println("Bienvenido \n ¿Que desea hacer? \n 1. Pedir Cafe \n 2. Llenar Cafetera \n 3. Vaciar
Cafetera \n 4. Agregar cafe" );
pedidoCafe=Entrada.nextInt();
switch(pedidoCafe) {
case 1:{
System.out.println("Bienvenido \n ¿Cuantos Cafes necesita?");
cafe1.servirTaza(pedidoCafe);
System.out.println("Cafe Actual "+ cafe1.getCantidadActual());
break;
}
case 2:{cafe1.llenarCafetera();
System.out.println("La cafetera ha sido llenada con exito, Cantidad Actual: "+cafe1.getCantidadActual());
break;
}
case 3: {cafe1.vaciarCafetera();
System.out.println("La cafetera ha sido vaciada con exito, Cantidad Actual: "+cafe1.getCantidadActual());
break;
}
case 4: {
System.out.println("Ingrese el valor en tazas a agregar Valor Actual: "+cafe1.getCantidadActual());
cafe1.agregarCafe(pedidoCafe);
System.out.println("Se agrego las tazas de cafe con exito, Cantidad Actual: "+cafe1.getCantidadActual());
break;
}
}
System.out.println("Proceso ejecutado con exito \n 1.Seguir \n 0. Salir");
}while(pedidoCafe!=0);
}
Ej14- Crea una clase llamada Libro que guarde la información de cada uno de los libros de una biblioteca. La clase debe
guardar el título del libro, autor, número de ejemplares del libro y número de ejemplares prestados.
La clase debe realizar las siguientes acciones:
● Préstamo: que incremente el atributo correspondiente cada vez que se realice un préstamo del libro. No se
podrán prestar libros de los que no queden ejemplares disponibles para prestar. Devuelve true si se ha podido
realizar la operación y false en caso contrario.
● Devolución: que disminuya el atributo correspondiente cuando se produzca la devolución de un libro. No se
podrán devolver libros que no se hayan prestado. Devuelve true si se ha podido realizar la operación y false en
caso contrario.
Pruebe la clase realizando las acciones correspondientes y muestre los atributos de un libro.
public class Libro {

private String titulo;
private String autor;
private int ejemplares;
private int prestados;
//constructor por defecto

public Libro() {
}
//constructor con parámetros

public Libro(String titulo, String autor, int ejemplares, int prestados) {
this.autor = autor;
this.ejemplares = ejemplares;
this.prestados = prestados;
}
//getters y setters
public String getAutor() {
return autor;
}
public void setAutor(String autor) {

this.autor = autor;
}
public int getEjemplares() {

return ejemplares;
}
public void setEjemplares(int ejemplares) {

this.ejemplares = ejemplares;
}
public int getPrestados() {

return prestados;
}
public void setPrestados(int prestados) {
this.prestados = prestados;
}
public String getTitulo() {

return titulo;
}
public void setTitulo(String titulo) {

}
//método para realizar el prestamo de un libro

public boolean prestamo() {
boolean prestado = true;
if (prestados < ejemplares) {
prestados++;
} else {
prestado = false;
}
return prestado;
}
//método para realizar la devolución de un libro

public boolean devolucion() {
boolean devuelto = true;
if (prestados == 0) {
devuelto = false;
} else {
prestados--;
}
return devuelto;
}
//método toString sobrescrito para mostrar los datos de la clase Libro

@Override
return "titulo: " + titulo + "\nautor: " + autor +
"\nejemplares: " + ejemplares + "\nprestados: " + prestados;
}
Clase Ejecutable
import java.util.*;

Scanner sc = new Scanner(System.in);
String titulo, autor;
int ejemplares;
//se crea el objeto libro1 utilizando el constructor con parámetros
Libro libro1 = new Libro("El quijote", "Cervantes", 1, 0);
//se crea el objeto libro2 utilizando el constructor por defecto
Libro libro2 = new Libro();
System.out.print("Introduce titulo: ");

titulo = sc.nextLine();
System.out.print("Introduce autor: ");
autor = sc.nextLine();
System.out.print("Numero de ejemplares: ");
ejemplares = sc.nextInt();
//se asigna a libro2 los datos pedidos por teclado.

//para ello se utilizan los métodos setters
libro2.setTitulo(titulo);
libro2.setAutor(autor);
libro2.setEjemplares(ejemplares);
//se muestran por pantalla los datos del objeto libro1

//se utilizan los métodos getters para acceder al valor de los atributos
System.out.println("Libro 1:");
System.out.println("Titulo: " + libro1.getTitulo());
System.out.println("Autor: " + libro1.getAutor());
System.out.println("Ejemplares: " + libro1.getEjemplares());
System.out.println("Prestados: " + libro1.getPrestados());
System.out.println();
//se realiza un préstamo de libro1. El método devuelve true si se ha podido

//realizar el préstamo y false en caso contrario
if (libro1.prestamo()) {
System.out.println("Se ha prestado el libro " + libro1.getTitulo());
} else {
System.out.println("No quedan ejemplares del libro " + libro1.getTitulo() + " para prestar");
}
//se realiza una devolución de libro1. El método devuelve true si se ha podido

//realizar la devolución y false en caso contrario
if (libro1.devolucion()) {
System.out.println("Se ha devuelto el libro " + libro1.getTitulo());
} else {
System.out.println("No hay ejemplares del libro " + libro1.getTitulo() + " prestados");
}
//se realiza otro préstamo de libro1

} else {
}
//se realiza otro préstamo de libro1. En este caso no se podrá realizar ya que
//solo hay un ejemplar de este libro y ya está prestado. Se mostrará por
//pantalla el mensaje No quedan ejemplares del libro…
} else {
}
//mostrar los datos del objeto libro1
//mostrar los datos del objeto libro2

Ej15- Realizar una agenda telefónica de contactos bajo las siguientes especificaciones:
● Un contacto está definido por un nombre y un teléfono (No es necesario de validar). Un contacto es igual a otro
cuando sus nombres son iguales.
● Una agenda de contactos está formada por un conjunto de contactos.
● Se podrá crear de dos formas, indicándose el tamaño o con un tamaño por defecto (10).
Las acciones de la agenda serán los siguientes:
● Añadir un contacto a la agenda(solicitando un objeto de tipo Contacto), si no se pueden meter más a la agenda se
indicará por pantalla. No se pueden meter contactos que existan, es decir, no podemos duplicar nombres,
aunque tengan distinto teléfono.
● Indicar si el contacto pasado existe o no (solicitando un objeto de tipo Contacto).
● Listar toda la agenda.
● Buscar un contacto por su nombre y mostrar su teléfono.
● Eliminar el contacto de la agenda, indicando si se ha eliminado o no (solicitando un objeto de tipo Contacto).
● Indicar si la agenda está llena.
● Indicar cuantos contactos más podemos meter.
Para su implementación y prueba deberá crear un menú de opciones por consola para probar todas las funcionalidades de
la agenda.
https://youtu.be/8EAxXhEmIlk
public class Contacto {

private int telefono;
public Contacto(String nombre, int telefono) {

this.telefono = telefono;
}
public Contacto(String nombre) {

this.telefono = 0;
}
return nombre;
}

}
public int getTelefono() {

return telefono;
}
public void setTelefono(int telefono) {

this.telefono = telefono;
}
public boolean equals(Contacto c){
if(this.nombre.trim().equalsIgnoreCase(c.getNombre().trim())){
return true;
}
return false;
@Override
return "nombre=" + nombre + ", telefono=" + telefono;
}
}
public class Agenda {
//Atributos
private Contacto[] contactos;
//Constructores
public Agenda() {
this.contactos = new Contacto[10]; //por defecto
}
public Agenda(int tamanio) {

this.contactos = new Contacto[tamanio]; //tamaño que nosotros queramos
}
//Metodos
/**
* Añade un contacto a la agenda
*
* @param c
*/
public void aniadirContacto(Contacto c) {
if (existeContacto(c)) { //Indico si existe el contacto

System.out.println("El contacto con ese nombre ya existe");
} else if (agendaLlena()) { //Indico si la agenda esta o no llena
System.out.println("La agenda esta llena, no se pueden meter mas contactos");
} else {
boolean encontrado = false;

for (int i = 0; i < contactos.length && !encontrado; i++) {
if (contactos[i] == null) { //controlo los nulos
contactos[i] = c; //Inserto el contacto
encontrado = true; //Indico que lo he encontrado
}
}
if (encontrado) {
System.out.println("Se ha añadido");
} else {
System.out.println("No se ha podido añadir");
}
}
/**
* Indica si existe un contacto
*
* @param c
* @return
*/
public boolean existeContacto(Contacto c) {
for (int i = 0; i < contactos.length; i++) {

//Controlo nulos e indico si el contacto es el mismo
if (contactos[i] != null && c.equals(contactos[i])) {
return true;
}
}
return false;
/**
* Lista los contactos de la agenda
*/
public void listarContactos() {
if (espacioLibre() == contactos.length) {
System.out.println("No hay contactos que mostrar");
} else {
if (contactos[i] != null) { //Controlo nulos
System.out.println(contactos[i]);
}
}
}
}
/**
* Busca un contacto por su nombre
*
* @param nombre
*/
public void buscarPorNombre(String nombre) {

if (contactos[i] != null && contactos[i].getNombre().trim().equalsIgnoreCase(nombre.trim())) {

System.out.println("Su telefono es " + contactos[i].getTelefono()); //muestro el telefono
}
}
if (!encontrado) {
System.out.println("No se ha encontrado el contacto");
}
/**
* Indica si la agenda esta llena o no
*
* @return
*/
public boolean agendaLlena() {

if (contactos[i] == null) { //Controlo nulos
return false; //indico que no esta llena
}
}
return true; //esta llena
/**
* Elimina el contacto de la agenda
*
* @param c
*/
public void eliminarContacto(Contacto c) {

if (contactos[i] != null && contactos[i].equals(c)) {
contactos[i] = null; //Controlo nulos
}
}
if (encontrado) {
System.out.println("Se ha eliminado el contacto");
} else {
System.out.println("No se ha eliminado el contacto");
/**
* Indica cuantos contactos más podemos meter
*
* @return
*/
public int espacioLibre() {
int contadorLibres = 0;
if (contactos[i] == null) { //Controlo nulos
contadorLibres++; //Acumulo
}
}
return contadorLibres;
import java.util.InputMismatchException;
Clase Ejecutable
Scanner sn = new Scanner(System.in);

boolean salir = false;
int opcion; //Guardaremos la opcion del usuario
Agenda agendaTelefonica = new Agenda(3);

String nombre;
int telefono;
Contacto c;
while (!salir) {
System.out.println("1. Añadir contacto");

System.out.println("2. Listar contactos");
System.out.println("3. Buscar contacto");
System.out.println("4. Existe contacto");
System.out.println("5. Eliminar contacto");
System.out.println("6. Contactos disponibles");
System.out.println("7. Agenda llena");
System.out.println("8. Salir");
try {
System.out.println("Escribe una de las opciones");
opcion = sn.nextInt();
switch (opcion) {
case 1:
//Pido valores
System.out.println("Escribe un nombre");
nombre = sn.next();
System.out.println("Escribe un telefono");
telefono = sn.nextInt();
//Creo el contacto
c = new Contacto(nombre, telefono);
agendaTelefonica.aniadirContacto(c);
break;
case 2:
agendaTelefonica.listarContactos();
break;
case 3:
//pido el nombre
nombre = sn.next();
agendaTelefonica.buscarPorNombre(nombre);
break;
case 4:
//pido el nombre
nombre = sn.next();
//Creo el contacto auxiliar

c = new Contacto(nombre, 0);
if (agendaTelefonica.existeContacto(c)) {
System.out.println("Existe contacto");
} else {
System.out.println("No existe contacto");
}
break;
case 5:
//pido el nombre
nombre = sn.next();
//Creo el contacto auxiliar

c = new Contacto(nombre, 0);
agendaTelefonica.eliminarContacto(c);
break;
case 6:
System.out.println("Hay " + agendaTelefonica.espacioLibre() + " contactos libre");
break;
case 7:
//como devuelve un booleano, lo meto en un if

if (agendaTelefonica.agendaLlena()) {
System.out.println("La agenda esta llena");
} else {
System.out.println("Aun puedes meter contactoss");
}
break;
case 8:
salir = true;
break;
default:
System.out.println("Solo números entre 1 y 8");
}
} catch (InputMismatchException e) {
System.out.println("Debes insertar un número");
sn.next();
}
Ej16- Cree un proyecto para gestión de empleados, los empleados deben tener como atributos, nombre, edad y salario,
además de una constante llamada BONO con un valor de 300.00. Se tendrán dos tipos de empleados:
● El comercial, aparte de los atributos anteriores, tiene uno más llamado comisión (double).
● El repartidor, aparte de los atributos de empleado, tiene otro llamado zona (String).
Deberá crear sus constructores, getters and setters. No se podrán crear objetos del tipo Empleado (la clase padre) pero sí
de sus hijas.
Las clases tendrán un método llamado bono, que según en cada clase tendrá una implementación distinta. Este bono
básicamente aumenta el salario del empleado.
En comercial, si tiene más de 30 años y cobra una comisión de más de 200, se le aplicará el bono.
En repartidor, si tiene menos de 25 y reparte en la “zona 3”, este recibirá el bono.
Puede hacer que devuelva un booleano o que no devuelva nada, lo dejo a tu elección.
Para probarlo, debe crear dos distintos empleados de cada tipo y ejecutar su método “bono”, mostrando el salario final de
ambos.
https://youtu.be/iDhF7kSjHL8
Clase Abstracta
public abstract class Empleado {
//Atributos
private int edad;
private double salario;
//Constantes
public final double BONO = 300;
//Constructores
public Empleado(String nombre, int edad, double salario) {
this.edad = edad;
this.salario = salario;
}
//Metodos
return nombre;
}

}
public int getEdad() {

return edad;
}
public void setEdad(int edad) {

this.edad = edad;
}
public double getSalario() {

return salario;
}
public void setSalario(double salario) {

this.salario = salario;
}
@Override
return "nombre=" + nombre + ", edad=" + edad + ", salario=" + salario + ", ";
}
//Metodo abstracto, obliga a las clases hijas que implementen esta función
public abstract boolean bono();
public class Comercial extends Empleado {
//Atributos
private double comision;
//Constructores
public Comercial(double comision, String nombre, int edad, double salario) {
super(nombre, edad, salario);
this.comision = comision;
}
//Metodos
public double getComision() {
return comision;
}
public void setComision(double comision) {

this.comision = comision;
}
/**
* Devuelve el estado del objeto, llama primero al toString de la clase
* padre
*
* @return
*/
@Override
return super.toString() + " comision=" + comision;
}
/**
* Si tiene mas de 30 años y la comision es mayor que 200, aumentamos el
* sueldo al empleado
*
* @return
*/
@Override
public boolean bono() {
if (super.getEdad() > 30 && this.comision > 200) {

//Con super. llamo a un metodo de la clase padre
double nuevoSalario = super.getSalario() + super.bono;
super.setSalario(nuevoSalario);
System.out.println("Se le añadido el bono, al empleado " + super.getNombre());
return true;
}
return false;
}
}
public class Repartidor extends Empleado {
//Atributos
private String zona;
//Constructores
public Repartidor(String zona, String nombre, int edad, double salario) {
super(nombre, edad, salario);
this.zona = zona;
}
//Metodos
public String getZona() {
return zona;
}
public void setZona(String zona) {

this.zona = zona;
}
@Override
return super.toString() + " zona=" + zona;
}
/**
* Si tiene menos de 25 años y la zona es "zona 3",
* aumentamos el sueldo al empleado
* @return
*/
@Override
public boolean bono() {
if (super.getEdad() < 25 && this.zona.equalsIgnoreCase("zona 3")) {

//Con super. llamo a un metodo de la clase padre
double nuevoSalario = super.getSalario() + super.bono;
super.setSalario(nuevoSalario);
System.out.println("Se le añadido el bono, al empleado "+super.getNombre());
return true;
}
return false;
}
Clase Ejecutable
//Creamos los objetos

Comercial c1 = new Comercial(300, "DDR", 37, 1000);
Repartidor r1 = new Repartidor("zona 3", "Fer", 26, 900);
//Llamamos a bono
c1.bono();
r1.bono();
//Mostramos la informacion
System.out.println(c1);
System.out.println(r1);
}
Ej17- Crear un proyecto que implemente una clase “CuentaBancaria” que tenga como atributos:
● saldoCuenta, de tipo double.

● nombreTitular, de tipo String.
● numeroCuenta, de tipo long.
y las siguientes funciones:
● Constructor que admite el nombre del titular y el saldo de la cuenta, para el número de la cuenta, se generará de
manera automática con el siguiente código:
● Se crearán dos getters, uno permitirá obtener el saldo (getSaldoCuenta) de la cuenta corriente y el otro obtendrá
los datos generales (getDatosCuenta) de una CCC.
● Se creará un método (RealizarTransferencia) para permitir realizar transferencias de dinero de una cuenta a otra
(de una CuentaBancaria a otra).
Para la implementación deberá crear dos cuentas bancarias y realizar una transferencia de una a otra, luego mostrar los
datos de ambas cuentas.
import java.text.DecimalFormat;
import java.util.Random;
public class CuentaBancaria {

private double saldoCuenta;
private String nombreTitular;
private long numeroCuenta;
public CuentaBancaria(String nombreTitular, double saldoCuenta)

{
this.saldoCuenta = saldoCuenta;
this.nombreTitular = nombreTitular;
Random numAleatorio = new Random();
this.numeroCuenta = Math.abs(numAleatorio.nextLong());
}
public void setIngreso (double ingreso)

{
if (ingreso <= 0)
System.out.println("El ingreso debe ser superior a cero euros");
else
saldoCuenta = saldoCuenta + ingreso;
}
public Double getSaldoCuenta ()
{
return saldoCuenta;
}
public ArrayList<String> getDatosCuenta ()

{
ArrayList<String> datosCuenta = new ArrayList<>();
datosCuenta.add("Titular: " + nombreTitular);
datosCuenta.add("Num. Cuenta: " + Long.toString(numeroCuenta));
//Redondeamos a dos decimales el saldo
DecimalFormat saldoRedondeado = new DecimalFormat("###.##");
datosCuenta.add("Saldo: $" + saldoRedondeado.format(saldoCuenta));
return datosCuenta;
}
public static void RealizarTransferencia(CuentaBancaria cuentaOrigen, CuentaBancaria cuentaDestino, double

importeTransferencia)
{
cuentaOrigen.saldoCuenta = cuentaOrigen.saldoCuenta - importeTransferencia;
cuentaDestino.saldoCuenta = cuentaDestino.saldoCuenta + importeTransferencia;
}
Clase Ejecutable
public class Banco {

Scanner lectura = new Scanner(System.in);
//Variables temporales para nombres de titulares y montos
String nombreTemp;
double montoTemp;
//Creamos la primera cuenta

System.out.println("Ingrese el nombre del titular:");
nombreTemp = lectura.nextLine();
System.out.println("Ingrese el monto de la cuenta:");
montoTemp = lectura.nextDouble();
CuentaBancaria c1 = new CuentaBancaria(nombreTemp, montoTemp);
//Creamos la segunda cuenta

System.out.println("Ingrese el nombre del titular:");
nombreTemp = lectura.nextLine();
System.out.println("Ingrese el monto de la cuenta:");
CuentaBancaria c2 = new CuentaBancaria(nombreTemp, montoTemp);
//Solicitamos el monto a transferir desde la cuenta 1 a la cuenta 2

System.out.println("Ingrese el monto a transferir desde la cuenta 1 a la cuenta 2:");
CuentaBancaria.RealizarTransferencia(c1, c2, montoTemp);
//mostramos las cuentas

System.out.println("Resumen de cuenta #1:");
for (String cc1 : c1.getDatosCuenta()) {
System.out.println(cc1);
}
ArrayList<String> datosCuenta2 = c2.getDatosCuenta();

System.out.println("Resumen de cuenta #2:");
for (int i = 0; i < datosCuenta2.size(); i++) {
System.out.println(datosCuenta2.get(i));
}
}
}

Guia de Trabajo POO

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia de Trabajo POO

Cargado por

Copyright:

Formatos disponibles

Guia de Trabajo POO-

public class Calculadora {

public class Main {

public static void main(String[] args) {

Scanner lectura = new Scanner(System.in);

// se manda a llamar el metodo o funcion operacion para realizar la operación solicitada

System.out.println("El resultado de la operación es " + resultado);

//clase padre o superclase

// métodos set y get para cada atributo

public class Circulo extends figuraGeometrica {

public void setDiametro(double diametro) {

public class Cuadrado extends figuraGeometrica{

// métodos set y get para cada atributo

public double getLado() {

public void setLado(double lado) {

public class Triangulo extends figuraGeometrica {

public void setLado(double lado) {

public class Main {

public static void main(String[] args) {

public class Notas {

// métodos set y get para cada atributo

public void setNota(double nota) {

// método que retornara un valor booleano falso o verdadero

public class Main {

public static void main(String[] args) {

int opcion, contadorAprobados, contadorReprobados;

System.out.println("Cantidad de examenes: " + examenes.size());

} while (opcion != 0);

public class Libro {

public Libro(int pISBN, String pTitulo, String pAutor, int pNumPaginas){

public int getISBN() {

public void setISBN(int ISBN) {

public String getTitulo() {

public void setTitulo(String titulo) {

public String getAutor() {

public void setAutor(String autor) {

public int getNumPaginas() {

public void setNumPaginas(int numPaginas) {

public class Main {

//Creamos los objetos

//Modificamos el atributo numPaginas del libro1

//Comparamos quien tiene mas paginas

obtenerRaices(): imprime las 2 posibles soluciones

public class Raices {

public static void main(String[] args) {

//Importamos la utilidad Arraylist para poder usarla

public class tarea {

//Declaramos el Arraylist que contendra los numeros aleatorios

//Declaramos un Array para almacenar los numeros mayores a 24.5

//Declaramos un número decimal aleatorio

private Double aleatorio;

//constructor de la Clase tarea

public tarea (){

this.lista = new ArrayList<Double> ();

this.filtro = new ArrayList<Double>();

//Creo un metodo para llenar los Arraylist

public void llenarlista ()

//agrego el número aleatorio a la lista

//uso el ciclo(for) y pregunto si alguno de los números generados es mayor a 24.5

System.out.println("Elemento del arreglo: " + it.next());

//imprimo la lista usando herencia(sobreescritura del método toString de la clase arrayList)

System.out.println ("******** Elementos mayores a 25.4**************");

//PARA sacar EL PROMEDIO/////

System.out.println (" Elementos mayores a 25.4******");