Se refiere al patrón de diseño de Java del círculo de dibujo cuadrado: patrón de adaptador

Escenarios de aplicación

Cuando la interfaz en la que confía el usuario no coincide con la interfaz del proveedor, agregue una capa de adaptación, sin modificar el código en ambos extremos del
ventilador utilizado en la vida, asumiendo que el enchufe es de dos orificios, pero el enchufe está encendido. la pared de nuestra casa solo tiene tres agujeros Sí, necesita un adaptador en este momento. Este adaptador es un enchufe comprado en el exterior. Tome el escenario anterior como ejemplo, escriba un ejemplo:

Toma de tres orificios:

public class ThreeOutlet {
    
    
    /** 三孔插座 */
    public void link(String positive, String negative, String earthWire) {
    
    
        System.out.println(String.format("多一根地线，保证安全用电：%s %s %s", positive, negative, earthWire));
    }
}

Necesitamos iniciar y cerrar la interfaz del ventilador eléctrico:

public interface TwoOutlet {
    
    
    /** 启动 */
    void power(String positive, String negative);

    /** 关闭 */
    void shutDown();
}

Enchufe adaptador, comprado en el exterior, puede usar dos orificios o tres orificios:

public class Adapter1 extends ThreeOutlet implements TwoOutlet {
    
    

    private String ew = "多一根地线";	// 私有内置地线

    @Override
    public void power(String positive, String negative) {
    
    
        link(positive, negative, ew);
    }

    @Override
    public void shutDown() {
    
    
        System.out.println("拔掉插头");
    }

    @Override
    public void link(String positive, String negative, String earthWire) {
    
    
        super.link(positive, negative, earthWire);
    }
}

Categoría de ventilador eléctrico:

public class Fanner {
    
    

    private TwoOutlet outlet;

    public void run() {
    
    
        outlet.power("1", "0");
        System.out.println("获得动力");
        System.out.println("风扇运转");
        outlet.shutDown();
        System.out.println("关闭电力，风扇停止运转");
    }

    public void setOutlet(TwoOutlet outlet) {
    
    
        this.outlet = outlet;
    }
}

Categoría de prueba:

public class Test {
    
    

    public static void main(String[] args) {
    
    
        Fanner fanner = new Fanner();
        Adapter1 adapter1 = new Adapter1();
        fanner.setOutlet(adapter1);
        fanner.run();
    }
}

Diagrama de clase:

Modo adaptador

definición

Convierta la interfaz de una clase en otra interfaz que el cliente espera, de modo que dos clases que no pueden funcionar juntas debido a una discrepancia de interfaz puedan trabajar juntas

intención

Convierta la interfaz de una clase en otra interfaz que desee el cliente. El modo de adaptador permite que las clases que no pueden trabajar juntas debido a interfaces incompatibles trabajen juntas

Principalmente resuelve el problema

Para resolver el problema en el sistema de software, a menudo es necesario colocar algunos "objetos existentes" en el nuevo entorno, y los objetos existentes no pueden satisfacer la interfaz requerida por el nuevo entorno.

Cuándo usar

1. El sistema necesita usar clases existentes y tales interfaces no satisfacen las necesidades del sistema.
2. Quiero crear una clase reutilizable para trabajar con algunas clases que no están muy relacionadas entre sí, incluidas algunas clases que pueden introducirse en el futuro. Estas clases fuente no necesariamente tienen una interfaz coherente
3. Insertar una clase en otro sistema de clases a través de la conversión de interfaz

Pros y contras

ventaja:

1. Puede hacer que dos clases no relacionadas se ejecuten juntas
2. Reutilización mejorada de clases.
3. Mayor transparencia de clase
4. Buena flexibilidad

Desventajas:

1. El uso excesivo de adaptadores hará que el sistema sea muy complicado y difícil de entender en su conjunto.
2. Dado que JAVA hereda como máximo una clase, solo se puede adaptar a una clase de adaptador, y la clase de destino debe ser una clase abstracta

Diagrama de clases:

los roles involucrados:

1. Rol de destino: esta es la interfaz esperada, el destino puede ser una clase concreta o abstracta
2. Rol de fuente (adaptado): interfaces existentes que necesitan ser adaptadas
3. Rol de adaptador: la clase de adaptador es el núcleo de este modelo; el adaptador transforma la interfaz de origen en la interfaz de destino; obviamente, este rol no puede ser una interfaz, pero debe ser una clase concreta

La estructura del patrón de adaptador de la clase:
Interfaz de destino:

public interface Target {
    
    

    /** 源类也有的方法 */
    void sampleOperation1();

    /** 源类没有的方法 */
    void sampleOperation2();
}

Rol de fuente adaptado:

public class Adaptee {
    
    

    public void sampleOperation1(){
    
    
        System.out.println("源类也有的方法");
    }
}

Rol del adaptador:

public class Adapter extends Adaptee implements Target {
    
    

