设计模式之适配器模式详解

小灰灰 2022-06-06 10:10 156阅读 0赞

**适配器模式的官方定义**：将一个类的接口转换为客户期望的另外的一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。  
**目的**：消除由于接口不匹配造成的类的不兼容问题。  
**分类**：有三类，主要是类的适配器模式，对象的适配器模式，接口的适配器模式。

**1.类的适配器模式**  
![类图][SouthEast]  
**核心思想：**有一个源目标类，有一个method1()方法，目标接口是Targetable接口，通过适配器Adapter类，将Source的功能扩展到目标接口中。

**1.类的适配器模式：**

首先是我们的源目标类：

public class Source {  
    
        public void method1() {  
            System.out.println("this is original method!");  
        }  
    }

然后是我们的目标接口：

public interface Targetable {  
    
        /* 与原类中的方法相同 */  
        public void method1();  
    
        /* 新类的方法 */  
        public void method2();  
    }

最后就是我们的适配器：

public class Adapter extends Source implements Targetable {   
    
        @Override  
        public void method2() {  
            System.out.println("this is the targetable method!");  
        }  
    }

Adapter 继承源目标类，并且实现目标接口，下面是测试代码：

public class AdapterTest {  
    
        public static void main(String[] args) {  
            Targetable target = new Adapter();  
            target.method1();  
            target.method2();  
        }  
    }

**输出：**  
this is original method!  
this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能，就解决了由于接口不兼容而导致类不能一起工作的问题。

**2.对象的适配器模式：**

对象的适配器模式的核心思想跟类的适配器模式差不多一样，区别在于此时Adapter不继承Source类，而是拥有Source一个实例。

**核心类图：**  
![这里写图片描述][SouthEast 1]

我们只是需要修改一下Adapter的代码即可：

public class Adapter implements Targetable {   
        private Source source;  
    
        public Wrapper(Source source){  
            super();  
            this.source = source;  
        } 
        @Override  
        public void method2() {  
            System.out.println("this is the targetable method!");  
        }
        @Override  
        public void method1() {  
            source.method1();  
        }   
    }

**测试代码：**

public class AdapterTest {  
        public static void main(String[] args) {  
            Source source = new Source();  
            Targetable target = new Wrapper(source);  
    
            target.method1();  
            target.method2();  
        }  
    }

**3.接口的适配器模式**  
首先我们先来看这么一个问题，就是在一个接口中我们写了很多个方法，如果我们要写该接口的实现类的时候又必须实现该接口的所有方法，但是有一些方法又不是我们所需要的，这个时候去实现完所有的方法实在是太浪费了。  
这是接口的适配器模式就有很大的作用了，所谓的接口适配器模式，我们可以借助一个抽象类实现该接口，我们不去跟源接口打交道，而是用一个类去继承这个抽象类，只需要重写我们需要的方法即可。  
![这里写图片描述][SouthEast 2]

源接口：

public interface Sourceable {  
    
            public void method1();  
            public void method2();  
        }  
    }

抽象类：

public abstract class Wrapper2 implements Sourceable{    
        public void method1(){}  
        public void method2(){}  
    }

比如我们只是需要method1()

public class SourceSub1 extends Wrapper2 {   
        public void method1(){  
            System.out.println("the sourceable interface's first Sub1!");  
        }  
    }

比如我们只是需要method2()

public class SourceSub2 extends Wrapper2 {   
        public void method2(){  
            System.out.println("the sourceable interface's first Sub2!");  
        }  
    }

最后是测试代码：

public class WrapperTest {  
    
        public static void main(String[] args) {  
            Sourceable source1 = new SourceSub1();  
            Sourceable source2 = new SourceSub2();  
    
            source1.method1();  
            source1.method2();  
            source2.method1();  
            source2.method2();  
        }  
    }

**结果：**

the sourceable interface’s first Sub1!  
the sourceable interface’s second Sub2!

**最后我们来总结一下适配器的使用场景：**

1.类的适配器模式，当一个类需要转换成满足另外一个新接口的时候，可以使用类的适配器模式，创建一个新类，继承源类，现实新的接口就可以。

2.对象的适配器模式，当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

3.接口的适配器模式，当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

[SouthEast]: /images/20220606/7d63d94702b9489983b35a9c8454f913.png
[SouthEast 1]: /images/20220606/523ab4b7ff0046e190f069545502181f.png
[SouthEast 2]: /images/20220606/743f28c95d344aa087decc6887353df2.png