Carlos Fernández García

Ejercicio 1

Crea una clase abstracta llamada FiguraGeometrica que represente una figura geométrica. La clase debe tener un atributo llamado nombre y un método abstracto calcularArea(). Luego, crea dos clases derivadas llamadas Circulo y Rectangulo que hereden de la clase FiguraGeometrica. La clase Circulo debe tener atributos adicionales radio y la clase Rectangulo debe tener atributos adicionales base y altura. Implementa el método calcularArea() en ambas clases derivadas para que calcule y retorne el área correspondiente a cada tipo de figura geométrica (fórmula del área del círculo y del rectángulo). En el método main, instancia al menos un objeto de cada clase derivada con información diferente y muestra en la consola el nombre de la figura y su área correspondiente.

Ejercicio 2

Crea una clase abstracta llamada Animal que represente a diferentes tipos de animales. La clase debe tener un atributo llamado nombre y un método abstracto llamado hacerSonido() que represente el sonido característico del animal. Luego, crea al menos dos clases derivadas de Animal: Perro y Gato. Cada una de estas clases debe implementar el método abstracto hacerSonido() para representar los sonidos típicos de un perro y un gato. En el método main, instancia al menos un objeto de cada clase derivada (Perro y Gato) con información diferente y muestra en la consola el nombre del animal y el sonido que hace. Este enunciado te permitirá practicar la creación de clases abstractas y la implementación de métodos abstractos para representar comportamientos específicos en las clases derivadas.

Ejercicio 3

Crea una clase abstracta llamada Figura que represente diferentes formas geométricas. La clase debe tener un atributo llamado nombre y dos métodos abstractos: calcularArea() y calcularPerimetro(). Luego, crea dos clases derivadas de Figura: Circulo y Rectangulo. La clase Circulo debe tener un atributo adicional radio, y la clase Rectangulo debe tener atributos adicionales base y altura. Implementa los métodos abstractos calcularArea() y calcularPerimetro() en ambas clases derivadas para que calcule y retorne el área y el perímetro correspondientes a cada tipo de figura geométrica. En el método main, instancia al menos un objeto de cada clase derivada (Circulo y Rectangulo) con información diferente y muestra en la consola el nombre de la figura, su área y su perímetro.

package abs;

public abstract class Figura {
	private String nombre;
	
	public Figura(String nombre) {
		this.nombre=nombre;
	}
	
	public String getNombre() {//getter
		return this.nombre;
	}
	
	public void setNombre(String nombre) {
		this.nombre=nombre;
	}
	
	public abstract double calcularArea();
	public abstract double calcularPerimetro();
	
	public String mostrarInfo() {
		return "El area de " + this.nombre + " es " +String.format("%.2f",calcularArea()) + 
				" y el perimetro es "+ String.format("%.2f",calcularPerimetro());
	}
	
	public static void main(String[] args) {
		Circulos c=new Circulos("circulillo",3.45);
		Rectangulos r=new Rectangulos("rectangulillo",5.43,6.57);
		
		
		System.out.println(c.mostrarInfo());
		System.out.println(r.mostrarInfo());

	}

}


class Circulos extends Figura {
	
	private double radio;
	
	public Circulos(String nombre,double radio) {
		super(nombre);
		this.radio=radio;
	}
	
	public double getRadio() {//getter
		return this.radio;
	}
	
	public void setRadio(double radio) {
		this.radio=radio;
	}
	
	public double calcularArea() {
		return (Math.PI*Math.pow(this.radio,2));
	}
	public double calcularPerimetro() {
		return (2*Math.PI*this.radio);
	}
	
	public String mostrarInfo() {
		return super.mostrarInfo();
	}
}

class Rectangulos extends Figura {
	
	private double base,altura;
	
	public Rectangulos(String nombre,double base,double altura) {
		super(nombre);
		this.base=base;
		this.altura=altura;
	}
	
	public double getBase() {//getter
		return this.base;
	}
	
	public double getAltura() {//getter
		return this.altura;
	}
	
	public void setBase(double Base) {//setter
		this.base=base;
	}
	public void setAltura(double altura) {//setter
		this.altura=altura;
	}
	
	public double calcularArea() {
		return (this.base*this.altura);
	}
	public double calcularPerimetro() {
		return ((2*this.base)+(2*this.altura));
	}
	
	public String mostrarInfo() {
		return super.mostrarInfo();
	}
}

Ejercicio 4

Crea una clase abstracta llamada Mueble que represente diferentes tipos de muebles. La clase debe tener un atributo llamado nombre y dos métodos abstractos: calcularPrecio() y descripcion(). El método calcularPrecio() debe calcular y retornar el precio del mueble, mientras que descripcion() debe mostrar una descripción del mueble. Luego, crea dos clases derivadas de Mueble: Silla y Mesa. La clase Silla debe tener un atributo adicional llamado material y la clase Mesa debe tener un atributo adicional llamado numPatas. Implementa los métodos abstractos calcularPrecio() y descripcion() en ambas clases derivadas para que calcule y retorne el precio y muestre una descripción correspondiente a cada tipo de mueble. En el método main, instancia al menos un objeto de cada clase derivada (Silla y Mesa) con información diferente y muestra en la consola el nombre del mueble, su descripción y su precio.

Ejercicio 5

Crea un sistema de gestión de empleados utilizando clases abstractas. La clase principal abstracta será Empleado, de la cual heredarán dos clases concretas: EmpleadoTemporal y EmpleadoPermanente. Luego, cada una de estas clases tendrá dos subclases adicionales llamadas EmpleadoContratista y EmpleadoFijo. La clase Empleado debe tener los siguientes atributos: nombre, edad y salarioBase. Además, debe tener un método abstracto llamado calcularSalario() que calculará el salario final del empleado. La clase EmpleadoTemporal debe tener un atributo adicional llamado diasTrabajados. Implementa el método calcularSalario() para calcular el salario multiplicando los días trabajados por un valor fijo diario. La clase EmpleadoPermanente debe tener un atributo adicional llamado antiguedad. Implementa el método calcularSalario() para calcular el salario sumando un extra por cada año de antigüedad. Las subclases EmpleadoContratista y EmpleadoFijo deben heredar de EmpleadoTemporal y EmpleadoPermanente, respectivamente. Además, cada una debe tener atributos adicionales específicos (proyecto para EmpleadoContratista y departamento para EmpleadoFijo). Implementa los métodos calcularSalario() en cada subclase para considerar estos atributos. En el método main, instancia al menos un objeto de cada clase (incluyendo las subclases) con información diferente y muestra en la consola la información completa de cada empleado, incluido su salario final.

package abs;

import java.util.Scanner;

public abstract class Empleado {
	private String nombre;
	private int edad;
	private double salarioBase;
	
	public Empleado(String nombre,int edad,double salarioBase) {
		this.nombre=nombre;
		this.edad=edad;
		this.salarioBase=salarioBase;
	}
	
	public String getNombre() {//getter
		return this.nombre;
	}
	
	public int getEdad() {//getter
		return this.edad;
	}
	
	public double getSalarioBase() {//getter
		return this.salarioBase;
	}
	
	public void setNombre(String nombre) {//setter
		this.nombre=nombre;
	}
	
	public void setEdad(int edad) {//setter
		this.edad=edad;
	}
	
	public void setSalarioBase(double salarioBase) {//setter
		this.salarioBase=salarioBase;
	}
	
	public abstract double calcularSalario();
	public abstract String mostrarInfo(); 
	public static void main(String[] args) {
		EmpleadoTemporal empleadoTemporal=new EmpleadoTemporal("Manolo",56,1500,23);
		EmpleadoPermanente empleadoPermanente=new EmpleadoPermanente("Maria",43,1800,12);
		EmpleadoContratista empleadoContratista=new EmpleadoContratista("Jacinto",63,1200,14,"reformar escalera");
		EmpleadoFijo empleadoFijo=new EmpleadoFijo("Elena",26,1900,4,"administrativa");
		
		Empleado[] empleado=new Empleado[4];
		empleado[0]=empleadoTemporal;
		empleado[1]=empleadoPermanente;
		empleado[2]=empleadoContratista;
		empleado[3]=empleadoFijo;
		
		
		for(Empleado e:empleado) {
			if(e!=null) {
				System.out.println(e.mostrarInfo());
			}
		}
		
	}

}
class EmpleadoTemporal extends Empleado{
	private int diasTrabajados;
	public EmpleadoTemporal(String nombre,int edad,double salarioBase,int diasTrabajados) {
		super(nombre,edad,salarioBase);
		this.diasTrabajados=diasTrabajados;
	}
	
	public int getDiasTrabajados() {//getter
		return this.diasTrabajados;
	}
	
	public void setDiasTrabajados(int diasTrabajados) {//setter
		this.diasTrabajados=diasTrabajados;
	}
	
	public double calcularSalario() {
		double precioDia=75;
		
		return (this.diasTrabajados*precioDia);
	}
	public String mostrarInfo() {
		return "\nNombre: " + super.getNombre() +
				"\nEdad: " + super.getEdad() +
				"\nSalario Base: " + String.format("%.2f", super.getSalarioBase()) +
				"\nDias Trabajados : " + this.diasTrabajados +
				"\nSalario total " + String.format("%.2f", this.calcularSalario());
	}
}

class EmpleadoPermanente extends Empleado{
	private int antiguedad;
	public EmpleadoPermanente(String nombre,int edad,double salarioBase,int antiguedad) {
		super(nombre,edad,salarioBase);
		this.antiguedad=antiguedad;
	}
	
	public int getAntiguedad() {//getter
		return this.antiguedad;
	}
	
	public void setAntiguedad(int antiguedad) {//setter
		this.antiguedad=antiguedad;
	}
	
	public double calcularSalario() {
		double anios=75;
		
		return (super.getSalarioBase()+(this.antiguedad*anios));
	}
	
	public String mostrarInfo() {
		return "\nNombre: " + super.getNombre() +
				"\nEdad: " + super.getEdad() +
				"\nSalario Base: " + String.format("%.2f", super.getSalarioBase()) +
				"\nAntigüedad : " + this.antiguedad +
				"\nSalario total " + String.format("%.2f", this.calcularSalario());
	}
}
class EmpleadoContratista extends EmpleadoTemporal{
	private String proyecto;
	public EmpleadoContratista(String nombre,int edad,double salarioBase,int diasTrabajados,String proyecto) {
		super(nombre,edad,salarioBase,diasTrabajados);
		this.proyecto=proyecto;
	}
	
	public String getProyecto() {//getter
		return this.proyecto;
	}
	
	public void setProyecto(String proyecto) {//setter
		this.proyecto=proyecto;
	}
	
	public double calcularSalario() {
		double incentivoProyecto=75;
		
		return (super.calcularSalario()+incentivoProyecto);
	}
	public String mostrarInfo() {
		return "\nNombre: " + super.getNombre() +
				"\nEdad: " + super.getEdad() +
				"\nSalario Base: " + String.format("%.2f", super.getSalarioBase()) +
				"\nProyecto : " + this.proyecto +
				"\nSalario total " + String.format("%.2f", this.calcularSalario());
	}
}


class EmpleadoFijo extends EmpleadoPermanente{
	private String departamento;
	public EmpleadoFijo(String nombre,int edad,double salarioBase,int antiguedad,String departamento) {
		super(nombre,edad,salarioBase,antiguedad);
		this.departamento=departamento;
	}
	
	public String getDepartamento() {//getter
		return this.departamento;
	}
	
	public void setDepartamento(String departamento) {//setter
		this.departamento=departamento;
	}
	
	public double calcularSalario() {
		double plusDepartamento=150;
		
		return (super.calcularSalario()+plusDepartamento);
	}
	public String mostrarInfo() {
		return "\nNombre: " + super.getNombre() +
				"\nEdad: " + super.getEdad() +
				"\nSalario Base: " + String.format("%.2f", super.getSalarioBase()) +
				"\nDepartamento : " + this.departamento +
				"\nSalario total " + String.format("%.2f", this.calcularSalario());
	}
}

