public
                class
                 Singleton {
     
                private
                static Singleton singleton = null; 
     //限制产生多个对象private Singleton(){
     }  
     //通过该方法获得实例对象publicstatic Singleton getSingleton(){
             if(singleton == null){
                    singleton = new Singleton();
             }
             return singleton;
     }
}

                public
                class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c){
             Product product=null;
             try {
                    product = (Product)Class.forName(c.getName()).newInstance();
             } catch (Exception e) {
                    //异常处理             }
             return (T)product;         
     }
}

                public abstract class AbstractCreator {
     //创建A产品家族
     public abstract AbstractProductA createProductA(); 
     //创建B产品家族
     public abstract AbstractProductB createProductB();
}
            

                public
                class PrototypeClass  implements Cloneable{
     //覆写父类Object方法     @Override
     public PrototypeClass clone(){
             PrototypeClass prototypeClass = null;
             try {
                    prototypeClass = (PrototypeClass)super.clone();
             } catch (CloneNotSupportedException e) {
                    //异常处理             }
             return prototypeClass;
     }
}

                public
                abstract
                class
                 Mediator {
     
                //
                定义同事类
                protected
                 ConcreteColleague1 c1;
     
                protected
                 ConcreteColleague2 c2;
     
                //
                通过getter/setter方法把同事类注入进来
                public
                 ConcreteColleague1 getC1() {
             
                return
                 c1;
     }
     
                public
                void
                 setC1(ConcreteColleague1 c1) {
             
                this.c1 = c1;
     }
     public ConcreteColleague2 getC2() {
             return c2;
}
     publicvoid setC2(ConcreteColleague2 c2) {
             this.c2 = c2;
     }
     //中介者模式的业务逻辑publicabstractvoid doSomething1();
     publicabstractvoid doSomething2();
}

                public
                abstract
                class
                 Handler {
     
                private
                 Handler nextHandler;
     
                //
                每个处理者都必须对请求做出处理
                public
                final
                 Response handleMessage(Request request){
             Response response = null;  
             //判断是否是自己的处理级别if(this.getHandlerLevel().equals(request.getRequestLevel())){
                    response = this.echo(request);
             }else{  //不属于自己的处理级别
                    //判断是否有下一个处理者if(this.nextHandler != null){
                            response = this.nextHandler.handleMessage(request);
                    }else{
                            //没有适当的处理者，业务自行处理                    }
             }
             return response;
     }
     //设置下一个处理者是谁publicvoid setNext(Handler _handler){
             this.nextHandler = _handler;
     }
     //每个处理者都有一个处理级别protectedabstract Level getHandlerLevel();
     //每个处理者都必须实现处理任务protectedabstract Response echo(Request request);
}

                public
                enum
                 Calculator {
     
                //
                加法运算
     ADD("+"){
             publicint exec(int a,int b){
                    return a+b;
             }
     },
     //减法运算
     SUB("-"){
             publicint exec(int a,int b){
                    return a - b;
             }
     };
     String value = "";
     //定义成员值类型private Calculator(String _value){
             this.value = _value;
     }
     //获得枚举成员的值public String getValue(){
             returnthis.value;
     }
     //声明一个抽象函数publicabstractint exec(int a,int b);
}

17.门面模式（Facade Pattern）

 

● Facade门面角色
　　客户端可以调用这个角色的方法。此角色知晓子系统的所有功能和责任。一般情况下，本角色会将所有从客户端发来的请求委派到相应的子系统去，也就说该角色没有实际的业务逻辑，只是一个委托类。
● subsystem子系统角色
　　可以同时有一个或者多个子系统。每一个子系统都不是一个单独的类，而是一个类的集合。子系统并不知道门面的存在。对于子系统而言，门面仅仅是另外一个客户端而已。

 

使用场景：

　　● 为一个复杂的模块或子系统提供一个供外界访问的接口

　　● 子系统相对独立——外界对子系统的访问只要黑箱操作即可

　　● 预防低水平人员带来的风险扩散

注意：

　　●一个子系统可以有多个门面

