Carlos Fernández García

Ejercicio 1

Desarrolla un programa en Java que simule una calculadora simple capaz de realizar operaciones básicas como suma, resta, multiplicación y división. Sin embargo, el programa debe manejar adecuadamente las excepciones que puedan surgir durante las operaciones aritméticas. El programa debe cumplir con los siguientes requisitos: El usuario debe ser capaz de introducir dos números y seleccionar la operación que desea realizar. El programa debe realizar la operación solicitada y mostrar el resultado en pantalla. Si ocurre un error durante la operación (por ejemplo, división por cero), el programa debe capturar la excepción y mostrar un mensaje apropiado al usuario. El programa debe permitir al usuario continuar realizando operaciones hasta que decida salir. Asegúrate de utilizar adecuadamente las estructuras de control y el manejo de excepciones en tu código.

package excepciones;

import java.util.Scanner;

public class Ejercicio1 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		int num1=0,num2=0,opcionMenu=0;
		boolean valido=false;
		do {
			try {
				System.out.println("Introduce el primer numero");
				num1=Integer.parseInt(entrada.next());
				valido=true;
			}catch(NumberFormatException e) {
				System.err.println("Numerono valido vuelve a introducirlo");
				valido=false;
			}
		}while(!valido);
		
		valido=false;
		
		do {
			try {
				System.out.println("Introduce el segundo numero");
				num2=Integer.parseInt(entrada.next());
				valido=true;
			}catch(NumberFormatException e) {
				System.err.println("Numerono valido vuelve a introducirlo");
				valido=false;
			}
		}while(!valido);
		
		do {
			System.out.println("CALCULADORA");
			System.out.println("(1).SUMAR");
			System.out.println("(2).RESTAR");
			System.out.println("(3).MULTIPLICAR");
			System.out.println("(4).DIVIDIR");
			System.out.println("(5).SALIR");
			System.out.println("OPCION");
			try {
				opcionMenu=Integer.parseInt(entrada.next());
			}catch(NumberFormatException e) {
				System.err.println("Formato no valido");
			}
			switch(opcionMenu) {
			case 1:
				sumar(num1,num2);
				break;
			case 2:
				restar(num1,num2);
				break;
			case 3:
				multiplicar(num1,num2);
				break;
			case 4:
				dividir(num1,num2);
				break;
			case 5:
				System.out.println("Apagando calculadora");
				break;
			default:
				break;
			}
		}while(opcionMenu!=5);
	}
public static void sumar(int num1,int num2) {
	System.out.println(num1 + "+" + num2 + "=" + num1+num2);
}

public static void restar(int num1,int num2) {
	System.out.println(num1 + "-" + num2 + "=" + (num1-num2));
}

public static void multiplicar(int num1,int num2) {
	System.out.println(num1 + "*" + num2 + "=" + num1*num2);
}

public static void dividir(int num1,int num2) {
	try {
		System.out.println(num1 + "/" + num2 + "=" + num1/num2);
	}catch(ArithmeticException e) {
		System.err.println("no se puede dividir entre 0");
	}
	
}
}

Ejercicio 2

Desarrolla un programa en Java que solicite al usuario ingresar la edad de una persona. El programa debe validar si la edad ingresada es un número entero válido en el rango de 0 a 120 años. Si la edad ingresada no cumple con estos criterios, el programa debe lanzar una excepción personalizada llamada InvalidAgeException y manejarla adecuadamente mostrando un mensaje de error informativo. Además, el programa debe permitir al usuario intentar ingresar la edad nuevamente hasta que se ingrese una edad válida.

Ejercicio 3

Desarrolla un programa en Java que solicite al usuario ingresar el nombre de un archivo. El programa debe intentar abrir y leer el contenido del archivo especificado. Si el archivo no se encuentra, debe lanzar una excepción FileNotFoundException y mostrar un mensaje indicando que el archivo no ha sido encontrado. Si se produce un error durante la lectura del archivo, debe lanzar una excepción IOException y mostrar un mensaje de error apropiado. El programa debe manejar estas excepciones de manera adecuada y continuar su ejecución.

Ejercicio 4

Desarrolla un programa en Java que solicite al usuario ingresar un número entero positivo. El programa debe realizar alguna operación matemática simple de tu elección con ese número. Sin embargo, el programa debe manejar adecuadamente el caso en que el número ingresado sea negativo o no sea un número entero válido. Debes lanzar una excepción personalizada llamada InvalidNumberException en caso de que se ingrese un número negativo o no entero, y manejarla apropiadamente mostrando un mensaje de error informativo. Además, el programa debe permitir al usuario intentar ingresar el número nuevamente hasta que se ingrese un número válido.

Ejercicio 5

