设计模式（结构型设计模式——适配器模式）

设计模式（结构型设计模式——适配器模式）

适配器模式

定义

1. 何谓适配器模式？适配器模式就是将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

2. 在适配器模式中，我们可以定义一个包装类，包装不兼容接口的对象，这个包装类就是适配器，它所包装的对象就是适配者。

3. 适配器提供给客户需要的接口，适配器的实现就是将客户的请求转换成对适配者的相应的接口的引用。也就是说，当客户调用适配器的方法时，适配器方法内部将调用适配者的方法，客户并不是直接访问适配者的，而是通过调用适配器方法访问适配者。因为适配器可以使互不兼容的类能够“合作愉快”。

模式结构

Target: 目标抽象类
Adapter: 适配器类
Adaptee: 适配者类
Client: 客户类

代码实现

Target 目标抽象类

public interface Car4s {
    Car changeColor(Car car, String color);
}
1
2
3

Adapter 适配器类

对象适配器（采用组合实现方式）

public class CarAdapter implements Car4s {
    CarFactory carFactory;
    public CarAdapter(CarFactory carFactory) {
        this.carFactory = carFactory;
    }
    public Car createCar(){
        return carFactory.createCar();
    }
    public Car changeColor(Car car, String color) {
        if(car == null) return null;
        car.setColor(color);
        return car;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Adaptee: 适配者类

工厂模式结合适配器使用

public interface CarFactory {
    Car createCar();
}
1
2
3

public class CarFactoryImplAUDI implements CarFactory {
    public Car createCar() {
        return new Car("白色", "奥迪");
    }
}
1
2
3
4
5

public class CarFactoryImplBMW implements CarFactory{
    public Car createCar() {
        return new Car("白色", "宝马");
    }
}
1
2
3
4
5

@Getter
@Setter
public class Car {
    private String color;//颜色
    private String band;//品牌

    public Car() {
    }

    public Car(String color, String band) {
        this.color = color;
        this.band = band;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试类

@Slf4j
public class Test {

    public static void main(String[] args){
        CarFactory bmwCar = new CarFactoryImplBMW();
        CarAdapter carAdapter = new CarAdapter(bmwCar);
        Car car = carAdapter.createCar();
        log.info("before change color : {} ", car);// Car(color=白色, band=宝马)
        carAdapter.changeColor(car, "红色");
        log.info("after change color : {} ", car);//Car(color=红色, band=宝马)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

优点

1. 将目标类和适配者类解耦，通过使用适配器让不兼容的接口变成了兼容，让客户从实现的接口解耦。

2. 加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用。

3. 灵活性和扩展性都非常好在不修改原有代码的基础上增加新的适配器类，符合《开闭原则》。