　　●门面不参与子系统内的业务逻辑

 

 

18.备忘录模式（Memento Pattern）

定义：Without violating encapsulation,capture and externalize an object‘s internal state so that the object can be restored to this state later.（在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。）

● Originator发起人角色

　　记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。

● Memento备忘录角色（简单的javabean）

　　负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。

● Caretaker备忘录管理员角色（简单的javabean）

　　对备忘录进行管理、保存和提供备忘录。

使用场景：

　　● 需要保存和恢复数据的相关状态场景。

　　● 提供一个可回滚（rollback）的操作。

　　● 需要监控的副本场景中。

　　● 数据库连接的事务管理就是用的备忘录模式。

注意：

　　● 备忘录的生命期

　　● 备忘录的性能

　　不要在频繁建立备份的场景中使用备忘录模式（比如一个for循环中）。    

 

clone方式备忘录：

　　● 发起人角色融合了发起人角色和备忘录角色，具有双重功效

 

多状态的备忘录模式

　　● 增加了一个BeanUtils类，其中backupProp是把发起人的所有属性值转换到HashMap中，方便备忘录角色存储。restoreProp方法则是把HashMap中的值返回到发起人角色中。

BeanUtil工具类代码：

                            public
                            class
                             BeanUtils {
     
                            //
                            把bean的所有属性及数值放入到Hashmap中
                            public
                            static HashMap<String,Object> backupProp(Object bean){
             HashMap<String,Object> result = new HashMap<String,Object>();
             try {
                     //获得Bean描述
                     BeanInfo beanInfo=Introspector.getBeanInfo(bean.getClass());
                     //获得属性描述
                     PropertyDescriptor[] descriptors=beanInfo.getPropertyDescriptors();
                     //遍历所有属性for(PropertyDescriptor des:descriptors){
                             //属性名称
                             String fieldName = des.getName();
                             //读取属性的方法
                             Method getter = des.getReadMethod();
                             //读取属性值
                             Object fieldValue=getter.invoke(bean,new Object[]{});
                    if(!fieldName.equalsIgnoreCase("class")){
                             result.put(fieldName, fieldValue);
                    }
               }
          } catch (Exception e) {
               //异常处理          }
          return result;
     }
     //把HashMap的值返回到bean中publicstaticvoid restoreProp(Object bean,HashMap<String,Object> propMap){
try {
               //获得Bean描述
               BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
               //获得属性描述
               PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
               //遍历所有属性for(PropertyDescriptor des:descriptors){
                    //属性名称
                    String fieldName = des.getName();
                    //如果有这个属性if(propMap.containsKey(fieldName)){
                         //写属性的方法
                         Method setter = des.getWriteMethod();
                         setter.invoke(bean, new Object[]{propMap.get(fieldName)});
                    }
               }
          } catch (Exception e) {
               //异常处理
               System.out.println("shit");
               e.printStackTrace();
          }
     }
} 

封装得更好一点：保证只能对发起人可读

　　● 建立一个空接口IMemento——什么方法属性都没有的接口，然后在发起人Originator类中建立一个内置类（也叫做类中类）Memento实现IMemento接口，同时也实现自己的业务逻辑。

 

19.访问者模式（Visitor Pattern）

定义：Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates. （封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。）

 

● Visitor——抽象访问者

　　抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是visit方法的参数定义哪些对象是可以被访问的。

● ConcreteVisitor——具体访问者

　　它影响访问者访问到一个类后该怎么干，要做什么事情。

● Element——抽象元素

　　接口或者抽象类，声明接受哪一类访问者访问，程序上是通过accept方法中的参数来定义的。

● ConcreteElement——具体元素

　　实现accept方法，通常是visitor.visit(this)，基本上都形成了一种模式了。

● ObjectStruture——结构对象

　　元素产生者，一般容纳在多个不同类、不同接口的容器，如List、Set、Map等，在项目中，一般很少抽象出这个角色。

 

使用场景：

　　● 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作，也就说是用迭代器模式已经不能胜任的情景。

