适配器模式的本质及分类

适配器模式的三种形式适配器模式，顾名思义，就是把原本不兼容的接⼝，通过适配，使之兼容。

举个⽣活中简单的例⼦，以前的⼿机内存卡可以取出来，但是想和电脑之间传输⾳乐、视频等资料不能直接传输，需要通过USB读卡器，然后插⼊USB接⼝就可以传输了，这个USB读卡器就相当于适配器。

你经常使⽤的⼿机或电脑充电器，也属于适配器，它将220V的交流电转换为⼿机可⽤的直流电。

下⾯，以⼿机充电器为例讲解适配器模式。

适配器模式⼀般分为三类：类适配器模式、对象适配器模式、接⼝适配器模式（缺省适配器模式）⼀、类适配器模式⼀般⼿机充电器输出的直流电压为5V，我们把交流电220V称为源，希望得到的直流电5V称为⽬标，⽽充电器即为适配器。

//源，交流电public class AC {public int outputAC(){return 220;}}//⽬标接⼝，直流电public interface IDC {public int outputDC();}//适配器public class ClsAdapter extends AC implements IDC{@Overridepublic int outputDC() {return outputAC()/44; //直流电为交流电的电压值除以44}public static void main(String[] args) {ClsAdapter adapter = new ClsAdapter();System.out.println("交流电电压:" + adapter.outputAC());System.out.println("直流电电压:" + adapter.outputDC());}}/**输出结果为：交流电电压:220直流电电压:5*/可以看到，类适配器是通过继承源类，实现⽬标接⼝的⽅式实现适配的。

但是，由于Java单继承的机制，这就要求⽬标必须是接⼝，有⼀定的局限性。

java设计模式-适配器模式java适配器模式1、概述 什么是适配器模式？ 适配器模式是⼀种结构型设计模式。

适配器模式就是：把⼀个类的接⼝变换成客户端所期待的另⼀种接⼝，从⽽使原本因接⼝不匹配⽽⽆法在⼀起⼯作的两个类能够在⼀起⼯作。

⽤电器来打个⽐喻：有⼀个电器的插头是三脚的，⽽现有的插座是两孔的，要使插头插上插座，我们需要⼀个插头转换器，这个转换器即是适配器。

适配器模式涉及3个⾓⾊：源（Adaptee）：需要被适配的对象或类型，相当于插头。

适配器（Adapter）：连接⽬标和源的中间对象，相当于插头转换器。

⽬标（Target）：期待得到的⽬标，相当于插座。

2、适配器模式UML图 图⽚来⾃⽹络 通过上⾯UML图可以知道，客户端期待的接⼝或者对象通过适配器的转换得到了满⾜，Adapter通过内部包装Adaptee对象把源对象转换成客户端期待的对象。

3、适配器模式分类 适配器模式包括3种形式：1. 类适配器模式：类适配器使⽤的是继承的⽅式，⼀般来说⽆法对其⼦类进⾏适配2. 对象适配器模式：对象适配器使⽤的是组合的⽅式，⼦孙类都可以被适配。

另外，对象适配器对于增加⼀些新⾏为⾮常⽅便，⽽且新增加的⾏为同时适⽤于所有的源。

3. 接⼝适配器模式（⼜称缺省适配器模式）：接⼝适配器模式（缺省适配模式）基本思想是，为⼀个接⼝提供缺省实现，这样⼦类可以从这个缺省实现进⾏扩展，⽽不必从原有接⼝进⾏扩展。

可以说对象适配器模式是另外6种结构型设计模式的起源（图⽚源⾃⽹络）。

4、三种适配器模式详解 适配器模式的三种实现⽅式及代码实例详解，⽤电器来打个⽐喻：有⼀个电器的插头是两脚的，⽽现有的插座是三孔的，要使插头插上插座，我们需要⼀个插头转换器，这个转换器即是适配器。

