興大作業(yè)設計模式代碼

1、1. 創(chuàng)建Quackable接口package yjx;public interface Quackable public void quack();/Quackable只需做好一件事 Quack（呱呱叫）現在某些鴨子實現了Quackable接口public class MallardDuck implements Quackable public void quack() System.out.println(Quack);package yjx;public class RedheadDuck implements Quackablepublic void quack() System.o

2、ut.println(Quack);package yjx;public class DuckCall implements Quackable /DuckCall(鴨鳴器)會呱呱叫，但聽起來并不十分像真的鴨叫public void quack() System.out.println(Kwak);package yjx;public class RubberDuck implements Quackable /當 RubberDuck（橡皮鴨）呱呱叫時，其聲音是吱吱叫public void quack() System.out.println(Squeak);3. 我們有了鴨子，需要模擬器p

3、ackage yjx;public class DuckSimulator public static void main(String args) /我們的main（）方法將讓所有的事情動起來 DuckSimulator simulator = new DuckSimulator(); /創(chuàng)建一個模擬器，然后調用simulator()方法 simulator.simulate();void simulate() Quackable mallardDuck = new MallardDuck(); /把每一種會叫的東西都產生一份實例 Quackable redheadDuck = new Re

4、dheadDuck(); Quackable duckCall = new DuckCall(); Quackable rubberDuck = new RubberDuck();System.out.println(nDuck Simulator); simulate(mallardDuck); /開始模擬每種鴨子 simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck);void simulate(Quackable duck) /我們重載了simulate()方法來模擬一只鴨子 duck.quack();/剩下的事就讓

5、多態(tài)發(fā)揮作用，無論傳入哪一種對象，多態(tài)都可調到正確的方法運行后出現：Duck SimulatorQuackQuackKwakSqueak4.當鴨子出現在這里的時候，就大概會有鴨子和鵝，我們?yōu)檫@個模擬器設計了一個Goose(鵝)類。package goosemodel_Sxl;public class Goose public void honk()System.out.println(Honk);/鵝的叫聲是咯咯5.鵝適配器 我們的模擬器期望看到Quackable接口.既然鵝不會呱呱叫,我們可以利用適配器將鵝適配成鴨子.package goosemodel_Sxl;import duckmod

6、el_Sxl.Quackable;public class GooseAdapter implements QuackableGoose goose;public GooseAdapter(Goose goose)this.goose = goose; public void quack() goose.honk(); 6.模擬器總可以使用鵝了 我們需要創(chuàng)建Goose對象,將它包裝進適配器,以便實現Quackable。package goosemodel_Sxl;import duckmodel_Sxl.DuckCall;import duckmodel_Sxl.MallardDuck;imp

7、ort duckmodel_Sxl.Quackable;import duckmodel_Sxl.RedheadDuck;import duckmodel_Sxl.RubberDuck;public class DuckSimulator public static void main(String args) /我們的main（）方法將讓所有的事情動起來 DuckSimulator simulator = new DuckSimulator(); /創(chuàng)建一個模擬器，然后調用simulator()方法 simulator.simulate();void simulate() Quackable

8、 mallardDuck = new MallardDuck(); /把每一種會叫的東西都產生一份實例 Quackable redheadDuck = new RedheadDuck(); Quackable duckCall = new DuckCall(); Quackable rubberDuck = new RubberDuck(); Quackable gooseDuck = new GooseAdapter(new Goose();/通過把Goose包裝進GooseAdapter，我們就可以讓鵝像鴨子一樣 System.out.println(nDuck Simulator); s

9、imulate(mallardDuck); /開始模擬每種鴨子 simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck); simulate(gooseDuck); /一旦鵝被包裝起來，我們就可以把它當作其他鴨子的Quackable對象void simulate(Quackable duck) /我們重載了simulate()方法來模擬一只鴨子 duck.quack();/剩下的事就讓多態(tài)發(fā)揮作用，無論傳入哪一種對象，多態(tài)都可調到正確的方法7.測試一下 測試時，simulate()會調用許多對象的quack()方法，其中包括

10、適配器的quack()方法，結果出現咯咯叫（honk）Duck SimulatorQuackQuackKwakSqueakHonk8.統(tǒng)計叫聲的次數 通過把鴨子包裝進裝飾者對象，給鴨子一些行為（計算次數的行為）。package counter_Sxl;import duckmodel_Sxl.Quackable;public class QuackCounter implements QuackableQuackable duck;static int numberOfQuacks; /用靜態(tài)變量跟蹤所有呱呱叫的次數public QuackCounter (Quackable duck) /將

