1.

Escribe un programa Java que realice lo siguiente: declarar una variable N de tipo int, una variable A de tipo double y una variable C de tipo char y asigna a cada una un
valor. A continuación muestra por pantalla:
El valor de cada variable.
La suma de N + A
La diferencia de A - N
El valor numérico correspondiente al carácter que contiene la variable C.
Si por ejemplo le hemos dado a N el valor 5, a A el valor 4.56 y a C el valor ‘a’, se debe mostrar por pantalla:

Variable N = 5
Variable A = 4.56
Variable C = a
5 + 4.56 = 9.559999999999999
4.56 - 5 = -0.4400000000000004
Valor numérico del carácter a = 97

/*
 * Solución Ejercicio Básico Inicial 1 
 */
package bi1;

public class Main {

    public static void main(String[] args) {

        int N = 5;
        double A = 4.56;
        char C = 'a';
        System.out.println("Variable N = " + N);
        System.out.println("Variable A = " + A);
        System.out.println("Variable C = " + C);
        System.out.println(N + " + " + A + " = " + (N+A));
        System.out.println(A + " - " + N + " = " + (A-N));
        System.out.println("Valor numérico del carácter " + C + " = " + (int)C);
    }
}

2.Escribe un programa Java que realice lo siguiente: declarar dos variables X e Y de tipo int, dos variables N y M de tipo double y asigna a cada una un valor. A continuación
muestra por pantalla:
El valor de cada variable.
La suma  X + Y
La diferencia  X – Y
El producto  X * Y
El cociente  X / Y
El resto  X % Y
La suma  N + M
La diferencia  N – M
El producto  N * M
El cociente  N / M
El resto  N % M
La suma X + N
El cociente Y / M
El resto Y % M
El doble de cada variable
La suma de todas las variables
El producto de todas las variables
Si por ejemplo le hemos dado a X el valor 1, a Y el valor 2, a M el valor 3.2 y a N el valor 4.7 se debe mostrar por pantalla:
Variable X = 1
Variable Y = 2
Variable M = 3.2
Variable N = 4.7
1+2=3
1 - 2 = -1
1*2=2
1/2=0
1%2=1
4.7 + 3.2 = 7.9
4.7 - 3.2 = 1.5
4.7 * 3.2 = 15.040000000000001
4.7 / 3.2 = 1.46875
4.7 % 3.2 = 1.5
1 + 4.7 = 5.7
2 / 3.2 = 0.625
2 % 3.2 = 2.0
Variable X = 1 el doble es 2
Variable Y = 2 el doble es 4
Variable M = 3.2 el doble es 6.4
Variable N = 4.7 el doble es 9.4
1 + 2 + 4.7 + 3.2 = 10.9
1 * 2 * 4.7 * 3.2 = 30.080000000000002

/*
 * Solución Ejercicio Básico Inicial 2 
 */

package bi2;

public class Main {

    public static void main(String[] args) {

        int X = 1, Y = 2;
        double M = 3.2, N = 4.7;
        System.out.println("Variable X = " + X);
        System.out.println("Variable Y = " + Y);
        System.out.println("Variable M = " + M);
        System.out.println("Variable N = " + N);
        System.out.println(X + " + " + Y + " = " + (X+Y));
        System.out.println(X + " - " + Y + " = " + (X-Y));
        System.out.println(X + " * " + Y + " = " + X*Y);
        System.out.println(X + " / " + Y + " = " + X/Y);
        System.out.println(X + " % " + Y + " = " + X%Y);
        System.out.println(N + " + " + M + " = " + (N+M));
        System.out.println(N + " - " + M + " = " + (N-M));
        System.out.println(N + " * " + M + " = " + N*M);
        System.out.println(N + " / " + M + " = " + N/M);
        System.out.println(N + " % " + M + " = " + N%M);
        System.out.println(X + " + " + N + " = " + (X+N));
        System.out.println(Y + " / " + M + " = " + Y/M);
        System.out.println(Y + " % " + M + " = " + Y%M);
        System.out.println("Variable X = " + X + " el doble es " + 2*X);
        System.out.println("Variable Y = " + Y + " el doble es " + 2*Y);
        System.out.println("Variable M = " + M + " el doble es " + 2*M);
        System.out.println("Variable N = " + N + " el doble es " + 2*N);
        System.out.println(X + " + " + Y + " + " + N + " + " + M + " = " + (X+Y+M+N));
        System.out.println(X + " * " + Y + " * " + N + " * " + M + " = " + (X*Y*M*N));
    }
}

3.Escribe un programa Java que declare una variable entera N y asígnale un valor. A continuación escribe las instrucciones que realicen los siguientes:
Incrementar N en 77.
Decrementarla en 3.
Duplicar su valor.
Si por ejemplo N = 1 la salida del programa será:
Valor inicial de N = 1
N + 77 = 78
N - 3 = 75
N * 2 = 150

/*
 * Solución Ejercicio Básico Inicial 3
 */
