设计模式--适配器模式

1. 问题的请提出：

   有一个系统需要和新的库搭配使用，但是这个库提供的接口与现有的系统不兼容，需要不改变现有系统的情况下解决这个 问题，就需要将新库的接口转化成当前系统需要的接口，这个时候就需要用到适配器模式。

2. 适配器模式：讲一个类的接口转化成另一个接口，让原本接口不兼容的类实现交互。

3. 在适配器模式中，需要定义一个包装类，包装不兼容接口的对象，这个包装类就是适配器，它所包装的对象就是适配者。

4. 适配器模式的UML图

   

5. 适配器分为对象适配器和类适配器，类适配器需要多重继承，在java中没办法实现。

6. 在类适配器中，由于适配器是适配者的子类，可以在适配器类中置换一些适配者的方法，使得适配者的灵活性更强。

7. 适配器模式的代码实现

   1. 创建一个实体类

      public class Car {
      
          private String name;
          private String color;
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public String getColor() {
              return color;
          }
      
          public void setColor(String color) {
              this.color = color;
          }
      }
      

   2. 创建实体类的工厂接口类

      public interface CarFactory {
          Car createCar();
      }
      

   3. 创建两个实体类的具体工厂类

      public class AudiCarFactory implements CarFactory {
          @Override
          public Car createCar() {
              Car car = new Car();
              car.setName("奥迪");
              car.setColor("红色");
              return car;
          }
      }
      
      public class BmwCarFactory  implements CarFactory  {
          @Override
          public Car createCar() {
              Car car = new Car();
              car.setName("宝马");
              car.setColor("红色");
              return car;
          }
      }
      

   4. 创建适配器的接口类

      public interface CarAdapter {
          Car changeColor(Car car, String color);
      }
      

   5. 类适配器的实现方式(只能适配一个类)

      /**
       * 通过继承AudiCarFactory，使CarAdapterImpl拥有了造车的能力，实现CarAdapter拥有了修改车颜色的能力
       *  类适配器，只能服务AudiCarFactory一个类
       */
      public class CarAdapterImpl extends AudiCarFactory implements CarAdapter{
      
          @Override
          public Car changeColor(Car car, String color) {
              car.setColor(color);
              return car;
          }
      }
      

   6. 类适配器的测试类

      public class Test {
          public static void main(String[] args) {
              //类适配器
              CarAdapterImpl carAdapter = new CarAdapterImpl();
              Car car = carAdapter.createCar();
              System.out.println(car.getColor()+car.getName());
      
              Car car1 = carAdapter.changeColor(car, "白色");
              System.out.println(car1.getColor()+car1.getName());
          }
      }
      

   7. 对象适配器的方式(可以适配多个类，只维护一个适配器)

      /**
       * 对象适配器
       */
      public class CarAdapterImpl2 implements CarAdapter {
      
          AudiCarFactory audi = new AudiCarFactory();
          BmwCarFactory bwm = new BmwCarFactory();
      
          public Car createCar(String factoryName){
              Car car = null;
              if ("audi".equals(factoryName)) {
                  car = audi.createCar();
              } else if("bmw".equals(factoryName)){
                  car = bwm.createCar();
              }
              return car;
          }
      
          @Override
          public Car changeColor(Car car, String color) {
              car.setColor(color);
              return car;
          }
      }
      

   8. 对象适配器的测试类

      public class Test {
          public static void main(String[] args) {
                  //对象适配器
              CarAdapterImpl2 carAdapterImpl2 = new CarAdapterImpl2();
              Car car = carAdapterImpl2.createCar("bmw");
              System.out.println(car.getColor()+car.getName());
      
              Car car1 = carAdapterImpl2.changeColor(car, "白色");
              System.out.println(car.getColor()+car.getName());
          }
      }
      

8. 适配器模式的优缺点

   1. 将目标类和适配这类解耦，通过使用适配器让不兼容的接口变得兼容，让客户从实现的接口解耦。
   2. 增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端来说是透明的，而且提高了适配者的复用。
   3. 灵活性和扩展性都非常好，在不修改原有代码的基础上增加新的适配器，符合"开闭原则"。

9. JDK中对适配器使用的地方