ArrayLists: Ejemplo de método sobrescrito en
ArrayList<String> lista = new una subclase:
ArrayList<>(); class Animal {
[Link]("elemento1"); void hacerSonido() {
[Link]("elemento2"); [Link]("Sonido de
for (String elemento : lista) { animal");
[Link](elemento); }
} }
HashMaps:
HashMap<String, Integer> mapa = class Perro extends Animal {
new HashMap<>(); @Override
[Link]("clave1", 10); void hacerSonido() {
[Link]("clave2", 20); [Link]("Guau!");
for ([Link]<String, Integer> entry : }
[Link]()) { }
[Link]([Link]() + Ejemplo de interfaz y clase que la
": " + [Link]()); 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() {
} [Link]("Conduciendo
un coche");
class Circulo extends Forma { }
double radio; }
Ejemplo de clase padre y subclase
@Override que la extiende:
double calcularArea() { class Animal {
return [Link] * radio * radio; void comer() {
} [Link]("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 = [Link](num1); [Link]("Guau!
int num3 = [Link](); 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() !=
[Link]()) {
return false;
}
Persona persona = (Persona) obj;
return [Link](nombre,
[Link]);
}
}
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 [Link]([Link],
[Link]);
}
}
Ejercicio Salon De Juegos }
import [Link];
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;
[Link] = titulo; }
[Link] = fabricante;
comprobarAnyo(anio); @Override
numTotalJuegos++; public boolean equals(Object obj) {
} if (this == obj) return true;
if (obj == null || getClass() !=
public abstract void [Link]()) return false;
comprobarAnyo(int anio); Juego juego = (Juego) obj;
return anio == [Link] &&
public String getTitulo() { [Link]([Link]) &&
return titulo; [Link]([Link]);
} }
public void setTitulo(String titulo) { public abstract int compareTo(Juego
[Link] = 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) {
[Link] = fabricante; public JuegoEnAlquiler() {
} super();
[Link] = 0;
public int getAnio() { [Link] = 0;
return anio; [Link] = 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;
[Link] = precio; }
[Link] =
numCopiasDisponibles; @Override
[Link] = public String toString() {
numDiasAlquiler; return [Link]() + ", Precio:
} " + precio + ", Número de copias
disponibles: " + numCopiasDisponibles
public + ", Número de días de alquiler: " +
JuegoEnAlquiler(JuegoEnAlquiler numDiasAlquiler;
otroJuego) { }
super([Link](), }
[Link](),
[Link]()); class JuegoEnVenta extends Juego {
[Link] = [Link]; private double precio;
[Link] = private int numCopiasDisponibles;
[Link];
[Link] = public JuegoEnVenta() {
[Link]; super();
} [Link] = 0;
[Link] = 0;
@Override }
public void comprobarAnyo(int anio)
{ public JuegoEnVenta(String titulo,
if (anio < 1970 || anio > String fabricante, int anio, double
[Link]().getValue()) { precio, int numCopiasDisponibles) {
[Link](1970); super(titulo, fabricante, anio);
} else { [Link] = precio;
[Link](anio); [Link] =
} numCopiasDisponibles;
} }
@Override @Override
public void alquilar() { public void comprobarAnyo(int anio)
numCopiasDisponibles--; {
} if (anio < 1970 || anio >
[Link]().getValue()) {
@Override [Link](1970);
} else {
[Link](anio);
}
}
public void vender() {
numCopiasDisponibles--;
}
@Override
public String toString() {
return [Link]() + ", Precio:
" + precio + ", Número de copias
disponibles: " +
numCopiasDisponibles;
}
}
interface Alquilable {
void alquilar();
void devolver();
double precioFinal();
}
import [Link]; public Electrodomestico(String
import [Link]; modelo, int precioBase, char consumo,
import [Link]; int peso) {
[Link] = modelo;
abstract class Electrodomestico { [Link] = precioBase;
private static int [Link] = consumo;
numTotalElectrodomesticos = 0; [Link] = 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; [Link](Charact
private int peso; [Link](consumo), 0);
int incrementoPeso = 0;
static { for (int limitePeso :
[Link]('A', 100); [Link]()) {
[Link]('B', 80); if (peso <= limitePeso) {
[Link]('C', 60); incrementoPeso =
[Link]('D', 50); [Link](limitePeso);
[Link]('E', 30); break;
[Link]('F', 10); }
}
[Link](19, 10); return incrementoConsumo +
[Link](49, 50); incrementoPeso;
[Link](79, 80); }
[Link](Integer.MAX_VALUE, public static int
100); getNumTotalElectrodomesticos() {
} return
numTotalElectrodomesticos;
public Electrodomestico() { }
[Link] = "Desconocido";
[Link] = 100; public static HashMap<Character,
[Link] = 'F'; Integer> getPrecioConsumo() {
[Link] = 5; return precioConsumo;
numTotalElectrodomesticos++; }
}
public static HashMap<Integer,
Integer> getPrecioPeso() {
return precioPeso;
} [Link] =
[Link](letra);
// Getters y Setters }
}
@Override
public String toString() { public double precioFinal() {
return "Modelo: " + modelo + ", double precioIncrementado =
Precio base: " + precioBase + "€, [Link]();
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 [Link]() + ", Carga:
super(); " + carga + " kg, Precio final: " +
[Link] = 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);
[Link] = carga; public Tienda() {
} [Link] = new
ArrayList<>();
public Lavadora(Lavadora lavadora) }
{
super([Link], public void
[Link], agregarLavadora(Lavadora lavadora) {
[Link], [Link]); if ()
[Link] = [Link]; {
} [Link](lavadora);
}
@Override }
public void
comprobarConsumo(char letra) { public Lavadora
if (letra < 'A' || letra > 'F') { buscarLavadora(String modelo) {
[Link] = 'F'; for (Lavadora lavadora :
} else { lavadoras) {
if int opcion;
([Link]().equals(modelo))
{ do {
return lavadora; [Link]("Menú:");
} [Link]("1. Agregar
} una lavadora.");
return null; [Link]("2. Buscar
} una lavadora por modelo.");
[Link]("3. Modificar
public void el precio base de una lavadora por
modificarPrecioBase(String modelo, int modelo.");
nuevoPrecio) { [Link]("4. Eliminar
Lavadora lavadora = una lavadora por modelo.");
buscarLavadora(modelo); [Link]("5. Mostrar
if (lavadora != null) { todas las lavadoras.");
[Link]("6. Salir");
[Link](nuevoPrecio); [Link]("Seleccione
} una opción: ");
} opcion = [Link]();
public void eliminarLavadora(String switch (opcion) {
modelo) { case 1:
Lavadora lavadora = agregarLavadora(tienda,
buscarLavadora(modelo); scanner);
if (lavadora != null) { break;
[Link](lavadora); case 2:
} buscarLavadora(tienda,
} scanner);
break;
public void case 3:
mostrarTodasLavadoras() {
for (Lavadora lavadora : modificarPrecioBase(tienda, scanner);
lavadoras) { break;
[Link](lavadora); case 4:
} eliminarLavadora(tienda,
} scanner);
} break;
case 5:
public class Main {
public static void main(String[] args) [Link]();
{ break;
Tienda tienda = new Tienda(); }
Scanner scanner = new } while (opcion != 6);
Scanner([Link]); }
[Link](lavadora);
public static void } else {
agregarLavadora(Tienda tienda, [Link]("No se
Scanner scanner) { encontró ninguna lavadora con ese
[Link]("Ingrese el modelo.");
modelo de la lavadora: "); }
String modelo = [Link](); }
[Link]("Ingrese el
precio base de la lavadora: "); public static void
int precioBase = modificarPrecioBase(Tienda tienda,
[Link](); Scanner scanner) {
[Link]("Ingrese el [Link]("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 = [Link]();
[Link]().charAt(0); [Link]("Ingrese el
[Link]("Ingrese el peso nuevo precio base: ");
de la lavadora: "); int nuevoPrecio =
int peso = [Link](); [Link]();
[Link]("Ingrese la carga
de la lavadora: "); [Link](modelo,
int carga = [Link](); nuevoPrecio);
[Link]("Precio base
Lavadora lavadora = new modificado con éxito.");
Lavadora(modelo, precioBase, }
consumo, peso, carga);
public static void
[Link](lavadora); eliminarLavadora(Tienda tienda,
[Link]("Lavadora Scanner scanner) {
agregada con éxito."); [Link]("Ingrese el
} modelo de la lavadora que desea
eliminar: ");
public static void String modelo = [Link]();
buscarLavadora(Tienda tienda, [Link](modelo);
Scanner scanner) { [Link]("Lavadora
[Link]("Ingrese el eliminada con éxito.");
modelo de la lavadora que desea }
buscar: "); }
String modelo = [Link]();
Lavadora lavadora =
[Link](modelo);
if (lavadora != null) {
[Link]("Lavadora
encontrada:");