package bi3;
public class Main {
    public static void main(String[] args) {
        int N = 1;
        System.out.println("Valor inicial de N = " + N);
        N+=77;
        System.out.println("N + 77 = " + N);
        N-=3;
        System.out.println("N - 3 = " + N);
        N*=2;
        System.out.println("N * 2 = " + N);
    }
}

4.Programa java que declare cuatro variables enteras A, B, C y D y asígnale un valor a cada una. A continuación realiza las instrucciones necesarias para que:
B tome el valor de C
C tome el valor de A
A tome el valor de D
D tome el valor de B
Si por ejemplo A = 1, B = 2, C = 3 y D = 4 el programa debe mostrar:
Valores iniciales
A=1
B=2
C=3
D=4
Valores finales
B toma el valor de C -> B = 3
C toma el valor de A -> C = 1
A toma el valor de D -> A = 4
D toma el valor de B -> D = 2

/*
 * Solución Ejercicio Básico Inicial 4
 */
package bi6;
public class Main {
    public static void main(String[] args) {
        int A = 1, B = 2, C = 3, D = 4, AUX;
        System.out.println("Valores iniciales");
        System.out.println("A = " + A);
        System.out.println("B = " + B);
        System.out.println("C = " + C);
        System.out.println("D = " + D);
        AUX = B;
        B = C;
        C = A;
        A = D;
        D = AUX;
        System.out.println("Valores finales");
        System.out.println("B toma el valor de C -> B = " + B);
        System.out.println("C toma el valor de A -> C = " + C);
        System.out.println("A toma el valor de D -> A = " + A);
        System.out.println("D toma el valor de B -> D = " + D);
    }
}
En esta entrada vamos a ver tres ejemplos de utilización del operador condicional ? :
Se trata de usar el operador condicional en lugar de la instrucción condicional if para mostrar por pantalla un mensaje u otro dependiendo de una condición.

5.Escribe un programa java que declare una variable A de tipo entero y asígnale un valor. A continuación muestra un mensaje indicando si A es par o impar. Utiliza el
operador condicional ( ? : ) dentro del println para resolverlo.
Si por ejemplo A = 14 la salida será
14 es par
Si fuese por ejemplo A = 15 la salida será:
15 es impar

/*
 * Solución Ejercicio Básico Inicial 5
 */
package bi7;
public class Main {
    public static void main(String[] args) {
        int A = 15;
        System.out.println(A + (A%2==0 ? " es par " : " es impar "));
    }
}
6.Escribe un programa java que declare una variable B de tipo entero y asígnale un valor. A continuación muestra un mensaje indicando si el valor de B es positivo o
negativo. Consideraremos el 0 como positivo. Utiliza el operador condicional ( ? : ) dentro del println para resolverlo.
Si por ejemplo B = 1 la salida será
1 es positivo
Si fuese por ejemplo B = -1 la salida será:
-1 es negativo

/*
 * Solución Ejercicio Básico Inicial 6
 */
package bi6;
public class Main {
    public static void main(String[] args) {
       int B = -1;
       System.out.println(B + (B >= 0 ? " es positivo " : " es negativo "));
    }
}

7.Escribe un programa java que declare una variable C de tipo entero y asígnale un valor. A continuación muestra un mensaje indicando si el valor de C es positivo o
negativo, si es par o impar, si es múltiplo de 5, si es múltiplo de 10 y si es mayor o menor que 100. Consideraremos el 0 como positivo. Utiliza el operador condicional ( ? : )
dentro del println para resolverlo.
Si por ejemplo C = 55 la salida será
55 es positivo
55 es impar
55 es múltiplo de 5
55 no es múltiplo de 10
55 es menor que 100

/*
 * Solución Ejercicio Básico Inicial 7
 */
package bi7;
public class Main {
    public static void main(String[] args) {
       int C = 55;
       System.out.println(C + (C >= 0 ? " es positivo " : " es negativo "));
       System.out.println(C + (C%2== 0 ? " es par " : " es impar "));
       System.out.println(C + (C%5== 0 ? " es múltiplo de 5 " : " no es múltiplo de 5 "));
       System.out.println(C + (C%10== 0 ? " es múltiplo de 10 " : " no es múltiplo de 10 "));
       System.out.println(C + (C>100 ? " es mayor que 100 " : " es menor que 100 "));
    }
}

8. Programa Java que lea un número entero por teclado y calcule si es par o impar.
Podemos saber si un número es par si el resto de dividir el número entre 2 es igual a cero. En caso contrario el número es impar
El operador Java que calcula el resto de la división entre dos números enteros o no es el operador %
El programa que calcula si un número entero es par o impar es el siguiente:
import java.util.*;
public class Condicional1_1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N;
        System.out.print("Introduzca Número entero: ");
        N = sc.nextInt(); 
        if(N%2==0)
           System.out.println("Par");    
        else
            System.out.println("Impar");  
    }
}
 

9. Programa que lea un número entero y muestre si el número es múltiplo de 10.

