Ejercicio Java
En este ejercicio, crearás un programa en Java que implementa varios patrones de diseño comunes en la programación orientada a objetos. Utilizarás el patrón **Singleton** para asegurar que solo exista una instancia de una clase, el patrón **Factory** para crear objetos sin especificar la clase exacta del objeto, y el patrón **Observer** para permitir que un objeto notifique a otros objetos sobre cambios de estado sin acoplar fuertemente las clases entre sí.
Instrucciones:
- Implementa el patrón **Singleton** para una clase que debe tener solo una instancia en toda la aplicación.
- Desarrolla el patrón **Factory** creando una interfaz común para la creación de diferentes tipos de objetos sin que el cliente conozca la clase exacta que se instanciará.
- Implementa el patrón **Observer** para que un objeto (el sujeto) notifique automáticamente a los objetos observadores cuando su estado cambie.
- Prueba cada patrón creando ejemplos de objetos que utilicen cada uno de estos patrones de diseño.
Este ejercicio te ayudará a comprender cómo utilizar patrones de diseño en Java para mejorar la estructura de tus aplicaciones y hacerlas más escalables y fáciles de mantener.
Ver código de ejemplo
// Singleton Pattern
class Singleton {
private static Singleton instancia;
private Singleton() {}
public static Singleton obtenerInstancia() {
if (instancia == null) {
instancia = new Singleton();
}
return instancia;
}
public void mostrarMensaje() {
System.out.println("Este es el patrón Singleton.");
}
}
// Factory Pattern
interface Vehiculo {
void crear();
}
class Coche implements Vehiculo {
public void crear() {
System.out.println("Coche creado.");
}
}
class Moto implements Vehiculo {
public void crear() {
System.out.println("Moto creada.");
}
}
class VehiculoFactory {
public static Vehiculo crearVehiculo(String tipo) {
if (tipo.equals("Coche")) {
return new Coche();
} else if (tipo.equals("Moto")) {
return new Moto();
}
return null;
}
}
// Observer Pattern
import java.util.ArrayList;
import java.util.List;
interface Observador {
void actualizar(String mensaje);
}
class Sujeto {
private List<Observador> observadores = new ArrayList<>();
public void agregarObservador(Observador observador) {
observadores.add(observador);
}
public void eliminarObservador(Observador observador) {
observadores.remove(observador);
}
public void notificarObservadores(String mensaje) {
for (Observador observador : observadores) {
observador.actualizar(mensaje);
}
}
}
class ObservadorConcreto implements Observador {
private String nombre;
public ObservadorConcreto(String nombre) {
this.nombre = nombre;
}
@Override
public void actualizar(String mensaje) {
System.out.println(nombre + " recibió el mensaje: " + mensaje);
}
}
public class Main {
public static void main(String[] args) {
// Singleton
Singleton singleton = Singleton.obtenerInstancia();
singleton.mostrarMensaje();
// Factory
Vehiculo coche = VehiculoFactory.crearVehiculo("Coche");
coche.crear();
Vehiculo moto = VehiculoFactory.crearVehiculo("Moto");
moto.crear();
// Observer
Sujeto sujeto = new Sujeto();
Observador observador1 = new ObservadorConcreto("Observador 1");
Observador observador2 = new ObservadorConcreto("Observador 2");
sujeto.agregarObservador(observador1);
sujeto.agregarObservador(observador2);
sujeto.notificarObservadores("Estado cambiado.");
}
}
Salida:
Este es el patrón Singleton.
Coche creado.
Moto creada.
Observador 1 recibió el mensaje: Estado cambiado.
Observador 2 recibió el mensaje: Estado cambiado.
Este código muestra la implementación de los tres patrones de diseño en Java. El patrón **Singleton** asegura que solo exista una instancia de la clase, el patrón **Factory** crea objetos sin especificar la clase concreta, y el patrón **Observer** permite que los objetos observadores reaccionen a los cambios de estado del sujeto sin estar fuertemente acoplados entre sí.