复合模式

矫情吗；* 2022-07-16 16:16 159阅读 0赞

package N\_Composite.duck;

import N\_Composite.duck.adapter.Goose;  
import N\_Composite.duck.adapter.GooseAdapter;  
import N\_Composite.duck.composite\_iterator.Flock;  
import N\_Composite.duck.decker.QuackCounter;  
import N\_Composite.duck.factory.CountingDuckFactory;  
import N\_Composite.duck.observer.Quackologist;

/\*\*  
\* 复合模式:结合2个或者以上模式，组成一个解决方案，解决一再发生的问题  
\* mvc:模型利用”观察者模式”让控制器和视图可以随最新状态改变而更新  
\* 视图和控制器实现”策略模式”，  
\* 控制器是视图的行为，可以更换控制器更换行为  
\* 视图使用组合模式管理窗口，按钮以及其他组件  
\*/  
public class DuckSimulator \{

public static void main(String[] args) {
        DuckSimulator duckSimulator = new DuckSimulator();
        duckSimulator.simulator();
        duckSimulator.simulator1();
    
        CountingDuckFactory countingDuckFactory = new CountingDuckFactory();
        duckSimulator.simulator2(countingDuckFactory);
        duckSimulator.simulator3(countingDuckFactory);
        duckSimulator.simulator4(countingDuckFactory);
    }
    
    /*
     * 适配器模式
     */
    public void simulator() {
        Quackable mallardDuck = new MallardDuck();
        Quackable duckCall = new DuckCall();
        Quackable redheadDuck = new RedheadDuck();
        Quackable rubberDuck = new RubberDuck();
        // 适配器模式
        Quackable gooseAdapter = new GooseAdapter(new Goose());
    
        simulator(mallardDuck);
        simulator(duckCall);
        simulator(redheadDuck);
        simulator(rubberDuck);
        simulator(gooseAdapter);
    }
    
    /*
     * 使用装饰者模式统计鸭子叫次数
        缺点：必须装饰对象才能获得被装饰的行为
        解决：工厂模式
     */
    public void simulator1() {
        Quackable mallardDuck = new QuackCounter(new MallardDuck());
        Quackable duckCall = new QuackCounter(new DuckCall());
        Quackable redheadDuck = new QuackCounter(new RedheadDuck());
        Quackable rubberDuck = new QuackCounter(new RubberDuck());
        Quackable gooseAdapter = new QuackCounter(new GooseAdapter(new Goose()));
    
        simulator(mallardDuck);
        simulator(duckCall);
        simulator(redheadDuck);
        simulator(rubberDuck);
        simulator(gooseAdapter);
        System.out.println(QuackCounter.getNumberOfQuacks());
    }
    
    /*
     * 工厂模式管理鸭子
     * 只能个别管理鸭子，无法管理一群鸭子
     * 解决：组合模式
     */
    private void simulator2(CountingDuckFactory duckFactory) {
        Quackable duckCall = duckFactory.createDuckCall();
        Quackable mallardDuck = duckFactory.createMallardDuck();
        Quackable redheadDuck = duckFactory.createRedheadDuck();
        Quackable rubberDuck = duckFactory.createRubberDuck();
        Quackable gooseAdapter = duckFactory.createGooseDuck();
    
        simulator(duckCall);
        simulator(mallardDuck);
        simulator(redheadDuck);
        simulator(rubberDuck);
        simulator(gooseAdapter);
        System.out.println(QuackCounter.getNumberOfQuacks());
    }
    
    /*
     *组合模式+迭代器模式管理一群鸭子 
     */
    private void simulator3(CountingDuckFactory duckFactory) {
        Quackable duckCall = duckFactory.createDuckCall();
        Quackable mallardDuck = duckFactory.createMallardDuck();
        Quackable redheadDuck = duckFactory.createRedheadDuck();
        Quackable rubberDuck = duckFactory.createRubberDuck();
        Quackable gooseAdapter = duckFactory.createGooseDuck();
    
        // 这个flock是主群
        Flock flockOfDucks = new Flock();
        flockOfDucks.add(duckCall);
        flockOfDucks.add(mallardDuck);
        flockOfDucks.add(redheadDuck);
        flockOfDucks.add(rubberDuck);
        flockOfDucks.add(gooseAdapter);
    
        // 创建绿头鸭群
        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("测试绿头鸭群");
        simulator(flockOfMallards);
        System.out.println("测试一整群");
        simulator(flockOfDucks);
        System.out.println(QuackCounter.getNumberOfQuacks());
    }
    
