Instalación, Configuración Entorno
Metodología Programación

Patrones de Diseño en JAVA

En este ejercicio, explorarás y practicarás los **patrones de diseño** más comunes en Java. Aprenderás a implementar patrones como **Singleton**, **Factory** y **Observer**, que son fundamentales para mejorar la estructura, escalabilidad y mantenimiento de tus aplicaciones Java. Estos patrones son esenciales en la programación orientada a objetos, ya que ayudan a resolver problemas recurrentes de diseño de manera eficiente y reutilizable. A través de ejemplos prácticos y detallados, entenderás cómo aplicar estos patrones en situaciones del mundo real para crear soluciones más robustas y flexibles.

Tema

Algoritmos Avanzados y Optimizaciones

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:

  1. Implementa el patrón **Singleton** para una clase que debe tener solo una instancia en toda la aplicación.
  2. 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á.
  3. Implementa el patrón **Observer** para que un objeto (el sujeto) notifique automáticamente a los objetos observadores cuando su estado cambie.
  4. 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.


// 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í.


 Comparte este ejercicio JAVA