Java学习-设计模式-适配器模式

Java学习-设计模式-适配器模式

概述：

适配器模式（有时候也称包装样式或者包装）将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。

将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

使用范围： 1、系统需要使用现有的类，而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。 3、通过接口转换，将一个类插入另一个类系中。

优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。

缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

理解：

这个我查资料的得知起码有三种写法，但是思想差不多，就是我目前只有一个两孔的插座，但是现在我想给电源先是三脚的电视供电，我们就需要一个转接头把三脚转接成两脚，这个转接的过程就是适配器模式。

举例：

1. 第一种实现（类适配器）

package Practices.Mode.Adapter_Pattern;
// 1. 首先定义两脚插头和三脚插头的接口
public interface Three_plug_Inte {
    public void show_three_plug();
}
package Practices.Mode.Adapter_Pattern;
// 1. 首先定义两脚插头和三脚插头的接口
public interface Two_plug_Inte {
    public void show_two_plug();
}

package Practices.Mode.Adapter_Pattern;
// 2. 接着定义两脚插口的实现类
public class Two_Plug_Relized implements Two_plug_Inte {
    public void show_two_plug() {
        System.out.println("使用两脚插头接电");
    }
}

package Practices.Mode.Adapter_Pattern;
// 3. 然后定义适配器模式，将三脚插头转接到二脚插头上（就是调用二脚插头的方法）
public class Adapter_Relized extends Two_Plug_Relized implements Three_plug_Inte {
    public void show_three_plug() {
        show_two_plug();
    }
}

package Practices.Mode.Adapter_Pattern;
// 4. 然后测试
public class Adapter_main_test {
    public static void main(String[] args) {
        Adapter_Relized adapterRelized = new Adapter_Relized();
        adapterRelized.show_three_plug();
    }
}

2. 与第一种差不多，只不过这里调用二脚插头的对象来实现，不用继承二脚插头的实现类。（对象适配器）

package Practices.Mode.Adapter_Pattern;
// 1. 首先定义两脚插头和三脚插头的接口
public interface Three_plug_Inte {
    public void show_three_plug();
}
package Practices.Mode.Adapter_Pattern;
// 1. 首先定义两脚插头和三脚插头的接口
public interface Two_plug_Inte {
    public void show_two_plug();
}

package Practices.Mode.Adapter_Pattern;
// 2. 接着定义两脚插口的实现类
public class Two_Plug_Relized implements Two_plug_Inte {
    public void show_two_plug() {
        System.out.println("使用两脚插头接电");
    }
}

package Practices.Mode.Adapter_Pattern;
// 3. 第二种实现的方法：使用一个两脚的插头的对象来完成
public class Adapter_Relized_2 implements Three_plug_Inte {
    private Two_Plug_Relized twoPlugRelized;

    public Adapter_Relized_2(Two_Plug_Relized twoPlugRelized) {
        this.twoPlugRelized = twoPlugRelized;
    }

    public void show_three_plug() {
        twoPlugRelized.show_two_plug();
    }
}

package Practices.Mode.Adapter_Pattern;
// 4. 然后测试
public class Adapter_main_test {
    public static void main(String[] args) {
        Adapter_Relized_2 relized_2 = new Adapter_Relized_2(new Two_Plug_Relized());
        relized_2.show_three_plug();
    }
}

3. 还有的时候，我们想实现一个类的某几个方法，其余的方法都用不上，但是这个类方法很多，如果直接是这个对象，就会浪费资源，这时我们就可以使用适配器模式类解决这个问题。（接口适配器）

   短时间内，我还没有遇到过这种现象，可能我遇到了，但是我直接创建对象调用了，目前对这块的性能还没注意过…

// 1. 假设我们要用到接口A的 b 和 d 方法
public interface A {
    void a();
    void b();
    void c();
    void d();
    void e();
    void f();
}

// 2. 定义一个抽象类来实现这个接口，方便后面的适配的实现
public abstract class Adapter implements A {
    public void a(){}
    public void b(){}
    public void c(){}
    public void d(){}
    public void e(){}
    public void f(){}
}

// 3. 实现适配
public class Ashili extends Adapter {
    public void b(){
        System.out.println("调用B方法");
    }
    public void d(){
        System.out.println("调用D方法");
    }
}

// 4. 测试
public class Clienter {
    public static void main(String[] args) {
        A a = new Ashili();
        a.a();
        a.d();
    }
}