    /*
     * 观察者模式：观察每只鸭叫的情况
     */
    private void simulator4(CountingDuckFactory duckFactory) {
        Quackable duckCall = duckFactory.createDuckCall();
        Quackable mallardDuck = duckFactory.createMallardDuck();
        Quackable redheadDuck = duckFactory.createRedheadDuck();
        Quackable rubberDuck = duckFactory.createRubberDuck();
        Quackable gooseAdapter = duckFactory.createGooseDuck();
    
        // 这个flock是主群
        Flock flockOfDucks = new Flock();
        flockOfDucks.add(duckCall);
        flockOfDucks.add(mallardDuck);
        flockOfDucks.add(redheadDuck);
        flockOfDucks.add(rubberDuck);
        flockOfDucks.add(gooseAdapter);
    
        // 创建绿头鸭群
        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);
    
        Quackologist quackologist = new Quackologist();
        flockOfDucks.registerObserver(quackologist);
        simulator(flockOfDucks);
        System.out.println(QuackCounter.getNumberOfQuacks());
    }
    
    public void simulator(Quackable duck) {
        duck.quack();
    }

\}  
package N\_Composite.duck;

import N\_Composite.duck.observer.Observable;  
import N\_Composite.duck.observer.Observer;

public class DuckCall implements Quackable \{  
Observable observable;

public DuckCall() {
        this.observable = new Observable(this);
    }
    
    public void quack() {
        System.out.println("quack");
        notifyObservers();
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }
    
    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

\}  
package N\_Composite.duck;

import N\_Composite.duck.observer.Observable;  
import N\_Composite.duck.observer.Observer;

public class MallardDuck implements Quackable \{  
Observable observable;

public MallardDuck() {
        observable = new Observable(this);
    }
    
    public void quack() {
        System.out.println("quack");
        notifyObservers();
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }
    
    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

\}  
package N\_Composite.duck;

import N\_Composite.duck.observer.QuackObservable;

public interface Quackable extends QuackObservable \{  
void quack();  
\}  
package N\_Composite.duck;

import N\_Composite.duck.observer.Observable;  
import N\_Composite.duck.observer.Observer;

public class RedheadDuck implements Quackable \{  
Observable observable;

public RedheadDuck() {
        this.observable = new Observable(this);
    }
    
    public void quack() {
        System.out.println("quack");
        notifyObservers();
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }
    
    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

\}  
package N\_Composite.duck;

import N\_Composite.duck.observer.Observable;  
import N\_Composite.duck.observer.Observer;

public class RubberDuck implements Quackable \{  
Observable observable;

public RubberDuck() {
        this.observable = new Observable(this);
    }
    
    public void quack() {
        System.out.println("quack");
        notifyObservers();
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }
    
    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

\}  
package N\_Composite.duck.adapter;

public class Goose \{  
public void honk() \{  
System.out.println(“honk”);  
\}  
\}  
package N\_Composite.duck.adapter;

import N\_Composite.duck.Quackable;  
import N\_Composite.duck.observer.Observable;  
import N\_Composite.duck.observer.Observer;

/\*\*  
\* 适配器模式，鹅伪装鸭子  
\*/  
public class GooseAdapter implements Quackable \{  
Goose goose;  
Observable observable;

public GooseAdapter(Goose goose) {
        this.goose = goose;
        this.observable = new Observable(this);
    }
    
    @Override
    public void quack() {
        goose.honk();
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }
    
    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

\}  
package N\_Composite.duck.composite\_iterator;

import java.util.ArrayList;  
import java.util.Iterator;

import N\_Composite.duck.Quackable;  
import N\_Composite.duck.observer.Observer;

/\*\*  
\* 组合模式和迭代器模式 透明性：因为组合(菜单)和叶节点(菜单项)具有一组相同的方法，好处是2者之间是透明的，客户不需要管是叶节点还是组合.  
\* 2者调用的同一个方法 但是因为因为这样失去了安全性 安全：叶节点和组合分开即可，  
\* 组合不继承Quackable，但是调用add时需要确定参数是Flock对象，这样也损失了透明性  
\*/  
public class Flock implements Quackable \{

ArrayList<Quackable> quarkers = new ArrayList<Quackable>();
    
    public void add(Quackable quarker) {
        this.quarkers.add(quarker);
    }
    
    @Override
    public void quack() {
        Iterator<Quackable> iterator = quarkers.iterator();
        while (iterator.hasNext()) {
            Quackable next = iterator.next();
            next.quack();
        }
    }
    //当响flock注册观察者时，其实是向所有Quackable注册
    public void registerObserver(Observer observer) {
        Iterator<Quackable> iterator = quarkers.iterator();
        while (iterator.hasNext()) {
            Quackable next = iterator.next();
            next.registerObserver(observer);
        }
    }
    
