频道栏目
首页 > 程序开发 > 软件开发 > Java > 正文
Java设计模式之结构型适配器模式详解
2017-12-27 11:12:43         来源:pinqiang的博客  
收藏   我要投稿

适配器模式是各种模式的起源

适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。

核心思想就是:有一个Source类,拥有一个方法,待适配,目标接口是Targetable,通过Adapter类,将Source的功能扩展到Targetable里。

1、适配器模式分类:

a.类的适配器模式.

b.对象的适配器模式.

c.接口的适配器模式。

2、类的适配器模式,代码演示:

a.Source类
        public class Source {  
            public void method1() {  
                System.out.println("this is original method!");  
            }  
        } 
b.目标接口Targetable
        public interface Targetable {  
            /* 与原类中的方法相同 */  
            public void method1();  

            /* 新类的方法 */  
            public void method2();  
        } 
c.类适配器
        //继承了Source,实现新接口,这样我们就可以用这个类既可以访问之前的method1,也可以访问新类的method2了
        public class Adapter extends Source implements Targetable {  
            @Override  
            public void method2() {  
                System.out.println("this is the targetable method!");  
            }
        }
d.测试类
        public class AdapterTest {  
            public static void main(String[] args) {  
                Targetable target = new Adapter();  
                target.method1();  
                target.method2();  
            }  
        }     
    结果:
    this is original method!
    this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能。   

3、对象的适配器模式,代码演示:

基本思路和类的适配器模式相同,只是将Adapter类作修改,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。
     a.Source类
        public class Source {  
            public void method1() {  
                System.out.println("this is original method!");  
            }  
        } 

    b.目标接口Targetable
        public interface Targetable {  
            /* 与原类中的方法相同 */  
            public void method1();  

            /* 新类的方法 */  
            public void method2();  
        } 

    上面2个和之前一样

    c.对象适配器
        public class Adapter implements Targetable {  

            private Source source;  
            public Adapter(Source source){  
                super();  
                this.source = source;  
            }  

            @Override  
            public void method2() {  
                System.out.println("this is the targetable method!");  
            }  

            @Override  
            public void method1() {  
                source.method1(); //调用传进来的类的方法
            }  
        }

    d.测试类
        public class AdapterTest {  

            public static void main(String[] args) {  
                Source source = new Source();  
                Targetable target = new Adapter(source);  
                target.method1();  
                target.method2();  
            }  
        }  

        结果:
        this is original method!
        this is the targetable method!

    和上面的功能一样,只是把需要适配的对象传进来了,没有使用继承的方式。

4、接口的适配器模式,代码演示:(比较重要)

有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些。
为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系。
我们写一个类,继承该抽象类,重写我们需要的方法就行
    a.接口Sourceable
        public interface Sourceable {  
            public void method1();  
            public void method2();  
        }

    b.抽象类Wrapper2
        目的就是实现所有的接口,但是方法都是空的,为的就是给其他的类继承
        public abstract class Wrapper2 implements Sourceable{  
            public void method1(){}  
            public void method2(){}  
        } 

    c.继承抽象类的类(重写我们需要的方法)
        public class SourceSub1 extends Wrapper2 {  
            public void method1(){  
                System.out.println("the sourceable interface's first Sub1!");  
            }  
        } 

        public class SourceSub2 extends Wrapper2 {  
            public void method2(){  
                System.out.println("the sourceable interface's second Sub2!");  
            }  
        } 

    d.测试
        public class WrapperTest {  
            public static void main(String[] args) {  
                Sourceable source1 = new SourceSub1();  
                Sourceable source2 = new SourceSub2();  

                source1.method1();  
                source1.method2();//没有重写这个方法,默认调了父类的method2空方法
                source2.method1();//没有重写这个方法,默认调了父类的method1空方法
                source2.method2();  
            }  
        } 
    输出:
    the sourceable interface's first Sub1!
    the sourceable interface's second Sub2!    

5、三种适配器模式的应用场景

类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。

对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。

接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。
点击复制链接 与好友分享!回本站首页
上一篇:在Eclipse 中配置JavaFX过程
下一篇:一切都是对象及java独立运行
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站