Carlos Fernández García

Ejercicio 1

Crea una enumeración llamada DiasSemana que contenga los días de la semana. Luego, escribe un programa que solicite al usuario ingresar un número (1-7) e imprima el día correspondiente.

Ejercicio 2

Define una enumeración llamada ColoresArcoiris con los colores del arcoíris. Escribe un programa que recorra la enumeración e imprima cada color en una línea.

Ejercicio 3

Crea una enumeración llamada TallasRopa con las tallas de ropa (XS, S, M, L, XL). * Solicita al usuario que ingrese su talla y muestra un mensaje indicando si está disponible.

Ejercicio 4

Crea una enumeración llamada EstacionesAnio que represente las estaciones del año. * Escribe un programa que pida al usuario ingresar un mes (1-12) y determine la estación correspondiente.

Ejercicio 5

Crea una enumeración llamada DiasLaborables que represente los días laborables de la semana (Lunes a Viernes). Luego, escribe un programa que solicite al usuario ingresar un día y muestre un mensaje indicando si es un día laborable o no.

Ejercicio 6

Define una enumeración llamada NotasMusicales que contenga las notas musicales (Do, Re, Mi, Fa, Sol, La, Si). Después, crea un programa que recorra la enumeración e imprima cada nota musical en una línea.

Ejercicio 7

Crea una enumeración llamada TiposVehiculos que represente diferentes tipos de vehículos (Automóvil, Motocicleta, Camión, Bicicleta). Escribe un método que tome un tipo de vehículo como argumento y devuelva un mensaje indicando si es motorizado o no.

Ejercicio 8

Crea una enumeración llamada MesesAnio que represente los meses del año. Luego, escribe un programa que solicite al usuario ingresar un número de mes (1 para enero, 2 para febrero, etc.) y determine la cantidad de días que tiene ese mes. Imprime un mensaje indicando la cantidad de días del mes ingresado. Ten en cuenta si el año es bisiesto (puedes asumir que el año actual es bisiesto).

Ejercicio 9

Crea una enumeración llamada DiasLaborables que represente los días laborables de la semana (Lunes, Martes, Miércoles, Jueves, Viernes). Luego, escribe un programa que solicite al usuario ingresar un día y muestre un mensaje indicando si es un día laborable o no.

Ejercicio 10

Crea una enumeración llamada EstacionesAnio que represente las estaciones del año (Primavera, Verano, Otoño, Invierno). Luego, escribe un programa que solicite al usuario ingresar un mes (1 para enero, 2 para febrero, etc.) y determine la estación correspondiente. Imprime un mensaje indicando la estación del año según el mes ingresado.

Ejercicio 11

Crea un enum llamado "DiasSemana" que represente los días de la semana (Lunes, Martes, Miércoles, Jueves, Viernes, Sábado, Domingo). Luego, escribe un programa que recorra todos los días de la semana e imprima un mensaje indicando si es laborable o no.

Ejercicio 12

Define un enum llamado "Meses" que represente los meses del año (Enero, Febrero, Marzo, ..., Diciembre). Luego, implementa un método en el enum que devuelva la cantidad de días de cada mes, considerando si es un año bisiesto o no.

Ejercicio 13

Crea un enum llamado "Colores" que represente algunos colores básicos (Rojo, Verde, Azul, Amarillo, Blanco, Negro). Luego, escribe un programa que solicite al usuario ingresar un color y muestre un mensaje indicando si es un color primario (Rojo, Verde, Azul) o un color secundario (Amarillo, Blanco, Negro).

Ejercicio 14

Crea un enum llamado "Estaciones" que represente las estaciones del año (Primavera, Verano, Otoño, Invierno). Luego, escribe un programa que solicite al usuario ingresar una estación y muestre un mensaje indicando cuántos meses dura esa estación.

Ejercicio 15

Crea un enum llamado "DiasLaborales" que represente los días de la semana laborables (Lunes, Martes, Miércoles, Jueves, Viernes). Implementa un método en el enum que devuelva el número correspondiente al día de la semana, donde Lunes sea 1 y Viernes sea 5.

Ejercicio 16

