1. Introducción

En la vida, muchas cosas tienen cambios en múltiples dimensiones, como los automóviles, hay cambios en la dimensión del color, cambios en la dimensión del modelo y cambios en la dimensión de la marca. Cómo diseñar la forma más sencilla de representar los cambios en las diferentes dimensiones de el coche ya? Se puede utilizar el modo puente.

2 Definiciones

El patrón de puente separa la abstracción de la implementación para que pueda variar de forma independiente. Se implementa con una relación de composición en lugar de una relación de herencia, lo que reduce el acoplamiento entre las dos dimensiones variables de abstracción e implementación. El modo puente es cambiar la relación de herencia a la relación de composición.

Personalmente, entiendo que esta definición es relativamente abstracta (no la entendí cuando la leí por primera vez de todos modos). Para continuar con el ejemplo de la introducción, un automóvil es un producto muy abstracto, y el color y el modelo son una realización de el automóvil Estamos diseñando un Cuando creamos un automóvil, tomamos el modelo y el color realizados y lo colocamos directamente en el automóvil para formar un automóvil.

Como otro ejemplo, si tiene 3 pinceles con puntas diferentes y 12 tipos de pintura, puede dibujar 3 * 12 tipos de líneas y los crayones necesitan 36 para lograr el mismo efecto. Los pinceles en el frente son de modo puente (diferentes tipos de bolígrafos son una dimensión de cambio, y las pinturas de diferentes colores son una dimensión de cambio, y las dos dimensiones no se afectan entre sí), mientras que los pinceles en la parte posterior son de herencia múltiple. (el tipo de bolígrafo y el pigmento afectan al crayón juntos). Después de entenderlo, lo abstraeremos en una descripción de código: la clase pluma es una clase abstracta con un método dibujar(). Si queremos usar un pincel, debemos poner un color y luego ejecutar el método de dibujo para dibujar este color.

3 La estructura es la realización

El modo puente incluye principalmente las siguientes funciones:

1. Función de abstracción: define una clase abstracta y contiene una referencia a un objeto implementado. Los coches, por ejemplo, contienen una referencia al color y al modelo.

2. Rol de implementador: define la interfaz del rol implementado, que es llamado por el rol abstracto extendido. Implementar un color.

3. Rol de Implementador Concreto: Dar la implementación concreta de la interfaz del rol implementado. Elige entre rojo, amarillo, blanco.

4. Función de abstracción extendida (abstracción refinada): es una subclase de la función abstraída, implementa los métodos comerciales en la clase principal y llama a los métodos comerciales en la función implementada a través de la relación de composición. coche especifico.

Imagen de la cita 2

4 Ventajas y desventajas

Las ventajas del modo Bridge son:

Separación de abstracción e implementación, fuerte escalabilidad
De acuerdo con el principio abierto-cerrado
Cumplir con el principio de síntesis y reutilización.

debilidad es:

Dado que la relación de agregación se establece en la capa de abstracción, los desarrolladores deben diseñar y programar para la abstracción y pueden identificar correctamente las dos dimensiones que cambian de forma independiente en el sistema, lo que aumenta la dificultad de comprender y diseñar el sistema.

5 escenarios de uso

Un caso de uso común para el patrón de puente es reemplazar la herencia. Sabemos que la herencia tiene muchas ventajas, como la abstracción, la encapsulación, el polimorfismo, etc., la clase principal encapsula las cosas en común y las subclases implementan características. La herencia puede realizar muy bien la función de reutilización de código (encapsulación), pero esto también es una gran desventaja de la herencia.

El modo puente es generalmente adecuado para los siguientes escenarios.

Cuando una clase tiene dos dimensiones que varían de forma independiente, y ambas dimensiones deben ampliarse.
Cuando un sistema no quiere usar la herencia o cuando el número de clases del sistema aumenta drásticamente debido a la herencia de varios niveles.
Cuando un sistema necesita agregar más flexibilidad entre los roles abstractos y concretos de los componentes.

6 ejemplos de código

Siguiendo con el ejemplo del coche, se separa el color y el modelo del coche.

6.1 Fábrica de colores ColorFactory

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 14:55
 **/
public class ColorFactory {
    @AllArgsConstructor
    public enum Color {
        YELLOW(1, "yellow"),
        RED(2, "red"),
        WHITE(3, "white"),
        BLACK(4, "black"),
        GREEN(5, "green");

        final int value;
        final String desc;

    }

    public String getColor(int code){
        String color = "";
        switch (code){
            case 1:
                color = Color.YELLOW.desc;
                break;
            case 2:
                color = Color.RED.desc;
                break;
            case 3:
                color = Color.WHITE.desc;
                break;
            case 4:
                color = Color.BLACK.desc;
                break;
            case 5:
                color = Color.GREEN.desc;
                break;
        }
        return color;
    }
}

6.2 Obtener el color concreto ConcreteColor

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 14:30
 **/
public class ConcreteColor {

    private ColorFactory colorFactory = new ColorFactory();

    public String printColor(int code) {
        return colorFactory.getColor(code);
    }
}

6.3 Fábrica modelo

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 14:55
 **/
public class ModelFactory {
    @AllArgsConstructor
    public enum Model {
        SUV(1, "越野车型"),
        SEDAN(2, "轿车");

        final int value;
        final String desc;

    }

    public String getModel(int code){
        String model = "";
        switch (code){
            case 1:
                model = Model.SUV.desc;
                break;
            case 2:
                model = Model.SEDAN.desc;
        }
        return model;
    }
}

6.4 Obtener modelo concreto

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 14:30
 **/
public class ConcreteModel {

    private ModelFactory modelFactory = new ModelFactory();

    public String printColor(int code) {
        return modelFactory.getModel(code);
    }
}

6.5 Abstracción de automóviles

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 14:26
 **/
public interface Car {

    /**
     * 选择颜色
     * @param code 颜色编号
     */
    void setColor(int code);

    /**
     * 选择车型
     * @param code 车型编号
     */
    void setModel(int code);
}

6.6 tesla tesla

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 15:05
 **/
public class Tesla implements Car{
    private ConcreteColor color = new ConcreteColor();
    private ModelFactory modelFactory = new ModelFactory();

    @Override
    public void setColor(int code) {
        System.out.println(color.printColor(code));
    }

    @Override
    public void setModel(int code) {
        System.out.println(modelFactory.getModel(code));
    }
}

6.7 Función principal

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-11-01 14:24
 **/
public class MainClass {
    public static void main(String[] args) {
        Tesla teslaFactory = new Tesla();
        System.out.println("配置颜色与车型：");
        teslaFactory.setColor(3);
        teslaFactory.setModel(2);
    }
}

6.8 Resultado de la ejecución

7 citas

1. "Patrones de diseño Dahua"

2. Explicación detallada del modo puente (modo puente)

8 código fuente

https://github.com/airhonor/design-pattern-learning/tree/main/src/com/hz/design/pattern/bridge

Patrones de diseño --- Patrones de puente