Desarrolla un programa en Java que solicite al usuario ingresar dos números enteros. El programa debe calcular la división del primer número por el segundo. Sin embargo, el programa debe manejar adecuadamente el caso en que el segundo número sea igual a cero, lo que resultaría en una división por cero. En este caso, el programa debe lanzar una excepción personalizada llamada DivisionByZeroException y manejarla apropiadamente mostrando un mensaje de error informativo. Además, el programa debe permitir al usuario intentar ingresar los números nuevamente hasta que se ingrese un segundo número diferente de cero.

Ejercicio 6

Desarrolla un programa en Java que simule una tienda en línea. El programa debe permitir al usuario agregar productos a su carrito de compras y luego proceder con el pago. Sin embargo, el programa debe manejar adecuadamente el caso en que el usuario intente agregar un producto que no existe en el inventario. En este caso, debe lanzar una excepción personalizada llamada ProductNotFoundException y manejarla apropiadamente mostrando un mensaje de error informativo. Además, el programa debe permitir al usuario continuar agregando productos hasta que decida proceder con el pago.

Ejercicio 7

Crea un programa que pida al usuario un número entero por teclado. Requisitos: Si el usuario introduce algo que no es un número, debes capturar la excepción y mostrar: Error: debes introducir un número entero. Si el número es negativo, debes lanzar tú una excepción con el mensaje: No se permiten números negativos. Si todo es correcto, muestra: Número válido: X El programa no debe romperse nunca. Siempre debe mostrar al final: Programa finalizado. Objetivo del ejercicio: usar try usar catch usar finally usar throw diferenciar excepción del sistema vs creada por ti

Ejercicio 8

Crea un programa que pida al usuario una edad por teclado. Requisitos: 1. Si el usuario introduce algo que no es un número, debes capturar la excepción y mostrar: "Error: debes introducir un número entero." 2. Si la edad es menor que 0 o mayor que 120, debes lanzar tú una excepción con el mensaje: "Edad no válida." 3. Si todo es correcto, muestra: "Edad válida: X años" 4. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti

Ejercicio 9

Crea un programa que pida al usuario un número para calcular su raíz cuadrada. Requisitos: 1. Si el usuario introduce algo que no es un número, debes capturar la excepción y mostrar: "Error: debes introducir un número." 2. Si el número es negativo, debes lanzar tú una excepción con el mensaje: "No se puede calcular la raíz de un número negativo." 3. Si todo es correcto, muestra: "La raíz cuadrada de X es Y" 4. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti


package excepciones;

import java.util.Scanner;

public class Ejercicio9 {

    public static void main(String[] args) {
        
        // Variable para almacenar el número ingresado por el usuario
        int numero;
        
        // try-with-resources: abre Scanner y garantiza que se cierre automáticamente
        try (Scanner in = new Scanner(System.in)) {
            
            // Solicitamos al usuario que introduzca un número
            System.out.println("Introduce un numero para calcular su raiz cuadrada:");
            
            // Convertimos la entrada a entero
            // Puede lanzar NumberFormatException si el usuario escribe algo que no es número
            numero = Integer.parseInt(in.nextLine());
            
            // Validamos que el número no sea negativo
            if (numero < 0) {
                // Lanzamos nuestra propia excepción unchecked (IllegalArgumentException)
                // Mensaje: "No se puede calcular la raíz de un número negativo."
                throw new IllegalArgumentException("No se puede calcular la raíz de un número negativo.");
            } else {
                // Si es válido, mostramos el resultado usando System.out (salida estándar)
                System.out.println("La raíz cuadrada de " + numero + " es " + Math.sqrt(numero));
            }
            
        } 
        // Capturamos la excepción del sistema si el usuario introduce algo que no es número
        catch (NumberFormatException e) {
            // Usamos System.err para indicar error
            System.err.println("Error: debes introducir un número.");
        } 
        // Capturamos cualquier otra excepción (en este caso, la lanzada por nosotros)
        catch (Exception e) {
            // Imprimimos directamente el mensaje de la excepción
            // También usamos System.err porque es un error de validación
            System.err.println(e.getMessage());
        } 
        // Bloque finally que se ejecuta siempre, pase lo que pase
        finally {
            // Mensaje informativo final, siempre en salida estándar
            System.out.println("Programa finalizado.");
        }

    }

}

Ejercicio 10

Crea un programa que pida al usuario dos números enteros por teclado y realice una división. Requisitos: 1. Si el usuario introduce algo que no es un número, debes capturar la excepción y mostrar: "Error: debes introducir números enteros." 2. Si el segundo número es 0, debes lanzar tú una excepción con el mensaje: "No se puede dividir entre cero." 3. Si todo es correcto, muestra: "Resultado: X" 4. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti

Ejercicio 11

Crea un programa que pida al usuario una contraseña por teclado. Requisitos: 1. La contraseña debe tener al menos 8 caracteres. 2. Debe contener al menos un número. 3. Si la contraseña no cumple estas condiciones, debes lanzar tu propia excepción con el mensaje: "Contraseña no válida." 4. Si todo es correcto, muestra: "Contraseña válida." 5. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - crear tu propia clase de excepción - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti

package excepciones;

import java.util.Scanner;

public class Ejercicio11 {

    public static void main(String[] args) {

        // Variable para almacenar la contraseña introducida por el usuario
        String password;

        // Try-with-resources para abrir el Scanner y que se cierre automáticamente
        try (Scanner in = new Scanner(System.in)) {
            
            // Mensaje con las reglas de la contraseña
            System.out.println("1. La contraseña debe tener al menos 8 caracteres.\r\n"
                    + "2. Debe contener al menos un número.");
            
            // Pedimos al usuario que introduzca la contraseña
            System.out.println("Introduce una contraseña:");
            password = in.nextLine();

            // Validamos la longitud de la contraseña
            if (password.length() < 8) {
                // Si es menor que 8, lanzamos nuestra excepción personalizada LongitudPassword
                throw new LongitudPassword("La contraseña debe tener al menos 8 caracteres");
            }

            // Contador para verificar que haya al menos un número
            int contadorNumeros = 0;

            // Recorremos cada carácter de la contraseña
            for (int i = 0; i < password.length(); i++) {
                // Si el carácter es un número (ASCII 48 a 57), aumentamos el contador
                if (password.charAt(i) >= 48 && password.charAt(i) <= 57) {
                    contadorNumeros++;
                }
            }

            // Si no hay ningún número, lanzamos nuestra excepción personalizada NumeroPassword
            if (contadorNumeros == 0) {
                throw new NumeroPassword("Debe contener al menos un número.");
            }

            // Si pasa todas las validaciones, la contraseña es válida
            System.out.println("Contraseña válida");

        } catch (LongitudPassword e) {
            // Capturamos la excepción de longitud insuficiente y mostramos el mensaje
            System.err.println(e.getMessage());
        } catch (NumeroPassword e) {
            // Capturamos la excepción de falta de números y mostramos el mensaje
            System.err.println(e.getMessage());
        } finally {
            // Siempre se ejecuta, sea correcta o incorrecta la contraseña
            System.out.println("Programa finalizado.");
        }

    }

}

// Clase de excepción personalizada para contraseñas con longitud insuficiente
class LongitudPassword extends Exception {

    private static final long serialVersionUID = 1L; // Para eliminar warning de serialización

    public LongitudPassword(String mensaje) {
        super(mensaje); // Pasamos el mensaje al constructor de Exception
    }

}

// Clase de excepción personalizada para contraseñas sin números
class NumeroPassword extends Exception {

    private static final long serialVersionUID = 1L; // Para eliminar warning de serialización

    public NumeroPassword(String mensaje) {
        super(mensaje); // Pasamos el mensaje al constructor de Exception
    }

}

Ejercicio 12

Crea un programa que gestione el stock de un producto en una tienda. Requisitos: 1. Pide al usuario que introduzca cuántas unidades quiere comprar. 2. Si el usuario introduce algo que no es un número, captura la excepción y muestra: "Error: debes introducir un número entero." 3. Si el número de unidades es mayor que el stock disponible, lanza tu propia excepción con el mensaje: "Stock insuficiente." 4. Si todo es correcto, muestra: "Compra realizada: X unidades." 5. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - crear tu propia clase de excepción - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti

Ejercicio 13

Crea un programa que gestione la edad de los usuarios para acceder a un sitio web. Requisitos: 1. Pide al usuario que introduzca su edad. 2. Si el usuario introduce algo que no es un número, captura la excepción y muestra: "Error: debes introducir un número entero." 3. Si la edad es menor que 18, lanza tu propia excepción con el mensaje: "Acceso denegado: debes ser mayor de edad." 4. Si todo es correcto, muestra: "Acceso permitido. Bienvenido." 5. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - crear tu propia clase de excepción - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti

Ejercicio 14

* Crea un programa que gestione el límite de intentos de inicio de sesión en una aplicación. Requisitos: 1. Pide al usuario que introduzca una contraseña (puedes usar cualquier contraseña fija para comprobar). 2. Si la contraseña es incorrecta, lanza tu propia excepción con el mensaje: "Contraseña incorrecta." 3. Permite un máximo de 3 intentos. Si se superan, lanza otra excepción con el mensaje: "Has superado el número máximo de intentos. Acceso bloqueado." 4. Si la contraseña es correcta dentro de los intentos permitidos, muestra: "Acceso permitido." 5. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - crear tus propias clases de excepción - usar try - usar catch - usar finally - usar throw - diferenciar excepción del sistema vs creada por ti


package excepciones;

import java.util.Scanner;

public class Ejercicio14 {