Ejercicio 6

EJEMPLO INTERFACE Crea un programa en Java que modele figuras geométricas. Define una interfaz llamada Figura que contenga dos métodos abstractos: calcularArea() y calcularPerimetro(). Luego, implementa esta interfaz en al menos dos clases: Circulo y Rectangulo. La clase Circulo debe tener un constructor que reciba el radio como parámetro, mientras que la clase Rectangulo debe tener un constructor que reciba la longitud y la anchura. En el programa principal, instancia un objeto de cada clase, calcula y muestra en la consola el área y el perímetro de cada figura geométrica. Este ejercicio te permitirá practicar la creación de interfaces, implementación de métodos abstractos y uso de clases concretas.

Ejercicio 7

Desarrolla un sistema de gestión de empleados que haga uso de clases abstractas en Java. El sistema debe tener las siguientes clases: Empleado: Esta clase abstracta representa a un empleado genérico e incluye los siguientes atributos: Nombre Edad Salario Además, debe tener un método abstracto llamado calcularSueldo() que deberá ser implementado por las clases concretas que hereden de esta clase. EmpleadoTemporal: Esta clase hereda de Empleado y representa a un empleado contratado temporalmente. Debe incluir los siguientes atributos adicionales: Duración del contrato (en meses) El método calcularSueldo() para este tipo de empleado deberá calcular el salario multiplicando la duración del contrato por un salario base mensual. EmpleadoPermanente: Esta clase hereda de Empleado y representa a un empleado contratado permanentemente. Debe incluir los siguientes atributos adicionales: Departamento El método calcularSueldo() para este tipo de empleado deberá calcular el salario sumando un bono adicional al salario base. Implementa un programa principal que permita crear empleados temporales y permanentes, ingresar los datos necesarios y obtener información sobre cada empleado, incluyendo su salario.

package abstraccion;

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

public class Ejercicio7 {
	public static void main(String[] args) {
	EmpleadoTemporal empleado1=new EmpleadoTemporal("Carlos",42,1500,23);
	
	EmpleadoPermanente empleado2=new EmpleadoPermanente("Maria",35,1800,"Marketing");
	
	ArrayList<Emple> empleados=new ArrayList<Emple>();
	
	empleados.add(empleado1);
	empleados.add(empleado2);
	
	for (Emple emple : empleados) {
		System.out.println(emple.toString());
	}
	
	for (Emple emple : empleados) {
		emple.calcularSueldo();
	}
	
	}
	
}

abstract class Emple{
	protected String nombre;
	protected int edad;
	protected double salario;
	
	public Emple(String nombre, int edad, double salario) {
		
		this.nombre = nombre;
		this.edad = edad;
		this.salario = salario;
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @return the edad
	 */
	public int getEdad() {
		return edad;
	}

	/**
	 * @param edad the edad to set
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}

	/**
	 * @return the salario
	 */
	public double getSalario() {
		return salario;
	}

	/**
	 * @param salario the salario to set
	 */
	public void setSalario(double salario) {
		this.salario = salario;
	}

	@Override
	public String toString() {
		
		return "Nombre: " + nombre + "   |   Edad: " + edad + "   |   Salario: " + salario;
	}
	
	public abstract void calcularSueldo();
	
	
}

class EmpleadoTemporal extends Emple{
	private int duracion;

	public EmpleadoTemporal(String nombre, int edad, double salario, int duracion) {
		super(nombre, edad, salario);
		this.duracion = duracion;
	}

	/**
	 * @return the duracion
	 */
	public int getDuracion() {
		return duracion;
	}

	/**
	 * @param duracion the duracion to set
	 */
	public void setDuracion(int duracion) {
		this.duracion = duracion;
	}

	@Override
	public String toString() {
		String cadena=super.toString();
		return cadena + "   |   Duracion: " + duracion;
	}
	
	public void calcularSueldo() {
		System.out.println("El empleado temporal cobra: " + String.format("%.2f",this.getSalario()*duracion));
	}
}

class EmpleadoPermanente extends Emple{
	private String departamento;

	public EmpleadoPermanente(String nombre, int edad, double salario, String departamento) {
		super(nombre, edad, salario);
		this.departamento = departamento;
	}

	/**
	 * @return the departamento
	 */
	public String getDepartamento() {
		return departamento;
	}

	/**
	 * @param departamento the departamento to set
	 */
	public void setDepartamento(String departamento) {
		this.departamento = departamento;
	}

	@Override
	public String toString() {
		String cadena=super.toString();
		return cadena + "  |   Departamento: " + departamento;
	}
	
	public void calcularSueldo() {
		Scanner entrada=new Scanner(System.in);
		double bono;
		while(true) {
			try {
				System.out.println("Introduce el bono");
				bono=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de numero incorrecto");
			}
		}
		
		System.out.println("El sueldo del trabajador es: " + String.format("%.2f", this.getSalario()+bono));
		
		entrada.close();
	}
	
}

Ejercicio 8

Desarrolla un sistema de gestión de figuras geométricas que haga uso de clases abstractas en Java. El sistema debe tener las siguientes clases: Figura: Esta clase abstracta representa a una figura geométrica genérica e incluye los siguientes métodos abstractos: calcularArea(): Debe calcular y devolver el área de la figura. calcularPerimetro(): Debe calcular y devolver el perímetro de la figura. Triangulo: Esta clase hereda de Figura y representa a un triángulo. Debe incluir los siguientes atributos adicionales: Lado1 Lado2 Lado3 Además, debe implementar los métodos abstractos calcularArea() y calcularPerimetro() para calcular el área y el perímetro del triángulo respectivamente. Circulo: Esta clase hereda de Figura y representa a un círculo. Debe incluir los siguientes atributos adicionales: Radio Además, debe implementar los métodos abstractos calcularArea() y calcularPerimetro() para calcular el área y el perímetro del círculo respectivamente. Implementa un programa principal que permita crear objetos de tipo Triangulo y Circulo, ingresar los datos necesarios y obtener información sobre el área y el perímetro de cada figura.

package abstraccion;

public class Ejercicio8 {

	public static void main(String[] args) {
		Triangulo triangulo=new Triangulo(2,3,4);
		Circulo circulo= new Circulo(2.34);
		
		
		System.out.println("El area del triangulo es: " + String.format("%.2f",triangulo.calcularArea()));
		System.out.println("El area del triangulo es: " + String.format("%.2f",triangulo.calcularPerimetro()));
		System.out.println("El area del triangulo es: " + String.format("%.2f",circulo.calcularArea()));
		System.out.println("El area del triangulo es: " + String.format("%.2f",circulo.calcularPerimetro()));
	}

}

abstract class Figura{
	public abstract double calcularArea();
	public abstract double calcularPerimetro();
}

class Triangulo extends Figura{
	private double lado1;
	private double lado2;
	private double lado3;
	
	public Triangulo(double lado1, double lado2, double lado3) {
		
		this.lado1 = lado1;
		this.lado2 = lado2;
		this.lado3 = lado3;
	}

	/**
	 * @return the lado1
	 */
	public double getLado1() {
		return lado1;
	}

	/**
	 * @param lado1 the lado1 to set
	 */
	public void setLado1(double lado1) {
		this.lado1 = lado1;
	}

	/**
	 * @return the lado2
	 */
	public double getLado2() {
		return lado2;
	}

	/**
	 * @param lado2 the lado2 to set
	 */
	public void setLado2(double lado2) {
		this.lado2 = lado2;
	}

	/**
	 * @return the lado3
	 */
	public double getLado3() {
		return lado3;
	}

	/**
	 * @param lado3 the lado3 to set
	 */
	public void setLado3(double lado3) {
		this.lado3 = lado3;
	}

	@Override
	public double calcularArea(){
		double s = (lado1 + lado2 + lado3) / 2;
        return Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3));
	}
	
	@Override
	public double calcularPerimetro(){
		return (lado1+lado2+lado3);
	}
	
	
}

class Circulo extends Figura{
	private double radio;

	public Circulo(double radio) {
		super();
		this.radio = radio;
	}

	/**
	 * @return the radio
	 */
	public double getRadio() {
		return radio;
	}

	/**
	 * @param radio the radio to set
	 */
	public void setRadio(double radio) {
		this.radio = radio;
	}

	@Override
	public double calcularArea() {
		
		return Math.PI*Math.pow(radio,2);
	}

	@Override
	public double calcularPerimetro() {
		
		return 2*Math.PI*radio;
	}
	
	
}

Ejercicio 9

Desarrolla un sistema de gestión de vehículos que haga uso de clases abstractas en Java. El sistema debe tener las siguientes clases: Vehiculo: Esta clase abstracta representa a un vehículo genérico e incluye los siguientes métodos abstractos: calcularVelocidad(): Debe calcular y devolver la velocidad del vehículo. calcularCombustible(): Debe calcular y devolver el consumo de combustible del vehículo. Automovil: Esta clase hereda de Vehiculo y representa a un automóvil. Debe incluir los siguientes atributos adicionales: Marca Modelo Año de fabricación Además, debe implementar los métodos abstractos calcularVelocidad() y calcularCombustible() para calcular la velocidad y el consumo de combustible del automóvil respectivamente. Motocicleta: Esta clase hereda de Vehiculo y representa a una motocicleta. Debe incluir los siguientes atributos adicionales: Marca Modelo Cilindrada Además, debe implementar los métodos abstractos calcularVelocidad() y calcularCombustible() para calcular la velocidad y el consumo de combustible de la motocicleta respectivamente. Implementa un programa principal que permita crear objetos de tipo Automovil y Motocicleta, ingresar los datos necesarios y obtener información sobre la velocidad y el consumo de combustible de cada vehículo.

package abstraccion;

import java.util.Scanner;

public class Ejercicio9 {

	public static void main(String[] args) {
		Automovil auto= new Automovil("Peugeot","206",2003);
		Motocicleta moto= new Motocicleta("Honda","XRS",2012);
		
		
		System.out.println("El coche fue a una velocidad de: " + String.format("%.2f",auto.calcularVelocidad()));
		System.out.println("El coche gasto un combustible de: " + String.format("%.2f",auto.calcularCombustible()));
		System.out.println("La moto fue a una velocidad de: " + String.format("%.2f",moto.calcularVelocidad()));
		System.out.println("La moto gasto un combustible de: " + String.format("%.2f",moto.calcularCombustible()));
	}

}
abstract class Vehiculo{
	abstract double calcularVelocidad();
	abstract double calcularCombustible();
}

class Automovil extends Vehiculo{
	private String marca;
	private String modelo;
	private int anio;
	
	public Automovil(String marca, String modelo, int anio) {
		super();
		this.marca = marca;
		this.modelo = modelo;
		this.anio = anio;
	}

	/**
	 * @return the marca
	 */
	public String getMarca() {
		return marca;
	}

	/**
	 * @param marca the marca to set
	 */
	public void setMarca(String marca) {
		this.marca = marca;
	}

	/**
	 * @return the modelo
	 */
	public String getModelo() {
		return modelo;
	}

	/**
	 * @param modelo the modelo to set
	 */
	public void setModelo(String modelo) {
		this.modelo = modelo;
	}

	/**
	 * @return the anio
	 */
	public int getAnio() {
		return anio;
	}

	/**
	 * @param anio the anio to set
	 */
	public void setAnio(int anio) {
		this.anio = anio;
	}
	
	public double calcularVelocidad() {
		Scanner entrada= new Scanner (System.in);
		double kilometros;
		double horas;
		
		while(true) {
			try {
				System.out.println("¿Cuantos km recorrio?");
				kilometros=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de km incorrecto");
			}
		}
		
		while(true) {
			try {
				System.out.println("¿Cuantas horas le llevo?");
				horas=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de horas incorrecto");
			}
		}
		
		return kilometros/horas;
	}
	
