CS 350 – Software Design Putting Patterns Together Let’s put a lot of patterns together. We need a lot of ducks! public interface Quackable { public void quack(); public void quack();} Some ducks that implement Quackable. public class MallardDall implements Quackable { public void quack() { public void quack() { System.out.println(“Quack”); System.out.println(“Quack”); }} public class RedheadDuck implements Quackable { public void quack() { public void quack() { System.out.println(“Quack”); System.out.println(“Quack”); }}

CS 350 – Software Design Putting Patterns Together More quackable ducks. public class DuckCall implements Quackable { public void quack() { public void quack() { System.out.println(“Kwak”); System.out.println(“Kwak”); }} public class RubberDuck implements Quackable { public void quack() { public void quack() { System.out.println(“Squeak”); System.out.println(“Squeak”); }}

CS 350 – Software Design Putting Patterns Together public class DuckSimulator { public static void main(String[] args) { public static void main(String[] args) { DuckSimulator simultor = new DuckSimulator(); DuckSimulator simultor = new DuckSimulator(); simulator.simulate(); simulator.simulate(); } void simulator() { void simulator() { Quackable mallardDuck = new MallardDuck(); Quackable mallardDuck = new MallardDuck(); Quackable redheadDuck = new RedheadDuck(); Quackable redheadDuck = new RedheadDuck(); Quackable duckCall = new DuckCall(); Quackable duckCall = new DuckCall(); Quackable rubberDuck = new RubberDuck(); Quackable rubberDuck = new RubberDuck(); System.out.println(“\nDuck Simulator”); System.out.println(“\nDuck Simulator”); simulate(mallardDuck); simulate(mallardDuck); simulate(redheadDuck); simulate(redheadDuck); simulate(duckCall); simulate(duckCall); simulate(rubberDuck); simulate(rubberDuck); void simulate(Quackable duck) { void simulate(Quackable duck) { duck.quack(); duck.quack(); }}

CS 350 – Software Design Putting Patterns Together public class Goose { public void honk() { public void honk() { System.out.println(“Honk”); System.out.println(“Honk”); }} public class Witch{ public void Complains() { public void Complains() { System.out.println(“I am not a witch, they dressed me like this!”); System.out.println(“I am not a witch, they dressed me like this!”); }}

CS 350 – Software Design Putting Patterns Together We can use an adapter public class GooseAdapter implements Quackable { Goose goose; Goose goose; public GooseAdapter(Goose goose) { public GooseAdapter(Goose goose) { this.goose = goose; this.goose = goose;} public void quack() { goose.honk(); goose.honk(); }} public class WitchAdapter implements Quackable { Witch witch; Witch witch; public WitchAdapter(Witch witch) { public WitchAdapter(Witch witch) { this.witch = witch; this.witch = witch;} public void quack() { witch.complain(); witch.complain(); }}

CS 350 – Software Design Putting Patterns Together Let’s add a goose to our simulator public class DuckSimulator { public static void main(String[] args) { public static void main(String[] args) { DuckSimulator simultor = new DuckSimulator(); DuckSimulator simultor = new DuckSimulator(); simulator.simulate(); simulator.simulate(); } void simulate() { void simulate() { Quackable mallardDuck = new MallardDuck(); Quackable mallardDuck = new MallardDuck(); Quackable redheadDuck = new RedheadDuck(); Quackable redheadDuck = new RedheadDuck(); Quackable duckCall = new DuckCall(); Quackable duckCall = new DuckCall(); Quackable rubberDuck = new RubberDuck(); Quackable rubberDuck = new RubberDuck(); Quackable gooseDuck = new GooseAdapater(new Goose()); Quackable gooseDuck = new GooseAdapater(new Goose()); System.out.println(“\nDuck Simulator”); System.out.println(“\nDuck Simulator”); simulate(mallardDuck); simulate(mallardDuck); simulate(redheadDuck); simulate(redheadDuck); simulate(duckCall); simulate(duckCall); simulate(rubberDuck); simulate(rubberDuck); simulate(gooseDuck); simulate(gooseDuck);} void simulate(Quackable duck) { void simulate(Quackable duck) { duck.quack(); duck.quack(); }}

CS 350 – Software Design Putting Patterns Together How many quacks do we have? We can decorate the ducks so they can be counted. public class QuackCounter implements Quackable { Quackable duck; Quackable duck; static int numberOfQuacks; static int numberOfQuacks; public QuackCounter (Quackable duck) { public QuackCounter (Quackable duck) { this.duck = duck; this.duck = duck;} public void quack() { duck.quack(); duck.quack(); numberOfQuacks++; numberOfQuacks++;} public static int getQuacks() { return numberofQuacks; return numberofQuacks; }}}

CS 350 – Software Design Putting Patterns Together Too many ducks, let’s create a factory! public abstract class AbstractDuckFactory { public abstract Quackable createMallardDuck(); public abstract Quackable createMallardDuck(); public abstract Quackable createRedheadDuck(); public abstract Quackable createRedheadDuck(); public abstract Quackable createDuckCall(); public abstract Quackable createDuckCall(); public abstract Quackable createRubberDuck(); public abstract Quackable createRubberDuck(); public class DuckFactory extends AbstractDuckFactory { public Quackable createMallardDuck() { public Quackable createMallardDuck() { return new MallardDuck(); return new MallardDuck(); } public Quackable createRedheadDuck() { public Quackable createRedheadDuck() { return new RedheadDuck(); return new RedheadDuck(); } public Quackable createDuckCall() { public Quackable createDuckCall() { return new DuckCall(); return new DuckCall(); } public Quackable createRubberDuck() { public Quackable createRubberDuck() { return new RubberDuck(); return new RubberDuck(); }

CS 350 – Software Design Putting Patterns Together What about the countable quackable ducks? public class CountingDuckFactory extends AbstractDuckFactory { public Quackable createMallardDuck() { public Quackable createMallardDuck() { return newQuackCounter(new MallardDuck())); return newQuackCounter(new MallardDuck())); } public Quackable createRedheadDuck() { public Quackable createRedheadDuck() { return newQuackCounter(new RedheadDuck()); return newQuackCounter(new RedheadDuck()); } public Quackable createDuckCall() { public Quackable createDuckCall() { return newQuackCounter(new DuckCall()); return newQuackCounter(new DuckCall()); } public Quackable createRubberDuck() { public Quackable createRubberDuck() { return newQuackCounter(new RubberDuck()); return newQuackCounter(new RubberDuck()); }

CS 350 – Software Design Putting Patterns Together Let’s alter the simulator to use the factory public class DuckSimulator { public static void main(String[] args) { public static void main(String[] args) { DuckSimulator simultor = new DuckSimulator(); DuckSimulator simultor = new DuckSimulator(); AbstractDuckFactory duckFactory = new CountingDuckFactory(); AbstractDuckFactory duckFactory = new CountingDuckFactory(); Simulator.simulate(duckFactory); Simulator.simulate(duckFactory); } void simulate(AbstractDuckFactory duckFactory) { void simulate(AbstractDuckFactory duckFactory) { Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable duckCall = duckFactory.createDuckCall(); Quackable duckCall = duckFactory.createDuckCall(); Quackable rubberDuck = duckFactory.createRubberDuck(); Quackable rubberDuck = duckFactory.createRubberDuck(); Quackable gooseDuck = new GooseAdapater(new Goose()); Quackable gooseDuck = new GooseAdapater(new Goose()); System.out.println(“\nDuck Simulator”); System.out.println(“\nDuck Simulator”); simulate(mallardDuck); simulate(mallardDuck); simulate(redheadDuck); simulate(redheadDuck); simulate(duckCall); simulate(duckCall); simulate(rubberDuck); simulate(rubberDuck); simulate(gooseDuck); simulate(gooseDuck);} void simulate(Quackable duck) { void simulate(Quackable duck) { duck.quack(); duck.quack(); }}

CS 350 – Software Design Putting Patterns Together Managing this many ducks can be burdensome: Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable duckCall = duckFactory.createDuckCall(); Quackable duckCall = duckFactory.createDuckCall(); Quackable rubberDuck = duckFactory.createRubberDuck(); Quackable rubberDuck = duckFactory.createRubberDuck(); Quackable gooseDuck = new GooseAdapater(new Goose()); Quackable gooseDuck = new GooseAdapater(new Goose()); simulate(mallardDuck); simulate(mallardDuck); simulate(redheadDuck); simulate(redheadDuck); simulate(duckCall); simulate(duckCall); simulate(rubberDuck); simulate(rubberDuck); simulate(gooseDuck); simulate(gooseDuck);

CS 350 – Software Design Putting Patterns Together Let’s create a flock of ducks. public class Flock implements Quackable{ ArrayList quackers = new ArrayList(); ArrayList quackers = new ArrayList(); public void add(Quackable quacker) { public void add(Quackable quacker) { quackers.add(quacker); quackers.add(quacker); } public void quack() public void quack() { Iterator iterator = quackers.iterator(); Iterator iterator = quackers.iterator(); while (iterator.hasNExt() { while (iterator.hasNExt() { Quack quacker = (Quackable)iterator.next(); Quack quacker = (Quackable)iterator.next(); quacker.quack(); quacker.quack(); } }} Shows two patterns that we didn’t previously mention, Composite & Iterator.

CS 350 – Software Design Putting Patterns Together Let’s alter the simulator to a flock public class DuckSimulator { // other stuff void simulate(AbstractDuckFactory duckFactory) { void simulate(AbstractDuckFactory duckFactory) { Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable mallardDuck = duckFactory.createMallardDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable redheadDuck = duckFactory.createRedheadDuck(); Quackable duckCall = duckFactory.createDuckCall(); Quackable duckCall = duckFactory.createDuckCall(); Quackable rubberDuck = duckFactory.createRubberDuck(); Quackable rubberDuck = duckFactory.createRubberDuck(); Quackable gooseDuck = new GooseAdapater(new Goose()) Quackable gooseDuck = new GooseAdapater(new Goose()) System.out.println(“\nDuck Simulator: With Compisite - Flocks”); System.out.println(“\nDuck Simulator: With Compisite - Flocks”); Flock flockOfDucks = new Flock(); Flock flockOfDucks = new Flock(); flockOfDucks.add(redheadDuck); flockOfDucks.add(redheadDuck); flockOfDucks.add(duckCall); flockOfDucks.add(duckCall); flockOfDucks.add(rubberDuck); flockOfDucks.add(rubberDuck); flockOfDucks.add(gooseDuck); flockOfDucks.add(gooseDuck); Flock flock of Mallards = new Flock(); Flock flock of Mallards = new Flock(); Quack mallardOne = duckFactory.createMallardDuck(); Quack mallardOne = duckFactory.createMallardDuck(); Quack mallardTwo = duckFactory.createMallardDuck(); Quack mallardTwo = duckFactory.createMallardDuck(); Quack mallardThree = duckFactory.createMallardDuck(); Quack mallardThree = duckFactory.createMallardDuck(); Quack mallardFour = duckFactory.createMallardDuck(); Quack mallardFour = duckFactory.createMallardDuck(); flockOfMallards.add(mallardOne);} flockOfMallards.add(mallardOne);} flockOfMallards.add(mallardTwo);} flockOfMallards.add(mallardTwo);} flockOfMallards.add(mallardThree);} flockOfMallards.add(mallardThree);} flockOfMallards.add(mallardFour);} flockOfMallards.add(mallardFour);} void simulate(Quackable duck) { void simulate(Quackable duck) { duck.quack(); duck.quack(); }}

CS 350 – Software Design Putting Patterns Together What if we also want to observer individual duck behavior? public interface QuackObservable { public void registerObeserver(Observer observer); public void registerObeserver(Observer observer); public void notifyObservers(); public void notifyObservers();} However, we coded all the Quackables differently, so what to do? What to do?

CS 350 – Software Design Putting Patterns Together What if we also want to observer individual duck behavior? public interface QuackObservable extends Quackable { public void registerObeserver(Observer observer); public void registerObeserver(Observer observer); public void notifyObservers(); public void notifyObservers();} However, we coded all the Quackables differently, so what to do? What to do? public interface QuackObserver extends Quackable { public void quack(); public void quack();}

CS 350 – Software Design Putting Patterns Together Implementing the concrete classes public class Observable implements QuackObserable { ArrayList observers = new ArrayList(); ArrayList observers = new ArrayList(); QuackObservable duck; QuackObservable duck; public Observable(QuackObservable duck) { public Observable(QuackObservable duck) { this.duck = duck; this.duck = duck; } public void registerObserver(Observer observer) { public void registerObserver(Observer observer) { observers.add(observer); observers.add(observer); } public void notifyObservers() { public void notifyObservers() { Iterator iterator = observers.iterator(); Iterator iterator = observers.iterator(); while (iterator.hasNext()) { while (iterator.hasNext()) { Observer observer = (Observer) iterator.next(); Observer observer = (Observer) iterator.next(); observer.update(duck); observer.update(duck); } }}

CS 350 – Software Design Putting Patterns Together Changing the Mallard Duck class public class MallardDall implements Quackable { Observable observable; Observable observable; public MallardDuck() { public MallardDuck() { observable = new Observable(this); observable = new Observable(this); } public void quack() { public void quack() { System.out.println(“Quack”); System.out.println(“Quack”); notifyObservers(); notifyObservers(); } public void registerObserver(Observer observer) { public void registerObserver(Observer observer) { observable.registerObserver(observer); observable.registerObserver(observer); } public void notifyObservers() { public void notifyObservers() { observable.notifyObservers(); observable.notifyObservers(); }}

CS 350 – Software Design Putting Patterns Together From the Observer side public interface Observer { public void update(QuackObservable duck); public void update(QuackObservable duck);} public class Quackologist implements Observer { public void update(QuackObservable duck) { public void update(QuackObservable duck) { System.out.println(“Quackologist: “ + duck + “ just quacked.”); System.out.println(“Quackologist: “ + duck + “ just quacked.”); }}

CS 350 – Software Design Putting Patterns Together The updated simulator public class DuckSimulator { // other stuff void simulate(AbstractDuckFactory duckFactory) { void simulate(AbstractDuckFactory duckFactory) { // create duck factories and flock here // create duck factories and flock here System.out.println(“\nDuck Simulator: With Observer”); System.out.println(“\nDuck Simulator: With Observer”); Quackologist quackologist = newQuackologist(); Quackologist quackologist = newQuackologist(); flockOfDucks.registerObserver(quackologist); flockOfDucks.registerObserver(quackologist); simulate(flockOfDucks); simulate(flockOfDucks); System.out.println(“\nThe ducks quacked “ + QuackCounter.getQuacks() + “ times”); System.out.println(“\nThe ducks quacked “ + QuackCounter.getQuacks() + “ times”); void simulate(Quackable duck) { void simulate(Quackable duck) { duck.quack(); duck.quack(); }}