复合模式

 

 

 

定义：多个模式一起工作

 

 

代码

工厂

/**
 * 
 * @author  feizhou 
 * 描述：抽象工厂
 */
public abstract class AbstractDuckFactory {
 
	public abstract Quackable createMallardDuck();
	public abstract Quackable createRedheadDuck();
	public abstract Quackable createDuckCall();
	public abstract Quackable createRubberDuck();
}



/**
 * 
 * @author  feizhou 
 * 描述：工厂模式
 */
public class DuckFactory extends AbstractDuckFactory {
  
	public Quackable createMallardDuck() {
		return new MallardDuck();
	}
  
	public Quackable createRedheadDuck() {
		return new RedheadDuck();
	}
  
	public Quackable createDuckCall() {
		return new DuckCall();
	}
   
	public Quackable createRubberDuck() {
		return new RubberDuck();
	}
}



/**
 * 
 * @author  feizhou 
 * 描述：真正工厂（装饰者（观察者））
 */
public class CountingDuckFactory extends AbstractDuckFactory {
  
	public Quackable createMallardDuck() {
		//装饰者（获取Quack方法调用次数）
		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());
	}
}

具体鸭子

/**
 * 
 * @author  feizhou 
 * 描述：DecoyDuck:诱骗鸭（类似鸭鸣器）
 */
public class DecoyDuck implements Quackable {
	Observable observable;

	public DecoyDuck() {
		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 "诱骗鸭";
	}
}




/**
 * 
 * @author  feizhou 
 * 描述：鸭鸣器
 */
public class DuckCall implements Quackable {
	Observable observable;

	public DuckCall() {
		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 "鸭鸣器";
	}
}


橡皮鸭
public class RubberDuck implements Quackable {
	Observable observable;

	public RubberDuck() {
		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 "橡皮鸭";
	}
}

红头鸭

public class RedheadDuck implements Quackable {
	Observable observable;

	public RedheadDuck() {
		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 "红头鸭";
	}
}


绿头鸭

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 "绿头鸭";
	}
}


/**
 * 
 * @author  feizhou 
 * 描述：鹅
 */
public class Goose {

	public void honk() {
		System.out.println("鹅叫");
	}

	public String toString() {
		return "鹅";
	}
}

观察者（主题）

/**
 * 
 * @author  feizhou 
 * 描述：接口主题
 */
public interface QuackObservable {
	public void registerObserver(Observer observer);
	public void notifyObservers();
}



/**
 * 
 * @author  feizhou 
 * 描述：继承主题的接口Quack接口
 */
public interface Quackable extends QuackObservable {
	public void quack();
}




/**
 * 
 * @author  feizhou 
 * 描述：实现主题接口的类
 */
public class Observable implements QuackObservable {
	ArrayList observers = new ArrayList();
	QuackObservable duck;
 
	public Observable(QuackObservable duck) {
		this.duck = duck;
	}
  
	public void registerObserver(Observer observer) {
		observers.add(observer);
	}
  
	public void notifyObservers() {
		Iterator iterator = observers.iterator();
		while (iterator.hasNext()) {
			Observer observer = (Observer)iterator.next();
			observer.update(duck);
		}
	}
 
	public Iterator getObservers() {
		return observers.iterator();
	}
}

观察者（观察者）

/**
 * 
 * @author  feizhou 
 * 描述：观察者接口
 */
public interface Observer {
	public void update(QuackObservable duck);
}




/**
 * 
 * @author  feizhou 
 * 描述：实现观察接口的类
 */
public class Quackologist implements Observer {
 
	public void update(QuackObservable duck) {
		System.out.println("收到主题的消息: " + duck + "   quacked");
	}
 
	public String toString() {
		return "Quackologist";
	}
}

装饰者

/**
 * 
 * @author  feizhou 
 * 描述：
 * 装饰者：获取Quack方法调用次数
 * Quackable：主题
 */
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 void registerObserver(Observer observer) {
		duck.registerObserver(observer);
	}
 
	public void notifyObservers() {
		duck.notifyObservers();
	}
   
	public String toString() {
		return duck.toString();
	}
}

适配器

/**
 * 
 * @author  feizhou 
 * 描述：适配器+观察者
 */
public class GooseAdapter implements Quackable {
	Goose goose;
	Observable observable;//主题

	public GooseAdapter(Goose goose) {
		this.goose = goose;
		observable = new Observable(this);
	}
 
	public void quack() {
		goose.honk();
		notifyObservers();
	}

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

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

	public String toString() {
		return "鹅看起来像鸭";
	}
}

 

组合+迭代器

/**
 * 
 * @author  feizhou 
 * 描述：组合+迭代器+观察者
 */
public class Flock implements Quackable {
	ArrayList ducks = new ArrayList();
  
	public void add(Quackable duck) {
		ducks.add(duck);
	}
  
	public void quack() {
		Iterator iterator = ducks.iterator();
		while (iterator.hasNext()) {
			Quackable duck = (Quackable)iterator.next();
			duck.quack();
		}
	}
   
	/**
	 * 注册一群鸭
	 */
	public void registerObserver(Observer observer) {
		Iterator iterator = ducks.iterator();
		while (iterator.hasNext()) {
			Quackable duck = (Quackable)iterator.next();
//每个鸭子都是主题，主题里面注册观察者
			duck.registerObserver(observer);
		}
	}
  
	public void notifyObservers() { }
  
	public String toString() {
		return "一群鸭";
	}
}

测试

 

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());
		//查看一群鸭子
		Flock flock1 = new Flock();
 
		flock1.add(redheadDuck);
		flock1.add(duckCall);
		flock1.add(rubberDuck);
		flock1.add(gooseDuck);
		//创建绿头鸭群2
		Flock flock2 = new Flock();
 
		Quackable mallard1 = duckFactory.createMallardDuck();
		Quackable mallard2 = duckFactory.createMallardDuck();
		Quackable mallard3 = duckFactory.createMallardDuck();
		Quackable mallard4 = duckFactory.createMallardDuck();

		flock2.add(mallard1);
		flock2.add(mallard2);
		flock2.add(mallard3);
		flock2.add(mallard4);
		//加入群1
		flock1.add(flock2);

		System.out.println("\nDuck Simulator: With Observer");
		//创建观察者
		Quackologist quackologist = new Quackologist();
		//注册观察者到所有主题中（刚刚添加的鸭子都是主题）
		flock1.registerObserver(quackologist);

		simulate(flock1);

		System.out.println("\n 鸭子叫的次数："+QuackCounter.getQuacks());  
		                  
		                  
	}
 
	void simulate(Quackable duck) {
		duck.quack();
	}
}



结果：


Duck Simulator: With Observer
红头鸭Quack
收到主题的消息: 红头鸭   quacked
鸭鸣器quack
收到主题的消息: 鸭鸣器   quacked
橡皮鸭quack
收到主题的消息: 橡皮鸭   quacked
鹅叫
收到主题的消息: 鹅看起来像鸭   quacked
绿头鸭Quack
收到主题的消息: 绿头鸭   quacked
绿头鸭Quack
收到主题的消息: 绿头鸭   quacked
绿头鸭Quack
收到主题的消息: 绿头鸭   quacked
绿头鸭Quack
收到主题的消息: 绿头鸭   quacked

 鸭子叫的次数：7