Podemos comprobar si un número entero es múltiplo de 10 si al dividirlo por 10 es resto de esta división es cero.
/* Programa que lea un número entero y muestre si el número es múltiplo de 10 */
import java.util.*;
public class Condicional1_2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N;
        System.out.print("Número entero: ");
        N = sc.nextInt(); 
        if(N%10==0)
           System.out.println("Es múltiplo de 10");    
        else
         System.out.println("No es múltiplo de 10");
    }
}

10. Programa que lea un carácter por teclado y compruebe si es una letra mayúscula
/* condicional1_3
 * Programa que lea un carácter por teclado y compruebe si es una letra mayúscula
 */
import java.io.*;
import java.util.*;
public class condicional1_3 {
    public static void main(String[] args) throws IOException{
          Scanner sc = new Scanner(System.in);
          char car, car1;
          System.out.print("Introduzca un carácter: ");
          car = (char)System.in.read(); //lee un solo caracter
         
          if(Character.isUpperCase(car)) //utilizamos el método isUpperCase de la clase Character
             System.out.println("Es una letra mayúscula");    
          else
              System.out.println("No es una letra mayúscula");   
     }
Forma alternativa de comprobar si un carácter es una letra mayúscula sin utilizar el método isUpperCase, en este caso comparando directamente con los caracteres A y Z        
        if(car>='A' && car <='Z')
           System.out.println("Es una letra mayúscula");    
        else
           System.out.println("No es una letra mayúscula");   

11.Programa que lea dos caracteres y compruebe si son iguales.

/* 
 *  Ejemplo básico java
 * Programa con estructura condicional
 * Programa que lea dos caracteres y compruebe
 * si son iguales.
 */
import java.io.*;
public class condicional1_5 {
    public static void main(String[] args) throws IOException {
        char car1, car2;
        System.out.print("Introduzca primer carácter: ");
        car1 = (char)System.in.read(); //lee un carácter
        System.in.read();  //saltar el intro que ha quedado en el buffer
        System.out.print("Introduzca segundo carácter: ");
        car2 = (char)System.in.read(); //lee el segundo carácter

        if(car1 == car2)

           System.out.println("Son iguales");    
        else
           System.out.println("No son iguales");        
    }
} 
Una forma alternativa de hacer este programa es creando dos objetos Character a partir de los caracteres que se han leído y compararlos utilizando el método equals
import java.io.*;
public class condicional1_5 {
    public static void main(String[] args) throws IOException {
        char car1, car2;
        System.out.print("Introduzca primer carácter: ");
        car1 = (char)System.in.read(); //lee un carácter
        System.in.read();  //saltar el intro que ha quedado en el buffer
        System.out.print("Introduzca segundo carácter: ");
        car2 = (char)System.in.read(); //lee el segundo carácter
        Character c1 = new Character(car1);
        Character c2 = new Character(car2);
        if(c1.equals(c2))  //comparamos dos objetos Character mediante el método equals
            System.out.println("Son iguales");   
        else
            System.out.println("No son iguales");
    }  
}
12.Programa java que lea dos caracteres por teclado y compruebe si los dos son letras minúsculas
/* Ejemplo básico java de programa con estructura condicional
 * Programa que lea dos caracteres y compruebe si los dos son letras minúsculas
 */
import java.io.*;
public class condicional1_6 {
public static void main(String[] args) throws IOException {
        char car1, car2;
        System.out.println("Introduzca primer carácter: ");
        car1 = (char)System.in.read(); //lee un carácter
        System.in.read();  //saltar el intro que ha quedado
        System.out.println("Introduzca segundo carácter: ");
        car2 = (char)System.in.read(); //lee el segundo carácter      
        if(Character.isLowerCase(car1)){ //utilizamos el método isLowerCase de la clase Character
           if(Character.isLowerCase(car2))
               System.out.println("Los dos son letras minúsculas");
           else
               System.out.println("El primero es una letra minúscula pero el segundo no");
        }
        else{
            if(Character.isLowerCase(car2))
               System.out.println("El segundo es una letra minúscula pero el primero no");
           else
               System.out.println("Ninguno es una letra minúscula");
        }
   }
}
Una forma alternativa de resolver este ejercicio es comparando directamente las dos variables con las letras minúsculas        
        if(car1>='a' && car1<='z'){
            if(car2>='a' && car2<='z')
               System.out.println("Los dos son letras minúsculas");
           else
               System.out.println("El primero es una letra minúscula pero el segundo no");
        }
        else{
            if(car2>='a' && car2<='z')
               System.out.println("El segundo es una letra minúscula pero el primero no");
           else
               System.out.println("Ninguno es una letra minúscula");
        }
13.Programa java que lea un carácter por teclado y compruebe si es un dígito numérico (cifra entre 0 y 9).
Vamos a escribir dos soluciones a este ejercicio. 
La primera consiste en comprobar si el carácter es un dígito mediante el método isDigit de la clase Character. Este método devuelve true si el carácter que se le pasa como parámetro es
una cifra entre 0 y 9:
/* 
  * Ejemplo de programa con estructura condicional
 * Programa que lea un carácter por teclado y compruebe si es un número
 */
import java.io.*;
public class condicional1_7 {
   public static void main(String[] args) throws IOException {
        char car1;
        System.out.print("Introduzca carácter: ");
        car1 = (char)System.in.read(); //lee un carácter
        if(Character.isDigit(car1)) //utilizamos el método isDigit de la clase Character
           System.out.println("Es un número");
        else
           System.out.println("No es un número");
 }
}

La otra solución es directa y consiste en comprobar si el carácter que se ha leído por teclado es mayor o igual que el carácter 0 y menor o igual que el carácter 9.

// Versión alternativa comparando con 

// los caracteres '0' ... '9'

