复合模式

原创 于 2017-03-03 23:41:10 发布 · 386 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

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;

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;
import N_Composite.duck.factory.AbstractDuckFactory;

/**
* 创建不同鸭子
*/
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);
}

}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值