图⽚源⾃⽹络4.1、类适配器模式 类适配器使⽤的是继承的⽅式，⼀般来说⽆法对其⼦类进⾏适配，请看代码实例 1.⾸先我们有⼀个要被适配的类/*** 源（相当于两脚插头,也就是被适配的类）* @author ningbeibei*/public class Adaptee {public void adapteeMethod() {System.out.println("两脚插头，被适配的类....");}} 2.定义⼀个⽬标接⼝/*** ⽬标（客户所期待的类，可以是⼀个接⼝抽象类具体的类）* 相当于三孔插板* @author ningbeibei*/public interface Target {void targetMethod(); 3.定义适配器类 定义适配器类通过继承 Adaptee 和实现 Target 接⼝关联起来，/*** 类适配器模式(相当于转换器)* 通过Adapter类把Adaptee类与Target接⼝衔接起来* @author ningbeibei*/public class Adapter extends Adaptee implements Target {@Overridepublic void targetMethod() {//操作处理adapteeMethod();//操作处理}} 4.测试代码/*** 适配器模式测试类* @author ningbeibei*/public class test {public static void main(String[] args) {//类适配器模式Adapter adapter = new Adapter();adapter.targetMethod();}} 5.运⾏结果4.2、对象适配器模式 对象适配器使⽤的是组合的⽅式，它把源类作为属性放⼊适配器类中，请看代码实例 1.定义被适配的类/*** 源（相当于两脚插头,也就是被适配的类）* @author ningbeibei*/public class Adaptee {public void adapteeMethod() {System.out.println("两脚插头，被适配的类....");}} 2.定义⽬标接⼝/*** ⽬标（客户所期待的类，可以是⼀个接⼝抽象类具体的类）* 相当于三孔插板* @author ningbeibei*/public interface Target {void targetMethod();} 3.定义适配器类（类似于转换器） 注意：通过持有Adaptee属性建⽴与Target接⼝联系/*** 对象适配器模式(相当于转换器)* 通过持有Adaptee属性建⽴与Target接⼝联系* @author ningbeibei*/public class Adapter implements Target {//添加属性private Adaptee adaptee;public Adapter (Adaptee adaptee) {this.adaptee = adaptee;}@Overridepublic void targetMethod() {//操作处理adaptee.adapteeMethod();//操作处理} 4.测试类/*** 适配器模式测试类* @author ningbeibei*/public class test {public static void main(String[] args) {//对象适配器模式Adapter adapter = new Adapter(new Adaptee());adapter.targetMethod();}} 5.结果输出4.3、接⼝适配器模式（缺省适配模式） 接⼝适配器模式⼜称缺省模式，这种模式通过抽象类对接⼝进⾏实现，在抽象类种对接⼝进⾏默认实现。

一、适配器模式定义Adapter，将一个类的接口转换成客户希望的另外一个接口。

Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

二、详细说明通常，客户类（clients of class）通过类的接口访问它提供的服务。

有时，现有的类（existing class）可以提供客户类的功能需要，但是它所提供的接口不一定是客户类所期望的。

这是由于现有的接口太详细或者缺乏详细或接口的名称与客户类所查找的不同等诸多不同原因导致的。

在这种情况下，现有的接口需要转化（convert）为客户类期望的接口，这样保证了对现有类的重用。

如果不进行这样的转化，客户类就不能利用现有类所提供的功能。

适配器模式（Adapter Pattern）可以完成这样的转化。

适配器模式建议定义一个包装类，包装有不兼容接口的对象。

这个包装类指的就是适配器（Adapter），它包装的对象就是适配者(Adaptee)。

适配器提供客户类需要的接口，适配器接口的实现是把客户类的请求转化为对适配者的相应接口的调用。

换句话说：当客户类调用适配器的方法时，在适配器类的内部调用适配者类的方法，这个过程对客户类是透明的，客户类并不直接访问适配者类。

因此，适配器可以使由于借口不兼容而不能交互的类可以一起工作（work together）。

三、Adapter的分类适配器总体上可以分为两类，类适配器（Class Adapter）和对象适配器(Object Adapter)类适配器：类适配器是通过继承类适配者类（Adaptee Class）实现的，另外类适配器实现客户类所需要的接口。

当客户对象调用适配器类方法的时候，适配器内部调用它所继承的适配者的方法。

对象适配器：对象适配器包含一个适配器者的引用（reference），与类适配器相同，对象适配器也实现了客户类需要的接口。

当客户对象调用对象适配器的方法的时候，对象适配器调它所包含的适配器者实例的适当方法。

定义：
把一个类的接口变换成客户端所期待的另一种接 口，从而使原本因接口不匹配而无法在一起工作的两 个类能够在一起工作。又称为转换器模式、变压器模 式、包装（Wrapper）模式（把已有的一些类包装起 来，使之能有满足需要的接口）。
模式中的角色： 目标接口（Target）：客户所期待的接口。目标可 以是具体的或抽象的类，也可以是接口。 需要适配的类（Adaptee）：需要适配的类或适配 者类。 适配器（Adapter）：通过包装一个需要适配的对 象，把原接口转换成目标接口。
THANKS!!!
Байду номын сангаас
优点
缺点

对于对象适配器来说，更换适配器的实现过程比较复杂。
适用场景




1、系统需要使用现有的类，而这些类的接口不符合 系统的接口。 2、想要建立一个可以重用的类，用于与一些彼此之 间没有太大关联的一些类，包括一些可能在将来引进的 类一起工作。 3、两个类所做的事情相同或相似，但是具有不同接 口的时候。 4、旧的系统开发的类已经实现了一些功能，但是客 户端却只能以另外接口的形式访问，但我们不希望手动 更改原有类的时候。 5、使用第三方组件，组件接口定义和自己定义的不 同，不希望修改自己的接口，但是要使用第三方组件接 口的功能。
总结： 无论哪种适配器，它的宗旨都是：保留现有类所提 供的服务，向客户提供接口，以满足客户的期望。即在 不改变原有系统的基础上，提供新的接口服务。




1、通过适配器，客户端可以调用同一接口，因而对 客户端来说是透明的。这样做更简单、更直接、更紧凑。 2、复用了现存的类，解决了现存类和复用环境要求 不一致的问题。 3、将目标类和适配者类解耦，通过引入一个适配器 类重用现有的适配者类，而无需修改原有代码。 4、 一个对象适配器可以把多个不同的适配者类适 配到同一个目标，也就是说，同一个适配器可以把适配 者类和它的子类都适配到目标接口。

Adapter pattern问题引出：大家生活中可能碰到的一个问题就是你新买的手机自带的耳机是2.5接口的，不幸的是有一天你的耳机坏了，你去市面上根本就找不到2.5的耳机了，基本上是3.5接口了，没办法你只好买了个3.5接口的耳机，老板告诉你：“我给你一个适配器”这不问题就解决了。

问题分析：3.5的接口的耳机在你手机上本来是没法使用的，因为它没有按照2.5接口的设计啊，而现在我又想使用这幅耳机，于是乎有了“适配器（Adapter）”这个一个东西出来了。

Adapter模式的定义：把一个类的接口变换成客户端所期待的另外一种接口，使得原本由于接口不兼容而不能再一起工作的那些类可以一起工作。

适配器模式分类：1.类的适配器模式（采用继承实现）2.对象适配器（采用对象组合方式实现）3.缺省的适配器模式类的适配器类图：模式的构成：以问题中例子为模型目标抽象角色(Target):定义客户所期待要使用的接口，我们把手机当做客户端，客户端所需要使用的耳机的接口是2.5的，在这里就可以抽象出来一个2.5接口的设备（并不一定是耳机）。

源角色(Adaptee):需要被适配的接口，在这里指的是我们从市场上买回来的那个3.5接口的耳机。

适配器角色(Adapter)：用来把源接口转换成符合要求的目标接口的设备，在这里指的是老板送给我们的那个“转换器”。

客户端(Client)：这里指的就是那个给我们带来麻烦的手机喽。

示例代码：Java代码1.//Target2.3.package pattern.adapter;4.5.public interface Target {6.7. public void provide2_5();8.9.}10.11.//Adaptee12.13.package pattern.adapter;14.15.public class Adaptee {16.17. public void provide3_5(){18.19. System.out.println("我是一个3.5的接口哦");20.21. }22.23.}24.25.//Adapter26.27.package pattern.adapter;28.29.public class Adapter extends Adaptee implements Target {30.31. @Override32.33. public void provide2_5() {34.35. this.provide3_5();36.37. }38.39.}40.41.//Client42.43.package pattern.adapter;44.45.public class CellPhoneClient {46.47. public static void main(String[] args) {48.49. Target target = new Adapter();50.51. //该手机只支持2.5接口的耳机52.53. target.provide2_5();54.55. }56.57.}输出结果：我是一个3.5的接口哦从输出结果可以看出只支持2.5接口的手机成功的使用3.5的耳机了。

适配器模式
1.模式定义
将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作。

适配器模式既可以作为类结构型模式，也可以作为对象结构型模式
定义中所提及的接口是指广义的接口，它可以表示一个方法或者方法的集合
2.模式结构
类适配器：
对象适配器：
适配器模式包含如下角色：
Target：目标抽象类
Adapter：适配器类
Adaptee：适配者类
3.模式优缺点
适配器模式优点：
（1）将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无须修改原有结构。

（2）增加了类的透明性和复用性，提高了适配者的复用性，同一个适配者类可以在多个不同的系统中复用。

（3）灵活性和扩展性非常好。

（4）类适配器模式：置换一些适配者的方法很方便。

（5）对象适配器模式：可以把多个不同的适配者适配到同一个目标，还可以适配一个适配者的子类。

缺点：
类适配器模式：
（1）一次最多只能适配一个适配者类，不能同时适配多个适配者。

（2）适配者类不能为最终类.
（3）目标抽象类只能为接口，不能为类。

对象适配器模式：在适配器中置换适配者类的某些方法比较麻烦。

4.实例一
先需要设计一个可以模拟各种动物行为的机器人，在机器人中定义了一系列方法，如机器人叫喊方法cry（），机器人移动方法move（）等。

如果希望在不修改原有的代码的基础上使得机器人能够像狗一样叫，像狗一样跑，像鸟一样叫，像鸟一样飞，可以使用适配器模式进行系统设计。

实例类图
代码如下：。

第⼀节：适配器设计模式
⼀、⽣活中适配器例⼦
⼆、基本介绍
1、适配器模式（Adapter Pattern）将某个类的接⼝转换成客户端期望的另⼀个接⼝表⽰，主要⽬的是兼容性，让原本因接⼝不匹配不能⼀起⼯作的两个类可以协同⼯作，⼜被称为包装器（Wrapper）。

2、适配器模式属于结构型模式；
3、主要分为三类：类适配器、对象适配器模式、接⼝适配器模式；
三、适配器模式⼯作原理
1、适配器模式：将⼀个类的接⼝转换成另⼀种接⼝，让原本接⼝不兼容的类可以兼容；
2、从⽤户的⾓度看不到被适配者，是解耦的；
3、⽤户调⽤适配器转化出来的⽬标接⼝⽅法，适配器再调⽤者被适配者的相关接⼝⽅法；
4、⽤户收到反馈结果，感觉只是和⽬标接⼝交互，如图：。

⼀⽂彻底弄懂适配器模式（Adapter）⽂章已收录我的仓库：设计意图适配器模式（Adapter Pattern）是作为两个不兼容的接⼝之间的桥梁。

这种类型的设计模式属于结构型模式，它结合了两个独⽴接⼝的功能。

在某些时候，客户期望获得某种功能接⼝但现有的接⼝⽆法满⾜客户的需求，例如美国的正常供电电压为110V，⼀个中国⼈带了⼀款中国制造电器去美国，这个电器必须要在220V电压下才能充电使⽤。

这种情况下，客户(中国⼈)的期望接⼝是有⼀个220V的电压为电器充电，但实际的接⼝是仅有⼀个110V的电压供电器充电，这种情况下就需要采⽤⼀根电压转换器(适配器)使得110V的电压能够转换为220V的电压，供客户使⽤。

将⼀个类的接⼝转换成客户希望的另外⼀个接⼝，这就是适配器需要做的事情，适配器模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。

适⽤条件系统需要使⽤现有的类，⽽此类的接⼝不符合系统的需要(核⼼需求)。

想要建⽴⼀个可以重复使⽤的适配器类，⽤于与⼀些彼此之间没有太⼤关联的⼀些类，包括⼀些可能在将来引进的类⼀起⼯作，这些源类不⼀定有⼀致的接⼝，但通过适配器使得它们都具有⼀致的接⼝。

通过接⼝转换，将⼀个类插⼊另⼀个类系中。

（⽐如⽼虎和飞禽，现在多了⼀个飞虎，在不增加实体的需求下，增加⼀个适配器，在⾥⾯包容⼀个虎对象，实现飞的接⼝。

）设计通常有两种⽅式实现适配器模式，⼀种是类适配器，类适配器⽬前已不太使⽤，另⼀种实现⽅式是对象适配器，通常情况下采⽤对象适配器会使得代码更易扩展与维护。

不管采⽤何种⽅式，其基本的实现思想都是：对现有接⼝的实现类进⾏扩展，使其实现客户期望的⽬标接⼝。

类适配器通过继承现有接⼝类并实现⽬标接⼝，这样的话会使得现有接⼝类完全对适配器暴露，使得适配器具有现有接⼝类的全部功能，破坏了封装性。

此外从逻辑上来说，这也是不符合常理的，适配器要做的是扩展现有接⼝类的功能⽽不是替代，类适配器只有在特定条件下会被使⽤。

带大家了解android中的适配器模式在android学习过程中，我相信ListView必定是让大家十分头痛的组件，原因很简单，这里有个适配器的概念，对于学生来讲是一个从未涉及的新的领域，所以我在这里写了本篇文章，目的是带大家了解android中的适配器模式，为你的学习之路铺平道路。

1.适配器模式的定义：Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatile interfaces.将一个类的接口变成客户端所期待的另一中接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

其中用到适配器模式的经典例子就是插座匹配问题，直接给图：2.适配器模式的分类：适配器模式主要分为两种：类适配器和对象适配器如上图所示(截取自《Head First Design Patterns》一书)，主要包括三个部分：1) Target目标角色。

该角色定义把其他类转换为我们的期待接口。

2) Adaptee源角色。

就是原始的类和接口对象，它是已经存在的，只是不符合现有的要求，而需要利用适配器角色的包装。

3) Adapter适配器角色。