    //每个Quackable负责自己通知观察者，不需要flock负责
    public void notifyObservers() {
    }

\}  
package N\_Composite.duck.decker;

import N\_Composite.duck.Quackable;  
import N\_Composite.duck.observer.Observer;

/\*\*  
\* 装饰者模式，统计所有鸭子叫的次数  
\*/  
public class QuackCounter implements Quackable \{

Quackable duck;
    static int numberOfQuacks;
    
    public QuackCounter(Quackable duck) {
        this.duck = duck;
    }
    
    @Override
    public void quack() {
        duck.quack();
        numberOfQuacks++;
    }
    
    public static int getNumberOfQuacks() {
        return numberOfQuacks;
    }
    
    @Override
    public void registerObserver(Observer observer) {
        duck.registerObserver(observer);
    }
    
    @Override
    public void notifyObservers() {
        duck.notifyObservers();
    }

\}  
package N\_Composite.duck.factory;

import N\_Composite.duck.Quackable;

/\*\*  
\* 创建不同种类的鸭子  
\*/  
public abstract class AbstractDuckFactory \{

public abstract Quackable createMallardDuck();
    
    public abstract Quackable createDuckCall();
    
    public abstract Quackable createRedheadDuck();
    
    public abstract Quackable createRubberDuck();
    
    public abstract Quackable createGooseDuck();

\}  
package N\_Composite.duck.factory;

import N\_Composite.duck.DuckCall;  
import N\_Composite.duck.MallardDuck;  
import N\_Composite.duck.Quackable;  
import N\_Composite.duck.RedheadDuck;  
import N\_Composite.duck.RubberDuck;  
import N\_Composite.duck.adapter.Goose;  
import N\_Composite.duck.adapter.GooseAdapter;  
import N\_Composite.duck.decker.QuackCounter;

/\*\*  
\* 统计鸭子叫的次数  
\*/  
public class CountingDuckFactory extends AbstractDuckFactory \{

@Override
    public Quackable createMallardDuck() {
        return new QuackCounter(new MallardDuck());
    }
    
    @Override
    public Quackable createDuckCall() {
        return new QuackCounter(new DuckCall());
    }
    
    @Override
    public Quackable createRedheadDuck() {
        return new QuackCounter(new RedheadDuck());
    }
    
    @Override
    public Quackable createRubberDuck() {
        return new QuackCounter(new RubberDuck());
    }
    
    @Override
    public Quackable createGooseDuck() {
        return new QuackCounter(new GooseAdapter(new Goose()));
    }

\}  
package N\_Composite.duck.factory;

/\*\*  
\* 创建不同鸭子  
\*/  
public class DuckFactory extends AbstractDuckFactory \{

@Override
    public Quackable createMallardDuck() {
        return new MallardDuck();
    }
    
    @Override
    public Quackable createDuckCall() {
        return new DuckCall();
    }
    
    @Override
    public Quackable createRedheadDuck() {
        return new RedheadDuck();
    }
    
    @Override
    public Quackable createRubberDuck() {
        return new RubberDuck();
    }
    
    @Override
    public Quackable createGooseDuck() {
        return new GooseAdapter(new Goose());
    }

\}  
package N\_Composite.duck.observer;

import java.util.ArrayList;  
import java.util.Iterator;  
/\*\*  
\* 需要每个鸭类都实现注册与通知，提取封装在此类，只需要鸭类组合这个类即可  
\*/  
public class Observable implements QuackObservable \{  
ArrayList observers = new ArrayList();  
QuackObservable duck;  
//当通知发生时，观察者会把此对象传过去，让观察者知道那个对象在叫notifyObservers().next.update(duck);  
public Observable(QuackObservable duck) \{  
this.duck = duck;  
\}

public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    
    public void notifyObservers() {
        Iterator<Observer> iterator = observers.iterator();
        while (iterator.hasNext()) {
            Observer next = iterator.next();
            next.update(duck);
        }
    }

\}  
package N\_Composite.duck.observer;

public interface Observer \{  
void update(QuackObservable duck);  
\}  
package N\_Composite.duck.observer;

/\*\*  
\* 观察者模式: 监控某个鸭子的持续叫声  
\* 所有的Quackable都实现此接口  
\*/  
public interface QuackObservable \{  
void registerObserver(Observer observer);

void notifyObservers();

\}  
package N\_Composite.duck.observer;

public class Quackologist implements Observer \{

@Override
    public void update(QuackObservable duck) {
        //打印呱呱叫的鸭子
        System.out.println(duck);
    }