Los 3 Tipos de Patrones de Diseño Java: Guía Completa con Ejemplos

En el mundo del desarrollo de software, los patrones de diseño son herramientas esenciales para crear código limpio, eficiente y reutilizable. Estos patrones ofrecen soluciones probadas a problemas recurrentes en la ingeniería de software, permitiendo a los desarrolladores evitar reinventar la rueda y centrarse en la lógica específica de su aplicación.

Una Mirada a los Tipos de Patrones de Diseño

Los patrones de diseño se clasifican en tres categorías principales: creacionales, estructurales y de comportamiento. Cada categoría aborda un aspecto diferente del desarrollo de software, ofreciendo soluciones para problemas específicos:

• Patrones de diseño creacionales: se enfocan en la creación de objetos. Estos patrones abstraen el proceso de creación de objetos, permitiéndonos controlar cómo se instancian y se configuran.
• Patrones de diseño estructurales: se centran en la estructura y composición de las clases y objetos. Estos patrones ayudan a crear relaciones flexibles y reutilizables entre diferentes elementos del sistema.
• Patrones de diseño de comportamiento: se enfocan en la interacción y la comunicación entre objetos. Estos patrones ayudan a definir cómo los objetos se comunican entre sí y cómo se ejecutan los procesos.

Patrones de Diseño Creacionales: Controlando la Creación de Objetos

Los patrones de diseño creacionales son los responsables de controlar la instanciación de objetos, proporcionando flexibilidad y control sobre el proceso de creación. Estos patrones permiten que el código sea más flexible y reutilizable, permitiendo que las clases se instancien de diferentes formas según las necesidades de la aplicación.

Patrón Singleton: Un Objeto Único y Universal

El patrón Singleton es uno de los patrones de diseño más conocidos. Su objetivo principal es asegurar que solo exista una instancia de una clase. Este patrón es ideal para recursos compartidos como configuraciones, bases de datos o conexiones de red.

Implementación del Patrón Singleton:

«`java
public class Singleton {
private static Singleton instance;

private Singleton() {
    // Constructor privado para evitar instancias directas
}

public static Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

}
«`

Ejemplo de Uso:

java
// Obtener la única instancia del Singleton
Singleton singleton = Singleton.getInstance();
// Hacer uso de la instancia
singleton.someMethod();


Variaciones del Patrón Singleton:

• Singleton Ansioso: La instancia del Singleton se crea al cargar la clase, independientemente de si se necesita o no.
• Singleton Perezoso: La instancia se crea solo cuando se llama al método getInstance().
• Singleton Seguro para Subprocesos: Protege la instancia de accesos simultáneos desde diferentes hilos, garantizando que solo se cree una instancia.

Patrón Factory Method: Creación de Objetos Personalizada

El patrón Factory Method define una interfaz para crear objetos, pero deja la decisión de qué tipo de objeto se crea a las subclases. Este patrón es ideal para sistemas que necesitan crear diferentes tipos de objetos de manera flexible.

Implementación del Patrón Factory Method:

«`java
public interface Shape {
void draw();
}

public class Circle implements Shape {
@Override
public void draw() {
System.out.println(«Dibujando un círculo»);
}
}

public class Square implements Shape {
@Override
public void draw() {
System.out.println(«Dibujando un cuadrado»);
}
}

public abstract class ShapeFactory {
public abstract Shape createShape();
}

public class CircleFactory extends ShapeFactory {
@Override
public Shape createShape() {
return new Circle();
}
}

public class SquareFactory extends ShapeFactory {
@Override
public Shape createShape() {
return new Square();
}
}
«`

Ejemplo de Uso:

«`java
ShapeFactory circleFactory = new CircleFactory();
Shape circle = circleFactory.createShape();
circle.draw(); // Dibujar un círculo

ShapeFactory squareFactory = new SquareFactory();
Shape square = squareFactory.createShape();
square.draw(); // Dibujar un cuadrado
«`

Patrón Abstract Factory: Fabricando Familias de Objetos

El patrón Abstract Factory proporciona una interfaz para crear familias de objetos relacionados. Este patrón es ideal para sistemas que necesitan trabajar con diferentes sets de objetos relacionados, como interfaces de usuario o configuraciones específicas.

Implementación del Patrón Abstract Factory:

«`java
public interface Button {
void render();
}

public interface Checkbox {
void render();
}

public interface GUI {
Button createButton();
Checkbox createCheckbox();
}

public class WindowsGUI implements GUI {
@Override
public Button createButton() {
return new WindowsButton();
}

@Override
public Checkbox createCheckbox() {
    return new WindowsCheckbox();
}

}

public class MacGUI implements GUI {
@Override
public Button createButton() {
return new MacButton();
}

@Override
public Checkbox createCheckbox() {
    return new MacCheckbox();
}

}

// Clases concretas para Button y Checkbox
public class WindowsButton implements Button {
@Override
public void render() {
System.out.println(«Renderizando botón de Windows»);
}
}

public class WindowsCheckbox implements Checkbox {
@Override
public void render() {
System.out.println(«Renderizando casilla de verificación de Windows»);
}
}

public class MacButton implements Button {
@Override
public void render() {
System.out.println(«Renderizando botón de Mac»);
}
}

public class MacCheckbox implements Checkbox {
@Override
public void render() {
System.out.println(«Renderizando casilla de verificación de Mac»);
}
}
«`

Ejemplo de Uso:

«`java
GUI windowsGUI = new WindowsGUI();
Button windowsButton = windowsGUI.createButton();
windowsButton.render(); // Renderizar botón de Windows

GUI macGUI = new MacGUI();
Checkbox macCheckbox = macGUI.createCheckbox();
macCheckbox.render(); // Renderizar casilla de verificación de Mac
«`

Patrones de Diseño Estructurales: Construyendo Estructuras Flexibles

Los patrones de diseño estructurales se enfocan en la estructura y composición de las clases y objetos. Estos patrones ayudan a construir estructuras flexibles y reutilizables para el código, permitiendo que los componentes del sistema se combinen de diferentes formas.

Patrón Decorador: Ampliando la Funcionalidad de los Objetos

El patrón Decorador permite añadir funcionalidades a un objeto en tiempo de ejecución sin modificar su clase base. Este patrón es ideal para sistemas que necesitan agregar comportamientos específicos a objetos sin alterar su estructura original.

Implementación del Patrón Decorador:

«`java
public interface Beverage {
double cost();
String getDescription();
}

public class Espresso implements Beverage {
@Override
public double cost() {
return 1.99;
}

@Override
public String getDescription() {
    return "Espresso";
}

}

public abstract class CondimentDecorator implements Beverage {
protected Beverage beverage;

public CondimentDecorator(Beverage beverage) {
    this.beverage = beverage;
}

@Override
public abstract double cost();

@Override
public abstract String getDescription();

}

public class Milk extends CondimentDecorator {
public Milk(Beverage beverage) {
super(beverage);
}

@Override
public double cost() {
    return beverage.cost() + 0.10;
}

@Override
public String getDescription() {
    return beverage.getDescription() + ", Leche";
}

}

public class Mocha extends CondimentDecorator {
public Mocha(Beverage beverage) {
super(beverage);
}

@Override
public double cost() {
    return beverage.cost() + 0.20;
}

@Override
public String getDescription() {
    return beverage.getDescription() + ", Mocha";
}

}
«`

Ejemplo de Uso:

«`java
Beverage espresso = new Espresso();
System.out.println(espresso.getDescription() + » $» + espresso.cost());

Beverage espressoWithMilk = new Milk(new Espresso());
System.out.println(espressoWithMilk.getDescription() + » $» + espressoWithMilk.cost());

Beverage espressoWithMocha = new Mocha(new Espresso());
System.out.println(espressoWithMocha.getDescription() + » $» + espressoWithMocha.cost());

Beverage espressoWithMilkAndMocha = new Mocha(new Milk(new Espresso()));
System.out.println(espressoWithMilkAndMocha.getDescription() + » $» + espressoWithMilkAndMocha.cost());
«`

Patrón Adapter: Adaptando Interfaces Incompatibles

El patrón Adapter permite que dos clases incompatibles trabajen juntas. Este patrón es ideal para sistemas que necesitan integrar clases con interfaces diferentes.

Implementación del Patrón Adapter:

«`java
public interface Target {
void request();
}

public class Adaptee {
public void specificRequest() {
System.out.println(«Ejecutando la solicitud específica»);
}
}

public class Adapter implements Target {
private Adaptee adaptee;

public Adapter(Adaptee adaptee) {
    this.adaptee = adaptee;
}

@Override
public void request() {
    adaptee.specificRequest();
}

}
«`

Ejemplo de Uso:

java
Adaptee adaptee = new Adaptee();
Adapter adapter = new Adapter(adaptee);
adapter.request(); // Ejecutar la solicitud específica a través del adapter


Patrones de Diseño de Comportamiento: Optimizando la Interacción Entre Objetos

Los patrones de diseño de comportamiento se enfocan en la interacción y la comunicación entre objetos. Estos patrones ayudan a definir cómo los objetos se comunican entre sí y cómo se ejecutan los procesos, mejorando la flexibilidad y la reutilización del código.

Patrón Comando: Desacoplando la Invocación de la Ejecución

El patrón Comando busca reducir el acoplamiento entre las partes involucradas, desacoplando la invocación de una acción de su ejecución real. Este patrón es ideal para sistemas que necesitan enviar solicitudes a otros objetos sin conocer los detalles de la implementación.

Implementación del Patrón Comando:

«`java
public interface Command {
void execute();
}

public class OrderPizza implements Command {
private String pizzaType;

public OrderPizza(String pizzaType) {
    this.pizzaType = pizzaType;
}

@Override
public void execute() {
    System.out.println("Ordenando una pizza " + pizzaType);
}

}

public class Waiter {
private Command command;

public Waiter(Command command) {
    this.command = command;
}

public void takeOrder() {
    command.execute();
}

}
«`

Ejemplo de Uso:

java
Command orderPizza = new OrderPizza("Pepperoni");
Waiter waiter = new Waiter(orderPizza);
waiter.takeOrder(); // Ordenar la pizza Pepperoni


Conclusión: Patrones de Diseño como Herramientas de Desarrollo

Los patrones de diseño son herramientas esenciales para cualquier desarrollador de software, ofreciendo soluciones probadas y reutilizables para problemas comunes. Estos patrones permiten crear código limpio, eficiente y flexible, mejorando la legibilidad y la reutilización del código. Al comprender los tipos de patrones de diseño, como creacionales, estructurales y de comportamiento, los desarrolladores pueden tomar decisiones informadas sobre cómo diseñar y desarrollar sus sistemas, mejorando la calidad y la eficiencia del código.