Implementa un programa en Java que gestione una lista de vehículos utilizando un enum para clasificar los tipos de vehículos. El programa debe incluir las siguientes funcionalidades: Definición del enum: Crea un enum llamado TipoVehiculo que tenga los valores: COCHE MOTO CAMION BICICLETA Clase Vehiculo: Diseña una clase Vehiculo con los siguientes atributos: String marca String modelo TipoVehiculo tipo (utilizando el enum) Además, implementa un constructor para inicializar los vehículos, junto con métodos toString para mostrar la información del vehículo. Menú del Programa: El programa debe permitir al usuario realizar las siguientes operaciones: Agregar vehículo: Solicita los datos (marca, modelo, tipo) al usuario y añade un nuevo vehículo a la lista. Listar vehículos por tipo: Solicita al usuario un tipo de vehículo y muestra todos los vehículos que pertenezcan a ese tipo. Mostrar todos los vehículos: Muestra todos los vehículos de la lista. Salir: Termina el programa. Validaciones: Asegúrate de que el usuario solo pueda introducir valores válidos para el tipo de vehículo. No se permite agregar vehículos duplicados (marca, modelo y tipo idénticos).

package enums;

import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio16 {

	/* Clase principal que inicializa y muestra el menú */
	public static void main(String[] args) {
		MenuEjercicio16 menu = new MenuEjercicio16();
		menu.mostrarMenu();
	}
}

/* Enum que define los tipos de vehículos posibles */
enum TipoVehiculo {
	COCHE("Coche"),
	MOTO("Moto"),
	CAMION("Camion"),
	BICICLETA("Bicicleta");

	private String Vehiculo; // Campo para almacenar el nombre del tipo de vehículo

	/* Constructor del enum que inicializa el nombre del vehículo */
	TipoVehiculo(String vehiculo) {
		this.Vehiculo = vehiculo;
	}

	/* Método para obtener el nombre del vehículo */
	public String getVehiculo() {
		return Vehiculo;
	}
}

/* Clase que representa un vehículo */
class Vehiculo {

	/* Lista estática para almacenar todos los vehículos creados */
	private static ArrayList<Vehiculo> listaVehiculos = new ArrayList<Vehiculo>();

	private String marca, modelo; // Atributos del vehículo
	private TipoVehiculo tipo;    // Tipo de vehículo basado en el enum

	/* Constructor vacío */
	public Vehiculo() {
	}

	/* Constructor que inicializa los atributos del vehículo */
	public Vehiculo(String marca, String modelo, TipoVehiculo tipo) {
		this.marca = marca;
		this.modelo = modelo;
		this.tipo = tipo;
	}

	/* Métodos getter y setter para los atributos */
	public String getMarca() {
		return marca;
	}

	public void setMarca(String marca) {
		this.marca = marca;
	}

	public String getModelo() {
		return modelo;
	}

	public void setModelo(String modelo) {
		this.modelo = modelo;
	}

	public TipoVehiculo getTipo() {
		return tipo;
	}

	public void setTipo(TipoVehiculo tipo) {
		this.tipo = tipo;
	}

	/* Método para mostrar la información del vehículo en formato String */
	@Override
	public String toString() {
		return "Vehiculo [marca=" + marca + ", modelo=" + modelo + ", tipo=" + tipo + "]";
	}

	/* Método auxiliar para solicitar texto al usuario con validación */
	private String campoTexto(Scanner entrada, String texto) {
		String dato = "";
		while (true) {
			System.out.println("Introduce " + texto + " del vehiculo");
			dato = entrada.nextLine();

			if (dato.trim().isEmpty()) {
				System.out.println("El campo " + texto + " no puede quedar vacio, introducelo de nuevo");
			} else {
				return dato;
			}
		}
	}

	/* Método para comprobar si un tipo de vehículo ingresado es válido */
	private boolean comprobarTipo(String tipoVehiculo) {
		TipoVehiculo tipos[] = TipoVehiculo.values();

		for (TipoVehiculo tipoVehiculo2 : tipos) {
			if (tipoVehiculo2.getVehiculo().equalsIgnoreCase(tipoVehiculo)) {
				return true;
			}
		}
		return false;
	}

