菜单

适配器模式(Adapter Pattern)

2018年11月15日 - jQuery

适配器模式(Adapter Pattern) 是作为少数单不匹配的接口之间的桥梁。

适配器模式:将一个类的接口转换成客户要之另外一个接口,使得本由接口互相不兼容而非克一起坐班的类可一并干活。

事例:读卡器是当做内存卡和笔记本中的凡适配器,内存卡插入读卡器,读卡器再插入笔记本电脑。

 有一个鸭接口:

manbetx2.0手机版参考资料:http://www.runoob.com/design-pattern/adapter-pattern.html 、[Java设计模式之《适配器模式》及应用场景

public interface Duck {
    public void quack();
    public void fly();
}

绿头鸭是鸭子的子类:

意:将一个好像的接口转换成为客户愿意的外一个接口。适配器模式让原本由接口不般配而未可知共同工作之那些看似可共同坐班。

public class MallardDuck implements Duck {
    public void quack() {
        System.out.println("Quack");
     }

    public void fly() {
        System.out.println("I'm flying");
    }
}

何时使用:1.只要利用都有的一个看似的方法,但是不入我们的利用正式,且我们不懂得那源码,无法copy。2。建立一个重复使用的切近,用于联系一些彼此之间没有最好可怜关系的接近。3.通过接口的更换,将一个看似插入到另外一个像样中。

出一个火鸡接口,不见面帅,只见面咯咯叫,与鸭子的例外,没有quack(),而是gobble():

如何促成:继承或因。适配器继承或因就有的代码,实现目标类的接口。

public interface Turkey {
    public void gobble();
    public void fly();
}

注意事项:适配器不是以事无巨细规划时增长的,而是解决在服役的种的问题。

一个野生的火鸡,实现火鸡接口:

适配器有星星点点栽模式:这有限种植的区别在一个凡随后承源角色类,一个是获取源角色类的靶子。

public class WildTurkey implements Turkey {
    public void gobble() {
        System.out.println("Gobble gobble");
    }
    public void fly() {
        System.out.println("I'm flying a short distance");
     }
}

  类适配器模式:(继承源角色)

哪些用火鸡冒充鸭子要客户无懂得吗?

  对象适配器模式:(获取源角色对象)

我们刻画个适配器,实现鸭子的接口,实际上她用的是火鸡

差别:1.类适配器的话,因为是连续了源角色类的干,所以无可知去处理源角色类的子类。而目标适配器则没有关联,一个适配器可以拿其源类和其子类都适配到目标接口。

public class TurkeyAdapter implements Duck {
    Turkey turkey;
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }
    public void quack() {
        turkey.gobble();
    }
    public void () {
        turkey.fly();
    }
}

   
 2.类适配器可以重定义源角色类的章程,通过重写方法即可。而目标适配器的说话才能够通过适配器子类的道来达成重写源角色类的计

适配器传入一个火鸡实例,调用quack方法时,实际是调整用gobble方法。

代码实现:类适配器模式

 

1 /**
2  * 目标角色
3  */
4 public interface Target {
5     //已有的方法
6     void sampleOp1();
7     //没有但是想要实现的方法
8     void sampleOp2();
9 }

1 /**
2  * 源角色
3  */
4 public class Adaptee {
5     
6     public void sampleOp1(){
7         System.out.println("sampleOp1...");
8     }
9 }

 1 /**
 2  * 适配器角色
 3  */
 4 public class Adapter extends Adaptee implements Target {
 5 
 6     @Override
 7     public void sampleOp2() {
 8         System.out.println("sampleOp2....");
 9     }
10 }

   //测试

   @Test
    public void test()throws Exception{
        Target target = new Adapter();
        target.sampleOp1();
        target.sampleOp2();
    }
/*
*输出
*sampleOp1...
*sampleOp2....
*/
public DuckTest {
       public static void main(String[] args) {
            MallarDuck duck = new MallarDuck();

            WildTurkey turkey = new WildTurkey();
            Duck turkeyAdapter = new TurkeyAdapter(turkey);

            duck.quack();
            duck.fly();

            turkeyAdapter.quack();   
            turkeyAdapter.fly();
       }
}

代码实现:对象适配器模式