　　● 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。

 

20.状态模式（复杂）

定义：Allow an object to alter its behavior when its internal state changes.The object will appear to change its class.（当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。）

● State——抽象状态角色

　　接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。

● ConcreteState——具体状态角色

　　每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。

● Context——环境角色

　　定义客户端需要的接口，并且负责具体状态的切换。

 

使用场景：

　　● 行为随状态改变而改变的场景

　　这也是状态模式的根本出发点，例如权限设计，人员的状态不同即使执行相同的行为结果也会不同，在这种情况下需要考虑使用状态模式。

　　● 条件、分支判断语句的替代者

 

　　注意： 状态模式适用于当某个对象在它的状态发生改变时，它的行为也随着发生比较大的变化，也就是说在行为受状态约束的情况下可以使用状态模式，而且使用时对象的状态最好不要超过5个。

 

21.解释器模式（Interpreter Pattern）（少用）

定义：Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.（给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。）

 

● AbstractExpression——抽象解释器

　　具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和Non-terminalExpression完成。

● TerminalExpression——终结符表达式

　　实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。具体到我们例子就是VarExpression类，表达式中的每个终结符都在栈中产生了一个　　VarExpression对象。

● NonterminalExpression——非终结符表达式

　　文法中的每条规则对应于一个非终结表达式，具体到我们的例子就是加减法规则分别对应到AddExpression和SubExpression两个类。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

● Context——环境角色

　　具体到我们的例子中是采用HashMap代替。  

使用场景：

　　● 重复发生的问题可以使用解释器模式

　　● 一个简单语法需要解释的场景

 

　　注意： 尽量不要在重要的模块中使用解释器模式，否则维护会是一个很大的问题。在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式，弥补Java编译型语言的不足。

 

22.享元模式（Flyweight Pattern）

定义：Use sharing to support large numbers of fine-grained objects efficiently.（使用共享对象可有效地支持大量的细粒度的对象。）

对象的信息分为两个部分：内部状态（intrinsic）与外部状态（extrinsic）。

● 内部状态

　　内部状态是对象可共享出来的信息，存储在享元对象内部并且不会随环境改变而改变。

● 外部状态

　　外部状态是对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态。

 

● Flyweight——抽象享元角色

　　它简单地说就是一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。

● ConcreteFlyweight——具体享元角色

　　具体的一个产品类，实现抽象角色定义的业务。该角色中需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态，这是绝对不允许的。

● unsharedConcreteFlyweight——不可共享的享元角色

　　不存在外部状态或者安全要求（如线程安全）不能够使用共享技术的对象，该对象一般不会出现在享元工厂中。

● FlyweightFactory——享元工厂

　　职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。

 

享元工厂的代码：

                                            public
                                            class
                                             FlyweightFactory {
     
                                            //
                                            定义一个池容器
                                            private
                                            static  HashMap<String,Flyweight> pool= new HashMap<String,Flyweight>();
     //享元工厂publicstatic Flyweight getFlyweight(String Extrinsic){
             //需要返回的对象
             Flyweight flyweight = null;
             //在池中没有该对象if(pool.containsKey(Extrinsic)){
                     flyweight = pool.get(Extrinsic);
             }else{
                     //根据外部状态创建享元对象
                     flyweight = new ConcreteFlyweight1(Extrinsic);
                     //放置到池中                     pool.put(Extrinsic, flyweight);
             }
             return flyweight;
     }
}

使用场景：

　　● 系统中存在大量的相似对象。

　　● 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份。

　　● 需要缓冲池的场景。

注意：

　　● 享元模式是线程不安全的，只有依靠经验，在需要的地方考虑一下线程安全，在大部分场景下不用考虑。对象池中的享元对象尽量多，多到足够满足为止。

　　● 性能安全：外部状态最好以java的基本类型作为标志，如String，int，可以提高效率。

 

23.桥梁模式（Bridge Pattern）

定义：Decouple an abstraction from its implementation so that the two can vary independently.（将抽象和实现解耦，使得两者可以独立地变化。）