	/* Método para agregar un vehículo a la lista */
	public void agregarVehiculos(Scanner entrada) {
		String tipoVehiculo = "";
		this.marca = campoTexto(entrada, "marca");
		this.modelo = campoTexto(entrada, "modelo");

		// Validar y asignar el tipo de vehículo
		while (!comprobarTipo(tipoVehiculo)) {
			tipoVehiculo = campoTexto(entrada, "tipo");
			if (comprobarTipo(tipoVehiculo)) {
				this.tipo = TipoVehiculo.valueOf(tipoVehiculo.toUpperCase());
			} else {
				System.out.println("No existe ese tipo de vehículo, introdúcelo de nuevo.");
			}
		}

		// Verificar si el vehículo ya existe en la lista
		boolean existe = false;
		for (Vehiculo vehiculo : listaVehiculos) {
			if (vehiculo.getMarca().equalsIgnoreCase(this.marca) && vehiculo.getModelo().equalsIgnoreCase(this.modelo)
					&& vehiculo.getTipo().getVehiculo().equalsIgnoreCase(tipoVehiculo)) {
				System.out.println("El tipo de vehiculo ya esta dado de alta");
				existe = true;
			}
		}

		// Agregar el vehículo si no existe
		if (!existe) {
			Vehiculo vehiculo = new Vehiculo(this.marca, this.modelo, this.tipo);
			listaVehiculos.add(vehiculo);
			System.out.println("Vehidulo dado de alta correctamente");
		}
	}

	/* Método para mostrar todos los vehículos en la lista */
	public void mostrarVehiculos() {
		if (listaVehiculos.isEmpty()) {
			System.out.println("No hay vehiculos en la lista");
		} else {
			for (Vehiculo vehiculo : listaVehiculos) {
				System.out.println(vehiculo);
			}
		}
	}

	/* Método para mostrar los vehículos de un tipo específico */
	public void mostrarVehiculosTipo(Scanner entrada) {
		if (listaVehiculos.isEmpty()) {
			System.out.println("No hay vehiculos en la lista");
		} else {
			String tipoVehiculo = "";
			while (!comprobarTipo(tipoVehiculo)) {
				tipoVehiculo = campoTexto(entrada, "tipo");
				if (comprobarTipo(tipoVehiculo)) {
					TipoVehiculo tipo = TipoVehiculo.valueOf(tipoVehiculo.toUpperCase());
					for (Vehiculo vehiculo : listaVehiculos) {
						if (vehiculo.getTipo() == tipo) {
							System.out.println(vehiculo);
						}
					}
				} else {
					System.out.println("No existe ese tipo de vehículo, introdúcelo de nuevo.");
				}
			}
		}
	}
}

/* Clase para manejar el menú de operaciones */
class MenuEjercicio16 {
	Scanner entrada = new Scanner(System.in); // Scanner para leer la entrada del usuario
	int menu = 0; // Opción del menú
	Vehiculo vehiculo = new Vehiculo(); // Instancia de la clase Vehiculo

	/* Método para mostrar el menú principal */
	public void mostrarMenu() {
		do {
			System.out.println("Menu vehiculos");
			System.out.println("1.Agregar vehiculo");
			System.out.println("2.Listar vehiculos por tipo");
			System.out.println("3.Listar todos los vehiculos");
			System.out.println("4.Salir");
			System.out.println("Escoge opcion:");

			try {
				menu = Integer.parseInt(entrada.nextLine()); // Leer la opción del usuario
				gestionarMenu(menu); // Llamar al método correspondiente según la opción
			} catch (NumberFormatException e) {
				System.err.println("Formato de menu no valido, introducelo de nuevo");
			}
		} while (menu != 4); // Repetir hasta que el usuario elija salir
	}

	/* Método para gestionar las operaciones del menú */
	private void gestionarMenu(int menu) {
		switch (menu) {
		case 1 -> vehiculo.agregarVehiculos(entrada); // Agregar vehículo
		case 2 -> vehiculo.mostrarVehiculosTipo(entrada); // Mostrar vehículos por tipo
		case 3 -> vehiculo.mostrarVehiculos(); // Mostrar todos los vehículos
		case 4 -> {
			System.out.println("Saliendo del programa ...");
			entrada.close(); // Cerrar el scanner al salir
		}
		default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
		}
	}
}

Ejercicio 17