     if(car1>='0' && car1<='9')

           System.out.println("Es un número");
        else
           System.out.println("No es un número");
   
14.Programa que lea dos números por teclado y muestre el resultado de la división del primer número por el segundo. Se debe comprobar que el divisor no puede ser cero.
/* 
 * Ejemplo de programa con estructura condicional
 * Programa que lea dos números por teclado y muestre el resultado 
 * de la división del primero por el segundo. 
 * Se comprueba que el divisor es distinto de cero.
 */
import java.util.*;
public class condicional1_8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double dividendo, divisor;
        System.out.print("Introduzca el dividendo: ");
        dividendo = sc.nextDouble(); 
        System.out.print("Introduzca el divisor: ");
        divisor = sc.nextDouble(); 
        if(divisor==0)
           System.out.println("No se puede dividir por cero");    
        else{
            System.out.println(dividendo + " / " + divisor + " = " + dividendo/divisor);   
            System.out.printf("%.2f / %.2f = %.2f %n" , dividendo, divisor , dividendo/divisor);
        }
    }
}
El programa lee por teclado tres números enteros y calcula y muestra el mayor de los tres.

/* 
 * Programa que lee tres números distintos 
 * y nos dice cuál de ellos es el mayor
 */
import java.util.*;
public class MayorDeTres {
 public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      int n1, n2, n3;
      System.out.print("Introduzca primer número: ");
      n1 = sc.nextInt();
    System.out.print("Introduzca segundo número: ");
      n2 = sc.nextInt();
      System.out.print("Introduzca tercer número: ");
        n3 = sc.nextInt();
        if(n1 > n2)
           if(n1>n3)
              System.out.println("El mayor es: " + n1);
           else
              System.out.println("el mayor es: " + n3);
        else if(n2>n3)
              System.out.println("el mayor es: " + n2);
                else
              System.out.println("el mayor es: " + n3);
    }
}

14.Programa que lea por teclado tres números enteros H, M, S correspondientes a hora, minutos y segundos respectivamente, y comprueba si la hora que indican es una hora válida.  
Supondremos que se leemos una hora en modo 24 Horas, es decir, el valor válido para las horas será mayor o igual que cero y menor que 24.
El valor válido para los minutos y segundos estará comprendido entre 0 y 59 ambos incluidos
/*
 * Programa java que lea tres números enteros H, M, S que contienen hora, minutos y
 * segundos respectivamente, y comprueba si la hora que indican es una hora válida.
 */
import java.util.*;
public class condicional1_16 {
    public static void main(String[] args) {
        int H,M,S;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduzca hora: ");
        H =  sc.nextInt();
        System.out.print("Introduzca minutos: ");
        M =  sc.nextInt();
        System.out.print("Introduzca segundos: ");
        S =  sc.nextInt();
        if(H>=0 && H<24 && M>=0 && M<60 && S>=0 && S<60)     
           System.out.println("Hora correcta");
        else
            System.out.println("Hora incorrecta");
    }
}
La instrucción que comprueba si la hora leída por teclado es correcta es:
if(H>=0 && H<24 && M>=0 && M<60 && S>=0 && S<60)      

Esta condición da como resultado true  cuando la hora es mayor o igual a 0 y menor que 24, los minutos son mayores o iguales a 0 y menores que 60 y los segundos son mayores 0
iguales a cero y menores a 60.

15.Programa que lea una variable entera mes y compruebe si el valor corresponde a un mes de 30 días, de 31 o de 28. Supondremos que febrero tiene 28 días. Se mostrará además el
nombre del mes. Se debe comprobar que el valor introducido esté comprendido entre 1 y 12.
/*
 * Programa java que lea una variable entera mes y compruebe si el valor corresponde
 * a un mes de 30 días. Se debe comprobar que el valor introducido esté
 * comprendido entre 1 y 12
 */
