精华内容
下载资源
问答
  • 类适配器
    2022-03-07 14:57:42

    适配器模式很常用的;商城中的例子比如快递发货,那么多种快递公司;可能每个快递公司的接口对接都不一样都要适配;比如各种框架中的类似以下思想的代码,都是为了适配。

    public function behaviors()
        {
            return array_merge(parent::behaviors(), [
                'login' => [
                    'class' => LoginBehavior::className(),
                ],
            ]);
        }

    适配器出现的原因:将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

    整个适配链的角色:

    ①目标角色:也就是我们希望得到的数据结构。

    ②源角色:需要进行适配的接口 (比如顺丰、中通、蜂鸟等他们的接口的数据结构都不一样;我们如果想要接通他们在我们平台可以使用;那就需要与他们对接后,把数据结构统一!)

    ③适配器:其实就相当与一个工具类,把源改造成 目标

    哪些场景适合使用适配器呢? 

    1.你想使用一个已存在的类;但是它的数据结构已经不能满足你的需求了
    
    2.或者说你想复用一个类(因为此类可能封装了很多底层的东西,你不清楚但也不敢改动),这是可以创建一个新类 拓展类
    
    3.你想使用一个已经存在的子类,但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口(仅限于对象适配器)

    1、类适配器

     

    //目标角色 接口类
    interface ITarget  
    {  
        function operation1();  
        function operation2();  
    }  
    
    
    //源角色   接口类
    interface IAdaptee  
    {  
        function operation1();  
    }  
      
    //源角色 实现 源接口类
    class Adaptee implements IAdaptee  
    {  
        public  function operation1()  
        {  
            echo "原方法";  
        }  
    }  
    
    
    //适配器角色 (把源改造成我们想要的)
    class Adapter extends Adaptee implements IAdaptee, ITarget  
    {  
        public  function operation2()  
        {  
            echo "适配方法";  
        }  
    }  
      
    //我们想要的数据;看=》目标角色 接口类 就可以知道我们需要的是2个方法
    class Client  
    {  
        public  function test()  
        {  
            $adapter = new Adapter();  
            $adapter->operation1();//原方法  
            $adapter->operation2();//适配方法  
        }  
    }

    2.对象适配器

     

    //目标角色
    interface ITarget  
    {  
        function operation1();  
        function operation2();  
    }  
    //源角色   
    interface IAdaptee  
    {  
        function operation1();  
    }  
      
    class Adaptee implements IAdaptee  
    {  
        public  function operation1()  
        {  
            echo "原方法";  
        }  
    }  
    
    //适配器角色  (这样的代码是否可以优化?如果ITarget目标接口类想要N个方法呢?在这里都一个一个写上?)
    class Adapter implements ITarget  
    {  
        private $adaptee;   
      
        public function __construct($adaptee)  
        {  
            $this->adaptee = $adaptee;  
        }  
      
        public  function operation1()  
        {  
             return $this->adaptee->operation1();  
        }  
      
        public  function operation2()  
        {  
            echo "适配方法";  
        }  
        
    }  
      
      
    class Client  
    {  
        public  function test()  
        {  
            $adapter = new Adapter(new Adaptee(null));  
            $adapter->operation1();//原方法  
            $adapter->operation2();//适配方法  
        }  
    }

    可以看出对象适配器比类适配器灵活一点的,但是还可以优化,比如使用php的__call方法;

    //改造前
    class Adapter implements ITarget  
    {  
        private $adaptee;   
      
        public function __construct($adaptee)  
        {  
            $this->adaptee = $adaptee;  
        }  
      
        public  function operation1()  
        {  
             return $this->adaptee->operation1();  
        }  
      
        public  function operation2()  
        {  
            echo "适配方法";  
        }  
        ....N个方法
    }  
    
    //改造后
    class Adapter implements ITarget  
    {  
        private $adaptee;   
      
        public function __construct($adaptee)  
        {  
            $this->adaptee = $adaptee;  
        }  
      //当实例化调用不存在的方法是 自动调用
        public function __call($func, $args)  
    {  
        if (is_callable(array($this->adaptee, $func))) {  
            return $this->adaptee->$func($args);  
        }  
        trigger_error('*********', E_USER_ERROR);  
    }
        
    }  

    更多相关内容
  • 主要介绍了Java 适配器模式(类适配器,对象适配器)优缺点对比的相关资料,java 适配器在基础知识中还是比较重要的,这里就说下如何使用,需要的朋友可以参考下
  • 现实生活中的适配器例子 ...主要分为三类:类适配器模式、对象适配器模式、接口适配器模式 工作原理 适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容 从用户的角度看不到

    现实生活中的适配器例子

    泰国插座用的是两孔的(欧标),可以买个多功能转换插头(适配器) ,这样就可以使用了。
    在这里插入图片描述

    基本介绍

    1. 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)
    2. 适配器模式属于结构型模式
    3. 主要分为三类:类适配器模式、对象适配器模式、接口适配器模式

    工作原理

    1. 适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容
    2. 从用户的角度看不到被适配者,是解耦的
    3. 用户调用适配器转化出来的目标接口方法,适配器再调用被适配者的相关接口方法
    4. 用户收到反馈结果,感觉只是和目标接口交互,如图
      在这里插入图片描述

    类适配器模式

    类适配器模式介绍

    基本介绍:Adapter 类,通过继承src 类,实现dst 类接口,完成src->dst 的适配。

    类适配器模式应用实例

    1. 应用实例说明
      以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter,220V 交流电相当于src (即被适配者),我们的目dst(即目标)是5V 直流电
    2. 思路分析(类图)
      在这里插入图片描述
    3. 代码实现

    IVoltage5V.java:适配接口(需要的)

    //适配接口
    public interface IVoltage5V {
    	public int output5V();
    }
    

    Voltage220V.java:被适配的类(要转换的)

    //被适配的类
    public class Voltage220V {
    	//输出220V的电压
    	public int output220V() {
    		int src = 220;
    		System.out.println("电压=" + src + "伏");
    		return src;
    	}
    }
    

    VoltageAdapter.java:适配器类(转换器)

    //适配器类
    public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    
    	@Override
    	public int output5V() {
    		// TODO Auto-generated method stub
    		//获取到220V电压
    		int srcV = output220V();
    		int dstV = srcV / 44 ; //转成 5v
    		return dstV;
    	}
    
    }
    

    Phone.java

    public class Phone {
    
    	//充电
    	public void charging(IVoltage5V iVoltage5V) {
    		if(iVoltage5V.output5V() == 5) {
    			System.out.println("电压为5V, 可以充电~~");
    		} else if (iVoltage5V.output5V() > 5) {
    			System.out.println("电压大于5V, 不能充电~~");
    		}
    	}
    }
    

    Client.java

    public class Client {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(" === 类适配器模式 ====");
    		Phone phone = new Phone();
    		phone.charging(new VoltageAdapter());
    	}
    
    }
    

    类适配器模式注意事项和细节

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

    对象适配器模式

    对象适配器模式介绍

    1. 基本思路和类的适配器模式相同,只是将Adapter 类作修改,不是继承src 类,而是持有src 类的实例,以解决兼容性的问题。即:持有src 类,实现dst 类接口,完成src->dst 的适配
    2. 根据“合成复用原则”,在系统中尽量使用关联关系(聚合)来替代继承关系
    3. 对象适配器模式是适配器模式常用的一种

    对象适配器模式应用实例

    1. 应用实例说明
      以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter,220V 交流电相当于src (即被适配者),我们的目dst(即目标)是5V 直流电,使用对象适配器模式完成。
    2. 思路分析(类图):只需修改适配器即可, 如下:
      在这里插入图片描述
    3. 代码实现(只改了客户端和适配器类:适配器类改为聚合关系

    VoltageAdapter.java

    //适配器类
    public class VoltageAdapter  implements IVoltage5V {
    
    	private Voltage220V voltage220V; // 关联关系-聚合
    	
    	
    	//通过构造器,传入一个 Voltage220V 实例
    	public VoltageAdapter(Voltage220V voltage220v) {
    		
    		this.voltage220V = voltage220v;
    	}
    
    
    	@Override
    	public int output5V() {
    		
    		int dst = 0;
    		if(null != voltage220V) {
    			int src = voltage220V.output220V();//获取220V 电压
    			System.out.println("使用对象适配器,进行适配~~");
    			dst = src / 44;
    			System.out.println("适配完成,输出的电压为=" + dst);
    		}
    		
    		return dst;
    		
    	}
    
    }
    

    Client.java

    public class Client {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(" === 对象适配器模式 ====");
    		Phone phone = new Phone();
    		phone.charging(new VoltageAdapter(new Voltage220V()));
    	}
    
    }
    

    对象适配器模式注意事项和细节

    1. 对象适配器和类适配器其实算是同一种思想,只不过实现方式不同。根据合成复用原则,使用组合替代继承, 所以它解决了类适配器必须继承src 的局限性问题,也不再要求dst必须是接口。
    2. 使用成本更低,更灵活。

    接口适配器模式

    接口适配器模式介绍

    1. 一些书籍称为:适配器模式(Default Adapter Pattern)或缺省适配器模式
    2. 核心思路:当不需要全部实现接口提供的方法时,可先设计一个抽象类实现接口,并为该接口中每个方法提供一个默认实现(空方法),那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
    3. 适用于一个接口不想使用其所有的方法的情况。

    最简单的实例

    1. 类图:
      在这里插入图片描述
      2)代码实现:

    Interface4.java

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

    AbsAdapter.java

    //在AbsAdapter 我们将 Interface4 的方法进行默认实现
    public abstract class AbsAdapter implements Interface4 {
    
    	//默认实现
    	public void m1() {
    	}
    
    	public void m2() {
    	}
    
    	public void m3() {
    	}
    
    	public void m4() {
    	}
    }
    

    Client.java

    public class Client {
    	public static void main(String[] args) {
    		
    		AbsAdapter absAdapter = new AbsAdapter() {
    			//只需要去覆盖我们 有需要地使用 接口方法
    			@Override
    			public void m1() {
    				// TODO Auto-generated method stub
    				System.out.println("使用了m1的方法");
    			}
    		};
    		
    		absAdapter.m1();
    	}
    }
    

    接口适配器模式应用实例

    1)Android中的属性动画ValueAnimator类(略)

    适配器模式在SpringMVC 框架应用的源码剖析

    1. SpringMvc 中的HandlerAdapter, 就使用了适配器模式
    2. SpringMVC 处理请求的流程回顾
    3. 使用HandlerAdapter 的原因分析:
      可以看到处理器的类型不同,有多重实现方式,那么调用方式就不是确定的,如果需要直接调用Controller 方法,需要调用的时候就得不断是使用if else 来进行判断是哪一种子类然后执行。那么如果后面要扩展Controller,就得修改原来的代码,这样违背了OCP 原则。
    4. 代码分析+Debug 源码
      在这里插入图片描述
    5. 动手写SpringMVC通过适配器设计模式获取到对应的Controller的源码
      1)类图:
      在这里插入图片描述
      2)代码实现

    说明
    • Spring定义了一个适配接口,使得每一种Controller有一种对应的适配器实现类
    • 适配器代替controller执行相应的方法
    • 扩展Controller 时,只需要增加一个适配器类就完成了SpringMVC的扩展了,
    • 这就是设计模式的力量

    适配器模式的注意事项和细节

    1. 三种命名方式,是根据src (被适配的)是以怎样的形式给到Adapter(在Adapter 里的形式)来命名的。
    2. 类适配器:以类给到,在Adapter 里,就是将src 当做类,继承
      对象适配器:以对象给到,在Adapter 里,将src 作为一个对象,持有
      接口适配器:以接口给到,在Adapter 里,将src 作为一个接口,实现
    3. Adapter 模式最大的作用还是将原本不兼容的接口融合在一起工作。
    4. 实际开发中,实现起来不拘泥于我们讲解的三种经典形式

    总结

    类适配器,继承src
    对象适配器,聚合src
    接口适配器,实现接口src,(可以抽象适配器类实现src,再默认实现,再根据需要在子类实现相应的方法

    展开全文
  • 在设计模式中,也存在一种类似的模式,存在两个接口不同的,可以使用一个适配器类来将一个接口转换为客户希望的另一个接口,称为适配器模式。 1、适配器模式 在适配器模式中引入了一个被称为适

    前言

    现在的笔记本都只存在USB接口,嵌入式设备只有串口,两者如何通信呢?可以使用USB转串口线连接电脑和嵌入式设备,其中USB一端连接电脑、串口和外部设备进行通信。嵌入式设备上存在的是串一端连接嵌入式设备。本来电脑和嵌入式设备由于接口不兼容,无法进行通信,而使用USB转串口线这个适配器,两者之间就可以正常进行数据通信。在设计模式中,也存在一种类似的模式,存在两个接口不同的类,可以使用一个适配器类来将一个接口转换为客户希望的另一个接口,称为适配器模式

    1、适配器模式

    在适配器模式中引入了一个被称为适配器(Adapter)的包装类,而它所包装的对象称为适配者(Adaptee),即被适配的类。适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用。也就是说:当客户类调用适配器的方法时,在适配器类的内部将调用适配者类的方法,而这个过程对客户类是透明的,客户类并不直接访问适配者类。因此,适配器让那些由于接口不兼容而不能交互的类可以一起工作。

    适配器模式可以将一个类的接口和另一个类的接口匹配起来,而无须修改原来的适配者接口和抽象目标类接口。适配器模式定义如下:

    适配器模式(Adapter Pattern):将一个接口转换成客户希望的另一个接口,使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。

    在适配器模式中,我们通过增加一个新的适配器类来解决接口不兼容的问题,使得原本没有任何关系的类可以协同工作。根据适配器类与适配者类的关系不同,适配器模式可分为对象适配器和类适配器两种,在对象适配器模式中,适配器与适配者之间是关联关系;在类适配器模式中,适配器与适配者之间是继承(或实现)关系。在实际开发中,对象适配器的使用频率更高。

     

    图片

                                                                    对象适配器模式结构图

     

    在对象适配器模式结构图中包含如下几个角色:

    Target(目标抽象类):目标抽象类定义客户所需接口,可以是一个抽象类或接口,也可以是具体类。

    Adapter(适配器类):适配器可以调用另一个接口,作为一个转换器,对Adaptee和Target进行适配,适配器类是适配器模式的核心在对象适配器中,它通过继承Target并关联一个Adaptee对象使二者产生联系

    Adaptee(适配者类):适配者即被适配的角色,它定义了一个已经存在的接口,这个接口需要适配,适配者类一般是一个具体类,包含了客户希望使用的业务方法,在某些情况下可能没有适配者类的源代码。

     

    根据对象适配器模式结构图,在对象适配器中,客户端需要调用request()方法,而适配者类Adaptee没有该方法,但是它所提供的specificRequest()方法却是客户端所需要的。为了使客户端能够使用适配者类,需要提供一个包装类Adapter,即适配器类。这个包装类包装了一个适配者的实例,从而将客户端与适配者衔接起来,在适配器的request()方法中调用适配者的specificRequest()方法。因为适配器类与适配者类是关联关系(也可称之为委派关系),所以这种适配器模式称为对象适配器模式。

     

    2、Socket 网络通信的设计与实现——对象适配器

     

    使用TCP进行网络通信,一般都会包含创建套接字、绑定套接字、监听套接字、连接套接字等4个过程。某网络公司已经有一套成熟的套接字软件包,里面包含网络通信的4个过程。现欲开发一套新的聊天软件,决定复用已经成熟的套接字软件包。

    图片

     

    SocketPackage就是成熟的套接字软件包,也就是Adaptee适配者类,包含创建套接字、绑定套接字、监听套接字、连接套接字等成熟方法; Socket是目标抽象类Target,定义了客户希望的方法; SocketAdapter为适配器类,将成熟软件包里面的方法转为Socket类中客户希望的方法。

     

    2.1 待适配的类——成熟的套接字

     

    成熟的套接字软件包实现代码如下:

    #ifndef _SOCKET_PACKAGE_H_  
    
    #define _SOCKET_PACKAGE_H_  
    
     
    
    #include <iostream>  
    
    #include <string>  
    
    using namespace std;  
    
    
    
    //套接字包(可以被复用)  
    
    class SocketPackage  
    
    {  
    
    public:  
    
        void CreateSpecificSocket()  
    
        {  
    
            cout << "创建套接字" << endl;  
    
        }  
    
        void BindSpecificSocket()  
    
        {  
    
            cout << "绑定套接字" << endl;  
    
        }  
    
        void ListenSpecificSocket()  
    
        {  
    
            cout << "监听套接字" << endl;  
    
        }  
    
        void ConnecSpecifictSocket()  
    
        {  
    
            cout << "连接套接字" << endl;  
    
        }  
    
    };  
    
    #endif

     

    现欲开发的聊天软件定义了一个抽象类Socket,也就是目标抽象类Target,里面包含创建套接字、绑定套接字、监听套接字、连接套接字等客户希望的方法,但这些方法和成熟软件包中的方法不同。如:Socket类创建套接字方法为CreateSocket,而SocketPackage类创建套接字方法为CreateSpecificSocket。这两个方法不同,无法进行通信,为了复用成熟套接字软件包里面的方法,可以提供一个适配器类,继承于抽象的Socket类。在适配器中的方法将调用套接字软件包里面的方法。

     

    2.2 适配器类——新的套接字

     

    套接字适配器类实现代码如下:

    #ifndef _SOCKET_H_  
    
    #define _SOCKET_H_  
    
    #include "SocketPackage.h"  
    
    //抽象套接字类  
    
    class Socket  
    
    {  
    
    public:  
    
        //创建套接字  
    
        virtual void CreateSocket() = 0;  
    
        //绑定套接字  
    
        virtual void BindSocket() = 0;  
    
        //监听套接字  
    
        virtual void ListenSocket() = 0;  
    
        //连接套接字  
    
        virtual void ConnectSocket() = 0;  
    
    };  
    
    //套接字适配器  
    
    class SocketAdapter : public Socket  
    
    {  
    
    private:  
    
        SocketPackage * m_pSocketPackage;  
    
    public:  
    
        //构造函数,创建一个需要复用的套接字包对象  
    
        SocketAdapter()  
    
        {  
    
            m_pSocketPackage = new SocketPackage();  
    
        }  
    
        //销毁需要复用的套接字包对象  
    
        ~SocketAdapter()  
    
        {  
    
            if( NULL != m_pSocketPackage )  
    
            {  
    
                delete m_pSocketPackage;  
    
                m_pSocketPackage = NULL;  
    
            }  
    
        }  
    
        //创建套接字  
    
        void CreateSocket()  
    
        {  
    
            m_pSocketPackage->CreateSpecificSocket();  
    
        }  
    
        //绑定套接字  
    
        void BindSocket()  
    
        {  
    
            m_pSocketPackage->BindSpecificSocket();  
    
        }  
    
        //监听套接字  
    
        void ListenSocket()  
    
        {  
    
            m_pSocketPackage->ListenSpecificSocket();  
    
        }  
    
        //连接套接字  
    
        void ConnectSocket()  
    
        {  
    
            m_pSocketPackage->ConnecSpecifictSocket();  
    
        }  
    
    };  
    
    #endif

     

     

    2.3 测试

     

    测试代码实现如下:

    #include <iostream>  
    
    #include "Socket.h"  
    
    using namespace std;  
    
    int main()  
    
    {  
    
        //创建套接字适配器对象  
    
        Socket * pSocketAdapter = new SocketAdapter();  
    
        //使用适配器进行套接字操作  
    
        pSocketAdapter->CreateSocket();  
    
        pSocketAdapter->BindSocket();  
    
        pSocketAdapter->ListenSocket();  
    
        pSocketAdapter->ConnectSocket();  
    
      
    
        //销毁操作  
    
        delete pSocketAdapter;  
    
        pSocketAdapter = NULL;  
    
       
    
        return 0;  
    
    }

     

     

    编译并执行,结果如下:

    图片

     

    SocketAdapter套接字适配器类和SocketPackage套接字包是一种组合的关系(指针),当调用套接字适配器类中的相应方法时,将调用套接字包对应的方法,通过组合的方式,实现对套接字软件包模块的复用。客户端不需要直接操作这个已经成熟的套接字软件包,而是由套接字适配器类进行委托操作,降低了客户端和适配者类的耦合。

    对象适配器模式中,适配器类Adapter和适配者类Adatpee类是一种关联关系,或者组合关系。适配器类维护一个适配者类的引用,在适配器的方法中调用相应的适配者类中的方法,实现对适配者功能的复用,这个过程对客户端是透明的,客户类不直接访问适配者类。

     

    3、Socket 网络通信的设计与实现——类适配器

     

    除了对象适配器模式之外,适配器模式还有一种形式,那就是类适配器模式,类适配器模式和对象适配器模式最大的区别在于适配器和适配者之间的关系不同,对象适配器模式中适配器和适配者之间是关联关系,而类适配器模式中适配器和适配者是继承关系。不管是对象适配器还是类适配器,都是为了复用适配者类的功能。

     

    图片

     

    SocketPackage就是成熟的套接字软件包,也就是Adaptee适配者类,包含创建套接字、绑定套接字、监听套接字、连接套接字等成熟方法; Socket是目标抽象类Target,定义了客户希望的方法; SocketAdapter为适配器类,继承自Socket类和SocketPackage类,将成熟软件包里面的方法转为Socket类中客户希望的方法。

     

    3.1 带适配类——成熟套接字

     

    成熟的套接字软件包实现代码如下:

    #ifndef _SOCKET_PACKAGE_H_  
    
    #define _SOCKET_PACKAGE_H_  
    
      
    
    #include <iostream>  
    
    #include <string>  
    
    using namespace std;  
    
      
    
    //套接字包(可以被复用)  
    
    class SocketPackage  
    
    {  
    
    public:  
    
        void CreateSpecificSocket()  
    
        {  
    
            cout << "创建套接字" << endl;  
    
        }  
    
      
    
        void BindSpecificSocket()  
    
        {  
    
            cout << "绑定套接字" << endl;  
    
        }  
    
      
    
        void ListenSpecificSocket()  
    
        {  
    
            cout << "监听套接字" << endl;  
    
        }  
    
      
    
        void ConnecSpecifictSocket()  
    
        {  
    
            cout << "连接套接字" << endl;  
    
        }  
    
      
    
    };  
    
      
    
    #endif

     

     

    SocketAdapter套接字适配器类和SocketPackage套接字包类不在是组合的关系,SocketAdapter继承于Socket类和SocketPackage,当调用SocketAdapter套接字适配器类中的方法,将会调用其基类SocketPackage的相应方法,通过继承的方式实现对适配者类的功能复用。

     

    3.2 适配类——采用(多)继承

     

    套接字适配器类实现代码如下:

    #ifndef _SOCKET_H_  
    
    #define _SOCKET_H_  
    
      
    
    #include "SocketPackage.h"  
    
      
    
    //抽象套接字类  
    
    class Socket  
    
    {  
    
    public:  
    
        //创建套接字  
    
        virtual void CreateSocket() = 0;  
    
      
    
        //绑定套接字  
    
        virtual void BindSocket() = 0;  
    
      
    
        //监听套接字  
    
        virtual void ListenSocket() = 0;  
    
      
    
        //连接套接字  
    
        virtual void ConnectSocket() = 0;  
    
    };  
    
    
    
    //套接字适配器(类适配器)  
    
    class SocketAdapter : public Socket, SocketPackage  
    
    {  
    
    public:  
    
      
    
        //创建套接字  
    
        void CreateSocket()  
    
        {  
    
            CreateSpecificSocket();  
    
        }  
    
          
    
        //绑定套接字  
    
        void BindSocket()  
    
        {  
    
            BindSpecificSocket();  
    
        }  
    
          
    
        //监听套接字  
    
        void ListenSocket()  
    
        {  
    
            ListenSpecificSocket();  
    
        }  
    
          
    
        //连接套接字  
    
        void ConnectSocket()  
    
        {  
    
            ConnecSpecifictSocket();  
    
        }  
    
    };  
    
      
    
    #endif

     

     

    3.3 测试

     

    测试程序实现代码如下:

    #include <iostream>  
    
    #include "Socket.h"  
    
      
    
    using namespace std;  
    
      
    
    int main()  
    
    {  
    
        //创建套接字适配器对象  
    
        Socket * pSocketAdapter = new SocketAdapter();  
    
          
    
        //使用适配器进行套接字操作  
    
        pSocketAdapter->CreateSocket();  
    
        pSocketAdapter->BindSocket();  
    
        pSocketAdapter->ListenSocket();  
    
        pSocketAdapter->ConnectSocket();  
    
      
    
        //销毁操作  
    
        delete pSocketAdapter;  
    
        pSocketAdapter = NULL;  
    
          
    
        return 0;  
    
    }

     

     

    编译并执行,程序结果如下:

    图片

    类适配器模式:适配器类继承于目标抽象类和适配者类,当调用适配器类的方法时,在该方法内部将调用其基类,也就是适配者类中相应的方法,通过继承的方式,实现复用适配者类的功能

    不管是对象适配器还是类适配器,都是为了实现功能的复用。

     

    4、适配器模式总结

     

    在对象适配器模式中,适配器与适配者之间是关联关系;在类适配器模式中,适配器与适配者之间是继承关系。不论是对象适配器还是类适配器,适配器模式都将现有接口转化为客户类所期望的接口,实现了对现有类的复用。为了避免两个或者多个事物之间直接耦合,应该如何分配职责? 大多数情况都可以通过增加一层间接性来解决,将职责分配给中介对象,使其作为其他构件或服务之间的媒介,以避免他们之间的直接耦合。在适配器模式中,为了避免客户类和与适配者类直接耦合,也就是客户类直接访问适配者类,可以增加一个适配器类,降低客户类与适配者类的耦合性。当客户类调用适配器的方法时,在适配器类的内部将调用适配者类的方法,而这个过程对客户类是透明的,客户类并不直接访问适配者类。它是一种使用频率非常高的设计模式,在软件开发中得以广泛应用。

     

    4.1 主要优点

     

    无论是对象适配器模式还是类适配器模式都具有如下优点:

     

    (1) 将目标类和适配者类解耦,通过引入一个适配器类来重用现有的适配者类,无须修改原有结构。

    (2) 增加了类的透明性和复用性,将具体的业务实现过程封装在适配者类中,对于客户端类而言是透明的,而且提高了适配者的复用性,同一个适配者类可以在多个不同的系统中复用。

    (3) 灵活性和扩展性都非常好,通过使用配置文件,可以很方便地更换适配器,也可以在不修改原有代码的基础上增加新的适配器类,完全符合“开闭原则”。

     

    具体来说,类适配器模式还有如下优点:

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

    对象适配器模式还有如下优点:

    (1) 一个对象适配器可以把多个不同的适配者适配到同一个目标;

    (2) 可以适配一个适配者的子类,由于适配器和适配者之间是关联关系,根据“里氏代换原则”,适配者的子类也可通过该适配器进行适配。

     

    4.2 主要缺点

     

    类适配器模式的缺点如下:

    (1) 对于Java、C#等不支持多重类继承的语言,一次最多只能适配一个适配者类,不能同时适配多个适配者;

    对象适配器模式的缺点如下:

    与类适配器模式相比,要在适配器中置换适配者类的某些方法比较麻烦。如果一定要置换掉适配者类的一个或多个方法,可以先做一个适配者类的子类,将适配者类的方法置换掉,然后再把适配者类的子类当做真正的适配者进行适配,实现过程较为复杂。

     

    4.3 适配器模式具体应用

    (1)复用已经写好的功能模块,例如:已经写好了一个员工信息模块,要重新开发一个新的企业管理系统,可以复用员工信息模块。

    (2)程序运行时的日志信息,可以记录到数据库,也可以记录到Txt文件中。现在变更需求,使日志信息能够同时记录到数据库和Txt文件中。可以添加一个适配器类,适配数据库操作和文件操作。

    (3)在软件开发过程中,我们会开发出一些功能性模块。如排序算法模块、查找模块、或者封装链表、队列、树等操作。在需要复用这些功能的时候,直接使用,无需重新开发这些功能模块。

    (4)网上银行加密模块开发: 已经开发好了一套网银加密模块,现在需要重新开发一个类似的软件,可以直接复用已经开发好的加密模块。

    (5)某公司已经开发了一套火车票识别软件,包含二值化、去噪、版面分析、栏目提取等模块。现在要开发银行卡识别项目,则可以直接复用火车票识别中的功能模块。

    (6)某公司想要开发一套输入法软件,可以购买搜狗输入法的搜索模块,直接加以复用,无需自己重头开发。

    (7)生活中的适配器: 电源适配器,USB转串口线,水管专修工人使用各种接口连接本来没法进行相连的管道。

    展开全文
  • Java类适配器模式(类适配器

    千次阅读 2020-07-30 20:13:37
    一、适配器在生活中的应用 现实生活中的适配器例子 泰国插座用的是两孔的(欧标),...主要分为三类:类适配器模式、对象适配器模式、接口适配器模式。 三、适配器工作原理 适配器模式:将一个类的接口转换成另一种接

    一、适配器在生活中的应用

    现实生活中的适配器例子 泰国插座用的是两孔的(欧标),可以买个多功能转换插头 (适配器) ,这样就可以使用了。

    二、适配器基本介绍

    1. 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)。
    2. 适配器模式属于结构型模式。
    3. 主要分为三类:类适配器模式、对象适配器模式、接口适配器模式。

    三、适配器工作原理

    1. 适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容。
    2. 从用户的角度看不到被适配者,是解耦的。
    3. 用户调用适配器转化出来的目标接口方法,适配器再调用被适配者的相关接口方法。
    4. 用户收到反馈结果,感觉只是和目标接口交互。如图:
      在这里插入图片描述

    四、类适配器模式介绍

    基本介绍:Adapter类,通过继承 src类,实现 dst 类接口,完成src->dst的适配。

    类适配器模式应用实例:

    1. 应用实例说明
      以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter,220V交流电相当于src (即被适配者),我们的目dst(即 目标)是5V直流电。
    2. 思路分析(类图)
      在这里插入图片描述

    代码实现:

    //被适配的类
    public class Voltage220V {
    	//输出220V的电压
    	public int output220V() {
    		int src = 220;
    		System.out.println("电压=" + src + "伏");
    		return src;
    	}
    }
    
    //适配接口
    public interface IVoltage5V {
    	public int output5V();
    }
    
    //适配器类
    public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    	@Override
    	public int output5V() {
    		//获取到220V电压
    		int srcV = output220V();
    		int dstV = srcV / 44 ; //转成 5v
    		return dstV;
    	}
    }
    
    public class Phone {
    	//充电
    	public void charging(IVoltage5V iVoltage5V) {
    		if(iVoltage5V.output5V() == 5) {
    			System.out.println("电压为5V, 可以充电~~");
    		} else if (iVoltage5V.output5V() > 5) {
    			System.out.println("电压大于5V, 不能充电~~");
    		}
    	}
    }
    

    测试类:

    public class Client {
    
    	public static void main(String[] args) {
    		System.out.println(" === 类适配器模式 ====");
    		Phone phone = new Phone();
    		phone.charging(new VoltageAdapter());
    	}
    }
    

    结果图:

    在这里插入图片描述

    展开全文
  • 概述 如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。 而我们使用的插头如下图最右边的。因此我们的笔记本电脑,手机在当地不能直接充电。 所以就需要一个插座转换器...适配器模式分为类适配器模式
  • 适配器(Adaper)角色public class Adapter extends Adaptee implements Target { /** * 由于源
  • I . 适配器模式 ( 类适配器 ) 代码模板 II . 适配器模式 ( 对象适配器 ) 代码模板 III . 适配器模式 代码示例
  • 结构三、类适配器模式四、对象适配器模式五、接口适配器模式六、适用场景 一、概述 如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。而我们使用的插头如下图最右边所示,因此我们的笔记本电脑、...
  • 一、 模式介绍   适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式,它结合了两个独立接口的功能,使得原本由于接口不兼容而不能在一起工作的类...2.1 类适配器
  • 适配器模式概述: 如果去欧洲国家去旅游的话,他们的插座如下图最...定义: 将一个的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些能一起工作。 适配器模式的结构: 适配器模.
  • 文章目录类适配器代码对象适配器代码 类适配器 SDCard 是一个接口,代表了 SD 卡本身具有的功能 SDCardImpl 是一个具体的实现类,代表了 SDCard 一种具体的实现形式 TFCard 是一个接口,代表了 TF 卡本身具有的功能...
  • Convert the interface of a class into another interface clients expect.Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.(将一个的接口变成客户端所期待的...
  • 设计模式之------适配器模式(类适配器和对象适配器案例) 适配器模式包含如下角色: Target:目标抽象类 Adapter:适配器类 Adaptee:适配者类 Client:客户类
  • 不兼容结构的协调——适配器模式(三)类适配器除了对象适配器模式之外,适配器模式还有一种形式,那就是类适配器模式,类适配器模式和对象适配器模式最大的区别在于适配器和适配者之间的关系不同,对象适配器模式中...
  • I . 适配器模式概念 II . 适配器模式 适用场景 III . 适配器模式 优缺点 IV . 适配器模式 与 外观...V ....VI . 适配器模式 ( 类适配器 ) 代码实现流程 ( 重点 ) VII . 适配器模式 ( 对象适配器 ) 代码实现流程 ( 重点 )
  • 设计模式-适配器模式:将一个的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些能一起工作。
  • 类适配器 Adapter 类继承Adaptee (被适配类),同时实现Target 接口(因为 Java 不支持多继承,所以只能通过接口的方法来实现多继承),在 Client 类中我们可以根据需要选择并创建任一种符合需求的子类,来实现...
  • 适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式。适配器模式包含类适配器和对象适配器
  • 计算机后端-Java-图解java设计模式061 类适配器.avi
  • 类适配器模式

    2016-12-19 16:16:18
    适配器模式中的类适配器,java实现
  • 适配器模式,将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 适配器的用法  在想使用一个已经存在...1、类适配器  从图中可以看出Ad
  • 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同工作。...类适配器 对象适配器 接口适配器 总结
  • java类适配器

    2015-11-05 23:18:41
    java适配器模式中的类适配器实例,可成功运行
  • 类适配器和对象适配器 类适配器 Adapter 类继承Adaptee (被适配类),同时实现Target 接口(因为 Java 不支持多继承,所以只能通过接口的方法来实现多继承),在 Client 类中我们可以根据需要选择并创建任一种...
  • 文章目录详解Java设计模式之适配器模式结构型模式结构型模式分类类结构型模式对象结构型模式结构性模式一览表案例引入适配器模式适配器模式定义适配器模式结构类适配器适配器的模式结构实例分析缺省适配器模式双向...
  • 类适配器与对象适配器的区别

    千次阅读 2015-06-03 16:52:35
    类适配器是客户类有一个接口规范的情况下可用,此时适配类只需作为功能类的子类,并实现接口并可,直接用功能类实现了客户类的要求。而对象适配类是在客户类没有提供接口的情况下用的,适配类作为客户类的子类,并在...
  • 类适配器和对象适配器

    千次阅读 2014-02-13 14:19:30
    顾名思义,这类适配器模式就是主要用于,单一的为某个类而实现适配的这样一种模式,为什么说只为某个类去实现,一会提到,我们先展示这种类适配模式的代码实现。 ========================   适配器模式把一个类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 225,139
精华内容 90,055
关键字:

类适配器