适配器模式的核心角色，其它两个角色都是已经存在的角色，而适配器角色是需要新建立的，它的职责非常简单;把源角色转换为目标角色;通过继承或是组合的方式。

3.适配器模式的优势：1)适配器模式可以让两个没有任何关系的类在一起运行，只要适配器这个角色能够搞定它们。

2)增加了类的通透性，我们访问的Target目标角色，但是具体的实现都委托给了源角色，而这些对高层次模块是透明的，也是它不需要关心得。

3)调高了类的复用性和灵活性非常好。

如果觉得适配器不够好，只要修改适配器就行，其它的代码都不用修改，适配器就是一个灵活的构件，想用就用。

适配器模式(adapter)1.适配器模式(Adapter)的定义:在软件开发中，由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是新环境的接口是现存对象所不满足的。

那么如何应对这种“迁移的变化”呢？如何利用现有对象的良好实现，同时又满足新的应用环境所要求的接口？这里说得就是Adapter模式。

2.意图：将一个类的接口转换成客户希望的另外一个接口，Adapter使得原本由于接口不兼容而不能一起工作的类可以一起共工作。

3.适配器模式的构成：1)目标抽象角色(Target)：定义客户要用的特定领域的接口2)适配器(Adapter):调用另一个接口，作为转换器3)适配器(Adaptee):定义一个接口，Adapter需要接入4)客户端(Client)：协同对相符合Adapter适配器4.适配器的分类：1)类适配器(采用集成的方式)2)对象适配器(采用对象组合的方式)-推荐3)缺省的适配器模式(AWT，Swing事件模型采用的模式)5.使用的场合：第一，对象需要使用现存的并且接口不兼容的类；第二，需要创建可重用的类以协调其他接口可能不兼容的类。