import java.util.*;
public class condicional1_17 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int mes;
        System.out.print("Introduzca número de mes: ");
        mes =  sc.nextInt();
        if(mes < 1 || mes > 12) //se comprueba que el valor del mes es correcto
            System.out.println("Mes incorrecto");
        else{  //si el mes es correcto
            switch(mes){  //se muestra el nombre mediante una instrucción switch
                case 1: System.out.print("Enero");
                        break;
                case 2: System.out.print("Febrero");
                        break;
                case 3: System.out.print("Marzo");
                        break;
                case 4: System.out.print("Abril");
                        break;
                case 5: System.out.print("Mayo");
                        break;
                case 6: System.out.print("Junio");
                        break;
                case 7: System.out.print("Julio");
                        break;
                case 8: System.out.print("Agosto");
                        break;
                case 9: System.out.print("Septiembre");
                        break;
                case 10: System.out.print("Octubre");
                        break;
                case 11: System.out.print("Noviembre");
                        break;
                case 12: System.out.print("Diciembre");
                        break;
            }
            // mostrar si es un mes de 30, 31 0 28 días
            if(mes == 4 || mes == 6 || mes == 9 || mes == 11)       
               System.out.println(" es un mes de 30 días");
            else if(mes == 2)
                     System.out.println(" es un mes de 28 días");
                   else
                      System.out.println(" es un mes de 31 días");
        }
    }
}
16.Ejemplo de uso de while: Programa Java que muestre los números del 1 al 100 utilizando la instrucción while.
/*
 * Ejercicios básicos java con estructura iterativa o repetitiva
 * Mostrar los números del 1 al 100 
 * utilizando un bucle while
 */
public class Main {
    public static void main(String[] args) {
         System.out.println("Numeros del 1 al 100: ");
         int i=1;
         while(i<=100) {
                   System.out.println(i);
                   i++;
         }
    }
}
17.Ejemplo de uso de do-while. Programa Java que muestre los números del 1 al 100 utilizando la instrucción do..while.
/*
 * Ejercicios básicos java con estructura iterativa o repetitiva
 * Mostrar los números del 1 al 100 utilizando un bucle do while
 */
public class Main {
    public static void main(String[] args) {
        int i = 1;
        System.out.println("Numeros del 1 al 100: ");
        do{
                   System.out.println(i);
                   i++;
        }while(i<=100);
    }
}
18.Ejemplo de uso de for. Programa Java que muestre los números del 1 al 100 utilizando la instrucción for.
/*
 * Ejercicios básicos java con estructura iterativa o repetitiva
 * Mostrar los números del 1 al 100 utilizando un bucle for
 */
public class Repetitiva1_3 {
    public static void main(String[] args) {
        System.out.println("Numeros del 1 al 100: ");
        for(int i = 1; i<=100;i++)
            System.out.println(i);
    }
}
 
19.Ejemplo de uso de while. Programa Java que muestre los números del 100 al 1 utilizando la instrucción while.
/*
 * Ejercicios básicos java con estructura iterativa o repetitiva
 * Mostrar los números del 100 al 1 utilizando un bucle while
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("Numeros del 100 al 1: ");
         int i=100;
         while(i>=1)
         {
                   System.out.println(i);
                   i--;
         }
    }
}
20.Ejemplo de uso de do-while. Programa Java que muestre los números del 100 al 1 utilizando la instrucción do..while.
/*
 * Ejercicios básicos java con estructura iterativa o repetitiva
 * Mostrar los números del 100 al 1 utilizando un bucle do while
 */
public class Main {
    public static void main(String[] args) {
        int i = 100;
        System.out.println("Numeros del 100 al 1: ");
         do{
                   System.out.println(i);
                   i--;
        }while(i>=1);
    }
}

21.Ejemplo de for. Programa Java que muestre los números del 100 al 1 utilizando la instrucción for.
/*
 * Ejercicios básicos java con estructura iterativa o repetitiva
 * Mostrar los números del 100 al 1 utilizando un bucle for
 */
public class Repetitiva1_6 {
    public static void main(String[] args) {
        System.out.println("Numeros del 100 al 1: ");
        for(int i=100;i>=1;i--)
            System.out.println(i);
    }
}

22.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
System.out.println("Saldo: " + cuenta1.getSaldo());
       
//mostrar los datos de cuenta2
System.out.println("Datos de la cuenta 2");
System.out.println("Nombre del titular: " + cuenta2.getNombre());
System.out.println("Número de cuenta: " + cuenta2.getNumeroCuenta());
System.out.println("Tipo de interés: " + cuenta2.getTipoInteres());
System.out.println("Saldo: " + cuenta2.getSaldo());
System.out.println();
       
//mostrar los datos de cuenta3
System.out.println("Datos de la cuenta 3");
System.out.println("Nombre del titular: " + cuenta3.getNombre());
System.out.println("Número de cuenta: " + cuenta3.getNumeroCuenta());
System.out.println("Tipo de interés: " + cuenta3.getTipoInteres());
System.out.println("Saldo: " + cuenta3.getSaldo());
System.out.println();
       
//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");
System.out.println("Saldo: " + cuenta2.getSaldo());
System.out.println();
       