	public double calcularCombustible() {
		Scanner entrada= new Scanner (System.in);
		double kilometros;
		double litrosCien;
		
		while(true) {
			try {
				System.out.println("¿Cuantos km recorrio?");
				kilometros=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de km incorrecto");
			}
		}
		
		while(true) {
			try {
				System.out.println("¿Cuanto gasta el coche a los 100?");
				litrosCien=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de gasto incorrecto");
			}
		}
		
		return (kilometros/100)*litrosCien;
	}
	
}

class Motocicleta extends Vehiculo{
	private String marca;
	private String modelo;
	private int cilindrada;
	
	public Motocicleta(String marca, String modelo, int cilindrada) {
		
		this.marca = marca;
		this.modelo = modelo;
		this.cilindrada = cilindrada;
	}

	/**
	 * @return the marca
	 */
	public String getMarca() {
		return marca;
	}

	/**
	 * @param marca the marca to set
	 */
	public void setMarca(String marca) {
		this.marca = marca;
	}

	/**
	 * @return the modelo
	 */
	public String getModelo() {
		return modelo;
	}

	/**
	 * @param modelo the modelo to set
	 */
	public void setModelo(String modelo) {
		this.modelo = modelo;
	}

	/**
	 * @return the cilindrada
	 */
	public int getCilindrada() {
		return cilindrada;
	}

	/**
	 * @param cilindrada the cilindrada to set
	 */
	public void setCilindrada(int cilindrada) {
		this.cilindrada = cilindrada;
	}
	
	public double calcularVelocidad() {
		Scanner entrada= new Scanner (System.in);
		double kilometros;
		double horas;
		
		while(true) {
			try {
				System.out.println("¿Cuantos km recorrio?");
				kilometros=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de km incorrecto");
			}
		}
		
		while(true) {
			try {
				System.out.println("¿Cuantas horas le llevo?");
				horas=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de horas incorrecto");
			}
		}
		
		return kilometros/horas;
	}
	
	public double calcularCombustible() {
		Scanner entrada= new Scanner (System.in);
		double kilometros;
		double litrosCien;
		
		while(true) {
			try {
				System.out.println("¿Cuantos km recorrio?");
				kilometros=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de km incorrecto");
			}
		}
		
		while(true) {
			try {
				System.out.println("¿Cuanto gasta la moto a los 100?");
				litrosCien=Double.parseDouble(entrada.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de gasto incorrecto");
			}
		}
		
		return (kilometros/100)*litrosCien;
	}
	
	
}

Ejercicio 10

Desarrolla un sistema de gestión de dispositivos electrónicos que haga uso de interfaces en Java. El sistema debe tener las siguientes interfaces y clases: Interfaz Conectable: Esta interfaz define dos métodos abstractos: conectar(): Debe imprimir un mensaje indicando que el dispositivo se ha conectado. desconectar(): Debe imprimir un mensaje indicando que el dispositivo se ha desconectado. Interfaz Recargable: Esta interfaz define un método abstracto: recargarBateria(): Debe imprimir un mensaje indicando que la batería del dispositivo se está recargando. Clase DispositivoElectronico: Esta clase abstracta representa un dispositivo electrónico genérico e implementa la interfaz Conectable. Debe incluir los siguientes atributos: Marca Modelo Año de fabricación Clase Smartphone: Esta clase hereda de DispositivoElectronico e implementa las interfaces Conectable y Recargable. Debe incluir un atributo adicional: SistemaOperativo Clase Portatil: Esta clase hereda de DispositivoElectronico e implementa las interfaces Conectable y Recargable. Debe incluir un atributo adicional: Tamaño de pantalla Implementa un programa principal que permita crear objetos de tipo Smartphone y Portatil, ingresar los datos necesarios y realizar las siguientes acciones para cada dispositivo: Conectar y desconectar. Recargar la batería.

package abstraccion;

public class Ejercicio10 {

	public static void main(String[] args) {
		Smartphone smartphone=new Smartphone("Nokia","sd25",2008,"Android");
		Portatil portatil=new Portatil("Asus","x50",2012,15.6);
		
		smartphone.conectar();
		smartphone.desconectar();
		smartphone.recargarBateria();
		
		portatil.conectar();
		portatil.desconectar();
		portatil.recargarBateria();

	}

}

interface Conectable{
	void conectar();
	void desconectar();
}

interface Recargable{
	void recargarBateria();
	
}

abstract class DispositivoElectronico implements Conectable,Recargable{
	
	private String marca;
	private String modelo;
	private int anio;
			
	public DispositivoElectronico(String marca, String modelo, int anio) {
		super();
		this.marca = marca;
		this.modelo = modelo;
		this.anio = anio;
	}
	
	
	
	/**
	 * @return the marca
	 */
	public String getMarca() {
		return marca;
	}



	/**
	 * @param marca the marca to set
	 */
	public void setMarca(String marca) {
		this.marca = marca;
	}



	/**
	 * @return the modelo
	 */
	public String getModelo() {
		return modelo;
	}



	/**
	 * @param modelo the modelo to set
	 */
	public void setModelo(String modelo) {
		this.modelo = modelo;
	}



	/**
	 * @return the anio
	 */
	public int getAnio() {
		return anio;
	}



	/**
	 * @param anio the anio to set
	 */
	public void setAnio(int anio) {
		this.anio = anio;
	}



	public void conectar() {
		System.out.println("Dispositivo conectado");
	}
	public void desconectar() {
		System.out.println("Dispositivo desconectado");
	}
	public abstract void recargarBateria();
	
}

class Smartphone extends DispositivoElectronico{
	private String sistemaOperativo;

	public Smartphone(String marca, String modelo, int anio, String sistemaOperativo) {
		super(marca, modelo, anio);
		this.sistemaOperativo = sistemaOperativo;
	}

	/**
	 * @return the sistemaOperativo
	 */
	public String getSistemaOperativo() {
		return sistemaOperativo;
	}

	/**
	 * @param sistemaOperativo the sistemaOperativo to set
	 */
	public void setSistemaOperativo(String sistemaOperativo) {
		this.sistemaOperativo = sistemaOperativo;
	}

	@Override
	public void recargarBateria() {
		System.out.println("Smartphone recargando......");
		
	}

	
}

class Portatil extends DispositivoElectronico{
	private double tamanioPantalla;

	public Portatil(String marca, String modelo, int anio, double tamanioPantalla) {
		super(marca, modelo, anio);
		this.tamanioPantalla = tamanioPantalla;
	}

	/**
	 * @return the tamanioPantalla
	 */
	public double getTamanioPantalla() {
		return tamanioPantalla;
	}

	/**
	 * @param tamanioPantalla the tamanioPantalla to set
	 */
	public void setTamanioPantalla(double tamanioPantalla) {
		this.tamanioPantalla = tamanioPantalla;
	}
	
	@Override
	public void recargarBateria() {
		System.out.println("Portatil recargando......");
		
	}

}

Ejercicio 11

Desarrolla un sistema de gestión de cuentas bancarias que haga uso de interfaces en Java. El sistema debe tener las siguientes interfaces y clases: Interfaz CuentaBancaria: Esta interfaz define métodos abstractos para realizar operaciones básicas con una cuenta bancaria: depositar(double cantidad): Debe agregar la cantidad especificada al saldo de la cuenta. retirar(double cantidad): Debe retirar la cantidad especificada del saldo de la cuenta. consultarSaldo(): Debe devolver el saldo actual de la cuenta. Clase CuentaCorriente: Esta clase implementa la interfaz CuentaBancaria y representa una cuenta corriente. Debe incluir un atributo adicional: sobregiro: El límite de sobregiro permitido para la cuenta corriente. Clase CuentaAhorro: Esta clase implementa la interfaz CuentaBancaria y representa una cuenta de ahorro. Debe incluir un atributo adicional: tasaInteres: La tasa de interés aplicada a los saldos de la cuenta de ahorro. Implementa un programa principal que permita crear objetos de tipo CuentaCorriente y CuentaAhorro, ingresar los datos necesarios y realizar las siguientes operaciones para cada cuenta: Depositar dinero. Retirar dinero. Consultar el saldo actual.

package abstraccion;

public class Ejercicio11 {

	public static void main(String[] args) {
		CuentaCorriente corriente=new CuentaCorriente(1500,500);
		CuentaAhorro ahorro=new CuentaAhorro(2000,4);
		
		corriente.depositar(1000.00);
		corriente.retirar(2750.36);
		if(corriente.consultarSaldo()<0) {
			System.err.println(corriente.consultarSaldo());
		}else {
			System.out.println(corriente.consultarSaldo());
		}
		
		
		corriente.depositar(1000.00);
		corriente.retirar(500.36);
		System.out.println(ahorro.consultarSaldo());

	}

}

interface CuentaBancaria{
	void depositar(Double cantidad);
	void retirar(Double cantidad);
	double consultarSaldo();
}

class CuentaCorriente implements CuentaBancaria{
	private double saldo;
	private double sobregiro;

	public CuentaCorriente(double saldo,double sobregiro) {
		super();
		this.saldo=saldo;
		this.sobregiro = sobregiro;
	}

	/**
	 * @return the sobregiro
	 */
	public double getSobregiro() {
		return sobregiro;
	}

	/**
	 * @param sobregiro the sobregiro to set
	 */
	public void setSobregiro(double sobregiro) {
		this.sobregiro = sobregiro;
	}
	
	/**
	 * @return the sobregiro
	 */
	public double getSaldo() {
		return saldo;
	}

	/**
	 * @param sobregiro the sobregiro to set
	 */
	public void setSaldo(double saldo) {
		this.saldo = saldo;
	}

	@Override
	public void depositar(Double cantidad) {
		this.saldo+=cantidad;
		System.out.println("Ingreso correcto");
	}

	@Override
	public void retirar(Double cantidad) {
		if(cantidad<(this.saldo+this.sobregiro)) {
			this.saldo-=cantidad;
			System.out.println("Retirada efectiva");
		}else {
			System.err.println("Saldo insuficiente");
		}
		
	}

	@Override
	public double consultarSaldo() {
		
		return this.saldo;
	}
	
	
}

class CuentaAhorro implements CuentaBancaria{
	private double saldo;
	private double tasaInteres;

	public CuentaAhorro(double saldo,double tasaInteres) {
		super();
		this.saldo=saldo;
		this.tasaInteres = tasaInteres;
		
	}

	/**
	 * @return the tasaInteres
	 */
	public double getTasaInteres() {
		return tasaInteres;
	}

	/**
	 * @param tasaInteres the tasaInteres to set
	 */
	public void setSaldo(double saldo) {
		this.saldo = saldo;
	}
	
	/**
	 * @return the tasaInteres
	 */
	public double getSaldo() {
		return saldo;
	}

	/**
	 * @param tasaInteres the tasaInteres to set
	 */
	public void setTasaInteres(double tasaInteres) {
		this.tasaInteres = tasaInteres;
	}

	@Override
	public void depositar(Double cantidad) {
		this.saldo=cantidad;
		System.out.println("Ingreso correcto");
	}

	@Override
	public void retirar(Double cantidad) {
		if(this.saldo>=cantidad) {
			this.saldo-=cantidad;
			System.out.println("Retirada efectiva");
		}else {
			System.err.println("Saldo insuficiente");
		}
		
	}

