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

    2016-07-09 20:25:08
    适配器设计模式

    适配器设计模式:

    接口中定义好多方法,适配器类(抽象类)中覆写接口中的全部方法,适配器类(抽象类)的实现类只实现其中的几个方法。

    解决的问题:避免实现类实现接口中全部的方法。

    interface Window{
    public void open();
    public void close();
    public void activated();
    public void iconified();
    public void deiconified();
    }


    abstract class WindowAdapter implements Window{
    public void open(){}
    public void close(){}
    public void activated(){}
    public void iconified(){}
    public void deiconified(){}
    }


    class WindowImpl extends WindowAdapter{
    public void open(){
    System.out.println("窗口打开");
    }
    public void close(){
    System.out.println("窗口关闭");
    }
    }


    public class Test {


    public static void main(String[] args) {


    Window win = new WindowImpl();
    win.open();
    win.close();
    }


    }


    运行结果:

    窗口打开
    窗口关闭

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

    2015-07-28 16:35:23
    适配器 设计模式

    1. 概述

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

    2. 解决的问题

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

    3. 模式中的角色

      3.1 目标接口(Target):客户所期待的接口。目标可以是具体的或抽象的类,也可以是接口。

      3.2 需要适配的类(Adaptee):需要适配的类或适配者类。

      3.3 适配器(Adapter):通过包装一个需要适配的对象,把原接口转换成目标接口。  

    4. 模式解读

      注:在GoF的设计模式中,对适配器模式讲了两种类型,类适配器模式对象适配器模式。由于类适配器模式通过多重继承对一个接口与另一个接口进行匹配,而C#、java等语言都不支持多重继承,因而这里只是介绍对象适配器。

      4.1 适配器模式的类图

      

      4.2 适配器模式的代码实现

    复制代码
        /// <summary>
        /// 定义客户端期待的接口
        /// </summary>
        public class Target
        {
            /// <summary>
            /// 使用virtual修饰以便子类可以重写
            /// </summary>
            public virtual void Request()
            {
                Console.WriteLine("This is a common request");
            }
        }
    
        /// <summary>
        /// 定义需要适配的类
        /// </summary>
        public class Adaptee
        {
            public void SpecificRequest()
            {
                Console.WriteLine("This is a special request.");
            }
        }
    
        /// <summary>
        /// 定义适配器
        /// </summary>
        public class Adapter:Target
        {
            // 建立一个私有的Adeptee对象
            private Adaptee adaptee = new Adaptee();
    
            /// <summary>
            /// 通过重写,表面上调用Request()方法,变成了实际调用SpecificRequest()
            /// </summary>
            public override void Request()
            {
                adaptee.SpecificRequest();
            }
        }
    复制代码

      4.3 客户端代码

    复制代码
        class Program
        {
            static void Main(string[] args)
            {
                // 对客户端来说,调用的就是Target的Request()
                Target target = new Adapter();
                target.Request();
    
                Console.Read();
            }
        }
    复制代码

      运行结果

      

    5. 模式总结

      5.1 优点

        5.1.1 通过适配器,客户端可以调用同一接口,因而对客户端来说是透明的。这样做更简单、更直接、更紧凑。

        5.1.2 复用了现存的类,解决了现存类和复用环境要求不一致的问题。

        5.1.3 将目标类和适配者类解耦,通过引入一个适配器类重用现有的适配者类,而无需修改原有代码。

        5.1.4 一个对象适配器可以把多个不同的适配者类适配到同一个目标,也就是说,同一个适配器可以把适配者类和它的子类都适配到目标接口。

      5.2 缺点

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

      5.3 适用场景

        5.3.1 系统需要使用现有的类,而这些类的接口不符合系统的接口。

        5.3.2 想要建立一个可以重用的类,用于与一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作。

        5.3.3 两个类所做的事情相同或相似,但是具有不同接口的时候。

        5.3.4 旧的系统开发的类已经实现了一些功能,但是客户端却只能以另外接口的形式访问,但我们不希望手动更改原有类的时候。

        5.3.5 使用第三方组件,组件接口定义和自己定义的不同,不希望修改自己的接口,但是要使用第三方组件接口的功能。

    6. 适配器应用举例

      6.1 使用过ADO.NET的开发人员应该都用过DataAdapter,它就是用作DataSet和数据源之间的适配器。DataAdapter通过映射Fill和Update来提供这一适配器。

      6.2 手机电源适配器

    转载自:http://www.cnblogs.com/wangjq/archive/2012/07/09/2582485.html

    展开全文
  • 结构设计模式 -适配器设计模式 适配器设计模式是结构设计模式之一,其使用使得两个不相关的接口可以一起工作。连接这些不相关接口的对象称为适配器。 目录 1 适配器设计模式 1.1 双向适配器模式 1.2 ...

     

    结构设计模式 - 适配器设计模式

     

    适配器设计模式是结构设计模式之一,其使用使得两个不相关的接口可以一起工作。连接这些不相关接口的对象称为适配器。

     

     

    目录

    1 适配器设计模式
    1.1 双向适配器模式
    1.2 适配器设计模式 - 类适配器
    1.3 适配器设计模式 - 对象适配器实现
    1.4 适配器设计模式类图
    1.5 JDK 中的适配器设计模式示例

    适配器设计模式

    适配器设计模式,java 中的适配器设计模式,适配器模式,适配器模式 java 示例
    适配器设计模式的一个重要现实例子是移动充电器。移动电池需要 3 伏充电才能充电,但普通插座需要 120V(美国)或 240V(印度)。因此,移动充电器可作为移动充电插座和墙壁插座之间的适配器。

    我们将尝试使用本教程中的适配器设计模式实现多适配器。

    首先,我们将有两个类 - Volt(测量电压)和 Socket(产生 120V 的恒定电压)。

    package com.journaldev.design.adapter;
    
    public class Volt {
    
    	private int volts;
    	
    	public Volt(int v){
    		this.volts=v;
    	}
    
    	public int getVolts() {
    		return volts;
    	}
    
    	public void setVolts(int volts) {
    		this.volts = volts;
    	}
    	
    }
    
    package com.journaldev.design.adapter;
    
    public class Socket {
    
    	public Volt getVolt(){
    		return new Volt(120);
    	}
    }
    

    现在我们要构建一个可以产生 3 伏,12 伏和默认 120 伏的适配器。首先,我们将使用这些方法创建一个适配器接口。

    package com.journaldev.design.adapter;
    
    public interface SocketAdapter {
    
    	public Volt get120Volt();
    		
    	public Volt get12Volt();
    	
    	public Volt get3Volt();
    }
    

    双向适配器模式

    在实现 Adapter 模式时,有两种方法 - 类适配器和对象适配器 - 但是这两种方法都产生相同的结果。

    类适配器 - 此表单使用 java 继承并扩展源接口,在我们的示例中为 Socket 类。
    对象适配器 - 此表单使用 Java Composition,而适配器包含源对象。
    适配器设计模式 - 类适配器
    这是我们的适配器的类适配器方法实现。

    package com.journaldev.design.adapter;
    
    //Using inheritance for adapter pattern
    public class SocketClassAdapterImpl extends Socket implements SocketAdapter{
    
    	@Override
    	public Volt get120Volt() {
    		return getVolt();
    	}
    
    	@Override
    	public Volt get12Volt() {
    		Volt v= getVolt();
    		return convertVolt(v,10);
    	}
    
    	@Override
    	public Volt get3Volt() {
    		Volt v= getVolt();
    		return convertVolt(v,40);
    	}
    	
    	private Volt convertVolt(Volt v, int i) {
    		return new Volt(v.getVolts()/i);
    	}
    
    }
    

    适配器设计模式 - 对象适配器实现

    这是我们的适配器的 Object 适配器实现。

    package com.journaldev.design.adapter;
    
    public class SocketObjectAdapterImpl implements SocketAdapter{
    
    	//Using Composition for adapter pattern
    	private Socket sock = new Socket();
    	
    	@Override
    	public Volt get120Volt() {
    		return sock.getVolt();
    	}
    
    	@Override
    	public Volt get12Volt() {
    		Volt v= sock.getVolt();
    		return convertVolt(v,10);
    	}
    
    	@Override
    	public Volt get3Volt() {
    		Volt v= sock.getVolt();
    		return convertVolt(v,40);
    	}
    	
    	private Volt convertVolt(Volt v, int i) {
    		return new Volt(v.getVolts()/i);
    	}
    }
    

    请注意,两个适配器实现几乎相同,并且它们实现了 SocketAdapter 接口。适配器接口也可以是抽象类。
    这是一个使用我们的适配器设计模式实现的测试程序。

    package com.journaldev.design.test;
    
    import com.journaldev.design.adapter.SocketAdapter;
    import com.journaldev.design.adapter.SocketClassAdapterImpl;
    import com.journaldev.design.adapter.SocketObjectAdapterImpl;
    import com.journaldev.design.adapter.Volt;
    
    public class AdapterPatternTest {
    
    	public static void main(String[] args) {
    		
    		testClassAdapter();
    		testObjectAdapter();
    	}
    
    	private static void testObjectAdapter() {
    		SocketAdapter sockAdapter = new SocketObjectAdapterImpl();
    		Volt v3 = getVolt(sockAdapter,3);
    		Volt v12 = getVolt(sockAdapter,12);
    		Volt v120 = getVolt(sockAdapter,120);
    		System.out.println("v3 volts using Object Adapter="+v3.getVolts());
    		System.out.println("v12 volts using Object Adapter="+v12.getVolts());
    		System.out.println("v120 volts using Object Adapter="+v120.getVolts());
    	}
    
    	private static void testClassAdapter() {
    		SocketAdapter sockAdapter = new SocketClassAdapterImpl();
    		Volt v3 = getVolt(sockAdapter,3);
    		Volt v12 = getVolt(sockAdapter,12);
    		Volt v120 = getVolt(sockAdapter,120);
    		System.out.println("v3 volts using Class Adapter="+v3.getVolts());
    		System.out.println("v12 volts using Class Adapter="+v12.getVolts());
    		System.out.println("v120 volts using Class Adapter="+v120.getVolts());
    	}
    	
    	private static Volt getVolt(SocketAdapter sockAdapter, int i) {
    		switch (i){
    		case 3: return sockAdapter.get3Volt();
    		case 12: return sockAdapter.get12Volt();
    		case 120: return sockAdapter.get120Volt();
    		default: return sockAdapter.get120Volt();
    		}
    	}
    }
    

    当我们运行上面的测试程序时,我们得到以下输出。

    v3 volts using Class Adapter=3
    v12 volts using Class Adapter=12
    v120 volts using Class Adapter=120
    v3 volts using Object Adapter=3
    v12 volts using Object Adapter=12
    v120 volts using Object Adapter=120
    

    适配器设计模式类图

    适配器模式类图,适配器设计模式,适配器模式,java 中的适配器设计模式

    JDK 中的适配器设计模式示例
    我可以在 JDK 类中轻松找到的一些适配器设计模式示例;

    java.util.Arrays 中#asList()
    java.io.InputStreamReader(InputStream)(返回一个 Reader)
    java.io.OutputStreamWriter(OutputStream)(返回一个 Writer)
    这就是 java 中适配器设计模式的全部内容。

    转载来源:https://www.journaldev.com/1487/adapter-design-pattern-java

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

    适配器模式从实现方式上分为两种,类适配器和对象适配器,这两种的区别在于实现方式上的不同,一种采用继承,一种采用组合的方式。

    另外从使用目的上来说,也可以分为两种,特殊适配器和缺省适配器,这两种的区别在于使用目的上的不同,一种为了复用原有的代码并适配当前的接口,一种为了提供缺省的实现,避免子类需要实现不该实现的方法。

    类适配器和对象适配器的权衡

    ● 类适配器使用对象继承的方式,是静态的定义方式;而对象适配器使用对象组合的方式,是动态组合的方式。  
    ● 对于类适配器,由于适配器直接继承了Adapter,使得适配器不能和Adapter的子类一起工作,因为继承是静态的关系,当适配器继承了Adapter后,就不可能再去处理Adapter的子类了。  
    ● 对于对象适配器,一个适配器可以把多种不同的源适配到同一个目标。换言之,同一个适配器可以把源类和它的子类都适配到目标接口。因为对象适配器采用的是对象组合的关系,只要对象类型正确,是不是子类都无所谓。  
    ● 对于类适配器,适配器可以重定义Adapter的部分行为,相当于子类覆盖父类的部分实现方法。  
    ● 对于对象适配器,要重定义Adapter的行为比较困难,这种情况下,需要定义Adapter的子类来实现重定义,然后让适配器组合子类。虽然重定义Adapter的行为比较困难,但是想要增加一些新的行为则方便的很,而且新增加的行为可同时适用于所有的源。  
    ● 对于类适配器,仅仅引入了一个对象,并不需要额外的引用来间接得到Adapter。对于对象适配器,需要额外的引用来间接得到Adapter。

    建议尽量使用对象适配器的实现方式,多用合成/聚合、少用继承。当然,具体问题具体分析,根据需要来选用实现方式,最适合的才是最好的。

    下面举几个例子

    类适配器

    有一个已经存在的接口

    package com.zndroid.dm.AdapterModel.ExtendsAdapter;
    
    /**
     * Created by luzhenyu on 2017/7/27.
     */
    
    public interface IStationary {
    
        void doSome();
    }

    有一个已经存在的具体的实例

    package com.zndroid.dm.AdapterModel.ExtendsAdapter;
    
    /**
     * Created by luzhenyu on 2017/7/27.
     */
    
    public class Stationary {
    
        public void disPlay() {
            System.out.println("stationary display");
        }
    }

    为了既使用该接口又复用原来的实例实现的方式就是类适配器方式
    package com.zndroid.dm.AdapterModel.ExtendsAdapter;
    
    
    /**
     * Created by luzhenyu on 2017/7/27.
     * 我们需要得到一个接口的类,但是又想用原有的类的功能,但是我们又改不了这个原来的类的代码,
     * 或者原来的类有一个完整的类体系,我们不希望破坏它,那么适配器模式就是你的不二之选了
     *
     * 本案例是类适配器,就是通过继承我们希望复用其功能的类,并且实现我们想适配的接口。(一般是针对适配目标是接口的情况下使用)
     * 由于Java单继承的关系所以引入了另外一个适配器 - 对象适配器(采用组合的方式实现)
     */
    
    //在保证不改变Stationary 和 IStationary代码的情况下  重新创建的这个类就是适配器,他同时拥有接口和父类的功能
    public class MixtureAdapter extends Stationary implements IStationary {
    
        @Override
        public void doSome() {
            System.out.println("mixtureAdapter doSome");
        }
    
        @Override
        public void disPlay() {
            super.disPlay();
            System.out.println("mixtureAdapter display");
        }
    }

    具体使用:

    MixtureAdapter mixtureAdapter = new MixtureAdapter();
    mixtureAdapter.doSome();
    mixtureAdapter.disPlay();

    对象适配器

    我有一个已经继承其他对象的实例

    package com.zndroid.dm.AdapterModel.ObjectAdapter.impl;
    
    import com.zndroid.dm.AdapterModel.ObjectAdapter.BaseModel;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     */
    
    public class User extends BaseModel {
    
        private String name;
        private String age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    }
    
    package com.zndroid.dm.AdapterModel.ObjectAdapter;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     */
    
    public class BaseModel {
    
        private int id;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    }
    我又有了一个已经实现好功能的其他对象

    package com.zndroid.dm.AdapterModel.ObjectAdapter;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     */
    
    public class OtherClass {
        private boolean isDubug = true;
    
        public void otherFun(String msg){ System.out.println("OtherClass - otherFun:" + msg);}
    
        public void setSome(boolean isDubug){
            System.out.println("OtherClass - setSome:" + isDubug);
            this.isDubug = isDubug;}
    }
    我为了能够复用这两个已经存在的类,因为不能多继承,所以采用对象适配器模式,即组合已有功能的引用

    package com.zndroid.dm.AdapterModel.ObjectAdapter;
    
    import com.zndroid.dm.AdapterModel.ObjectAdapter.impl.User;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     *
     * 针对适配目标是类或者是需要复用的对象多于一个的时候使用,
     * 这里再专门提示一下,对象适配器有时候是为了将多个类一起适配,所以才不得不使用组合的方式,而且我们采用对象适配器的时候,继承也不是必须的,
     * 而是根据实际的类之间的关系来进行处理,上述例子当中一定要直接或间接的继承自BaseEntity是为了不破坏我们原来的继承体系,但有些情况下这并不是必须的。
     */
    
    public class OtherClassUserAdapter extends User {
        private OtherClass otherClass = new OtherClass();//让OtherClassUserAdapter同时拥有User特性和OtherClass特性
    
        public void otherFun(String msg){
            otherClass.otherFun(msg);
        }
    
        public void setSome(boolean isDubug){
            otherClass.setSome(isDubug);
        }
    
    }
    具体使用:

    /**
     * (对象适配器)
     * 与类的适配器模式一样,对象的适配器模式把被适配的类的API转换成为目标类的API,
     * 与类的适配器模式不同的是,对象的适配器模式不是使用继承关系连接到Adapter类,而是使用委派关系连接到Adapter类。
     * */
     OtherClassUserAdapter otherClassUserAdapter = new OtherClassUserAdapter();
     otherClassUserAdapter.setAge("25");
     log(otherClassUserAdapter.getAge());
     otherClassUserAdapter.otherFun("OtherClassUserAdapter invoking OtherClass's function");
     otherClassUserAdapter.setSome(false);

    缺省适配器

    对于某个接口有很多行为,然而我们要适配的对象并不是都关系其中的行为,有可能只是使用其中的一或者两个行为,为了适配这种情况我们采用缺省适配器模式,即改缺省的适配器实现了接口的所有默认行为,对于将来要适配的对象只需要挑自己关心的方法进行复写就行了。

    我有一个已经存在的接口,里面有好几种行为:

    package com.zndroid.dm.AdapterModel.DefaultAdapter;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     */
    
    public interface ICommon {
        void speck();
        void eat();
        boolean drink();
        void work(String area);
    }
    但是接下来想复用该接口并扩展的对象并不都是关心接口里面所有的行为,所以采用一个默认的适配器去实现该接口的所有默认行为:

    package com.zndroid.dm.AdapterModel.DefaultAdapter;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     * 接口设计的最小化只是理想状态,难免会有一些实现类,对其中某些方法不感兴趣,
     * 这时候,如果方法过多,子类也很多,并且子类的大部分方法都是空着的,那么就可以采取这种方式了。
     *
     * 当然,这样做违背了里氏替换原则,但是上面的做法原本就违背了接口的最小化原则,所以我们在真正使用时要权衡二者的利弊,
     * 到底我们需要的是什么。所以从此也可以看出来,原则只是指导,并不一定也不可能全部满足,所以我们一定要学会取舍。
     */
    
    public class DefaultAdapter implements ICommon {
        @Override
        public void speck() {
            System.out.println("DefaultAdapter: " + "speck");
        }
    
        @Override
        public void eat() {
            System.out.println("DefaultAdapter: " + "eat");
        }
    
        @Override
        public boolean drink() {
            System.out.println("DefaultAdapter: " + "drink");
            return false;
        }
    
        @Override
        public void work(String area) {
            System.out.println("DefaultAdapter: " + "work at " + area);
        }
    }
    接下来就是要适配的对象1

    package com.zndroid.dm.AdapterModel.DefaultAdapter.impl;
    
    import com.zndroid.dm.AdapterModel.DefaultAdapter.DefaultAdapter;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     * 去实现我关心的方法,其他不关心
     */
    
    public class DefaultAdapterImpl1 extends DefaultAdapter {
        @Override
        public void speck() {
            System.out.println("DefaultAdapterImpl1: " + "speck");
        }
    
        @Override
        public void eat() {
            System.out.println("DefaultAdapterImpl1: " + "eat");
        }
    
        @Override
        public boolean drink() {
            System.out.println("DefaultAdapterImpl1: " + "drink");
            return true;
        }
    }
    要适配的对象2

    package com.zndroid.dm.AdapterModel.DefaultAdapter.impl;
    
    import com.zndroid.dm.AdapterModel.DefaultAdapter.DefaultAdapter;
    
    /**
     * Created by luzhenyu on 2017/8/4.
     */
    
    public class DefaultAdapterImpl2 extends DefaultAdapter {
    
        @Override
        public void eat() {
            System.out.println("DefaultAdapterImpl2: " + "eat");
        }
    
        @Override
        public boolean drink() {
            System.out.println("DefaultAdapterImpl2: " + "drink");
            return false;
        }
    
        @Override
        public void work(String area) {
            System.out.println("DefaultAdapterImpl2: " + "work at " + area);
        }
    }
    具体使用:

    /**
     * (缺省适配器)
     * 用于接口定义过多,然而实现者不需要关系接口中的某些方法,从中抽取缺省的适配器去实现接口的所有方法,真正实现者继承该
     * 缺省适配器去复写自己关心的方法就行了。
     * */
     DefaultAdapterImpl1 defaultAdapterImpl1 = new DefaultAdapterImpl1();
     defaultAdapterImpl1.drink();
     defaultAdapterImpl1.eat();
     defaultAdapterImpl1.speck();
     defaultAdapterImpl1.work("shanghai");
     
     DefaultAdapterImpl2 defaultAdapterImpl2 = new DefaultAdapterImpl2();
     defaultAdapterImpl2.drink();
     defaultAdapterImpl2.eat();
     defaultAdapterImpl2.speck();
     defaultAdapterImpl2.work("suzhou");
     log("----------------我是分割线-----------------");


    【欢迎上码】

    【微信公众号搜索 h2o2s2】


    展开全文
  • 适配器设计模式消息经纪人 适配器设计模式-使用RabbitMQ本地测试服务总线 消息经纪人-简介 RabbitMQ入门 Azure服务总线-入门
  • 适配器设计模式是一种结构设计模式 ,可以帮助我们连接到通过不同接口公开相似功能的旧版或第三方代码。 适配器的现实世界是我们用来将USB电缆连接到以太网端口的类比。 在设计一个面向对象的应用程序时,当...
  • 这几天一直在学习设计模式,今天我们来说说适配器设计模式吧 适配器模式 在接口类型设计模式中定义的有一个适配器模式,关于适配器模式的学习中主要围绕以下几个问题展开: 1. 什么是适配器模式? 2. 适配器模式...
  • 适配器设计模式1.1 场景1.2 类适配器模式1.3 对象适配器模式1.4 接口适配器模式1.5 SpringMVC中适配器设计1.6 适配器模式的注意事项和细节 1.适配器设计模式 基本介绍 适配器模式(AdapterPattern)将某个类的接口...
  • Java设计模式:适配器设计模式 主要的作用是: 由于接口不兼容而不能一起工作的类可以一起工作 大致分为两种: 1. 类适配器/对象适配器 2. 缺省适配器 一、类适配器/对象适配器 &amp;nbsp; &amp;nbsp;&...
  • 适配器设计模式分为: 类适配器 对象适配器 接口适配器 类适配器和对象适配器 应用场景:在需要使用A类中的方法时又需要使用B类中的一些功能。 public class Shipeier extends ShiperAdapter{ public static ...
  • 适配器设计模式ppt

    2009-04-19 18:43:03
    Head.First设计模式-适配器设计模式
  • 设计模式---适配器设计模式   什么事适配器: 1. 在使用监听的时候,需要定义一个类事件监听器接口 2. 通常接口中有多个方法,而程序中不一定所有的方法都用到,但又必须重写,很繁琐 3. 适配器简化了这些操作...
  • 文章目录一、适配器模式1.基本介绍2.工作原理二、类适配器模式1.类适配器模式介绍2. 类适配器模式应用实例3.代码三、对象适配器模式1.对象适配器模式应用实例2.代码适配接口被适配类对象适配器手机实体调用3.对象...
  • java设计模式之适配器设计模式 1,为什么有适配器(根本原因:事情不是一个独立单元做的) 假如在现实社会中你是一个工人,需要做一个鼠标,然后你又需要做一个主板,这个时候如果需要再做个鼠标与主板的适配接口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,739
精华内容 8,295
关键字:

适配器设计模式