Ejercicio Básico POO Java

Ejercicio Básico POO Java.
Clase Cuenta
Escribe una clase Cuenta para representar una cuenta bancaria. Los datos de la cuenta
son: nombre del cliente (String), número de cuenta (String), tipo de interés (double) y
saldo (double).
La clase contendrá los siguientes métodos:
Constructor por defecto
Constructor con todos los parámetros
Constructor copia.
Métodos setters/getters para asignar y obtener los datos de la cuenta.
Métodos ingreso y reintegro. Un ingreso consiste en aumentar el saldo en la cantidad
que se indique. Esa cantidad no puede ser negativa. Un reintegro consiste en disminuir
el saldo en una cantidad pero antes se debe comprobar que hay saldo suficiente. La
cantidad no puede ser negativa. Los métodos ingreso y reintegro devuelven true si la
operación se ha podido realizar o false en caso contrario.
Método transferencia que permita pasar dinero de una cuenta a otra siempre que en la
cuenta de origen haya dinero suficiente para poder hacerla. Ejemplo de uso del método
transferencia:
cuentaOrigen.transferencia(cuentaDestino, importe);
que indica que queremos hacer una transferencia desde cuentaOrigen a cuentaDestino
del importe indicado.
Prueba el funcionamiento de la clase Cuenta con este main:
public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
String nombre, numero;
double tipo, importe;
//se crea objeto cuenta1 sin parámetros

//se ejecuta el constructor por defecto
Cuenta cuenta1 = new Cuenta();
System.out.print("Nombre : ");
nombre = sc.nextLine();
System.out.print("Número de cuenta : ");
numero = sc.nextLine();
System.out.print("Tipo de interes : ");
tipo = sc.nextDouble();
System.out.print("Saldo: ");
importe = sc.nextDouble();
cuenta1.setNombre(nombre);
cuenta1.setNumeroCuenta(numero);
cuenta1.setTipoInteres(tipo);
cuenta1.setSaldo(importe);
//se crea el objeto cuenta2 con los valores leidos por teclado
//se ejecuta el constructor con parámetros
Cuenta cuenta2 = new Cuenta("Juan Ferrández Rubio", "12345678901234567890", 1.75,
300);
//se crea cuenta3 como copia de cuenta1

//se ejecuta el constructor copia
Cuenta cuenta3 = new Cuenta(cuenta1);
//mostrar los datos de cuenta1

System.out.println("Datos de la cuenta 1");
System.out.println("Nombre del titular: " + cuenta1.getNombre());
System.out.println("Número de cuenta: " + cuenta1.getNumeroCuenta());
System.out.println("Tipo de interés: " + cuenta1.getTipoInteres());
System.out.println("Saldo: " + cuenta1.getSaldo());
System.out.println();

//se realiza un ingreso en cuenta1
cuenta1.ingreso(4000);

//mostrar el saldo de cuenta1 después del ingreso



//realizar una transferencia de 10€ desde cuenta3 a cuenta2
cuenta3.transferencia(cuenta2, 10);

//mostrar el saldo de cuenta2
System.out.println("Saldo de la cuenta 2");

//mostrar el saldo de cuenta3
System.out.println("Saldo de la cuenta 3");
}
Solución:
//Clase Cuenta
public class Cuenta {
private String nombre;

private String numeroCuenta;
private double tipoInteres;
private double saldo;
//Constructor por defecto

public Cuenta() {
}
//Constructor con parámetros

public Cuenta(String nombre, String numeroCuenta, double tipoInteres, double
saldo) {
this.nombre = nombre;
this.numeroCuenta = numeroCuenta;
this.tipoInteres = tipoInteres;
this.saldo = saldo;
}
//Constructor copia
public Cuenta(final Cuenta c) {
nombre = c.nombre;
numeroCuenta = c.numeroCuenta;
tipoInteres = c.tipoInteres;
saldo = c.saldo;
}
//getters y setters
public void setNombre(String s) {
nombre = s;
}
public void setNumeroCuenta(String s) {

numeroCuenta = s;
}
public void setTipoInteres(double n) {

tipoInteres = n;
}
public void setSaldo(double n) {

saldo = n;
}
public String getNombre() {

return nombre;
}
public String getNumeroCuenta() {

return numeroCuenta;
}
public double getTipoInteres() {

return tipoInteres;
}
public double getSaldo() {
return saldo;
}
//método ingreso
public boolean ingreso(double n) {
boolean ingresoCorrecto = true;
if (n < 0) {
ingresoCorrecto = false;
} else {
saldo = saldo + n;
}
return ingresoCorrecto;
}
//método reintegro
public boolean reintegro(double n) {
boolean reintegroCorrecto = true;
if (n < 0) {
reintegroCorrecto = false;
} else if (saldo >= n) {
saldo -= n;
} else {
reintegroCorrecto = false;
}
return reintegroCorrecto;
}
//método transferencia
public boolean transferencia(Cuenta c, double n) {
boolean correcto = true;
if (n < 0) {
correcto = false;
} else if (saldo >= n) {
reintegro(n);
c.ingreso(n);
} else {
correcto = false;
}
return correcto;
}
}
Ejercicio Básico POO. Clase Contador
Crea una clase llamada Contador que contenga un único atributo entero llamado cont.
La clase tendrá los siguientes constructores:
Constructor por defecto
Constructor con parámetros para inicializar el contador con un valor no negativo. Si el
valor inicial que se recibe es negativo el contador tomará el valor cero como valor
inicial.
Constructor copia.
Además de los métodos getter y setter, la clase contendrá los métodos:
incrementar: incrementa el contador en una unidad.
decrementar: decrementa el contador en una unidad. El contador nunca podrá tener
un valor negativo. Si al decrementar se alcanza un valor negativo el contador toma el
valor cero.
Una vez creada la clase, escribe un método main para probar la clase.
Solución:
//Ejercicio Básico Programación Orientada a Objetos Java
//Clase Contador
public class Contador {
private int cont;
//constructor por defecto

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

public Contador(int cont) {
if (cont < 0) {
this.cont = 0;
} else {
this.cont = cont;
}
}
//constructor copia
public Contador(final Contador c) {
cont = c.cont;
}
//getter
public int getCont() {
return cont;
}
//setter
public void setCont(int cont) {
if (cont < 0) {
this.cont = 0;
} else {
this.cont = cont;
}
}
//método incrementar contador

public void incrementar() {
cont++;
}
//método decrementar contador

public void decrementar() {
cont--;
if (cont < 0) {
cont = 0;
}
}
}
Un método main para probar la clase puede ser este:



//Utilizar el constructor por defecto
Contador contador1 = new Contador();

int n;
System.out.println("Introduce valor para inicializar el contador: ");
n = sc.nextInt();

//asignar un valor al contador
contador1.setCont(n);
//incrementar el contador
contador1.incrementar();
//mostrar el valor actual
System.out.println(contador1.getCont());



//restar 1 al valor del contador
contador1.decrementar();

//crear un nuevo objeto Contador con valor inicial 10

Contador contador2 = new Contador(10);

//incrementar y decrementar el contador2 y mostrar su valor
contador2.decrementar();
//crear un objeto Contador utilizando el constructor copia

//se crea el objeto contador3 como copia de contador2
Contador contador3 = new Contador(contador2);
//mostrar el valor de contador3

}
Ejercicios Básicos de Programación Orientada a
Objetos Java. Clase Libro
EJERCICIOS BÁSICOS RESUELTOS POO JAVA
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 contendrá los siguientes
métodos:
Constructor por defecto.
Constructor con parámetros.
Métodos Setters/getters
Método 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.
Método devolución que decremente 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.
Método toString para mostrar los datos de los libros. Este método se heredada de

Object y lo debemos modificar (override) para adaptarlo a la clase Libro.
Escribe un programa para probar el funcionamiento de la clase Libro.
public class Libro {
private String titulo;
private String autor;
private int ejemplares;
private int prestados;
public Libro() {
}
//constructor con parámetros
public Libro(String titulo, String autor, int ejemplares, int prestados) {
this.titulo = titulo;
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) {
this.titulo = 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
public String toString() {
return "titulo: " + titulo + "\nautor: " + autor +
"\nejemplares: " + ejemplares + "\nprestados: " + prestados;
}

Un programa para probar la clase Libro puede ser este:
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());
//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 {
para prestar");
}
//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 {