6.案例(通过类的继承模式)：1)目标抽象角色(Target):package com.abao.adapter;public interface Target{public void method1();}2)适配器-Adapter需要接入：package com.abao.adapter;public class Adaptee{public void method2(){System.out.println("目标方法");}}3)适配器(Adapter):package com.abao.adapter;public class Adapter extends Adaptee implements Target {@Overridepublic void method1(){this.method2();}}4)客户端(Client)：package com.abao.adapter;public class Client{public static void main(String[] args){Target target = new Adapter();target.method1();}}7.Junit中使用的额适配器模式：1)Junit在TestCase类中应用了适配器(Adapter)模式：2)在runBare方法中，通过runTest方法经我们自己编写的testXXX方法进行的适配，使得junit可以执行我们自己编写的Test Case，runTest方法的实现如下：8.案例(使用对象组合的方式实现适配器) 1)目标抽象角色(Target):package com.abao.adapter;public interface Target{public void method1();}2)适配器-Adapter需要接入：package com.abao.adapter;public class Adaptee{public void method2(){System.out.println("目标方法");}}3)适配器(Adapter)-这个地方就不是采用继承:package com.abao.adapter1;public class Adapter implements Target{private Adaptee adaptee;public Adapter(Adaptee adaptee){this.adaptee = adaptee;}@Overridepublic void method1(){adaptee.method2();}}4)客户端(Client)：package com.abao.adapter1;public class Client{public static void main(String[] args){Target target = new Adapter(new Adaptee());target.method1();}}9.案例(缺省的适配器模式)：1)抽象的接口服务角色：package com.abao.defaultadapter;public interface AbstractService{public void service1();public void service2();public void service3();}2)适配器角色(和swing比较几乎一样)：package com.abao.defaultadapter;public class ServiceAdapter implements AbstractService {@Overridepublic void service1(){}@Overridepublic void service2(){}@Overridepublic void service3(){}}3)具体的服务角色：package com.abao.defaultadapter;public class ConcreteService extends ServiceAdapter{@Overridepublic void service1(){System.out.println("执行业务方法");}}10.上面的适配器模式和AWT、swing中的适配器的模式实现是完全一样的。

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。

A d a p t e r 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适用场景：1、已经存在的类的接口不符合我们的需求；2、创建一个可以复用的类，使得该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作；3、在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类。

通用类图：电源适配器，它是用于电流变换（整流）的设备。

适配器的存在，就是为了将已存在的东西（接口）转换成适合我们的需要、能被我们所利用。

在现实生活中，适配器更多的是作为一个中间层来实现这种转换作用。

在上面的通用类图中，Cient 类最终面对的是Target 接口（或抽象类），它只能够使用符合这一目标标准的子类；而Adaptee 类则是被适配的对象（也称源角色），因为它包含specific （特殊的）操作、功能等，所以我们想要在自己的系统中使用它，将其转换成符合我们标准的类，使得Client 类可以在透明的情况下任意选择使用ConcreteTarget 类或是具有特殊功能的Adatee 类。

