多个模式合作

复合模式：结合多个模式组成一个解决方案，解决一再发生的一般性问题。

这篇博客写的不是复合模式，而是多个模式合作解决问题。之所以不是复合模式，是因为复合模式要求解决一再发生的一般性问题。典型案例是MVC。

下面是多个模式合作解决问题的案例：

现在有不同种类的鸭子类，实现Quackable接口（有quack()方法）。

想把鹅也加进来，用到适配器模式，实现Quackable接口，并且有鹅的引用，实现quack()。

想记录鸭子叫声的次数，但不改变鸭子类。这里用到装饰者模式，用DuckCounter类把Quackable接口的实例包起来，改变quack()方法，加上计数的功能。

想自动产生计数和不计数的鸭子，以免忘了给它加上计数器。这里用抽象工厂模式，AbstractFactory两个子类分别创建计数和不计数的不同种类的鸭子。

想管理一群鸭子，用到组合模式。创建鸭群类Flock，实现Quackable接口。

又想监视一个鸭子或者鸭群叫声，用到观察者模式，把要观察的鸭群或鸭子继承Observable，把monitor实现Observer。这里为了不让每个鸭子类都写Observable的代码，用一个Observable类实现所有相应功能，鸭子类只用保持Observable对象就可以了。

复习了很多模式。

public interface Quackble extends QuackObservable{
    public void quack();
}

public class MallardDuck implements Quackble {
    Observable observable;

    public class MallardDuck implements Quackble {
    Observable observable = new Observable();
    
    @Override
    public void quack() {

    }

    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }
}

public class Goose {
    public void honk(){};
}

public class GooseAdapter implements Quackble {
    Goose goose;
    Observable observable = new Observable();

    public GooseAdapter(Goose goose){
        this.goose = goose;
        this.observable = observable;
    }
    @Override
    public void quack() {
        goose.honk();
    }

    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }
}

public abstract class AbstractFactoryDuck {
    public abstract Quackble createMallardQuack();
}

public class FactoryCountingDuck extends AbstractFactoryDuck {
    @Override
    public Quackble createMallardQuack() {
        return new QuackCounter(new MallardDuck());
    }
}

public class FactoryDuck extends AbstractFactoryDuck {
    @Override
    public Quackble createMallardQuack() {
        return new MallardDuck();
    }
}

public class Flock implements Quackble {
    Observable observable;
    List<Quackble> quackers = new ArrayList<>();
    @Override
    public void quack() {
        Iterator<Quackble> iterator = quackers.iterator();
        while (iterator.hasNext()){
            Quackble quacker = (Quackble) iterator.next();
            quacker.quack();
        }
    }

    public void add(Quackble quackble){
        quackers.add(quackble);
    }

    @Override
    public void registerObserver(Observer observer) {
        Iterator<Quackble> iterator = quackers.iterator();
        while (iterator.hasNext()){
            Quackble quackble = (Quackble) iterator.next();
            quackble.registerObserver(observer);
        }
    }

    @Override
    public void notifyObservers() {
        Iterator<Quackble> iterator = quackers.iterator();
        while (iterator.hasNext()){
            Quackble quackble = (Quackble) iterator.next();
            quackble.notifyObservers();
        }
    }

}

public interface QuackObservable {
    public void registerObserver(Observer observer);
    public void notifyObservers();
}

public class Observable implements QuackObservable {
    List<Observer> list = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        list.add(observer);
    }

    @Override
    public void notifyObservers() {
        Iterator<Observer> iterator = list.iterator();
        while (iterator.hasNext()){
            Observer observer = (Observer) iterator.next();
            observer.update();
        }
    }
}

public interface Observer {
    public void update();
}


public void patternCooperation(){
        Quackble mallardDuck = new PatternCooperation.MallardDuck();
        Goose goose = new Goose();
        Quackble gooseAdapter = new GooseAdapter(goose);
        Quackble quackCounter = new QuackCounter(mallardDuck);
        Quackble quackCounterGoose = new QuackCounter(gooseAdapter);
        AbstractFactoryDuck factoryDuck = new FactoryDuck();
        Quackble mallardDuckF = factoryDuck.createMallardQuack();
        AbstractFactoryDuck factoryDuckCounter = new FactoryCountingDuck();
        Quackble mallardDuckCounterF = factoryDuckCounter.createMallardQuack();
        Flock flock = new Flock();
        flock.add(mallardDuck);
        flock.add(gooseAdapter);
        flock.quack();
    }