para prestar");
}
//mostrar los datos del objeto libro1
//mostrar los datos del objeto libro2
}
Ejercicio Básico Programación Orientada a Objetos
Java. Clase Fraccion
Escribe una clase para representar fracciones. La clase tendrá dos atributos de tipo int:
num (numerador) y den (denominador). La clase debe contener los constructores y
métodos adecuados para que este método main funcione de forma correcta:
// Se crean 4 fracciones
Fraccion f1 = new Fraccion(1, 4); // Fracción 1/4
Fraccion f3 = new Fraccion(); // Fracción 0/1
Fraccion f4 = new Fraccion(4); // Fracción 4/1
// operaciones aritméticas con esas fracciones
Fraccion suma = f1.sumar(f2);
Fraccion resta = f1.restar(f3);
Fraccion producto = f1.multiplicar(f4);
Fraccion cociente = f1.dividir(f2);
//mostrar resultados
System.out.println(f1 + " + " + f2 + " = " + suma);
System.out.println(f1 + " - " + f3 + " = " + resta);
System.out.println(f1 + " * " + f4 + " = " + producto);
System.out.println(f1 + " / " + f2 + " = " + cociente);
}
La ejecución del método main debe mostar por pantalla lo siguiente:
1/4 + 1/2 = 3/4
1/4 - 0/1 = 1/4
1/4 * 4/1 = 1/1
1/4 / 1/2 = 1/2
Las fracciones se deben mostrar siempre simplificadas. Para ello la clase Fraccion debe
contener un método privado simplificar() que actuará de la siguiente forma:
Para simplificar una fracción primero hay que hallar el máximo común divisor del
numerador y del denominador. Una vez hallado se divide el numerador y el
denominador por este número. Para calcular el máximo común divisor podemos usar
este método mcd que calcula y devuelve el máximo común divisor del numerador y del
denominador utilizando el método de Euclides
//Cálculo del máximo común divisor
private int mcd(){
int u=Math.abs(num);
int v=Math.abs(den);
if(v==0){
return u;
}
int r;
while(v!=0){
r=u%v;
u=v;
v=r;
}
return u;
}
Solución: Vamos a estudiar el código del método main y a continuación escribiremos
los métodos necesarios en Clase Fracción.
1. Para poder crear los objetos f1 y f2:
la clase Fracción debe tener un constructor con dos parámetros, el primer parámetro
es el valor del numerador y el segundo el del denominador. Debemos controlar que el
denominador de la fracción no sea cero. Si el valor del segundo parámetro es cero, es
decir, si se crean objetos de esta forma:
Fraccion f = new Fraccion(3, 0);
en el constructor se asignará el valor 1 la denominador.
//constructor de la clase con dos parámetros
public Fraccion(int num, int den) {
this.num = num;
if(den==0){
den = 1;
}
this.den = den;
simplificar();
}
El constructor llama al método simplificar.
2. Para poder crear objetos como el f3:
Fraccion f3 = new Fraccion(); // Fracción 0/1
La clase Fraccion tendrá un constructor por defecto (sin parámetros), que asigne el
valor 0 al numerador y el valor 1 al denominador.
public Fraccion() {
this.num = 0;
this.den = 1;
}
3. Para crear objetos como el f4:
Fraccion f4 = new Fraccion(4); // Fracción 4/1
La clase deberá tener un tecer constructor con un solo parámetro. El valor del
parámetro es el valor de numerador de la fracción. El valor del denominador será 1.
//constructor con un parámetro
public Fraccion(int num) {
this.num = num;
this.den = 1;
}
4. Operaciones con fracciones.
Para realizar las operaciones aritméticas:
Fraccion suma = f1.sumar(f2);
Fraccion resta = f1.restar(f3);
Fraccion producto = f1.multiplicar(f4);
Fraccion cociente = f1.dividir(f2);
la clase Fraccion tendrá un método para cada una de ellas. Estos métodos reciben un
objeto Fracción que será la que se opere con la fracción que llama al método. Se
devuelve el objeto Fracción resultante de la operación.
El método sumar puede ser éste:
//sumar fracciones
public Fraccion sumar(Fraccion f) {
Fraccion aux = new Fraccion(); //fracción para guardar la suma
aux.num = this.num * f.den + this.den * f.num;
aux.den = this.den * f.den;
aux.simplificar(); //se simplifica antes de devolverla
return aux;
}
Después de cada operación se simplifica la fracción resultante. El resto de métodos
para realizar las otras operaciones aritméticas son similares a éste.
5. Para que una instrucción println como esta:
System.out.println(f1 + " + " + f2 + " = " + suma);
Muestre por pantalla:
1/4 + 1/2 = 3/4
La clase debe tener un método toString() que devuelva un String con el contenido de
la fracción de la forma: numerador/denominador
//método toString
@Override
simplificar();
return num + "/" + den;
}
Solo faltan por añadir los métodos get y set para acceder a los atributos de la clase y
el método simplificar que a su vez llama al método mcd.
//Clase Fracción
public class Fraccion {
private int num;

private int den;
public Fraccion() {
this.num = 0;
this.den = 1;
}
public Fraccion(int num, int den) {

this.num = num;
if(den==0){
den = 1;
}
this.den = den;
simplificar();
}
public Fraccion(int num) {

this.num = num;
this.den = 1;
}
public int getDen() {

return den;
}
public void setDen(int den) {

this.den = den;
}
public int getNum() {
return num;
}
public void setNum(int num) {

this.num = num;
}
//sumar fracciones
public Fraccion sumar(Fraccion f) {
Fraccion aux = new Fraccion();
aux.num = this.num * f.den + this.den * f.num;
return aux;
}

//restar fracciones
public Fraccion restar(Fraccion f) {
aux.num = this.num * f.den - this.den * f.num;
return aux;
}

//multiplicar fracciones
public Fraccion multiplicar(Fraccion f) {
aux.num = this.num * f.num;
return aux;
}
//dividir fracciones
public Fraccion dividir(Fraccion f) {
aux.num = this.num * f.den;
aux.den = this.den * f.num;
return aux;
}

//Cálculo del máximo común divisor por el algoritmo de Euclides
private int mcd() {
int u = Math.abs(num); //valor absoluto del numerador
int v = Math.abs(den); //valor absoluto del denominador
if (v == 0) {
return u;
}
int r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
//método para simplificar fracciones

private void simplificar() {
int n = mcd(); //se calcula el mcd de la fracción
num = num / n;
den = den / n;
}
@Override
simplificar();
return num + "/" + den;
}
} //Fin de la clase Fraccion
Java Ejercicios POO Resueltos. Clase Complejo
Escribe una clase Complejo que modele el comportamiento de los números complejos.
Un número complejo, es una entidad matemática que viene dada por un par de
números reales, el primero a se denomina la parte real y al segundo b la parte
imaginaria.
Se representa escribiendo las dos partes del número entre paréntesis (a, b) o también
de la forma a + bi.
La i se denomina unidad imaginaria, representa la raíz cuadrada de -1.
La clase Complejo tendrá dos datos privados de tipo double: parte real y parte
imaginaria.
La clase Complejo contendrá un constructor por defecto que inicializará a 0 los
atributos y un constructor con dos parámetros correspondientes a los valores de la
parte real e imaginaria a asignar al nuevo objeto.
Contendrá, además de los setters y getters, los siguientes métodos:
sumar para sumar dos números complejos.
(a, b) + (c, d) = (a + c, b + d);
restar para restar dos números complejos.
(a, b) - (c, d) = (a - c, b - d);
multiplicar para multiplicar dos números complejos:
(a, b) * (c, d) = (a*c – b*d, a*d + b*c)
multiplicar para multiplicar un número complejo por un número double:
(a, b) * n = (a * n, b * n)
dividir para dividir dos números complejos:
(a, b) / (c, d) = ((a*c + b*d) / (c2 + d2) , (b*c – a*d) / (c2 + d2))
Todos los métodos anteriores devuelven el objeto número complejo resultado de la
operación.
La clase contendrá además un método toString para mostrar el número complejo de
la siguiente forma: (parte real, parte imaginaria) y un método equals que compruebe
si dos números complejos son iguales o no.
Una vez creada la clase, escribe un programa para probar la clase. Un ejemplo de main
podría ser este:

// declaración de números complejos
Complejo c1 = new Complejo(1.0, 1.0);
Complejo c3;
// operadores aritméticos
c3 = c1.sumar(c2);
System.out.println(c1 + " + " + c2 + " = " + c3);
c3 = c1.restar(c2);
System.out.println(c1 + " - " + c2 + " = " + c3);
c3 = c1.dividir(c2);
System.out.println(c1 + " / " + c2 + " = " + c3);
c3 = c1.multiplicar(c2);
System.out.println(c1 + " * " + c2 + " = " + c3);
c3 = c1.multiplicar(3.5);
System.out.println(c1 + " * 3.5 = " + c3);
if (c2.equals(c3)) {
System.out.println(c2 + " igual que " + c3);
} else {
System.out.println(c2 + " distinto que " + c3);
}
}
Si la clase Complejo está bien diseñada, este programa debe mostrar el siguiente
resultado por pantalla:
(1.0, 1.0) + (2.0, 2.0) = (3.0, 3.0)

(1.0, 1.0) - (2.0, 2.0) = (-1.0, -1.0)
(1.0, 1.0) / (2.0, 2.0) = (0.5, 0.0)
(1.0, 1.0) * (2.0, 2.0) = (0.0, 4.0)
(1.0, 1.0) * 3.5 = (3.5, 3.5)
(2.0, 2.0) distinto que (3.5, 3.5)
Solución: A continuación se muestra la clase Complejo
public class Complejo {

private double real;
private double imag;

//Constructor por defecto de la clase
public Complejo() {

}
public Complejo(double real, double imag) {
this.real = real;
this.imag = imag;
}
//métodos setters y getters

public double getImag() {
return imag;
}
public void setImag(double imag) {

this.imag = imag;
}
public double getReal() {

return real;
}
public void setReal(double real) {

this.real = real;
}

//sumar dos números complejos
//(a, b) + (c, d) = (a + c, b + d);
public Complejo sumar(Complejo c){
Complejo aux = new Complejo();
aux.real = real + c.real;
aux.imag = imag + c.imag;
return aux;
}

//restar dos números complejos
//(a, b) - (c, d) = (a - c, b - d);
public Complejo restar(Complejo c){
aux.real = real - c.real;
aux.imag = imag - c.imag;
return aux;
}

//multiplicar dos números complejos
//(a, b) * (c, d) = (a*c – b*d, a*d + b*c)
public Complejo multiplicar(Complejo c){
aux.real = real * c.real - imag * c.imag;
aux.imag = real * c.imag + imag * c.real;
return aux;
}

//multiplicar un número complejo por un número de tipo double
//(a, b) * n = (a * n, b * n)
public Complejo multiplicar(double n){
aux.real = real * n;
aux.imag = imag * n;
return aux;
}

//dividir dos números complejos
//(a, b) / (c, d) = ((a*c + b*d) / (c^2 + d^2) , (b*c – a*d) / (c^2 + d^2))
public Complejo dividir(Complejo c){
aux.real = (real * c.real + imag * c.imag)/(c.real * c.real + c.imag * c.imag);
aux.imag = (imag * c.real - real * c.imag)/(c.real * c.real + c.imag * c.imag);
return aux;
}
//método toString
@Override
return "(" + real + ", " + imag + ")";
}
//método equals
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Complejo other = (Complejo) obj;
if (this.real != other.real) {
return false;
}
if (this.imag != other.imag) {
return false;
}
return true;
}
} //Fin de la Clase Complejo Java
Clase Fecha en Java
Crear una Clase Fecha en Java. La clase tendrá tres atributos privados dia, mes y año
de tipo int. La clase contendrá los siguientes métodos:
Constructor por defecto.
Constructor con tres parámetros para crear objetos con valores iniciales.
Métodos set y get para asignar y obtener los valores de los atributos de la clase.
Método fechaCorrecta() que comprueba si la fecha es correcta. Devuelve un valor de
tipo boolean indicando si la fecha es correcta o no. Este método a su vez utilizará un
método privado de la clase llamado esBisiesto que calcula si el año es o no bisiesto. El
método esBisiesto devuelve true si el año es bisiesto y false si no lo es.
Método diaSiguiente() que cambia la fecha actual por la del día siguiente. El objeto de
la clase Fecha al que se le aplique este método deberá quedar siempre en un estado
consistente, es decir, la nueva fecha deberá ser correcta.
Modificar el método toString() heredado de Object para mostrar las fechas de la forma
dd-mm-aaaa. El día y el mes se deben mostrar con dos cifras. Si el dia o el mes tienen
solo una cifra se escribirá un cero delante. Por ejemplo si la fecha es dia=1, mes=6,
año= 2015 la fecha que se mostrará será: 01-06-2015
Escribe un programa para probar la clase Fecha. El método diaSiguiete() pruébalo
dentro de un bucle que imprima la fecha durante cada iteración del bucle.
Solución:
//Clase Fecha Java
public class Fecha {
private int dia;

private int mes;
private int año;

public Fecha() {
}

public Fecha(int dia, int mes, int año) {
this.dia = dia;
this.mes = mes;
this.año = año;
}
//setters y getters
public void setDia(int d) {
dia = d;
}
public void setMes(int m) {
mes = m;
}
public void setAño(int a) {
año = a;
}
public int getDia() {
return dia;
}
public int getMes() {
return mes;
}
public int getAño() {
return año;
}
//Método para comprobar si la fecha es correcta

public boolean fechaCorrecta() {
boolean diaCorrecto, mesCorrecto, añoCorrecto;
añoCorrecto = año > 0;
mesCorrecto = mes >= 1 && mes <= 12;
switch (mes) {
case 2:
if (esBisiesto()) {
diaCorrecto = dia >= 1 && dia <= 29;
} else {
}
break;
case 4:
case 6:
case 9:
case 11:
break;
default:
}
return diaCorrecto && mesCorrecto && añoCorrecto;
}
//Método privado para comprobar si el año es bisiesto

//Este método lo utiliza el método fechaCorrecta
private boolean esBisiesto() {
return (año % 4 == 0 && año % 100 != 0 || año % 400 == 0);
}
//Método que modifica la fecha cambiándola por la del día siguiente

public void diaSiguiente() {
dia++;
if (!fechaCorrecta()) {
dia = 1;
mes++;
if (!fechaCorrecta()) {
mes = 1;
año++;
}
}
}
//Método toString para mostrar la fecha
@Override
StringBuilder sb = new StringBuilder();
if (dia < 10) {
sb.append("0");
}
sb.append(dia);
sb.append("-");
if (mes < 10) {
sb.append("0");
}
sb.append(mes);
sb.append("-");
sb.append(año);
return sb.toString();
}
} //Fin de la clase Fecha
Un programa para probar la clase Fecha podría ser este:

public class ProyectoFecha {

int d, m, a;
//Se pide por teclado el dia, mes y año

System.out.println("Introduce fecha: ");
System.out.print("dia: ");
d = sc.nextInt();
System.out.print("mes: ");
m = sc.nextInt();
System.out.print("año: ");
a = sc.nextInt();
//Se crea un objeto Fecha utilizando el consructor con parámetros

Fecha fecha = new Fecha(d,m,a);
if (fecha.fechaCorrecta()) { //si la fecha es correcta
//Se muestra utilizando el método toString()

System.out.println("Fecha introducida: " + fecha);
//Se muestran los 10 días siguientes utilizando el método diaSiguiente()

System.out.println("Los 10 días siguientes son:");
for (int i = 1; i <= 10; i++) {
fecha.diaSiguiente();
System.out.println(fecha);
}
} else { //Si la fecha no es correcta

System.out.println("Fecha no valida");
}
}
}
Ejemplo de ejecución del programa:
Introduce fecha:
dia: 28
mes: 12
año: 2015
Fecha introducida: 28-12-2015
Los 10 días siguientes son:
29-12-2015
30-12-2015
31-12-2015
01-01-2016
02-01-2016
03-01-2016
04-01-2016
05-01-2016
06-01-2016
07-01-2016
Java Ejercicios POO Resueltos. Clase Complejo
Escribe una clase Complejo que modele el comportamiento de los números complejos.
Un número complejo, es una entidad matemática que viene dada por un par de
números reales, el primero a se denomina la parte real y al segundo b la parte
imaginaria.
Se representa escribiendo las dos partes del número entre paréntesis (a, b) o también
de la forma a + bi.
La i se denomina unidad imaginaria, representa la raíz cuadrada de -1.
La clase Complejo tendrá dos datos privados de tipo double: parte real y parte
imaginaria.
La clase Complejo contendrá un constructor por defecto que inicializará a 0 los
atributos y un constructor con dos parámetros correspondientes a los valores de la
parte real e imaginaria a asignar al nuevo objeto.
Contendrá, además de los setters y getters, los siguientes métodos:
sumar para sumar dos números complejos.
(a, b) + (c, d) = (a + c, b + d);
restar para restar dos números complejos.
(a, b) - (c, d) = (a - c, b - d);
multiplicar para multiplicar dos números complejos:
(a, b) * (c, d) = (a*c – b*d, a*d + b*c)
multiplicar para multiplicar un número complejo por un número double:
(a, b) * n = (a * n, b * n)
dividir para dividir dos números complejos:
(a, b) / (c, d) = ((a*c + b*d) / (c2 + d2) , (b*c – a*d) / (c2 + d2))
Todos los métodos anteriores devuelven el objeto número complejo resultado de la
operación.
La clase contendrá además un método toString para mostrar el número complejo de
la siguiente forma: (parte real, parte imaginaria) y un método equals que compruebe
si dos números complejos son iguales o no.
Una vez creada la clase, escribe un programa para probar la clase. Un ejemplo de main
podría ser este:

// declaración de números complejos
Complejo c3;
// operadores aritméticos
c3 = c1.sumar(c2);
System.out.println(c1 + " + " + c2 + " = " + c3);
c3 = c1.restar(c2);
System.out.println(c1 + " - " + c2 + " = " + c3);
c3 = c1.dividir(c2);
System.out.println(c1 + " / " + c2 + " = " + c3);
c3 = c1.multiplicar(c2);
System.out.println(c1 + " * " + c2 + " = " + c3);
c3 = c1.multiplicar(3.5);
System.out.println(c1 + " * 3.5 = " + c3);
if (c2.equals(c3)) {
System.out.println(c2 + " igual que " + c3);
} else {
System.out.println(c2 + " distinto que " + c3);
}
}
Si la clase Complejo está bien diseñada, este programa debe mostrar el siguiente
resultado por pantalla:
(1.0, 1.0) + (2.0, 2.0) = (3.0, 3.0)