//mostrar el saldo de cuenta3
System.out.println("Saldo de la cuenta 3");
System.out.println("Saldo: " + cuenta3.getSaldo());
System.out.println();
}
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;
    }
}
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:

public static void main(String[] args) {

       
        Scanner sc = new Scanner(System.in);
       
        //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());
       
        contador1.incrementar();
        contador1.incrementar();
       
        //mostrar el valor actual
        System.out.println(contador1.getCont());
       
        //restar 1 al valor del contador
        contador1.decrementar();
       
        //mostrar el valor actual
        System.out.println(contador1.getCont());

        //crear un nuevo objeto Contador con valor inicial 10

        Contador contador2 = new Contador(10);
       
        //incrementar y decrementar el contador2 y mostrar su valor
        contador2.incrementar();
        System.out.println(contador2.getCont());
        contador2.decrementar();
        System.out.println(contador2.getCont());

        //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

        System.out.println(contador3.getCont());
    }
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;

    //constructor por defecto

    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:

public static void main(String[] args) {

        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

        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 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…
        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");
        }
        //mostrar los datos del objeto libro1
        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();

        //mostrar los datos del objeto libro2

        System.out.println("Libro 2:");
        System.out.println("Titulo: " + libro2.getTitulo());
        System.out.println("Autor: " + libro2.getAutor());
        System.out.println("Ejemplares: " + libro2.getEjemplares());
        System.out.println("Prestados: " + libro2.getPrestados());
        System.out.println();
    }
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:
public static void main(String[] args) {
        // Se crean 4 fracciones
        Fraccion f1 = new Fraccion(1, 4); // Fracción 1/4
        Fraccion f2 = new Fraccion(1, 2); // Fracción 1/2
        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:
Fraccion f1 = new Fraccion(1, 4); // Fracción 1/4
Fraccion f2 = new Fraccion(1, 2); // Fracción 1/2
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.
//constructor por defecto
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
public String toString() {
        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;
        aux.den = this.den * f.den;
        aux.simplificar();  //se simplifica antes de devolverla
        return aux;
    }
   
    //restar fracciones
    public Fraccion restar(Fraccion f) {
        Fraccion aux = new Fraccion();
        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;
    }
   
    //multiplicar fracciones
    public Fraccion multiplicar(Fraccion f) {
        Fraccion aux = new Fraccion();
        aux.num = this.num * f.num;
        aux.den = this.den * f.den;
        aux.simplificar();  //se simplifica antes de devolverla
        return aux;
    }

    //dividir fracciones
    public Fraccion dividir(Fraccion f) {
        Fraccion aux = new Fraccion();
        aux.num = this.num * f.den;
        aux.den = this.den * f.num;
        aux.simplificar();  //se simplifica antes de devolverla
        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
    public String toString() {
        simplificar();
        return num + "/" + den;
    }    
} //Fin de la clase Fraccion
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;

    //Constructor por defecto

    public Fecha() {
    }

    //Constructor con parámetros

    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 {
                    diaCorrecto = dia >= 1 && dia <= 28;
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                diaCorrecto = dia >= 1 && dia <= 30;
                break;
            default:
                diaCorrecto = dia >= 1 && dia <= 31;
        }
        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
    public String toString() {
        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 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        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
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;
   
    //Constructor por defecto
    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
    public String toString() {
        StringBuilder sb = new StringBuilder();
        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);
        return  sb.toString();
    }
}//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.println(e);
            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.println(e);
            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.println(e);
            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];
        for (int i = 1; i < indice; i++) {
            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];
        for (int i = 1; i < indice; i++) {
            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];
        for (int i = 1; i < indice; i++) {
            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];
        for (int i = 1; i < indice; i++) {
            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() {
        for (int i = 0; i < indice; i++) {
            System.out.println(empleados[i]);
            System.out.printf("Sueldo: %.2f € %n" , empleados[i].calcularSueldo());
        }
    }
}//Fin de la Clase Principal
Crea una clase Persona con los siguientes atributos: nombre, dirección, códigoPostal, ciudad y fechaNacimiento.
El atributo fechaNacimiento es un objeto de la clase Fecha creada en esta entrada.
Las clases Persona y Fecha tienen por tanto una relación de composición.

A la clase Fecha que ya tenemos le añadiremos un método boolean esMayorQue(Fecha f) que nos será útil en este ejercicio. Este método devuelve true si la fecha que contiene el
objeto es mayor que la fecha que recibe como parámetro y false en caso contrario.
La clase Persona contendrá los siguientes métodos:
Constructor
Métodos get y set
Método boolean esMayorDeEdad() que devuelve true si la persona es mayor de edad y false en caso contrario. Para sabre si la persona es mayor de edad se comparará la fecha de
nacimiento con la fecha actual obtenida del sistema.
Método toString() que muestre los datos de la siguiente forma:

Nombre: Adolfo Pérez Clavarana