	@Override
	public double consultarSaldo() {
		
		return this.saldo;
	}
	
	
}

Ejercicio 12

Desarrolla un sistema de gestión de biblioteca en Java que permita administrar tanto libros como revistas. El sistema deberá ser capaz de realizar operaciones como agregar nuevos elementos, buscar por título, autor o categoría, prestar y devolver libros/revistas, así como generar informes de inventario. Funcionalidades del Sistema: Registro de Libros y Revistas: El sistema permitirá a los bibliotecarios registrar nuevos libros y revistas en la base de datos, incluyendo detalles como título, autor, año de publicación y categoría. Búsqueda por Título, Autor o Categoría: Los usuarios podrán buscar libros y revistas en el sistema utilizando diferentes criterios de búsqueda, como título, autor o categoría. Préstamo y Devolución de Libros/Revistas: Los bibliotecarios podrán registrar préstamos y devoluciones de libros y revistas para los usuarios registrados en el sistema, manteniendo un registro actualizado del inventario. Generación de Informes: El sistema permitirá generar informes detallados sobre el inventario de la biblioteca, incluyendo el listado de libros y revistas disponibles, los elementos prestados, y el historial de préstamos. Estructura del Sistema: El sistema estará compuesto por las siguientes interfaces y clases: Interfaz GestorBiblioteca: Definirá métodos abstractos para realizar operaciones básicas de gestión de la biblioteca, como agregar elementos, buscar, prestar y devolver libros/revistas, y generar informes. Clase Libro: Representará un libro en la biblioteca, incluyendo atributos como título, autor, año de publicación y categoría. Implementará la interfaz GestorBiblioteca. Clase Revista: Representará una revista en la biblioteca, incluyendo atributos como título, editor, año de publicación y categoría. También implementará la interfaz GestorBiblioteca. Clase Biblioteca: Será la clase principal que gestionará la base de datos de libros y revistas, así como las operaciones de préstamo y devolución. Implementará la interfaz GestorBiblioteca.

package abstraccion;

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

public class Ejercicio12 {

	public static void main(String[] args) {
		Scanner entrada = new Scanner(System.in);
		Biblioteca biblioteca=new Biblioteca();
		Prestamos prestamo=new Prestamos();
		int menu=0;
		do {
			System.out.println("BIBLIOTECA");
			System.out.println("(1).Agregar");
			System.out.println("(2).Buscar");
			System.out.println("(3).Prestar");
			System.out.println("(4).Devolver");
			System.out.println("(5).Informe");
			System.out.println("(6).Salir");
			try {
				System.out.println("Escoge opcion:");
				menu=Integer.parseInt(entrada.nextLine());
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion menu incorrecto");
			}
			
			switch(menu) {
			case 1:
				biblioteca.agregar();
				break;
			case 2:
				biblioteca.buscar();
				break;
			case 3:
				prestamo.prestar();
				break;
			case 4:
				prestamo.devolver();
				break;
			case 5:
				biblioteca.informe();
				break;
			case 6:
				System.out.println("Saliendo de biblioteca");
				break;
			default:
				System.err.println("Opcion no contemplada en el menu");
				break;
			}
		}while(menu!=6);

	}
	
	

}

interface GestorBiblioteca{
	
	void agregar();
	void buscar();
	void prestar();
	void devolver();
	void informe();
}

class Biblioteca implements GestorBiblioteca{
	protected int codigo;
	protected String titulo;
	protected String autor;
	protected int anio;
	protected String categoria;
	protected static ArrayList<Biblioteca> biblioteca=new ArrayList<Biblioteca>();
	private static int codigoNumero=0;
	protected boolean estado=true;
	

	public Biblioteca(int codigo, String titulo, String autor, int anio, String categoria) {
		super();
		this.codigo = codigo;
		this.titulo = titulo;
		this.autor = autor;
		this.anio = anio;
		this.categoria = categoria;
	}
	
	
	
	/**
	 * @return the estado
	 */
	public boolean getEstado() {
		return estado;
	}



	/**
	 * @param estado the estado to set
	 */
	public void setEstado(boolean estado) {
		this.estado = estado;
	}



	public Biblioteca() {
		super();
	}



	/**
	 * @return the codigo
	 */
	public int getCodigo() {
		return codigo;
	}


	/**
	 * @param codigo the codigo to set
	 */
	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}


	/**
	 * @return the titulo
	 */
	public String getTitulo() {
		return titulo;
	}


	/**
	 * @param titulo the titulo to set
	 */
	public void setTitulo(String titulo) {
		this.titulo = titulo;
	}


	/**
	 * @return the autor
	 */
	public String getAutor() {
		return autor;
	}


	/**
	 * @param autor the autor to set
	 */
	public void setAutor(String autor) {
		this.autor = autor;
	}


	/**
	 * @return the anio
	 */
	public int getAnio() {
		return anio;
	}


	/**
	 * @param anio the anio to set
	 */
	public void setAnio(int anio) {
		this.anio = anio;
	}


	/**
	 * @return the categoria
	 */
	public String getCategoria() {
		return categoria;
	}


	/**
	 * @param categoria the categoria to set
	 */
	public void setCategoria(String categoria) {
		this.categoria = categoria;
	}


	/**
	 * @return the biblioteca
	 */
	public static ArrayList<Biblioteca> getBiblioteca() {
		return biblioteca;
	}


	/**
	 * @param biblioteca the biblioteca to set
	 */
	public static void setBiblioteca(ArrayList<Biblioteca> biblioteca) {
		Biblioteca.biblioteca = biblioteca;
	}
	
	

	@Override
	public String toString() {
		String disponibilidad;
		if(this.estado) {
			disponibilidad="Disponible";
		}else {
			disponibilidad="Prestado";
		}
		
		return "Codigo: " + codigo + "   |   Titulo: " + titulo + "   |   Autor: " + autor + "   |   Anio: " + anio
				+ "   |   Categoria: " + categoria + "   |   Estado: " + disponibilidad;
	}



	public String formato(String funcion) {
		Scanner entrada2=new Scanner(System.in);
		String formato;
		
		while(true) {
			System.out.println("¿Quieres " + funcion + " un libro o revista L/R?");
			formato=entrada2.nextLine().toUpperCase();
			if(formato.equals("L") || formato.equals("R")) {
				if(formato.equals("L")) {
					formato="libro";
				}else {
					formato="revista";
				}
				return formato;
			}else {
				System.err.println("Opcion incorrecta. vuelve a escoger");
			}
		}
	}
	
	public void agregar() {
		Scanner entrada2=new Scanner(System.in);
		String formato,titulo,autor,categoria;
		int anio;
		
		formato=formato("agregar");
						
		System.out.println("Introduce el titulo de " + formato);
		titulo=entrada2.nextLine();
		
		System.out.println("Introduce el autor de " + formato);
		autor=entrada2.nextLine();
		
		while(true) {
			try {
				System.out.println("Introduce el año de " + formato);
				anio=Integer.parseInt(entrada2.nextLine());
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de anio incorrecto");
			}
		}
			System.out.println("Introduce la categoria de " + formato);
			categoria=entrada2.nextLine();
			
			++codigoNumero;
			
			if(formato.equals("libro")) {
				Libro libro=new Libro(codigoNumero,titulo,autor,anio,categoria);
				biblioteca.add(libro);
			}else {
				Revista revista=new Revista(codigoNumero,titulo,autor,anio,categoria);
				biblioteca.add(revista);
			}
			
			System.out.println("Articulo agregado a la biblioteca");
	}
		

	public void buscar() {
		Scanner entrada2=new Scanner(System.in);
		String formato,titulo,autor,categoria;
		int anio,opcion=0;
		
		formato=formato("buscar");
		do {
			System.out.println("(1).Buscar " + formato + " por titulo");
			System.out.println("(2).Buscar " + formato + " por autor");
			System.out.println("(3).Buscar " + formato + " por anio");
			System.out.println("(4).Buscar " + formato + " por categoria");
			System.out.println("(5).Volver a menu principal");
			System.out.println("Escoge opcion:");
			while(true) {
				try {
					opcion=Integer.parseInt(entrada2.nextLine());
					break;
				}catch(NumberFormatException e) {
					System.err.println("Formato d emenu incorrecto");
				}
			}
			
			switch(opcion) {
			case 1:
				System.out.println("Introduce el titulo a buscar de " + formato);
				titulo=entrada2.nextLine();
				 boolean encontrado = false;

				    for (Biblioteca elemento : biblioteca) {
				        if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") && elemento instanceof Revista)) {
				            if (elemento.getTitulo().equalsIgnoreCase(titulo)) {
				                System.out.println((formato.equals("libro") ? "libro" : "revista") + " encontrado:");
				                System.out.println(elemento.toString());
				                encontrado = true;
				                break; //
				            }
				        }
				    }

				    if (!encontrado) {
				        System.out.println("No se encontró " + (formato.equals("libro") ? "libro" : "revista") + " con el título \"" + titulo + "\".");
				    }
				break;
			case 2:
				System.out.println("Introduce el autor a buscar de " + formato);
				autor=entrada2.nextLine();
				 boolean encontradoAutor = false;

				    for (Biblioteca elemento : biblioteca) {
				        if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") && elemento instanceof Revista)) {
				            if (elemento.getAutor().equalsIgnoreCase(autor)) {
				                System.out.println((formato.equals("libro") ? "libro" : "revista") + elemento.toString());
				                encontradoAutor = true;
				                break; //
				            }
				        }
				    }

				    if (!encontradoAutor) {
				        System.out.println("No se encontró " + (formato.equals("libro") ? "libro" : "revista") + " del autor \"" + autor + "\".");
				    }
				break;
			case 3:
				System.out.println("Introduce el año a buscar de " + formato);
				anio=Integer.parseInt(entrada2.nextLine());
				 boolean encontradoAnio = false;

				    for (Biblioteca elemento : biblioteca) {
				        if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") && elemento instanceof Revista)) {
				            if (elemento.getAnio()==anio) {
				                System.out.println((formato.equals("libro") ? "libro" : "revista") + elemento.toString());
				                encontradoAnio = true;
				                break; //
				            }
				        }
				    }

				    if (!encontradoAnio) {
				        System.out.println("No se encontró " + (formato.equals("libro") ? "libro" : "revista") + " del año \"" + anio + "\".");
				    }
				break;
			case 4:
				System.out.println("Introduce la categoria a buscar de " + formato);
				categoria=entrada2.nextLine();
				 boolean encontradoCategoria = false;

				    for (Biblioteca elemento : biblioteca) {
				        if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") && elemento instanceof Revista)) {
				            if (elemento.getCategoria().equalsIgnoreCase(categoria)) {
				                System.out.println((formato.equals("libro") ? "libro" : "revista") + elemento.toString());
				                encontradoCategoria = true;
				                break; //
				            }
				        }
				    }

				    if (!encontradoCategoria) {
				        System.out.println("No se encontró " + (formato.equals("libro") ? "libro" : "revista") + " de la categoria \"" + categoria + "\".");
				    }
				break;
			case 5:
				System.out.println("Volviendo a menu principal");
				break;
			default:
				System.err.println("Opcion no valida");
				break;
			}
			
		}while(opcion!=5);
		
	}
	public void prestar() {
		
	}
	public void devolver() {
		
	}
	public void informe() {
		for (Biblioteca elemento : biblioteca) {
			System.out.println(elemento.toString());
		}
	}
}

class Libro extends Biblioteca implements GestorBiblioteca{

	public Libro(int codigo, String titulo, String autor, int anio, String categoria) {
		super(codigo, titulo, autor, anio, categoria);
		
	}

	public Libro() {
		super(0, "", "", 0, ""); // Valores por defecto
	}
	
	public void agregar() {
		super.agregar();
	}
	
	
}


class Revista extends Biblioteca implements GestorBiblioteca{

	public Revista(int codigo, String titulo, String autor, int anio, String categoria) {
		super(codigo, titulo, autor, anio, categoria);
		
	}
	
	
}

class Prestamos extends Biblioteca implements GestorBiblioteca{
	private static ArrayList<Biblioteca> prestamos=new ArrayList<Biblioteca>();
	