(1.0, 1.0) - (2.0, 2.0) = (-1.0, -1.0)
(1.0, 1.0) / (2.0, 2.0) = (0.5, 0.0)
(1.0, 1.0) * (2.0, 2.0) = (0.0, 4.0)
(1.0, 1.0) * 3.5 = (3.5, 3.5)
(2.0, 2.0) distinto que (3.5, 3.5)
Solución: A continuación se muestra la clase Complejo
public class Complejo {

private double real;
private double imag;

//Constructor por defecto de la clase
public Complejo() {

}
public Complejo(double real, double imag) {
this.real = real;
this.imag = imag;
}
//métodos setters y getters

public double getImag() {
return imag;
}
public void setImag(double imag) {

this.imag = imag;
}
public double getReal() {

return real;
}
public void setReal(double real) {

this.real = real;
}

//sumar dos números complejos
//(a, b) + (c, d) = (a + c, b + d);
public Complejo sumar(Complejo c){
aux.real = real + c.real;
aux.imag = imag + c.imag;
return aux;
}

//restar dos números complejos
//(a, b) - (c, d) = (a - c, b - d);
public Complejo restar(Complejo c){
aux.real = real - c.real;
aux.imag = imag - c.imag;
return aux;
}

//multiplicar dos números complejos
//(a, b) * (c, d) = (a*c – b*d, a*d + b*c)
public Complejo multiplicar(Complejo c){
aux.real = real * c.real - imag * c.imag;
aux.imag = real * c.imag + imag * c.real;
return aux;
}

//multiplicar un número complejo por un número de tipo double
//(a, b) * n = (a * n, b * n)
public Complejo multiplicar(double n){
aux.real = real * n;
aux.imag = imag * n;
return aux;
}

//dividir dos números complejos
//(a, b) / (c, d) = ((a*c + b*d) / (c^2 + d^2) , (b*c – a*d) / (c^2 + d^2))
public Complejo dividir(Complejo c){
aux.real = (real * c.real + imag * c.imag)/(c.real * c.real + c.imag * c.imag);
aux.imag = (imag * c.real - real * c.imag)/(c.real * c.real + c.imag * c.imag);
return aux;
}
//método toString
@Override
return "(" + real + ", " + imag + ")";
}
//método equals
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Complejo other = (Complejo) obj;
if (this.real != other.real) {
return false;
}
if (this.imag != other.imag) {
return false;
}
return true;
}
} //Fin de la Clase Complejo Java
Ejemplo de Clase Java con un atributo static o
atributo de clase: Clase Empleado
Crea una clase Empleado que tenga los siguientes atributos privados:
Nif.
Nombre.
Sueldo base.
Horas extra realizadas en el mes.
Tipo de IRPF (%).
Casado o no.
Número de hijos.
Importe de la hora extra. Este será un atributo static o atributo de clase.
Los objetos Empleado se podrán crear con un constructor por defecto o con un
constructor con un solo parámetro correspondiente al DNI.
Además de los métodos getter/setter la clase Empleado tendrá estos métodos:
Método para el cálculo del complemento correspondiente a las horas extra realizadas.
Método para calcular el sueldo bruto (sueldo base + complemento por horas extras)
Método para calcular las retenciones por IRPF. El porcentaje de IRPF se aplica sobre el
sueldo bruto, teniendo en cuenta que el porcentaje que hay que aplicar es el tipo
menos 2 puntos si el empleado está casado y menos 1 punto adicional por cada hijo
que tenga.
Método toString() para mostrar los datos de los empleados de la siguiente forma:
12345678A Lucas Guerrero Arjona
Sueldo Base: 1150.0
Horas Extras: 4
tipo IRPF: 15.0
Casado: S
Número de Hijos: 2
Una vez creada la clase Empleado, la utilizaremos en un programa que lea empleados
y los guarde en un array estático. El número total de empleados se pide por teclado. El
número máximo de empleados es de 20.
Después de leer los datos de los empleados se pedirá que se introduzca el importe
correspondiente al pago por hora extra asignándoselo al atributo estático de la clase.
A continuación el programa mostrará:
- El empleado que más cobra y el que menos
- El empleado que cobra más por horas extra y el que menos.
- Todos los empleados ordenados por salario de menor a mayor.
Solución:
//Clase Empleado
public class Empleado {

private static double pagoPorHoraExtra; //atributo de clase
private String nif;
private String nombre;
private double sueldoBase;
private int horasExtras;
private double tipoIRPF;
private char casado; //S ó N
private int numeroHijos;

public Empleado() {
}
//Constructor con un parámetro

public Empleado(String nif) {
this.nif = nif;
}
//Métodos get/set
public char getCasado() {
return casado;
}
public void setCasado(char casado) {

this.casado = casado;
}
public int getHorasExtras() {

return horasExtras;
}
public void setHorasExtras(int horasExtras) {

this.horasExtras = horasExtras;
}
public String getNif() {

return nif;
}
public void setNif(String nif) {

this.nif = nif;
}
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

this.nombre = nombre;
}
public int getNumeroHijos() {

return numeroHijos;
}
public void setNumeroHijos(int numeroHijos) {

this.numeroHijos = numeroHijos;
}
public double getSueldoBase() {

return sueldoBase;
}
public void setSueldoBase(double sueldoBase) {

this.sueldoBase = sueldoBase;
}
public double getTipoIRPF() {

return tipoIRPF;
}
public void setTipoIRPF(double tipoIRPF) {

this.tipoIRPF = tipoIRPF;
}
//métodos get/set para el atributo static

public static double getPagoPorHoraExtra() {
return pagoPorHoraExtra;
}
public static void setPagoPorHoraExtra(double pagoPorHoraExtra) {

Empleado.pagoPorHoraExtra = pagoPorHoraExtra;
}

//calcular el importe de las horas extra
public double calcularImporteHorasExtras(){
return horasExtras * pagoPorHoraExtra;
}

//calcular el sueldo bruto
public double calcularSueldoBruto(){
return sueldoBase + calcularImporteHorasExtras();
}

//calcular el importe de las retencion por IRPF
public double calcularRetencionIrpf(){
double tipo = tipoIRPF;
if(casado == 's' || casado == 'S') {
tipo = tipo - 2; //2 puntos menos si está casado
}
tipo = tipo - numeroHijos; //un punto menos por cada hijo
if(tipo<0){
tipo = 0;
}
return calcularSueldoBruto() * tipo / 100;
}

