java设计模式

                                                                                     java常用设计模式理解

一：什么是设计模式

 设计模式是针对问题的解决方案，是套被反复使用、多数人知晓的、经过分类编目 的代码设计经验的总结。

二：设计模式的作用

 a：可以把它应用到特定的应用中，用于解决相似的问题

 b：为了可重用代码、让代码更容易被他人理解、保证代码可靠性

 c: 逼格高，使代码看起来就高大上。

三：设计模式的六个原则

① 开闭原则
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们就需要使用接口和抽象类，。

② 里氏代换原则
里氏代换原则（LSP）面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。

废话这么多，实际的理解就是：子类对象能够替换父类对象，而程序逻辑不变。也就是说共享的父类方法就应该保持不变，不能被子类重新定义。也就是说子类不要随便去重写父类的方法。

那么问题来了，如何理解多态，多态跟LSP是否相互矛盾。（这个问题这里不讨论，可以自己看一下）

多态的前提就是子类覆盖并重新定义父类的方法，为了符合LSP，我们应该将父类定义为抽象类，并定义抽象方法，让子类重新定义这些方法，当父类是抽象类时，父类就是不能实例化，所以也不存在可实例化的父类对象在程序里。也就不存在子类替换父类实例时逻辑不一致的可能。

不符合LSP的最常见的情况是，父类和子类都是可实例化的非抽象类，且父类的方法被子类重新定义，这一类的实现继承会造成父类和子类间的强耦合，也就是实际上并不相关的属性和方法牵强附会在一起，不利于程序扩展和维护。

③依赖倒转原则
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

④接口隔离原则

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以要：降低依赖，降低耦合。

⑤迪米特法则（最少知道原则）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

⑥合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用继承。

四：设计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

五：常用的设计模式

1：单例模式（转载出处：http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html）

第一种（懒汉，线程不安全）：

 1  public   class  Singleton {  
 2       private   static  Singleton instance;  
 3      private Singleton (){}   
 4       public   static  Singleton getInstance() {  
 5       if  (instance  ==   null ) {  
 6          instance  =   new  Singleton();  
 7      }  
 8       return  instance;  
 9      }  
10  }  
11 

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。

第二种（懒汉，线程安全）：

 1  public   class  Singleton {  
 2       private   static  Singleton instance;  
 3      private Singleton (){}
 4       public   static   synchronized  Singleton getInstance() {  
 5       if  (instance  ==   null ) {  
 6          instance  =   new  Singleton();  
 7      }  
 8       return  instance;  
 9      }  
10  }  
11 

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

第三种（饿汉）：

1  public   class  Singleton {  
2       private   static  Singleton instance  =   new  Singleton();  
3      private Singleton (){}
4       public   static  Singleton getInstance() {  
5       return  instance;  
6      }  
7  }  
8 

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

第四种（饿汉，变种）：

 1  public   class  Singleton {  
 2       private  Singleton instance  =   null ;  
 3       static  {  
 4      instance  =   new  Singleton();  
 5      }  
 6      private Singleton (){}
 7       public   static  Singleton getInstance() {  
 8       return   this .instance;  
 9      }  
10  }  
11 

表面上看起来差别挺大，其实更第三种方式差不多，都是在类初始化即实例化instance。

2：工厂模式

工厂模式从上到下逐步抽象，大概可以分三类：

1）简单工厂模式：不利于产生系列产品；

2）工厂方法模式：又称为多形性工厂；

3）抽象工厂模式：又称为工具箱，产生产品族，但不利于产生新的产品；

简单工厂模式又称静态工厂方法模式，它的组成：

a:工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
b: 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
c: 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
        

看UML关系图就可以看出，简单工厂模式就是建立一个工厂类，对实现了抽象方法的同一接口的一些类进行实例的创建。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。这个比较好理解，具体事例代码如下：（事例来自：http://www.cnblogs.com/zhangchenliang/p/3700820.html）