	public Prestamos(int codigo, String titulo, String autor, int anio, String categoria) {
		super(codigo, titulo, autor, anio, categoria);
		
	}
	
	public Prestamos() {
		super(0, "", "", 0, ""); // Valores por defecto
	}
	
	
	public void prestar() {
		Scanner entrada2 =new Scanner(System.in);
		String formato;
		boolean disponibles=false,codigoEncontrado=false;
		int codigo;
		formato=formato("prestar");
		for (Biblioteca elemento : biblioteca) {
			if ((formato.equals("libro") && elemento instanceof Libro) && elemento.getEstado() || (formato.equals("revista") && elemento instanceof Revista && elemento.getEstado())) {
				disponibles=true;
			}
		}
		if(disponibles) {
			System.out.println(formato + " disponibles para prestar");
			for (Biblioteca elemento : biblioteca) {
				if ((formato.equals("libro") && elemento instanceof Libro) && elemento.getEstado() || (formato.equals("revista") && elemento instanceof Revista && elemento.getEstado())) {
					System.out.println(elemento.toString());
				}
			}
			
			while(true) {
				try {
					System.out.println("Introduce el codigo de  " + formato + " a prestar");
					codigo=Integer.parseInt(entrada2.nextLine());
					for (Biblioteca elemento : biblioteca) {
						if ((formato.equals("libro") && elemento instanceof Libro) && elemento.getEstado() || (formato.equals("revista") && elemento instanceof Revista && elemento.getEstado())) {
							if(elemento.getCodigo()==codigo) {
								codigoEncontrado=true;
								elemento.setEstado(false);
								if(elemento instanceof Libro) {
									Libro presto=new Libro(codigo,elemento.getTitulo(),elemento.getAutor(),elemento.getAnio(),elemento.getCategoria());
									prestamos.add(presto);
								}else {
									Revista presto=new Revista(codigo,elemento.getTitulo(),elemento.getAutor(),elemento.getAnio(),elemento.getCategoria());
									prestamos.add(presto);
								}
								
								
								System.out.println(formato + " prestado correctamente");
								break;
							}
						}
					}
					if(codigoEncontrado) {
						break;
					}else {
						System.out.println("El codgio introducido no corresponde a ningun " + formato + " disponible para prestamo, introduce otro");
					}
				}catch(NumberFormatException e) {
					System.err.println("Formato de codigo no valido, vuelve a introducirlo");
				}
			}
			
			
		}else {
			System.out.println("No hay " + formato + " disponibles para prestamo");
		}
		
	}
	
		
	public void devolver() {
		Scanner entrada2=new Scanner(System.in);
		String formato;
		int codigo;
		boolean existenDevoluciones=false,codigoEncontrado=false;
		
		
		formato=formato("devolver");
		
		
		for (Biblioteca elemento : prestamos) {
			if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") && elemento instanceof Revista )) {
				existenDevoluciones=true;
			}
		}
		
		if(existenDevoluciones) {
			System.out.println("Lista de " + formato + " disponibles para devolucion");
			for (Biblioteca elemento : prestamos) {
				if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") )) {
					System.out.println(elemento.toString());
				}
			}
			 while(true) {
				 try {
					 System.out.println("Introduce el codigo de " + formato + " a devolver" );
					 codigo=Integer.parseInt(entrada2.nextLine());
					 for (Biblioteca elemento : prestamos) {
							if ((formato.equals("libro") && elemento instanceof Libro) || (formato.equals("revista") && elemento instanceof Revista)) {
								if(codigo==elemento.getCodigo()) {
									for (Biblioteca devolver : biblioteca) {
										if(codigo==devolver.getCodigo()) {
											devolver.setEstado(true);
											System.out.println("Devolucion correcta");
											codigoEncontrado=true;
											
											break;
											
											
										}
									}
								}
							}
						}
					 if(codigoEncontrado) {
						 Iterator<Biblioteca> it=prestamos.iterator();
						 while(it.hasNext()) {
							 Biblioteca biblio=it.next();
							 if(biblio.getCodigo()==codigo)
								 it.remove();
						 }
						 break;
					 }else {
						 System.err.println("El codigo no corresponde a ningun " + formato + " que este en prestamo");
					 }
				 }catch(NumberFormatException e) {
					 System.err.println("Formato de codigo incorrecto");
				 }
			 }
			
		}else {
			System.out.println("No hay " + formato + " disponibles para devolucion");
		}
	}
}

Ejercicio 13

Desarrolla un sistema de gestión de empleados en Java que permita administrar información sobre empleados de una empresa. El sistema deberá ser capaz de realizar operaciones como agregar nuevos empleados, buscar empleados por diferentes criterios, calcular el salario de un empleado y generar informes de empleados. Funcionalidades del Sistema: Registro de Empleados: El sistema permitirá a los administradores registrar nuevos empleados en la base de datos, incluyendo detalles como nombre, edad, puesto y salario base. Búsqueda de Empleados: Los usuarios podrán buscar empleados en el sistema utilizando diferentes criterios de búsqueda, como nombre, edad o puesto. Cálculo de Salario: El sistema calculará el salario de un empleado teniendo en cuenta su salario base y cualquier bonificación o deducción aplicable. Generación de Informes: El sistema permitirá generar informes detallados sobre los empleados, incluyendo la lista de todos los empleados, empleados por departamento, o empleados que ganan más de cierta cantidad. Estructura del Sistema: El sistema estará compuesto por las siguientes interfaces y clases: Interfaz GestorEmpleados: Definirá métodos abstractos para realizar operaciones básicas de gestión de empleados, como agregar empleados, buscar, calcular salario y generar informes. Clase Empleado: Representará un empleado en la empresa, incluyendo atributos como nombre, edad, puesto y salario base. Clase Empresa: Será la clase principal que gestionará la base de datos de empleados y las operaciones relacionadas. Implementará la interfaz GestorEmpleados.

package abstraccion;

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

public class Ejercicio13 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		int menu=0;
		Empresa empresa=new Empresa();
		
		do {
			System.out.println("EMPRESA FICTICIA");
			System.out.println("(1).Agregar empleados");
			System.out.println("(2).Buscar empleados");
			System.out.println("(3).Calcular salario empleados");
			System.out.println("(4).Informes");
			System.out.println("(5).Salir");
			System.out.println("Escoge opcion:");
			try {
				menu=Integer.parseInt(entrada.nextLine());
				switch(menu) {
				case 1:
					empresa.agregarEmpleados();
					break;
				case 2:
					empresa.buscarEmpleados();
					break;
				case 3:
					empresa.calcularSalario();
					break;
				case 4:
					empresa.generarInformes();
					break;
				case 5:
					System.out.println("Cerrando empresa");
					break;
				default:
					System.out.println("Opcion no contemplada, intentalo de nuevo");
					break;
				
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion de menu no valido, intentalo de nuevo");
			}
			
		}while(menu!=5);

	}

}

interface GestorEmpleados{
	void agregarEmpleados();
	void buscarEmpleados();
	void calcularSalario();
	void generarInformes();
}

class Empresa implements GestorEmpleados{
	private static int numeroCodigo=0;
	private static ArrayList<Empleado> empleados=new ArrayList<Empleado>();
	
	//funcion agregar un empleado nuevo
	public void agregarEmpleados() {
		Scanner entrada2=new Scanner(System.in);
		String nombre,puesto;
		int codigo,edad;
		double salarioBase;
		
		System.out.println("Introduce el nombre del empleado");
		nombre=entrada2.nextLine();
		
		//controlamos que la edad sea valida para trabajar en España
		do {
			try {
				System.out.println("Introduce la edad del empleado:");
				edad=Integer.parseInt(entrada2.nextLine());
				
				if(edad<16 || edad>66) {
					System.err.println(edad + " no es una edad de trabajar, introduce otra edad");
				}else {
					break;
				}
			}catch(NumberFormatException e) {
				System.err.println("Numero de edad no valido");
			}
		}while(true);
		
		System.out.println("Introduce el puesto del empleado:");
		puesto=entrada2.nextLine();
		
		//controlamos que el salario sea digno, se supone que no hay trabajadores a media jornada.
		do {
			try {
				System.out.println("Introduce el salario base del empleado:");
				salarioBase=Double.parseDouble((entrada2.nextLine()));
				
				if(salarioBase<1050.00) {
					System.err.println(salarioBase + "no es un salario legal en España en estos momento a jornada completa. Min 1050.00€");
				}else {
					break;
				}
			}catch(NumberFormatException e) {
				System.err.println("Numero de salario no valido");
			}
		}while(true);
		
		//generamos el numero de codigo
		++numeroCodigo;
		
		//agregamos el trabajador a la base de datos
		Empleado emple=new Empleado(numeroCodigo,nombre,edad,puesto,salarioBase);
		empleados.add(emple);
		
		System.out.println("Empleado contratado con exito");
		
	}
	
