Java设计模式

来源：互联网发布：怎么让淘宝信誉高起来编辑：程序博客网时间：2024/05/18 12:02

软件设计的开-闭原则：

开闭原则是：一个系统要对扩展开放，而对修改关闭。这里的所指的意思就是在不修改以前已经写好的代码或者尽量不改的情况下来扩展系统的功能。
由于从抽象层导出一个或多个新的具体类可以改变系统的行为，因此系统的设计对扩展是开放的，这就满足了开闭原则的第一条。
在语言里，可以给出一个或多个抽象类或者接口，规定出所有的具体类必须提供的方法的特征作为系统设计的抽象层。这个抽象层预见了所有的可扩展性，因此，在任何扩展情况下都不会改变。这就使得系统的抽象不需要修改，从而满足了开闭原则的第二条，对修改关闭。

Design pattern 分类

(1)、创建型，一般通过用来创建对象 Factory Method Pattern、Builder Pattern、Prototype Pattern、Singleton Pattern.

(2)、结构型，对象组合来获取更大的结构 Adapter Pattern、 Proxy Pattern、 Facade Pattern、Bridge Pattern、Decorator Pattern。

(3)、行为模型，处理对象如何交互 Observer Pattern、 Template Pattern、 Strategy Pattern、 State Pattern、 Command Pattern、 Iterator Pattern。

一：单态模式(Single Pattern)

注意：构造函数可见性为private。这样使得外面的类不能通过引言来产生对象。

构造器（Constructor）声明为private的话，外面不能实例化，典型的单例模式和一些工具类（提供静态方法），都把构造器声明为private。所以要得到这个类的实例只能是类名。method()取的它实例。

[java] view plaincopy
public class Singleton{  
  
           private static Singleton instance=new SinglePattern();  
  
           private Singleton(){}  
  
           public static Singleton getInstance(){  
  
              return instance;  
  
          }   
  
    }

线程安全的Singleton

[java] view plaincopy
public class Singleton{  
  
          private Singleton instance = null;  
  
           public static Synchronizeed  Singleton getInstance(){  
  
              if (instance == null)  {  
  
                 instance = new Singleton();   
  
              }  
  
              return instance;  
  
           }  
  
    }

为什么需要使用Singleton:单态模式是保证一个类有且仅有一个对象实例。单态模式经常使用在控制资源的访问上。例如配置文件管理类、数据工具类或Socket连接等。单态模式可以控制在某个时刻只有一个线程访问资源。

[java] view plaincopy
public class DBUtil {  
  
     //单一实例  
     private static final DBUtil instance = null;  
       
     //数据源的JNDI  
     private static final String datasource = "java:comp/env/jdbc/dataS";  
      
    //私有构造方法,防止外部实例化  
     private DBUtil() {  
  
     }  
       
    //数据库工具类实例工厂  
     public static synchronized DBUtil getInstance() {  
         if(instance == null ){  
            instance = new DBUtil();  
         }  
         return instance;  
     }  
  
  
     //业务方法:用于获取数据库连接  
     public Connection getConnection() {  
         Connection conn = null;  
         try {  
             Context ctx = new InitialContext();  
             DataSource ds = (DataSource) ctx.lookup(datasource);  
             conn = ds.getConnection();  
         } catch (NamingException e) {  
             System.out.println("获取数据源异常,请AppServer的JNDI数据源配置!");  
             e.printStackTrace();  
  
         } catch (SQLException e) {  
             System.err.println("获取数据库连接发生异常!");  
             e.printStackTrace();  
         }  
         return conn;  
     }  
  
}  

二：工厂模式(Factory Pattern)

(a):简单工厂模式(Simple Factory Pattern)

