• 1. Java与设计模式Lesson 1
  • 2. 设计模式分类 创建模式 结构模式 行为模式 优点 面向接口编程 降低耦合性 增加灵活性
  • 3. 创建模式
  • 4. 设计模式之Factory -工厂模式客户类和工厂类分开。消费者任何时候需要某种产品,只需向工厂请求即可。消费者无须修改就可以接纳新产品。 缺点是当产品修改时,工厂类也要做相应的修改。
  • 5. 设计模式之Factory -工厂模式public class Factory{    public static Sample creator(int which){      if (which==1)     return new SampleA();    else if (which==2)     return new SampleB();   } } public class SampleA extends Sample {  } public class SampleB extends Sample {  } 如果要实例化Sample时.就使用 Sample a=Factory.creator(1); // instance of SampleA Sample b=Factory.creator(2); // instance of SampleB
  • 6. public class Factory{    public static Sample creator(String className){    //getClass 产生Sample 一般可使用动态类装载装入类。 Class c =Class.forName(className);    return (Sample) c.newInstance();   } } 如何调用Builder模式: Sample a=Factory.creator(“SampleA”); // instance of SampleA Sample b=Factory.creator(“SampleB”); // instance of SampleB
  • 7. 设计模式之FACTORY METHOD -工厂方法模式核心工厂类不再负责所有产品的创建,而是将具体创建的工作交给子类去做,成为一个抽象工厂角色,仅负责给出具体工厂类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。
  • 8. 设计模式之FACTORY METHOD 工厂模式public abstract class Factory{    public abstract Sample creator();   public abstract Sample2 creator(String name); } public class SimpleFactory extends Factory{   public Sample creator(){     return new SampleA   }   public Sample2 creator(String name){     return new Sample2A   } } public class BombFactory extends Factory{   public Sample creator(){    ......     return new SampleB   }   public Sample2 creator(String name){     return new Sample2B   } }
  • 9. 設計模式之Builder -建造模式将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。 建造模式可以强制实行一种分步骤进行的建造过程。
  • 10. 設計模式之Builder -建造模式public interface Builder {      void buildPartA(); //創建部件A  比如創建汽車車輪   void buildPartB(); //創建部件B 比如創建汽車方向盤   void buildPartC(); //創建部件C 比如創建汽車發動機   //返回最後組裝成品結果 (返回最後裝配好的汽車)   //成品的組裝過程不在這裏進行,而是轉移到下面的Director類別中進行。   //從而實現解耦   Product getResult(); } public class Director {    private Builder builder;   public Director( Builder builder ) { this.sbuilder = builder; }   public void construct() { // 將部件partA partB partC最後組成複雜物件        builder.buildPartA();     builder.buildPartB();     builder.buildPartC();    } Product getResult(){ return builder.getResult();} }
  • 11. public class ConcreteBuilder implements Builder {   Part partA, partB, partC;   public void buildPartA() {     //这里是具体如何构建partA的代码   }   public void buildPartB() {     //这里是具体如何构建partB的代码   }    public void buildPartC() {     //这里是具体如何构建partB的代码   }    public Product getResult() {     //返回最后组装成品结果   } } 如何调用Builder模式: Builder builder = new ConcreteBuilder(); Director director = new Director( builder ); director.construct(); Product product = builder.getResult();
  • 12. 設計模式之PROTOTYPE -原始模型模式通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类,产品类不需要非得有任何事先确定的等级结构,原始模型模式适用于任何的等级结构。 缺点是每一个类都必须配备一个克隆方法。
  • 13. 設計模式之PROTOTYPE -原始模型模式public abstract class AbstractSpoon implements Cloneable{   String spoonName;   public void setSpoonName(String spoonName) { this.spoonName = spoonName; }   public String getSpoonName() {return this.spoonName;}   public Object clone() {     Object object = null;     try {       object = spoonName.clone();     } catch (CloneNotSupportedException exception) {       System.err.println("AbstractSpoon is not Cloneable");     }     return object;   } }  
  • 14. public class SoupSpoon extends AbstractSpoon{   public SoupSpoon(){     setSpoonName("Soup Spoon");   } } public class SaladSpoon extends AbstractSpoon{   public SaladSpoon(){     setSpoonName("Salad Spoon");   } } 调用Prototype模式很简单: AbstractSpoon spoon1 = new SoupSpoon(); String s1=(String) spoon1. clone() ; AbstractSpoon spoon2 = new SaladSpoon(); String s2=(String) spoon2. clone() ; 当然也可以结合工厂模式来创建AbstractSpoon实例
  • 15. 设计模式之Singleton -单例模式单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例模式。 单例模式只应在有真正的“单一实例”的需求时才可使用。
  • 16. 设计模式之Singleton -单例模式public class Singleton {     private Singleton() {} private static Singleton instance = null;   public static synchronized Singleton getInstance() {   //不用每次都进行生成对象,只是第一次使用时生成实例,提高了效率!    if (instance==null)     instance=new Singleton();     return instance;    } }   Singleton s= Singleton.getInstance() ;
  • 17. 結構模式
  • 18. 設計模式之Adapter -适配器把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。
  • 19. 設計模式之Adapter -适配器public interface IRoundPeg{   public void insertIntoHole(String msg); } public interface ISquarePeg{   public void insert(String str); } public class PegAdapter implements IRoundPeg, ISquarePeg{   private IRoundPeg roundPeg;   private ISquarePeg squarePeg;   // 構造方法   public PegAdapter(IRoundPeg peg){this.roundPeg=peg;}     public PegAdapter(ISquarePeg peg)(this.squarePeg=peg;) // 方法   public void insert(String str){ roundPeg.insertIntoHole(str);}   public void insertIntoHole(String str){SquarePeg.insert(str);} }
  • 20. 設計模式之Bridge -桥梁模式将抽象化与实现化脱耦,使得二者可以独立的变化,也就是说将他们之间的强关联变成弱关联,也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系,从而使两者可以独立的变化。
  • 21. 設計模式之Bridge -桥梁模式public abstract class Coffee{   CoffeeImp coffeeImp;   public void setCoffeeImp() {     this.CoffeeImp = CoffeeImpSingleton.getTheCoffeImp();   }   public CoffeeImp getCoffeeImp() {return this.CoffeeImp;}   public abstract void pourCoffee(); } public abstract class CoffeeImp{   public abstract void pourCoffeeImp(); } //bridge public class CoffeeImpSingleton{   private static CoffeeImp coffeeImp;   public CoffeeImpSingleton(CoffeeImp coffeeImpIn) {this.coffeeImp = coffeeImpIn;}   public static CoffeeImp getTheCoffeeImp(){     return coffeeImp;   } } 
  • 22. //中杯 public class MediumCoffee extends Coffee{   public MediumCoffee() {setCoffeeImp();}   public void pourCoffee(){     CoffeeImp coffeeImp = this.getCoffeeImp();          for (int i = 0; i < 2; i++){       coffeeImp.pourCoffeeImp();     }     } } //大杯 public class SuperSizeCoffee extends Coffee{   public SuperSizeCoffee() {setCoffeeImp();}   public void pourCoffee(){     CoffeeImp coffeeImp = this.getCoffeeImp();         for (int i = 0; i < 5; i++){       coffeeImp.pourCoffeeImp();     }     } }
  • 23. //加奶 public class MilkCoffeeImp extends CoffeeImp {   MilkCoffeeImp() {}   public void pourCoffeeImp()   {     System.out.println("加了美味的牛奶");   } } //不加奶 public class FragrantCoffeeImp extends CoffeeImp {   FragrantCoffeeImp() {}   public void pourCoffeeImp(){     System.out.println("什么也没加,清香");   } }
  • 24. 看看中杯加奶 和大杯加奶 是怎么出来的: 动态结合,我们现在可以喝到至少四种咖啡: 1.中杯加奶 2.中杯不加奶 3.大杯加奶 4.大杯不加奶 //拿出牛奶 CoffeeImpSingleton coffeeImpSingleton = new CoffeeImpSingleton(new MilkCoffeeImp()); //中杯加奶 MediumCoffee mediumCoffee = new MediumCoffee(); mediumCoffee.pourCoffee(); //大杯加奶 SuperSizeCoffee superSizeCoffee = new SuperSizeCoffee(); superSizeCoffee.pourCoffee(); 注意: Bridge模式的执行类如CoffeeImp和Coffee是一对一的关系, 正确创建CoffeeImp是该模式的关键,
  • 25. 設計模式之Composite -合成模式合成模式将对象组织到树结构中,可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。 合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
  • 26. 設計模式之Composite -合成模式public abstract class Equipment{   private String name; public Equipment(final String name) { this.name=name; }      public abstract double netPrice();//網路價格     public abstract double discountPrice(); //折扣價格    //增加部件方法     public boolean add(Equipment equipment) { return false; }   //刪除部件方法   public boolean remove(Equipment equipment) { return false; }   //注意, 這裏就提供一種用於訪問組合體類別的部件方法。   public Iterator iter() { return null; }   } public class Disk extends Equipment{ public Disk(String name) { super(name); }  public double netPrice() { return 1.; } //定义Disk网络价格为1    public double discountPrice() { return .5; } //定义了disk折扣价格是0.5 对折。 }
  • 27. abstract class CompositeEquipment extends Equipment{   private int i=0;   //定义一个ArrayList用来存放'儿子‘instance   private List equipments=new ArrayList();   public CompositeEquipment(String name) { super(name); }   public boolean add(Equipment equipment) {      this.equipments.add(equipment);      return true;    }   public double discountPrice() {     double discountPrice=0.;     Iterator iter=equipments.iterator();     for(iter.hasNext())   public double netPrice() {     double netPrice=0.;     Iterator iter=equipments.iterator();     for(iter.hasNext())       netPrice+=((Equipment)iter.next()).netPrice();     return netPrice;   }       discountPrice+=((Equipment)iter.next()).discountPrice();     return discountPrice;   } }
  • 28. public class Chassis extends CompositeEquipment{    public Chassis(String name) { super(name); }    public double netPrice() { return 1.+super.netPrice(); }    public double discountPrice() { return .5+super.discountPrice(); } } public class Cabinet extends CompositeEquipment{    public Cabinet(String name) { super(name); }    public double netPrice() { return 1.+super.netPrice(); }    public double discountPrice() { return .5+super.discountPrice(); } } 客户端调用Composote代码: Chassis chassis=new Chassis("PC Chassis"); chassis.add(new Disk("10 GB")); //将硬盘装到盘盒里 Cabinet cabinet=new Cabinet("Tower"); cabinet.add(chassis);//将盘盒装到箱子里 //调用 netPrice()方法; System.out.println("netPrice="+ cabinet.netPrice()); System.out.println("discountPrice="+ cabinet.discountPrice());
  • 29. 設計模式之DECORATOR -装饰模式装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案,提供比继承更多的灵活性。动态给一个对象增加功能,这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。
  • 30. 設計模式之DECORATOR -装饰模式public interface Work { public void insert(); } public class SquarePeg implements Work{ //核心功能   public void insert() { System.out.println("方形樁插入"); } } public class Decorator implements Work{    private Work work; //核心功能   private ArrayList others = new ArrayList(); //額外增加的功能被打包在這個List中   //在構造器中使用組合new方式,引入Work物件;   public Decorator(Work work){     this.work=work;       others.add("挖坑");     others.add("釘木板");   }  //在新方法中,我們在insert之前增加其他方法,這裏次序先後是用戶靈活指定的      public void insert(){otherMethod(); work.insert(); }      public void otherMethod(){     ListIterator listIterator = others.listIterator();     while (listIterator.hasNext()) {       System.out.println(((String)(listIterator.next())) + " 正在進行");     }   }   }
  • 31. 如何调用: Work squarePeg = new SquarePeg(); Work decorator = new Decorator(squarePeg); decorator.insert(); 为什么使用Decorator? 我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的. 使用Decorator的理由: 这些功能需要由用户动态决定加入的方式和时机.Decorator提供了"即插即用"的方法,在运行期间决定何时增加何种功能.
  • 32. 設計模式之Facade -门面模式外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口,使得子系统更易于使用。每一个子系统只有一个门面类,而且此门面类只有一个实例,也就是说它是一个单例模式。但整个系统可以有多个门面类。
  • 33. 設計模式之Facade -门面模式public class DBCompare {   String sql = “SELECT * FROM WHERE = ?”;     try {      MyDB msql=new MyDB(sql); // Facade PreparedStatement prep=msql.getPreparedStatement();     prep.setString( 1, "" );     ResultSet rset = prep.executeQuery();      if( rset.next() )         System.out.println( rset.getString( "
  • 34. 設計模式之FLYWEIGHT -享元模式FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部,不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态,它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来,将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象,而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类).
  • 35. 設計模式之FLYWEIGHT -享元模式public class CD {    private String title;   private int year;   private Artist artist;   public String getTitle() {  return title; }   public int getYear() {    return year;  }   public Artist getArtist() {    return artist;  }   public void setTitle(String t){    title = t;}   public void setYear(int y){year = y;}   public void setArtist(Artist a){artist = a;} } public class Artist {      private String name; //內部狀態 public Artist(String n){     name = n;   }   String getName(){return name;}   // note that Artist is immutable. }
  • 36. Flyweight factory负责维护一个Flyweight池(存放内部状态),当客户端请求一个共享Flyweight时,这个factory首先搜索池中是否已经有可适用的,如果有,factory只是简单返回送出这个对象,否则,创建一个新的对象,加入到池中,再返回送出这个对象池. Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多:比如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们可以将这些字符串储存在Flyweight池(pool)中. public class ArtistFactory {    Hashtable pool = new Hashtable();   public static Artist getArtist(String key){     Artist result;     result = (Artist)pool.get(key);     ////産生新的Artist     if(result == null) {       result = new Artist(key);       pool.put(key,result);            }     return result;   } }
  • 37. 設計模式之PROXY -代理模式代理模式给某一个对象提供一个代理对象,并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下,客户不想或者不能够直接引用一个对象,代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象,而仅仅持有一个被代理对象的接口,这时候代理对象不能够创建被代理对象,被代理对象必须有系统的其他角色代为创建并传入。
  • 38. 設計模式之PROXY -代理模式public class ForumPermissions implements Cacheable public class ForumProxy implements Forum public class DbForum implements Forum, Cacheable
  • 39. 行为模式
  • 40. 設計模式之Chain of Responsibility -職責鏈 在责任链模式中,很多对象由每一个对象对其下家的引用而接 起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求,系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择:承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。
  • 41. 設計模式之Chain of Responsibility 職責鏈public interface Handler{   public void handleRequest(Request request); } public class Request{   private String type;   public Request(String type){this.type=type;}   public String getType(){return type;}   public void execute(){//request真正具體行爲代碼   } } public class ConcreteHandler implements Handler{   private Handler successor;   public ConcreteHandler(Handler successor){     this.successor=successor;   }   public void handleRequest(Request request){     if (request instanceof HelpRequest){        request.execute(); //這裏是處理HelpRequest的具體代碼     }else if (request instanceof PrintRequest){       request.execute();//這裏是處理PrintRequst的具體代碼     }else       successor.handleRequest (request);  //傳遞到下一個     }   } }
  • 42. 設計模式之COMMAND - 命令模式 命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开,委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求是怎么被接收,以及操作是否执行,何时被执行以及是怎么被执行的。系统支持命令的撤消。
  • 43. 設計模式之COMMAND - 命令模式public interface Command {   public abstract void execute ( ); } public class Producer{   public static List produceRequests() {     List queue = new ArrayList();     queue.add( new Engineer() );     queue.add( new Politician() );     queue.add( new Programmer() );     return queue;   } } public class Engineer implements Command {   public void execute( ) { //do Engineer's command } } public class Programmer implements Command {   public void execute( ) { //do programmer's command } } public class Politician implements Command {   public void execute( ) {//do Politician's command} }
  • 44. 具体的Command模式代码各式各样,因为如何封装命令,不同系统,有不同的做法.下面事例是将命令封装在一个Collection的List中,任何对象一旦加入List中,实际上装入了一个封闭的黑盒中,对象的特性消失了,只有取出时,才有可能模糊的分辨出: public class TestCommand {   public static void main(String[] args) {          List queue = Producer.produceRequests();     for (Iterator it = queue.iterator(); it.hasNext(); )         ((Command)it.next()).execute();      } } 由此可见,调用者基本只和接口打交道,不和具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了.
  • 45. 設計模式之INTERPRETER -解释器模式给定一个语言后,解释器模式可以定义出其文法的一种表示,并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后,使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构,也就是一系列的组合规则。每一个命令对象都有一个解释方法,代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。
  • 46. 設計模式之INTERPRETER -解释器模式定義語言的文法 ,並且建立一個解釋器來解釋該語言中的句子。
  • 47. 設計模式之ITERATOR -迭代子模式迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集,聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中,从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象,每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。
  • 48. 設計模式之ITERATOR -迭代子模式用來遍曆Collection中对象 public class TestCommand {   public static void main(String[] args) {          List queue = Producer.produceRequests();     for (Iterator it = queue.iterator(); it.hasNext(); )         //取出List中对象,其他特徵都不能確定,只能保證一個特徵是100%正確,他們至少是Command的"兒子"。所以強制轉換類別型爲Command         ((Command)it.next()).execute();      } }
  • 49. 設計模式之MEDIATOR -调停者模式调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时,不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。 调停者模式将对象的行为和协作抽象化,把对象在小尺度的行为上与其他对象的相互作用分开处理。
  • 50. 設計模式之MEDIATOR -调停者模式public interface Mediator { } public class ConcreteMediator implements Mediator {    //假設當前有兩個成員.    private ConcreteColleague1 colleague1 = new ConcreteColleague1();    private ConcreteColleague2 colleague2 = new ConcreteColleague2(); ... } public class Colleague {    private Mediator mediator;    public Mediator getMediator() {       return mediator;    }    public void setMediator( Mediator mediator ) {       this.mediator = mediator;    } } public class ConcreteColleague1 { } public class ConcreteColleague2 { }
  • 51. 設計模式之MEMENTO -备忘录模式备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下,将一个对象的状态捉住,并外部化,存储起来,从而可以在将来合适的时候把这个对象还原到存储起来的状态。
  • 52. 設計模式之MEMENTO -备忘录模式public class Originator {    private int number;   private File file = null;   public Originator(){}  // 創建一個Memento   public Memento getMemento(){     return new Memento(this);   }  // 恢復到原始值   public void setMemento(Memento m){      number = m.number;      file = m.file;   } } private class Memento implements java.io.Serializable{    private int number;   private File file = null;   public Memento( Originator o){     number = o.number;     file = o.file;   } }
  • 53. 設計模式之OBSERVER -观察者模式观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使他们能够自动更新自己。
  • 54. 設計模式之OBSERVER -观察者模式public class product extends Observable{   private String name;   private float price;   public String getName(){ return name;}   public void setName(){    this.name=name;    //設置變化點    setChanged();    notifyObservers(name);   }    } public class NameObserver implements Observer{    private String name=null;   public void update(Observable obj,Object arg){     if (arg instanceof String){      name=(String)arg;      //産品名稱改變值在name中      System.out.println("NameObserver :name changet to "+name);     }   } }
  • 55. 設計模式之STATE -状态模式状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里,每一个状态对象都属于一个抽象状态类的一个子类。 状态模式的意图是让一个对象在其内部状态改变的时候,其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时,系统便改变所选的子类。
  • 56. 設計模式之STATE -状态模式public class BlueState extends State{   public void handlePush(Context c){      //根據push方法"如果是blue狀態的切換到green" ;      c.setState(new GreenState());   }   public void handlePull(Context c){      //根據pull方法"如果是blue狀態的切換到red" ;     c.setState(new RedState());   }   public void getColor(){ return (Color.blue)} }
  • 57. public class Context{   private State state=null; //我們將原來的 Color state 改成了新建的State state;   //setState是用來改變state的狀態 使用setState實現狀態的切換   pulic void setState(State state){     this.state=state;   }   public void push(){     //狀態的切換的細節部分,在本例中是顔色的變化,已經封裝在子類別的handlepush中實現,這裏無需關心     state.handlePush(this);          //因爲sample要使用state中的一個切換結果,使用getColor()     Sample sample=new Sample(state.getColor());     sample.operate();   }     public void pull(){     state.handlePull(this);          Sample2 sample2=new Sample2(state.getColor());     sample2.operate();   } }
  • 58. 設計模式之STRATEGY-策略模式策略模式针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类,各种算法在具体的策略类中提供。由于算法和环境独立开来,算法的增减,修改都不会影响到环境和客户端。
  • 59. 設計模式之STRATEGY-策略模式public abstract class RepTempRule{ protected String oldString=""; public void setOldString(String oldString){   this.oldString=oldString; } protected String newString=""; public String getNewString(){   return newString; } public abstract void replace() throws Exception; } public class RepTempRuleOne extends RepTempRule{ public void replace() throws Exception{ //… } } public class Test{   public void testReplace(){    //使用第一套方案進行替換。     RepTempRule rule=new RepTempRuleOne();     rule.setOldString(record);     rule.replace();   } }
  • 60. 設計模式之TEMPLATE METHOD-模板方法模式模板方法模式准备一个抽象类,将部分逻辑以具体方法以及具体构造子类的形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法,从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架,而将逻辑的细节留给具体的子类去实现。
  • 61. 設計模式之TEMPLATE METHOD-模板方法模式public abstract class Benchmark{    public abstract void benchmark();       public final long repeat (int count) {     if (count <= 0)       return 0;     else {       long startTime = System.currentTimeMillis();     for (int i = 0; i < count; i++)       benchmark();      long stopTime = System.currentTimeMillis();      return stopTime - startTime;    } } } public class MethodBenchmark extends Benchmark{     public void benchmark() {      for (int i = 0; i < Integer.MAX_VALUE; i++)       System.out.printtln("i="+i);        } }
  • 62. 設計模式之VISITOR -访问者模式访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话,接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统,它把数据结构和作用于结构上的操作之间的耦合解脱开,使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易,就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中,而不是分散到一个个的节点类中。当使用访问者模式时,要将尽可能多的对象浏览逻辑放在访问者类中,而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。
  • 63. 設計模式之VISITOR -访问者模式public interface Visitable{    public void accept(Visitor visitor); } public class ConcreteVisitor implements Visitor{    public void visitCollection(Collection collection) {       Iterator iterator = collection.iterator()       while (iterator.hasNext()) {          Object o = iterator.next();          if (o instanceof Visitable)             ((Visitable)o).accept(this);       } }   public void visitString(String string) {       System.out.println("'"+string+"'");    }    public void visitFloat(Float float) {       System.out.println(float.toString()+"f");    } }