Crea un programa que enumere las estaciones del año y permita al usuario seleccionar una para mostrar un mensaje específico relacionado con esa estación. Detalles del enunciado: Define un enum llamado Estacion con las siguientes constantes: PRIMAVERA, VERANO, OTOÑO, INVIERNO. Cada constante del enum debe tener una descripción, como "Tiempo de flores", "Tiempo de playa", etc. En el programa principal: Muestra al usuario una lista de estaciones. Permite al usuario ingresar el nombre de una estación. Según la entrada, imprime la descripción de la estación elegida. Si el usuario introduce un nombre no válido, muestra un mensaje de error.

/* Crea un programa que enumere las estaciones del año y permita al usuario seleccionar una 
   para mostrar un mensaje específico relacionado con esa estación.

   Detalles del enunciado:
   - Define un enum llamado Estacion con las siguientes constantes: PRIMAVERA, VERANO, OTOÑO, INVIERNO.
   - Cada constante del enum debe tener una descripción, como "Tiempo de flores", "Tiempo de playa", etc.
   - En el programa principal:
       - Muestra al usuario una lista de estaciones.
       - Permite al usuario ingresar el nombre de una estación.
       - Según la entrada, imprime la descripción de la estación elegida.
       - Si el usuario introduce un nombre no válido, muestra un mensaje de error.
*/

package enums;

import java.util.Scanner;

public class Ejercicio17 {

    public static void main(String[] args) {
        // Obtener todas las estaciones definidas en el enum
        Estacion[] estaciones = Estacion.values();
        int index = 0; // Variable para enumerar las estaciones en la lista
        String estacionUsuario = ""; // Almacena la entrada del usuario
        Scanner entrada = new Scanner(System.in); // Scanner para la entrada de datos

        // Mostrar la lista de estaciones disponibles al usuario
        System.out.println("Lista de estaciones");
        for (Estacion estacion : estaciones) {
            index++;
            System.out.println(index + "." + estacion.name().toLowerCase()); // Mostrar el nombre en minúsculas
        }

        // Solicitar al usuario que ingrese el nombre de una estación
        while (true) {
            System.out.println("Introduce el nombre de una estacion");
            estacionUsuario = entrada.nextLine(); // Leer la entrada del usuario
            
            // Verificar si la entrada está vacía
            if (estacionUsuario.trim().isEmpty()) {
                System.out.println("El nombre de la estacion no puede quedar vacio, introducelo de nuevo");
            } else {
                break; // Salir del bucle si la entrada no está vacía
            }
        }

        // Variable para verificar si la estación ingresada existe
        boolean existe = false;

        // Comparar la entrada del usuario con las estaciones del enum
        for (Estacion estacion : estaciones) {
            if (estacion.name().equalsIgnoreCase(estacionUsuario)) { // Ignorar mayúsculas y minúsculas
                // Mostrar la descripción de la estación seleccionada
                System.out.println("En " + estacion.name().toLowerCase() + " es " + estacion.getDecripcion());
                existe = true; // Indicar que la estación fue encontrada
                break; // Salir del bucle si la estación es válida
            }
        }

        // Si la estación no existe, mostrar un mensaje de error
        if (!existe) {
            System.out.println("La estacion no existe");
        }

        // Cerrar el recurso Scanner
        entrada.close();
    }
}

// Definición del enum Estacion con descripciones para cada estación
enum Estacion {
    PRIMAVERA("tiempo de flores"),
    VERANO("tiempo de playa y piscina con cervezas"),
    OTOÑO("tiempo de castañas"),
    INVIERNO("tiempo de caldo de marisco caliente");

    // Campo para almacenar la descripción de cada estación
    private String decripcion;

    // Constructor para inicializar la descripción de la estación
    Estacion(String descripcion) {
        this.decripcion = descripcion;
    }

    // Método para obtener la descripción de la estación
    public String getDecripcion() {
        return decripcion;
    }
}

Ejercicio 18