11、Quackable當作參數傳入構造器，并記錄在實例變量中。this.duck = duck; public void quack() duck.quack(); /當quack（）被調用時，我們就把調用委托給正在裝飾的Quackable對象 numberOfQuacks+; /把叫聲的次數加一 public static int getQuacks() /給裝飾者加入一個靜態(tài)方法，以便返回在所有的Quackable中發(fā)生的叫聲次數 return numberOfQuacks; 9.更新模擬器，以便創(chuàng)建被裝飾的鴨子 包裝在QuackCounter裝飾者中被實例化的每個Quackable對象pac

12、kage counter_Sxl;import goosemodel_Sxl.Goose;import goosemodel_Sxl.GooseAdapter;import duckmodel_Sxl.DuckCall;import duckmodel_Sxl.MallardDuck;import duckmodel_Sxl.Quackable;import duckmodel_Sxl.RedheadDuck;import duckmodel_Sxl.RubberDuck;public class DuckSimulator public static void main(String arg

13、s) /我們的main（）方法將讓所有的事情動起來 DuckSimulator simulator = new DuckSimulator(); /創(chuàng)建一個模擬器，然后調用simulator()方法 simulator.simulate();void simulate() Quackable mallardDuck = new QuackCounter (new MallardDuck(); /把每一種會叫的東西都產生一份實例 Quackable redheadDuck = new QuackCounter(new RedheadDuck(); Quackable duckCall = new

14、 QuackCounter(new DuckCall(); Quackable rubberDuck = new QuackCounter(new RubberDuck(); Quackable gooseDuck = new GooseAdapter(new Goose();/通過把Goose包裝進GooseAdapter，我們就可以讓鵝像鴨子一樣 System.out.println(nDuck Simulator:With Decorator); simulate(mallardDuck); /開始模擬每種鴨子 simulate(redheadDuck); simulate(duckCa

15、ll); simulate(rubberDuck); simulate(gooseDuck); /一旦鵝被包裝起來，我們就可以把它當作其他鴨子的Quackable對象 System.out.println(The ducks quacked + QuackCounter.getQuacks() + times);/在這里我們?yōu)檫蛇山袑W家收集呱呱叫行為void simulate(Quackable duck) /我們重載了simulate()方法來模擬一只鴨子 duck.quack();/剩下的事就讓多態(tài)發(fā)揮作用，無論傳入哪一種對象，多態(tài)都可調到正確的方法輸出:Duck Simulator:Wi

16、th DecoratorQuackQuackKwakSqueakHonkThe ducks quacked 4times10.我們需要工廠產生鴨子 我們需要一些質量控制來確保鴨子一定是被包裝起來的.我們要建造一個工廠,創(chuàng)建裝飾過得鴨子.此工廠應該生產各種不同類型的鴨子的產品家族,所以使用抽象工廠模式.package factory_Sxl;import duckmodel_Sxl.Quackable;public abstract class AbstractDuckFactory /定義一個抽象工廠，它的子類們會創(chuàng)建不同的家族public abstract Quackable createM

17、allardDuck(); /每個方法創(chuàng)建一種鴨子public abstract Quackable createRedheadDuck();public abstract Quackable createDuckCall();public abstract Quackable createRubberDuck();創(chuàng)建一個工廠,此工廠創(chuàng)建沒有裝飾者的鴨子package factory_Sxl;import duckmodel_Sxl.DuckCall;import duckmodel_Sxl.MallardDuck;import duckmodel_Sxl.Quackable;import

18、duckmodel_Sxl.RedheadDuck;import duckmodel_Sxl.RubberDuck;public class DuckFactory extends AbstractDuckFactory / DuckFactory擴展抽象工廠public Quackable createMallardDuck() /每個方法創(chuàng)建一個產品，一種特定種類的Quackable，模擬器并不知道實際產品是什么，值知道它實現了Quackable接口return new MallardDuck();public Quackable createRedheadDuck()return new

19、 RedheadDuck();public Quackable createDuckCall()return new DuckCall();public Quackable createRubberDuck()return new RubberDuck();現在創(chuàng)建真正需要的工廠CountingDuckFactorypackage factory_Sxl;import counter_Sxl.QuackCounter;import duckmodel_Sxl.DuckCall;import duckmodel_Sxl.MallardDuck;import duckmodel_Sxl.Quack

20、able;import duckmodel_Sxl.RedheadDuck;import duckmodel_Sxl.RubberDuck;public class CountingDuckFactory extends AbstractDuckFactorypublic Quackable createMallardDuck()return new QuackCounter(new MallardDuck();public Quackable createRedheadDuck()return new QuackCounter(new RedheadDuck();public Quackab

21、le createDuckCall()return new QuackCounter(new DuckCall();public Quackable createRubberDuck()return new QuackCounter(new RubberDuck();11.設置模擬器來使用這個工廠 創(chuàng)建一個多態(tài)的方法，此方法需要一個創(chuàng)建對象的工廠，通過傳入不同的工廠，我們就會得到不同的產品家族。package factory_Sxl;import counter_Sxl.QuackCounter;import goosemodel_Sxl.Goose;import goosemodel_Sxl

22、.GooseAdapter;import duckmodel_Sxl.Quackable;public class DuckSimulator public static void main(String args) /我們的main（）方法將讓所有的事情動起來 DuckSimulator simulator = new DuckSimulator(); /創(chuàng)建一個模擬器，然后調用simulator()方法 AbstractDuckFactory duckFactory = new CountingDuckFactory(); /創(chuàng)建工廠，準備把它傳入simulate（）方法 simulato

23、r.simulate(duckFactory);void simulate(AbstractDuckFactory duckFactory) /simulate()方法需要AbstractDuckFactory參數，利用它創(chuàng)建鴨子，而不是直接實例化鴨子 Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable duckCall = duckFactory.createDuckCall(); Quackabl

24、e rubberDuck =duckFactory.createRubberDuck(); Quackable gooseDuck = new GooseAdapter(new Goose();/通過把Goose包裝進GooseAdapter，我們就可以讓鵝像鴨子一樣 System.out.println(nDuck Simulator:With Decorator); simulate(mallardDuck); /開始模擬每種鴨子 simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck); simulate(gooseD

25、uck); /一旦鵝被包裝起來，我們就可以把它當作其他鴨子的Quackable對象 System.out.println(The ducks quacked + QuackCounter.getQuacks() + times);/在這里我們?yōu)檫蛇山袑W家收集呱呱叫行為void simulate(Quackable duck) /我們重載了simulate()方法來模擬一只鴨子 duck.quack();/剩下的事就讓多態(tài)發(fā)揮作用，無論傳入哪一種對象，多態(tài)都可調到正確的方法執(zhí)行后：Duck Simulator:With DecoratorQuackQuackKwakSqueakHonkThe d

26、ucks quacked 4times12.讓我們創(chuàng)建一群鴨子（實際上是一群Quackable） package flock_Sxl;import java.util.ArrayList;import java.util.Iterator;import duckmodel_Sxl.Quackable;public class Flock implements QuackableArrayList quackers = new ArrayList();public void add(Quackable quacker)quackers.add( quacker); public void qua

27、ck() Iterator iterator = quackers.iterator(); while (iterator.hasNext() Quackable quacker = (Quackable)iterator.next(); quacker.quack(); 13.修改模擬器我們需要一些鴨子能進入組合結構的代碼。package flock_Sxl;import counter_Sxl.QuackCounter;import duckmodel_Sxl.Quackable;import factory_Sxl.AbstractDuckFactory;import factory_S

28、xl.CountingDuckFactory;import goosemodel_Sxl.Goose;import goosemodel_Sxl.GooseAdapter;public class DuckSimulator public static void main(String args) /我們的main（）方法將讓所有的事情動起來 DuckSimulator simulator = new DuckSimulator(); /創(chuàng)建一個模擬器，然后調用simulator()方法 AbstractDuckFactory duckFactory = new CountingDuckFac

29、tory(); /創(chuàng)建工廠，準備把它傳入simulate（）方法 simulator.simulate(duckFactory);void simulate(AbstractDuckFactory duckFactory) /simulate()方法需要AbstractDuckFactory參數，利用它創(chuàng)建鴨子，而不是直接實例化鴨子 /Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable duckCal

30、l = duckFactory.createDuckCall(); Quackable rubberDuck =duckFactory.createRubberDuck(); Quackable gooseDuck = new GooseAdapter(new Goose();/通過把Goose包裝進GooseAdapter，我們就可以讓鵝像鴨子一樣 System.out.println(nDuck Simulator:With Decorator - Flocks);Flock flockOfDucks = new Flock();flockOfDucks.add(redheadDuck);

31、flockOfDucks.add(duckCall);flockOfDucks.add(rubberDuck);flockOfDucks.add(gooseDuck);Flock flockOfMallards = new Flock();Quackable mallardOne = duckFactory.createMallardDuck(); Quackable mallardTwo = duckFactory.createMallardDuck(); Quackable mallardThree = duckFactory.createMallardDuck(); Quackable

32、mallardFour = duckFactory.createMallardDuck(); flockOfMallards.add(mallardOne); flockOfMallards.add(mallardTwo); flockOfMallards.add(mallardThree); flockOfMallards.add(mallardFour); flockOfDucks.add(flockOfMallards); /simulate(mallardDuck); /開始模擬每種鴨子 /simulate(redheadDuck); /simulate(duckCall); /sim

33、ulate(rubberDuck); /simulate(gooseDuck); /一旦鵝被包裝起來，我們就可以把它當作其他鴨子的Quackable對象 System.out.println(nDuck Simulator:Whole Flock Simulation); simulate(flockOfDucks); System.out.println(nDuck Simulator:Mallard Flock Simulation); simulate(flockOfMallards); System.out.println(The ducks quacked + QuackCounte

34、r.getQuacks() + times);/在這里我們?yōu)檫蛇山袑W家收集呱呱叫行為void simulate(Quackable duck) /我們重載了simulate()方法來模擬一只鴨子 duck.quack();/剩下的事就讓多態(tài)發(fā)揮作用，無論傳入哪一種對象，多態(tài)都可調到正確的方法執(zhí)行結果：Duck Simulator:With Decorator - FlocksDuck Simulator:Whole Flock SimulationQuackKwakSqueakHonkQuackQuackQuackQuackDuck Simulator:Mallard Flock Simula

35、tionQuackQuackQuackQuackThe ducks quacked 11times14.想要觀察個別鴨子的行為適用觀察者模式 首先需要一個Observable接口，所謂的Observable就是被觀察的對象。Observable需要注冊和通知觀察者的方法。package observable_Sxl;import java.util.Observable;public interface QuackObservable /QuackObservable是一個接口，任何想被觀察的Quackable都必須實現QuackObservable接口public void register

36、Observer(Observable observer); /當具有注冊觀察者的方法，任何實現了Observable接口的對象都可以監(jiān)聽呱呱叫，稍后我們會定義觀察者接口public void notifyObservers(); /它也有通知觀察者的方法現在我們需要確定所有的Quackable都實現此接口public interface Quackable extends QuackObservable /我們干脆讓Quackable來擴展此接口public void quack();/Quackable只需做好一件事 Quack（呱呱叫）15.現在我們必須確定所有實現Quakable的具體

37、類都能夠扮演QuackObservable的角色我們要在另一個被稱為Observable的類中封裝注冊和通知的代碼，然后將它和QuackObservable組合在一起，這樣我們只需要一份代碼即可，QuackObservable所有的調用都委托給Observable輔助類public class Observable implements QuackObservable ArrayList duck6 = new ArrayList();QuackObservable duck; public Observable(QuackObservable duck) this.duck = duck;

38、public void registerObserver(Observer observer) duck6.add(observer); public void notifyObservers() Iterator iterator = duck6.iterator();while (iterator.hasNext() Observer duck6 = iterator.next();duck6.update(duck); public Iterator getObservers() return duck6.iterator();16整合Observable輔助類和Quackable類，我

39、們只要確定Quackable類是和Observable組合在一起的，并且他們知道怎樣來委托工作。然后，它們就準備好成為Observable了。public class MallardDuck2 extends MallardDuck implements QuackablePlusObservable duck6; public MallardDuck2() duck6 = new Observable(this); public void quack() super.quack();notifyObservers(); public void registerObserver(Observe

40、r observer) duck6.registerObserver(observer); public void notifyObservers() duck6.notifyObservers();17 public interface Observer public void update(QuackObservable duck);public class Quackologist implements Observer public void update(QuackObservable duck) System.out.println(Quackologist: + duck + just quacked.); public String toString() return Quackologist;18 public class DuckSimulator private static final AbstractDuckFactory DuckFa