经过适配器,火鸡成功冒充了鸭子,对客户的话无异调用了鸭子的quack和fly方法,gobble方法对客户不可见。

 1 /**
 2  * 目标角色
 3  */
 4 public interface Target {
 5     //已有的方法
 6     void sampleOp1();
 7     //没有但是想要实现的方法
 8     void sampleOp2();
 9 }
10 
11 
12 /**
13  * 源角色
14  */
15 public class Adaptee {
16     public void sampleOp1(){
17         System.out.println("sampleOp1...");
18     }
19 }
20 
21 
22 /**
23  * 适配器角色
24  */
25 public class Adapter implements Target{
26     private Adaptee adaptee;
27 
28     public Adapter(Adaptee adaptee) {
29         this.adaptee = adaptee;
30     }
31 
32     @Override
33     public void sampleOp1() {
34         this.adaptee.sampleOp1();
35     }
36 
37     @Override
38     public void sampleOp2() {
39         System.out.println("sampleOp2....");
40     }
41 }

//测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class AdapterTest {

    @Test
    public void test()throws Exception{
        Target adapter = new Adapter(new Adaptee());
        adapter.sampleOp1();
        adapter.sampleOp2();
    }
}

/*
*sampleOp1...
*sampleOp2....
*/

这种适配器称为对象适配器。

除去,适配器模式还有一样种下。缺省模式 

manbetx2.0手机版 1

使用场景:我们若实现一个接口,但是于该接口的恢宏主意中,我们才想只要中的个别一两单。

鸭子接口相当给Target,TurkeyAdapter相当于Adapter,Turkey相当给Adaptee。

    在接口的实现着,必须使用那具备的主意进行重写。所以会以代码内发恢宏底空缺省的章程,造成类似的叠。

 

适配器的缺省模式:一个架空的适配器角色实现该接口。

若果我们无Duck接口,只有MallardDuck类,那么将Adapter继承MallardDuck类,其他还是一样的,这就是改成了近乎适配器。

          目标角色继续该抽象类。只需要实现协调想使之办法即可。

假定我们的Duck接口含有fly方法是Turkey没有底,我们无思再也写这主意,那么尽管写一个虚无的Adapter,Turkey继承这Adapter,那便光需要更写quck方法,这就是是接口适配器。

代码实现:

 

 1 /**
 2  * 一个和尚应该要做的事情
 3  */
 4 public interface Bonze {
 5     void chiZhai();
 6     void nianFo();
 7     void daZuo();
 8     void saoDi();
 9     void xiWu();
10     void zhuangZhong();
11     String getName();
12 }
13 
14 
15 
16 /**
17  * 适配器
18  */
19 public abstract class TianStar implements Bonze {
20     @Override
21     public void chiZhai() {
22 
23     }
24 
25     @Override
26     public void nianFo() {
27 
28     }
29 
30     @Override
31     public void daZuo() {
32 
33     }
34 
35     @Override
36     public void saoDi() {
37 
38     }
39 
40     @Override
41     public void xiWu() {
42 
43     }
44 
45     @Override
46     public void zhuangZhong() {
47 
48     }
49 
50     @Override
51     public String getName() {
52         return null;
53     }
54 }
55 
56 
57 
58 /**
59  * 目标角色
60  */
61 public class LuZhiShen extends TianStar {
62     @Override
63     public void xiWu() {
64         System.out.println("" +
65                 "        拳打镇关西;\n" +
66                 "        大闹五台山;\n" +
67                 "        大闹桃花村;\n" +
68                 "        火烧瓦官寺;\n" +
69                 "        倒拔垂杨柳;");
70     }
71 
72     @Override
73     public String getName() {
74         return "鲁智深在此";
75     }
76 }
77 
78 
79 @RunWith(SpringRunner.class)
80 @SpringBootTest
81 public class LuZhiShenTest {
82 
83     @Test
84     public void test()throws Exception{
85         Bonze bonze = new LuZhiShen();
86         bonze.xiWu();
87         System.out.println(bonze.getName());
88     }
89 }
90 
91 /*
92 *        拳打镇关西;
93 *        大闹五台山;
94 *        大闹桃花村;
95 *        火烧瓦官寺;
96 *        倒拔垂杨柳;
97 *鲁智深在此
98 */

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图