Java經典23種設計模式之行為型模式(四)，23種設計模式

Java經典23種設計模式之行為型模式(四)，23種設計模式

本文介紹11種行為型設計模式裡的策略模式、模板方法、訪問者模式。

一、策略模式

定義一系列的演算法,把它們每個封裝起來,並且使它們可相互替換。本模式使得演算法可獨立於使用它的客戶而變化。

1.Strategy定義所有支援的演算法的公用介面。Context使用這個介面來調用某ConcreteStrategy定義的演算法。

public abstract class Strategy {
    public abstract void method();
}

2.ConcreteStrategy以Strategy介面實現某具體演算法。

public class *trategyImplA extends Strategy {    public voi* method() {        System.out.println("這是第一個實現");    }}public class StrategyImplB extends Strategy {    public void method() {        System.out.println("這是第二個實現");    }}public class StrategyImplC extends Strategy {    public void method() {        Syst*m.out.println("這是第三個實現");    }}

3.Context用一個ConcreteStrategy對象來配置。維護一個對Strategy對象的引用。可定義一個介面來讓Stategy訪問它的資料。

pub*ic class Context {


    Strategy stra;
    
    public Cont*xt(Strategy stra) {
        this.stra = stra;
    }
    
    pub*ic void doMethod() {
        stra*method();
    }
}

測試代碼：

public class Test {        public static void main(String[] ar*s) {        Context ctx = new C*ntext(new StrategyImplA());        ctx.doMethod();                ctx = new Context(new *trategyImplB());        ctx.doMethod();                ctx = new Context(new StrategyImplC());        ctx.doMethod();    }}

適應性：

1.許多相關的類僅僅是行為有異。“策略”提供了一種用多個行為中的一個行為來配置一個類的方法。
2.需要使用一個演算法的不同變體。
3.演算法使用客戶不應該知*的資料。可使用原則模式以避免暴露複雜的、與演算法相關的資料結構。
4*一個類定義了多種行為,並且這些行為在這個類的操作中以*個條件陳述式的形式出現。將相關的條件分支移入它們各自的Strategy類中以代替這些條件陳述式。

二、模板方法

定義每個操作中的演算法的骨架，*將一些步驟延遲到子類中。TemplateMethod使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。

 1.AbstractClass定義抽象的原語操作（primitiveoperation），具體的子類將重定義它們以實現一個演算法的各步驟。實現一個模板方法,定義一個演算法的骨架。該模板方法不僅調用原語操作，也調用定義在AbstractClass或其他對象中的操作。

public abstract class Template {


    public abstract void print();
    
    public void update() {
        System.out.println("開始列印");
        for (int i = 0; i < 10; i++) {
            print();
        }
    }
}

2.ConcreteClass實現*語操作以完成演算法中與特定子類相關的步驟。

public class TemplateConcrete extends Template {


    @override
    public void print() {
        System.out.println("這是子類的實現");
    }
}

測試代碼：

public class Test {


    pu*lic static void main(String[] args) {
        Te*plate temp = new TemplateConcrete();
        temp.update();
    }
}

適用性：

    1.一次性實現一個演算法的不變的部分，並將可變的*為留給子類來實現。
    2.各子類中公用的行為應被提取出來並集中到一個公用父類中以避免代碼重複。首先識別現有*碼中的不同之處，並且將不同之處分離為新的操作。最後，用*個調用這些新的操作的模板方法來替換這些不同的代碼。
    3.控制子類擴充。

三、訪問者模式

    表示一個作用於某對象結構中的各元素的操作。它使你可以在不改變各元素的類的前提下定義作用於這些元素的新操作。

    1.Visitor為該對象結構中ConcreteEle*ent的每一個類聲明一個Visit操作。該操作的名字和特徵標識了發送*isit請求給該訪問者的那個類。這使得訪問者可以確定正被訪問元素*具體的類。這樣訪問者就可以通過該元素的特定介面直*訪問它。

public interface Visitor {


    public void visitString(StringElement stringE);
    
    public void visitFloat(FloatElement floatE);
    
    public void visitCollection(Collection collection); 
}

    2.Concret*Visitor實現每個由Visitor聲明的操作。每個操作實現本演算法的一部分，而該演算法片斷乃是對應於結構中對象的類。Concret*Visitor*該演算法提供了上下文並存*它的局部狀態。
這一狀態常常在遍曆該結構的過程中累*結果。

public class C*ncreteVisitor implements Visitor {    public void visitCollectio*(Collection colle*tion) {        // TODO Auto-generated method stub        Iterator iterator = collection.iterator();        while (iterator.hasNext()) {            Object o = iterato*.next();            if (o in*tanceof Visitable) {                (*Visitable)o).accept(this);            }        }    }    public void visitFloat(FloatElement floatE) {        System.out.println(floatE.getFe*));    }    public void visitString(StringElement stringE) {        System.out.println(stringE.getSe());    }}

    3.Element
      定義一個Accept操作，它以一個訪問者為參數。

public interface Visitabl* {


    publ*c void accept(Visitor visitor);
}