代码实现如下：// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类class Adaptee {publicvoid specificRequest() {System.out.println("被适配类具有特殊功能...");}}// 目标接口，或称为标准接口interface Target {publicvoid request();}// 具体目标类，只提供普通功能class ConcreteTarget implements Target {publicvoid request() {System.out.println("普通类具有普通功能...");}}// 适配器类，继承了被适配类，同时实现标准接口class Adapter extends Adaptee implements Target {publicvoid request() {super.specificRequest();//特殊调用}}// 测试类publicclass Client {publicstaticvoid main(String[] args) {// 使用普通功能类Target concreteTarget = new ConcreteTarget();concreteTarget.request();// 使用特殊功能类，即适配类Target adapter = new Adapter();adapter.request();}}测试结果：普通类具有普通功能...被适配类具有特殊功能...上面这种实现的适配器称为类适配器，因为Adapter 类既继承了Adaptee （被适配类），也实现了Target 接口（因为Java 不支持多继承，所以这样来实现），在Client 类中我们可以根据需要选择并创建任一种符合需求的子类，来实现具体功能。

Adaptee adaptee=new Adaptee(); public void Request() {
adaptee.SpecificRequest(); } }
public class Client {
public static void main(String[] args) {
ITarget t = new Adapter(); t.Request(); } }
对象适配器效果 ① 允许一个Adapter与多个Adaptee及它们所
有子类同时工作。Adapter也可以一次给 所有的Adaptee添加功能 ② 使得重定义Adaptee的行为比较困难。这 就 需 要 生 成 Adaptee 的 子 类 并 且 使 得 Adapter引用这个子类而不是引用Adaptee 本身。
} }
类适配器效果
① 用Adapter类对Adaptee和Target进行匹配。 当想要匹配一个类以及所有它的子类时， 类Adapter将不能胜任工作
② 使得Adapter可以重定义Adaptee的部分行 为，因为Adapter是Adaptee的一个子类。
③ 仅仅引入一个对象，并不需要额外的指针 以间接得到adaptee
this.turkey = turkey;
} public void quack() {
火鸡适配器包装了一 个火鸡对象，同时实
turkey.gobble(); } public void fly() {
现了鸭子接口。这样 就可以像使用鸭子一 样使用火鸡了。
for(int i=0; i < 5; i++) {
duck.fly();
}
}
需要使用鸭子对象
分析