[java] view plaincopy
 public interface AB { public void drive();};  
  
    public A implements AB{ public void drive(){ System.out.println("My is A!") }};  
  
    public B implements AB{ public void drive(){ System.out.println("My is B!") }};  
  
     public class Factory{  
  
                  public static AB createFactory(int i){  //返回的是静态的抽象产品角色  
  
                              switch(i){  
  
                                   case 1:  
  
                                        return new A();  
  
                                   case 2:  
  
                                        return new B();  
  
                  }  
  
     }  
  
public operatorFactory{  
  
          AB ab=Factory.createFactory(1);  
  
          ab.dirive();//输出A  
  
}

简单工厂模式符合设计开闭原则的第一个原则，对扩展开发，但不符合第二个原则，如果再增加一个产品，则在工厂里增加相应的业务逻辑和判断逻辑。

改进版，通过类的反射机制来实现

[java] view plaincopy
public class Factory{  
  
     public static AB createFactory(String className){  
  
           Class c = Class.forName(className);  
  
           AB ab = (AB)c.newInstance();  
  
           return ab;  
  
     }  
  
Client:   
     AB a = createFactory("cn.com.chenlly.A");  

(b):工厂方法模式(Abstract Factory Pattern)：当添加一个操作时，需要修改静态工厂方法不符合开闭原则（对扩展开放，对修改封闭)。把工厂里的静态工厂方法由不同的工厂子类来分担。

[java] view plaincopy
public interface AB {  
    public void drive();  
}  
  
public A implements AB{  
    public void drive(){   
      System.out.println("My is A!");   
    }  
}  
  
public B implements AB{   
  public void drive(){   
     System.out.println("My is B!");   
  }  
}  
  
  // 把静态工厂方法抽象出来  
  
public interface CreateAbstractorFacto{  
    pubic AB createFactory();  
}  
  
public createAFactory implements CreateAbstractorFactory{   
   public AB createFactory(){  
       return new A();  
   }  
}  
  
public createBFactory implements CreateAbstractorFactory{  
    public AB createFactory(){  
        return new B();  
    }  
}  
  
public operatorFactory{  
    CreateAbstractorFactory  caf = new createAFactory ();  
    A  a = caf.createFactory();// 有A的工厂类制造出A  
    a.drive();  // 输出A  
}  

三建造模型（Builder Pattern）

客户首先创建一个指导者对象和一个建造者角色，并将建造者角色传入指导者对象进行配置。然后，指导者按照步骤调用建造者的方法创建产品。最后客户从建造者或指导者那里得到产品。建造模式将复杂对象的组件和表示方式封装在一个具体的建造角色中，而由指导者来协调建造者角色来得到具体的产品实例。

类图：

[java] view plaincopy
Interface Builder{  
  
               public buildPart1();  
  
               public buildPart2();  
  
               public buildPart3();  
  
              public Procedure getResult();  
  
}  
  
public class CreateBuilder implements Builder{    
  
           Part1 part1;  
  
           Part2 part2;  
  
           Part3 part3;  
  
           public void buildPart1{//构建Part1代码}  
  
           public void buildPart2{//构建Part2代码}  
  
           public void buildPart3{//构建Part3代码}  
  
           public Procedure getResult(){   
  
                    //产品生产    
  
           }  
  
}    
  
public class Director{  
  
          private Builder build;  
  
          public Director(build){  
  
                   this.build=build;   
  
         }  
  
        public void construct(){  
  
                 // 将部件partA partB partC最后组成复杂对象  
　          　//这里是将车轮 方向盘和发动机组装成汽车的过程  
  
                 build.buildPart1();  
  
                build.buildPart2();  
  
                build.buildPart3();  
  
        }  
  
}  
  
//调用：  
  
  CreateBuilder  cb=new CreateBuilder();  
  
  Direct dt=new Direct(cb);  
  
  dt.construct();  
  
  cb.getResult();  
  
interface Produce {}  //对象产品  
  
interface Part(){}        //对象附件

四适配器模式（Adapter pattern）

将一个类的接口转换为客户希望的另一个类的接口

A接口使用了方法1来实现某个功能，B接口使用了方法2来实现某个功能。修改任何一个接口中的方法都要修改其实现和使用到的地方。此模式是为了在面向接口编程中更好的复用。

形状接口定义了它所对应的绘制图形所有的基本方法，现在要绘制椭圆，庆幸自己发现系统中已经有了绘制图形的实现。但是发现Shape接口中定义的方法和TextCircle中定义的方法不一样。

看在Circle中如何实现

[java] view plaincopy
public class Circle extends Shape{  
  
         private TextCircle tc;  
  
         public Circle(){  
  
                tc=new TextCircle;    
  
        }  
  
       public void display(){  
  
                tc.displayCircle();  
  
        }  
  
}

五桥接模式（bridge pattern）

桥梁模式主要的手段用动态的聚合关系，代替为静态的继承关系，从而达到系统的重构，使系统具有更高的复用.用意是将问题的抽象和实现分离开来实现，通过用聚合代替继承来解决子类爆炸性增长的问题。

当系统有两个可变因素时我就应该考虑到桥梁模式，至少它应该在你的脑子里闪过

如形状接口中，可能还会增加一个形状，画法可能除了画法一还有画法二，这就要要考虑bridge pattern

1：找出变化并且封装

2：优先考虑聚合而不是继承

eg:

抽象形状(抽象角色形状)

[java] view plaincopy
    public interface Shape{  
  
                  public void doDraw();   
  
        }  
  
       public class Circle implements Shape{}  
  
       public class Rectangle implements Shape({}  
  
       抽象方法（实现角色 方法）  
  
       public interface Drawing {  
  
                   public void draw();  
  
        }  
  
        public class draw1 implements Drawing{}  
  
        public class draw2 implements Drawing {}  
  
        //实现抽象角色  
  
       public class Circle implements Shape(){  
  
            private Drawing drawing;  
  
            //get() set()  
  
            public void doDraw(){  
  
                    drawing.draw();  
  
             }  
  
        }  
  
//客户端调用  
  
public void main(String []args){  
  
       Shape circle=new Circle(new drawing3);  
  
       circle.doDraw();  
  
}

仔细体会了一下桥梁模式，感觉凡是‘调用和实现’之间的问题都可以用桥梁模式解决。

六组合模型（composite）

Composite模式的一个重要思想是递归组合，关键是一个抽象类，它既可以代表组合对象，又可以代表一个被组合的对象。经常在Java开发中遇到的容器就使用了组合模式，一方面组件可以放在容器中，另一方面容器也可以作为组件放在另外的容器中。

removeComponent(Component com) com 可以是Component类的子类对象也可以是它本身。

七装饰模式（decorator Pattern 或包装器模式Wrapper Pattern）

应用：Java 的I/O API就是使用Decorator实现的 ,I/O变种很多,如果都采取继承方法,将会产生很多子类,显然相当繁琐。如：

FileReader fr = new FileReader(filename);
BufferedReader br = new BufferedReader(fr);

定义：动态给一个对象添加一些额外的职责。这些功能需要由用户动态决定加入的方式和时机.Decorator提供了"即插即用"的方法,在运行期间决定何时增加何种功能。使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的.

eg:

[java] view plaincopy
public interface Work{  
  
                public void insert();      
  
     }  
  
    public class SeqarePeg implements Work{  
  
               public void insert(){  
  
                   System.out.println("插入方桩");  
  
         }  
  
    }  
  
    public Decorator implements Work{  
  
             private Work work;  
  
             private List list=new ArrayList();  
  
             public Decorator(Work work){  
  
                          this.work=work;  
  
                          list.add("挖坑");  
  
                          list.add("装木板');//打桩的额外功能  
  
            }  
  
          public void insert(){  
  
                  work.insert();  
  
                   Iterator it=list.iterator();  
  
                   while(it.hasNext()){  
  
                        System.out.println(((String)it.next())+"正在进行");  
  
                   }  
  
          }  
  
      }

八门面模式（facade Pattern）

又叫外观模式，为子系统中的一组接口提供一个一致的界面。

门面模式的门面类将客户端与子系统的内部复杂性分隔开，使得客户端只需要与门面对象打交道，而不需要与子系统内部的很多对象打交道。一个典型应用就是进行数据库连接。一般我们在每一次对数据库进行访问，都要进行以下操作：先得到 connect 实例，然后打开 connect 获得连接，得到一个 statement ，执行 sql 语句进行查询，得到查询结果集。

eg:

[java] view plaincopy
买衣服  
  
public class Clothing {  
              public void getClothing(){  
                    System.out.println("买衣服");  
              }  
      }  
  
买鞋子  
  
public class Shoes {  
             public void getShoes(){  
                    System.out.println("买鞋子");  
             }  
       }  
      买玩具  
  
public class Toy {  
              public void getToys(){  
                  System.out.println("买玩具");  
               }  
       }  
  
   
  
//商店(门面)  
  
public class ShoppingCenter {  
  
            public void clothingStore(){  
                     Clothing c = new Clothing();  
                     c.getClothing();  
             }  
   
             public void shoesStore(){  
                     Shoes s = new Shoes();  
                     s.getShoes();  
             }  
   
             public void ToyStore(){  
                     Toy t = new Toy();  
                     t.getToys();  
              }  
       }  
  
//客户端public class Buys {  
             public void buy(){  
                    //买衣服  
                   Clothing c = new Clothing();  
                   c.getClothing();  
               }  
              //方法(1)原始方法  
                 new Buys().buy(); //没有门面，客户直接去货架上拿东西  
               //方法(2)增加门面商店后的方法。客户只需要在商店里拿东西了  
  
               ShoppingCenter sc = new ShoppingCenter();  
             sc.clothingStore();  
             sc.shoesStore();  
             sc.ToyStore();  
 }  

九代理模式（proxy Pattern）

定义：为其它对象提供一种代理以控制这个对象的访问，一般客户不想直接或者不能引用某一个对象。而代理则可以在客户和目标对象之间起到中间作用。proxy 可以控制原对象，但不能修改原对象。代理类必须和原来的接口(目标类)是一样的。

eg:把要进行安全性检查的一个方法模块化，写在类里。当我们生产了代理对象的时候，如果调用代理方法的时候，会自动默认调用invoke方法。这个模块化的类就是所谓的切面(Aspect),安全性检查就是advice。

[java] view plaincopy
import java.lang.reflect.InvocationHandler;//是代理实例的调用处理程序 实现的接口。   
import java.lang.reflect.Proxy;  
  
  
public class SecurityHandler implements InvocationHandler{  
   private Object targetObject;//目标实例  
   public Object newProxy(Object targetObject){  
         this.targetObject = targetObject;  
         //返回一个目标对象的代理类  
         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),//目标程序的类加载器  
                                 targetObject.getClass().interfaces(),//目标程序的接口  
                                 this);//代理指定调用的处理程序  
     }  
  
 public Object invoke(Object proxy,Method method,Object args) throws Throws{  
     //安全性检查,这是一个before Advice  
     checkSecurity();  
     //调用目标对象的正是实现,有可能有返回值，  
               Object res = null;  
      try{  
              res = method.invoke(targetObject,args);  
       }catch(Exception ex){  
            ex.printStackTrace();  
        }  
}  
  
  
 //安全性检查  
 private void checkSecurity(){  
       //todo something;  
 }  
}  
  
//客户端调用  
public class Client{  
  SecurityHandler sh = new SecurityHandler();  
 //得到代理类,Annotation就是使用了动态代理机制  
 UserManagerImpl userManagerImpl = (UserManagerImpl)sh.newProxy(new   UserManagerImpl());  
   userManagerImpl.addUser();  
   userManagerImpl.deleteUser(12);  
}  

十享元模式（FlyWeight Pattern）

享元模式属于结构型模式，其意图是运用共享技术有效地支持大量细粒度的对象。

FlyweightFactory(Object obj)：创建并管理Flyweight对象。确保合理的共享Flyweight。当用户请求一个flyweight时，FlyweightFactory对象提供一个已经创建的实例或者创建一个。比如：String类的字符串池，每次创建一个新的字符串对象都会去字符串池里去找有没有这个对象，如果没有创建一个新的，如果共享原来的对象。

[java] view plaincopy
享元接口   
public interface FlyWeight {  
     public void operator();  
}  
  
享元具体实现  
public class ConcreteFlyWeight implements FlyWeight {  
       private String str;  
  
public ConcreteFlyWeight(String str){  
       this.str = str;  
}  
public void operator() {  
         System.out.println("this is FlyWeight===》"+str);  
}  
  
}  
  
  
享元工厂类  
public class FlyWeightFactory {  
  
        private Map map = new HashMap();  
  
public FlyWeight getFlyWeight(Object obj) {  
        FlyWeight flyWeight = (FlyWeight) map.get(obj);  
if (flyWeight == null) {  
        flyWeight = new ConcreteFlyWeight(obj.toString());  
        map.put(obj, flyWeight);  
}   
  
        return flyWeight;  
}  
}  
  
   
  
客户端  
public class FlyWeightClient {  
 public static void main(String[] args) {  
  FlyWeightFactory factory = new FlyWeightFactory();  
  FlyWeight f1;  
  FlyWeight f2;  
  FlyWeight f3;  
  FlyWeight f4;  
  FlyWeight f5;  
  FlyWeight f6;  
  f1 = factory.getFlyWeight("Good");  
  f2 = factory.getFlyWeight("Bad");  
  f3 = factory.getFlyWeight("Head");  
  f4 = factory.getFlyWeight("Good");  
  f5 = factory.getFlyWeight("Good");  
  f6 = factory.getFlyWeight("Good");  
  f1.operator();  
  f2.operator();  
  f3.operator();  
  f4.operator();  
  f5.operator();  
  f6.operator();  
 }  
}  
 f4,f5,f5 不会重新创建对象，而是共享了f1  

十一责任链模式

责任链模式用于弱化请求发生者和请求处理者之间的关系。当多个对象都可以对请求进行处理，但不同的对象能处理的请求类型不同时，可以通过指向另一个对象的引用把这些对象连成一条责任链。当 Client 发出一个请求时，并不知道具体由哪个对象进行处理，它看到的只是一条责任链，将请求直接交给责任链，请求会在责任链中传递，直到找到一个能够进行处理的对象或者遍历结束找不到一个能够处理的对象为止。

[c-sharp] view plaincopy
abstract public class  Employee {  
 protected String name;  
   
 protected Employee boss; //属性 boss 指向自己的上级老板  
   
 protected int requestLevel;  
   
 public Employee(String name, Employee boss){  
  this.name = name;  
  this.boss = boss;  
 }  
   
 public String getName(){  
  return name;  
 }  
   
 public void handleRequest(Request request){  
  if (boss!=null){  
   boss.handleRequest(request);  
  } else{  
   System.out.println("No body can handle the request!");  
  }  
 }  
}  
  
   
  
Manager:  
  
public class Manager extends Employee {  
  
 /** 
  * @param name 
  * @param boss 
  */  
 public Manager(String name, Employee boss) {  
  super(name, boss);  
  requestLevel = 1;  
 }  
   
 public void handleRequest(Request request){  
  if (requestLevel >= request.getType()){  
   System.out.println("(Manager) say: I can handle the request");  
  } else {  
   System.out.println("(Manager) say: I can not handle the request.My boss"+boss.getName()+" can handle the request");  
   super.handleRequest(request);  
  }  
 }  
}  
  
   
  
Director:  
  
public class Director extends Employee {  
  
 /** 
  * @param name 
  * @param boss 
  */  
 public Director(String name, Employee boss) {  
  super(name, boss);  
  requestLevel = 2;  
 }  
 public void handleRequest(Request request){  
  if (requestLevel >= request.getType()){  
   System.out.println("(Director) say: I can handle the request");  
  } else {  
   System.out.println("(Director) say: I can not handle the request.My boss"+boss.getName()+" can handle the request");  
   super.handleRequest(request);  
  }  
 }  
  
}  
  
   
  
CEO:  
  
public class CEO extends Employee {  
  
 /** 
  * @param name 
  * @param boss 
  */  
 public CEO(String name, Employee boss) {  
  super(name, boss);  
  requestLevel = 3;  
 }  
   
 public void handleRequest(Request request){  
  if (requestLevel >= request.getType()){  
   System.out.println("(Manager) say: I can handle the request");  
  } else {  
   System.out.println("(Manager) say: I can not handle the request.My boss "+boss.getName()+"can handle the request");  
   super.handleRequest(request);  
  }  
 }  
}  
  
   
  
Request:  
  
public class Request {  
 public static final int REQUEST_LEVEL1 = 1;  
  
 public static final int REQUEST_LEVEL2 = 2;  
  
 public static final int REQUEST_LEVEL3 = 3;  
  
 private int type;  
  
 public Request(int type) {  
  this.type = type;  
 }  
  
 public int getType() {  
  return type;  
 }  
}  
  
   
  
Client:  
  
public class responsibilityChain {  
  
 /** 
  * @param args 
  */  
 public static void main(String[] args) {  
  Employee ceo = new CEO("Tom",null);  
    
  Employee director = new Director("chen", ceo);  
    
  Employee manager = new Manager("liling",director);  
    
  Request request1 = new Request(Request.REQUEST_LEVEL1);  
  Request request2 = new Request(Request.REQUEST_LEVEL2);  
  Request request3 = new Request(Request.REQUEST_LEVEL3);  
    
  manager.handleRequest(request1);  
    
  manager.handleRequest(request2);  
    
  manager.handleRequest(request3);  
 }  
  
}  
  
后台日志：  
  
(Manager) say: I can handle the request  
(Manager) say: I can not handle the request.My bosschen can handle the request  
(Director) say: I can handle the request  
(Manager) say: I can not handle the request.My bosschen can handle the request  
(Director) say: I can not handle the request.My bossTom can handle the request  
(Manager) say: I can handle the request  
  
   

eg: 不同角色的人员能够处理的 Request 的级别不同，Manager 只能处理一般的 Request，Director 具有更高的权限，能够审批更高级别的 Request，CEO 能处理的 Request 级别还要高些。

抽象类：

十二访问者模式

在不修改已有程序的前提下，通过添加额外的"访问者"来完成对已有代码的提升。
定义：表示作用于某一结构对象的各个元素的操作。它可以使你在不修改各个元素类的情况下定义作用于这些元素的新的操作。

[java] view plaincopy
(1) 访问者接口  
  
public interface Visitor {  
  
     public void visit(Red red);  
   
    public void visit(Yellow yellow);  
     
    public void visit(Green green);  
}  
  
(2) 访问者实现类 Bee2  
  
public class Bee2 implements Visitor {  
  
   public void visit(Red red) {  
        System.out.println("Bee2 and red");  
    }  
  
    public void visit(Yellow yellow) {  
      System.out.println("Bee2 and yellow");  
    }  
  
     public void visit(Green green) {  
         System.out.println("Bee2 and green");  
     }  
}  
  
  
//对象生成器 Generator(生成) Generic(普通)   
  
public class ColorGenerator {  
 private static Random random = new Random();  
   
 public static Color newColor(){  
  switch(random.nextInt(3)){  
   default:  
   case 0: return new Red();  
   case 1: return new Yellow();  
   case 2: return new Green();  
  }  
 }  
}  
  
(3) 对象结构  
  
public class  ColorStruct{  
  
     private ColorGenerator  colorGenerator;   
  
     private List<Color>  colors = new ArrayList()<Color>  
  
     public List<Color> getColors(){  
  
          for (int i = 0; i< 3; i++){  
                   colors.add(ColorGenerator.newColor());  
           }  
  
     }  
  
}  
  
(4) 元素  
  
public interface Color {  
       void accept(Visitor visitor);  
}  
  
   
  
public class Yellow implements Color {  
  
   public void accept(Visitor v) {  
        v.visit(this);  
    }  
  
}  
  
   
  
public class Red implements Color {  
  
     public void accept(Visitor v) {  
         v.visit(this);  
     }  
  
}  
  
   
  
public class Green implements Color {  
  
    public void accept(Visitor v) {  
          v.visit(this);  
    }  
  
}  
  
   
  
Client:客户端 制作一个访问者Bee2   
  
 Visitor v;  
  v= new Bee2();  
  for (Iterator<Color> iterator =  colors.iterator(); iterator.hasNext();){  
      Color color = (Color)iterator.next();  
      color.accept(v);  
  }  

十三状态模式

输入信号是事件；输出是状态结果，状态模式状态机就是一个黑盒子。
状态模式主要突出了两个字:”改变”，对象的状态决定了状态的行为，事物的本质决定了事物的行为。
对一个状态特别重要的对象，通过状态机来建模一个对象的状态；
状态模式处理的核心问题是状态的迁移，因为在对象存在很多状态情况下，
对各个business flow，各个状态之间跳转和迁移过程都是及其复杂的。
例如一个工作流，审批一个文件，存在新建、提交、已修改。
HR部门审批中、老板审批中、HR审批失败、老板审批失败等状态，涉及多个角色交互，涉及很多事件，
这种情况下用状态模式(状态机)来建模更加合适；
把各个状态和相应的实现步骤封装成一组简单的继承自一个接口或抽象类的类，
通过另外的一个Context来操作他们之间的自动状态变换，通过event来自动实现各个状态之间的跳转
参与者：
Context(环境，Person)定义客户感兴趣的类。
State(Moodstate)：定义一个接口以封装与Context的一个特定状态相关的行为
ConcreteState Subclasses(具体状态子类，如Angry)每一个子类实现一个与Context的状态相关的行为。
他们的协作关系是：
Context将于状态相关的请求委托给当前的ConcreteState对象处理。
Context可将自身作为一个参数传递给处理该请求的状态对象，这使得状态对象在必要的时候可访问Context。
Context是客户使用的主要接口，客户可用状态对象来配置一个Context，一旦一个Context配置完毕，他的客户不再需要直接与状态对象打交道。
Context或者ConcreteState子类都可以决定哪个状态是另外那个状态的后继者，以及是在何种条件下进行状态转换。

[java] view plaincopy
Context:  
  
public class Persion {  
 private MoodState state;  
   
 public Persion(){  
  state = new Mad(this);//开始默认为抓狂状态  
 }  
  
 public void setState(MoodState state) {  
  this.state = state;  
 }  
   
 public void request(){  
  state.doSomething();       
  state.changeState();  
 }  
   
}  
  
状态接口：  
public interface MoodState {  
 public void doSomething();  
   
 public void changeState();  
}  
  
   
  
抓狂状态：  
public class Mad implements MoodState {  
   
 Persion persion;  
 public Mad(Persion persion){  
  this.persion = persion;  
 }  
  
 public void changeState() {  
  persion.setState(new Angry(persion));  
 }  
  
 public void doSomething() {  
  System.out.println("I'm Mad!");  
  
 }  
  
}  
  
生气状态：  
public class Angry implements MoodState {  
   
 Persion persion;  
   
 public Angry(Persion persion){  
  this.persion = persion;  
 }  
  
 public void changeState() {  
  persion.setState(new Happy(persion));  
 }  
  
 public void doSomething() {  
  System.out.println("I'm Angry!");  
 }  
  
}  
  
高兴状态：  
public class Happy implements MoodState {  
   
 Persion persion;  
   
 public Happy(Persion persion){  
  this.persion = persion;  
 }  
 public void changeState() {  
  persion.setState(new Mad(persion));  
 }  
  
 public void doSomething() {  
  System.out.println("I'm Happy!");  
 }  
  
}  

十四观察者模式

定义对象之间的一种一对多的关系，当一个对象的状态改变时，所有依赖它的对象都会被通知并且自动更新.
1，观察者（具体执行操作的对象，有多个）
2，被观察者（顾名思义是被观察的对象，如果该对象发生某些变化则通知观察者执行对应的操作）
参照 java.util.Observable java.util.Observer

下面以一个例子来讲解观察者模式
一监控系统，需要根据系统某些变化报警，报警方式有Email、短信等多种，
IAlarm是报警接口。(观察者)当我们的系统需要添加报警方式的时候只需实现IAlarm的Warn方法即可。Email类是EmailAlarm报警的实现，SMSAlarm类是短信报警的实现。
MonitorContainer是监视器（抽象类）相当于被观察者。只负责通知变化，当子类调用Notify方法它即会通知报警模块报警，如Email和SMS(短信)。
NetMonitor是其中的具体的监控模块，继承于MonitorContainer。当发现系统网络有问题时会调用父类的Notify方法。

[java] view plaincopy
(1)定义观察者：  
  
public class MonitorContainer {  
 private int state;  
   
 private List<IAlarm> obs;   
 //创建被观察者时就创建一个它持有的观察者列表  
 public MonitorContainer(){  
  obs = new ArrayList<IAlarm>();  
 }  
   
 //添加观察者到观察者列表中去    
 public void addAlarm(IAlarm obj){  
  if (obj == null) {  
   throw new NullPointerException();  
  }  
  if(!obs.contains(obj)){  
   obs.add(obj);  
  }  
 }  
 //删除一个观察者  
 public void remove(IAlarm obj){  
  obs.remove(obj);  
 }  
 //通知操作,即被观察者发生变化，通知对应的观察者进行事先设定的操作  
 public void notifyAlarm(){  
  //state 越小，级别越低  
  if (state == 2){  
   //邮件预警  
   new EmailAlarm().warm();  
  }  
  if(state == 1){  
   //消息预警  
   new SMSAlarm().warm();  
  }  
  if(state == 0){  
   //级别最高都需要预警  
   for (int i = 0; i<obs.size(); i++ ){  
    obs.get(i).warm();  
   }  
  }  
 }  
  
 public int getState() {  
  return state;  
 }  
  
 public void setState(int state) {  
  this.state = state;  
 }  
}  
  
(2) 具体观察者(网络预警)  
  
public class NetMonitor extends MonitorContainer {  
 public void doBusiness(int state){  
  super.setState(state);  
  //状态改变，通知观察者  
  notifyAlarm();  
 }  
}  
  
(3)定义观察者：  
  
public interface IAlarm {  
 public void warm();  
}  
  
  //具体观察者  
  
public class EmailAlarm implements IAlarm {  
  
 public void warm() {  
  System.out.println("EmailAlarm:电子邮件预警!");  
 }  
  
}  
  
 //具体观察者  
  
public class SMSAlarm implements IAlarm {  
  
 public void warm() {  
  System.out.println("SMSAlarm:短信预警!");  
 }  
  
}  
  
Client:  
public class ObserverClient {  
 public static void main(String []args){  
  NetMonitor netMonitor = new NetMonitor();  
  //添加观察者  
  EmailAlarm e = new EmailAlarm();  
  SMSAlarm s = new SMSAlarm();  
  netMonitor.addAlarm(e);  
  netMonitor.addAlarm(s);  
  netMonitor.doBusiness(0);  
 }  
}  

十五备忘录模式

其意图是在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可以将对象恢复到原先保存的状态。
备忘录实际上有两个接口，
“备忘录管理者角色”只能看到备忘录提供的窄接口——对于备忘录角色中存放的属性是不可见的。不能对备忘录的属性操作或检查
“备忘发起角色”则能够看到一个宽接口——能够得到自己放入备忘录角色中属性。

[java] view plaincopy
(1) 备忘录的发起者  
  
public class Employee {  
 private String name;  
   
 private int age;  
   
 private String sex;  
   
  
 // 定义一个备忘录管理者  
 private Caretaker c = new Caretaker();  
   
 public Employee(String name, int age, String sex){  
  this.name = name;  
  this.age = age;  
  this.sex = sex;  
 }  
   
 //创建一个备忘录角色，并将当前状态属性存入，托给"备忘录管理者角色"存放  
 public  void createMemento(){  
  c.saveMemento(new Memento(name));  
 }  
   
 //读取备忘录角色以恢复以前的状态  
 public void readMemento(){  
  this.name = c.getMemento().getName();  
 }  
   
 public void show(){  
  System.out.println("Employee");  
  System.out.println(" name:"+name);  
  System.out.println(" age:"+age);  
  System.out.println(" sex:"+sex);  
 }  
    
}  
  
   
  
(2)备忘录  
  
public class Memento {  
 private String name;  
   
 public Memento(String name){  
  this.name = name;  
 }  
  
 public String getName() {  
  return name;  
 }  
  
 public void setName(String name) {  
  this.name = name;  
 }  
}  
  
(3) 备忘录管理者  
  
public class Caretaker {  
 private List<Memento> meList;  
   
 //注意:备忘录，只能恢复前一步，比如redo,undo  
 private int current;  
   
 public Caretaker(){  
  current = -1;  
  meList = new ArrayList<Memento>();  
 }  
   
 public void saveMemento(Memento memento){  
  for (int i= current+1; i<meList.size(); i++){  
   meList.remove(i);  
  }  
  current ++;  
  meList.add(memento);  
 }  
   
 public Memento getMemento(){  
  if (current>=0){  
   return meList.get(current--);  
  }  
  return null;  
 }  
}  
  
   
  
Client:  
  
Employee employee = new Employee("chen",10,"男");  
  employee.createMemento();  
  employee.show();  
    
  employee.name ="qing";  
  employee.createMemento();  
  employee.show();  
    
  employee.name ="li";  
  employee.createMemento();  
  employee.show();  
    
  //从备忘录恢复  
  employee.readMemento();  
  employee.show();  
    
  //从备忘录恢复  
  employee.readMemento();  
  employee.show();  
    
  //从备忘录恢复  
  employee.readMemento();  
  employee.show();  

十六调停者模式

调停者模式有着分层设计的锥形，调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。
系统中有大量的对象，这些对象既会影响别的对象，又会被别的对象所影响，因此常常叫做同事（Colleague）对象。
抽象调停者（Mediator）角色：定义出同事对象到调停者对象的接口，其中主要的方法是一个（或多个）事件方法。在某些情况下，这个抽象对象可以省略。
具体调停者（ConcreteMediator）角色:实现了抽象超类所声明的事件方法。具体调停者知晓所有的具体同事类，它从具体同事对象接收消息，向具体同事对象发出命令。
抽象同事类（Colleague）角色:定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。

[java] view plaincopy
(1)调停者接口  
  
public interface  Mediator {  
 public  void colleagueChanged();  
}  
  
(2)具体调停者  
  
public class ConcreteMediator implements Mediator {  
   
 private Landlord landlord;  
   
 private Lodger lodger;  
   
 /*创建同事对象*/  
 public  ConcreteMediator(){  
  landlord = new Landlord(this);  
  lodger = new Lodger(this);  
 }  
   
 public void colleagueChanged() {  
  //这样中介拿到房东的房屋信息(s1)和租房者的需求信息(s2)  
  landlord.action();  
  String s1 = landlord.getHousesInfo();  
  lodger.action();  
  String s2 = lodger.getRequireInfo();  
  System.out.println("房屋信息:"+s1);  
  System.out.println("需求信息:"+s2);  
 }  
  
}  
  
   
  
(3) 抽象同事者  
  
public abstract class Colleague {  
 private Mediator mediator;  
   
 public Colleague(Mediator mediator){  
  this.mediator = mediator;  
 }  
   
 /* 获得调停者对象*/  
 public Mediator getMediator() {  
  return mediator;  
 }  
  
 //抽象行为  
 public abstract void action();  
   
}  
  
   
  
(4) 具体同时者 ，房东  
  
public class Landlord extends Colleague {  
   
 private String housesInfo;  
  
 public Landlord(Mediator mediator) {  
  super(mediator);  
 }  
   
 /** 
  * 房东具体的行为方法,例如,将房间资料交给中介等 
 */  
 @Override  
 public void action() {  
  housesInfo = ("进行将房间资料交给中介等操作");  
 }  
  
 public String getHousesInfo() {  
  return housesInfo;  
 }  
  
}  

十七解释器模式

描写简单语法的解释器，主要用在面向对象语言开发编译器中
定义上下文context类，定义HashMap
定义抽象类表达式Expression,定义方法interpret(Context con)
定义变量Variable，常量Constant，加法Add，减法Subtract，乘法Multiply ，除法Division 类表达式
计算 (a*b)/(a-b+2)

十八命令模式

解耦了发送者和接受者之间联系。发送者调用一个操作，接受者接受请求执行相应的动作，因为使用Command模式解耦，
发送者无需知道接受者任何接口。
将这些命令封装成在一个类中,将这些命令封装成在一个类中,然后用户(调用者)再对这个类进行操作,
这就是Command模式,换句话说,本来用户(调用者)是直接调用这些命令的,如菜单上打开文档(调用者),
就直接指向打开文档的代码,使用Command模式,就是在这两者之间增加一个中间者,将这种直接关系拗断,
同时两者之间都隔离,基本没有关系了.
在这个例子中，被操作的对象有电风扇(fan)和灯(light)，他们主要有开和关两种动作。把操作开或者关的请求封装成一个对象，
于是就有了在本例中就有FanOn(Off)Command和lightOn（Off）Command四个类，每个类都实现了Command接口，具备执行和撤销操作。
这些对象的协作关系是 Client创建一个具体的命令对象（fanOnCommand）并指定他的Receiver（fan）对象，
Invoker(dealer)对象存储该具体的命令对象，该Invoker通过调用Command对象的Execute对象的Execute操作来提交一个请求，
若该命令是可撤销的，具体的命令对象就再执行Execute之前存储当前的状态以取消该命令。
具体对象调用它的Receiver对象的一些操作以执行该请求。

(5) 具体同时者，房客

public class Lodger extends Colleague {

private String requireInfo;

public Lodger(Mediator mediator) {
  super(mediator);
  // TODO Auto-generated constructor stub
}

/**
* 房客具体的行为方法,例如,将租房需求交给中介等
*/

@Override
public void action() {
  requireInfo="进行将租房需求交给中介等操作";
}

public String getRequireInfo() {
return requireInfo;
}

}

Client:

public class MediatorClient {
public static void main(String []args){
ConcreteMediator c = new ConcreteMediator();
c.colleagueChanged();
}
}

转载自：http://blog.csdn.net/cdl2008sky/article/details/3335385

0 0