1. //抽象产品  
2. abstract class Car{  
3.     private String name;  
4.       
5.     public abstract void drive();  
6.       
7.     public String getName() {  
8.         return name;  
9.     }  
10.     public void setName(String name) {  
11.         this.name = name;  
12.     }  
13. }  
14. //具体产品  
15. class Benz extends Car{  
16.     public void drive(){  
17.         System.out.println(this.getName()+"----go-----------------------");  
18.     }  
19. }  
20.   
21. class Bmw extends Car{  
22.     public void drive(){  
23.         System.out.println(this.getName()+"----go-----------------------");  
24.     }  
25. }  
26.   
27. //简单工厂  
28. class Driver{  
29.     public static Car createCar(String car){  
30.         Car c = null;  
31.         if("Benz".equalsIgnoreCase(car))  
32.             c = new Benz();  
33.         else if("Bmw".equalsIgnoreCase(car))  
34.             c = new Bmw();  
35.         return c;  
36.     }  
37. }  
38.   
39. //老板  
40. public class BossSimplyFactory {  
41.   
42.     public static void main(String[] args) throws IOException {  
43.         //老板告诉司机我今天坐奔驰  
44.         Car car = Driver.createCar("benz");  
45.         car.setName("benz");  
46.          //司机开着奔驰出发  
47.         car.drive();  
48.     }  

工厂方法模式：是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

来看下它的组成：

a:抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
b:具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
c:抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
d:具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

事例代码：

1. //抽象产品  
2. abstract class Car{  
3.     private String name;  
4.       
5.     public abstract void drive();  
6.       
7.     public String getName() {  
8.         return name;  
9.     }  
10.     public void setName(String name) {  
11.         this.name = name;  
12.     }  
13. }  
14. //具体产品  
15. class Benz extends Car{  
16.     public void drive(){  
17.         System.out.println(this.getName()+"----go-----------------------");  
18.     }  
19. }  
20. class Bmw extends Car{  
21.     public void drive(){  
22.         System.out.println(this.getName()+"----go-----------------------");  
23.     }  
24. }  
25.   
26.   
27. //抽象工厂  
28. abstract class Driver{  
29.     public abstract Car createCar(String car) throws Exception;  
30. }  
31. //具体工厂（每个具体工厂负责一个具体产品）  
32. class BenzDriver extends Driver{  
33.     public Car createCar(String car) throws Exception {  
34.         return new Benz();  
35.     }  
36. }  
37. class BmwDriver extends Driver{  
38.     public Car createCar(String car) throws Exception {  
39.         return new Bmw();  
40.     }  
41. }  
42.   
43. //老板  
44. public class Boss{  
45.   
46.     public static void main(String[] args) throws Exception {  
47.         Driver d = new BenzDriver();  
48.         Car c = d.createCar("benz");   
49.         c.setName("benz");  
50.         c.drive();  
51.     }  
52. }  

使用开闭原则来分析下工厂方法模式（对比简单工厂模式）。当有新的产品（即汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。（即当有新产品时，只要创建并基础抽象产品；新建具体工厂继承抽象工厂；而不用修改任何一个类）工厂方法模式是完全符合开闭原则的！

说了这么多先来一个小结：如果不使用工厂模式来实现我们的例子，也许代码会减少很多——只需要实现已有的车，不使用多态。但是在可维护性上，可扩展性上是非常差的（你可以想象一下添加一辆车后要牵动的类）。因此为了提高扩展性和维护性，多写些代码是值得的。

抽象工厂方法：这个确实是非常抽象，但是往往越抽象，逼格就显的越高，所有！我们也稍微看一下这个好像不比较少用到的模式：（自己可以先去认识下什么是产品族）

老规矩：先来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

实例代码如下（来自：http://www.cnblogs.com/zhangchenliang/p/3700820.html）

1. //抽象产品（Bmw和Audi同理）  
2. abstract class BenzCar{  
3.     private String name;  
4.       
5.     public abstract void drive();  
6.       
7.     public String getName() {  
8.         return name;  
9.     }  
10.     public void setName(String name) {  
11.         this.name = name;  
12.     }  
13. }  
14. //具体产品（Bmw和Audi同理）  
15. class BenzSportCar extends BenzCar{  
16.     public void drive(){  
17.         System.out.println(this.getName()+"----BenzSportCar-----------------------");  
18.     }  
19. }  
20. class BenzBusinessCar extends BenzCar{  
21.     public void drive(){  
22.         System.out.println(this.getName()+"----BenzBusinessCar-----------------------");  
23.     }  
24. }  
25.   
26. abstract class BmwCar{  
27.     private String name;  
28.       
29.     public abstract void drive();  
30.       
31.     public String getName() {  
32.         return name;  
33.     }  
34.     public void setName(String name) {  
35.         this.name = name;  
36.     }  
37. }  
38. class BmwSportCar extends BmwCar{  
39.     public void drive(){  
40.         System.out.println(this.getName()+"----BmwSportCar-----------------------");  
41.     }  
42. }  
43. class BmwBusinessCar extends BmwCar{  
44.     public void drive(){  
45.         System.out.println(this.getName()+"----BmwBusinessCar-----------------------");  
46.     }  
47. }  
48.   
49. abstract class AudiCar{  
50.     private String name;  
51.       
52.     public abstract void drive();  
53.       
54.     public String getName() {  
55.         return name;  
56.     }  
57.     public void setName(String name) {  
58.         this.name = name;  
59.     }  
60. }  
61. class AudiSportCar extends AudiCar{  
62.     public void drive(){  
63.         System.out.println(this.getName()+"----AudiSportCar-----------------------");  
64.     }  
65. }  
66. class AudiBusinessCar extends AudiCar{  
67.     public void drive(){  
68.         System.out.println(this.getName()+"----AudiBusinessCar-----------------------");  
69.     }  
70. }  
71.   
72.   
73. //抽象工厂  
74. abstract class Driver3{  
75.     public abstract BenzCar createBenzCar(String car) throws Exception;  
76.       
77.     public abstract BmwCar createBmwCar(String car) throws Exception;  
78.       
79.     public abstract AudiCar createAudiCar(String car) throws Exception;  
80. }  
81. //具体工厂  
82. class SportDriver extends Driver3{  
83.     public BenzCar createBenzCar(String car) throws Exception {  
84.         return new BenzSportCar();  
85.     }  
86.     public BmwCar createBmwCar(String car) throws Exception {  
87.         return new BmwSportCar();  
88.     }  
89.     public AudiCar createAudiCar(String car) throws Exception {  
90.         return new AudiSportCar();  
91.     }  
92. }  
93. class BusinessDriver extends Driver3{  
94.     public BenzCar createBenzCar(String car) throws Exception {  
95.         return new BenzBusinessCar();  
96.     }  
97.     public BmwCar createBmwCar(String car) throws Exception {  
98.         return new BmwBusinessCar();  
99.     }  
100.     public AudiCar createAudiCar(String car) throws Exception {  
101.         return new AudiBusinessCar();  
102.     }  
103. }  
104.   
105. //老板  
106. public class BossAbstractFactory {  
107.   
108.     public static void main(String[] args) throws Exception {  
109.           
110.         Driver3 d = new BusinessDriver();  
111.         AudiCar car = d.createAudiCar("");  
112.         car.drive();  
113.     }  
114. }  

讲到这里再来一个小结：

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。 所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了

3：代理模式

什么是代理模式呢？我很忙，忙的没空理你，那你要找我呢就先找我的代理人吧， 那代理人总要知道被代理人能做哪些事情不能做哪些事情吧，那就是两个人具备同一个接口，代理人虽然不能干活，但是被代理的人能干活呀。

代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象。

代理模式一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口； 
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

java代理一共有三种模式，这里就介绍一下静态代理和动态代理。

先看一下静态代理：(http://www.cnblogs.com/wangchy0927/archive/2012/08/02/2619964.html)

这里举一个例子就是：比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理 ，用代码就是 这样的：

先定义一种类型的女人：

1. /**
   * 定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
   */
   
   public interface KindWomen {
   //这种类型的女人能做什么事情呢？
   public void makeEyesWithMan(); //抛媚眼
   public void happyWithMan(); //happy what? You know that!
   }
3. /**
   * 定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
   */
   
   public interface KindWomen {
   //这种类型的女人能做什么事情呢？
   public void makeEyesWithMan(); //抛媚眼
   public void happyWithMan(); //happy what? You know that!
   }
5. /**
   *定义一个王婆
   * 王婆这个人老聪明了，她太老了，是个男人都看不上，
   * 但是她有智慧有经验呀，她作为一类女人的代理！
   */
   public class WangPo implements KindWomen {
   private KindWomen kindWomen;
   public WangPo(){ //默认的话，是潘金莲的代理
   this.kindWomen = new PanJinLian();
   }
   //她可以是KindWomen的任何一个女人的代理，只要你是这一类型
   public WangPo(KindWomen kindWomen){
   this.kindWomen = kindWomen;
   }
   public void happyWithMan() {
   this.kindWomen.happyWithMan(); //自己老了，干不了，可以让年轻的代替
   }
   public void makeEyesWithMan() {
   this.kindWomen.makeEyesWithMan(); //王婆这么大年龄了，谁看她抛媚眼？！
   }
   }
7.   
8. /**
   * 
   * 
   * 定义一个西门庆，这人色中饿鬼
   */
   public class XiMenQing {
   /*
   * 水浒里是这样写的：西门庆被潘金莲用竹竿敲了一下难道，痴迷了，
   * 被王婆看到了, 就开始撮合两人好事，王婆作为潘金莲的代理人
   * 收了不少好处费，那我们假设一下：
   * 如果没有王婆在中间牵线，这两个不要脸的能成吗？难说的很！
   */
   public static void main(String[] args) {
   //把王婆叫出来
   WangPo wangPo = new WangPo();
   //然后西门庆就说，我要和潘金莲happy，然后王婆就安排了西门庆丢筷子的那出戏:
   wangPo.makeEyesWithMan(); //看到没，虽然表面上时王婆在做，实际上HAPPY的是潘金莲
   wangPo.happyWithMan(); }
   }
10.   

静态代理总结:
1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:

• 因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

如何解决静态代理中的缺点呢?答案是可以使用动态代理方式

动态代理：

讲动态代理之前，我们先了解一下JAVA的反射：

java里的class文件加载分为两种情况，一种就是类型是编译器已知的，这种文件的.class文件在编译的时候，编译器会把.class文件打开检查，但是注意不是加载哦，第二种就是我们可能是从别的地方获取到了一个引用，然后动态的把这个未知类型的引用的对象的.class文件加载进jvm虚拟机里。我们称后者为“反射”，反射也是作为一个java的核心技术的存在。在java里提供了一个叫做reflect的库，这个库里封装了Method,Constructor,field,Proxy,InvocationHandler 等类（这些类的源码我还还没去看，反正就是先知道有这些东西）。

反射最大的作用就在于我们可以不在编译时知道某个对象的类型，而在运行时得到。同时我们只需要得到我们想得到的类的名字即可(如果不在一个包，必须写完整的名字包括包名)。举个简单的反射的例子：

public class Main {
    public static void main(String[] args) throws Exception{
        //返回A的构造方法
        Constructor c = A.class.getConstructor();
        //返回A类的所有为public 声明的构造方法
        Constructor[] cons = A.class.getConstructors();
        //返回A类所有的构造方法，包括private
        Constructor[] cons2 = A.class.getDeclaredConstructors();
        //返回A类的第一个public 方法
        Method m = A.class.getMethod("say");
        //执行
        m.invoke(A.class.newInstance(), null);
        //返回A类所有的public 方法
        Method[] ms = A.class.getMethods();
        //返回A类所有的方法，包括private
        Method[] allMs = A.class.getDeclaredMethods();
        //返回A类的public字段
        Field field = A.class.getField("i");
        System.out.println(field.get(A.class.newInstance()));
        //返回A类的static 字段
        System.out.println(field.get(null));
    }
}


class A{
    public int i = 1;
    public static int b = 2;
    public A(){
        System.out.println("无参构造");
    }
    private A(String s){
        System.out.println("有参构造"+s);
    }
    
    public void say(){
        System.out.println("say");
    }
}

通过上面的例子我们可以看出我们只用知道一个类的名字便可以得知它内部方法和字段，那么这里已经强烈的体现到了反射的作用。关于.class类字面常量的知识请参照博文:http://www.cnblogs.com/haodawang/articles/5954368.html。

然后我们就讲到动态代理了，动态代理就是用到了反射机制，在使用动态代理时，我们需要定义一个位于代理类与委托类之间的中介类，也叫动态代理类，这个类被要求实现InvocationHandler接口：

interface ProxyInterface{
    void say();
}


//被代理类
class RealObject implements ProxyInterface{
    public void say(){
        System.out.println("i'm talking");
    }
}


//代理类，实现InvocationHandler 接口
class ProxyObject implements InvocationHandler{
    private Object proxied = null;
    public ProxyObject(){
        
    }
    public ProxyObject(Object proxied){
        this.proxied  = proxied;
    }
    public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
        System.out.println("hello");
        return arg1.invoke(proxied, arg2);
    };
}

public class Main {
    static void customer(ProxyInterface pi){
        pi.say();
    }
    public static void main(String[] args){
        RealObject real = new RealObject();
        ProxyInterface proxy = (ProxyInterface)Proxy.newProxyInstance(ProxyInterface.class.getClassLoader(),new Class[]{ProxyInterface.class}, new ProxyObject(real));
        customer(proxy);
    }
}

这里对这个模式只做初步介绍，如果要深入了解动态代理的机制，请看这篇博文：http://www.cnblogs.com/flyoung2008/archive/2013/08/11/3251148.html

可以看到动态代理的代理类是实现了一个InvocationHandler的接口，我们通过reflect.Proxy的类的newProxyInstance方法就可以得到这个接口的实例，然后再来作为参数传递进去，这里每一个在代理类上处理的东西也会被重定向到调用处理器上。


至于动态代理和静态代理的区别，即动态代理是动态的创建代理和动态的处理方法的。

动态代理有以下特点:。

1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

4：适配器模式:

使用场景：用电器做例子，笔记本电脑的插头一般都是三相的，即除了阳极、阴极外，还有一个地极。而有些地方的电源插座却只有两极，没有地极。电源插座与笔记本电脑的电源插头不匹配使得笔记本电脑无法使用。这时候一个三相到两相的转换器（适配器）就能解决此问题，而这正像是适配器模式所做的事情。

还是老规矩，先来看一下适配器模式的角色：

模式所涉及的角色有：

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

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

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

适配器模式有类的适配器模式和对象的适配器模式两种不同的形式。

类适配器例子（来自博文：http://www.cnblogs.com/java-my-life/archive/2012/04/13/2442795.html）：

public interface Target {
    /**
     * 这是源类Adaptee也有的方法
     */
    public void sampleOperation1(); 
    /**
     * 这是源类Adapteee没有的方法
     */
    public void sampleOperation2(); 
}

上面给出的是目标角色的源代码，这个角色是以一个JAVA接口的形式实现的。可以看出，这个接口声明了两个方法：sampleOperation1()和sampleOperation2()。而源角色Adaptee是一个具体类，它有一个sampleOperation1()方法，但是没有sampleOperation2()方法。

public class Adaptee {
    
    public void sampleOperation1(){}

}

　　适配器角色Adapter扩展了Adaptee,同时又实现了目标(Target)接口。由于Adaptee没有提供sampleOperation2()方法，而目标接口又要求这个方法，因此适配器角色Adapter实现了这个方法。

public class Adapter extends Adaptee implements Target {
    /**
     * 由于源类Adaptee没有方法sampleOperation2()
     * 因此适配器补充上这个方法
     */
    @Override
    public void sampleOperation2() {
        //写相关的代码
    }

}

下面的是对象适配器

public interface Target {
    /**
     * 这是源类Adaptee也有的方法
     */
    public void sampleOperation1(); 
    /**
     * 这是源类Adapteee没有的方法
     */
    public void sampleOperation2(); 
}

public class Adaptee {

    public void sampleOperation1(){}
    
}

public class Adapter {
    private Adaptee adaptee;
    
    public Adapter(Adaptee adaptee){
        this.adaptee = adaptee;
    }
    /**
     * 源类Adaptee有方法sampleOperation1
     * 因此适配器类直接委派即可
     */
    public void sampleOperation1(){
        this.adaptee.sampleOperation1();
    }
    /**
     * 源类Adaptee没有方法sampleOperation2
     * 因此由适配器类需要补充此方法
     */
    public void sampleOperation2(){
        //写相关的代码
    }
}

从上面其实就可以看出了：适配器模式使用起来有点像多重继承机制，利用接口的特性，把一些零散类组织到一起，成为一个新的类来实现调用，并且看起来像是对一个类的操作。实际上，适配器模式更多的是强调对代码的组织，而不是功能的实现。

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

　　●　　类适配器使用对象继承的方式，是静态的定义方式；而对象适配器使用对象组合的方式，是动态组合的方式。

　　●　　对于类适配器，由于适配器直接继承了Adaptee，使得适配器不能和Adaptee的子类一起工作，因为继承是静态的关系，当适配器继承了Adaptee后，就不可能再去处理  Adaptee的子类了。

　　　　 对于对象适配器，一个适配器可以把多种不同的源适配到同一个目标。换言之，同一个适配器可以把源类和它的子类都适配到目标接口。因为对象适配器采用的是对象组合的关系，只要对象类型正确，是不是子类都无所谓。

　　●　  对于类适配器，适配器可以重定义Adaptee的部分行为，相当于子类覆盖父类的部分实现方法。

　　　　 对于对象适配器，要重定义Adaptee的行为比较困难，这种情况下，需要定义Adaptee的子类来实现重定义，然后让适配器组合子类。虽然重定义Adaptee的行为比较困难，但是想要增加一些新的行为则方便的很，而且新增加的行为可同时适用于所有的源。

　　●　　对于类适配器，仅仅引入了一个对象，并不需要额外的引用来间接得到Adaptee。

　　　　 对于对象适配器，需要额外的引用来间接得到Adaptee。

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

接下来就有一个问题了，适配器模式跟代理模式有一点类似，如何区别和选择了？

其实很明显，适配器模式是因为新旧接口不一致导致出现了客户端无法得到满足的问题，但是，由于旧的接口是不能被完全重构掉的，因为我们还想使用实现了这个接口的一些服务。那么为了使用以前实现旧接口的服务，我们就应该把新的接口转换成旧接口；实现这个转换的类就是抽象意义的转换器。
        就比如在java中早期的枚举接口是Enumeration而后定义的枚举接口是Iterator;有很多旧的类实现了enumeration接口暴露出了一些服务，但是这些服务我们现在想通过传入Iterator接口而不是Enumeration接口来调用，这时就需要一个适配器，那么client就能用这个服务了（服务端只想用Iterator或者只知道这个接口）。
        相比于适配器的应用场景，代理就不一样了，虽然代理也同样是增加了一层，但是，代理提供的接口和原本的接口是一样的，代理模式的作用是不把实现直接暴露给client，而是通过代理这个层，代理能够做一些处理。