Skip to content

Commit d624c9d

Browse files
Roswell468Roswell468
authored
Merge pull request #9026 from AnaLauDB/reto-28-java
#28 - Java
2 parents fc1d8a8 + c8b865f commit d624c9d

File tree

1 file changed

+364
-0
lines changed

1 file changed

+364
-0
lines changed

‎Roadmap/28 - SOLID LSP/java/AnaLauDB.java‎

Lines changed: 364 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,364 @@
1+
public class AnaLauDB {
2+
3+
// ==========================================================================
4+
// IMPLEMENTACIÓN QUE CUMPLE EL PRINCIPIO DE SUSTITUCIÓN DE LISKOV (LSP)
5+
// ==========================================================================
6+
7+
// 1. Clase base Vehículo
8+
static abstract class Vehiculo {
9+
protected String marca;
10+
protected String modelo;
11+
protected double velocidad;
12+
protected double velocidadMaxima;
13+
protected boolean encendido;
14+
15+
public Vehiculo(String marca, String modelo, double velocidadMaxima) {
16+
this.marca = marca;
17+
this.modelo = modelo;
18+
this.velocidadMaxima = velocidadMaxima;
19+
this.velocidad = 0;
20+
this.encendido = false;
21+
}
22+
23+
// Método para encender el vehículo
24+
public void encender() {
25+
if (!encendido) {
26+
encendido = true;
27+
System.out.println(marca + " " + modelo + " encendido.");
28+
}
29+
}
30+
31+
// Método para apagar el vehículo
32+
public void apagar() {
33+
if (encendido && velocidad == 0) {
34+
encendido = false;
35+
System.out.println(marca + " " + modelo + " apagado.");
36+
} else if (velocidad > 0) {
37+
System.out.println("No se puede apagar el vehículo en movimiento.");
38+
}
39+
}
40+
41+
// Método acelerar - debe ser implementado por las subclases
42+
public abstract void acelerar(double incremento);
43+
44+
// Método frenar - debe ser implementado por las subclases
45+
public abstract void frenar(double decremento);
46+
47+
// Método para mostrar estado actual
48+
public void mostrarEstado() {
49+
System.out.printf("%s %s - Velocidad: %.1f km/h, Estado: %s%n",
50+
marca, modelo, velocidad, encendido ? "Encendido" : "Apagado");
51+
}
52+
53+
// Getters
54+
public double getVelocidad() {
55+
return velocidad;
56+
}
57+
58+
public double getVelocidadMaxima() {
59+
return velocidadMaxima;
60+
}
61+
62+
public boolean isEncendido() {
63+
return encendido;
64+
}
65+
66+
public String getMarca() {
67+
return marca;
68+
}
69+
70+
public String getModelo() {
71+
return modelo;
72+
}
73+
}
74+
75+
// ==========================================================================
76+
// 2. SUBCLASES DE VEHÍCULO QUE CUMPLEN LSP
77+
// ==========================================================================
78+
79+
// Subclase: Automóvil
80+
static class Automovil extends Vehiculo {
81+
private int numeroPuertas;
82+
83+
public Automovil(String marca, String modelo, double velocidadMaxima, int numeroPuertas) {
84+
super(marca, modelo, velocidadMaxima);
85+
this.numeroPuertas = numeroPuertas;
86+
}
87+
88+
@Override
89+
public void acelerar(double incremento) {
90+
if (!encendido) {
91+
System.out.println("Error: Debe encender el automóvil primero.");
92+
return;
93+
}
94+
95+
if (incremento < 0) {
96+
System.out.println("Error: El incremento de velocidad debe ser positivo.");
97+
return;
98+
}
99+
100+
double nuevaVelocidad = velocidad + incremento;
101+
if (nuevaVelocidad <= velocidadMaxima) {
102+
velocidad = nuevaVelocidad;
103+
System.out.printf("Automóvil acelerando: %.1f km/h%n", velocidad);
104+
} else {
105+
velocidad = velocidadMaxima;
106+
System.out.printf("Automóvil alcanzó velocidad máxima: %.1f km/h%n", velocidad);
107+
}
108+
}
109+
110+
@Override
111+
public void frenar(double decremento) {
112+
if (decremento < 0) {
113+
System.out.println("Error: El decremento de velocidad debe ser positivo.");
114+
return;
115+
}
116+
117+
double nuevaVelocidad = velocidad - decremento;
118+
if (nuevaVelocidad >= 0) {
119+
velocidad = nuevaVelocidad;
120+
System.out.printf("Automóvil frenando: %.1f km/h%n", velocidad);
121+
} else {
122+
velocidad = 0;
123+
System.out.println("Automóvil detenido completamente.");
124+
}
125+
}
126+
127+
public int getNumeroPuertas() {
128+
return numeroPuertas;
129+
}
130+
}
131+
132+
// Subclase: Motocicleta
133+
static class Motocicleta extends Vehiculo {
134+
private int cilindrada;
135+
136+
public Motocicleta(String marca, String modelo, double velocidadMaxima, int cilindrada) {
137+
super(marca, modelo, velocidadMaxima);
138+
this.cilindrada = cilindrada;
139+
}
140+
141+
@Override
142+
public void acelerar(double incremento) {
143+
if (!encendido) {
144+
System.out.println("Error: Debe encender la motocicleta primero.");
145+
return;
146+
}
147+
148+
if (incremento < 0) {
149+
System.out.println("Error: El incremento de velocidad debe ser positivo.");
150+
return;
151+
}
152+
153+
// Las motocicletas aceleran más rápido que los automóviles
154+
double aceleracionReal = incremento * 1.2;
155+
double nuevaVelocidad = velocidad + aceleracionReal;
156+
157+
if (nuevaVelocidad <= velocidadMaxima) {
158+
velocidad = nuevaVelocidad;
159+
System.out.printf("Motocicleta acelerando rápidamente: %.1f km/h%n", velocidad);
160+
} else {
161+
velocidad = velocidadMaxima;
162+
System.out.printf("Motocicleta alcanzó velocidad máxima: %.1f km/h%n", velocidad);
163+
}
164+
}
165+
166+
@Override
167+
public void frenar(double decremento) {
168+
if (decremento < 0) {
169+
System.out.println("Error: El decremento de velocidad debe ser positivo.");
170+
return;
171+
}
172+
173+
// Las motocicletas pueden frenar más bruscamente
174+
double frenadoReal = decremento * 1.1;
175+
double nuevaVelocidad = velocidad - frenadoReal;
176+
177+
if (nuevaVelocidad >= 0) {
178+
velocidad = nuevaVelocidad;
179+
System.out.printf("Motocicleta frenando: %.1f km/h%n", velocidad);
180+
} else {
181+
velocidad = 0;
182+
System.out.println("Motocicleta detenida completamente.");
183+
}
184+
}
185+
186+
public int getCilindrada() {
187+
return cilindrada;
188+
}
189+
}
190+
191+
// Subclase: Camión
192+
static class Camion extends Vehiculo {
193+
private double capacidadCarga;
194+
195+
public Camion(String marca, String modelo, double velocidadMaxima, double capacidadCarga) {
196+
super(marca, modelo, velocidadMaxima);
197+
this.capacidadCarga = capacidadCarga;
198+
}
199+
200+
@Override
201+
public void acelerar(double incremento) {
202+
if (!encendido) {
203+
System.out.println("Error: Debe encender el camión primero.");
204+
return;
205+
}
206+
207+
if (incremento < 0) {
208+
System.out.println("Error: El incremento de velocidad debe ser positivo.");
209+
return;
210+
}
211+
212+
// Los camiones aceleran más lento debido a su peso
213+
double aceleracionReal = incremento * 0.7;
214+
double nuevaVelocidad = velocidad + aceleracionReal;
215+
216+
if (nuevaVelocidad <= velocidadMaxima) {
217+
velocidad = nuevaVelocidad;
218+
System.out.printf("Camión acelerando lentamente: %.1f km/h%n", velocidad);
219+
} else {
220+
velocidad = velocidadMaxima;
221+
System.out.printf("Camión alcanzó velocidad máxima: %.1f km/h%n", velocidad);
222+
}
223+
}
224+
225+
@Override
226+
public void frenar(double decremento) {
227+
if (decremento < 0) {
228+
System.out.println("Error: El decremento de velocidad debe ser positivo.");
229+
return;
230+
}
231+
232+
// Los camiones necesitan más distancia para frenar
233+
double frenadoReal = decremento * 0.8;
234+
double nuevaVelocidad = velocidad - frenadoReal;
235+
236+
if (nuevaVelocidad >= 0) {
237+
velocidad = nuevaVelocidad;
238+
System.out.printf("Camión frenando gradualmente: %.1f km/h%n", velocidad);
239+
} else {
240+
velocidad = 0;
241+
System.out.println("Camión detenido completamente.");
242+
}
243+
}
244+
245+
public double getCapacidadCarga() {
246+
return capacidadCarga;
247+
}
248+
}
249+
250+
// ==========================================================================
251+
// 4. CÓDIGO QUE COMPRUEBA EL CUMPLIMIENTO DEL LSP
252+
// ==========================================================================
253+
254+
// Método que trabaja con la clase base Vehículo
255+
public static void probarVehiculo(Vehiculo vehiculo) {
256+
System.out.println("\n--- Probando vehículo: " + vehiculo.getMarca() + " " + vehiculo.getModelo() + " ---");
257+
258+
// Encender vehículo
259+
vehiculo.encender();
260+
vehiculo.mostrarEstado();
261+
262+
// Acelerar varias veces
263+
vehiculo.acelerar(20);
264+
vehiculo.mostrarEstado();
265+
266+
vehiculo.acelerar(30);
267+
vehiculo.mostrarEstado();
268+
269+
vehiculo.acelerar(40);
270+
vehiculo.mostrarEstado();
271+
272+
// Frenar
273+
vehiculo.frenar(25);
274+
vehiculo.mostrarEstado();
275+
276+
vehiculo.frenar(50);
277+
vehiculo.mostrarEstado();
278+
279+
// Apagar vehículo
280+
vehiculo.apagar();
281+
}
282+
283+
// Método que demuestra el polimorfismo y LSP
284+
public static void simularCarrera(Vehiculo[] vehiculos) {
285+
System.out.println("\n=== SIMULACIÓN DE CARRERA ===");
286+
287+
// Encender todos los vehículos
288+
for (Vehiculo v : vehiculos) {
289+
v.encender();
290+
}
291+
292+
// Acelerar todos por igual
293+
System.out.println("\n ¡Comienza la carrera! Todos aceleran 50 km/h");
294+
for (Vehiculo v : vehiculos) {
295+
v.acelerar(50);
296+
}
297+
298+
// Mostrar velocidades después de la aceleración
299+
System.out.println("\n Velocidades después de acelerar:");
300+
for (Vehiculo v : vehiculos) {
301+
System.out.printf("%-15s: %.1f km/h%n",
302+
v.getMarca() + " " + v.getModelo(), v.getVelocidad());
303+
}
304+
305+
// Frenar todos
306+
System.out.println("\n Todos frenan 30 km/h");
307+
for (Vehiculo v : vehiculos) {
308+
v.frenar(30);
309+
}
310+
311+
// Mostrar velocidades finales
312+
System.out.println("\n Velocidades después de frenar:");
313+
for (Vehiculo v : vehiculos) {
314+
System.out.printf("%-15s: %.1f km/h%n",
315+
v.getMarca() + " " + v.getModelo(), v.getVelocidad());
316+
}
317+
}
318+
319+
public static void main(String[] args) {
320+
System.out.println("=== DEMOSTRACIÓN DEL PRINCIPIO DE SUSTITUCIÓN DE LISKOV (LSP) ===");
321+
322+
// Crear instancias de diferentes tipos de vehículos
323+
Vehiculo auto = new Automovil("Toyota", "Corolla", 180, 4);
324+
Vehiculo moto = new Motocicleta("Honda", "CBR600", 250, 600);
325+
Vehiculo camion = new Camion("Volvo", "FH16", 120, 40000);
326+
327+
// 4. Comprobar que se cumple el LSP
328+
System.out.println("1. Probando cada vehículo individualmente:");
329+
330+
// Cada subclase puede ser sustituida por la clase base sin romper la
331+
// funcionalidad
332+
probarVehiculo(auto); // LSP: Automóvil puede sustituir a Vehículo
333+
probarVehiculo(moto); // LSP: Motocicleta puede sustituir a Vehículo
334+
probarVehiculo(camion); // LSP: Camión puede sustituir a Vehículo
335+
336+
// Demostrar polimorfismo y LSP con un array de vehículos
337+
Vehiculo[] vehiculos = { auto, moto, camion };
338+
simularCarrera(vehiculos);
339+
340+
// Verificar que todas las subclases mantienen las postcondiciones de la clase
341+
// base
342+
System.out.println("\n=== VERIFICACIÓN LSP ===");
343+
System.out.println("Todas las subclases pueden ser sustituidas por la clase base");
344+
System.out.println("Los métodos acelerar() y frenar() funcionan correctamente");
345+
System.out.println("Las precondiciones no son fortalecidas en las subclases");
346+
System.out.println("Las postcondiciones no son debilitadas en las subclases");
347+
System.out.println("Los invariantes de la clase base se mantienen en todas las subclases");
348+
349+
// Ejemplo de uso polimórfico adicional
350+
System.out.println("\n=== EJEMPLO POLIMÓRFICO ADICIONAL ===");
351+
for (Vehiculo v : vehiculos) {
352+
System.out.println("\nTipo: " + v.getClass().getSimpleName());
353+
v.encender();
354+
v.acelerar(60);
355+
v.frenar(60);
356+
v.apagar();
357+
}
358+
359+
System.out.println("\n CONCLUSIÓN: El LSP se cumple correctamente!");
360+
System.out.println(" - Cualquier instancia de Vehículo puede ser reemplazada por sus subclases");
361+
System.out.println(" - El comportamiento del programa sigue siendo correcto");
362+
System.out.println(" - No hay efectos secundarios inesperados");
363+
}
364+
}

0 commit comments

Comments
 (0)