设计模式大作业报告

1、2015 年 6 月 18 日问题描述2设计描述21、 duck1 详细步骤2duck1 类图42. duck2 详细步骤4duck2 类图53.duck3 详细步骤6duck3 类图74. duck4 详细步骤7duck4 类图95.duck5 详细步骤9duck5 类图116. duck6 详细步骤11duck6 类图14设计的评价14设计的扩充15总结15问题描述设计一个鸭子模拟器，可以实现鸭子、鸭鸣器、橡皮鸭的呱呱叫，鹅的咯咯叫。添加一名装饰者，统计叫的次数。创建鸭子工厂，实现需要鸭子时，直接从工厂调用。将他们集结成群，允许群中有群，便于管理。观察者，当呱呱声响起时，观察者就会被通知，

2、统计通知它的鸭子的个数和像鸭子一样叫的个数。设计时可以使用设计模式，应用成设计模式能够增强代码的可复用性、可扩展性与可性，设计模式具有的设计上的弹性会给之后的变更带来些便利。设计描述1、 duck1 详细步骤1、创建一个 Quackable 接口，这样就知道这个模拟器中，有哪些东西可以呱呱叫，像绿头鸭、红头鸭，甚至可能还会看到橡皮鸭。package duck1;publicerface Quackablepublic void quack();Quackable 只需做好一件事 Quack（呱呱叫）2、设计一些具体的鸭子，来实现 Quackable 接口public class Mallard

3、Duck implements Quackable 标准绿头鸭public class RedheadDuck implements Quackable加入鸭鸣器和橡皮鸭public class DuckCall implements Quackable DuckCall(鸭鸣器)会呱呱叫，但听起来并不十分像真的鸭叫public class RubberDuck implements Quackable 当 RubberDuck（橡皮鸭）呱呱叫时，其声音是吱吱叫制造一个确认鸭子会呱呱叫的模拟器public class DuckSimulatorpublic sic void main(Stri

4、ng args)main（）方法将让所有事情动起来DuckSimulator simulator = new DuckSimulator(); 创建一个模拟器，simulator.simulate();然后调用 simulator()方法void simulate()把每一种会叫的东西都产生一份实例，开始模拟每种鸭子void simulate(Quackable duck)重载了 simulate()方法来模拟一只鸭子duck.quack();剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法运行后出现：Duck SimulatorQuackQuackKwakSqueakdu

5、ck1 类图2. duck2 详细步骤4、当鸭子出现在这里的时候，就大概会有鸭子和鹅类。为这个模拟器设计了一个 Goose(鹅)package goosem_duck2;public class Goose /鹅的是咯咯5.鹅适配器的模拟望看到 Quackable 接口.既然鹅不会呱呱叫,可以利用适配器将鹅适配成鸭子.public class GooseAdapter implements QuackableGoose goose;public GooseAdapter(Goose goose)6. 模拟器总可以使用鹅了，Quackable。需要创建 Goose 对象, 将它包装进适配器, 以

6、便实现public class DuckSimulatorpublic sic void main(String args)main（）方法将让所有的事情动起来DuckSimulator simulator = new DuckSimulator();创建一个模拟器，然后调用 simulator()方法void simulate()把每一种会叫的东西都产生一份实例，通过把 Goose 包装进 GooseAdapter，就可以让鹅像鸭子一样System.out.prln(nDuck Simulator);开始模拟每种鸭子，一旦鹅被包装起来，就可以把它当作其他鸭子的 Quackable 对象voi

7、d simulate(Quackable duck)重载了 simulate()方法来模拟一只鸭子duck.quack();方法剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的7.测试一下测试时，simulate()会调用许多对象的 quack()方法，其中包括适配器的 quack()方法，结果出现咯咯叫（honk）Duck SimulatorQuackQuackKwakSqueakHonkduck2 类图3.duck3 详细步骤8.统计的次数，通过把鸭子包装进装饰者对象，给鸭子一些行为（计算次数的行为）。package duck3publicclass QuackCounte

8、r implements QuackablesicnumberOfQuacks; 用静态变量所有呱呱叫的次数publicQuackCounter (Quackable duck) 将 Quackable 当作参数传入构造器，并在实例变量中。public void quack()duck.quack(); 当 quack（）被调用时，就把调用委托给正在装饰的 Quackable 对象numberOfQuacks+; 把的次数加一public s中发生的ic次数getQuacks()给装饰者加入一个静态方法，以便返回在所有的 Quackablereturn numberOfQuacks;9.更新模