	public void buscarEmpleados() {
		Scanner entrada2 = new Scanner(System.in);
		
		if(empleados.size()==0) {
			System.out.println("Todavia no hay empleados dados de alta");
			return;
		}
		
		int menuBusqueda=0;
		do {
			System.out.println("BUSQUEDA");
			System.out.println("(1).Busqueda por codigo"); 
			System.out.println("(2).Busqueda por nombre");
			System.out.println("(3).Busqueda por edad");
			System.out.println("(4).Busqueda por salario");
			System.out.println("(5).Volver a menu principal");
			System.out.println("Escoge opcion:");
			try {
				menuBusqueda=Integer.parseInt(entrada2.nextLine());
			}catch(NumberFormatException e) {
				System.err.println("Formato de numero de menu no valido, introducelo de nuevo");
			}
			
			switch(menuBusqueda){
			case 1:
				int codigo=0;
				boolean empleadoEncontrado=false;
				try {
					System.out.println("Introduce el codigo del empleado para buscarlo");
					codigo=Integer.parseInt(entrada2.nextLine());
					
					for (Empleado empleado : empleados) {
						if(empleado.getCodigo()==codigo) {
							System.out.println(empleado.toString());
							empleadoEncontrado=true;
							break;
						}
					}
					
				}catch(NumberFormatException e) {
					System.err.println("Formato de codigo no valido");
				}
				
				if(!empleadoEncontrado) {
					System.out.println("No hay ningun empleado con ese codigo de empleado");
				}
				
				break;
			case 2:
				String nombre="";
				empleadoEncontrado=false;
				
					System.out.println("Introduce el nombre del empleado para buscarlo");
					nombre=entrada2.nextLine();
					
					for (Empleado empleado : empleados) {
						if(empleado.getNombre().equalsIgnoreCase(nombre)) {
							System.out.println(empleado.toString());
							empleadoEncontrado=true;
						}
					}

				if(!empleadoEncontrado) {
					System.out.println("No hay ningun empleado con ese nombre de empleado");
				}
				
				break;
			case 3:
				int menuEdad=0,edad;
				boolean edadEncontrada=false;
				do {
					System.out.println("Busqueda por edad");
					System.out.println("(1).Una edad concreta");
					System.out.println("(2).Mayores de ...");
					System.out.println("(3).Menores de ...");
					System.out.println("(4).Volver a menu busqueda");
					System.out.println("Escoge opcion:");
					try {
						menuEdad=Integer.parseInt(entrada2.nextLine());
						
						while(true)
							try {
								System.out.println("Introduce la edad:");
								edad=Integer.parseInt(entrada2.nextLine());
								if(edad>=16 && edad<=66) {
									if (menuEdad==1) {
										for (Empleado empleado : empleados) {
											if(empleado.getEdad()==edad) {
												System.out.println(empleado.toString());
												edadEncontrada=true;
											}
										}
										if(!edadEncontrada) {
											System.out.println("No hay empleados de " + edad + " años en la empresa");
										}
									}else if(menuEdad==2) {
										for (Empleado empleado : empleados) {
											if(empleado.getEdad()>edad) {
												System.out.println(empleado.toString());
												edadEncontrada=true;
											}
										}
										if(!edadEncontrada) {
											System.out.println("No hay empleados mayores de " + edad + " años en la empresa");
										}
										
									}else if(menuEdad==3) {
										for (Empleado empleado : empleados) {
											if(empleado.getEdad()<edad) {
												System.out.println(empleado.toString());
												edadEncontrada=true;
											}
										}
										if(!edadEncontrada) {
											System.out.println("No hay empleados menores de " + edad + " años en la empresa");
										}
									}else {
										System.out.println("Opcion no contemplada");
										break;
									}
								}else {
									System.out.println("Edad no valida para trabajadores, introducela de nuevo"); 
								}
								break;
							}catch(NumberFormatException e) {
								System.err.println("Formato de edad no valido, introducelo de nuevo");
							}
					}catch(NumberFormatException e) {
						System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
					}
					
				}while(menuEdad!=4);
				break;
			case 4:
				int menuSalario=0;
				double salario;
				boolean salarioEncontrado=false;
				do {
					System.out.println("Busqueda por salario");
					System.out.println("(1).Un salario concreto");
					System.out.println("(2).Cobran mas de ...");
					System.out.println("(3).Cobran menos de ...");
					System.out.println("(4).Volver a menu busqueda");
					System.out.println("Escoge opcion:");
					try {
						while(true)
							try {
								System.out.println("Introduce el salario:");
								salario=Double.parseDouble(entrada2.nextLine());
								if(salario>1050) {
									if (menuSalario==1) {
										for (Empleado empleado : empleados) {
											if(empleado.getSalarioBase()==salario) {
												System.out.println(empleado.toString());
												salarioEncontrado=true;
											}
										}
										if(!salarioEncontrado) {
											System.out.println("No hay empleados con ese " + salario + " salario en la empresa");
										}
									}else if(menuSalario==2) {
										for (Empleado empleado : empleados) {
											if(empleado.getSalarioBase()>salario) {
												System.out.println(empleado.toString());
												salarioEncontrado=true;
											}
										}
										if(!salarioEncontrado) {
											System.out.println("No hay empleados que cobren mas de  " + salario + "€ en la empresa");
										}
										
									}else if(menuSalario==3) {
										for (Empleado empleado : empleados) {
											if(empleado.getSalarioBase()<salario) {
												System.out.println(empleado.toString());
												salarioEncontrado=true;
											}
										}
										if(!salarioEncontrado) {
											System.out.println("No hay que cobren menos de " + salario + "€ en la empresa");
										}
									}else {
										System.out.println("Opcion no contemplada");
										break;
									}
								}else {
									System.out.println("Salario no valido para trabajadores, introducela de nuevo"); 
								}
								break;
							}catch(NumberFormatException e) {
								System.err.println("Formato de salario no valido, introducelo de nuevo");
							}
					}catch(NumberFormatException e) {
						System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
					}
					
					
				}while(menuSalario!=4);
				break;
			case 5:
				System.out.println("Volviendo a menu principal");
				break;
			default:
				System.err.println("Opcion no valida, introducela de nuevo");
				break;
			}
		}while(menuBusqueda!=5);
	}
	public void calcularSalario() {
		double bonusEdad=0.0;
		
		for (Empleado empleado : empleados) {
			if(empleado.getEdad()<25) {
				bonusEdad=empleado.getSalarioBase()+500;
			}else if(empleado.getEdad()>=25 && empleado.getEdad()<60) {
				bonusEdad=empleado.getSalarioBase()+750;
			}else if(empleado.getEdad()>=60) {
				bonusEdad=empleado.getSalarioBase()+900;
			}
			System.out.println("Codigo: " + empleado.getCodigo() + "   |   Nombre:" + empleado.getNombre() + "   |   Edad:" + empleado.getEdad() + "   |   Puesto:" + empleado.getPuesto()
				+ "   |   Salario Base + Bonus edad:  " + bonusEdad);
		}
	}
	public void generarInformes() {
		int menuInformes=0;
		Scanner entrada2=new Scanner(System.in);
		double sumaTotal=0;
		do {
			System.out.println("INFORMES");
			System.out.println("(1).Salario mensual total de la empresa");
			System.out.println("(2).Salario mensual total mayores de 60");
			System.out.println("(3).Salario mensual total menores de 25");
			System.out.println("(4).Volver a menu principal");
			System.out.println("Escoge opcion:");
			try {
				menuInformes=Integer.parseInt(entrada2.nextLine());
				
				switch(menuInformes) {
				case 1:
					sumaTotal=0;
					for (Empleado empleado : empleados) {
						sumaTotal+=empleado.getSalarioBase();
					}
					System.out.println("El importe mensual en sueldos de la empresa asciende a " + String.format("%.2f",sumaTotal) + "€");
					break;
				case 2:
					sumaTotal=0;
					for (Empleado empleado : empleados) {
						if(empleado.getEdad()>60) {
							sumaTotal+=empleado.getSalarioBase();
						}
						
					}
					System.out.println("El importe mensual en sueldos de la empresa de mayores de 60 asciende a " + String.format("%.2f",sumaTotal) + "€");
					break;
				case 3:
					sumaTotal=0;
					for (Empleado empleado : empleados) {
						if(empleado.getEdad()<25) {
							sumaTotal+=empleado.getSalarioBase();
						}
						
					}
					System.out.println("El importe mensual en sueldos de la empresa de menores de 25 asciende a " + String.format("%.2f",sumaTotal) + "€");
					break;
				case 4:
					System.out.println("Volviendo al menu principal");
					break;
				default:
					System.err.println("Opcion no valida, intentalo de nuevo");
					break;
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion no valido, intentalo de nuevo");
			}
		}while(menuInformes!=4);
	}
}

class Empleado extends Empresa{
	private int codigo;
	private String nombre;
	private int edad;
	private String puesto;
	private double salarioBase;
	
	public Empleado(int codigo, String nombre, int edad, String puesto, double salarioBase) {
		super();
		this.codigo = codigo;
		this.nombre = nombre;
		this.edad = edad;
		this.puesto = puesto;
		this.salarioBase = salarioBase;
	}
	
	@Override
	public String toString() {
		return "Codigo: " + codigo + "   |   Nombre:" + nombre + "   |   Edad:" + edad + "   |   Puesto:" + puesto
				+ "   |   Salario Base: " + salarioBase;
	}

	public Empleado() {
		super();
	}

	/**
	 * @return the codigo
	 */
	public int getCodigo() {
		return codigo;
	}

	/**
	 * @param codigo the codigo to set
	 */
	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @return the edad
	 */
	public int getEdad() {
		return edad;
	}

	/**
	 * @param edad the edad to set
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}

	/**
	 * @return the puesto
	 */
	public String getPuesto() {
		return puesto;
	}

	/**
	 * @param puesto the puesto to set
	 */
	public void setPuesto(String puesto) {
		this.puesto = puesto;
	}

	/**
	 * @return the salarioBase
	 */
	public double getSalarioBase() {
		return salarioBase;
	}

	/**
	 * @param salarioBase the salarioBase to set
	 */
	public void setSalarioBase(double salarioBase) {
		this.salarioBase = salarioBase;
	}
	
	
	
	
	
}

Ejercicio 14

Desarrolla un sistema de gestión de productos en un inventario en Java que permita administrar información sobre productos y realizar operaciones como agregar nuevos productos, buscar productos por diferentes criterios, calcular el total de inventario y generar informes de productos más vendidos. Funcionalidades del Sistema: Registro de Productos: El sistema permitirá a los administradores registrar nuevos productos en el inventario, incluyendo detalles como nombre, precio, cantidad disponible y categoría. Búsqueda de Productos: Los usuarios podrán buscar productos en el inventario utilizando diferentes criterios de búsqueda, como nombre, precio o categoría. Cálculo del Total de Inventario: El sistema calculará el valor total del inventario sumando el precio de todos los productos disponibles en stock. Generación de Informes de Productos más Vendidos: El sistema permitirá generar informes que muestren los productos más vendidos en un período de tiempo específico, mostrando el nombre del producto, la cantidad vendida y los ingresos generados. Estructura del Sistema: El sistema estará compuesto por las siguientes interfaces y clases: Interfaz GestorProductos: Definirá métodos abstractos para realizar operaciones básicas de gestión de productos, como agregar productos, buscar, calcular el total de inventario y generar informes. Clase Producto: Representará un producto en el inventario, incluyendo atributos como nombre, precio, cantidad disponible y categoría. Clase Inventario: Será la clase principal que gestionará el inventario de productos y las operaciones relacionadas. Implementará la interfaz GestorProductos.

package abstraccion;

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

public class Ejercicio14 {

	public static void main(String[] args) {
		Scanner entrada= new Scanner(System.in);
		int menu=0;
		Inventario inventario=new Inventario();
		do {
			System.out.println("Menu productos");
			System.out.println("(1).Agregar un producto");
			System.out.println("(2).Buscar un producto");
			System.out.println("(3).Sumar inventario");
			System.out.println("(4).Control de stock");
			System.out.println("(5).cerrar almacen");
			System.out.println("Escoge opcion:");
			try {
				menu=Integer.parseInt(entrada.nextLine());
				
				switch(menu) {
				case 1:
					inventario.agregarProductos();
					break;
				case 2:
					inventario.buscarProductos();
					break;
				case 3:
					inventario.sumarInventario();
					break;
				case 4:
					inventario.generarinformes();
					break;
				case 5:
					System.out.println("Cerrando almacen");
					break;
				default:
					System.out.println("Opcion no contemplada en el menu, vuelve a intentarlo");
					break;
					
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion menu no valido, intentalo de nuevo");
			}
		}while(menu!=5);

	}

}

interface GestorProductos{
	void agregarProductos();
	void buscarProductos();
	void sumarInventario();
	void generarinformes();
}

class Inventario implements GestorProductos{
	protected static ArrayList<Productos> productos=new ArrayList<Productos>();
	private static int generoCodigo=0;
	
