设计模式总结：5种创建型，7种结构型，11种行为型

设计模式总结：  5种创建型，7种结构型，11种行为型 1.1  工厂方法模式     工厂方法模式（根据参数不同，工厂方法返回不同的产品对象），     多个工厂方法模式（创建不同产品不需要参数），     静态工厂方法模式（将工厂方法改为静态的，不需要实例化类） 1.2  抽象工厂：适合产品多变的情况，要生产新的产品就必须在工厂类里面加生产的方法，违背开闭原则。抽象工厂，        增加一个 工厂类接口，一个接口方法； 各种产品实现这个工厂接口，生产自己对应的产品。 1.3   单例模式 ：Singleton  （懒汉式&饿汉式） 特殊的工厂方法模式，一个类只有一个实例：                            1. 拥有一个私有的静态实例；                            2. 拥有 私有的默认构造函数；                            3. 静态工厂方法，如果是懒汉式的必须同步的，防止多线程同时操作；                            4.重写clone()函数， 返回当前实例对象，默认clone()创建新实例； public class SingletonFactory{            //1.私有的防止外部变量引用；              private static SingletonFactory _instance=null;             //2.私有的默认构造函数，防止使用构造函数实例化；              private SingletonFactory(){                       }             //3.单例静态工厂方法，同步方式多线程同时执行； synchronized public  static SingletonFactory getInstance(){             if(_instance==null){                     _instance=new SingletonFactory();                         }                         retrun _instance;             }         //4.重写克隆函数 public SingletonFactory  clone(){         return getInstance();                         } }      1.4  建造者模式    StringBuilder public class Client {     public static void main(String[]args){         Builder  builder = new  ConcreteBuilder();//接口buider,实现接口的具体建造者ConcreteBuilder,导演者Director，         Director director = new  Director(builder);         director.construct();         Product product =  builder.retrieveResult();         System.out.println(product.getPart1());         System.out.println(product.getPart2());     } } 1.5 原型模式： 复制一个已经存在的实例来返回一个新的实例，而不是新建 ------------------------------------------------------------------------------------------------------------ 2.1   适配器模式： 类的适配器：对类进行适配。A继承B，实现接口C。 对象的适配器：对对象进行包装；A实现接口C，不继承B，包含一个B的对象； 接口的适配器：对接口抽象化。A实现所有接口，为每个接口提供一个默认实现； 缺省适配器模式：       （A extends AbstractB implements interfaceC，那么A即可以选择实现(@Override)接口interfaceC中的方法，也可以选择不实现；A即可以选择实现(@Override)抽象类AbstractB中的方法，也可以选择不实现） 2.2  装饰器模式：（io流） 一个接口A，一个接口A的实现类B，一个装饰器C。C实现了A，并且有一个私有的类型为A的成员，构造函数初始化它。 适配器模式是将一个类A转换为另一个类B； 装饰器模式是为一个类A增强新的功能，从而变成Ｂ； 代理模式是为一个类Ａ转换为操作类B； 2.3  代理模式          Proxy实现接口Sourcable,含有一个Source对象 2.4  外观模式 jdbc 代理模式（一对一）发展而来的外观模式（一对多） 客户端访问子系统中的各个类，高度耦合。中间加一个统一接口，降低耦合度，客户端访问该类，该类调用子系统中的各个类。 2.5  桥接模式  jdbc 客户端通过访问 桥 访问目标实现类，桥抽象化类包含目标接口类对象，可以赋值 目标接口类的实现类的实例化给他，通过桥调用不同的目标实现类对象。 2.6 组合 2.7 享元 ----------------------------------------- 父类与子类之间： 1.策略模式：【实现C中函数指针的功能，不同的比较策略】  （comparable & Comparator）； 2.模板方法模式 两个类之间： 3.观察者模式 4.迭代子模式 （容器与容器遍历） 5.责任链模式 （责任链模式） （ 串的替换---可以使用链式操作） 6.命令模式 类的状态： 7.备忘录模式 8.状态模式 通过中间类： 9.访问者模式 10.中介模式 11.解释器模式 ###################################################################### 1.责任链模式（ 过滤器模式 ）： 2.OO思想 3.Iterator模式：（容器与容器遍历） 4.策略模式Strategy（comparable & Comparator）； 5.动态代理模式 6.工厂模式 7.其他模式 缺省适配模式（ 接口和抽象类 ）； ************************************************************************************************************************************************************************************* 面向接口的编程，面向抽象的编程 1. Java设计模式--责任链 先写测试，测试驱动开发；---------极限编程 串的替换---可以使用链式操作 过滤器链--过滤器模式； ################################################ 0826 2.Java设计模式--oo面向对象 策略模式--------comparable & Comparator 封装，继承，多态； 面向对象思维：             考虑类：名词，例子：美国人继承人---》人这个类包含国籍这个属性更合理             属性：不可脱离具体的属性；             考虑方法；             类之间的关系；              隐藏（封装），降低耦合度；             继承； is  a    继承的耦合度很强，谨慎使用；             多态：可扩展 Extensibility 可扩展原则： 修改不如添加（重载加方法，接口和抽象类 加类）； ################################################################################################################################## 面对对象的设计，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用！ Java接口(interface)和Java抽象类(abstract class)代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序 的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些有用的抽象类型作为你结构层次上的顶层。

抽象类和接口的区别：

Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以（就是interface中只能定义方法，而不能有方法的实现，而在abstract class中则可以既有方法的具体实现，又有没有具体实现的抽象方法），这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。这个在我的另外一篇博客mapreduce 新旧API 区别中有提到类似的问题，在新的mapreduce api中更倾向于使用抽象类，而不是接口，因为这更容易扩展。原因就是上面划线部分所说的。一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。（使用抽象类，那么继承这个抽象类的子类类型就比较单一，因为子类只能单继承抽象类；而子类能够同时实现多个接口，因为类型就比较多。接口和抽象类都可以定义对象，但是只能用他们的具体实现类来进行实例化。）从第2点不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java 接口在最上面，然后紧跟着抽象类，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。（A extends AbstractB implements interfaceC，那么A即可以选择实现(@Override)接口interfaceC中的方法，也可以选择不实现；A即可以选择实现(@Override)抽象类AbstractB中的方法，也可以选择不实现）

Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的，如果你准备写一个具体类去继承另一个具体类的话，那你的设计就有很大问题了。Java抽象类就是为了继承而存在的，它的抽象方法就是为了强制子类必须去实现的。

需要注意的是在抽象类中，如果方法没有具体实现（就是方法后面没有{}），那么必须加上abstract来声明这个方法，而接口中不需要使用abstract来声明（抽象类之所以被称为抽象类，就是因为它包含有抽象方法。含有抽象方法的类叫做抽象类） 先学会用，在研究源码内部原理； Over Design 也是一种罪过 接口与抽象类：需要继承，设计一个基类；    ------交通工具()                        共同的规范，共性的动作之类，设计一个接口；--------go() ################################################################# 3. 设计模式Iterator interface里面的方法都是public，可以不写； 面向接口编程； 不关心ArrayList或者LinkedList具体实现也能遍历，写Iterator接口，Collection中有返回Iterator的方法，具体不同实现类中实现这个方法，实现方法中写一个内部类实现Iterator的两个函数的具体不同实现：hasNext(),Next(); ################################################################# 4. 设计模式：策略模式----------comparable & Comparator： comparable: 写一个可复用的sort()对猫狗都可以排序； 先写一个接口Comparable，并包含方法ComparaTo()，猫狗都实现这个接口; ******************************** Comparator： 写一个接口Comparator，并包含方法compara(),猫狗中包含一个接口的属性，值为实例化一个Comparator的子类；写一个猫的比较器实现接口Comparator； ******************************** 接口中的方法默认都是public的，因此可以省略不写； ################################################################ 5. 设计模式：动态代理模式 类tank实现了接口moveable, tank2  继承tank,可以重写里面的方法，调用父类方法，前后加内容--前后加当前时间，计算方法耗时； tank3 聚合实现：实现moveable接口，里面有成员 moveable t  ，t.move()前后加内容; 继承和聚合都可以实现代理，但是继承实现代理不够灵活； 聚合灵活：不会导致类爆炸，容易交换包裹顺序； Tank t=new Tank(); TankLogProxy tlp=new TankLogProxy (t); TankTimeProxy  ttp=new TankTimeProxy(tlp);  Moveable m=ttp; m.move(); ################################################################# 6.设计模式：工厂模式 ################################################################# 7.其他模式： ################################################################# 设计模式： 一．5种创建型的模式 １.工厂方法模式【工厂方法模式，多个工厂方法模式，静态工厂模式】：               负责实例化同一接口的多个类；定义一个创建产品对象的工厂类，由该工厂统一创建继承了同一接口的多个产品的对象； 有大量产品需要创建适用； 工厂方法模式： public class Farm1（）{                                          //工厂类                 public Animal produce(String type){      //Animal 接口；工厂方法函数                     if (type=="pig"){                                 return new Pig();                     }else if(type=="sheep"){                               return new Sheep();                         }                             } } 多个工厂方法模式：创建不同产品不需要参数。 public class Farm1（）{                                          //工厂类  核心                 public void producePig(){        //Pig 工厂方法函数                             return new Pig();                                          }                       public void produceSheep(){       //Sheep 工厂方法函数                             return new Sheep();                                          } } 静态工厂方法模式：（简单工厂模式） 将多个工厂方法模式中，工厂方法改为静态，就不需要创建工厂对象了 2.抽象工厂模式： 问题：工厂方法一个工厂类承担了所有产品的的创建，如果产品的树形结构需要扩展，必须在工厂类中增加创建的功能；违背开闭原则； 抽象工厂模式：建立与产品类等级相似的工厂等级结构；为每一个产品提供一个具体的工厂类；扩展一个新产品的时候，只需要增加一个新的工厂类，甚至类似的对应产品多层继承工厂类； 增加一个工厂类接口，一个接口方法； 各种产品实现这个工厂接口，生产自己对应的产品。 适用：产品结构多变或有可能扩展的产品创建中 3.单例模式：Singleton 特殊的工厂方法模式，一个类只有一个实例：                            1.拥有一个私有的静态实例；                            2. 拥有私有的默认构造函数；                            3.静态工厂方法，同步的，防止多线程同时操作；                            4.重写cone()函数，返回当前实例对象，默认clone()创建新实例； public class SingletonFactory{            //1.私有的防止外部变量引用；             private static SingletonFactory _instance=null;             //2.私有的默认构造函数，防止使用构造函数实例化；             private SingletonFactory(){                       }             //3.单例静态工厂方法，同步方式多线程同时执行； synchronized public static SingletonFactory getInstance(){             if(_instance==null){                     _instance=new SiongletonFactory();                         }                         retrun _instance;             }         //4.重写克隆函数 public SingletonFactory clone(){         return getInstance();                         } } 4.建造者模式： StringBuilder 类，增加删除修改各种数据。构造数据集。 创建符合对象；将各种产品集中了起来；不关注各部分怎么创建用工厂模式，关注各部分用建造者模式； 各种产品都放List 中。 Farm5 farm=new Farm5(); farm.producePig(); farm.produceSheep(); farm.sum(); 5.原型模式：prototype  创建复杂耗时的实例。         复制一个已经存在的实例来返回一个新的实例，而不是新建。 public class Prototype implements Cloneable{         public Object clone() throws ConeNotSupporteException{                 Prototype prototype=(Prototype) super.clone();                 return prototype;                     } } 以上是浅复制. 浅复制和深复制，基本类型值都一样被复制，引用类型的，只有是深复制的时候才会被复制。浅复制，引用的对象不被复制，引用同一个引用对象。 二．7种结构型的模式 1.适配器模式 源角色：Adaptee 目标角色：Target 适配器角色：Adapter                          Adaptee只有方法operation(),没有newoperation（），但是客户端同时要求又这两种方法，这时候新建一个接口Target，提供一个中间环节Adapter类， 适配器类Adapter继承源角色Adaptee,实现目标角色Target接口。    类的适配器：对类进行适配 对象的适配器：对对象进行包装； 接口的适配器：对接口抽象化。 类的适配器模式：         Source类：operation1（）         Targetable类：接口类，operation1（）,  operation2（）         Adapter类:  extends  Source，implements  Targetable 适配后的类，可以 通过调用Targetable接口来实现对Source的操作； 对象的适配器模式：         Source类：operation1（）         Targetable类：接口类，operation1（）,  operation2（）         Wrapper类: implements  Targetable; 不继承Source，包含一个Source对象，构造函数初始化，operation1（）{source.operation1();}  接口的适配器模式： Sourcable:定义多个接口函数的接口类； DefaultWrapper：抽象类，实现了接口Sourcable，为每个接口函数提供一个默认实现；       解决问题：实现一个接口编写一个类，不必实现所有接口函数； 2.装饰模式： 接口类：Sourable  源类：Source，实现接口类 装饰类：Decorator1，实现接口类，含有一个私有接口类型的成员，构造函数初始化；          Sourable source=new  Source();         Sourable obj=new  Decorator1(new Decorator2(new Decorator3(source)));         obj.operator(); Decorator1：     private Sourable source;     public Decorator1(Sourable source)     {         super();         this.source = source;     } 适配器模式是将一个类A转换为另一个类B； 装饰器模式是为一个类A增强新的功能，从而变成Ｂ； 代理模式是为一个类Ａ转换为操作类B； 3.代理模式 被代理对象接口Sourcable 被代理对象Source 代理者Proxy Proxy实现接口Sourcable,含有一个Source对象，跟对象适配器类似， 不同的是在初始化的时候不能由外部传入，在构造函数中new Source();在operation1（）中调用source.operation1(),前后可以加入新增内容，跟装饰模式很像，不同的是关注点不同，代理模式关注如何调用，装饰模式关注扩展功能。Proxy实现对Source的调用。还实现了自己的功能。 4.外观模式：JDBC屏蔽了于数据库进行连接，查询，更新，删除等一系列的操作； 代理模式（一对一）发展而来的外观模式（一对多） 客户端访问子系统中的各个类，高度耦合。中间加一个统一接口，降低耦合度，客户端访问该类，该类调用子系统中的各个类。 目标类-----外观类-----客户端类。外观类中有各个子系统类的对象。 5.桥接模式：JDBC桥 DriverManager 抽象化角色：桥接类 修正抽象化：桥接具体类 实现化角色：目标接口 具体实现化：目标实现类 客户端通过访问桥访问目标实现类，桥抽象化类包含目标接口类对象，可以赋值 目标接口类的实现类的实例化给他，通过桥调用不同的目标实现类对象。 6.组合模式 将对象组合成树形结构以表示部分-整体的层次结构。 组合模式类：节点名称，父节点，孩子节点 private String  name; private TreeNode parent; private Vector <TreeNode> v=new Vector<TreeNode>(); 7.享元模式 FlyWeight            java中的数据库连接池 使用共享的方式，达到高效地支持大量的细粒度对象，他的目的就是节省占用的空间资源，从而实现系统性能的改善。 三．11种行为型的模式 父类与子类之间： 1.策略模式：【实现C中函数指针的功能，不同的比较策略】 2.模板方法模式 两个类之间： 3.观察者模式 4.迭代子模式 5.责任链模式 6.命令模式 类的状态： 7.备忘录模式 8.状态模式 通过中间类： 9.访问者模式 10.中介模式 11.解释器模式