9、拟器，以便创建被装饰的鸭子，包装在 QuackCounter 装饰者中被实例化的每个Quackable 对象public class DuckSimulator public sic void main(String args)main（）方法将让所有的事情动起来DuckSimulator simulator = new DuckSimulator();创建一个模拟器，然后调用 simulator()方法Quackable mallardDuck = new QuackCounter (new MallardDuck();把每一种会叫的东西都产生一份实例Quackable gooseDuck

10、= new GooseAdapter(new Goose(); 通 过 把 Goose 包 装 进GooseAdapter，就可以让鹅像鸭子一样simulate(mallardDuck); 开始模拟每种鸭子simulate(gooseDuck); 一旦鹅被包装起来，就可以把它当作其他鸭子的 Quackable 对象system.out.prln(The ducks quacked + QuackCounter.getQuacks() + times);在这里为呱呱叫学家收集呱呱叫行为void simulate(Quackable duck)重载了 simulate()方法来模拟一只鸭子duck

11、.quack();剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法输出:Duck Simulator:With DecoratorQuackQuackKwakSqueakHonkThe ducks quacked4timesduck3 类图4. duck4 详细步骤10.需要工厂产生鸭子需要一些质量控制来确保鸭子一定是被包装起来的.要建造一个工厂,创建装饰过得鸭子.此工厂应该生产各种不同类型的鸭子的产品用抽象工厂模式.,所以使public abstract class AbstractDuckFactory 定义一个抽象工厂，它的子类们会创建不同的public abstra

12、ct Quackable createMallardDuck(); 每个方法创建一种鸭子创建一个工厂,此工厂创建没有装饰者的鸭子public class DuckFactory extends AbstractDuckFactory DuckFactory 扩展抽象工厂public Quackable createMallardDuck() 每个方法创建一个产品， 一种特定种类的Quackable，模拟器并不知道实际产品是什么，值知道它实现了 Quackable 接口现在创建真正需要的工厂 CountingDuckFactorypublic class CountingDuckFactory

13、extends AbstractDuckFactory11.设置模拟器来使用这个工厂，创建一个多态的方法，此方法需要一个创建对象的工厂，通过传入不同的工厂，就会得到不同的产品。public class DuckSimulator public sic void main(String args)main（）方法将让所有的事情动起来DuckSimulator simulator = new DuckSimulator();创建一个模拟器，然后调用 simulator()方法AbstractDuckFactory duckFactory = new CountingDuckFactory(); 创

14、建工厂，准备把它传入 simulate（）方法voidsimulate(AbstractDuckFactoryduckFactory)simulate()方法需要AbstractDuckFactory 参数，利用它创建鸭子，而不是直接实例化鸭子Quackable gooseDuck = new GooseAdapter(new Goose(); 通 过 把 Goose 包 装 进GooseAdapter，就可以让鹅像鸭子一样simulate(mallardDuck); 开始模拟每种鸭子simulate(gooseDuck); /一旦鹅被包装起来，对象就可以把它当作其他鸭子的 Quackable

15、System.out.prln(The ducks quacked + QuackCounter.getQuacks() + times);在这里为呱呱叫学家收集呱呱叫行为void simulate(Quackable duck)重载了 simulate()方法来模拟一只鸭子duck.quack();剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法执行后：Duck Simulator:With DecoratorQuackQuackKwakSqueakHonkThe ducks quacked4timesduck4 类图5.duck5 详细步骤12.让创建一群鸭子（实际上是

16、一群 Quackable）publicclass Flock implements Quackablepublicvoid add(Quackable quacker)publicvoid quack()Quackable quacker = (Quackable)iterator.next();13.修改模拟器，需要一些鸭子能进入组合结构的代码。public class DuckSimulator public sic void main(String args)main（）方法将让所有的事情动起来DuckSimulator simulator = new DuckSimulator();创

17、建一个模拟器，然后调用 simulator()方法AbstractDuckFactory duckFactory = new CountingDuckFactory();创建工厂，准备把它传入 simulate（）方法voidsimulate(AbstractDuckFactoryduckFactory)simulate()方法需要AbstractDuckFactory 参数，利用它创建鸭子，而不是直接实例化鸭子Quackable gooseDuck = new GooseAdapter(new Goose(); 通 过 把 Goose 包 装 进GooseAdapter，就可以让鹅像鸭子一样

18、simulate(mallardDuck); 开始模拟每种鸭子simulate(gooseDuck); 一旦鹅被包装起来，就可以把它当作其他鸭子的 Quackable 对象System.out.prln(The ducks quacked + QuackCounter.getQuacks() + times);在这里为呱呱叫学家收集呱呱叫行为void simulate(Quackable duck)重载了 simulate()方法来模拟一只鸭子duck.quack();剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法执行结果：Duck Simulator:With Deco

19、rator - FlocksDuck Simulator:Whole Flock SimulationQuackKwakSqueakHonkQuackQuackQuackQuackDuck Simulator:MallardFlock SimulationQuackQuackQuackQuackThe ducks quacked 11timesduck5 类图6. duck6 详细步骤14.想要观察个别鸭子的行为适用观察者模式，首先需要一个 Observable 接口，所谓的Observable 就是被观察的对象。Observable 是需要和通知观察者的方法。publicerface Qua

20、ckObservable QuackObservable 是一个接口， 任何想被观察的Quackable 都必须实现 QuackObservable 接口public void registerObserver(Observable observer); 当具有观察者的方法，任何实现了 Observable 接口的对象都可以呱呱叫，稍后会定义观察者接口publicvoid notifyObservers();它也有通知观察者的方法现在需要确定所有的 Quackable 都实现此接口publicerface Quackable extends QuackObservable干脆让 Quackab

21、le 来扩展接口publicvoid quack();Quackable 只需做好一件事 Quack（呱呱叫）15.、现在须确定所有实现 Quakable 的具体类都能够扮演 QuackObservable 的角色，要在另一个被称为 Observable 的类中封装和通知的代码， 然后将它和QuackObservable 组合在一起，这样用都委托给 Observable 辅助类只需要一份代码即可，QuackObservable 所有的调public class Observable implements QuackObservableObservable 必须 实现QuackObservabl

22、e 因为它们具有一组相同的方法，QuackObservable 会将这些方法的调用转给Observable 的方法public Observable(QuackObservable duck)再此构造器中，传进了 QuackObservable，当通知发生时，观察者把此对象传过去，让观察者知道叫的对象public void registerObserver(Observer observer)观察者public void notifyObservers()通知观察者整合 Observable 辅助类和 Quakable 类只要确定 Quakable 类是和 Observable 组合在一起的，

23、并且他们知道怎样来委托工作，然后，他们就准备好成为 Observable，下面是MallardDuck 的实现，其他的鸭子实现也类似public class MallardDuck2 extends MallardDuck implements QuackablePlusObservable duck6;每个 Quackable 都有一个 Quackable 实例变量notifyObservers();呱呱叫时，让观察者知道public void registerObserver(Observer observer)public void notifyObservers() 委托给辅助类需要把

24、模式的 Observer 端完成，还需要一些观察者 Observerpublicerface Observublic void update(QuackObservable duck); Observer 接口只有一个方法 update()，他需要传入正在呱呱叫的对象(QuackObservable)public class Quackologist implements Observerpublic void update(QuackObservable duck)实现呱呱叫更新模拟器，准备开始观察void simulate(AbstractDuckFactory duckFactory)

25、创建鸭子工厂和鸭子，创建群Quackologist quackologist = new Quackologist();创建 Quackologist，把它个群的观察者成为一flockOfDucks.registerObserver(quackologist);simulate(flockOfDucks);模拟整个群运行结果：Duck Simulator: With ObserverQuackQuackologist:duck6.RedheadDuck212ac706a just quacked.KwakQuackologist:duck6.DuckCall2770848b9 just quacked.SqueakQuackologist:duck6.RubberDuck240dea6bc just quacked.Quackologist:duck6.GooseAdapter25994a1e9 just quacked.QuackQuackologist:duck6.MallardDuck22d11f5f1 just quacked.QuackQuackologist:duck6.MallardDuck27629b854 just quacked.QuackQuackologist: duck6.MallardDuck22d04cf