    public static void main(String[] args) {

        // contraseña correcta del sistema
        String clave = "carlos1981";

        // variable donde se guardará lo que escriba el usuario
        String password = "";

        // contador de intentos
        int intentos = 0;

        // Scanner para leer por teclado
        Scanner in = new Scanner(System.in);

        try {

            // bucle que permite hasta 3 intentos
            do {
                try {
                    System.out.println("Introduce tu password");
                    password = in.nextLine();

                    // aumentamos el contador de intentos
                    intentos++;

                    // si la contraseña es incorrecta
                    if (!password.equals(clave)) {

                        // si ya es el tercer intento → excepción de bloqueo
                        if (intentos == 3) {
                            throw new NumeroIntentos(
                                "Has superado el número máximo de intentos. Acceso bloqueado."
                            );
                        }

                        // si aún quedan intentos → excepción de contraseña incorrecta
                        throw new PasswordIncorrecto("Contraseña incorrecta");
                    }

                    // si la contraseña es correcta
                    System.out.println("Acceso permitido.");
                    break;

                } catch (PasswordIncorrecto e) {
                    // capturamos nuestra excepción personalizada
                    System.err.println(e.getMessage());

                } catch (NumeroIntentos e) {
                    // capturamos la excepción de bloqueo
                    System.err.println(e.getMessage());
                    break; // salimos del bucle porque ya no hay más intentos
                }

            } while (intentos < 3);

        } finally {
            // este bloque se ejecuta siempre
            System.out.println("Programa finalizado");
            in.close();
        }
    }
}


//Excepción personalizada para cuando la contraseña es incorrecta.
//Es una checked porque extiende de Exception.

class PasswordIncorrecto extends Exception {

    private static final long serialVersionUID = 1L;

    public PasswordIncorrecto(String mensaje) {
        super(mensaje);
    }
}


//Excepción personalizada para cuando se superan los intentos máximos.

class NumeroIntentos extends Exception {

    private static final long serialVersionUID = 1L;

    public NumeroIntentos(String mensaje) {
        super(mensaje);
    }
}

Ejercicio 15

Crea un programa que simule un cajero automático. Requisitos: 1. El usuario tiene un saldo inicial de 500€. 2. Pide al usuario cuánto dinero quiere retirar. 3. Si introduce algo que no es un número, captura la excepción y muestra: "Error: debes introducir una cantidad válida." 4. Si la cantidad es menor o igual que 0, lanza tu propia excepción: "Cantidad no válida." 5. Si intenta retirar más dinero del que tiene, lanza otra excepción: "Saldo insuficiente." 6. Si todo es correcto, muestra: "Retirada realizada. Saldo restante: X€" 7. El programa no debe romperse nunca. Siempre debe mostrar al final: "Programa finalizado." Objetivo del ejercicio: - usar NumberFormatException (del sistema) - crear 2 excepciones personalizadas - usar throw - usar try-catch - usar finally - practicar varias excepciones en el mismo programa


package excepciones;

import java.util.Scanner;

public class Ejercicio15 {

    public static void main(String[] args) {
        
        double saldoInicial = 500; // saldo inicial del usuario
        double retiro = 0.0; // cantidad que quiere retirar
        
        // try-with-resources para cerrar automáticamente el Scanner
        try (Scanner in = new Scanner(System.in)) {
            System.out.println("¿Cuánto dinero quieres retirar?");
            retiro = Double.parseDouble(in.nextLine()); // convertir entrada a double
            
            // validar que la cantidad sea mayor que 0
            if (retiro <= 0) {
                throw new RetiroInvalido("Cantidad no válida.");
            }
            
            // validar que no exceda el saldo
            if (retiro > saldoInicial) {
                throw new SaldoInsuficiente("Saldo insuficiente.");
            }
            
            // si todo es correcto, calcular el saldo restante
            double saldoRestante = saldoInicial - retiro;
            System.out.println("Retirada realizada. Saldo restante: " + String.format("%.2f€", saldoRestante));
        
        } catch (NumberFormatException e) { // captura si el usuario no introduce un número válido
            System.err.println("Error: debes introducir una cantidad válida.");
        } catch (RetiroInvalido e) { // captura si el retiro es <= 0
            System.err.println(e.getMessage());
        } catch (SaldoInsuficiente e) { // captura si se intenta retirar más del saldo
            System.err.println(e.getMessage());
        } finally { // siempre se ejecuta
            System.out.println("Programa finalizado");
        }
    }

}

// excepción personalizada para retiros inválidos (<= 0)
class RetiroInvalido extends Exception {

    private static final long serialVersionUID = 1L;

    public RetiroInvalido(String mensaje) {
        super(mensaje);
    }
}

// excepción personalizada para saldo insuficiente
class SaldoInsuficiente extends Exception {

    private static final long serialVersionUID = 1L;

    public SaldoInsuficiente(String mensaje) {
        super(mensaje);
    }
}