	public void agregarProductos() {
		Scanner entrada2=new Scanner(System.in);
		String nombre,categoria;
		double precio;
		int cantidad;
		
		System.out.println("Introduce nombre del producto:");
		nombre=entrada2.nextLine();
		
		while(true) {
			try {
				do {
					System.out.println("Introduce el precio de " + nombre);
					precio=Double.parseDouble(entrada2.nextLine());
					if(precio<0) {
						System.err.println("El precio no puede ser negativo, introducelo de nuevo");
					}
				}while(precio<0);
				
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de precio no valido");
			}
		}
		
		while(true) {
			try {
				do {
					System.out.println("Introduce la cantidad de " + nombre);
					cantidad=Integer.parseInt(entrada2.nextLine());
					if(cantidad<0) {
						System.err.println("El stock no puede ser negativo, introducelo de nuevo");
					}
				}while(cantidad<0);
				
				break;
			}catch(NumberFormatException e) {
				System.err.println("Formato de cantidad no valido");
			}
		}
		
		System.out.println("Introduce la categoria de " + nombre);
		categoria=entrada2.nextLine();
		
		++generoCodigo;
		
		Productos producto=new Productos(generoCodigo,nombre,precio,cantidad,categoria);
		productos.add(producto);
		System.out.println("Producto agregado correctamente al stock");
	}
	
	
	public void buscarProductos() {
		if(productos.size()==0) {
			System.out.println("Todavia no hay productos dados de alta");
			return;
		}
		
		Scanner entrada2=new Scanner(System.in);
		int menu=0;
		
		do {
			System.out.println("Menu de busqueda");
			System.out.println("(1).Buscar por codigo");
			System.out.println("(2).Buscar por nombre");
			System.out.println("(3).Buscar por precio");
			System.out.println("(4).Buscar por cantidad");
			System.out.println("(5).Buscar por categoria");
			System.out.println("(6).Volver a menu prinpical");
			System.out.println("Escoge opcion:");
			try {
				menu=Integer.parseInt(entrada2.nextLine());
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion de menu no valido, intentalo de nuevo");
			}
			
			switch(menu) {
			case 1:
				int codigo=0;
				boolean codigoEncontrado=false;
				
				try {
					do {
						System.out.println("Introduce el codigo a buscar:");
						codigo=Integer.parseInt(entrada2.nextLine());
						
						if(codigo<1) {
							System.out.println("Los codigos empiezan en 1, introducelo de nuevo");
						}
					}while(codigo<1);
					
				}catch(NumberFormatException e) {
					System.err.println("Formato de codigo no valido");
				}
				
				for (Productos producto: productos) {
					if(producto.getCodigo()==codigo) {
						codigoEncontrado=true;
						System.out.println(producto.toString());
						break;
					}
				}
				
				if(!codigoEncontrado) {
					System.err.println("El codigo no corresponde a ningun producto de nuestro alamacen");
				}
				
				break;
			case 2:
				String nombre;
				boolean nombreEncontrado=false;
				
				System.out.println("Introduce el nombre de producto a buscar");
				nombre=entrada2.nextLine();
				
				for (Productos producto : productos) {
					if(producto.getNombre().equalsIgnoreCase(nombre)) {
						nombreEncontrado=true;
						System.out.println(producto.toString());
					}
				}
				
				if(!nombreEncontrado) {
					System.err.println("El nombre no corresponde a ningun producto de nuestro alamacen");
				}
				
				break;
			case 3:
				double precio=0;
				boolean precioEncontrado=false;
				
				try {
					do {
						System.out.println("Introduce el precio a buscar:");
						precio=Double.parseDouble(entrada2.nextLine());
						
						if(precio<0.01) {
							System.out.println("Los precios no pueden ser 0 o negativos, introducelo de nuevo");
						}
					}while(precio<0.01);
					
				}catch(NumberFormatException e) {
					System.err.println("Formato de precio no valido");
				}
				
				for (Productos producto: productos) {
					if(producto.getPrecio()==precio) {
						precioEncontrado=true;
						System.out.println(producto.toString());
					}
				}
				
				if(!precioEncontrado) {
					System.err.println("No hay productos de ese precio en nuestro alamacen");
				}
				break;
			case 4:
				int cantidad=0;
				boolean cantidadEncontrado=false;
				
				try {
					do {
						System.out.println("Introduce la cantidad a buscar:");
						cantidad=Integer.parseInt(entrada2.nextLine());
						
						if(cantidad<0) {
							System.out.println("No existe el stock negativo, introducelo de nuevo");
						}
					}while(cantidad<0);
					
				}catch(NumberFormatException e) {
					System.err.println("Formato de cantidad no valido");
				}
				
				for (Productos producto: productos) {
					if(producto.getCantidad()==cantidad) {
						cantidadEncontrado=true;
						System.out.println(producto.toString());
					}
				}
				
				if(!cantidadEncontrado) {
					System.err.println("No hay articulos con esa cantidad en nuestro alamacen");
				}
				break;
			case 5:
				String categoria;
				boolean categoriaEncontrado=false;
				
				System.out.println("Introduce la categoria del producto a buscar");
				categoria=entrada2.nextLine();
				
				for (Productos producto : productos) {
					if(producto.getCategoria().equalsIgnoreCase(categoria)) {
						categoriaEncontrado=true;
						System.out.println(producto.toString());
					}
				}
				
				if(!categoriaEncontrado) {
					System.err.println("La categoria no corresponde a ningun producto de nuestro alamacen");
				}
				break;
			case 6:
				System.out.println("Volviendo al menu pricipal");
				break;
			default:
				System.out.println("Opcion no reflejada en el menu, intentalo de nuevo");
				break;
				
			}
		}while(menu!=6);
		
	}
	public void sumarInventario() {
		if(productos.size()==0) {
			System.out.println("Todavia no hay productos en el inventario");
			return;
		}
		double sumaInventario=0;
		
		for (Productos producto : productos) {
			sumaInventario+=(producto.getCantidad()*producto.getPrecio());
		}
		
		System.out.println("El valor de todo el inventario asciende a " + sumaInventario + "€"); 
		
	}
	public void generarinformes() {
		int contadorAgotados=0;
		if(productos.size()==0) {
			System.out.println("Todavia no hay productos en el inventario");
			return;
		}else {
			
			for (Productos producto: productos) {
				if(producto.getCantidad()==0) {
					contadorAgotados++;
					break;
				}
			}
		}
		if(contadorAgotados==0) {
			System.out.println("No hay productos sin stock en el inventario");
		}else {
			System.out.println("Listado de productos sin stock");
			for (Productos producto : productos) {
				System.out.println(producto.toString()); 
			}
		}
	}
	
}

class Productos extends Inventario{
	private int codigo;
	private String nombre;
	private double precio;
	private int cantidad;
	private String categoria;
	
	public Productos(int codigo, String nombre, double precio, int cantidad, String categoria) {
		super();
		this.codigo = codigo;
		this.nombre = nombre;
		this.precio = precio;
		this.cantidad = cantidad;
		this.categoria = categoria;
	}

	public Productos() {
		super();
	}

	/**
	 * @return the codigo
	 */
	public int getCodigo() {
		return codigo;
	}

	/**
	 * @param codigo the codigo to set
	 */
	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @return the precio
	 */
	public double getPrecio() {
		return precio;
	}

	/**
	 * @param precio the precio to set
	 */
	public void setPrecio(double precio) {
		this.precio = precio;
	}

	/**
	 * @return the cantidad
	 */
	public int getCantidad() {
		return cantidad;
	}

	/**
	 * @param cantidad the cantidad to set
	 */
	public void setCantidad(int cantidad) {
		this.cantidad = cantidad;
	}

	/**
	 * @return the categoria
	 */
	public String getCategoria() {
		return categoria;
	}

	/**
	 * @param categoria the categoria to set
	 */
	public void setCategoria(String categoria) {
		this.categoria = categoria;
	}

	@Override
	public String toString() {
		return "Codigo: " + codigo + "   |   Nombre: " + nombre + "   |   Precio: " + precio + "   |   Cantidad: " + cantidad
				+ "   |   Categoria: " + categoria;
	}
	
	
	
}

Ejercicio 15

Desarrolla un sistema en Java para administrar el personal de una empresa. El sistema debe permitir gestionar distintos tipos de empleados, como empleados regulares, gerentes y directores. Cada tipo de empleado tiene características específicas y el sistema debe ser capaz de manejarlas adecuadamente. Funcionalidades del Sistema: Registro de Empleados: El sistema debe permitir registrar nuevos empleados, incluyendo detalles como nombre, edad, salario base y departamento al que pertenecen. Cálculo de Salario: El sistema debe ser capaz de calcular el salario mensual de cada empleado. El salario base puede variar según el tipo de empleado, y se le pueden aplicar bonificaciones o deducciones adicionales. Listado de Empleados: El sistema debe poder mostrar un listado de todos los empleados registrados, mostrando sus detalles como nombre, edad, salario y departamento. Búsqueda de Empleados: Debe ser posible buscar empleados por diferentes criterios, como nombre, departamento o rango salarial. Estructura del Sistema: El sistema estará compuesto por las siguientes clases y una clase abstracta: Clase abstracta Empleado: Esta clase representará a un empleado genérico en la empresa. Deberá contener métodos abstractos para calcular el salario mensual y para mostrar los detalles del empleado. Clase Regular: Esta clase representará a un empleado regular en la empresa. Deberá extender la clase Empleado e implementar los métodos abstractos con la lógica específica para calcular el salario y mostrar los detalles. Clase Gerente: Esta clase representará a un gerente en la empresa. Deberá extender la clase Empleado e implementar los métodos abstractos con la lógica específica para calcular el salario y mostrar los detalles. Clase Director: Esta clase representará a un director en la empresa. Deberá extender la clase Empleado e implementar los métodos abstractos con la lógica específica para calcular el salario y mostrar los detalles. Consideraciones Adicionales: Utiliza los conceptos de herencia y polimorfismo para organizar y manejar los diferentes tipos de empleados en el sistema. Asegúrate de realizar una correcta encapsulación de los atributos de cada clase y utiliza métodos getters y setters según sea necesario. Implementa una interfaz de usuario sencilla para interactuar con el sistema, permitiendo al usuario realizar las diferentes operaciones mencionadas.

package abstraccion;

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

public class Ejercicio15 {

	public static void main(String[] args) {
		Scanner entrada= new Scanner(System.in);
		int menu=0,menuAlta=0,menuInformes=0;
		Operaciones operaciones=new Operaciones();
		Regular regular=new Regular();
		Gerente gerente=new Gerente();
		Director director=new Director();
		do {
			System.out.println("Empleados");
			System.out.println("(1).Dar alta empleado");
			System.out.println("(2).Detalles de empleados");
			System.out.println("(3).Busqueda de empleados");
			System.out.println("Escoge opcion:");
			try {
				menu=Integer.parseInt(entrada.nextLine());
				
				switch(menu) {
				case 1:
					do {
						System.out.println("Dar altas de empleados");
						System.out.println("(1).Dar alta regular");
						System.out.println("(2).Dar alta gerente");
						System.out.println("(3).Dar alta director");
						System.out.println("(4).Volver a menu principal");
						System.out.println("Escoge opcion:");
						try {
							menuAlta=Integer.parseInt(entrada.nextLine());
							
							switch(menuAlta) {
							case 1:
								operaciones.altaEmpleados("regular");
								break;
							case 2:
								operaciones.altaEmpleados("gerente");
								break;
							case 3:
								operaciones.altaEmpleados("director");
								break;
							default:
								System.out.println("opcion no contemplada, vuelve a intentarlo");
								break;
								
							}
						}catch(NumberFormatException e) {
							System.err.println("Formato de opcion no valida, vuelve a intentarlo");
						}
					}while(menuAlta!=4);
					break;
				case 2:
					do {
						System.out.println("Informes de empleados");
						System.out.println("(1).Informes de empleados regulares");
						System.out.println("(2).Informes de gerentes");
						System.out.println("(3).Informes de directores");
						System.out.println("(4).Volver a menu principal");
						System.out.println("Escoge opcion:");
						try {
							menuInformes=Integer.parseInt(entrada.nextLine());
							
							switch(menuInformes) {
							case 1:
								regular.detallesEmpleado();
								break;
							case 2:
								gerente.detallesEmpleado();
								break;
							case 3:
								director.detallesEmpleado();
								break;
							case 4:
								System.out.println("Volviendo al menu principal");
								break;
							default:
								System.out.println("opcion no contemplada, vuelve a intentarlo");
								break;
								
							}
						}catch(NumberFormatException e) {
							System.err.println("Formato de opcion no valida, vuelve a intentarlo");
						}
					}while(menuInformes!=4);
					break;
				case 3:
					operaciones.detallesEmpleado();
					break;
				default:
					System.out.println("Opcion no contemplada en el menu, intentalo de nuevo"); 
					break;
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion menu no valido, intentalo de nuevo");
			}
		}while(menu!=4);

	}

}

abstract class Empleada{
	protected int codigo;
	protected String nombre;
	protected int edad;
	protected double salarioBase;
	protected String departamento;
	protected static ArrayList<Empleada> empleados=new ArrayList<Empleada>();
	private static int generoCodigo=0;
	
		
	public Empleada(int codigo, String nombre, int edad, double salarioBase, String departamento) {
		super();
		this.codigo = codigo;
		this.nombre = nombre;
		this.edad = edad;
		this.salarioBase = salarioBase;
		this.departamento = departamento;
	}
	
	
	/**
	 * @return the codigo
	 */
	public int getCodigo() {
		return codigo;
	}


