精华内容
下载资源
问答
  • Java设计模式 适配器模式


    适配器模式的作用:适配器模式把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作


    适配器模式主要包括三种:类适配器模式,对象适配器模式,接口适配器模式


    1.类适配器模式

    类的适配器模式把适配的类的API转换成为目标类的API。


      在上图中可以看出,Adaptee类并没有sampleOperation2()方法,而客户端则期待这个方法。为使客户端能够使用Adaptee类,提供一个中间环节,即类Adapter,把Adaptee的API与Target类的API衔接起来。Adapter与Adaptee是继承关系,这决定了这个适配器模式是类的:

      模式所涉及的角色有:

      ●  目标(Target)角色:这就是所期待得到的接口。注意:由于这里讨论的是类适配器模式,因此目标不可以是类。

      ●  源(Adapee)角色:现在需要适配的接口。

      ●  适配器(Adaper)角色:适配器类是本模式的核心。适配器把源接口转换成目标接口。显然,这一角色不可以是接口,而必须是具体类。

    public interface Target {
    
        public void sampleOperation1();
    
        public void sampleOperation2();
    }
    
    public class Adaptee {
    
        public void sampleOperation1() {
            System.out.println("sampleOperation1");
        }
    }
    public class Adapter extends Adaptee implements Target {
    
        public void sampleOperation2() {
            System.out.println("sampleOperation2");
        }
    }
    
    public class Test {
    
        public static void main(String[] args) {
            Target target = new Adapter();
            target.sampleOperation1();
            target.sampleOperation2();
        }
    }
    sampleOperation1
    sampleOperation2
    
    Process finished with exit code 0


    2.对象适配器模式
    与类的适配器模式一样,对象的适配器模式把被适配的类的API转换成为目标类的API,与类的适配器模式不同的是,对象的适配器模式不是
    使用继承关系连接到Adaptee类,而是使用委派关系连接到Adaptee类,其实就是组合方式。

    从上图可以看出,Adaptee类并没有sampleOperation2()方法,而客户端则期待这个方法。为使客户端能够使用Adaptee类,需要提供

    一个包装(Wrapper)类Adapter。这个包装类包装了一个Adaptee的实例,从而此包装类能够把Adaptee的API与Target类的API衔接起来。

    Adapter与Adaptee是委派关系,这决定了适配器模式是对象的。

    public interface Target {
    
        public void sampleOperation1();
    
        public void sampleOperation2();
    }
    
    public class Adaptee {
    
        public void sampleOperation1() {
            System.out.println("sampleOperation1");
        }
    }
    public class Adapter implements Target {
    
        Adaptee adaptee;
    
        Adapter (Adaptee adaptee) {
            super();
            this.adaptee = adaptee;
        }
    
        public void sampleOperation1() {
            this.adaptee.sampleOperation1();
        }
    
        //新方法
        public void sampleOperation2() {
            System.out.println("sampleOperation2");
        }
    }
    public class Test {
    
        public static void main(String[] args) {
            Adaptee adaptee = new Adaptee();
            Target target = new Adapter(adaptee);
            target.sampleOperation1();
            target.sampleOperation2();
        }
    }
    sampleOperation1
    sampleOperation2
    
    Process finished with exit code 0


    3.接口适配器模式

    接口适配器模式我看到过两种说法,以下都列举出来

    1)在客户端接口的实现方法和现有类相同但是方法名不同时,适配器继承现有类并实现客户端接口,其实这种方式看上去很像类的适配器模式

    //客户提供的的接口
    public interface Target {
    
        public void sampleOperation1();
    
        public void sampleOperation2();
    }
    
    //现有类
    public class Adaptee {
    
        public void sampleOper1() {
            System.out.println("sampleOperation1");
        }
    
        public void sampleOper2() {
            System.out.println("sampleOperation1");
        }
    }
    //适配器类
    public class Adapter extends Adaptee implements Target {
    
        public void sampleOperation1() {
            sampleOper1();
        }
    
        public void sampleOperation2() {
            sampleOper2();
        }
    }
    public class Test {
    
        public static void main(String[] args) {
            Target target = new Adapter();
            target.sampleOperation1();
            target.sampleOperation2();
        }
    }
    
    sampleOperation1
    sampleOperation1
    
    Process finished with exit code 0


    2)借助一个抽象类,该抽象类实现了接口的所有方法,我们再自己写类来继承这个抽象类根据需求重写方法

    public interface Target {
    
        public void sampleOperation1();
    
        public void sampleOperation2();
    }
    
    public abstract class Adapter implements Target {
    
        public void sampleOperation1() {}
    
        public void sampleOperation2() {}
    }
    public class sample1 extends Adapter {
        @Override
        public void sampleOperation1() {
            System.out.println("sampleOperation1");
        }
    }
    
    public class sample2 extends Adapter {
        @Override
        public void sampleOperation2() {
            System.out.println("sampleOperation2");
        }
    }
    
    public class Test {
    
        public static void main(String[] args) {
            sample1 s1 = new sample1();
            sample2 s2 = new sample2();
            s1.sampleOperation1();
            s2.sampleOperation2();
        }
    }
    sampleOperation1
    sampleOperation2
    
    Process finished with exit code 0


    总结:

    类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。
    对象的适配器模式:当希望在新类拥有另一个类的一些方法时,可以让新类持有原类的一个实例,在新类的方法中,调用实例的方法就行。
    接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类实现所有方法,我们写别的类的时候,继承抽象类即可。

    展开全文
  • java设计模式适配器模式讲解 请点击你的鼠标进入java设计模式吧!

    java设计模式适配器模式讲解

    请点击你的鼠标进入java设计模式吧!

    展开全文
  • 设计模式 适配器模式 以手机充电器为例

    万次阅读 多人点赞 2014-05-14 21:59:35
    继续设计模式,尼玛停了段时间就不想写了,一定要坚持~今天带来适配器模式 老样子,定义:将一个类的接口转换成客户期望的另一个接口,适配器让原本接口不兼容的类可以相互合作。这个定义还好,说适配器的功能就是把...

    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/25833393

    坚持,坚持~

    继续设计模式,尼玛停了段时间就不想写了,一定要坚持~今天带来适配器模式

    老样子,定义:将一个类的接口转换成客户期望的另一个接口,适配器让原本接口不兼容的类可以相互合作。这个定义还好,说适配器的功能就是把一个接口转成另一个接口。

    发现两张图片可以很好的解释适配器模式:



    这两张图很好的说明了适配器的作用哈,话说我当年买了个欧版的HTC G17 ,还配了个插头转化器,这个插头转化器就是起得适配器的作用。下来来点代码解释哈,如题目,手机充电器一般都是5V左右吧,咱天朝的家用交流电压220V,所以手机充电需要一个适配器(降压器),有什么物理名词使用错误的,见谅。

    首先一部手机:Mobile.java

    package com.zhy.pattern.adapter;
    
    public class Mobile
    {
    	/**
    	 * 充电
    	 * @param power 
    	 */
    	public void inputPower(V5Power power)
    	{
    		int provideV5Power = power.provideV5Power();
    		System.out.println("手机(客户端):我需要5V电压充电,现在是-->" + provideV5Power + "V");
    	}
    }
    

    可以看出,手机依赖一个提供5V电压的接口:

    package com.zhy.pattern.adapter;
    /**
     * 提供5V电压的一个接口
     * @author zhy
     *
     */
    public interface V5Power
    {
    	public int provideV5Power();
    }
    

    然后我们拥有的是220V家用交流电:

    package com.zhy.pattern.adapter;
    
    /**
     * 家用220V交流电
     * @author zhy
     *
     */
    public class V220Power
    {
    	/**
    	 * 提供220V电压
    	 * @return
    	 */
    	public int provideV220Power()
    	{
    		System.out.println("我提供220V交流电压。");
    		return 220 ; 
    	}
    }
    

    下面我们需要一个适配器,完成220V转5V的作用:

    package com.zhy.pattern.adapter;
    
    /**
     * 适配器,把220V电压变成5V
     * @author zhy
     *
     */
    public class V5PowerAdapter implements V5Power
    {
    	/**
    	 * 组合的方式
    	 */
    	private V220Power v220Power ;
    	
    	public V5PowerAdapter(V220Power v220Power)
    	{
    		this.v220Power = v220Power ;
    	}
    
    	@Override
    	public int provideV5Power()
    	{
    		int power = v220Power.provideV220Power() ;
    		//power经过各种操作-->5 
    		System.out.println("适配器:我悄悄的适配了电压。");
    		return 5 ; 
    	} 
    	
    }
    

    最后测试,我们给手机冲个电:

    package com.zhy.pattern.adapter;
    
    public class Test
    {
    	public static void main(String[] args)
    	{
    		Mobile mobile = new Mobile();
    		V5Power v5Power = new V5PowerAdapter(new V220Power()) ; 
    		mobile.inputPower(v5Power);
    	}
    }
    

    输出:

    现有类:我提供220V交流电压。
    适配器:我悄悄的适配了电压。
    手机(客户端):我需要5V电压充电,现在是-->5V
    

    可以看出,我们使用一个适配器完成了把220V转化了5V然后提供给手机使用,且我们使用了组合(OO设计原则),原有的手机,以及200V电压类都不需要变化,且手机(客户端)和220V(被适配者)完全解耦。

    最后画个uml类图,便于大家理解:


    上面是适配器的类图,下面是我们的例子的类图,咋样,还不错吧。没事画个图也不错,不然软件都白装了。。。。



    最后,恭喜你,你又学会了一个设计模式,适配器模式。持续求赞,求留言~




    展开全文
  • Java 设计模式 适配器模式

    千次阅读 2014-01-20 17:13:07
    当现有的某个类的接口不能满足客户所需要的接口,需要将这个类的接口转换为客户想要的接口,可以使用适配器模式。这相当于给接口做了一个适配,使这个接口可以在现有的模块内可以使用。  举一个简单的例子,我们...


            当现有的某个类的接口不能满足客户所需要的接口,需要将这个类的接口转换为客户想要的接口,可以使用适配器模式。这相当于给接口做了一个适配,使这个接口可以在现有的模块内可以使用。

           举一个简单的例子,我们国家家用电网提供的是220V交流电,对于台式机而言,主板需要12V直流电,当然不能直接拿交流电来使用啦。所以主机都有一个电源适配器,将220V 交流电 转换成 12V直流电。这个电源适配器就是从中间起到了一个转换的作用。

    看一下类图:

     

    package com.lou.adapter.instance;
    
    public interface AbstractComputerPower {
    
    	/*
    	 * 直流电电源 提供直流电
    	 */
    	public String provideDirectCurrent();
    }
    

     

    package com.lou.adapter.instance;
    
    public interface AbstractNationalPower {
    
    	/*
    	 * 国家电网提供交流电
    	 */
    	public String provideAlternatableCurrent();
    }
    

     

    package com.lou.adapter.instance;
    
    public class ComputerPowerAdapter implements AbstractComputerPower {
    
    	private AbstractNationalPower power = new ChinesePower();
    	@Override
    	public String provideDirectCurrent() {
    		
    		String nationalPower = power.provideAlternatableCurrent();
    		return transfer(nationalPower);
    	}
    
    	private String transfer(String nationalPower)
    	{
    		System.out.println( "对交流电整流,变压,输出直流电");
    		return "12V 直流电";
    	}
    }
    


     

    package com.lou.adapter.instance;
    
    public class Client {
    
    	public static void main(String[] args) {
    		AbstractComputerPower  computerPower = new ComputerPowerAdapter();
    		computerPower.provideDirectCurrent();
    	}
    }
    


     

    package com.lou.adapter.instance;
    
    public class ChinesePower implements AbstractNationalPower {
    
    	@Override
    	public String provideAlternatableCurrent() {
    		return "220V 交流电。";
    	}
    }
    


    综上,适配器模式是指:

             将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。——Gang of Four

    适配器的通用模型为:

     

     

     适配器模式最后真正完成业务的还是靠原来的接口,adapter从中间起到了转换,代理的作用。

     

    再举一个更实际的例子:

    在 项目中会涉及到查询用户信息的相关操作,在当前系统内,既有的底层提供的用户信息接口如下:

    package com.lou.patterns.adapter;
    
    public interface UserInfo {
    
    	public String getUserName();
    	
    	public String getUserId();
    	
    	public Integer getUserAge();
    	
    	public String getUserProvince();
    	
    	public String getUserCity();
    	
    	public String getUserStreet();
    	
    }
    

    当前系统内,用户查询接口 可以查询 用户名,用户id,年龄 ,用户所在的省份,所在的城市,所在的街道。

    但是现在系统的另外一个模块定义的用户查询 接口如下:

    package com.lou.patterns.adapter;
    
    public interface UserInformation {
    
    	public String getUserName();
    	
    	public String getUserId();
    	
    	public Integer getUserAge();
             //UserAddredss = province + city + street;	
             public String getUserAddress();
        
    }
    

    即:这个模块定义的用户查询接口应该为 查询用户名,用户id,用户年龄,用户的地址
    现在就会存在问题:因为这个模块定义的接口和底层定义的接口不兼容,无法将底层的UserInfo 实现类直接拿来使用,现在要在这两个接口之间架起一道桥梁,使我们可以是两个模块兼容起来,所以,我们构造一个适配器,这个适配器要能完成 UserInformation 定义的功能:

     

    package com.lou.patterns.adapter;
    
    public class UserInfoAdapter implements UserInformation{
    
    	private UserInfo userInfo;
    
    	@Override
    	public String getUserName() {
    		return userInfo.getUserName();
    	}
    
    	@Override
    	public String getUserId() {
    		return userInfo.getUserId();
    	}
    
    	@Override
    	public Integer getUserAge() {
    		return userInfo.getUserAge();
    	}
    
    	@Override
    	public String getUserAddress() {
    		return userInfo.getUserProvince()+" " + userInfo.getUserCity()+ " " +userInfo.getUserStreet();
    	}
    }
    


     

     

    package com.lou.patterns.adapter;
    
    public class UserInfoImpl implements UserInfo{
    
    	UserBean userBean = new UserBean();
    	@Override
    	public String getUserName() {
    		return userBean.getName();
    	}
    
    	@Override
    	public String getUserId() {
    		return userBean.getId();
    	}
    
    	@Override
    	public Integer getUserAge() {
    		return userBean.getAge();
    	}
    
    	@Override
    	public String getUserProvince() {
    		return userBean.getProvince();
    	}
    
    	@Override
    	public String getUserCity() {
    		return userBean.getCity();
    	}
    
    	@Override
    	public String getUserStreet() {
    		return userBean.getStreet();
    	}
    
    }
    


     

    package com.lou.patterns.adapter;
    
    public class UserBean {
    
    	private String name;
    	private String id;
    	private Integer age;
    	private String province;
    	private String city;
    	private String street;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public Integer getAge() {
    		return age;
    	}
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    	public String getProvince() {
    		return province;
    	}
    	public void setProvince(String province) {
    		this.province = province;
    	}
    	public String getCity() {
    		return city;
    	}
    	public void setCity(String city) {
    		this.city = city;
    	}
    	public String getStreet() {
    		return street;
    	}
    	public void setStreet(String street) {
    		this.street = street;
    	}
    }
    





    这样,两个模块就可以兼容起来使用了。

    总结:

    适配器模式在于,adaptee在系统中的不可代替性,一般为模块的底层或者是基础部分,当遇到不兼容的情况时,不方便或者对于当前系统稳定性和拓展性的考虑,应当遵循 “对修改关闭,对拓展开放”的原则,使用适配器模式可以很好地满足这一点。

    这里的适配器模式,有一定程度的代理模式的意味在里面,真正业务的实现偏重在adaptee实现,adapter再对其进行转换,满足另外一个模块的要求。

     

    个人观点,欢迎拍砖。

    展开全文
  • https://blog.csdn.net/qq_36982160/article/details/79965027
  • 结构设计模式 -适配器设计模式 ...1.1 双向适配器模式 1.2 适配器设计模式 - 类适配器 1.3 适配器设计模式 - 对象适配器实现 1.4 适配器设计模式类图 1.5 JDK 中的适配器设计模式示例 适配器设计模式 ...
  • 设计模式 | 适配器模式及典型应用

    万次阅读 多人点赞 2018-09-20 01:37:29
    适配器模式 适配器模式(Adapter Pattern):将一个接口转换成客户希望的另一个接口,使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。 在...
  • 本小节主要学习适配器模式适配器模式的简单介绍说到适配器(注意,不是适配器模式),相信大家应该不陌生吧,生活中我们经常需要用到适配器,比如说目前比较热门的安卓充电线的接头,之前主要一直都是micro
  • 常用设计模式-适配器模式

    万次阅读 2020-11-27 13:15:05
    这种类型的设计模式属于结构型模式。 优点:1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。 缺点:1、过多地使用适配器,会让系统非常零乱,不易整体进行把握...
  • 文章目录设计模式-适配器模式1. 类适配器模式代码实现类适配接口`Voltage5V`被适配的类`Voltage220V`适配器类`VoltageAdapter`Phone类Client类适配器模式细节2. 对象适配器模式代码实现适配器类`VoltageAdapter`...
  • 设计模式适配器模式

    千次阅读 多人点赞 2013-12-29 22:33:10
    适配器模式设计模式体系中属于结构型模式,可以分为三类:类的适配器模式、对象的适配器模式和接口的适配器模式,由于类和接口的适配器模式需要适配器继承原有的类,而纯面向对象语言Java、C#都是不支持多继承的,...
  • 超级链接: Java常用设计模式的实例学习系列-绪论 参考:《HeadFirst设计模式》 1.关于适配器模式 适配器模式是一种结构型模式。 适配器模式:将一个类的接口转换成客户期望的另一个接口。 下面以一张经典的图来描述...
  • 设计模式-适配器模式

    2016-01-31 02:01:22
    设计模式——适配器模式 适配器模式:在计算机编程中,适配器模式(有时候也称包装样式或者包装)将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起,...
  • 适配器设计模式分为: 类适配器 对象适配器 接口适配器适配器和对象适配器 应用场景:在需要使用A类中的方法时又需要使用B类中的一些功能。 public class Shipeier extends ShiperAdapter{ public static ...
  • Android当中的设计模式适配器Adapter

    千次阅读 2015-04-02 20:50:20
    适配器模式 Adapter(别名Wrapper)模式:将一个类的接口,转换成客户期望的另一个类的接口。适配器让原本接口不兼容的类可以合作无间。 要点: 1. 适配器模式主要应用于“希望复用一些现存的类,但是接口又与...
  • 设计模式——适配器模式

    千次阅读 2018-04-06 17:23:43
    适配器模式分为类适配器模式和对象适配器模式。类适配器模式采用继承的方式来实现,而对象适配器模式则是采用对象组合的方式来实现,开发过程中根据实际情况来进行选择。涉及到的角色:目标接口(Tar...
  • JAVA设计模式——适配器模式

    万次阅读 多人点赞 2018-01-18 16:28:30
    适配器模式是一种结构型设计模式适配器模式的思想是:把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。 用电器来打个比喻:有一个电器的插头是...
  • Java设计模式-适配器模式

    千次阅读 2019-03-26 14:46:47
    适配器模式
  • JAVA设计模式--适配器模式

    万次阅读 2016-08-28 20:42:19
    适配器(Adapter)模式又叫做包装( Wrapper )模式,是由GOF提出的23种设计模式中的一种结构型设计模式,Adapter模式的设计意图:将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作.....
  • 设计模式适配器模式(Adapter)

    千次阅读 2020-06-18 02:19:24
    设计模式适配器模式(Adapter)【设计模式适配器模式(Adapter)【设计模式适配器模式(Adapter)【设计模式适配器模式(Adapter)【设计模式适配器模式(Adapter)【设计模式适配器模式(Adapter) ...
  • 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同工作。 文章目录 适配器模式 类适配器 对象适配器 接口适配器 ...
  • Python设计模式适配器模式

    万次阅读 2019-12-29 15:11:42
    设计模式五:适配器模式 什么是适配器模式 实现两个不兼容接口之间的兼容 使用场景 某个产品已制造出来之后,需要应对新的需求,希望其仍然有效 不兼容接口是他方的或者是老旧的,无法访问其源码或者修改起来不切...
  • 设计模式——适配器模式和外观模式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,419
精华内容 42,967
关键字:

设计模式适配器模式