    4.ConcreteElement
      實現Accept操作，該操作以一個訪問者為參數。

public class FloatElement implements Visitable {    private Float fe;        public FloatElement(Float fe) {        this.fe = fe;    }        public Float getFe() {        return this.fe;    }        public void accept(Visitor visitor) {        visitor.*isitFloat(this);    }}public class StringElement implements Visitable *    private String se;        public String*lement(String se) {        this.se = se;    }        public String getS*() {        return thi*.se;    }        public void accept(Visitor visitor) {        visitor.visitString(this);    }}

測試代碼：

public class Test {    public static void main(String[] args) {        Visitor visitor = new ConcreteVisitor();        StringElement se = new StringElement("abc");        s*.accep*(visitor);                Fl*atElement fe = new FloatElement(n*w Float(1.5));        fe.accept(visitor);        S*stem.out.println("===========");        List result = new ArrayList();        result.add(new StringEle*ent("abc"));        result.a*d(new StringElement("abc"));        result.add(*ew StringElement("abc"));        result.add(new FloatElement(new Float(1.5)));        result.add(new FloatElement(new Float(1.5)));        result.add(new FloatElement(new Float(1.5)));        visitor.visitCollection(result);    }}

適應性：  

  1.一個對象結構包含很多類對象，它們有不同的介面，而你想對這些對象實施一些依賴於其具體類的操*。
   2.需要對一個對象結構中的對象進行很多不同的並且不相關的操作，*你想避免讓這些操作“汙染”這些對象的類。
      Visitor使得你可以將相關的操作集中起來定義在一個類中。
      當該對象結構被很多應用共用時，用Visitor模式讓每個應用僅包含需要用到的操作。
    3.定義對象結構的類很少改變，但經常需要在此結構上定義新的操作。
      改變對象結構類需要重定義對所有訪問者的介面，這可能*要很大的代價。
      如果對象結構類經常改變，那麼可能還是在這些類中定義這些操作較好。

java 23種設計模式

設計模式主要分三個類型:建立型、結構型和行為型。
其中建立型有：
一、Singleton，單例模式：保證一個類只有一個執行個體，並提供一個訪問它的全域訪問點
二、Abstract Factory，抽象工廠：提供一個建立一系列相關或相互依賴對象的介面，而無須指定它們的具體類。
三、Factory Method，Factory 方法：定義一個用於建立對象的介面，讓子類決定執行個體化哪一個類，Factory Method使一個類的執行個體化延遲到了子類。
四、Builder，建造模式：將一個複雜物件的構建與他的表示相分離，使得同樣的構建過程可以建立不同的表示。
五、Prototype，原型模式：用原型執行個體指定建立對象的種類，並且通過拷貝這些原型來建立新的對象。
行為型有：
六、Iterator，迭代器模式：提供一個方法順序訪問一個彙總對象的各個元素，而又不需要暴露該對象的內部表示。
七、Observer，觀察者模式：定義對象間一對多的依賴關係，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知自動更新。
八、Template Method，模板方法：定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中，TemplateMethod使得子類可以不改變一個演算法的結構即可以重定義該演算法得某些特定步驟。
九、Command，命令模式：將一個請求封裝為一個對象，從而使你可以用不同的請求對客戶進行參數化，對請求排隊和記錄請求日誌，以及支援可撤銷的操作。
十、State，狀態模式：允許對象在其內部狀態改變時改變他的行為。對象看起來似乎改變了他的類。
十一、Strategy，策略模式：定義一系列的演算法，把他們一個個封裝起來，並使他們可以互相替換，本模式使得演算法可以獨立於使用它們的客戶。
十二、China of Responsibility，職責鏈模式：使多個對象都有機會處理請求，從而避免請求的送發者和接收者之間的耦合關係
十三、Mediator，中介者模式：用一個中介對象封裝一些列的對象互動。
十四、Visitor，訪問者模式：表示一個作用於某對象結構中的各元素的操作，它使你可以在不改變各元素類的前提下定義作用於這個元素的新操作。
十五、Interpreter，解譯器模式：給定一個語言，定義他的文法的一個表示，並定義一個解譯器，這個解譯器使用該表示來解釋語言中的句子。
十六、Memento，備忘錄模式：在不破壞對象的前提下，捕獲一個對象的內部狀態，並在該對象之外儲存這個狀態。
結構型有：
十七、Composite，組合模式：將對象組合成樹形結構以表示部分整體的關係，Composite使得使用者對單個對象和組合對象的使用具有一致性。
十八、Facade，面板模式：為子系統中的一組介面提供一致的介面，fa?ade提供了一高層介面，這個介面使得子系統更容易使用。
十九、Proxy，代理模式：為其他對象提供一種代理以控制對這個對象的訪問
二十、Adapter,適配器模式：將一類的介面轉換成客戶希望的另外一個介面，Adapter模式使得原本由於介面不相容而不能一起工作那些類可以一起工作。
二十一、Decrator，裝飾模式：動態地給一個對象增加一些額外的職責，就增加的功能來說，Decorator模式相比產生子類更加靈活。
二十二、Bridge，橋模式：將抽象部分與它的實現部分......餘下全文>>
 
Java中23種設計模式,什是必須瞭解的?

1、簡單原廠模式（Simple Factory Pattern）
2、建造者模式（Builder Pattern）
3、策略（Strategy）模式
4、Factory 方法模式（Factory Method Pattern）
5、抽象原廠模式（Abstract Factory）
6、命令模式（Command Pattern）
7、模版方法（Template Method）
8、單件模式（Single Pattern）
9、原型模式（Prototype Pattern）