//calcular el importe liquido a cobrar
public double calcularSueldo(){
return calcularSueldoBruto() - calcularRetencionIrpf();
}
//mostrar los datos de un trabajador

@Override
sb.append("\nNif: ");
sb.append(nif);
sb.append("\nSueldo Base: ");
sb.append(sueldoBase);
sb.append("\nHoras Extras: ");
sb.append(horasExtras);
sb.append("\ntipo IRPF: ");
sb.append(tipoIRPF);
sb.append("\nCasado: ");
sb.append(casado);
sb.append("\nNúmero de Hijos: ");
sb.append(numeroHijos);
}
}//Fin de la Clase Empleado
//Clase Principal
import java.io.IOException;
import java.util.Scanner;
public class ProyectoEmpleados {
final static int MAXIMO_EMPLEADOS = 20;

static Empleado[] empleados = new Empleado[MAXIMO_EMPLEADOS];
static int indice = 0;
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) throws IOException {
double importe;
Empleado e;
leerEmpleados();
if (numeroDeEmpleados() > 0) {
//mostrar empleados
System.out.println("\n\nEmpleados introducidos: ");
mostrar();
importe = leerImporteHorasExtras();
//asignar el atributo estático pagoPorHoraExtra

Empleado.setPagoPorHoraExtra(importe);
//calcular el empleado que más cobra

e = empleadoQueMasCobra();
System.out.println("\n\nEmpleado que más cobra:");
System.out.println(e);
System.out.printf("Sueldo: %.2f € %n", e.calcularSueldo());
//calcular el empleado que menos cobra
e = empleadoQueMenosCobra();
System.out.println("\n\nEmpleado que menos cobra:");
System.out.printf("Sueldo: %.2f € %n", e.calcularSueldo());
//calcular el empleado que más cobra por horas extra

e = empleadoQueMasCobraPorHorasExtras();
System.out.println("\n\nEmpleado que más cobra por horas extras:");
System.out.printf("Total horas extras: %.2f €" ,
e.calcularImporteHorasExtras());
//calcular el empleado que menos cobra por horas extra

e = empleadoQueMenosCobraPorHorasExtras();
System.out.println("\n\nEmpleado que menos cobra por horas extras:");
System.out.printf("Total horas extras: %.2f €" ,
e.calcularImporteHorasExtras());
//ordenar por salario de menor a mayor

ordenarPorSalario();
System.out.println("\n\nEmpleados ordenados por salario:");
mostrarEmpleadosYSalarios();
}
}
//método para leer todos los empleados y guardarlos en el array

public static void leerEmpleados() throws IOException {
Empleado e;
String dni, nombre;
double sueldoBase;
int horasExtras;
double tipoIRPF;
char casado; // S ó N
int numeroHijos;
int i, N;
do {
System.out.print("Número de empleados? ");
N = sc.nextInt();
} while (N < 0 || N > MAXIMO_EMPLEADOS);

for (i = 1; i <= N; i++) {
sc.nextLine(); //limpiar el intro
System.out.println("Empleado " + i);
System.out.print("Nif: ");
dni = sc.nextLine();
System.out.print("Nombre: ");
nombre = sc.nextLine();
System.out.print("Sueldo Base: ");
sueldoBase = sc.nextDouble();
System.out.print("Horas extra: ");
horasExtras = sc.nextInt();
System.out.print("Tipo de IRPF: ");
tipoIRPF = sc.nextDouble();
System.out.print("Casado (S/N): ");
casado = (char) System.in.read();
System.out.print("Número de hijos: ");
numeroHijos = sc.nextInt();
e = new Empleado(dni); //crear una nueva instancia de empleado
e.setNombre(nombre);
e.setSueldoBase(sueldoBase);
e.setHorasExtras(horasExtras);
e.setTipoIRPF(tipoIRPF);
e.setCasado(Character.toUpperCase(casado));
e.setNumeroHijos(numeroHijos);
empleados[indice] = e; //se añade el empleado al array

indice++;
}
}
//método para mostrar todos los empleados

public static void mostrar() {
for (int i = 0; i < indice; i++) {
System.out.println(empleados[i]);
}
}
//método para pedir el importe de la hora extra

public static double leerImporteHorasExtras() {
double importe;
System.out.print("Introduce el importe a pagar por cada hora extra: ");
importe = sc.nextDouble();
return importe;
}
//método que devuelve el número total de empleados

public static int numeroDeEmpleados() {
return indice;
}
//método que devuelve el empleado que más cobra

