适配器模式（java实现）

痛定思痛。 2023-07-13 03:27 12阅读 0赞

## 简介 ##

> 参考资料：https://www.bilibili.com/video/av57936239?p=60

适配器模式（Adapter Pattern）将某个接口转换成客户端希望的另一个接口表示，主要目的是兼容性，让原本因接口不匹配而不能一起工作的两个类可以协同工作。其别名为包装器（Wrapper）

适配器模式属于结构型模式

主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

#### 工作原理 ####

*  适配器模式：将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容
 *  从用户的角度看不到被适配者，是解耦的
 *  用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法
 *  用户收到反馈结果，感觉只是和目标接口交互

## 三种适配器模式 ##

#### 类适配器 ####

例如，现在有一个提供5V电压充电的接口：

// 使用5V充电
    public interface Charge5V { 
        void charging();
    }

充电宝类实现了该接口：

// 充电宝
    public class MobilePower implements Charge5V { 
        @Override
        public void charging() { 
            System.out.println("使用充电宝给手机充电(5V)");
        }
    }

然后手机可以充电：

// 手机
    public class Phone { 
        public void charge(Charge5V c) { 
            c.charging();
        }
    
        public static void main(String[] args) { 
            Phone phone = new Phone();
            MobilePower mobilePower = new MobilePower();
            phone.charge(mobilePower);
        }
    }

现在有一个插座类，输出220V电压

// 插座
    public class Socket{ 
        public void chargingWith220V() { 
            System.out.println("使用插座直接充电（220V）");
        }
    }

插座类也想给手机充电，但是因为接口类型不匹配，不能充电

![不能直接充电][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpMzQ1NTI3NzkyNQ_size_16_color_FFFFFF_t_70]  
现在就需要出现一个适配器类：充电器

// 充电器
    public class ChargerAdapter extends Socket implements Charge5V { 
        @Override
        public void charging() { 
            chargingWith220V();
            System.out.println("转化为5V");
        }
    }

然后插座通过使用充电器来给手机充电：

// 手机
    public class Phone { 
        public void charge(Charge5V c) { 
            c.charging();
        }
    
        public static void main(String[] args) { 
            Phone phone = new Phone();
            ChargerAdapter chargerAdapter = new ChargerAdapter();
            phone.charge(chargerAdapter);
        }
    }

UML类图：  
![UML类图][UML]

使用类适配器的注意细节：

*  Java是单继承，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是接口，有一定的局限性
 *  src类的方法在Adapter中都会暴露出来，也增加了使用成本
 *  由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter类的灵活性增强了

#### 对象适配器 ####

简介：

*  基本思路和类适配器相同，只是将Adapter类做修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。
 *  根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系
 *  对象适配器模式是适配器模式中常用的一种
 *  使用成本更低，更灵活

仍然使用上面手机充电的例子，修改适配器：

// 充电器
    public class ChargerAdapter implements Charge5V { 
        private Socket socket;
    
        public ChargerAdapter(Socket socket) { 
            this.socket = socket;
        }
    
        public void charging() { 
            socket.chargingWith220V();
            System.out.println("转化为5V");
        }
    }

在Phone调用：

// 手机
    public class Phone { 
        public void charge(Charge5V c) { 
            c.charging();
        }
    
        public static void main(String[] args) { 
            Phone phone = new Phone();
            Socket socket = new Socket();
            ChargerAdapter chargerAdapter = new ChargerAdapter(socket);
            phone.charge(chargerAdapter);
        }
    }

UML类图：

![UML类图][UML 1]

#### 接口适配器 ####

简介

*  一些书籍上称为缺省适配器模式
 *  当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现，那么该抽象类的子类可有选择的覆盖父类的某些方法来实现需求
 *  适用于一个接口不想使用其所有的方法的情况

例如现在有一个接口`Interface1`：

public interface Interface1 { 
        void m1();
        void m2();
        void m3();
        void m4();
    }

现在有一个`Client`只想使用`m1`方法

public class Client { 
        public void solve(Interface1 i1){ 
            i1.m1();
        }
    }

于是就可以新建一个抽象适配器，让其实现`Interface1`：

public abstract class ClientAdapter implements Interface1 { 
        @Override
        public void m1() {  }
        @Override
        public void m2() {  }
        @Override
        public void m3() {  }
        @Override
        public void m4() {  }
    }

现在在使用`Client`的时候就可以使用`ClientAdapter`，只需重写方法`m1`即可

public static void main(String[] args) { 
        Client client = new Client();
        Interface1 interface1 = new ClientAdapter() { 
            @Override
            public void m1() { 
                System.out.println("ClientAdapter.m1");
            }
        };
        client.solve(interface1);
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpMzQ1NTI3NzkyNQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200309231642972.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpMzQ1NTI3NzkyNQ==,size_16,color_FFFFFF,t_70
[UML]: https://img-blog.csdnimg.cn/20200310114057735.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpMzQ1NTI3NzkyNQ==,size_16,color_FFFFFF,t_70
[UML 1]: https://img-blog.csdnimg.cn/20200310114932643.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpMzQ1NTI3NzkyNQ==,size_16,color_FFFFFF,t_70