Ejercicio 1
Crea una clase llamada Libro que tenga atributos como titulo, autor, añoPublicacion, y isbn. Luego, desarrolla una clase llamada Biblioteca que pueda almacenar varios libros. Implementa métodos para agregar libros a la biblioteca, buscar libros por título o autor, y mostrar la información de todos los libros en la biblioteca.
package p;
import java.util.Scanner;
public class Libro1 {
private String titulo;
private String autor;
private int anioPublicacion;
private String isbm;
public Libro1(String titulo,String autor,int anioPublicacion,String isbm) {
this.titulo=titulo;
this.autor=autor;
this.anioPublicacion=anioPublicacion;
this.isbm=isbm;
}
public void getMostrar() { //getter
System.out.println("Titulo: "+titulo);
System.out.println("Autor: "+autor);
System.out.println("anioPublicacion: "+anioPublicacion);
System.out.println("ISBM: "+isbm);
}
public void getBuscarTitulo(String titulo) { //getter
if(this.titulo.equalsIgnoreCase(titulo)) {
getMostrar();
}
}
public void getBuscarAutor(String autor) { //getter
if(this.autor.equalsIgnoreCase(autor)) {
getMostrar();
}
}
public static void main(String[] args)
{
Libro1 libro1=new Libro1("Gabriel Garcia Marquez","Cronica de una muerte anunciada",2003,"0002589");
Libro1[] libro=new Libro1[5];
Scanner leer=new Scanner(System.in);
int opcion=0;
do {
System.out.println("BIBLIOTECA");
System.out.println("(1).Agregar libros");
System.out.println("(2).Buscar por autor");
System.out.println("(3).Buscar por titulo");
System.out.println("(4).Listar");
System.out.println("(5).Salir");
System.out.println("OPCION:");
opcion=leer.nextInt();
switch(opcion)
{
case 1:
String titulo;
String autor;
int anioPublicacion;
String isbm;
for(int i=0;i<5;i++)
{
System.out.println("Introduce el titulo del libro "+(i+1)+"/5");
titulo=leer.next();
System.out.println("Introduce el autor del libro "+titulo);
autor=leer.next();
System.out.println("Introduce el año de publicacion del libro "+titulo);
anioPublicacion=leer.nextInt();
System.out.println("Introduce el ISBM del libro "+titulo);
isbm=leer.next();
libro[i]=new Libro1(titulo,autor,anioPublicacion,isbm);
}
break;
case 2:
System.out.println("Introduce un autor a buscar:");
autor=leer.next();
for(Libro1 l:libro)
{
l.getBuscarAutor(autor);
}
break;
case 3:
System.out.println("Introduce el titulo a buscar:");
titulo=leer.next();
for(Libro1 l:libro) {
l.getBuscarTitulo(titulo);
}
break;
case 4:
for(Libro1 l:libro) {
l.getMostrar();
}
break;
case 5:
System.out.println("Saliendo de la bibiloteca");
break;
default:
System.out.println("No existe esa opcion");
break;
}
}while(opcion!=5);
}
}
Ejercicio 2
Crea una clase estudiante con los nombre,edad,carnet,curso a continuacion crea lo metodos necesarios para buscar por carnet, mostrar datos del estudiante,calcular la media de edad de todoslos estudiantes y agregar estudiantes
package p;
import java.util.Scanner;
public class Estudiante {
private String nombre;
private int edad;
private String carnet;
private String curso;
public Estudiante(String nombre, int edad, String carnet, String curso) {
this.nombre = nombre;
this.edad = edad;
this.carnet = carnet;
this.curso = curso;
}
public void getBuscarCarnet(Estudiante[] estudiantes, String carnet) {
Scanner leer = new Scanner(System.in);
boolean encontrado = false;
for (Estudiante e : estudiantes) {
if (e != null && e.carnet.equalsIgnoreCase(carnet)) {
encontrado = true;
System.out.println("Nombre: " + e.nombre);
System.out.println("Edad: " + e.edad);
System.out.println("Carnet: " + e.carnet);
System.out.println("Curso: " + e.curso);
}
}
if (!encontrado) {
System.out.println("El estudiante no estudia aquí.");
}
}
public double getCalcularMedia(Estudiante[] estudiantes, int contadorEstudiantes) {
double suma = 0;
for (int i = 0; i < contadorEstudiantes; i++) {
suma += estudiantes[i].edad;
}
return suma / contadorEstudiantes;
}
public static void main(String[] args) {
int opcion = 0;
Estudiante[] estudiantes = new Estudiante[5];
int contadorEstudiantes = 0;
Scanner leer = new Scanner(System.in);
do {
System.out.println("Universidad");
System.out.println("(1).Agregar estudiante");
System.out.println("(2).Buscar estudiante");
System.out.println("(3).Calcular media");
System.out.println("(4).Salir");
System.out.println("Opcion:");
opcion = leer.nextInt();
switch (opcion) {
case 1:
if (contadorEstudiantes < estudiantes.length) {
String nombre, carnet, curso;
int edad;
System.out.println("Introduce nombre del estudiante:");
nombre = leer.next();
System.out.println("Introduce edad del estudiante:");
edad = leer.nextInt();
System.out.println("Introduce el carnet del estudiante:");
carnet = leer.next();
System.out.println("Introduce el curso del estudiante:");
curso = leer.next();
estudiantes[contadorEstudiantes] = new Estudiante(nombre, edad, carnet, curso);
contadorEstudiantes++;
} else {
System.out.println("La universidad está llena. No se pueden agregar más estudiantes.");
}
break;
case 2:
System.out.println("Introduce un carnet a buscar:");
String carnetBuscar = leer.next();
boolean encontrado = false;
for (int i = 0; i < contadorEstudiantes; i++) {
if (estudiantes[i] != null && estudiantes[i].carnet.equalsIgnoreCase(carnetBuscar)) {
encontrado = true;
estudiantes[i].getBuscarCarnet(estudiantes,carnetBuscar);
break;
}
}
if (!encontrado) {
System.out.println("El estudiante no estudia aquí.");
}
break;
case 3:
if (contadorEstudiantes > 0) {
System.out.println("La edad media de la universidad es: " + estudiantes[0].getCalcularMedia(estudiantes, contadorEstudiantes));
} else {
System.out.println("No hay estudiantes en la universidad.");
}
break;
case 4:
System.out.println("Universidad cerrando");
break;
default:
System.out.println("No existe esa opcion");
break;
}
} while (opcion != 4);
}
}
Ejercicio 3
Crea una clase impresora con los campos marca.modelo,color,tipotinta,ppm,multifuncion a continuacion crea lo metodos necesarios para recargar la tinta al 100%, imprmir(cada hoja restara 1% tinta) y consultar nivel de tinta asi como unmetodo que muestre todos los atributos de la impresora y prueba la clase, la impresora de inicia con los cartuchos o toner de regalo al comprarla que vienen con uan carga del 50%
package p;
public class Impresora {
private String marca;
private String modelo;
private String color;
private String tipoTinta;
private int ppm;
private boolean multifuncion;
private int nivelTinta=50;
public Impresora(String marca,String modelo,String color,String tipoTinta,int ppm,boolean multifuncion) {
this.marca=marca;
this.modelo=modelo;
this.color=color;
this.tipoTinta=tipoTinta;
this.ppm=ppm;
this.multifuncion=multifuncion;
}
public String getDatosImpresora() {//getter
String multi="";
if(this.multifuncion) {
multi="Si";
}else {
multi="No";
}
return "Marca: "+this.marca+
"\nModelo :"+this.modelo+
"\nColor :"+this.color+
"\nTipoTinta :"+this.tipoTinta+
"\nPPM :"+this.ppm+
"\nMultifuncion :"+multi+
"\nNivel :"+this.nivelTinta;
}
public int getConsultarNivelTinta() {
return this.nivelTinta;
}
public void setMarca(String marca) {//setter
this.marca=marca;
}
public void setModelo(String modelo) {//setter
this.modelo=modelo;
}
public void setColor(String color) {//setter
this.color=color;
}
public void setTipoTinta(String tipoTinta) {//setter
this.tipoTinta=tipoTinta;
}
public void setPpm(int ppm) {//setter
this.ppm=ppm;
}
public void setMultifuncion(boolean multifuncion) {//setter
this.multifuncion=multifuncion;
}
public void setRecargar(int nivelTinta) {//setter
this.nivelTinta=100;
}
public void setImprimir(int numPaginas) {
//Cada pagina baja la tinta un 1%;
if(this.nivelTinta-numPaginas<0) {
System.out.println("Agotada tinta, quedaron sin imprimier "+(numPaginas-this.nivelTinta));
this.nivelTinta=0;
}else if (this.nivelTinta==0) {
System.out.println("Tienes que cambiar el cartucho antes de imprimir,impresion cancelada");
}else {
this.nivelTinta-=numPaginas;
}
}
public static void main(String[] args) {
Impresora printer1=new Impresora("Hp","Deskjet 3520","Color","Cartucho",17,true);
System.out.println(printer1.getDatosImpresora());
System.out.println("Nivel de tinta estimado:"+printer1.getConsultarNivelTinta());
printer1.setRecargar(0);
System.out.println("Nivel de tinta estimado:"+printer1.getConsultarNivelTinta());
printer1.setImprimir(99);
System.out.println("Nivel de tinta estimado:"+printer1.getConsultarNivelTinta());
printer1.setImprimir(9);
}
}
Ejercicio 4
Crea una clase llamada Vehiculo con los siguientes atributos: marca, modelo, año, color y kilometraje. La clase debe tener un constructor para inicializar estos atributos y métodos getter y setter para acceder y modificar la información del vehículo. En el método main, instancia al menos dos objetos de la clase Vehiculo con información diferente y muestra los detalles de ambos vehículos en la consola.
package p;
public class Vehiculo {
private String marca;
private String modelo;
private int anio;
private String color;
private int km;
public Vehiculo(String marca,String modelo,int anio,String color,int km) {
this.marca=marca;
this.marca=modelo;
this.anio=anio;
this.color=color;
this.km=km;
}
public String getmarca() {//getter
return this.marca;
}
public String getmodelo() {//getter
return this.modelo;
}
public int getanio() {//getter
return this.anio;
}
public String getcolor() {//getter
return this.color;
}
public int getkm() {//getter
return this.km;
}
public void setMarca(String marca) {//setter
this.marca=marca;
}
public void setModelo(String modelo) {//setter
this.modelo=modelo;
}
public void setAnio(int anio) {//setter
this.anio=anio;
}
public void setColor(String color) {//setter
this.color=color;
}
public void setKm(int km) {//setter
this.km=km;
}
public static void main(String[] args) {
Vehiculo coche=new Vehiculo("Renault","R5",1986,"Amarillo",350000);
Vehiculo moto=new Vehiculo("Honda","XRE",2003,"Negra",175000);
System.out.println("Marca: "+coche.marca);
System.out.println("Modelo: "+coche.modelo);
System.out.println("Anio: "+coche.anio);
System.out.println("Color: "+coche.color);
System.out.println("km: "+coche.km);
System.out.println("\n\n");
System.out.println("Marca: "+coche.marca);
System.out.println("Modelo: "+coche.modelo);
System.out.println("Anio: "+coche.anio);
System.out.println("Color: "+coche.color);
System.out.println("km: "+coche.km);
coche.setAnio(1500);
coche.setColor("Rosa");
System.out.println("Marca: "+coche.marca);
System.out.println("Modelo: "+coche.modelo);
System.out.println("Anio: "+coche.anio);
System.out.println("Color: "+coche.color);
System.out.println("km: "+coche.km);
}
}
Ejercicio 5
Crea una clase llamada CuentaBancaria que represente una cuenta bancaria simple. La clase debe tener los siguientes atributos: titular (nombre del titular de la cuenta), saldo (saldo actual de la cuenta) y numeroCuenta (número de cuenta). La clase debe tener un constructor para inicializar estos atributos, así como métodos depositar y retirar para realizar operaciones en la cuenta. Además, implementa un método mostrarInformacion que imprima en la consola los detalles de la cuenta (titular, saldo y número de cuenta). En el método main, instancia un objeto de la clase CuentaBancaria, realiza algunas operaciones de depósito y retiro, y muestra la información de la cuenta en la consola
package p;
import java.util.Scanner;
public class CuentaBancaria {
private String titular;
private double saldo;
private String numeroCuenta;
public CuentaBancaria(String titular,double saldo,String numeroCuenta) {
this.titular=titular;
this.saldo=saldo;
this.numeroCuenta=numeroCuenta;
}
public void setDepositar(double deposito) {//setter
this.saldo+=deposito;
System.out.println("Ingreso correcto");
}
public void setRetirar(double retiro) {//setter
if(this.saldo>=retiro) {
this.saldo-=retiro;
}else {
System.out.println("Saldo insuficiente no se puede hacer la operacion");
}
if(this.saldo==0) {
System.out.println("Cuenta a 0!!!!");
}
}
public String getMostrarInformacion() {
return "\nTitular: " +this.titular +
"\nSaldo: " +this.saldo +
"\nIBAN: " +this.numeroCuenta;
}
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
CuentaBancaria cuenta=new CuentaBancaria("Carlos Fernández García",5948.69,"82-5689-2365-4556-4528-36");
int opcion;
do {
System.out.println("CAJERO AUTOMATICO");
System.out.println("(1).Consultar Cuenta");
System.out.println("(2).Ingresar dinero");
System.out.println("(3).Retirar dinero");
System.out.println("(4).Salir");
System.out.println("Introduce opcion:");
opcion=entrada.nextInt();
switch (opcion) {
case 1:
System.out.println(cuenta.getMostrarInformacion());
break;
case 2:
double deposito=0;
do {
System.out.println("¿Que cantidad quieres ingresar por cajero?");
deposito=entrada.nextDouble();
}while(deposito<=0);
cuenta.setDepositar(deposito);
break;
case 3:
double retiro=0;
do {
System.out.println("¿Que cantidad quieres retirar de la cuenta?");
retiro=entrada.nextDouble();
}while(retiro<=0);
cuenta.setRetirar(retiro);
break;
case 4:
System.out.println("Retire su tarjeta, vuelva cuando quiera");
break;
default:
break;
}
}while(opcion!=4);
}
}
Ejercicio 6
Crea una clase llamada Empleado que represente a un empleado de una empresa. La clase debe tener los siguientes atributos: nombre, apellido, salarioMensual y cargo. El atributo cargo debe ser una enumeración llamada Cargos que contenga valores como "GERENTE", "ANALISTA", "DESARROLLADOR", etc. La clase Empleado debe tener un constructor para inicializar estos atributos y métodos getter y setter para acceder y modificar la información del empleado. En el método main, instancia al menos tres objetos de la clase Empleado con información diferente y realiza las siguientes operaciones: Muestra en la consola la información de cada empleado. Aumenta el salario de un empleado en un 10%. Cambia el cargo de otro empleado. Muestra nuevamente la información de cada empleado.
package p;
public class Empleados {
enum Cargos{
Gerente,Analista,Desarrollador;
}
private String nombre;
private String apellido;
private double salarioMensual;
private Cargos cargo;
public Empleados(String nombre,String apellido,double salarioMensual,Cargos cargo) {
this.nombre=nombre;
this.apellido=apellido;
this.salarioMensual=salarioMensual;
this.cargo=cargo;
}
public String getNombre() {//getter
return this.nombre;
}
public String getApellido() {//getter
return this.apellido;
}
public double getSalarioMensual() {//getter
return this.salarioMensual;
}
public Cargos getCargo() {//getter
return this.cargo;
}
public void setNombre(String nombre) {//setter
this.nombre=nombre;
}
public void setApellido(String apellido) {//setter
this.apellido=apellido;
}
public void setSalarioMensual(double salarioMensual) {//setter
this.salarioMensual=salarioMensual;
}
public void setCargo(Cargos cargo) {//setter
this.cargo=cargo;
}
public static void main(String[] args) {
Empleados[] empleados=new Empleados[3];
empleados[0]=new Empleados("Carlos","Fernández",1666.66,Cargos.Desarrollador);
empleados[1]=new Empleados("Carmen","Rosalia",1899.99,Cargos.Analista);
empleados[2]=new Empleados("Maria","Suarez",2423.69,Cargos.Gerente);
for(Empleados e:empleados) {
mostrarDatos(e);
}
for(Empleados e:empleados) {
e.setSalarioMensual(e.salarioMensual+(e.salarioMensual*0.1));
}
empleados[1].setCargo(Cargos.Gerente);
for(Empleados e:empleados) {
mostrarDatos(e);
}
}
public static void mostrarDatos(Empleados e) {
System.out.println("Nombre:" +e.nombre);
System.out.println("Apellido:" +e.apellido);
System.out.println("Salario:" +e.salarioMensual);
System.out.println("cargo:" +e.cargo);
System.out.println("\n\n");
}
}
Ejercicio 7
Crea una clase llamada Producto que represente un producto en una tienda. La clase debe tener los siguientes atributos: nombre, precio, codigo y categoria. La categoría debe ser una enumeración llamada Categorias que contenga valores como "ELECTRONICA", "ROPA", "ALIMENTOS", etc. La clase Producto debe tener un constructor para inicializar estos atributos y métodos getter y setter para acceder y modificar la información del producto. Luego, crea una clase principal llamada GestionTienda con el método main. En el método main, instancia al menos tres objetos de la clase Producto con información diferente y realiza las siguientes operaciones: Muestra en la consola la información de cada producto. Cambia la categoría de uno de los productos. Ajusta el precio de otro producto. Muestra nuevamente la información de cada producto.
package p;
public class Productos {
enum Categorias{
Electronica,Ropa,Alimentos;
}
private String nombre;
private double precio;
private int codigo;
private Categorias categoria;
public Productos(String nombre,double precio,int codigo,Categorias categoria) {
this.nombre=nombre;
this.precio=precio;
this.codigo=codigo;
this.categoria=categoria;
}
public String getNombre() {//getter
return this.nombre;
}
public double getPrecio() {//getter
return this.precio;
}
public int getCodigo() {//getter
return this.codigo;
}
public Categorias getCategoria() {//getter
return this.categoria;
}
public void setNombre(String nombre) {//setter
this.nombre=nombre;
}
public void setPrecio(double precio) {//setter
this.precio=precio;
}
public void setCodigo(int codigo) {//setter
this.codigo=codigo;
}
public void setCategoria(Categorias categoria) {//setter
this.categoria=categoria;
}
public static void main(String[] args) {
Productos[] producto=new Productos[3];
producto[0]=new Productos("Mouse",12.25,1,Categorias.Electronica);
producto[1]=new Productos("Sudadera",39.99,2,Categorias.Ropa);
producto[2]=new Productos("Manzanas",2.47,3,Categorias.Alimentos);
for(Productos e:producto) {
e.mostrarInfo(e);
}
producto[0].setCategoria(Categorias.Ropa);
producto[1].setPrecio(29.99);
for(Productos e:producto) {
e.mostrarInfo(e);
}
}
public void mostrarInfo(Productos e) {
System.out.println("\n\nArticulo: "+e.nombre);
System.out.println("P.V.P: "+e.precio+"$");
System.out.println("Codigo: "+e.codigo);
System.out.println("Seccion: "+e.categoria);
}
}
Ejercicio 8
Crea una clase llamada Contacto que represente un contacto en una agenda. La clase debe tener los siguientes atributos: nombre, telefono y email. Además, incluye un método mostrarInformacion que imprima en la consola los detalles del contacto. En el método main, instancia al menos tres objetos de la clase Contacto con información diferente y realiza las siguientes operaciones: Muestra en la consola la información de cada contacto utilizando el método mostrarInformacion. Modifica el teléfono de uno de los contactos. Añade un nuevo contacto a la agenda. Muestra nuevamente la información de cada contacto.
import java.util.Scanner;
public class Contacto {
private String nombre;
private String telefono;
private String email;
public Contacto(String nombre,String telefono,String email) {
this.nombre=nombre;
this.telefono=telefono;
this.email=email;
}
public String getNombre() {//getter
return this.nombre;
}
public String getTelefono() {//getter
return this.telefono;
}
public String getemail() {//getter
return this.email;
}
public void setNombre(String nombre) {//setter
this.nombre=nombre;
}
public void setTelefono(String telefono) {//setter
this.telefono=telefono;
}
public void setEmail(String email) {//setter
this.email=email;
}
public String getMostrarInformacion() {//getter
return "\nNombre: "+this.nombre +
"\nTelefono: "+this.telefono +
"\nEmail: "+this.email;
}
public static void main(String[] args) {
Contacto[] agenda=new Contacto[4];
agenda[0]=new Contacto("Carlos","656656656","info@info.es");
agenda[1]=new Contacto("Maria","555222123","admin@info.es");
agenda[2]=new Contacto("Juan","888999666","service@info.es");
for(Contacto c:agenda) {
if(c!=null) {
System.out.println(c.getMostrarInformacion());
}
}
agenda[0].setTelefono("666666666");
String nombre,telefono,email;
Scanner entrada=new Scanner(System.in);
System.out.println("Introduce el nombre del contacto");
nombre=entrada.next();
System.out.println("Introduce el telefono del contacto");
telefono=entrada.next();
System.out.println("Introduce el mail del contacto");
email=entrada.next();
agenda[3]=new Contacto(nombre,telefono,email);
for(Contacto c:agenda) {
if(c!=null) {
System.out.println(c.getMostrarInformacion());
}
}
}
}
Ejercicio 9
Crea una clase llamada Contacto que represente un contacto en una agenda. La clase debe tener los siguientes atributos: nombre, telefono y email. Además, incluye un método mostrarInformacion que imprima en la consola los detalles del contacto. En el método main, instancia al menos tres objetos de la clase Contacto con información diferente y realiza las siguientes operaciones: Muestra en la consola la información de cada contacto utilizando el método mostrarInformacion. Modifica el teléfono de uno de los contactos. Añade un nuevo contacto a la agenda. Muestra nuevamente la información de cada contacto.
public class Alumno {
private String nombre;
private String apellido;
private double[] notas;
public Alumno(String nombre, String apellido, double[] notas) {
this.nombre = nombre;
this.apellido = apellido;
this.notas = notas;
}
public String getNombre() {
return this.nombre;
}
public String getApellido() {
return this.apellido;
}
public double[] getNotas() {
return this.notas;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public void setNotas(int indice, double valor) {
if (indice >= 0 && indice < this.notas.length) {
this.notas[indice] = valor;
} else {
System.out.println("Índice de nota no válido.");
}
}
public static void main(String[] args) {
Alumno[] alumnos = new Alumno[3];
double[] notasAlumno1 = {5.8, 7.5, 4.3, 6.6, 9.9, 8.75, 7.73, 4.9};
alumnos[0] = new Alumno("Carlos", "Fernández", notasAlumno1);
double[] notasAlumno2 = {5.8, 7.5, 4.3, 6.6, 9.9, 8.75, 7.73, 4.9};
alumnos[1] = new Alumno("Maria", "Sobada", notasAlumno2);
double[] notasAlumno3 = {5.8, 7.5, 4.3, 6.6, 9.9, 8.75, 7.73};
alumnos[2] = new Alumno("Paca", "Pacheco", notasAlumno3);
for(Alumno a : alumnos) {
mostrarInformacion(a);
}
alumnos[1].setNotas(3, 5.55);
alumnos[2].setNotas(7, 6.66);
for(Alumno a : alumnos) {
mostrarInformacion(a);
}
}
public static void mostrarInformacion(Alumno a) {
if (a != null) {
System.out.println("\nNombre: " + a.getNombre());
System.out.println("Apellido: " + a.getApellido());
System.out.print("Notas: ");
for(double n : a.getNotas()) {
System.out.print(n + " ");
}
System.out.println();
}
}
}
Ejercicio 10
Claro, aquí tienes un enunciado más sencillo: Crea una clase llamada Persona que represente a una persona. La clase debe tener los siguientes atributos: nombre, edad y ciudad. La clase Persona debe tener un constructor para inicializar estos atributos y métodos getter y setter para acceder y modificar la información de la persona. En el método main, instancia al menos dos objetos de la clase Persona con información diferente y realiza las siguientes operaciones: Muestra en la consola la información de cada persona (nombre, edad, ciudad). Modifica la edad de una de las personas. Agrega una nueva persona a la lista. Muestra nuevamente la información de cada persona.
import java.util.Scanner;
public class Persona {
private String nombre;
private int edad;
private String ciudad;
public Persona(String nombre,int edad,String ciudad) {
this.nombre=nombre;
this.edad=edad;
this.ciudad=ciudad;
}
public String getNombre() {//getter
return this.nombre;
}
public int getEdad() {//getter
return this.edad;
}
public String getCiudad() {//getter
return this.nombre;
}
public void setNombre(String nombre) {//setter
this.nombre=nombre;
}
public void setEdad(int edad) {//setter
this.edad=edad;
}
public void setCiudad(String ciudad) {//setter
this.ciudad=ciudad;
}
public static void main(String[] args) {
Persona[] persona=new Persona[3];
persona[0]=new Persona("Carlos",42,"Gijón");
persona[1]=new Persona("Agapito",69,"Langreo");
for(Persona p:persona) {
if(p!=null) {
mostrarInformacion(p);
}
}
persona[1].setEdad(99);
String nombre,ciudad;
int edad;
Scanner entrada=new Scanner(System.in);
System.out.println("Introduce el nombre de una nueva persona:");
nombre=entrada.next();
System.out.println("Introduce la edad de esta persona:");
edad=entrada.nextInt();
System.out.println("Introduce la ciudad de esta persona:");
ciudad=entrada.next();
persona[2]=new Persona(nombre,edad,ciudad);
for(Persona p:persona) {
if(p!=null) {
mostrarInformacion(p);
}
}
}
public static void mostrarInformacion(Persona p) {
System.out.println("\nNombre:"+p.nombre);
System.out.println("Edad:"+p.edad);
System.out.println("Ciudad:"+p.ciudad);
}
}
Ejercicio 11
Crea una aplicación en Java para gestionar una biblioteca. Debe haber clases para representar libros y usuarios de la biblioteca. Los libros deben tener un título, un autor, un año de publicación y un estado que indique si están disponibles para ser prestados o no. Los usuarios deben tener un nombre, un número de identificación y una lista de libros prestados. El sistema debe permitir: Agregar nuevos libros a la biblioteca. Prestar un libro a un usuario, marcando el libro como no disponible. Devolver un libro prestado por un usuario, marcándolo como disponible. Mostrar una lista de todos los libros de la biblioteca, indicando su disponibilidad. Mostrar los libros actualmente prestados por un usuario en particular. Mostrar una lista de todos los usuarios de la biblioteca, junto con los libros que tienen prestados. Implementa las clases necesarias con sus métodos para lograr esta funcionalidad. Además, crea una clase principal que permita interactuar con el sistema, mostrando un menú con las opciones disponibles y solicitando la entrada del usuario para realizar las acciones correspondientes.
package poo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
public class Ejercicio11 {
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
int opcion=0;
Usuarios u=new Usuarios();
Libro l=new Libro();
//ArrayList tanto como para la coleccion de libros como para la de usuarios
ArrayList<Usuarios> usuarios=new ArrayList<Usuarios>();
ArrayList<Libro> libros=new ArrayList<Libro>();
//Menu y todos los casos contemplados
do {
System.out.println(" BIBLIOTECA CARLOS");
System.out.println("1.Dar de alta usuario");
System.out.println("2.Dar de baja usuario");
System.out.println("3.Listar usuarios");
System.out.println("4.Dar de alta libro");
System.out.println("5.Dar de baja libro");
System.out.println("6.Listar libros");
System.out.println("7.Prestar libro");
System.out.println("8.Devolver libro");
System.out.println("9.Salir de la bibloteca");
System.out.println("Escoge opcion:");
try {
opcion=Integer.parseInt(entrada.next());
}catch (NumberFormatException e){
opcion=10;
}
switch(opcion) {
case 1:
u.altaUsuario(usuarios);
break;
case 2:
u.borrarUsuario(usuarios);
break;
case 3:
u.listarUsuarios(usuarios,libros);
break;
case 4:
l.altaLibro(libros);
break;
case 5:
l.borrarLibro(libros);
break;
case 6:
l.listarLibros(libros);
break;
case 7:
prestar(usuarios,libros);
break;
case 8:
devolver(usuarios,libros);
break;
case 9:
System.out.println("Biblioteca cerrada");
entrada.close();
break;
default:
System.out.println("Opcion no contemplada en el menu");
break;
}
}while(opcion!=9);
entrada.close();
}
//Metodo devolver un libro
public static void devolver(ArrayList<Usuarios> usuarios, ArrayList<Libro> libros) {
Scanner entrada2 = new Scanner(System.in);
//Compruebo que hay usuarios dados de alta
if(usuarios.size()==0) {
System.out.println("No hay usuarios dados de alta en la biblioteca");
return;
}
//Compruebo que hay libros dados de alta
if(libros.size()==0) {
System.out.println("No hay libros dados de alta en la biblioteca");
return;
}
int prestados=0;
//Compruebo que hay libros en estado de prestado
for (Libro libro : libros) {
if(!libro.getEstado()) {
prestados++;
}
}
if(prestados==0) {
System.out.println("En este momento todos no hay libros en estado de prestamo");
return;
}
int numSocio=0,socio=0;;
System.out.println("Introduce tu numero de socio:");
try {
numSocio=Integer.parseInt(entrada2.next());
}catch (NumberFormatException e) {
System.out.println("Codigo de usuario no valido");
return;
}
for (Usuarios usuario : usuarios) {
if(numSocio==usuario.getNumSocio()) {
socio++;
}
}
//Compruebo que el socio existe
if(socio==0) {
System.out.println("El usuario no esta dado de alta en la biblioteca");
return;
}
boolean prestamo=true;
ArrayList<Integer> codigos=new ArrayList<Integer>();
codigos.clear();
//Muestro lq lista de todos los libros que el usuario tiene en prestamo
System.out.println("Libros que el usuario tiene en prestamo");
for (Usuarios user : usuarios) {
for (Integer codigo:user.getLibros()) {
for (Libro libro : libros) {
if(libro.getCodigo()==codigo) {
System.out.println("("+ libro.getCodigo()+")."+ libro.getTitulo());
codigos.add(codigo);
prestamo=false;
}
}
}
}
int codigo=0;
if(prestamo) {
System.out.println("El usuario no tiene libros en estado de prestamo");
}else {
//pedimos codigo del libro a devolver
System.out.println("Introduce el codigo del libro a devolver");
try {
codigo=Integer.parseInt(entrada2.next());
}catch (NumberFormatException e) {
System.out.println("Codigo no valido");
return;
}
}
//realizamos la devolucion
Iterator<Usuarios> iterator = usuarios.iterator();
while (iterator.hasNext()) {
Usuarios usuario = iterator.next();
if (usuario.getNumSocio() == numSocio) {
Iterator<Integer> librosIterator = usuario.getLibros().iterator();
while (librosIterator.hasNext()) {
Integer cod = librosIterator.next();
if (cod == codigo) {
librosIterator.remove();
break;
}
}
}
}
for (Libro libro : libros) {
if (libro.getCodigo() == codigo) {
libro.setEstado(true);
System.out.println("Libro devuelto a la biblioteca");
break;
}
}
}
public static void prestar(ArrayList<Usuarios> usuarios,ArrayList<Libro> libros) {
int alquilados=0;
//Compruebo que la biblioteca tenga libros dados de alta
if(libros.size()==0){
System.out.println("No hay libros en la biblioteca");
return;
}
//Compruebo que no esten todos prestados
for (Libro libro : libros) {
if(libro.getEstado()) {
alquilados++;
}
}
if(alquilados==0) {
System.out.println("Todos los libros estan en estado de prestamo biblioteca vacia");
return;
}
//Comprueblo que la biblioteca tenga usuarios dados de alta
if(usuarios==null || usuarios.size()==0) {
System.out.println("No hay usuarios en la base de datos");
}else {
int numSocio,codigoLibro;
Scanner entrada2=new Scanner(System.in);
System.out.println("Introduce tu numero de socio:");
numSocio=Integer.parseInt(entrada2.next());
Iterator<Usuarios> itUser=usuarios.iterator();
boolean encontrado=true,encontradoUser=true;
while(itUser.hasNext()) {
Usuarios user=itUser.next();
if(user.getNumSocio()==numSocio) {
encontradoUser=false;
System.out.println("Listado de libros dispoibles");
for (Libro libro : libros) {
//muestro un listado de los libros que estan disponibles
if(libro.getEstado()) {
System.out.println("("+libro.getCodigo()+")."+libro.getTitulo());
}
}
System.out.println("Introduce el codigo del libro que quieres llevar de la bibloteca");
codigoLibro=Integer.parseInt(entrada2.next());
//Realizo el prestamo
Iterator<Libro> it=libros.iterator();
while(it.hasNext()) {
Libro libro=it.next();
if(libro.getCodigo()==codigoLibro) {
if(libro.getEstado()) {
libro.setEstado(false);
user.agregarLibroPrestado(libro.getCodigo());
encontrado=false;
System.out.println("Disfrute de su libro");
}else {
System.out.println("El libro esta en manos de otro usuario de la biblioteca");
}
}
}
}
}
if(encontradoUser) {
System.out.println("Usuario no encontrado");
}
if(encontrado) {
System.out.println("El libro no se encuentra en la biblioteca");
}
}
}
}
class Libro{
private String titulo;
private String autor;
private int anio;
private boolean estado;
private int codigo;
public Libro(String titulo, String autor, int anio, boolean estado,int codigo) {
this.titulo = titulo;
this.autor = autor;
this.anio = anio;
this.estado = estado;
this.codigo=codigo;
}
public Libro() {
}
/**
* @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 estado
*/
public boolean getEstado() {
return estado;
}
/**
* @param estado the estado to set
*/
public void setEstado(boolean estado) {
this.estado = estado;
}
/**
* @return the codigo
*/
public int getCodigo() {
return codigo;
}
/**
* @param codigo the codigo to set
*/
public void setCodigo(int codigo) {
this.codigo = codigo;
}
//Metodo para dar de alta un libro
public ArrayList<Libro> altaLibro(ArrayList<Libro> libro){
String autor,titulo;
int anio=0;
Scanner entrada2=new Scanner(System.in);
System.out.println("Introduce el titulo del libro");
titulo=entrada2.nextLine();
System.out.println("Introduce el autor del libro");
autor=entrada2.nextLine();
int numero=0;
if (libro.size()==0) {
numero=1;
}else {
numero=0;
for (Libro l : libro) {
if(l.codigo>numero) {
numero=l.codigo;
}
}
numero++;
}
System.out.println("Introduce el año del libro");
try {
anio=Integer.parseInt( entrada2.next());
}catch (NumberFormatException e) {
System.out.println("Fomato de año no valido");
Libro nuevoLibro=new Libro(titulo,autor,anio,true,numero);
libro.add(nuevoLibro);
System.out.println("Libro dado de alta correctamente");
}
return libro;
}
//metodo para dar de baja libros si no estan en poder de un usuario
public ArrayList<Libro> borrarLibro(ArrayList<Libro> libros){
int codigoLibro=0;
Scanner entrada2=new Scanner(System.in);
System.out.println("Introduzca el codigo del libro a borrar:");
try {
codigoLibro=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
}
boolean encontrado=true;
Iterator<Libro> it=libros.iterator();
while(it.hasNext()) {
Libro libro=it.next();
if(libro.getCodigo()==codigoLibro) {
it.remove();
System.out.println("El libro ha sido borrado correctamente");
encontrado=false;
}
}
if(encontrado) {
System.out.println("Libro no encontrado en nuestra biblioteca");
}
return libros;
}
//metodo para listar libros
public void listarLibros(ArrayList<Libro> libros) {
String estado="";
for (Libro libro : libros) {
System.out.println("\nTitulo: " + libro.getTitulo());
System.out.println("Autor: " + libro.getAutor());
System.out.println("Año: " + libro.getAnio());
if(libro.getEstado()) {
estado="Disponible";
}else {
estado="Prestado";
}
System.out.println("Estado: " + estado);
}
}
}
class Usuarios{
private String nombre;
private int numSocio;
private ArrayList<Integer> libros;
public Usuarios(String nombre, int numSocio) {
this.nombre = nombre;
this.numSocio = numSocio;
this.libros = new ArrayList<Integer>();
}
public Usuarios() {
}
/**
* @return the nombre
*/
public String getNombre() {
return nombre;
}
/**
* @param nombre the nombre to set
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
/**
* @return the numSocio
*/
public int getNumSocio() {
return numSocio;
}
/**
* @param numSocio the numSocio to set
*/
public void setNumSocio(int numSocio) {
this.numSocio = numSocio;
}
/**
* @return the libros
*/
public ArrayList<Integer> getLibros() {
return libros;
}
/**
* @param libros the libros to set
*/
public void setLibros(ArrayList<Integer> libros) {
this.libros = libros;
}
//metodo prestar libro a usuario
public void agregarLibroPrestado(int libro) {
if (libros == null) {
libros = new ArrayList<>();
}
libros.add(libro);
}
//metodo para agregar usuarios
public ArrayList<Usuarios> altaUsuario(ArrayList<Usuarios> usuarios) {
String nombre;
int numero;
Scanner entrada2=new Scanner(System.in);
System.out.println("Introduce el nombre del nuevo usuario");
nombre=entrada2.nextLine();
if (usuarios.size()==0) {
numero=1;
}else {
numero=0;
for (Usuarios user : usuarios) {
if(user.numSocio>numero) {
numero=user.numSocio;
}
}
numero++;
}
Usuarios user=new Usuarios(nombre,numero);
usuarios.add(user);
return usuarios;
}
//metodo para listar usuarios
public void listarUsuarios(ArrayList<Usuarios> usuarios,ArrayList<Libro> libros) {
for (Usuarios user : usuarios) {
System.out.println("\nNº Socio: " + user.getNumSocio());
System.out.println("Nombre: " + user.getNombre());
try{
for (Integer l:user.libros) {
for (Libro li: libros) {
if(l==li.getCodigo()) {
System.out.println(" Codigo: " +li.getCodigo());
System.out.println(" Titulo: " +li.getTitulo());
System.out.println(" Autor: " +li.getAutor());
System.out.println(" Año: " +li.getAnio());
System.out.println(" Estado: " +(li.getEstado()?"Disponible\n" :"Prestado\n"));
}
}
}
}catch (NullPointerException e) {
System.out.println("El usuario no tiene libros prestados");
}
}
}
//metodo para dar de baja usuarios siempre que no tengan libros en prestamo
public ArrayList<Usuarios> borrarUsuario(ArrayList<Usuarios> usuarios){
int numSocio=0;
Scanner entrada2=new Scanner(System.in);
System.out.println("Introduzca el numero de socio a borrar:");
try {
numSocio=Integer.parseInt(entrada2.next());
}catch (NumberFormatException e){
System.out.println("Usuario no encontrado en la base de datos");
}
boolean encontrado=true;
Iterator<Usuarios> it=usuarios.iterator();
while(it.hasNext()) {
Usuarios usuario=it.next();
if(usuario.getNumSocio()==numSocio) {
if (usuario.getLibros() == null) {
it.remove();
System.out.println("El usuario ha sido borrado correctamente");
} else {
System.out.println("No se puede borrar al usuario porque tiene libros en préstamo");
}
encontrado=false;
}
}
if(encontrado) {
System.out.println("Usuario no encontrado en la base de datos");
}
return usuarios;
}
}
Ejercicio 12
Crea una aplicación en Java para gestionar una tienda de productos electrónicos. Deben existir clases para representar productos y clientes de la tienda. Los productos deben tener un nombre, un precio, una cantidad disponible en stock y una categoría. Los clientes deben tener un nombre, un número de cliente y un historial de compras. El sistema debe permitir: Agregar nuevos productos al inventario de la tienda. Realizar ventas a clientes, actualizando la cantidad disponible en stock de los productos vendidos y registrando la transacción en el historial de compras del cliente. Actualizar la información de los productos, como su precio y cantidad disponible en stock. Mostrar una lista de todos los productos disponibles en la tienda, incluyendo su nombre, precio, cantidad disponible y categoría. Mostrar el historial de compras de un cliente en particular, incluyendo los productos comprados y el monto total gastado por el cliente en todas sus compras. Mostrar una lista de todos los clientes de la tienda, junto con su número de cliente y el total gastado en compras. Implementa las clases necesarias con sus métodos para lograr esta funcionalidad. Además, crea una clase principal que permita interactuar con el sistema, mostrando un menú con las opciones disponibles y solicitando la entrada del usuario para realizar las acciones correspondientes.
package poo;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;
public class Ejercicio12 {
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
ArrayList<Clientes> clientes=new ArrayList<Clientes>();
Clientes cliente=new Clientes();
ArrayList<Productos> productos=new ArrayList<Productos>();
Productos producto=new Productos();
Historial historial=new Historial();
int menu=0;
do {
System.out.println("*** ELECTRO CARLOS SYSTEM ***");
System.out.println("(1).Clientes");
System.out.println("(2).Productos");
System.out.println("(3).Ventas e Historial de ventas");
System.out.println("(4).Salir");
try {
menu=Integer.parseInt(entrada.next());
}catch(NumberFormatException e) {
System.out.println("Opcion no valida");
}
switch(menu) {
case 1:
Scanner entradaClientes=new Scanner(System.in);
int menuClientes=0;
do {
System.out.println(" Clientes");
System.out.println(" (1).Alta Cliente");
System.out.println(" (2).Baja Cliente");
System.out.println(" (3).Actualizar Cliente");
System.out.println(" (4).Listar Clientes");
System.out.println(" (5).volver a menu principal");
System.out.println(" Escoge opcion:");
try {
menuClientes=Integer.parseInt(entradaClientes.next());
}catch(NumberFormatException e) {
System.out.println("Opcion no valida");
}
switch(menuClientes) {
case 1:
cliente.altaClientes(clientes);
break;
case 2:
cliente.borrarCliente(clientes);
break;
case 3:
cliente.actualizarCliente(clientes);
break;
case 4:
cliente.listarClientes(clientes);
break;
case 5:
System.out.println("Saliendo de menu clientes");
break;
default:
System.out.println("opcion no contemplada");
break;
}
}while(menuClientes!=5);
break;
case 2:
int menuProductos=0;
do {
System.out.println(" Menu productos");
System.out.println(" (1).Alta producto");
System.out.println(" (2).Baja producto");
System.out.println(" (3).Actualizar producto");
System.out.println(" (4).Listar productos");
System.out.println(" (5).Volver a menu principal");
System.out.println(" Escoge opcion:");
try {
menuProductos=Integer.parseInt(entrada.next());
}catch(NumberFormatException e) {
System.out.println("Opcion no valida");
}
switch(menuProductos) {
case 1:
producto.altaProducto(productos);
break;
case 2:
producto.borrarProducto(productos,clientes);
break;
case 3:
int menuActualizar=0;
do {
System.out.println(" Menu actualizar producto");
System.out.println(" (1).Actualziar Nombre producto");
System.out.println(" (2).Actualziar precio producto");
System.out.println(" (3).Actualziar stock producto");
System.out.println(" (4).Actualziar categoria producto");
System.out.println(" (5).Volver menu producto");
System.out.println(" Escoge opcion:");
try {
menuActualizar=Integer.parseInt(entrada.next());
}catch(NumberFormatException e) {
System.out.println("Opcion no valida");
}
String campo="";
switch(menuActualizar) {
case 1:
campo="nombre";
producto.actualizarProducto(productos, campo);
break;
case 2:
campo="precio";
producto.actualizarProducto(productos, campo);
break;
case 3:
campo="cantidad";
producto.actualizarProducto(productos, campo);
break;
case 4:
campo="categoria";
producto.actualizarProducto(productos, campo);
break;
case 5:
System.out.println("Volviendo a menu de productos");
break;
default:
System.out.println("Opcion no validad");
break;
}
}while(menuActualizar!=5);
break;
case 4:
producto.listarTodosProductos(productos);
break;
case 5:
System.out.println("Volviendo al menu principal");
break;
default:
System.out.println("Opcion no contemplada");
break;
}
}while(menuProductos!=5);
break;
case 3:
int menuHistorial=0;
do {
System.out.println(" Menu historial y ventas");
System.out.println(" (1).Realizar una venta");
System.out.println(" (2).Listar productos disponibles");
System.out.println(" (3).Listar productos agotados");
System.out.println(" (4).Listar todos los productos disponibles");
System.out.println(" (5).Mostrar historial de un cliente");
System.out.println(" (6).Volver al menu principal");
System.out.println(" Escoge opcion");
try {
menuHistorial=Integer.parseInt(entrada.next());
}catch(NumberFormatException e) {
System.out.println("Opcion no valida");
}
switch(menuHistorial) {
case 1:
historial.venderProducto(productos, clientes);
break;
case 2:
producto.listarProductosDisponibles(productos);
break;
case 3:
producto.listarProductosNoDisponibles(productos);
break;
case 4:
producto.listarTodosProductos(productos);
break;
case 5:
historial.mostrarHitorial(productos,clientes);
break;
case 6:
System.out.println("Volviendo a menu principal");
break;
default:
System.out.println("Opcion no contemplada");
break;
}
}while(menuHistorial!=6);
break;
case 4:
System.out.println("Cerrando tienda");
break;
default:
System.out.println("Opcion no contemplada");
break;
}
}while(menu!=4);
}
}
class Productos{
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() {
}
/**
* @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;
}
//Funcion dar de alta un producto
public void altaProducto(ArrayList<Productos> productos) {
String nombre,categoria;
int codigo,cantidad=0,numCodigo=Integer.MIN_VALUE;
double precio=-1;
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
numCodigo=1;
}else {
for (Productos pro : productos) {
if(pro.getCodigo()>numCodigo) {
numCodigo=pro.getCodigo();
}
}
numCodigo++;
}
System.out.println("Introduce nombre del producto");
nombre=entrada2.nextLine();
do {
try {
System.out.println("Introduce el precio del producto");
precio=Double.parseDouble(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Precio no valido");
precio=-1;
}
}while(precio==-1);
do {
System.out.println("Introduce stock");
try {
cantidad=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Cantidad no validad");
cantidad=-1;
}
}while(cantidad<0);
entrada2.nextLine();
System.out.println("Introduce categoria del producto");
categoria=entrada2.nextLine();
Productos producto=new Productos(numCodigo,nombre,precio,cantidad,categoria);
productos.add(producto);
System.out.println("Producto dado de alta correctamente");
}
//Listar Todos los productos
public void listarTodosProductos(ArrayList<Productos> productos) {
if (productos.size()==0) {
System.out.println("No hay productos dados de alta");
return;
}
System.out.println("Listado de productos");
for (Productos pro : productos) {
System.out.println("Codigo: " +pro.getCodigo());
System.out.println("Nombre: " +pro.getNombre());
System.out.println("Precio: " +pro.getPrecio()+"€");
System.out.println("Cantidad: " +pro.getCantidad());
System.out.println("Categoria: " +pro.getCategoria()+"\n");
}
}
//Listar Todos los productos
public void listarProductosDisponibles(ArrayList<Productos> productos) {
if (productos.size()==0) {
System.out.println("No hay productos dados de alta");
return;
}
System.out.println("Listado de productos disponibles");
for (Productos pro : productos) {
if(pro.getCantidad()>0) {
System.out.println("Codigo: " +pro.getCodigo());
System.out.println("Nombre: " +pro.getNombre());
System.out.println("Precio: " +pro.getPrecio()+"€");
System.out.println("Cantidad: " +pro.getCantidad());
System.out.println("Categoria: " +pro.getCategoria()+"\n");
}
}
}
//Listar Todos los productos
public void listarProductosNoDisponibles(ArrayList<Productos> productos) {
if (productos.size()==0) {
System.out.println("No hay productos dados de alta");
return;
}
System.out.println("Listado de productos agotados");
for (Productos pro : productos) {
if(pro.getCantidad()==0) {
System.out.println("Codigo: " +pro.getCodigo());
System.out.println("Nombre: " +pro.getNombre());
System.out.println("Precio: " +pro.getPrecio()+"€");
System.out.println("Cantidad: " +pro.getCantidad());
System.out.println("Categoria: " +pro.getCategoria()+"\n");
}
}
}
//funcion actualizar producto
public void actualizarProducto(ArrayList<Productos> productos,String campo) {
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
System.out.println("No hay productos en la base de datos");
return;
}
listarTodosProductos(productos);
int codigo=0;
boolean encontrado=false;
System.out.println("Introduce codigo del producto a actulizar");
try {
codigo=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Codigo incorrecto");
}
entrada2.nextLine();
switch(campo) {
case "nombre":
String nombre="";
System.out.println("Introduce el nuevo nombre");
nombre=entrada2.nextLine();
for (Productos pro : productos) {
if(pro.getCodigo()==codigo) {
pro.setNombre(nombre);
System.out.println("Nombre del producto actualizado");
encontrado=true;
}
}
break;
case "precio":
double precio=-1;
do {
System.out.println("Introduce el nuevo precio");
try {
precio=Double.parseDouble(entrada2.next());
}catch(NumberFormatException e) {
precio=-1;
}
}while(precio==-1);
for (Productos pro : productos) {
if(pro.getCodigo()==codigo) {
pro.setPrecio(precio);
System.out.println("Precio del producto actualizado");
encontrado=true;
}
}
break;
case "cantidad":
int cantidad=-1;
do {
System.out.println("Introduce el nuevo stock");
try {
cantidad=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
cantidad=-1;
}
}while(cantidad==-1);
for (Productos pro : productos) {
if(pro.getCodigo()==codigo) {
pro.setCantidad(cantidad);
System.out.println("Stock del producto actualizado");
encontrado=true;
}
}
break;
case "categoria":
String categoria="";
System.out.println("Introduce la nueva categoria");
categoria=entrada2.nextLine();
for (Productos pro : productos) {
if(pro.getCodigo()==codigo) {
pro.setCategoria(categoria);
System.out.println("Categoria del producto actualizado");
encontrado=true;
}
}
break;
default:
System.out.println("Categoria incorrecta");
break;
}
if(!encontrado) {
System.out.println("El producto no se encuentra en la base de datos");
}
}
//funcion borrar producto
public void borrarProducto(ArrayList<Productos> productos,ArrayList<Clientes>clientes) {
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
System.out.println("No hay productos en la base de datos");
return;
}
listarTodosProductos(productos);
int numCodigo=0;
boolean encontrado=false;
try {
System.out.println("Introduce el codigo del producto a borrar:");
numCodigo=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
}
boolean noBorrar=false;
Iterator<Productos> it=productos.iterator();
while(it.hasNext()) {
Productos producto=it.next();
if(producto.getCodigo()==numCodigo) {
if(producto.getCantidad()==0) {
for (Clientes cli : clientes) {
for (Historial cl : cli.getHistorial()) {
if(cl.getCodigo()==numCodigo) {
noBorrar=true;
}
}
}
if(!noBorrar) {
it.remove();
System.out.println("Producto borrado correctamente");
encontrado=true;
}else {
System.out.println("No se peude borrar el producto se encuentra en el historial de ventas");
}
}else {
System.out.println("No se pueden borrar productos que tienen stock");
return;
}
}
}
if(!encontrado) {
System.out.println("El producto no se encuentra en la base de datos");
}
}
}
class Clientes{
private int codigo;
private String nombre;
private ArrayList<Historial> historial;
public Clientes(int codigo, String nombre) {
super();
this.codigo = codigo;
this.nombre = nombre;
this.historial = new ArrayList<Historial>();
}
public Clientes() {
}
/**
* @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 historial
*/
public ArrayList<Historial> getHistorial() {
return historial;
}
/**
* @param historial the historial to set
*/
public void setHistorial(ArrayList<Historial> historial) {
this.historial = historial;
}
//Funcion dar de alta un cliente
public void altaClientes(ArrayList<Clientes> clientes) {
String nombre;
int codigo=Integer.MIN_VALUE;
Scanner entrada2 =new Scanner(System.in);
System.out.println("Introduce el nombre del cliente:");
nombre=entrada2.nextLine();
if(clientes.size()==0) {
codigo=1;
}else {
for (Clientes cli : clientes) {
if(cli.getCodigo()>codigo) {
codigo=cli.getCodigo();
}
}
codigo++;
}
Clientes cliente=new Clientes(codigo,nombre);
clientes.add(cliente);
System.out.println("Cliente dado de alta correctamente");
}
//funcion muestro clientes
public void muestroClientes(ArrayList<Clientes> clientes) {
System.out.println("Lista de clientes");
for (Clientes cli : clientes) {
System.out.println("("+cli.getCodigo()+")."+cli.getNombre());
}
}
//Funcion actualizar un cliente
public void actualizarCliente(ArrayList<Clientes> clientes) {
if (clientes.size()==0) {
System.out.println("No hay clientes en la base de datos");
return;
}
Scanner entrada2=new Scanner(System.in);
boolean encontrado=false;
muestroClientes(clientes);
int codigo=0;
try {
System.out.println("Introduce codigo del cliente a actualizar:");
codigo=Integer.parseInt(entrada2.next());
entrada2.nextLine();
for (Clientes cli : clientes) {
if(cli.codigo==codigo) {
String nom="";
System.out.println("Introduce nuevo nombre");
nom=entrada2.nextLine();
cli.setNombre(nom);
System.out.println("Cliente actualizado");
encontrado=true;
}
}
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
}
if(!encontrado) {
System.out.println("El codigo no corresponde con ningun cliente");
}
}
//funcion listar clientes
public void listarClientes(ArrayList<Clientes>clientes) {
System.out.println("Lista de clientes");
for (Clientes cliente : clientes) {
System.out.println("Codigo:" +cliente.getCodigo());
System.out.println("Nombre:" +cliente.getNombre()+"\n");
}
}
//funcion borrar cliente
public void borrarCliente(ArrayList<Clientes> clientes) {
if(clientes.size()==0) {
System.out.println("la lista de clientes esta vacia");
return;
}
Scanner entrada2 =new Scanner(System.in);
int codigo=0;
muestroClientes(clientes);
System.out.println("Introduce codigo de cliente:");
try {
codigo=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
}
boolean encontrado=false;
Iterator<Clientes> it=clientes.iterator();
while(it.hasNext()) {
Clientes cliente=it.next();
if(cliente.getCodigo()==codigo) {
if(cliente.getHistorial().size()!=0) {
System.out.println("No se puede borrar el cliente, se encuentra en el historial de ventas");
return;
}
it.remove();
System.out.println("Cliente borrado con exito");
encontrado=true;
}
}
if(!encontrado) {
System.out.println("El cliente no se encuentra en nuestra base de datos");
}
}
}
class Historial{
private int codigo;
private int cantidad;
private Date fecha;
private double precio;
public Historial(int codigo, int cantidad, Date fecha,double precio) {
super();
this.codigo = codigo;
this.cantidad = cantidad;
this.fecha = fecha;
this.precio=precio;
}
public Historial() {
}
/**
* @return the codigo
*/
public int getCodigo() {
return codigo;
}
/**
* @param codigo the codigo to set
*/
public void setCodigo(int codigo) {
this.codigo = codigo;
}
/**
* @return the cantidad
*/
public int getCantidad() {
return cantidad;
}
/**
* @param cantidad the cantidad to set
*/
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}
/**
* @return the fecha
*/
public Date getFecha() {
return fecha;
}
/**
* @param fecha the fecha to set
*/
public void setFecha(Date fecha) {
this.fecha = fecha;
}
/**
* @return the precio
*/
public double getPrecio() {
return precio;
}
/**
* @param precio the precio to set
*/
public void setPrecio(double precio) {
this.precio = precio;
}
//funcion vender producto
public void venderProducto(ArrayList<Productos> productos,ArrayList<Clientes> clientes) {
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
System.out.println("No hay productos en la base de datos");
return;
}
if(clientes.size()==0) {
System.out.println("No hay clientes en la base de datos");
return;
}
Clientes cliente=new Clientes();
cliente.listarClientes(clientes);
int numCodigo=0;
boolean encontrado=false;
try {
System.out.println("Introduce el codigo del cliente:");
numCodigo=Integer.parseInt(entrada2.next());
for (Clientes cli : clientes) {
if(cli.getCodigo()==numCodigo) {
encontrado=true;
Productos producto=new Productos();
producto.listarTodosProductos(productos);
int codPro=0;
System.out.println("Introduce el codigo del producto a comprar");
try {
codPro=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
}
int cantidad=-1;
for (Productos pro : productos) {
if (pro.getCodigo()==codPro) {
if(pro.getCantidad()>0) {
System.out.println("¿Cuantas unidades deseas de "+ pro.getNombre()+"?" );
do {
try {
cantidad=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Cantidad no valida");
cantidad=-1;
}
}while(cantidad==-1);
}else {
System.out.println("Producto agotado");
return;
}
if(cantidad<=pro.getCantidad()) {
pro.setCantidad(pro.getCantidad()-cantidad);
Date fechaDia=new Date();
Historial historial=new Historial(codPro,cantidad,fechaDia,pro.getPrecio());
cli.getHistorial().add(historial);
System.out.println("Gracias por su compra, vuelva cuando quiera");
}else {
char regateo;
do {
System.out.println("Solo quedan " + pro.getCantidad()+" unidades, ¿las llevas todas(s) o cancelamos la compra(c)?");
regateo=entrada2.next().toLowerCase().charAt(0);
}while (regateo!='s' && regateo!='c');
if(regateo=='c') {
System.out.println("Compra cancelada");
return;
}else {
cantidad=pro.getCantidad();
pro.setCantidad(0);
Date fechaDia=new Date();
Historial historial=new Historial(codPro,cantidad,fechaDia,pro.getPrecio());
cli.getHistorial().add(historial);
System.out.println("Gracias por su compra, vuelva cuando quiera");
}
}
}
}
}
}
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
}
if(!encontrado) {
System.out.println("El cliente no se encuentra en nuestra base de datos");
}
}
//funcion mostrar historial de cliente
public void mostrarHitorial(ArrayList<Productos> productos,ArrayList<Clientes> clientes) {
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
System.out.println("No hay productos en la base de datos");
return;
}
if(clientes.size()==0) {
System.out.println("No hay clientes en la base de datos");
return;
}
int numCliente=0;
Clientes cliente=new Clientes();
cliente.listarClientes(clientes);
do {
try {
System.out.println("Introduce codigo cliente:");
numCliente=Integer.parseInt(entrada2.next());
}catch(NumberFormatException e) {
System.out.println("Codigo no valido");
numCliente=0;
}
}while(numCliente==0);
boolean encontrado=false;
String producto="";
for (Clientes cli : clientes) {
if(numCliente==cli.getCodigo()) {
encontrado=true;
for (Historial histo : cli.getHistorial()) {
for (Productos pro : productos) {
if(pro.getCodigo()==histo.codigo) {
producto=pro.getNombre();
}
}
System.out.println("Producto: " + producto + " Cantidad: " + histo.getCantidad() + " Fecha: " +histo.getFecha()+" Total: " +String.format("%.2f",(histo.getCantidad()*histo.getPrecio()))+"€");
}
}
}
if(!encontrado) {
System.out.println("El cliente no tiene historial");
}
}
}
Ejercicio 13
Desarrolla un sistema de gestión de empleados para una empresa. Cada empleado tiene los siguientes atributos: Nombre,Apellido,Edad,Cargo,Salario El sistema debe permitir realizar las siguientes operaciones: Agregar un nuevo empleado especificando todos sus atributos. Mostrar la lista de todos los empleados registrados en la empresa. Buscar un empleado por su nombre y apellido. Actualizar la información de un empleado (nombre, apellido, edad, cargo o salario). Calcular el promedio de salario de todos los empleados. Implementa una clase Empleado que contenga los atributos mencionados y métodos para realizar las operaciones descritas anteriormente. Luego, crea una clase principal (Main) que interactúe con el usuario y utilice objetos de la clase Empleado para realizar las operaciones solicitadas.
package poo;
import java.util.ArrayList;
import java.util.Scanner;
public class Ejercicio13 {
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
ArrayList<Empleado> empleados=new ArrayList<Empleado>();
Empleado empleado=new Empleado();
int opcionMenu=0;
do {
System.out.println("Gestion de Empleados");
System.out.println("(1).Contratar un empleado");
System.out.println("(2).Mostrar la lista de todos los empleados");
System.out.println("(3).Buscar empleado por nombre");
System.out.println("(4).Buscar empleado por apellido");
System.out.println("(5).Actualizar datos de empleado");
System.out.println("(6).Calcular salario medio de la plantilla");
System.out.println("(7).Salir");
System.out.println("Escoge opcion");
try {
opcionMenu=Integer.parseInt(entrada.next());
}catch(NumberFormatException e) {
System.out.println("Formato de numero no valido");
}
switch(opcionMenu) {
case 1:
empleado.contratarEmpleado(empleados);
break;
case 2:
System.out.println("Lista de todos los empleados de la empresa");
empleado.listarEmpleados(empleados);
break;
case 3:
empleado.buscarEmpleado(empleados, true);
break;
case 4:
empleado.buscarEmpleado(empleados, false);
break;
case 5:
empleado.actualizarEmpleado(empleados);
break;
case 6:
empleado.calcularSalarioMedio(empleados);
break;
case 7:
System.out.println("Bajando persiana de la empresa por hoy");
entrada.close();
break;
default:
System.out.println("Opcion no contemplada");
break;
}
}while(opcionMenu!=7);
}
}
class Empleado{
private String nombre;
private String Apellido;
private int edad;
private String cargo;
private double salario;
public Empleado(String nombre, String apellido, int edad, String cargo, double salario) {
super();
this.nombre = nombre;
Apellido = apellido;
this.edad = edad;
this.cargo = cargo;
this.salario = salario;
}
public Empleado() {
}
/**
* @return the nombre
*/
public String getNombre() {
return nombre;
}
/**
* @param nombre the nombre to set
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
/**
* @return the apellido
*/
public String getApellido() {
return Apellido;
}
/**
* @param apellido the apellido to set
*/
public void setApellido(String apellido) {
Apellido = apellido;
}
/**
* @return the edad
*/
public int getEdad() {
return edad;
}
/**
* @param edad the edad to set
*/
public void setEdad(int edad) {
this.edad = edad;
}
/**
* @return the cargo
*/
public String getCargo() {
return cargo;
}
/**
* @param cargo the cargo to set
*/
public void setCargo(String cargo) {
this.cargo = cargo;
}
/**
* @return the salario
*/
public double getSalario() {
return salario;
}
/**
* @param salario the salario to set
*/
public void setSalario(double salario) {
this.salario = salario;
}
//Funcion para contratar a los empleados
public void contratarEmpleado(ArrayList<Empleado> empleados) {
datosEmpleado(empleados,false);
}
//Funcion para listar a todos los empleados
public void listarEmpleados(ArrayList<Empleado> empleados) {
for (Empleado empleado : empleados) {
System.out.println("\nNombre: " +empleado.getNombre());
System.out.println("Apellido: " +empleado.getApellido());
System.out.println("Edad: " +empleado.getEdad());
System.out.println("Cargo: " +empleado.getCargo());
System.out.println("Salario: " +empleado.getSalario());
}
}
//Funcion para buscar empleados por nombre y apellido
public void buscarEmpleado(ArrayList<Empleado> empleados, boolean campo) {
String campoBusqueda="";
Scanner entrada2=new Scanner(System.in);
if(campo) {
System.out.println("Introduce el nombre a buscar:");
campoBusqueda=entrada2.nextLine();
}else {
System.out.println("Introduce el apellido a buscar:");
campoBusqueda=entrada2.nextLine();
}
ArrayList<Empleado> filtrados=new ArrayList<Empleado>();
for (Empleado empleado : empleados) {
if(campo) {
if(empleado.getNombre().toLowerCase().contains(campoBusqueda.toLowerCase())) {
Empleado emple=new Empleado(empleado.getNombre(),empleado.getApellido(),empleado.getEdad(),empleado.getCargo(),empleado.getSalario());
filtrados.add(emple);
}
}else {
if(empleado.getApellido().toLowerCase().contains(campoBusqueda.toLowerCase())) {
Empleado emple=new Empleado(empleado.getNombre(),empleado.getApellido(),empleado.getEdad(),empleado.getCargo(),empleado.getSalario());
filtrados.add(emple);
}
}
}
if(campo) {
System.out.println("Lista de todos los empleados de la empresa que su nombre contiene " + campoBusqueda);
}else {
System.out.println("Lista de todos los empleados de la empresa que su apellido contiene " + campoBusqueda);
}
listarEmpleados(filtrados);
}
//funcion actualziar datos de empleado
public void actualizarEmpleado(ArrayList<Empleado> empleados) {
datosEmpleado(empleados,true);
}
//funcion datos empleado
private void datosEmpleado(ArrayList<Empleado> empleados,boolean actualizo) {
String nombreBuscar="";
Scanner entrada2=new Scanner(System.in);
boolean existe=false;
if(actualizo) {
System.out.println("Introduce el nombre del empleado a actualizar");
nombreBuscar=entrada2.nextLine();
for (Empleado empleado : empleados) {
if(empleado.getNombre().toLowerCase().equals(nombreBuscar.toLowerCase())) {
existe=true;
}
}
if(existe) {
System.out.println("Introduce los nuevos datos");
}else {
System.out.println("No es empleado de nuesta empresa");
return;
}
}
String nombre,apellido,cargo;
int edad;
double salario;
System.out.println("Introduce el nombre del nuevo empleado");
nombre=entrada2.nextLine();
System.out.println("Introduce el apellido del nuevo empleado");
apellido=entrada2.nextLine();
while(true) {
try {
System.out.println("Introduce la edad del nuevo empleado");
edad=Integer.parseInt(entrada2.nextLine());
break;
}catch (NumberFormatException e) {
System.err.println("Edad no valida, introducela de nuevo");
}
}
System.out.println("Introduce el cargo del nuevo empleado");
cargo=entrada2.nextLine();
while(true) {
try {
System.out.println("Introduce el salario del nuevo empleado");
salario=Integer.parseInt(entrada2.nextLine());
break;
}catch (NumberFormatException e) {
System.err.println("Salario no valido, introducelo de nuevo");
}
}
if(actualizo) {
for (Empleado empleado : empleados) {
if(empleado.getNombre().toLowerCase().equals(nombreBuscar)) {
empleado.setNombre(nombre);
empleado.setApellido(apellido);
empleado.setEdad(edad);
empleado.setCargo(cargo);
empleado.setSalario(salario);
}
}
System.out.println("Empleado actualizdo con exito");
}else {
Empleado empleado=new Empleado(nombre,apellido,edad,cargo,salario);
empleados.add(empleado);
System.out.println("Empleado contratado con exito");
}
}
//funcion calcular salario medio
public void calcularSalarioMedio(ArrayList<Empleado> empleados) {
double total=0.0;
for (Empleado empleado : empleados) {
total+=empleado.getSalario();
}
System.out.println("El salario medio del empleado es: " + String.format("%.2f", total/empleados.size()));
}
}
Ejercicio 14
Desarrolla un sistema de gestión de estudiantes para una escuela. Cada estudiante tiene los siguientes atributos: número de identificación, nombre, edad y promedio de calificaciones. El sistema debe permitir realizar las siguientes operaciones: Agregar un nuevo estudiante especificando todos sus atributos. Mostrar la lista de todos los estudiantes matriculados en la escuela. Buscar un estudiante por su número de identificación o por su nombre. Actualizar la información de un estudiante (nombre, edad, promedio de calificaciones). Calcular el promedio de edad de todos los estudiantes matriculados. Calcular el promedio de calificaciones de todos los estudiantes matriculados. Implementa una clase Estudiante que contenga los atributos mencionados y métodos para realizar las operaciones descritas anteriormente. Luego, crea una clase principal (Main) que interactúe con el usuario y utilice objetos de la clase Estudiante para realizar las operaciones solicitadas.
package poo;
import java.util.ArrayList;
import java.util.Scanner;
public class Ejercicio14 {
/*
La solucion que aqui doy con los getters y los setters privados no seria la mas adecuada para futuras ampliaciones
de la aplicacion aunque funciona a la perfeccion
*/
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
int opcionMenu=0;
Estudiante estudiante=new Estudiante();
do {
System.out.println("Universidad de Programacion En Java");
System.out.println("(1).Agregar un nuevo estudiante");
System.out.println("(2).Mostrar listado de todos los estudiantes");
System.out.println("(3).Mostrar estudiante por codigo");
System.out.println("(4).Mostrar estudiante por nombre");
System.out.println("(5).Actualizar datos personales de un estudiante");
System.out.println("(6).Calcular edad media del alumnado");
System.out.println("(7).Calcular nota media de todos los estudiantes");
System.out.println("(8).Salir de la universidad");
opcionMenu=Integer.parseInt(entrada.nextLine());
switch(opcionMenu) {
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
estudiante.tratarMenu(opcionMenu);
break;
case 8:
System.out.println("Cerrando Universidad hasta septiembre");
entrada.close();
break;
default:
System.out.println("Opcion no contemplada");
break;
}
}while(opcionMenu!=8);
}
}
class Estudiante{
private int codigo;
private String nombre;
private int edad;
private double notaMedia;
private ArrayList<Estudiante> estudiantes=new ArrayList<Estudiante>();
private Estudiante(int codigo, String nombre, int edad, double notaMedia) {
super();
this.codigo = codigo;
this.nombre = nombre;
this.edad = edad;
this.notaMedia = notaMedia;
}
public Estudiante() {
}
/**
* @return the codigo
*/
private int getCodigo() {
return codigo;
}
/**
* @param codigo the codigo to set
*/
/**
* @return the nombre
*/
private String getNombre() {
return nombre;
}
/**
* @param nombre the nombre to set
*/
private void setNombre(String nombre) {
this.nombre = nombre;
}
/**
* @return the edad
*/
private int getEdad() {
return edad;
}
/**
* @param edad the edad to set
*/
private void setEdad(int edad) {
this.edad = edad;
}
/**
* @return the notaMedia
*/
private double getNotaMedia() {
return notaMedia;
}
/**
* @param notaMedia the notaMedia to set
*/
private void setNotaMedia(double notaMedia) {
this.notaMedia = notaMedia;
}
public void tratarMenu(int opcion) {
switch(opcion) {
case 1:
agregarEstudiante();
break;
case 2:
listarEstudiantes(0);
break;
case 3:
mostrarEstudiantePorCodigo();
break;
case 4:
buscarEstudiantePorNombre();
break;
case 5:
actualizarEstudiante();
break;
case 6:
calcularMediaEdad();
break;
case 7:
calcularMediaNota();
break;
default:
System.out.println("Nunca entrara aqui");
break;
}
}
//funcion para dar de alta un nuevo estudiante
private void agregarEstudiante() {
Scanner entrada2=new Scanner(System.in);
int maxCodigo=Integer.MIN_VALUE;
if(this.estudiantes.size()==0) {
maxCodigo=1;
}else {
for (Estudiante estudiante : estudiantes) {
if(estudiante.getCodigo()>maxCodigo) {
maxCodigo=estudiante.getCodigo();
}
}
maxCodigo++;
}
System.out.println("Introduce el nombre del estudiante");
this.nombre=entrada2.nextLine();
do{
try {
System.out.println("Introduce la edad del estudiante (16-99)");
this.edad=Integer.parseInt(entrada2.nextLine());
}catch(NumberFormatException e) {
System.err.println("Formato de edad no valido");
}
}while(this.edad<16 && this.edad>99);
do{
try {
System.out.println("Introduce la nota media del estudiante (0-10)");
this.notaMedia=Double.parseDouble(entrada2.nextLine());
}catch(NumberFormatException e) {
System.err.println("Formato de nota media no valido");
}
}while(this.notaMedia<0 && this.notaMedia>10);
Estudiante estudiante=new Estudiante(maxCodigo,this.nombre,this.edad,this.notaMedia);
estudiantes.add(estudiante);
System.out.println("Estudiante dado de alta correctamente");
}
//funcion imprimir datos
private void imprimirDatosEstudiante(Estudiante estudiante) {
System.out.println("\nCodigo: " + estudiante.getCodigo());
System.out.println("Nombre: " + estudiante.getNombre());
System.out.println("Edad: " + estudiante.getEdad());
System.out.println("Nota media: " + estudiante.getNotaMedia());
}
//Funcion listar todos los estudiantes o uno concreto
private void listarEstudiantes(int codigo) {
if(codigo!=0) {
for (Estudiante estudiante : estudiantes) {
if(estudiante.getCodigo()==codigo) {
imprimirDatosEstudiante(estudiante);
}
}
}else if (codigo==0){
for (Estudiante estudiante : estudiantes) {
imprimirDatosEstudiante(estudiante);
}
}
}
//Funcion Buscar estudiante por codigo
private void mostrarEstudiantePorCodigo() {
Scanner entrada2=new Scanner(System.in);
int codigo=0;
boolean encontrado=false;
if(estudiantes.size()!=0) {
do {
try {
System.out.println("Introduce el codigo del estudiante a buscar");
codigo=Integer.parseInt(entrada2.nextLine());
for (Estudiante estudiante : estudiantes) {
if(estudiante.getCodigo()==codigo) {
listarEstudiantes(codigo);
encontrado=true;
}
}
}catch(NumberFormatException e) {
System.err.println("Formato de codigo no valido");
}
}while(codigo<1);
}else {
System.out.println("No hay estudiantes en la base de datos");
}
if(!encontrado) {
System.out.println("El estudiante no se encuentra en la base de datos");
}
}
//Funcion buscar estudiante por nombre
private void buscarEstudiantePorNombre() {
Scanner entrada2=new Scanner(System.in);
String nombre="";
boolean encontrado=false;
if(estudiantes.size()!=0) {
System.out.println("Introduce el nombre a buscar");
nombre=entrada2.nextLine();
for (Estudiante estudiante : estudiantes) {
if(estudiante.getNombre().toLowerCase().contains(nombre.toLowerCase())) {
listarEstudiantes(estudiante.getCodigo());
encontrado=true;
}
}
}else {
System.out.println("No hay estudiantes en la base de datos");
}
if(!encontrado) {
System.out.println("El estudiante no se encuentra en la base de datos");
}
}
//Funcion actualizar un estudiante
private void actualizarEstudiante() {
Scanner entrada2=new Scanner(System.in);
int codigo=0;
boolean encontrado=false;
String nombre="";
int edad=0;
double notaMedia=0.0;
if(estudiantes.size()!=0) {
do {
try {
System.out.println("Introduce el codigo del estudiante:");
codigo=Integer.parseInt(entrada2.nextLine());
for (Estudiante estudiante : estudiantes) {
if(estudiante.getCodigo()==codigo) {
System.out.println("Introduce el nombre del estudiante");
nombre=entrada2.nextLine();
do{
try {
System.out.println("Introduce la edad del estudiante (16-99)");
edad=Integer.parseInt(entrada2.nextLine());
}catch(NumberFormatException e) {
System.err.println("Formato de edad no valido");
}
}while(edad<16 && edad>99);
do{
try {
System.out.println("Introduce la nota media del estudiante (0-10)");
notaMedia=Double.parseDouble(entrada2.nextLine());
}catch(NumberFormatException e) {
System.err.println("Formato de nota media no valido");
}
}while(notaMedia<0 && notaMedia>10);
estudiante.setNombre(nombre);
estudiante.setEdad(edad);
estudiante.setNotaMedia(notaMedia);
System.out.println("Estudiante actualizado correctamente");
encontrado=true;
}
}
}catch(NumberFormatException e) {
System.err.println("Formato de codigo no valido");
}
}while(codigo<1);
}else {
System.out.println("No hay estudiantes en la base de datos");
}
if(!encontrado) {
System.out.println("El estudiante no se encuentra en la base de datos");
}
}
//funcion calcular edad media del alumnado
private void calcularMediaEdad() {
double sumaEdad=0.0;
if(estudiantes.size()!=0) {
for (Estudiante estudiante : estudiantes) {
sumaEdad+=estudiante.getEdad();
}
System.out.println("La edad media del alumnado es :" + String.format("%.2f", (sumaEdad/estudiantes.size())));
}else {
System.out.println("No hay estudiantes en la base de datos");
}
}
//funcion calcular nota media del alumnado
private void calcularMediaNota() {
double sumaNota=0.0;
if(estudiantes.size()!=0) {
for (Estudiante estudiante : estudiantes) {
sumaNota+=estudiante.getNotaMedia();
}
System.out.println("La nota media del alumnado es :" + String.format("%.2f", (sumaNota/estudiantes.size())));
}else {
System.out.println("No hay estudiantes en la base de datos");
}
}
}
Ejercicio 15
Desarrolla un sistema de registro de ventas para una tienda. Cada venta tiene los siguientes atributos: número de factura, fecha, monto total y lista de productos vendidos. Cada producto vendido tiene un nombre, precio unitario y cantidad. El sistema debe permitir realizar las siguientes operaciones: Agregar una nueva venta especificando todos sus atributos, incluida la lista de productos vendidos. Mostrar la lista de todas las ventas registradas en la tienda. Buscar una venta por número de factura o por fecha. Calcular el monto total de ventas en un rango de fechas especificado por el usuario. Mostrar los productos más vendidos. Salir del sistema. Implementa una clase Venta que contenga los atributos mencionados y métodos para realizar las operaciones descritas anteriormente. Luego, crea una clase principal (Main) que interactúe con el usuario y utilice objetos de la clase Venta para realizar las operaciones solicitadas.
package poo;
import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Ejercicio15 {
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
Producto producto=new Producto();
Venta venta=new Venta();
ArrayList<Producto> productos=new ArrayList<Producto>();
ArrayList<Venta> ventas=new ArrayList<Venta>();
int opcionMenu=0;
do {
System.out.println("Carrito de la compra");
System.out.println("(1).Agregar productos");
System.out.println("(2).Realizar una compra");
System.out.println("(3).Mostrar ventas");
System.out.println("(4).Mostrar venta por numero de factura");
System.out.println("(5).Mostrar venta por fecha de venta");
System.out.println("(6).Mostrar total de ventas entre dos fechas");
System.out.println("(7).Top 10 productos mas vendidos");
System.out.println("(8).Salir del carrito");
System.out.println("Introduce opcion:");
try {
opcionMenu=Integer.parseInt(entrada.next());
}catch(NumberFormatException e) {
System.out.println("Formato de opcion de menu no valido,intentalo de nuevo");
}
switch(opcionMenu){
case 1:
producto.agregarProducto(productos);
break;
case 2:
venta.venderProducto(productos,ventas);
break;
case 3:
venta.mostrarVentas(ventas,0);
break;
case 4:
int numFactura=0;
Scanner entrada3=new Scanner(System.in);
do {
try {
System.out.println("Introduce el numero de factura a buscar");
numFactura=Integer.parseInt(entrada3.nextLine());
venta.mostrarVentas(ventas, numFactura);
}catch(NumberFormatException e) {
System.err.println("Numero de factura no valido");
numFactura=0;
}finally {
entrada3.nextLine();
}
}while(numFactura==0);
break;
case 5:
venta.mostrarFacturasFecha(ventas);
break;
case 6:
venta.mostrarTotalFechas(ventas);
break;
case 7:
venta.mostrarTopProductosMasVendidos(ventas);
break;
case 8:
System.out.println("Cierre de dia");
break;
default:
System.err.println("Opcion no contemplada en el menu");
break;
}
}while(opcionMenu!=8);
}
}
class Venta{
private int numFactura;
private LocalDate fecha;
private double total;
private ArrayList<Producto> productosVenta=new ArrayList<Producto>();
public Venta(int numFactura, LocalDate fecha, double total,ArrayList<Producto> productosVenta) {
this.numFactura = numFactura;
this.fecha = fecha;
this.total = total;
this.productosVenta=productosVenta;
}
public Venta() {
}
/**
* @return the numFactura
*/
public int getNumFactura() {
return numFactura;
}
/**
* @param numFactura the numFactura to set
*/
public void setNumFactura(int numFactura) {
this.numFactura = numFactura;
}
/**
* @return the fecha
*/
public LocalDate getFecha() {
return fecha;
}
/**
* @param fecha the fecha to set
*/
public void setFecha(LocalDate fecha) {
this.fecha = fecha;
}
/**
* @return the total
*/
public double getTotal() {
return total;
}
/**
* @param total the total to set
*/
public void setTotal(double total) {
this.total = total;
}
public ArrayList<Producto> getProductosVenta() {
return productosVenta;
}
//Funcion realizar una compra
public void venderProducto(ArrayList<Producto> productos,ArrayList<Venta> ventas) {
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
System.err.println("No hay productos dados de alta en el almacen");
return;
}
//Genero el numero de factura que sea consecutivo
int numFactura=0;
if(ventas.size()==0) {
numFactura=1;
}else {
for (Venta venta : ventas) {
if(venta.getNumFactura()>numFactura) {
numFactura=venta.getNumFactura();
}
}
numFactura++;
}
//Genero la fecha actual para la factura
LocalDate fechaFactura=LocalDate.now();
System.out.println("\nLista de productos");
for (Producto producto : productos) {
System.out.println("Codigo: " + producto.getCodigo() + " | Nombre: " + producto.getNombre() +
" | Precio: " + producto.getPrecio() + " | Cantidad: " + producto.getCantidad());
}
int codigoProducto=0,cantidadProducto=0;
String continuarCompra;
boolean productoEncontrado=false;
ArrayList<Producto> productosCarrito=new ArrayList<Producto>();
double total=0.0;
while(true) {
try {
productoEncontrado=false;
System.out.println("Introduce el codigo del producto");
codigoProducto=Integer.parseInt(entrada2.nextLine());
for (Producto producto : productos) {
if(codigoProducto==producto.getCodigo()) {
productoEncontrado=true;
do {
try {
System.out.println("Has disponibles " + producto.getCantidad() + " de " + producto.getNombre()
+ " ¿Cuantas quieres comprar?");
cantidadProducto=Integer.parseInt(entrada2.nextLine());
if(cantidadProducto>producto.getCantidad()) {
cantidadProducto=0;
}
}catch(NumberFormatException e) {
System.err.println("Formato de cantidad no valido");
cantidadProducto=0;
}
}while(cantidadProducto>producto.getCantidad() || cantidadProducto==0);
producto.setCantidad(producto.getCantidad()-cantidadProducto);
Producto registroCompra=new Producto(producto.getCodigo(),producto.getNombre(),producto.getPrecio(),cantidadProducto);
productosCarrito.add(registroCompra);
System.out.println("Producto agregado al carrito");
total+=producto.getPrecio()*cantidadProducto;
}
}
if(!productoEncontrado) {
System.err.println("Ese producto no se encuentra en el almacen");
}
}catch(NumberFormatException e) {
System.err.println("Formato de codigo no valido");
}
do {
System.out.println("¿Quieres agregar mas productos s/n?");
continuarCompra=entrada2.nextLine();
}while(!continuarCompra.toLowerCase().equals("s") && !continuarCompra.toLowerCase().equals("n"));
if(continuarCompra.toLowerCase().equals("n")) {
break;
}
}
Venta nuevaVenta=new Venta(numFactura,fechaFactura,total,productosCarrito);
ventas.add(nuevaVenta);
System.out.println("Compra finalizada, total: " + total + "€");
}
//funcion mostrar ventas
public void mostrarVentas(ArrayList<Venta> ventas,int numFactura) {
if(ventas.size()==0) {
System.err.println("No hay ninguna venta todavia");
return;
}
boolean encuentroFactura=false;
if(numFactura==0) {
System.out.println("Listado de todas las ventas");
for (Venta venta : ventas) {
System.out.println("Nº Factura: " + venta.getNumFactura() + " | Fecha: " + venta.getFecha() + " | Total: " + venta.getTotal());
}
}else {
for (Venta venta : ventas) {
if(venta.getNumFactura()==numFactura) {
System.out.println("Factura solicitada");
System.out.println("Nº Factura: " + venta.getNumFactura() + " | Fecha: " + venta.getFecha() + " | Total: " + venta.getTotal());
encuentroFactura=true;
}
}
if (!encuentroFactura) {
System.out.println("Numero de factura no encontrada");
}
}
}
//Funcion mostrar facturas por fecha
public void mostrarFacturasFecha(ArrayList<Venta> ventas) {
if(ventas.size()==0) {
System.err.println("No hay ventas aun en la base de datos");
}
Scanner entrada2=new Scanner(System.in);
String fechaBusqueda;
try {
System.out.println("Introduce la fecha de busqueda (yyyy-mm-dd)");
fechaBusqueda=entrada2.nextLine();
LocalDate FechaBusquedaFormato=LocalDate.parse(fechaBusqueda);
boolean facturasFecha=false;
for (Venta venta : ventas) {
if(venta.getFecha().equals(FechaBusquedaFormato)) {
System.out.println("Nº Factura: " + venta.getNumFactura() + " | Fecha: " + venta.getFecha() + " | Total: " + venta.getTotal());
facturasFecha=true;
}
}
if(!facturasFecha) {
System.out.println("No hay facturas de esa fecha");
}
}catch(DateTimeParseException e) {
System.err.println("Formato de fecha no valido");
}
}
//funcion mostrar total por fechas
public void mostrarTotalFechas(ArrayList<Venta> ventas) {
if(ventas.size()==0) {
System.err.println("No hay ventas aun en la base de datos");
}
Scanner entrada2=new Scanner(System.in);
String fechaBusquedaInicial,fechaBusquedaFinal;
try {
System.out.println("Introduce la fecha de busqueda inicial (yyyy-mm-dd)");
fechaBusquedaInicial=entrada2.nextLine();
LocalDate FechaBusquedaFormatoInicial=LocalDate.parse(fechaBusquedaInicial);
System.out.println("Introduce la fecha de busqueda final (yyyy-mm-dd)");
fechaBusquedaFinal=entrada2.nextLine();
LocalDate FechaBusquedaFormatoFinal=LocalDate.parse(fechaBusquedaFinal);
boolean facturasFecha=false;
double sumaTotal=0.0;
for (Venta venta : ventas) {
if(venta.getFecha().isAfter(FechaBusquedaFormatoInicial) && venta.getFecha().isBefore(FechaBusquedaFormatoFinal)) {
System.out.println("Nº Factura: " + venta.getNumFactura() + " | Fecha: " + venta.getFecha() + " | Total: " + venta.getTotal());
facturasFecha=true;
sumaTotal+=venta.getTotal();
}
}
if(!facturasFecha) {
System.out.println("No hay facturas de esa fecha");
}else {
System.out.println("Total de facturas entre fechas: " +sumaTotal);
}
}catch(DateTimeParseException e) {
System.err.println("Formato de fecha no valido");
}
}
//funcion top10
public void mostrarTopProductosMasVendidos(ArrayList<Venta> ventas) {
if (ventas.size() == 0) {
System.err.println("No hay ventas registradas.");
return;
}
HashMap<Integer, Integer> ventasPorProducto = new HashMap<>();
// Contar cuántas veces se ha vendido cada producto
for (Venta venta : ventas) {
for (Producto producto : venta.getProductosVenta()) {
int codigoProducto = producto.getCodigo();
int cantidadVendida = producto.getCantidad();
if (ventasPorProducto.containsKey(codigoProducto)) {
ventasPorProducto.put(codigoProducto, ventasPorProducto.get(codigoProducto) + cantidadVendida);
} else {
ventasPorProducto.put(codigoProducto, cantidadVendida);
}
}
}
// Ordenar los productos por cantidad vendida de manera descendente
ArrayList<Map.Entry<Integer, Integer>> listaProductosOrdenada = new ArrayList<>(ventasPorProducto.entrySet());
listaProductosOrdenada.sort((a, b) -> b.getValue().compareTo(a.getValue()));
// Mostrar los 10 productos más vendidos
int numProductosAMostrar = Math.min(10, listaProductosOrdenada.size());
if (numProductosAMostrar > 0) {
System.out.println("Los 10 productos más vendidos son:");
for (int i = 0; i < numProductosAMostrar; i++) {
int codigoProducto = listaProductosOrdenada.get(i).getKey();
int cantidadVendida = listaProductosOrdenada.get(i).getValue();
String nombreProducto = obtenerNombreProducto(codigoProducto, ventas);
System.out.println((i + 1) + ". " + nombreProducto + " - Cantidad vendida: " + cantidadVendida);
}
} else {
System.out.println("No hay suficientes ventas registradas para mostrar los productos más vendidos.");
}
}
// Función auxiliar para obtener el nombre de un producto dado su código
private String obtenerNombreProducto(int codigoProducto, ArrayList<Venta> ventas) {
for (Venta venta : ventas) {
for (Producto producto : venta.getProductosVenta()) {
if (producto.getCodigo() == codigoProducto) {
return producto.getNombre();
}
}
}
return "";
}
}
class Producto{
private int codigo;
private String nombre;
private double precio;
private int cantidad;
public Producto(int codigo, String nombre, double precio, int cantidad) {
this.codigo = codigo;
this.nombre = nombre;
this.precio = precio;
this.cantidad = cantidad;
}
public Producto() {
}
/**
* @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;
}
//Funcion agregar un producto
public void agregarProducto(ArrayList<Producto> productos) {
int codigoMax= Integer.MIN_VALUE;
Scanner entrada2=new Scanner(System.in);
if(productos.size()==0) {
codigoMax=1;
}else {
for (Producto producto : productos) {
if(producto.getCodigo()>codigoMax) {
codigoMax=producto.getCodigo();
}
}
codigoMax++;
}
System.out.println("Introduce el nombre del producto");
this.nombre=entrada2.nextLine();
do {
System.out.println("Introduce el precio de " + this.nombre);
try {
this.precio=Double.parseDouble(entrada2.nextLine());
}catch(NumberFormatException e) {
System.out.println("Precio no valido, introducelo de nuevo");
this.precio=-1;
}
}while(this.precio<0);
do {
System.out.println("Introduce el cantidad de stock de " + this.nombre);
try {
this.cantidad=Integer.parseInt(entrada2.nextLine());
}catch(NumberFormatException e) {
System.out.println("Cantidad no valida, introducelo de nuevo");
this.cantidad=-1;
}
}while(this.precio<0);
Producto producto=new Producto(codigoMax,this.nombre,this.precio,this.cantidad);
productos.add(producto);
}
}
Ejercicio 16
Ejercicio POO básico en Java: El programa cumple el enunciado porque: - Define una clase Persona con atributos privados - Usa encapsulación mediante getters y setters - Tiene un constructor para inicializar los datos - Implementa métodos de comportamiento propios del objeto - Incluye un método main para probar la clase en el mismo archivo
package poo;
public class Persona {
// Atributos privados (encapsulación)
private String nombre;
private int edad;
// Constructor que inicializa los atributos
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
// Getter del nombre
public String getNombre() {
return nombre;
}
// Setter del nombre
public void setNombre(String nombre) {
this.nombre = nombre;
}
// Getter de la edad
public int getEdad() {
return edad;
}
// Setter de la edad
public void setEdad(int edad) {
this.edad = edad;
}
// Representación del objeto en formato texto
@Override
public String toString() {
return "Persona [nombre=" + nombre + ", edad=" + edad + "]";
}
// Método que muestra los datos de la persona
public String mostrarDatos() {
return "Nombre: " + nombre + "\nEdad: " + edad;
}
// Método que indica si la persona es mayor de edad
public boolean esMayorDeEdad() {
return edad >= 18;
}
// Método main para probar la clase
public static void main(String[] args) {
// Creación de objetos Persona
Persona p1 = new Persona("Carlos", 44);
Persona p2 = new Persona("Teo", 5);
// Mostrar datos de cada persona
System.out.println(p1.mostrarDatos());
System.out.println(p2.mostrarDatos());
// Comprobar si son mayores de edad
System.out.println(p1.esMayorDeEdad() ?
"Es mayor de edad" : "No es mayor de edad");
System.out.println(p2.esMayorDeEdad() ?
"Es mayor de edad" : "No es mayor de edad");
}
}
Ejercicio 17
Ejercicio POO - CuentaBancaria El programa cumple el enunciado porque: - Define una clase CuentaBancaria con atributos privados - Usa encapsulación mediante getters y setters - Tiene un constructor para inicializar titular y saldo - Permite ingresar y retirar dinero de la cuenta - Controla que no se pueda retirar más dinero del disponible - Incluye un método que indica si la cuenta tiene saldo - Contiene un main para probar la clase en el mismo archivo
package poo;
public class CuentaBancaria {
// Atributos privados (encapsulación)
private String titular;
private double saldo;
// Constructor que inicializa titular y saldo
public CuentaBancaria(String titular, double saldo) {
this.titular = titular;
this.saldo = saldo;
}
// Getter y Setter del titular
public String getTitular() {
return titular;
}
public void setTitular(String titular) {
this.titular = titular;
}
// Getter y Setter del saldo
public double getSaldo() {
return saldo;
}
public void setSaldo(double saldo) {
this.saldo = saldo;
}
// Método para mostrar los datos de la cuenta
public String mostrarDatos() {
return "Titular: " + titular + "\nSaldo: " + saldo;
}
// Método para ingresar dinero
public void ingresarSaldo(double cantidad) {
saldo += cantidad;
}
// Método para retirar dinero solo si hay saldo suficiente
public void retirarSaldo(double cantidad) {
if (saldo >= cantidad) {
saldo -= cantidad;
}
}
// Método que indica si la cuenta tiene saldo
public boolean tieneSaldo() {
return saldo > 0;
}
// Main de prueba
public static void main(String[] args) {
// Crear dos cuentas
CuentaBancaria cuenta1 = new CuentaBancaria("Carlos Fernandez Garcia", 3126.23);
CuentaBancaria cuenta2 = new CuentaBancaria("Beatriz Arevalo Roson", 13589.23);
// Operaciones con las cuentas
cuenta1.ingresarSaldo(1319.25);
cuenta2.retirarSaldo(523.36);
cuenta1.retirarSaldo(126.36);
// Mostrar resultados finales
System.out.println(cuenta1.mostrarDatos());
System.out.println(cuenta2.mostrarDatos());
}
}
Ejercicio 18
Ejercicio POO - Producto El programa cumple el enunciado porque: - Define una clase Producto con atributos privados - Usa encapsulación mediante getters y setters - Permite vender y reponer unidades del producto - Controla que no se pueda vender más stock del disponible - Incluye un método que indica si hay stock - Contiene un main para probar la clase en el mismo archivo
package poo;
public class Ejercicio18 {
public static void main(String[] args) {
// Crear dos productos
Producto p1 = new Producto("Tornillos", 5.25, 100);
Producto p2 = new Producto("Tuercas", 3.25, 0);
// Operaciones
p1.vender(50); // venta correcta
p2.vender(50); // no hay stock, no se vende
p2.reponer(150); // reponer unidades
// Mostrar resultados finales
System.out.println(p1.mostrarDatos());
System.out.println(p2.mostrarDatos());
}
}
// Clase Producto
class Producto {
// Atributos privados
private String nombre;
private double precio;
private int stock;
// Constructor
public Producto(String nombre, double precio, int stock) {
this.nombre = nombre;
this.precio = precio;
this.stock = stock;
}
// Getters y Setters
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public double getPrecio() {
return precio;
}
public void setPrecio(double precio) {
this.precio = precio;
}
public int getStock() {
return stock;
}
public void setStock(int stock) {
this.stock = stock;
}
// Mostrar datos del producto
public String mostrarDatos() {
return "Nombre: " + nombre + "\nPrecio: " + precio + "€\nStock: " + stock;
}
// Vender unidades solo si hay suficiente stock
public boolean vender(int cantidad) {
if (stock >= cantidad) {
stock -= cantidad;
return true;
} else {
return false;
}
}
// Reponer unidades
public void reponer(int cantidad) {
stock += cantidad;
}
// Comprobar si hay stock
public boolean tieneStock() {
return stock > 0;
}
}
Ejercicio 19
Ejercicio POO - Libro El programa cumple el enunciado porque: - Define una clase Libro con atributos privados - Usa encapsulación mediante getters y setters - Permite prestar y devolver libros controlando si ya estaban prestados - Incluye un método que indica si el libro está prestado - Contiene un main para probar la clase en el mismo archivo
package poo;
public class Ejercicio19 {
public static void main(String[] args) {
// Crear dos libros
Libro l1 = new Libro("Don Quijote", "Cervantes", 2569);
Libro l2 = new Libro("Lazarillo de Tormes", "Anónimo", 350);
// Intentos de prestar
System.out.println(l1.prestar() ? "Prestado" : "Ya estaba prestado");
System.out.println(l1.prestar() ? "Prestado" : "Ya estaba prestado");
// Devolver libro
l1.devolver();
// Mostrar datos finales
System.out.println(l1.mostrarDatos());
System.out.println(l2.mostrarDatos());
}
}
// Clase Libro
class Libro {
// Atributos privados
private String titulo;
private String autor;
private int numPaginas;
private boolean prestado;
// Constructor: prestado por defecto es false
public Libro(String titulo, String autor, int numPaginas) {
this.titulo = titulo;
this.autor = autor;
this.numPaginas = numPaginas;
this.prestado = false;
}
// Getters y setters
public String getTitulo() {
return titulo;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public String getAutor() {
return autor;
}
public void setAutor(String autor) {
this.autor = autor;
}
public int getNumPaginas() {
return numPaginas;
}
public void setNumPaginas(int numPaginas) {
this.numPaginas = numPaginas;
}
public boolean isPrestado() {
return prestado;
}
public void setPrestado(boolean prestado) {
this.prestado = prestado;
}
// Mostrar datos del libro
public String mostrarDatos() {
return "Título: " + titulo +
"\nAutor: " + autor +
"\nNº Páginas: " + numPaginas +
"\nPrestado: " + (prestado ? "Sí" : "No");
}
// Prestar libro solo si no estaba prestado
public boolean prestar() {
if (!prestado) {
prestado = true;
return true;
}
return false;
}
// Devolver libro
public void devolver() {
prestado = false;
}
// Comprobar si está prestado
public boolean estaPrestado() {
return prestado;
}
}
Ejercicio 20
ENUNCIADO Crea una clase llamada Empleado que tenga: Atributos: - String nombre - double sueldo - int horasExtra Métodos: - Constructor con nombre y sueldo (horasExtra empieza en 0) - mostrarDatos() → muestra: Nombre Sueldo base Horas extra Sueldo total - agregarHorasExtra(int horas) - calcularSueldoTotal() (cada hora extra se paga a 15 €) Main (en el mismo archivo): - Crea dos empleados - Añade horas extra a uno de ellos - Muestra los datos de ambos
package poo;
public class Ejercicio20 {
public static void main(String[] args) {
// Creamos dos empleados
Empleado carlos = new Empleado("Carlos", 1319.56);
Empleado bea = new Empleado("Bea", 2425.32);
// Añadimos horas extra a Carlos
carlos.agregarHorasExtra(15);
// Mostramos los datos de ambos empleados
System.out.println(carlos.mostrarDatos());
System.out.println(bea.mostrarDatos());
}
}
class Empleado {
// Atributos del empleado
private String nombre;
private double sueldo;
private int horasExtra;
// Constructor: inicializa nombre y sueldo
// Las horas extra comienzan en 0
public Empleado(String nombre, double sueldo) {
this.nombre = nombre;
this.sueldo = sueldo;
this.horasExtra = 0;
}
// Getters y setters
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public double getSueldo() {
return sueldo;
}
public void setSueldo(double sueldo) {
this.sueldo = sueldo;
}
public int getHorasExtra() {
return horasExtra;
}
public void setHorasExtra(int horasExtra) {
this.horasExtra = horasExtra;
}
// Muestra todos los datos del empleado
public String mostrarDatos() {
return "Nombre: " + nombre +
"\nSueldo base: " + sueldo + " €" +
"\nHoras extra: " + horasExtra +
"\nSueldo total: " + calcularSueldoTotal() + " €";
}
// Suma horas extra al empleado
public void agregarHorasExtra(int horas) {
horasExtra += horas;
}
// Calcula el sueldo total
// Cada hora extra vale 15 €
public double calcularSueldoTotal() {
return sueldo + (horasExtra * 15);
}
}