Crea un enum llamado DiaDeLaSemana que represente los días de la semana (de lunes a domingo). Cada día debe tener una propiedad tipo que puede ser "laboral" o "fin de semana". Además, implementa un método que devuelva una lista de todos los días laborales y otra lista de los fines de semana. Define el enum con los días de la semana y la propiedad tipo. Crea un método diasLaborales() que devuelva los días laborales (lunes a viernes). Crea un método finDeSemana() que devuelva los días del fin de semana (sábado y domingo). En el main(), muestra por consola los días laborales y los fines de semana utilizando los métodos creados.

package enums;

public class Ejercicio18 {

    public static void main(String[] args) {
        // Llama al método para mostrar los días laborales
        DiaDeLaSemana.diasLaborales();

        // Llama al método para mostrar los días del fin de semana
        DiaDeLaSemana.finDeSemana();
    }
}

// Enum que representa los días de la semana
enum DiaDeLaSemana {
    LUNES(true),    // Lunes es un día laboral
    MARTES(true),   // Martes es un día laboral
    MIERCOLES(true),// Miércoles es un día laboral
    JUEVES(true),   // Jueves es un día laboral
    VIERNES(true),  // Viernes es un día laboral
    SABADO(false),  // Sábado es un fin de semana
    DOMINGO(false); // Domingo es un fin de semana

    // Propiedad que indica si es un día laboral (true) o de fin de semana (false)
    private boolean tipo;

    // Constructor del enum que asigna el tipo a cada día
    DiaDeLaSemana(boolean tipo) {
        this.tipo = tipo;
    }

    // Método estático que imprime los días laborales
    public static void diasLaborales() {
        // Obtiene todos los días del enum
        DiaDeLaSemana[] dias = DiaDeLaSemana.values();

        // Itera a través de los días y muestra los laborales
        for (DiaDeLaSemana diaDeLaSemana : dias) {
            if (diaDeLaSemana.tipo) {  // Si es un día laboral
                // Imprime el nombre del día en minúsculas seguido de la descripción
                System.out.println(diaDeLaSemana.name().toLowerCase() + " es laborable");
            }
        }
    }

    // Método estático que imprime los días de fin de semana
    public static void finDeSemana() {
        // Obtiene todos los días del enum
        DiaDeLaSemana[] dias = DiaDeLaSemana.values();

        // Itera a través de los días y muestra los del fin de semana
        for (DiaDeLaSemana diaDeLaSemana : dias) {
            if (!diaDeLaSemana.tipo) {  // Si no es un día laboral, es fin de semana
                // Imprime el nombre del día en minúsculas seguido de la descripción
                System.out.println(diaDeLaSemana.name().toLowerCase() + " no es laborable");
            }
        }
    }
}

Ejercicio 19

Crea un enum llamado NivelDeAcceso que represente tres niveles de acceso para un sistema: ADMIN, USUARIO y VISITANTE. Cada nivel debe tener una propiedad descripcion que describa el nivel de acceso. Define el enum con los tres niveles de acceso y su propiedad descripcion. Implementa un método esAltaSeguridad() que devuelva true si el nivel de acceso es ADMIN y false en caso contrario. En el main(), muestra por consola los niveles de acceso y si requieren alta seguridad, utilizando el método esAltaSeguridad().

package enums;

import java.util.ArrayList;

public class Ejercicio19 {

    public static void main(String[] args) {
        
        // Crear instancias de los diferentes niveles de acceso
        NivelDeAcceso nivelUno = NivelDeAcceso.ADMIN; // Nivel de acceso ADMIN
        NivelDeAcceso nivelDos = NivelDeAcceso.USUARIO; // Nivel de acceso USUARIO
        NivelDeAcceso nivelTres = NivelDeAcceso.VISITANTE; // Nivel de acceso VISITANTE
        
        // Crear una lista de usuarios con los diferentes niveles de acceso
        ArrayList<NivelDeAcceso> listaUsuarios = new ArrayList<NivelDeAcceso>();
        listaUsuarios.add(nivelUno);  // Agregar nivel ADMIN a la lista
        listaUsuarios.add(nivelDos);  // Agregar nivel USUARIO a la lista
        listaUsuarios.add(nivelTres); // Agregar nivel VISITANTE a la lista
        
        // Iterar sobre la lista de usuarios para verificar si requieren alta seguridad
        for (NivelDeAcceso nivelDeAcceso : listaUsuarios) {
            // Llamar al método esAltaSeguridad para verificar si el nivel es de alta seguridad
            if (nivelDeAcceso.esAltaSeguridad()) {
                // Si es ADMIN, imprimir "Es admin"
                System.out.println("Es admin");
            } else {
                // Si no es ADMIN, imprimir "No es admin"
                System.out.println("No es admin");
            }
        }

    }

}