    /** 源类和目标类都有的方法 */
    @Override
    public void sampleOperation1() {
    
    
        super.sampleOperation1();
    }

    /** 源类没有的方法，期望有这个方法 */
    @Override
    public void sampleOperation2() {
    
    

    }
}

La estructura del patrón de adaptador del objeto:
Interfaz de destino:

public interface Target {
    
    

    /** 源类也有的方法 */
    void sampleOperation1();

    /** 源类没有的方法 */
    void sampleOperation2();
}

Rol de fuente adaptado:

public class Adaptee {
    
    

    public void sampleOperation1(){
    
    
        System.out.println("源类也有的方法");
    }
}

Rol del adaptador:

public class Adapter implements Target {
    
    
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
    
    
        this.adaptee = adaptee;
    }

    /** 源类和目标类都有的方法 */
    @Override
    public void sampleOperation1() {
    
    
        this.adaptee.sampleOperation1();
    }

    /** 源类没有的方法，期望有这个方法 */
    @Override
    public void sampleOperation2() {
    
    
        System.out.println("适配一个方法");
    }
}

Cabe señalar que el adaptador no se utiliza al inicio del diseño, sino para solucionar los problemas en el proyecto existente.

Se refiere al ciervo como un caballo VS se refiere al cuadrado como un círculo

Refiérase al ciervo como el caballo

Deberías haber escuchado la historia de Zhao Gao señalando al ciervo como un caballo. Aquí hay un pequeño ejemplo en el modo adaptador:

Lo que se necesita ahora es un caballo:

public interface NeedHorse {
    
    

    /** 需要一匹马 */
    void needHorse();
}

Pero hay un ciervo:

public class DeerAdaptee {
    
    

    public void deer() {
    
    
        System.out.println("我是一头鹿，有人要指鹿为马！");
    }
}

Para adaptar un ciervo a un caballo y referirse a un ciervo como un caballo:

public class DeerChangeAdapter implements NeedHorse {
    
    

    private DeerAdaptee deerAdaptee;

    public DeerChangeAdapter(DeerAdaptee deerAdaptee) {
    
    
        this.deerAdaptee = deerAdaptee;
        this.deerAdaptee.deer();
    }

    public void deer() {
    
    
        System.out.println("我是一头鹿，有人要指鹿为马！");
    }

    @Override
    public void needHorse() {
    
    
        System.out.println("我是一匹马(其实我的真实身份是一只鹿)");
    }
}

Categoría de prueba:

public class Test {
    
    

    public static void main(String[] args) {
    
    
        System.out.println("这个是鹿还是马？");
        DeerAdaptee adaptee = new DeerAdaptee();
        DeerChangeAdapter adapter = new DeerChangeAdapter(adaptee);
        adapter.needHorse();
    }
}

Diagrama de clase:

Se refiere al círculo

En la antigüedad, un ciervo era un caballo y el dedo existente era un círculo. Bien:
lo que necesitamos es una pelota:

public interface BallIF {
    
    

    /** 计算体积 */
    Double calculateVolume();

    /** 计算面积 */
    Double calculateAcreage();

    /** 半径取值 */
    Double getRadius();

    /** 半径赋值 */
    Double setRadius(double radius);
}

Ahora hay un cubo:

public class Cube {
    
    

    private Double width;

    public Cube(Double width) {
    
    
        this.width = width;
    }

    /** 计算体积 */
    public Double calculateVolume() {
    
    
        return width * width * width;
    }

    /** 计算面积 */
    public Double calculateAcreage() {
    
    
        return width * width;
    }

    /** 长度取值 */
    public Double getWidth() {
    
    
        return width;
    }

    /** 长度赋值 */
    public void setWidth(Double width) {
    
    
        this.width = width;
    }
}

Adapte el adaptador, el cuadrado se refiere a un círculo:

public class MagicFinger implements BallIF {
    
    

    private double radius = 0;

    private static double PI = 3.14d;

    private Cube adaptee;

    public MagicFinger(Cube adaptee) {
    
    
        super();
        this.adaptee = adaptee;
        radius = this.adaptee.getWidth();
    }

    @Override
    public Double calculateVolume() {
    
    
        return  (4.0d/3.0d) * PI * (radius * radius);
    }

    @Override
    public Double calculateAcreage() {
    
    
        return PI * 4.0d * (radius * radius * radius);
    }

    @Override
    public Double getRadius() {
    
    
        return radius;
    }

    @Override
    public Double setRadius(double radius) {
    
    
        return this.radius = radius;
    }
}

tener una prueba:

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Cube cube = new Cube(2.0);
        MagicFinger finger = new MagicFinger(cube);
        System.out.println("半径：" + finger.getRadius());
        System.out.println("体积：" + finger.calculateVolume());
        System.out.println("面积：" + finger.calculateAcreage());
    }
}

Diagrama de clases:

si desea motivar a modificar la interfaz de un sistema operativo normal, debe considerar usar el modo adaptador en este momento