ArrayLists: Ejemplo de método sobrescrito en
ArrayList<String> lista = new una subclase:
ArrayList<>(); class Animal {
lista.add("elemento1"); void hacerSonido() {
lista.add("elemento2"); System.out.println("Sonido de
for (String elemento : lista) { animal");
System.out.println(elemento); }
} }
HashMaps:
HashMap<String, Integer> mapa = class Perro extends Animal {
new HashMap<>(); @Override
mapa.put("clave1", 10); void hacerSonido() {
mapa.put("clave2", 20); System.out.println("Guau!");
for (Map.Entry<String, Integer> entry : }
mapa.entrySet()) { }
System.out.println(entry.getKey() + Ejemplo de interfaz y clase que la
": " + entry.getValue()); implementa:
} interface Vehiculo {
void conducir();
Ejemplo de clase abstracta y }
subclase que la extiende:
class Coche implements Vehiculo {
abstract class Forma { @Override
abstract double calcularArea(); public void conducir() {
} System.out.println("Conduciendo
un coche");
class Circulo extends Forma { }
double radio; }
Ejemplo de clase padre y subclase
@Override que la extiende:
double calcularArea() { class Animal {
return Math.PI * radio * radio; void comer() {
} System.out.println("El animal está
} comiendo");
}
Ejemplo de conversión de tipos }
primitivos a objetos y viceversa:
class Perro extends Animal {
int num1 = 10; void ladrar() {
Integer num2 = Integer.valueOf(num1); System.out.println("Guau!
int num3 = num2.intValue(); Guau!");
}
}
Override de toString():
class Persona {
private String nombre;
// Constructor y otros métodos
@Override
public String toString() {
return "Persona: " + nombre;
}
}
Override de equals():
class Persona {
private String nombre;
// Constructor y otros métodos
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() !=
obj.getClass()) {
return false;
}
Persona persona = (Persona) obj;
return Objects.equals(nombre,
persona.nombre);
}
}
Override de compareTo():
class Persona implements
Comparable<Persona> {
private String nombre;
private int edad;
// Constructor y otros métodos
@Override
public int compareTo(Persona
otraPersona) {
return Integer.compare(this.edad,
otraPersona.edad);
}
}
Ejercicio Salon De Juegos }
import java.time.Year;
abstract class Juego { public void setAnio(int anio) {
private static int numTotalJuegos = comprobarAnyo(anio);
0; }
private String titulo;
private String fabricante; public static int
private int anio; getNumTotalJuegos() {
return numTotalJuegos;
public Juego() { }
this("Sin título", "Desconocido",
1970); @Override
} public String toString() {
return "Título: " + titulo + ",
public Juego(String titulo, String Fabricante: " + fabricante + ", Año: " +
fabricante, int anio) { anio;
this.titulo = titulo; }
this.fabricante = fabricante;
comprobarAnyo(anio); @Override
numTotalJuegos++; public boolean equals(Object obj) {
} if (this == obj) return true;
if (obj == null || getClass() !=
public abstract void obj.getClass()) return false;
comprobarAnyo(int anio); Juego juego = (Juego) obj;
return anio == juego.anio &&
public String getTitulo() { titulo.equals(juego.titulo) &&
return titulo; fabricante.equals(juego.fabricante);
} }
public void setTitulo(String titulo) { public abstract int compareTo(Juego
this.titulo = titulo; otroJuego);
} }
public String getFabricante() { class JuegoEnAlquiler extends Juego
return fabricante; implements Alquilable {
} private double precio;
private int numCopiasDisponibles;
public void setFabricante(String private int numDiasAlquiler;
fabricante) {
this.fabricante = fabricante; public JuegoEnAlquiler() {
} super();
this.precio = 0;
public int getAnio() { this.numCopiasDisponibles = 0;
return anio; this.numDiasAlquiler = 1;
} public void devolver() {
numCopiasDisponibles++;
public JuegoEnAlquiler(String titulo, }
String fabricante, int anio, double
precio, int numCopiasDisponibles, int @Override
numDiasAlquiler) { public double precioFinal() {
super(titulo, fabricante, anio); return precio * numDiasAlquiler;
this.precio = precio; }
this.numCopiasDisponibles =
numCopiasDisponibles; @Override
this.numDiasAlquiler = public String toString() {
numDiasAlquiler; return super.toString() + ", Precio:
} " + precio + ", Número de copias
disponibles: " + numCopiasDisponibles
public + ", Número de días de alquiler: " +
JuegoEnAlquiler(JuegoEnAlquiler numDiasAlquiler;
otroJuego) { }
super(otroJuego.getTitulo(), }
otroJuego.getFabricante(),
otroJuego.getAnio()); class JuegoEnVenta extends Juego {
this.precio = otroJuego.precio; private double precio;
this.numCopiasDisponibles = private int numCopiasDisponibles;
otroJuego.numCopiasDisponibles;
this.numDiasAlquiler = public JuegoEnVenta() {
otroJuego.numDiasAlquiler; super();
} this.precio = 0;
this.numCopiasDisponibles = 0;
@Override }
public void comprobarAnyo(int anio)
{ public JuegoEnVenta(String titulo,
if (anio < 1970 || anio > String fabricante, int anio, double
Year.now().getValue()) { precio, int numCopiasDisponibles) {
this.setAnio(1970); super(titulo, fabricante, anio);
} else { this.precio = precio;
this.setAnio(anio); this.numCopiasDisponibles =
} numCopiasDisponibles;
} }
@Override @Override
public void alquilar() { public void comprobarAnyo(int anio)
numCopiasDisponibles--; {
} if (anio < 1970 || anio >
Year.now().getValue()) {
@Override this.setAnio(1970);
} else {
this.setAnio(anio);
}
}
public void vender() {
numCopiasDisponibles--;
}
@Override
public String toString() {
return super.toString() + ", Precio:
" + precio + ", Número de copias
disponibles: " +
numCopiasDisponibles;
}
}
interface Alquilable {
void alquilar();
void devolver();
double precioFinal();
}
import java.util.ArrayList; public Electrodomestico(String
import java.util.HashMap; modelo, int precioBase, char consumo,
import java.util.Scanner; int peso) {
this.modelo = modelo;
abstract class Electrodomestico { this.precioBase = precioBase;
private static int this.consumo = consumo;
numTotalElectrodomesticos = 0; this.peso = peso;
private static HashMap<Character, numTotalElectrodomesticos++;
Integer> precioConsumo = new }
HashMap<>();
private static HashMap<Integer, public abstract void
Integer> precioPeso = new comprobarConsumo(char letra);
HashMap<>();
private String modelo; public double incrementoPrecio() {
private int precioBase; double incrementoConsumo =
protected char consumo; precioConsumo.getOrDefault(Charact
private int peso; er.toUpperCase(consumo), 0);
int incrementoPeso = 0;
static { for (int limitePeso :
precioConsumo.put('A', 100); precioPeso.keySet()) {
precioConsumo.put('B', 80); if (peso <= limitePeso) {
precioConsumo.put('C', 60); incrementoPeso =
precioConsumo.put('D', 50); precioPeso.get(limitePeso);
precioConsumo.put('E', 30); break;
precioConsumo.put('F', 10); }
}
precioPeso.put(19, 10); return incrementoConsumo +
precioPeso.put(49, 50); incrementoPeso;
precioPeso.put(79, 80); }
precioPeso.put(Integer.MAX_VALUE, public static int
100); getNumTotalElectrodomesticos() {
} return
numTotalElectrodomesticos;
public Electrodomestico() { }
this.modelo = "Desconocido";
this.precioBase = 100; public static HashMap<Character,
this.consumo = 'F'; Integer> getPrecioConsumo() {
this.peso = 5; return precioConsumo;
numTotalElectrodomesticos++; }
}
public static HashMap<Integer,
Integer> getPrecioPeso() {
return precioPeso;
} this.consumo =
Character.toUpperCase(letra);
// Getters y Setters }
}
@Override
public String toString() { public double precioFinal() {
return "Modelo: " + modelo + ", double precioIncrementado =
Precio base: " + precioBase + "€, super.incrementoPrecio();
Consumo energético: " + consumo + ", if (carga > 30) {
Peso: " + peso + " kg"; precioIncrementado += 50;
} }
} return precioBase +
precioIncrementado;
class Lavadora extends }
Electrodomestico {
private int carga; @Override
public String toString() {
public Lavadora() { return super.toString() + ", Carga:
super(); " + carga + " kg, Precio final: " +
this.carga = 5; precioFinal() + "€";
} }
}
public Lavadora(String modelo, int
precioBase, char consumo, int peso, class Tienda {
int carga) { private ArrayList<Lavadora>
super(modelo, precioBase, lavadoras;
consumo, peso);
this.carga = carga; public Tienda() {
} this.lavadoras = new
ArrayList<>();
public Lavadora(Lavadora lavadora) }
{
super(lavadora.modelo, public void
lavadora.precioBase, agregarLavadora(Lavadora lavadora) {
lavadora.consumo, lavadora.peso); if (!lavadoras.contains(lavadora))
this.carga = lavadora.carga; {
} lavadoras.add(lavadora);
}
@Override }
public void
comprobarConsumo(char letra) { public Lavadora
if (letra < 'A' || letra > 'F') { buscarLavadora(String modelo) {
this.consumo = 'F'; for (Lavadora lavadora :
} else { lavadoras) {
if int opcion;
(lavadora.getModelo().equals(modelo))
{ do {
return lavadora; System.out.println("Menú:");
} System.out.println("1. Agregar
} una lavadora.");
return null; System.out.println("2. Buscar
} una lavadora por modelo.");
System.out.println("3. Modificar
public void el precio base de una lavadora por
modificarPrecioBase(String modelo, int modelo.");
nuevoPrecio) { System.out.println("4. Eliminar
Lavadora lavadora = una lavadora por modelo.");
buscarLavadora(modelo); System.out.println("5. Mostrar
if (lavadora != null) { todas las lavadoras.");
System.out.println("6. Salir");
lavadora.setPrecioBase(nuevoPrecio); System.out.print("Seleccione
} una opción: ");
} opcion = scanner.nextInt();
public void eliminarLavadora(String switch (opcion) {
modelo) { case 1:
Lavadora lavadora = agregarLavadora(tienda,
buscarLavadora(modelo); scanner);
if (lavadora != null) { break;
lavadoras.remove(lavadora); case 2:
} buscarLavadora(tienda,
} scanner);
break;
public void case 3:
mostrarTodasLavadoras() {
for (Lavadora lavadora : modificarPrecioBase(tienda, scanner);
lavadoras) { break;
System.out.println(lavadora); case 4:
} eliminarLavadora(tienda,
} scanner);
} break;
case 5:
public class Main {
public static void main(String[] args) tienda.mostrarTodasLavadoras();
{ break;
Tienda tienda = new Tienda(); }
Scanner scanner = new } while (opcion != 6);
Scanner(System.in); }
System.out.println(lavadora);
public static void } else {
agregarLavadora(Tienda tienda, System.out.println("No se
Scanner scanner) { encontró ninguna lavadora con ese
System.out.print("Ingrese el modelo.");
modelo de la lavadora: "); }
String modelo = scanner.next(); }
System.out.print("Ingrese el
precio base de la lavadora: "); public static void
int precioBase = modificarPrecioBase(Tienda tienda,
scanner.nextInt(); Scanner scanner) {
System.out.print("Ingrese el System.out.print("Ingrese el
consumo energético de la lavadora modelo de la lavadora cuyo precio
(letra entre A y F): "); base desea modificar: ");
char consumo = String modelo = scanner.next();
scanner.next().charAt(0); System.out.print("Ingrese el
System.out.print("Ingrese el peso nuevo precio base: ");
de la lavadora: "); int nuevoPrecio =
int peso = scanner.nextInt(); scanner.nextInt();
System.out.print("Ingrese la carga
de la lavadora: "); tienda.modificarPrecioBase(modelo,
int carga = scanner.nextInt(); nuevoPrecio);
System.out.println("Precio base
Lavadora lavadora = new modificado con éxito.");
Lavadora(modelo, precioBase, }
consumo, peso, carga);
public static void
tienda.agregarLavadora(lavadora); eliminarLavadora(Tienda tienda,
System.out.println("Lavadora Scanner scanner) {
agregada con éxito."); System.out.print("Ingrese el
} modelo de la lavadora que desea
eliminar: ");
public static void String modelo = scanner.next();
buscarLavadora(Tienda tienda, tienda.eliminarLavadora(modelo);
Scanner scanner) { System.out.println("Lavadora
System.out.print("Ingrese el eliminada con éxito.");
modelo de la lavadora que desea }
buscar: "); }
String modelo = scanner.next();
Lavadora lavadora =
tienda.buscarLavadora(modelo);
if (lavadora != null) {
System.out.println("Lavadora
encontrada:");