public static Empleado empleadoQueMasCobra() {
Empleado mayor = empleados[0];
if (empleados[i].calcularSueldo() > mayor.calcularSueldo()) {
mayor = empleados[i];
}
}
return mayor;
}
//método que devuelve el empleado que menos cobra
public static Empleado empleadoQueMenosCobra() {
Empleado menor = empleados[0];
if (empleados[i].calcularSueldo() < menor.calcularSueldo()) {
menor = empleados[i];
}
}
return menor;
}
//método que devuelve el empleado que más cobra por horas extra
public static Empleado empleadoQueMasCobraPorHorasExtras() {
Empleado mayor = empleados[0];
if (empleados[i].calcularImporteHorasExtras() >
mayor.calcularImporteHorasExtras()) {
mayor = empleados[i];
}
}
return mayor;
}
//método que devuelve el empleado que menos cobra por horas extra
public static Empleado empleadoQueMenosCobraPorHorasExtras() {
Empleado menor = empleados[0];
if (empleados[i].calcularImporteHorasExtras() <
menor.calcularImporteHorasExtras()) {
menor = empleados[i];
}
}
return menor;
}
//método para ordenar todos los empleados por su salario de menor a mayor
public static void ordenarPorSalario() {
int i, j;
Empleado aux;
for (i = 0; i < indice - 1; i++) {
for (j = 0; j < indice - i - 1; j++) {
if (empleados[j + 1].calcularSueldo() < empleados[j].calcularSueldo()) {
aux = empleados[j + 1];
empleados[j + 1] = empleados[j];
empleados[j] = aux;
}
}
}
}
//método para mostrar los datos de cada empleado junto con su sueldo
public static void mostrarEmpleadosYSalarios() {
System.out.println(empleados[i]);
System.out.printf("Sueldo: %.2f € %n" , empleados[i].calcularSueldo());
}
}
}//Fin de la Clase Principal
Ejercicio Básico de Clases en Java: Clase NIF
Crea una clase NIF que represente el DNI con su correspondiente letra. Los atributos
de la clase serán el número de DNI y su letra.
La clase NIF dispondrá de los siguientes métodos:
Un constructor por defecto.
Un constructor que reciba como parámetro el DNI y calcule y asigne la letra que le
corresponde.
Un método leer(): que pida por teclado el número de DNI y calcule a partir del DNI
introducido la letra que le corresponde.
Método toString() que muestre el NIF de la siguiente forma: ocho dígitos, un guión y la
letra en mayúscula. Por ejemplo: 12345678-Z
Método para obtener la letra del NIF:
La letra del NIF se calculará usando un método privado. La forma de obtener la letra
del NIF es la siguiente:
Se obtiene el resto de la división entera del número de DNI entre 23 y se usa la
siguiente tabla para obtener la letra que corresponde:
0 - T 1 - R 2 - W 3 - A 4 - G 5 – M
6 – Y 7 – F 8 – P 9 - D 10 – X 11 – B
12 – N 13 – J 14 – Z 15 – S 16 - Q 17 - V
18 - H 19 - L 20 – C 21 – K 22 – E
Una vez creada la clase, escribe un programa para probarla.

Solución:
//Clase NIF
import java.util.Scanner;
public class Nif {
private int dni;

private char letra;
//Constructores
public Nif() {
}
public Nif(int dni) {

this.dni = dni;
letra = calcularLetra();
}
//Método para calcular la letra del NIF

private char calcularLetra() {
char[] letras = {'T', 'R', 'W', 'A', 'G', 'M', 'Y', 'F', 'P', 'D', 'X',
'B', 'N', 'J', 'Z', 'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'};
return letras[dni % 23];
}
//Método para leer por teclado el número de DNI y calcular la letra
public void leer() {
do {
System.out.print("Introduce dni: ");
dni = sc.nextInt();
} while (dni <= 0);
letra = calcularLetra();
}
//Método que devuelve un String de la forma 99999999-X

@Override
sb.append(dni);
sb.append("-");
sb.append(letra);
}
Un programa sencillo para probar esta clase puede der este:
//Clase Principal
public class Main {

Nif nif1 = new Nif();
nif1.leer();
System.out.println(nif1);
Nif nif2 = new Nif(12345678);

System.out.println(nif2);
}
}
La ejecución de este programa produce esta salida por pantalla:
Introduce dni: 22334455

22334455-Y
12345678-Z

Ejercicio Básico POO Java

Cargado por

Información del documento

Descripción 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

Ejercicio Básico POO Java

Cargado por

Copyright:

Formatos disponibles

Ejercicio Básico POO Java.

//se crea objeto cuenta1 sin parámetros

//se crea cuenta3 como copia de cuenta1

//mostrar los datos de cuenta1

private String nombre;

//Constructor por defecto

//Constructor con parámetros

public void setNumeroCuenta(String s) {

public void setTipoInteres(double n) {

public void setSaldo(double n) {

public String getNombre() {

public String getNumeroCuenta() {

public double getTipoInteres() {

private int cont;

//constructor por defecto

//constructor con parámetros

//método incrementar contador

//método decrementar contador

Un método main para probar la clase puede ser este:

//crear un nuevo objeto Contador con valor inicial 10

//crear un objeto Contador utilizando el constructor copia

//mostrar el valor de contador3

EJERCICIOS BÁSICOS RESUELTOS POO JAVA

Constructor por defecto.

Constructor con parámetros.

Método préstamo que incremente el atributo correspondiente cada vez que se realice

Método devolución que decremente el atributo correspondiente cuando se produzca la

Método toString para mostrar los datos de los libros. Este método se heredada de

Escribe un programa para probar el funcionamiento de la clase Libro.

public class Libro {

private String titulo;

private String autor;

private int ejemplares;

private int prestados;

//constructor por defecto

//constructor con parámetros

public Libro(String titulo, String autor, int ejemplares, int prestados) {

public String getAutor() {

public void setAutor(String autor) {

public int getEjemplares() {

public void setEjemplares(int ejemplares) {

public int getPrestados() {

public void setPrestados(int prestados) {

public String getTitulo() {

public void setTitulo(String titulo) {

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

public boolean prestamo() {

boolean prestado = true;

if (prestados < ejemplares) {

//método para realizar la devolución de un libro

public boolean devolucion() {

boolean devuelto = true;

//método toString sobrescrito para mostrar los datos de la clase Libro

return "titulo: " + titulo + "\nautor: " + autor +

"\nejemplares: " + ejemplares + "\nprestados: " + prestados;

Un programa para probar la clase Libro puede ser este:

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

String titulo, autor;

//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();