	/**
	 * @param codigo the codigo to set
	 */
	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}


	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}


	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}


	/**
	 * @return the edad
	 */
	public int getEdad() {
		return edad;
	}


	/**
	 * @param edad the edad to set
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}


	/**
	 * @return the salarioBase
	 */
	public double getSalarioBase() {
		return salarioBase;
	}


	/**
	 * @param salarioBase the salarioBase to set
	 */
	public void setSalarioBase(double salarioBase) {
		this.salarioBase = salarioBase;
	}


	/**
	 * @return the departamento
	 */
	public String getDepartamento() {
		return departamento;
	}


	/**
	 * @param departamento the departamento to set
	 */
	public void setDepartamento(String departamento) {
		this.departamento = departamento;
	}


	/**
	 * @return the generoCodigo
	 */
	public static int getGeneroCodigo() {
		return generoCodigo;
	}


	/**
	 * @param generoCodigo the generoCodigo to set
	 */
	public static void setGeneroCodigo(int generoCodigo) {
		Empleada.generoCodigo = generoCodigo;
	}

	
	
	@Override
	public String toString() {
		return "Codigo: " + codigo + "   |   Nombre: " + nombre + "   |   Edad: " + edad + "   |   Salario Base: " + salarioBase
				+ "   |   Departamento: " + departamento;
	}

	public int generoCodigo() {
		
		return ++generoCodigo; 
	}
	
	abstract void calcularSalario();
	abstract void detallesEmpleado();
}

class Regular extends Empleada{
	
	private String cargo;
	
	public Regular(int codigo, String nombre, int edad, double salarioBase, String departamento,String cargo) {
		super(codigo, nombre, edad, salarioBase, departamento);
		this.cargo="operario";
	}
	public Regular() {
		super(0,"",0,0,"");
	}
			
	/**
	 * @return the cargo
	 */
	public String getCargo() {
		return cargo;
	}




	/**
	 * @param cargo the cargo to set
	 */
	public void setCargo(String cargo) {
		this.cargo = cargo;
	}

	


	@Override
	public String toString() {
		String cadena=super.toString();
		return cadena + "   |   Cargo: " + cargo;
	}

	@Override
	public void calcularSalario() {
		double bonus=0;
		if(this.edad<25) {
			bonus=100;
		}else if(edad>=25 && edad<=60) {
			bonus=300;
		}else if(edad>60) {
			bonus=500;
		}
		setSalarioBase(getSalarioBase()+bonus);
	}
	
	@Override
	public void detallesEmpleado() {
		for (Empleada empleada : empleados) {
			if(empleada instanceof Regular) {
				System.out.println(empleada.toString());
			}
		}
		
	}
	
	public void altaEmpleados() {
		
	}
}

class Gerente extends Empleada{
	
	private String cargo;
	
	public Gerente(int codigo, String nombre, int edad, double salarioBase, String departamento,String cargo) {
		super(codigo, nombre, edad, salarioBase, departamento);
		this.cargo="gerente";
	}
	public Gerente() {
		super(0,"",0,0,"");
	}
	
	/**
	 * @return the cargo
	 */
	public String getCargo() {
		return cargo;
	}




	/**
	 * @param cargo the cargo to set
	 */
	public void setCargo(String cargo) {
		this.cargo = cargo;
	}

	@Override
	public String toString() {
		String cadena=super.toString();
		return cadena + "   |   Cargo: " + cargo;
	}
	
	@Override
	public void calcularSalario() {
		double bonus=0;
		if(this.edad<25) {
			bonus=250;
		}else if(edad>=25 && edad<=60) {
			bonus=500;
		}else if(edad>60) {
			bonus=750;
		}
		setSalarioBase(getSalarioBase()+bonus);
	}
	
	@Override
	public void detallesEmpleado() {
		for (Empleada empleada : empleados) {
			if(empleada instanceof Gerente) {
				System.out.println(empleada.toString());
			}
		}
	}
}

class Director extends Empleada{
	
	private String cargo;
	
	public Director(int codigo, String nombre, int edad, double salarioBase, String departamento,String cargo) {
		super(codigo, nombre, edad, salarioBase, departamento);
		this.cargo="director";
	}
	public Director() {
		super(0,"",0,0,"");
	}
	
	/**
	 * @return the cargo
	 */
	public String getCargo() {
		return cargo;
	}




	/**
	 * @param cargo the cargo to set
	 */
	public void setCargo(String cargo) {
		this.cargo = cargo;
	}

	@Override
	public String toString() {
		String cadena=super.toString();
		return cadena + "   |   Cargo: " + cargo;
	}
	
	@Override
	public void calcularSalario() {
		double bonus=0;
		if(this.edad<25) {
			bonus=700;
		}else if(edad>=25 && edad<=60) {
			bonus=1000;
		}else if(edad>60) {
			bonus=2500;
		}
		setSalarioBase(getSalarioBase()+bonus);
	}
	
	@Override
	public void detallesEmpleado() {
		for (Empleada empleada : empleados) {
			if(empleada instanceof Director) {
				System.out.println(empleada.toString());
			}
		}
	}
}

class Operaciones extends Empleada{
		
	public Operaciones(){
		super(0, "", 0, 0.0, "");
	}

	@Override
	public void calcularSalario() {
		
	}
	
	@Override
	public void detallesEmpleado() {
		Scanner entrada2 =new Scanner(System.in);
		String nombre,departamento;
		double sueldoMin, sueldoMax;
		int menu=0;
		
		do {
			System.out.println("Menu de busqueda:");
			System.out.println("(1).Busqueda por nombre");
			System.out.println("(2).Busqueda por departamento");
			System.out.println("(3).Busqueda por rango salarial");
			System.out.println("(4).Volver a menu principal");
			System.out.println("Escoge opcion:");
			try {
				menu=Integer.parseInt(entrada2.nextLine());
				
				switch(menu) {
				case 1:
					System.out.println("Introduce el nombre a buscar:");
					nombre=entrada2.nextLine();
					System.out.println("Lista de empleados regulares");
					for (Empleada empleada : empleados) {
						if(empleada.getNombre().equalsIgnoreCase(nombre) && empleada instanceof Regular) {
							System.out.println(empleada.toString());
						}
					}
					
					System.out.println("Lista de empleados gerentes");
					for (Empleada empleada : empleados) {
						if(empleada.getNombre().equalsIgnoreCase(nombre) && empleada instanceof Gerente) {
							System.out.println(empleada.toString());
						}
					}
					
					System.out.println("Lista de empleados directores");
					for (Empleada empleada : empleados) {
						if(empleada.getNombre().equalsIgnoreCase(nombre) && empleada instanceof Director) {
							System.out.println(empleada.toString());
						}
					}
					break;
				case 2:
					System.out.println("Introduce el departamento a buscar:");
					departamento=entrada2.nextLine();
					System.out.println("Lista de empleados regulares del departamento de " + departamento);
					for (Empleada empleada : empleados) {
						if(empleada.getDepartamento().equalsIgnoreCase(departamento) && empleada instanceof Regular) {
							System.out.println(empleada.toString());
						}
					}
					
					System.out.println("Lista de empleados gerentes del departamento de " + departamento);
					for (Empleada empleada : empleados) {
						if(empleada.getDepartamento().equalsIgnoreCase(departamento) && empleada instanceof Gerente) {
							System.out.println(empleada.toString());
						}
					}
					
					System.out.println("Lista de empleados directores del departamento de " + departamento);
					for (Empleada empleada : empleados) {
						if(empleada.getDepartamento().equalsIgnoreCase(departamento) && empleada instanceof Director) {
							System.out.println(empleada.toString());
						}
					}
					break;
				case 3:
					while(true) {
						try {
							System.out.println("Introduce el sueldo min de busqueda:");
							sueldoMin=Double.parseDouble(entrada2.nextLine());
							if(sueldoMin<1050) {
								System.out.println("El sueldo minimo es España es de 1050, introducelo de nuevo");
							}
							else {
								break;
							}
						}catch(NumberFormatException e){
							System.err.println("Formato de sueldo no valido introducelo de nuevo");
						}
					}
					
					while(true) {
						try {
							System.out.println("Introduce el sueldo max de busqueda:");
							sueldoMax=Double.parseDouble(entrada2.nextLine());
							if(sueldoMax<sueldoMin) {
								System.out.println("El segundo sueldo de busqueda tiene que ser mayor que " + sueldoMin + " introducelo de nuevo");
							}
							else {
								break;
							}
						}catch(NumberFormatException e){
							System.err.println("Formato de sueldo no valido introducelo de nuevo");
						}
					}
					
					System.out.println("Lista de empleados regulares con sueldos entre " + sueldoMin + "€ y " + sueldoMax + "€");
					for (Empleada empleada : empleados) {
						if(empleada.getSalarioBase()>=sueldoMin && empleada.getSalarioBase()<=sueldoMax && empleada instanceof Regular) {
							System.out.println(empleada.toString());
						}
					}
					
					System.out.println("Lista de empleados gerentes con sueldos entre " + sueldoMin + "€ y " + sueldoMax + "€");
					for (Empleada empleada : empleados) {
						if(empleada.getSalarioBase()>=sueldoMin && empleada.getSalarioBase()<=sueldoMax && empleada instanceof Gerente) {
							System.out.println(empleada.toString());
						}
					}
					
					System.out.println("Lista de empleados directores con sueldos entre " + sueldoMin + "€ y " + sueldoMax + "€");
					for (Empleada empleada : empleados) {
						if(empleada.getSalarioBase()>=sueldoMin && empleada.getSalarioBase()<=sueldoMax && empleada instanceof Director) {
							System.out.println(empleada.toString());
						}
					}
					break;
				case 4:
					System.out.println("Volviendo al menu principal");
					break;
				default:
					System.out.println("Opcion no contemplada, vuelve a intentarlo");
					break;
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de opcion menu no valido, vuelve a intentarlo"); 
			}
		}while(menu!=4);
		
		
	}
	
	public void altaEmpleados(String tipo) {
		String nombre="",departamento="";
		int edad=0,codigo=0;
		double salarioBase=0;
		Scanner entrada2=new Scanner(System.in);
		
		
		System.out.println("Introduce el nombre del empleado");
		nombre=entrada2.nextLine();
		
		do{
			try {
				System.out.println("Introduce la edad del empleado " + nombre);
				edad=Integer.parseInt(entrada2.nextLine());
				if(edad<16 || edad>66) {
					System.out.println("La edad legal para trabajar en España es de 16 a 66, vuelve a introducirla");
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de edad no valido");
			}
		}while(edad<16 || edad>66);
		
		do{
			try {
				System.out.println("Introduce el sueldo del empleado " + nombre);
				salarioBase=Double.parseDouble(entrada2.nextLine());
				if(salarioBase<1050) {
					System.out.println("El sueldo minimo a jornada completa en España es de 1050€, vuelve a introducirlo");
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de sueldo no valido");
			}
		}while(salarioBase<1050);
		
		System.out.println("Introduce el departamento del empleado " + nombre);
		departamento=entrada2.nextLine();
		
		codigo=generoCodigo();
		switch(tipo) {
		case "regular":
			Regular regular=new Regular(codigo,nombre,edad,salarioBase,departamento,"");
			regular.calcularSalario();
			empleados.add(regular);
			System.out.println(regular.toString());
			break;
		case "gerente":
			Gerente gerente=new Gerente(codigo,nombre,edad,salarioBase,departamento,"");
			gerente.calcularSalario();
			empleados.add(gerente);
			break;
		case "director":
			Director director=new Director(codigo,nombre,edad,salarioBase,departamento,"");
			director.calcularSalario();
			empleados.add(director);
			break;
		}
		
		System.out.println("Empleado " + nombre + " dado de alta correctamente");
	}
	
	
}