// Definición del enum NivelDeAcceso
enum NivelDeAcceso {
    // Definir los tres niveles de acceso con su respectiva descripción
    ADMIN("Administrador del sistema"),
    USUARIO("Usuario del sistema"),
    VISITANTE("Visitante sin privilegios");
    
    private String descripcion; // Propiedad para almacenar la descripción de cada nivel
    
    // Constructor para asignar la descripción a cada nivel de acceso
    NivelDeAcceso(String descripcion) {
        this.descripcion = descripcion;
    }

    // Método para obtener la descripción del nivel de acceso
    public String getDescripcion() {
        return descripcion;
    }
    
    // Método para verificar si el nivel de acceso requiere alta seguridad
    public boolean esAltaSeguridad() {
        // Si el nivel es ADMIN, se considera de alta seguridad
        if (this == ADMIN) {
            System.out.println(getDescripcion()); // Imprimir la descripción del nivel
            return true; // Retornar true si es ADMIN
        } else {
            System.out.println(getDescripcion()); // Imprimir la descripción del nivel
            return false; // Retornar false si no es ADMIN
        }
    }
}

Ejercicio 20

Crea un enum llamado Estacion que represente las cuatro estaciones del año: Primavera, Verano, Otoño e Invierno. Cada estación debe tener una propiedad descripcion que indique si es una estación cálida o fría. Define el enum con las estaciones y su respectiva descripción. Implementa un método esCálida() que devuelva true si la estación es cálida (Primavera o Verano) y false en caso contrario. En el main(), crea una lista de las estaciones y muestra por consola las estaciones cálidas y frías, utilizando el método esCálida() para determinarlo.

package enums;

import java.util.ArrayList;

public class Ejercicio20 {

    public static void main(String[] args) {
        // Se crean las estaciones utilizando el enum Estaciones
        Estaciones primavera = Estaciones.PRIMAVERA;  // Estación Primavera
        Estaciones verano = Estaciones.VERANO;        // Estación Verano
        Estaciones otoño = Estaciones.OTOÑO;          // Estación Otoño
        Estaciones invierno = Estaciones.INVIERNO;    // Estación Invierno

        // Se crea una lista para almacenar las estaciones
        ArrayList<Estaciones> listaEstaciones = new ArrayList<Estaciones>();
        listaEstaciones.add(primavera);  // Se agrega Primavera
        listaEstaciones.add(verano);     // Se agrega Verano
        listaEstaciones.add(otoño);     // Se agrega Otoño
        listaEstaciones.add(invierno);  // Se agrega Invierno

        // Se itera sobre la lista para determinar si cada estación es cálida o fría
        for (Estaciones estacion : listaEstaciones) {
            // Se verifica si la estación es cálida utilizando el método esCalida()
            if (estacion.esCalida()) {
                System.out.println("La estación es cálida");
            } else {
                System.out.println("La estación es fría");
            }
        }
    }
}

/* 
 * Enum Estaciones que representa las cuatro estaciones del año con su descripción.
 * Cada estación tiene una descripción que indica si es cálida o fría.
 */
enum Estaciones {
    PRIMAVERA("Cálida"),  // Primavera es cálida
    VERANO("Cálida"),     // Verano es cálido
    OTOÑO("Fría"),        // Otoño es frío
    INVIERNO("Fría");     // Invierno es frío

    private String descripcion;  // Propiedad para almacenar la descripción

    // Constructor que inicializa la descripción de la estación
    Estaciones(String descripcion) {
        this.descripcion = descripcion;
    }

    // Método que devuelve la descripción de la estación
    public String getDescripcion() {
        return descripcion;
    }

    // Método que verifica si la estación es cálida
    // Devuelve true si la estación es Primavera o Verano, false si es Otoño o Invierno
    public boolean esCalida() {
        return this.getDescripcion().equals("Cálida");  // Compara la descripción con "Cálida"
    }
}