Fecha Nacimiento: 12-07-1987
Dirección: C/ La Isla 19 2-B
03030 Elche
La clase Persona se va a utilizar en un programa que pida por teclado los datos de varias personas y las guarde en un ArrayList de objetos de tipo Persona y a continuación muestre
información sobre ellas.
La clase principal del proyecto y el método main serán estos:

public class Main {

    //se crea el ArrayList de Personas
    static ArrayList<Persona> personas = new ArrayList<Persona>();
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {

        //se leen las personas y se introducen en el ArrayList
        leerPersonas();
        if (numeroDePersonas() > 0) {
            //se muestran todas las personas introducidas
            System.out.println("\nPersonas introducidas: ");
            mostrar();
            //se muestra la persona de mayor edad
            System.out.println("\nPersona de mayor edad: ");
            System.out.println(personaMayorEdad());
            //se muestran todas las personas que viven en Elche
            System.out.println("\nNúmero de personas que viven en Elche: "
                                          + cuantasPersonasVivenEn(“Elche”));
            //se muestra el número de personas mayores de edad
            System.out.println("\nNúmero de personas mayores de edad : "
                                          + personasMayoresDeEdad());         
        }
    }
     //Resto de métodos
}
A continuación del método main se escribirá el código del resto de métodos:
Método leerPersonas(): pide por teclado los datos de las personas y las añade al array.
Método mostrar(): muestra los datos de todas las personas introducidas.
Método númeroDePersonas(): devuelve el número de personas que contiene el array.
Método personaMayorEdad(): devuelve la persona de mayor edad. Si hay varias devuelve la primera encontrada.
Método cuantasPersonasVivenEn(String): método que recibe el nombre de una población y devuelve cuántas de esas personas viven en ella.
Método personasMayoresDeEdad(): método que devuelve cuántas de esas personas son mayores de edad.
Solución:

///////////////////////////////////////////////////////////////////////////////////////////
//Clase Fecha
///////////////////////////////////////////////////////////////////////////////////////////
public class Fecha {

    private int dia;

    private int mes;
    private int año;

    //Constructor por defecto

    public Fecha() {
    }

    //Constructor con parámetros

    public Fecha(int dia, int mes, int año) {
        this.dia = dia;
        this.mes = mes;
        this.año = año;
    }

    //Métodos get y set

    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;
    }

    //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 {
                    diaCorrecto = dia >= 1 && dia <= 28;
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                diaCorrecto = dia >= 1 && dia <= 30;
                break;
            default:
                diaCorrecto = dia >= 1 && dia <= 31;
        }
        return diaCorrecto && mesCorrecto && añoCorrecto;
    }

    //Comprobar si el año es bisiesto

    //Método privado invocado desde el método fechaCorrecta
    private boolean esBisiesto() {
        return (año % 4 == 0 && año % 100 != 0 || año % 400 == 0);
    }

    public void diaSiguiente() {

        dia++;
        if (!fechaCorrecta()) {
            dia = 1;
            mes++;
            if (!fechaCorrecta()) {
                mes = 1;
                año++;
            }

        }
    }

    //Método para comprobar si la fecha es mayor que la que se recibe

    public boolean esMayorQue(Fecha f){
        if(año > f.año) {
            return true;
        }
        else if(año==f.año && mes > f.mes) {
            return true;
        }
        else if(año==f.año && mes == f.mes && dia > f.dia) {
            return true;
        }
        return false;
    }
   
    //Método para mostrar la fecha
    @Override
    public String toString() {
        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();
    }
} //Final de la Clase Fecha
///////////////////////////////////////////////////////////////////////////////////////////
//Clase Persona
///////////////////////////////////////////////////////////////////////////////////////////
import java.util.Calendar;

public class Persona {

    private String nombre;

    private String direccion;
    private int codigoPostal;
    private String ciudad;
    private Fecha fechaNacimiento;

    //Constructor por defecto

    public Persona() {
        fechaNacimiento = new Fecha();
    }

    //Métodos get y set

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {

        this.nombre = nombre;
    }

    public String getDireccion() {

        return direccion;
    }

    public void setDireccion(String direccion) {

        this.direccion = direccion;
    }

    public int getCodigoPostal() {

        return codigoPostal;
    }

    public void setCodigoPostal(int codigoPostal) {

        this.codigoPostal = codigoPostal;
    }

    public String getCiudad() {

        return ciudad;
    }

    public void setCiudad(String ciudad) {

        this.ciudad = ciudad;
    }

    public Fecha getFechaNacimiento() {

        return fechaNacimiento;
    }

    public void setFechaNacimiento(Fecha fecha) {

        fechaNacimiento.setDia(fecha.getDia());
        fechaNacimiento.setMes(fecha.getMes());
        fechaNacimiento.setAño(fecha.getAño());
    }

