El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Bridge

Siguiente ►
►

Introducción

El patrón de diseño Bridge es un patrón estructural que separa la abstracción de su implementación, permitiendo que ambas evolucionen de manera independiente. Este patrón es útil cuando se desea evitar un fuerte acoplamiento entre la abstracción y la implementación, facilitando la extensión y modificación de ambas partes sin afectar a la otra.

Objetivos del Patrón Bridge

  • Desacoplar una abstracción de su implementación para que ambas puedan variar de manera independiente.
  • Facilitar la extensión y modificación de las clases sin afectar a otras partes del sistema.
  • Reducir la complejidad de las jerarquías de clases.

Estructura del Patrón Bridge

El patrón Bridge se compone de los siguientes elementos:

  1. Abstraction (Abstracción): Define la interfaz de alto nivel y mantiene una referencia a un objeto de tipo Implementor.
  2. RefinedAbstraction (Abstracción Refinada): Extiende la interfaz definida por Abstraction.
  3. Implementor (Implementador): Define la interfaz para las implementaciones de la abstracción.
  4. ConcreteImplementor (Implementador Concreto): Implementa la interfaz de Implementor y define su comportamiento específico.

Diagrama UML

Abstraction
+ operation(): void
+ implementor: Implementor

RefinedAbstraction
+ operation(): void

Implementor
+ operationImp(): void

ConcreteImplementorA
+ operationImp(): void

ConcreteImplementorB
+ operationImp(): void

Ejemplo Práctico

Consideremos un ejemplo donde tenemos diferentes formas (Shape) y diferentes colores (Color). Queremos que las formas puedan ser de cualquier color sin crear una jerarquía de clases compleja.

Código de Ejemplo

Paso 1: Definir la Abstracción y la Implementación

// Implementor
interface Color {
    void applyColor();
}

// ConcreteImplementorA
class RedColor implements Color {
    public void applyColor() {
        System.out.println("Applying red color");
    }
}

// ConcreteImplementorB
class BlueColor implements Color {
    public void applyColor() {
        System.out.println("Applying blue color");
    }
}

// Abstraction
abstract class Shape {
    protected Color color;

    protected Shape(Color color) {
        this.color = color;
    }

    abstract void draw();
}

// RefinedAbstraction
class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }

    public void draw() {
        System.out.print("Drawing Circle with ");
        color.applyColor();
    }
}

// RefinedAbstraction
class Square extends Shape {
    public Square(Color color) {
        super(color);
    }

    public void draw() {
        System.out.print("Drawing Square with ");
        color.applyColor();
    }
}

Paso 2: Uso del Patrón Bridge

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new RedColor());
        Shape blueSquare = new Square(new BlueColor());

        redCircle.draw();  // Output: Drawing Circle with Applying red color
        blueSquare.draw(); // Output: Drawing Square with Applying blue color
    }
}

Explicación del Código

  1. Color Interface (Implementor): Define la interfaz Color con el método applyColor().
  2. RedColor y BlueColor (ConcreteImplementors): Implementan la interfaz Color y definen el comportamiento específico de applyColor().
  3. Shape (Abstraction): Define la clase abstracta Shape que contiene una referencia a un objeto Color.
  4. Circle y Square (RefinedAbstractions): Extienden la clase Shape y definen el método draw() que utiliza el método applyColor() de Color.

Ejercicio Práctico

Ejercicio 1: Implementar una Nueva Forma y Color

  1. Objetivo: Añadir una nueva forma Rectangle y un nuevo color GreenColor.
  2. Instrucciones:
    • Crear la clase GreenColor que implemente la interfaz Color.
    • Crear la clase Rectangle que extienda la clase Shape.
    • Modificar el método main para incluir la nueva forma y color.

Solución

Paso 1: Crear la Clase GreenColor

class GreenColor implements Color {
    public void applyColor() {
        System.out.println("Applying green color");
    }
}

Paso 2: Crear la Clase Rectangle

class Rectangle extends Shape {
    public Rectangle(Color color) {
        super(color);
    }

    public void draw() {
        System.out.print("Drawing Rectangle with ");
        color.applyColor();
    }
}

Paso 3: Modificar el Método main

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new RedColor());
        Shape blueSquare = new Square(new BlueColor());
        Shape greenRectangle = new Rectangle(new GreenColor());

        redCircle.draw();      // Output: Drawing Circle with Applying red color
        blueSquare.draw();     // Output: Drawing Square with Applying blue color
        greenRectangle.draw(); // Output: Drawing Rectangle with Applying green color
    }
}

Retroalimentación y Errores Comunes

  • Error Común: No desacoplar correctamente la abstracción de la implementación, creando una jerarquía de clases compleja.
    • Solución: Asegurarse de que la abstracción y la implementación puedan variar de manera independiente.
  • Error Común: No utilizar correctamente la referencia a Color en la clase Shape.
    • Solución: Asegurarse de que la clase Shape utilice la referencia a Color en sus métodos.

Conclusión

El patrón Bridge es una poderosa herramienta para desacoplar la abstracción de su implementación, permitiendo que ambas evolucionen de manera independiente. Este patrón es especialmente útil en sistemas complejos donde se requiere una alta flexibilidad y extensibilidad. Al dominar el patrón Bridge, los desarrolladores pueden crear sistemas más mantenibles y escalables.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados