兴大作业设计模式代码

1、1. 创建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(); /创建一个模拟器，然后调用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、多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法运行后出现：Duck SimulatorQuackQuackKwakSqueak4.当鸭子出现在这里的时候，就大概会有鸭子和鹅，我们为这个模拟器设计了一个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.模拟器总可以使用鹅了 我们需要创建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(); /创建一个模拟器，然后调用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();/剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法7.测试一下 测试时，simulate()会调用许多对象的quack()方法，其中包括

10、适配器的quack()方法，结果出现咯咯叫（honk）Duck SimulatorQuackQuackKwakSqueakHonk8.统计叫声的次数 通过把鸭子包装进装饰者对象，给鸭子一些行为（计算次数的行为）。package counter_Sxl;import duckmodel_Sxl.Quackable;public class QuackCounter implements QuackableQuackable duck;static int numberOfQuacks; /用静态变量跟踪所有呱呱叫的次数public QuackCounter (Quackable duck) /将

11、Quackable当作参数传入构造器，并记录在实例变量中。this.duck = duck; public void quack() duck.quack(); /当quack（）被调用时，我们就把调用委托给正在装饰的Quackable对象 numberOfQuacks+; /把叫声的次数加一 public static int getQuacks() /给装饰者加入一个静态方法，以便返回在所有的Quackable中发生的叫声次数 return numberOfQuacks; 9.更新模拟器，以便创建被装饰的鸭子 包装在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(); /创建一个模拟器，然后调用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);/在这里我们为呱呱叫学家收集呱呱叫行为void simulate(Quackable duck) /我们重载了simulate()方法来模拟一只鸭子 duck.quack();/剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法输出:Duck Simulator:Wi

16、th DecoratorQuackQuackKwakSqueakHonkThe ducks quacked 4times10.我们需要工厂产生鸭子 我们需要一些质量控制来确保鸭子一定是被包装起来的.我们要建造一个工厂,创建装饰过得鸭子.此工厂应该生产各种不同类型的鸭子的产品家族,所以使用抽象工厂模式.package factory_Sxl;import duckmodel_Sxl.Quackable;public abstract class AbstractDuckFactory /定义一个抽象工厂，它的子类们会创建不同的家族public abstract Quackable createM

17、allardDuck(); /每个方法创建一种鸭子public abstract Quackable createRedheadDuck();public abstract Quackable createDuckCall();public abstract Quackable createRubberDuck();创建一个工厂,此工厂创建没有装饰者的鸭子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() /每个方法创建一个产品，一种特定种类的Quackable，模拟器并不知道实际产品是什么，值知道它实现了Quackable接口return new MallardDuck();public Quackable createRedheadDuck()return new

19、 RedheadDuck();public Quackable createDuckCall()return new DuckCall();public Quackable createRubberDuck()return new RubberDuck();现在创建真正需要的工厂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.设置模拟器来使用这个工厂 创建一个多态的方法，此方法需要一个创建对象的工厂，通过传入不同的工厂，我们就会得到不同的产品家族。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(); /创建一个模拟器，然后调用simulator()方法 AbstractDuckFactory duckFactory = new CountingDuckFactory(); /创建工厂，准备把它传入simulate（）方法 simulato

23、r.simulate(duckFactory);void simulate(AbstractDuckFactory duckFactory) /simulate()方法需要AbstractDuckFactory参数，利用它创建鸭子，而不是直接实例化鸭子 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);/在这里我们为呱呱叫学家收集呱呱叫行为void simulate(Quackable duck) /我们重载了simulate()方法来模拟一只鸭子 duck.quack();/剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法执行后：Duck Simulator:With DecoratorQuackQuackKwakSqueakHonkThe d

26、ucks quacked 4times12.让我们创建一群鸭子（实际上是一群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(); /创建一个模拟器，然后调用simulator()方法 AbstractDuckFactory duckFactory = new CountingDuckFac

29、tory(); /创建工厂，准备把它传入simulate（）方法 simulator.simulate(duckFactory);void simulate(AbstractDuckFactory duckFactory) /simulate()方法需要AbstractDuckFactory参数，利用它创建鸭子，而不是直接实例化鸭子 /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);/在这里我们为呱呱叫学家收集呱呱叫行为void simulate(Quackable duck) /我们重载了simulate()方法来模拟一只鸭子 duck.quack();/剩下的事就让多态发挥作用，无论传入哪一种对象，多态都可调到正确的方法执行结果：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接口的对象都可以监听呱呱叫，稍后我们会定义观察者接口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