    //Método para mostrar los datos de las personas según el formato pedido
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Nombre: ");
        sb.append(nombre);
        sb.append("\nFecha de Nacimiento: ");
        sb.append(fechaNacimiento);
        sb.append("\nDireccion: ");
        sb.append(direccion);
        sb.append("\n");
        sb.append(codigoPostal);
        sb.append("\n");
        sb.append(ciudad);
        sb.append("\n");
        return sb.toString();
    }

    //Método que comprueba si la persona es mayor de edad

    public boolean esMayorDeEdad() {
        Calendar hoy = Calendar.getInstance();
        int añoActual = hoy.get(Calendar.YEAR);
        int mesActual = hoy.get(Calendar.MONTH) + 1;
        int diaActual = hoy.get(Calendar.DAY_OF_MONTH);
        if (añoActual - fechaNacimiento.getAño() > 18) {
            return true;
        } else if (añoActual - fechaNacimiento.getAño() == 18 &&
                      mesActual > fechaNacimiento.getMes()) {
            return true;
        } else if (añoActual - fechaNacimiento.getAño() == 18 &&
                     mesActual == fechaNacimiento.getMes() &&
                     diaActual >= fechaNacimiento.getDia()) {
            return true;
        }
        return false;
    }
} //Final de la clase Persona

///////////////////////////////////////////////////////////////////////////////////////////
//Clase Principal
///////////////////////////////////////////////////////////////////////////////////////////
import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    //se crea el ArrayList de Personas

    static ArrayList<Persona> personas = new ArrayList<Persona>();
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {

        //se leen las personas y se introducen en el ArrayList
        leerPersonas();
        if (numeroDePersonas() > 0) {
            //se muestran todas las personas introducidas
            System.out.println("\nPersonas introducidas: ");
            mostrar();
            //se muestra la persona de mayor edad
            System.out.println("\nPersona de mayor edad: ");
            System.out.println(personaMayorEdad());
            //se muestran todas las personas que viven en Elche
            System.out.println("\nNúmero de personas que viven en Elche: "
                                          + cuantasPersonasVivenEn(“Elche”));
            //se muestra el número de personas mayores de edad
            System.out.println("\nNúmero de personas mayores de edad : "
                                          + personasMayoresDeEdad());         
        }
    }

    //Método que lee los datos de cada persona y las añade al ArrayList
    public static void leerPersonas() {

        String nombre, direccion, ciudad;

        Fecha fecha;
        Persona p;
        int codigoPostal, N, i, dia, mes, año;

        do {
            System.out.print("Número de personas? ");
            N = sc.nextInt();
        } while (N < 0);
        sc.nextLine(); //limpiar el buffer de entrada

        for (i = 1; i <= N; i++) {

            System.out.println("Persona " + i);
            System.out.print("Nombre: ");
            nombre = sc.nextLine();
            do {
                System.out.println("Fecha de Nacimiento: ");
                System.out.print("Dia: ");
                dia = sc.nextInt();
                System.out.print("Mes: ");
                mes = sc.nextInt();
                System.out.print("Año: ");
                año = sc.nextInt();
                fecha = new Fecha(dia, mes,año);
            } while (!fecha.fechaCorrecta());

            sc.nextLine();
            System.out.print("Dirección: ");
            direccion = sc.nextLine();
            System.out.print("Codigo Postal: ");
            codigoPostal = sc.nextInt();
            sc.nextLine();
            System.out.print("Ciudad: ");
            ciudad = sc.nextLine();

            //se crea una nueva instancia de Persona

            p = new Persona();
            p.setNombre(nombre);
            p.setFechaNacimiento(fecha);
            p.setDireccion(direccion);
            p.setCodigoPostal(codigoPostal);
            p.setCiudad(ciudad);

            //se añade el objeto al array

            personas.add(p);
        }
    }

    //Mostrar todas las personas

    public static void mostrar() {
        for (int i = 0; i < personas.size(); i++) {
            System.out.println(personas.get(i));
        }
    }

    //Devuelve el número de personas que contiene el array

    public static int numeroDePersonas() {
        return personas.size();
    }

    //Devuelve la persona de mayor edad

    //En este método se utiliza el método esMayorQue() añadido a la clase Fecha
    public static Persona personaMayorEdad() {
        Persona aux = personas.get(0);
        for (int i = 1; i < personas.size(); i++) {
            if (personas.get(i).getFechaNacimiento().esMayorQue(aux.getFechaNacimiento())) {
                aux = personas.get(i);
            }
        }
        return aux;
    }

    //Calcula y devuelve el número de personas que viven

    //en la ciudad que se recibe como parámetro
    public static int cuantasPersonasVivenEn(String ciudad) {
        int cont = 0;
        for (int i = 0; i < personas.size(); i++) {
            if (personas.get(i).getCiudad().equalsIgnoreCase(ciudad)) {
                cont++;
            }
        }
        return cont;
    }

    //Calcula y devuelve el número de personas mayores de edad

    public static int personasMayoresDeEdad() {
        int cont = 0;
        for (int i = 0; i < personas.size(); i++) {
            if (personas.get(i).esMayorDeEdad()) {
                cont++;
            }
        }
        return cont;
    }
} //Fin de la Clase Principal