设计模式之：适配器模式适配器很容易理解, ⼤多数⼈家庭都有⼿机转接器, ⽤来为移动电话充电,这就是⼀种适配器. 如果只有USB接头, 就⽆法将移动电话插到标准插座上. 实际上, 必须使⽤⼀个适配器, ⼀端接USB插头, ⼀端接插座. 当然, 你可以拿出电⽓⼯具,改装USB连接头, 或者重新安装插座, 不过这样会带来很多额外的⼯作, ⽽且可能会把连接头或插座弄坏. 所以, 最可取的⽅法就是找⼀个适配器. 软件开发也是如此.类适配器模式(使⽤继承)类适配器模式很简单, 不过与对象适配器模式相⽐, 类适配器模式的灵活性弱些, 类适配器简单的原因在于 , 适配器(Adapter)会从被适配者(Adaptee)继承功能, 所以适配模式中需要编写的代码⽐较少.由于类适配器模式包含双重继承, 但是PHP并不⽀持双重继承, 不过幸运的是,PHP可以⽤接⼝来模拟双重继承, 下⾯是⼀个正确的结构, 不仅继承了⼀个类, 同时还继承了⼀个接⼝class ChildClass extends ParentClass implements ISomeAdapter{}实现类适配器模式时, 参与者必须包括⼀个PHP接⼝下⾯以⼀个货币兑换为例来演⽰:假设有⼀个企业⽹站在同时销售软件服务和软件产品, ⽬前, 所有交易都在美国进⾏, 所以完全可以⽤美元来完成所有计算.现在开发⼈员希望能有⼀个转换器能处理美元和欧元的兑换, ⽽不改变原来按美元交易额的类.通过增加⼀个适配器, 现在程序即可以⽤美元计算也可以⽤欧元计算.DollarCalc.php<?phpclass DollarCalc{private $dollar;private $product;private $service;public $rate = 1;public function requestCalc($productNow, $serviceNow){$this->product = $productNow;$this->service = $serviceNow;$this->dollar = $this->product + $this->service;return $this->requestTotal();}public function requestTotal(){$this->dollar *= $this->rate;return $this->dollar;}}查看这个类,可以看到其中有⼀个属性$rate,requestTotal()⽅法使⽤$rate计算⼀次交易的⾦额.在这个版本中, 这个值设置为1,实际上总⾦额⽆需再乖以兑换率, 不过如果要为客户提供折扣或者要增加额外服务或产品的附加费, $rate变量会很⽅便. 这个类并不是适合器模式的⼀部分, 不过这是⼀个起点.需求变化了现在客户的公司要向欧洲发展,所以需要开发⼀个应⽤, 能够⽤欧元完成同样的计算. 你希望这个欧元计算能够像DollarCalc⼀样, 所要做的就是改变变量名.EuroCalc.php<?phpclass EuroCalc{private $euro;private $product;private $service;public $rate = 1;public function requestCalc($productNow, $serviceNow){$this->product = $productNow;$this->service = $serviceNow;$this->euro = $this->product + $this->service;return $this->requestTotal();}public function requestTotal(){$this->euro *= $this->rate;return $this->euro;}}接下来, 再把应⽤的其余部分插⼊到EuroCalc类中. 不过,因为客户的所有数据都是按美元计算的.换句话说, 如果不重新开发整个程序, 就⽆法在系统中"插⼊"这个欧元计算. 但是你不想这么做. 为了加⼊EuroCalc, 你需要⼀个适配器: 就像找⼀个适配器来适应欧洲的插座⼀样, 可以创建⼀个适配器, 使你的系统能够使⽤欧元. 幸运的是, 类适配器正是为这样的情况设计的.⾸先需要创建⼀个接⼝. 在这个类图中, 这个接⼝名为ITarget. 它只有⼀个⽅法requester(). requester()是⼀个抽象⽅法, 要由接⼝的具体实现来实现这个⽅法.ITarget.php<?phpinterface ITarget{public function requester();}现在开发⼈员可以实现requester()⽅法, 请求欧元⽽不是美元.在使⽤继承的适配器设计模式中, 适配器(Adapter)参与都既实现ITarget接⼝,还实现了具体类EuroCalc. 创建EuroAdapter不需要做太多⼯作,因为⼤部分⼯作已经在EuroCal类中完成.现在要做的就是实现request()⽅法, 使它能把美元值转换为欧元值.EuroAdapter.php<?phpinclude_once('EuroCalc.php');include_once('ITarget.php');class EuroAdapter extends EuroCalc implements ITarget{public function __construct(){$this->requester();}public function requester(){$this->rate = 0.8111;return $this->rate;}}类适配模式中, ⼀个具体类会继承另⼀个具体类, 有这种结构的设计模式很少见, ⼤多数设计模式中, ⼏乎都是继承⼀个抽象类, 并由类根据需要实现其抽象⽅法和属性. 换句话说, ⼀般谈到继承时, 都是具体类继承抽象类.由于既实现了⼀个接⼝⼜扩展了⼀个类, 所以EuroAdapter类同时拥有该接⼝和具体类的接⼝. 通过使⽤requester()⽅法, EuroAdapter类可以设置rate值(兑换率), 从⽽能使⽤被适配者的功能, ⽽元⽽做任何改变.下⾯定义⼀个Client类, 从EuroAdapter和DollarCalc类发出请求. 可以看到,原来的DollarCalc仍能很好地⼯作, 不过它没有ITarget接⼝. Client.php<?phpinclude_once('EuroAdapter.php');include_once('DollarCalc.php');class Client{public function __construct(){$euro = '€';echo "区元: $euro" . $this->makeApapterRequest(new EuroAdapter()) . '<br />';echo "美元: $: " . $this->makeDollarRequest(new DollarCalc()) . '<br />';}private function makeApapterRequest(ITarget $req){return $req->requestCalc(40,50);}private function makeDollarRequest(DollarCalc $req){return $req->requestCalc(40,50);}}$woker = new Client();运⾏结果如下:Euros: €72.999Dollars: $: 90可以看到,美元和欧元都可以处理, 这就是适配器模式的⽅便之处.这个计算很简单, 如果是针对更为复杂的计算, 继承要提供建⽴类适配器的Target接⼝的必要接⼝和具体实现使⽤组合的适配器模式对象适配器模式使⽤组合⽽不是继承, 不过它也会完成同样的⽬标. 通过⽐较这两个版本的适配器模式, 可以看出它们各⾃的优缺点. 采⽤类适配器模式时,适配器可以继承它需要的⼤多数功能, 只是通过接⼝稍微调. 在对象适配器模式中适配器(Adapter)参与使⽤被适配者(Adaptee), 并实现Target接⼝. 在类适配器模式中, 适配器(Adapter)则是⼀个被适配者(Adaptee), 并实现Target接⼝.⽰例: 从桌⾯环境转向移动环境PHP程序员经常会遇到这样⼀个问题:需要适应移动环境⽽做出调整.不久之前,你可能只需要考虑提供⼀个⽹站来适应多种不同的桌⾯环境.⼤多数桌⾯都使⽤⼀个布局, 再由设计⼈员让它更美观. 对于移动设备, 设计⼈员和开发⼈员不仅需要重新考虑桌⾯和移动环境中页⾯显⽰的设计元素, 还要考虑如何从⼀个环境切换到另⼀个环境.⾸先来看桌⾯端的类Desktop(它将需要⼀个适配器). 这个类使⽤了⼀个简单但很宽松的接⼝:IFormat.php<?phpinterface IFormat{public function formatCSS();public function formatGraphics();public function horizontalLayout();}它⽀持css和图⽚选择, 不过其中⼀个⽅法指⽰⼀种⽔平布局, 我们知道这种布局并不适⽤⼩的移动设备.下⾯给出实现这个接⼝的Desktop类Desktop.php<?phpinclude_once('IFormat.php');class Desktop implements IFormat{public function formatCSS(){echo "引⽤desktop.css<br />";}public function formatGraphics(){echo "引⽤desktop.png图⽚<br />";}public function horizontalLayout(){echo '桌⾯:⽔平布局';}}问题来了, 这个布局对于⼩的移动设备来说太宽了. 所以我们的⽬标是仍采⽤同样的内容, 但调整为⼀种移动设计.下⾯来看移动端的类Mobile⾸先移动端有⼀个移动端的接⼝IMobileFormat<?phpinterface IMobileFormat{public function formatCSS();public function formatGraphics();public function verticalLayout();}可以看到, IMobileFormat接⼝和IFormat接⼝是不⼀样的,也就是不兼容的, ⼀个包含了⽅法horizontalLayout(), 另⼀个包含⽅法verticalLaout(),它们的差别很⼩, 最主要的区别是: 桌⾯设计可以采⽤⽔平的多栏布局, ⽽移动设计要使⽤垂直布局,⽽适配器就是要解决这个问题下⾯给出⼀个实现了IMoibleFormat接⼝的Mobile类Mobile.php<?phpinclude_once('IMobileFormat.php');class Mobile implements IMobileFormat{public function formatCSS(){echo "引⽤mobile.css<br />";}public function formatGraphics(){echo "引⽤mobile.png图⽚<br />";}public function verticalLayout(){echo '移动端:垂直布局';}}Mobile类和Desktop类⾮常相似, 不过是图⽚和CSS引⽤不同接下来,我们需要⼀个适配器,将Desktop和Mobile类结合在⼀起MobileAdapter.php<?phpinclude_once('IFormat.php');include_once('Mobile.php');class MobileAdapter implements IFormat{private $mobile;public function __construct(IMobileFormat $mobileNow){$this->mobile = $mobileNow;}public function formatCSS(){$this->mobile->formatCSS();}public function formatGraphics(){$this->mobile->formatGraphics();}public function horizontalLayout(){$this->mobile->verticalLayout();}}可以看到,MobileAdapter实例化时要提供⼀个Mobile对象实例.还要注意 ,类型提⽰中使⽤了IMobileFormat, 确保参数是⼀个Mobile对象.有意思的是, Adapter参与者通过实现horizontalLayout()⽅法来包含verticalLayout()⽅法.实际上, 所有MobileAdapter⽅法都包装了⼀个Mobile⽅法.碰巧的是, 适配器参与者中的⼀个⽅法并不在适配器接⼝中(verticalLayout());它们可能完全不同, 适配器只是把它们包装在适配器接⼝(IFormat)的某⼀⽅法中.客户调⽤(Client)Client.php<?phpinclude_once('Mobile.php');include_once('MobileAdapter.php');class Client{private $mobile;private $mobileAdapter;public function __construct(){$this->mobile = new Mobile();$this->mobileAdapter = new MobileAdapter($this->mobile);$this->mobileAdapter->formatCSS();$this->mobileAdapter->formatGraphics();$this->mobileAdapter->horizontalLayout();}}$worker = new Client();适配器模式中的Client类必须包装Adaptee(Mobile)的⼀个实例, 以便集成到Adapter本⾝.实例化Adapter时, Client使⽤Adatee作为参数来完成Adapter的实例化.所以客户必须⾸先创建⼀个Adapter对象(new Mobile()), 然后创建⼀个Adapter((new MobileAdapter($this->mobile)). Client类的⼤多数请求都是通过MobileAdapter发出的. 不过这个代码的最后他使⽤了Mobile类的实例.适配器和变化PHP程序员要即该⾯对变化.不同版本的PHP会变化, 可能增加新的功能, 另外还可能取消⼀些功能.⽽且随着PHP的⼤⼤⼩⼩的变化,MySQL也在改变.例如, mysql的扩展包升级为mysqli, PHP开发⼈员需要相应调整, 要改为使⽤mysqli中的新API.这⾥适合采⽤适配器模式吗?可能不适合.适配器可能适⽤, 可能不适⽤,这取决于你的程序如何配置.当然可以重写所有连接和交互代码, 不过这可不是适配器模式的本意, 这就像是重新安装USB连接头, 想把它插进标准的墙上插座⼀样. 不过, 如果所有原来的mysql代码都在模块中, 你可以修改这个模块(类),换⼊⼀个有相同接⼝的新模块.只是要使⽤mysqli⽽不是mysql.我不认为交换等同于适配器, 不过道理是⼀样的, 在适配器模式中, 原来的代码没有任何改变, 有变化的只是适配器.如果需要结合使⽤两个不兼容的接⼝, 这种情况下, 适配器模式最适⽤.适配器可以完成接⼝的"联姻".可以把适配器看作是⼀个婚姻顾问;通过创建⼀个公共接⼝来克服双⽅的差异.利⽤这种设计模式, 可以促成⼆者的合作,⽽避免完全重写某⼀部分.。

适配器（Adapter）模式一、适配器（Adapter）模式适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本接口不匹配而无法在一起工作的两个类能够在一起工作。

名称由来这很像变压器（Adapter），变压器把一种电压变换成另一种电压。

美国的生活用电电压是110V，而中国的电压是220V。

如果要在中国使用美国电器，就必须有一个能把220V电压转换成110V电压的变压器。

这个变压器就是一个Adapter。

Adapter模式也很像货物的包装过程：被包装的货物的真实样子被包装所掩盖和改变，因此有人把这种模式叫做包装（Wrapper）模式。

事实上，大家经常写很多这样的Wrapper 类，把已有的一些类包装起来，使之有能满足需要的接口。

适配器模式的两种形式适配器模式有类的适配器模式和对象的适配器模式两种。

我们将分别讨论这两种Adapter 模式。

二、类的Adapter模式的结构：由图中可以看出，Adaptee类没有Request方法，而客户期待这个方法。

为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest 方法，实现了适配的目的。

因为Adapter与Adaptee是继承的关系，所以这决定了这个适配器模式是类的。

该适配器模式所涉及的角色包括：目标（Target）角色：这是客户所期待的接口。

因为C#不支持多继承，所以Target必须是接口，不可以是类。

源（Adaptee）角色：需要适配的类。

适配器（Adapter）角色：把源接口转换成目标接口。

这一角色必须是类。

三、类的Adapter模式示意性实现：下面的程序给出了一个类的Adapter模式的示意性的实现：// Class Adapter pattern -- Structural exampleusing System;// "ITarget"interface ITarget{// Methodsvoid Request();}// "Adaptee"class Adaptee{// Methodspublic void SpecificRequest(){Console.WriteLine("Called SpecificRequest()" );}}// "Adapter"class Adapter : Adaptee, ITarget{// Implements ITarget interfacepublic void Request(){// Possibly do some data manipulation// and then call SpecificRequestthis.SpecificRequest();}}///<summary>/// Client test///</summary>public class Client{public static void Main(string[] args){// Create adapter and place a requestITarget t = new Adapter();t.Request();}}四、对象的Adapter模式的结构：从图中可以看出：客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。

适配器模式、装饰器模式、代理模式的区别
适配器模式、装饰器模式、代理模式都属于设计模式中的结构型模式，结构型设计模式是从程序的结构上解决模块之间的耦合问题。

适配器模式意图：将一个类的接口转换成另外一个客户希望的接口。

Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

Adapter模式通过类的继承或者对象的组合侧重于转换已有的接口，类适配器采用多继承的实现方式，带来了不良的高耦合，所以一般不推荐使用。

对象适配器采用对象组合的方式，更符合松耦合精神。

例如：笔记本电源适配器，可以将220v转化为适合笔记本使用的电压。

适用性：
你想使用一个已经存在的类，而它的接口不符合你的需求。

你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。

（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。

对象适配器可以适配它的父类接口。

代理模式意图：为其他对象提供一种代理以控制对这个对象的访问，解决直接访问某些对象是出现的问题。

例如：律师本身就是我们维权的一个代理！
适用性：在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用Proxy模式。

下面是一些可以使用Proxy模式常见情况：
远程代理（Remote Proxy）为一个对象在不同的地址空间提供局部代表。

虚代理（Virtual Proxy）根据需要创建开销很大的对象。

保护代理（ProtecTIon Proxy）控制对原始对象的访问。

保护代理用于对象应该有不同的访问权限的时候。

三种适配器模式总结和使⽤场景转载请标明出处：本⽂出⾃:⼀概述定义：适配器模式将某个类的接⼝转换成客户端期望的另⼀个接⼝表⽰，主的⽬的是兼容性，让原本因接⼝不匹配不能⼀起⼯作的两个类可以协同⼯作。

其别名为包装器(Wrapper)。

属于结构型模式主要分为三类：类适配器模式、对象的适配器模式、接⼝的适配器模式。

本⽂定义：需要被适配的类、接⼝、对象（我们有的），简称 src（source）最终需要的输出（我们想要的），简称 dst (destination，即Target)适配器称之为 Adapter 。

⼀句话描述适配器模式的感觉： src->Adapter->dst,即src以某种形式（三种形式分别对应三种适配器模式）给到Adapter⾥，最终转化成了dst。

拿我们Android开发最熟悉的展⽰列表数据的三⼤控件：ListView，GridView，RecyclerView的Adapter来说，它们三个控件需要的是View(dst),⽽我们有的⼀般是datas(src),所以适配器Adapter就是完成了数据源datas 转化成 ItemView的⼯作。

带⼊src->Adapter->dst中，即datas->Adapter->View.使⽤场景：1 系统需要使⽤现有的类，⽽这些类的接⼝不符合系统的需要。

2 想要建⽴⼀个可以重复使⽤的类，⽤于与⼀些彼此之间没有太⼤关联的⼀些类，包括⼀些可能在将来引进的类⼀起⼯作。

3 需要⼀个统⼀的输出接⼝，⽽输⼊端的类型不可预知。

⼆类适配器模式：⼀句话描述：Adapter类，通过继承 src类，实现 dst 类接⼝，完成src->dst的适配。

别的⽂章都⽤⽣活中充电器的例⼦来讲解适配器，的确，这是个极佳的举例，本⽂也不能免俗：充电器本⾝相当于Adapter，220V交流电相当于src，我们的⽬dst标是5V直流电。

我们现有的src类：/*** 介绍：src类: 我们有的220V电压* 作者：zhangxutong* 邮箱：zhangxutong@* 时间： 2016/10/18.*/public class Voltage220 {public int output220V() {int src = 220;System.out.println("我是" + src + "V");return src;}}我们想要的dst接⼝：/*** 介绍：dst接⼝：客户需要的5V电压* 作者：zhangxutong* 邮箱：zhangxutong@* 时间： 2016/10/18.*/public interface Voltage5 {int output5V();}适配器类：/*** 介绍：Adapter类：完成220V-5V的转变* 通过继承src类，实现 dst 类接⼝，完成src->dst的适配。

Python中的适配器模式适配器模式是一种软件设计模式，用于将不兼容的接口转换为兼容的接口，从而使得不同组件之间能够互相协作的标准化交互。

在Python中，适配器模式的应用相对来说比较灵活，可以应用于各种场景中，比如将已有的类适配为某个接口，或者将两个不同的接口适配为兼容的接口等。

一、适配器模式的简介适配器模式是一种结构型设计模式，旨在将不兼容的接口转换为兼容的接口，从而满足不同组件之间的标准化交互，同时又不影响已有的系统结构。

适配器模式涉及到三个角色：适配器(Adapter)、适配者(Adaptee)和目标(Target)。

适配器是将适配者的接口转换为目标的接口的中间件，适配者是需要被适配的对象，而目标是适配器期望得到的接口。

二、适配器模式的应用场景在实际开发过程中，适配器模式的应用场景非常广泛，比如：1.将已有的类适配为某个接口通常情况下，我们会使用继承的方式来实现类的复用，但是如果需要将现有的类适配为某个接口，这种方式就不是很合适。

此时，适配器模式就可以派上用场，它能够将已有的类适配为目标接口，从而使得现有的类也能够满足新的需求，不需要对现有的类进行修改。

2.将两个不同的接口适配为兼容的接口在不同系统间进行数据交换时，往往由于数据格式不同、协议不同或者接口不同等原因，导致无法正常交互。

此时，适配器模式就可以将两个不同的接口适配为兼容的接口，从而使得这两个系统能够正常交互。

三、适配器模式的实现方法1.类适配器模式类适配器模式是一种通过多重继承的方式实现适配器模式的方法。

在类适配器模式中，适配器类继承了适配者类，并实现了目标接口，从而达到将适配者类适配为目标接口的目的。

示例代码如下：```class Adaptee:def specific_request(self):return "specific request"class Target:def request(self):return "default request"class Adapter(Target, Adaptee):def request(self):return self.specific_request()if __name__ == "__main__":adapter = Adapter()assert adapter.request() == "specific request" ```2.对象适配器模式对象适配器模式是一种通过组合的方式实现适配器模式的方法。