dede织梦织梦更换模板网站,官网排名优化方案,驻马店市网站建设,专业的网站优化公司模式通常被一起使用#xff0c;并被组合在同一个解决方案中。
复合模式在一个解决方案中结合两个或多个模式#xff0c;以解决一般或重复发生的问题。
首先重新构建鸭子模拟器#xff1a;
package headfirst.designpatterns.combining.ducks;public interface Quackable …模式通常被一起使用并被组合在同一个解决方案中。
复合模式在一个解决方案中结合两个或多个模式以解决一般或重复发生的问题。
首先重新构建鸭子模拟器
package headfirst.designpatterns.combining.ducks;public interface Quackable {public void quack();
}public class MallardDuck implements Quackable {public void quack() {System.out.println(Quack);}
}public class RubberDuck implements Quackable {public void quack() {System.out.println(Squeak);}
}
package headfirst.designpatterns.combining.ducks;public class DuckSimulator {public static void main(String[] args) {DuckSimulator simulator new DuckSimulator();simulator.simulate();}void simulate() {Quackable mallardDuck new MallardDuck();Quackable redheadDuck new RedheadDuck();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) {duck.quack();}
}
需求1有鸭子的地方大概率就会有鹅怎样在模拟器使用鹅呢适配器
package headfirst.designpatterns.combining.adapter;public class Goose {public void honk() {System.out.println(Honk);}
}
package headfirst.designpatterns.combining.adapter;public class GooseAdapter implements Quackable {Goose goose;public GooseAdapter(Goose goose) {this.goose goose;}public void quack() {goose.honk();}public String toString() {return Goose pretending to be a Duck;}
}
需求2如果在不变化鸭子类的情况下计算呱呱叫的次数呢装饰者
将鸭子包装进装饰者对象赋予鸭子一些新行为。
package headfirst.designpatterns.combining.decorator;public class QuackCounter implements Quackable {Quackable duck;static int numberOfQuacks;public QuackCounter (Quackable duck) {this.duck duck;}public void quack() {duck.quack();numberOfQuacks;}public static int getQuacks() {return numberOfQuacks;}public String toString() {return duck.toString();}
}
// 更新模拟器Quackable mallardDuck new QuackCounter(new MallardDuck());
需求3有时候我们在代码中可能搞忘装饰对象所以我们希望在最开始创建的时候就确保鸭子是被装饰过的工厂模式
package headfirst.designpatterns.combining.factory;public abstract class AbstractDuckFactory {public abstract Quackable createMallardDuck();public abstract Quackable createRedheadDuck();public abstract Quackable createDuckCall();public abstract Quackable createRubberDuck();
}
package headfirst.designpatterns.combining.factory;public class CountingDuckFactory extends AbstractDuckFactory {public Quackable createMallardDuck() {return new QuackCounter(new MallardDuck());}public Quackable createRedheadDuck() {return new QuackCounter(new RedheadDuck());}public Quackable createDuckCall() {return new QuackCounter(new DuckCall());}public Quackable createRubberDuck() {return new QuackCounter(new RubberDuck());}
}
抽象工厂通过传入不同的工厂到创建方法中得到不同的产品家族。
package headfirst.designpatterns.combining.factory;public class DuckSimulator {public static void main(String[] args) {DuckSimulator simulator new DuckSimulator();AbstractDuckFactory duckFactory new CountingDuckFactory();simulator.simulate(duckFactory);}void simulate(AbstractDuckFactory duckFactory) {Quackable mallardDuck duckFactory.createMallardDuck();Quackable redheadDuck duckFactory.createRedheadDuck();Quackable duckCall duckFactory.createDuckCall();Quackable rubberDuck duckFactory.createRubberDuck();Quackable gooseDuck new GooseAdapter(new Goose());System.out.println(\nDuck Simulator: With Abstract Factory);simulate(mallardDuck);simulate(redheadDuck);simulate(duckCall);simulate(rubberDuck);simulate(gooseDuck);System.out.println(The ducks quacked QuackCounter.getQuacks() times);}void simulate(Quackable duck) {duck.quack();}
}
需求4同时管理一群鸭子组合模式
package headfirst.designpatterns.combining.composite;import java.util.Iterator;
import java.util.ArrayList;public class Flock implements Quackable {ArrayListQuackable quackers new ArrayListQuackable();public void add(Quackable quacker) {quackers.add(quacker);}public void quack() {IteratorQuackable iterator quackers.iterator();while (iterator.hasNext()) {Quackable quacker iterator.next();quacker.quack();}}public String toString() {return Flock of Quackers;}
}
package headfirst.designpatterns.combining.composite;public class DuckSimulator {public static void main(String[] args) {DuckSimulator simulator new DuckSimulator();AbstractDuckFactory duckFactory new CountingDuckFactory();simulator.simulate(duckFactory);}void simulate(AbstractDuckFactory duckFactory) {Quackable redheadDuck duckFactory.createRedheadDuck();Quackable duckCall duckFactory.createDuckCall();Quackable rubberDuck duckFactory.createRubberDuck();Quackable gooseDuck new GooseAdapter(new Goose());System.out.println(\nDuck Simulator: With Composite - Flocks);Flock flockOfDucks new Flock();flockOfDucks.add(redheadDuck);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 mallardFour duckFactory.createMallardDuck();flockOfMallards.add(mallardOne);flockOfMallards.add(mallardTwo);flockOfMallards.add(mallardThree);flockOfMallards.add(mallardFour);flockOfDucks.add(flockOfMallards);System.out.println(\nDuck Simulator: Whole Flock Simulation);simulate(flockOfDucks);System.out.println(\nDuck Simulator: Mallard Flock Simulation);simulate(flockOfMallards);System.out.println(\nThe ducks quacked QuackCounter.getQuacks() times);}void simulate(Quackable duck) {duck.quack();}
}
需求5持续追踪个别鸭子的实时呱呱叫观察者模式
package headfirst.designpatterns.combining.observer;public interface QuackObservable {public void registerObserver(Observer observer);public void notifyObservers();
}public interface Quackable extends QuackObservable {public void quack();
}
现在需要保证Quackable的具体类都能扮演QuackObservable角色在具体类中添加一个arraylist变量然后实现接口方法。但这里用的不同的做法不知道为什么在Observable类中封装注册和通知的代码然后将其和具体类组合在一起。
package headfirst.designpatterns.combining.observer;import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;public class Observable implements QuackObservable {ListObserver observers new ArrayListObserver();QuackObservable duck;public Observable(QuackObservable duck) {this.duck duck;}public void registerObserver(Observer observer) {observers.add(observer);}public void notifyObservers() {IteratorObserver iterator observers.iterator();while (iterator.hasNext()) {Observer observer iterator.next();observer.update(duck);}}public IteratorObserver getObservers() {return observers.iterator();}
}
package headfirst.designpatterns.combining.observer;public class MallardDuck implements Quackable {Observable observable;public MallardDuck() {observable new Observable(this);}public void quack() {System.out.println(Quack);notifyObservers();}public void registerObserver(Observer observer) {observable.registerObserver(observer);}public void notifyObservers() {observable.notifyObservers();}public String toString() {return Mallard Duck;}
} ------------------------------------------------------------------------------------
