Modo de adaptador modo de adaptador de clase, modo de adaptador de objeto

Visión general

Si viaja a países europeos, sus enchufes están en el extremo izquierdo, como se muestra en la imagen a continuación, que son estándares europeos.

Y el enchufe que usamos está en el extremo derecho de la imagen de abajo. Por lo tanto, nuestras computadoras portátiles y teléfonos móviles no se pueden cargar directamente a nivel local.

Entonces necesitamos un convertidor de enchufe, el primer lado del convertidor está enchufado en el enchufe local y el segundo lado es para que lo carguemos, de modo que nuestro enchufe se pueda usar localmente

Hay muchos ejemplos de esto en la vida, como cargadores de teléfonos móviles (que convierten 220v a 5v de voltaje), lectores de tarjetas, etc., de hecho, usan el modo adaptador.

definición:

Convierta la interfaz de una clase en otra interfaz que el cliente desee, para que las clases que no pueden trabajar juntas debido a la incompatibilidad de la interfaz puedan trabajar juntas.

El modo de adaptador se divide en modo de adaptador de clase y modo de adaptador de objeto,

El primero tiene un mayor grado de acoplamiento entre clases que el segundo, y requiere que los programadores comprendan la estructura interna de los componentes relacionados en la biblioteca de componentes existente, por lo que hay relativamente pocas aplicaciones.

5.2.2 Estructura

El modo de adaptador (Adaptador) incluye las siguientes funciones principales:

Interfaz de destino : la interfaz que espera el negocio del sistema actual, que puede ser una clase o interfaz abstracta.
Clase Adaptee : Es la interfaz del componente en la biblioteca de componentes existente a la que se accede y se adapta.
Clase de adaptador : es un convertidor que convierte la interfaz del adaptador en una interfaz de destino heredando o haciendo referencia al objeto del adaptador, lo que permite a los clientes acceder al adaptador en el formato de la interfaz de destino.

5.2.3 Modo de adaptador de clase

Método de implementación: defina una clase de adaptador para implementar la interfaz comercial del sistema actual y, al mismo tiempo, herede los componentes existentes en la biblioteca de componentes existente.

[Ejemplo] Lector de tarjetas

Una computadora existente solo puede leer la tarjeta SD, y si desea leer el contenido de la tarjeta TF, debe usar el modo adaptador. Cree un lector de tarjetas para leer el contenido de la tarjeta TF.

El diagrama de clases es el siguiente:

SDCard.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: SDCard
 * @Description: 目标接口
 * @Author: dym
 */
public interface SDCard {

    //从SD卡中读取数据
    String readSD();
    //往SD卡中写数据
    void writeSD(String msg);
}

SDCardImpl.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: SDCardImpl
 * @Description: 具体的SD卡
 * @Author: dym
 */
public class SDCardImpl implements SDCard {

    public String readSD() {
        String msg = "SDCard read msg ： hello word SD";
        return msg;
    }

    public void writeSD(String msg) {
        System.out.println("SDCard write msg ：" + msg);
    }
}

TFCard.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: TFCard
 * @Description: 适配者类的接口
 * @Author: dym
 */
public interface TFCard {

    //从TF卡中读取数据
    String readTF();
    //往TF卡中写数据
    void writeTF(String msg);
}

TFCardImpl.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: TFCardImpl
 * @Description: 适配者类
 * @Author: dym
 */
public class TFCardImpl implements TFCard {

    public String readTF() {
        String msg = "TFCard read msg ： hello word TFcard";
        return msg;
    }

    public void writeTF(String msg) {
        System.out.println("TFCard write msg :" + msg);
    }
}

SDAdapterTF.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: SDAdapterTF
 * @Description: 适配器类
 * @Author: dym
 */
public class SDAdapterTF extends TFCardImpl implements SDCard {

    public String readSD() {
        System.out.println("adapter read tf card");
        return readTF();
    }

    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        writeTF(msg);
    }
}

Computer.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: Computer
 * @Description: 计算机类
 * @Author: dym
 */
public class Computer {

    //从SD卡中读取数据
    public String readSD(SDCard sdCard) {
        if(sdCard == null) {
            throw  new NullPointerException("sd card is not null");
        }
        return sdCard.readSD();
    }
}

Client.java

package com.itheima.pattern.adapter.class_adapter;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: TODO(一句话描述该类的功能)
 * @Author: dym
 */
public class Client {
    public static void main(String[] args) {
        //创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中的数据
        String msg = computer.readSD(new SDCardImpl());
        System.out.println(msg);

        System.out.println("===============");
        //使用该电脑读取TF卡中的数据
        //定义适配器类
        String msg1 = computer.readSD(new SDAdapterTF());
        System.out.println(msg1);
    }
}

El patrón de adaptador de clase viola el principio de reutilización compuesta.

El adaptador de clase está disponible cuando la clase de cliente tiene una especificación de interfaz y viceversa.

Patrón de adaptador de objeto

Modo de implementación: el modo de adaptador de objetos se puede utilizar para introducir componentes que se han implementado en la biblioteca de componentes existente en la clase de adaptador, que también implementa la interfaz comercial del sistema actual.

[Ejemplo] Lector de tarjetas

Usamos el patrón de adaptador de objeto para reescribir la carcasa del lector de tarjetas. El diagrama de clases es el siguiente:

el código se muestra a continuación:

Para el código del patrón de adaptador de clase, solo necesitamos modificar la clase de adaptador (SDAdapterTF) y la clase de prueba.