复合模式

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

 

男人、机器人、狗。人都可以说话，狗不会说话。

通过适配器模式，让狗也可以说话。

通过装饰者模式，统计说话次数。

通过工厂模式，来创建人。

通过组合模式，管理一群人。

 

通过观察者模式，观察机器人说话。

 

 

package com.ez.biz;

import com.ez.AbstractPersonFactory;
import com.ez.Person;
import com.ez.impl.Android;
import com.ez.impl.Dog;
import com.ez.impl.DogAdapter;
import com.ez.impl.Human;
import com.ez.impl.Man;
import com.ez.impl.PersonCount;
import com.ez.impl.PersonCountFactory;
import com.ez.impl.Screen;

/**
 * @author 窗外赏雪（EZ编程网）
 */
public class Test {
	
	static void talk(Person person){
		person.talk();
	}
	
	public static void main(String[] args) {
		System.out.println("=======使用适配器模式，适配狗说话=======");
		Person person=new Android();
		talk(person);
		person=new Man();
		talk(person);
		person=new DogAdapter(new Dog());
		talk(person);
		
		System.out.println("=========使用装饰者模式统计说话次数========");
		person=new PersonCount(new Man());
		talk(person);
		person=new PersonCount(new Android());
		talk(person);
		person=new PersonCount(new DogAdapter(new Dog()));
		talk(person);
		System.out.println("===说话次数为："+PersonCount.getTalkNum()+"===");
		
		System.out.println("======使用工厂方式创建======");
		AbstractPersonFactory factory=new PersonCountFactory();
		person=factory.createAndroid();
		talk(person);
		person=factory.createMan();
		talk(person);
		
		System.out.println("=======使用组合模式管理一群人=========");
		Human persons=new Human();
		persons.add(factory.createMan());
		persons.add(factory.createAndroid());
		
		Human persons1=new Human();
		persons1.add(factory.createAndroid());
		persons1.add(factory.createAndroid());
		persons1.add(factory.createAndroid());
		persons1.add(factory.createAndroid());
		
		persons.add(persons1);
		talk(persons);
		
		System.out.println("====使用观察者模式，观察机器人说话====");
		Android android=new Android();
		Screen screen=new Screen();
		android.registerObserver(screen);
		android.talk();
		
	}
}

 

package com.ez;
/**
 * 人接口，狗适配器需要实现此接口
 * @author 窗外赏雪（EZ编程网）
 */
public interface Person {
	/**
	 * 人都会说话
	 */
	void talk();
}

 

package com.ez.impl;

import com.ez.Observer;
import com.ez.Person;
import com.ez.PersonObservable;
/**
 * 机器人，通过组合，实现被观察者的行为。
 * @author 窗外赏雪（EZ编程网）
 *
 */
public class Android implements Person,PersonObservable{
	private Observable observable;
	public Android() {
		observable=new Observable(this);
	}
	
	@Override
	public void talk() {
		System.out.println("你好，我们机器人。");
		notifyObservers();
	}

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

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

}

 

package com.ez.impl;

import com.ez.Person;
/**
 * 男人，是人，会说话
 * @author 窗外赏雪（EZ编程网）
 */
public class Man implements Person{

	@Override
	public void talk() {
		System.out.println("你好，我是男人");
	}

}

 

package com.ez.impl;
/**
 * 狗不是人，不会说话，要想说话，必须通过DogAdapter适配器。
 * @author 窗外赏雪（EZ编程网）
 */
public class Dog {
	/**
	 * 狗不会说话，只会叫
	 */
	public void shout(){
		System.out.println("汪汪");
	}
}

 

package com.ez.impl;

import com.ez.Person;
/**
 * 狗适配器，让狗可以说话，实现person接口
 * @author 窗外赏雪（EZ编程网）
 */
public class DogAdapter implements Person{
	private Dog dog;
	public DogAdapter(Dog dog) {
		this.dog=dog;
	}
	@Override
	public void talk() {
		dog.shout();
	}
}

 

package com.ez.impl;

import com.ez.Person;
/**
 * person装饰者，用于统计人的说话次数。
 * @author 窗外赏雪（EZ编程网）
 */
public class PersonCount implements Person{
	
	private Person person;
	private static int numberOfTalk;
	
	public PersonCount(Person person) {
		this.person=person;
	}

	@Override
	public void talk() {
		person.talk();
		numberOfTalk++;
	}
	
	public static int getTalkNum(){
		return numberOfTalk;
	}
}

 

package com.ez;
/**
 * 工厂抽象类
 * @author 窗外赏雪（EZ编程网）
 */
public abstract class AbstractPersonFactory {
	public abstract Person createMan();
	public abstract Person createAndroid();
}

 

package com.ez.impl;

import com.ez.AbstractPersonFactory;
import com.ez.Person;
/**
 * 创建人的工厂
 * @author 窗外赏雪（EZ编程网）
 */
public class PersonFactory extends AbstractPersonFactory{

	@Override
	public Person createMan() {
		return new Man();
	}

	@Override
	public Person createAndroid() {
		return new Android();
	}

}

 

package com.ez.impl;

import com.ez.AbstractPersonFactory;
import com.ez.Person;
/**
 * 创建人的装饰者的工厂
 * @author 窗外赏雪（EZ编程网）
 */
public class PersonCountFactory extends AbstractPersonFactory {

	@Override
	public Person createMan() {
		return new PersonCount(new Man());
	}

	@Override
	public Person createAndroid() {
		return new PersonCount(new Android());
	}

}

 

package com.ez.impl;

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

import com.ez.Person;
/**
 * 组合模式的数据结构，无差异的处理一个和一组person对象。
 * @author 窗外赏雪（EZ编程网）
 */
public class Human implements Person{
	
	private List<Person> persons=new ArrayList<Person>();

	public void add(Person person){
		persons.add(person);
	}
	
	@Override
	public void talk() {
		Iterator<Person> iterator=persons.iterator();
		while(iterator.hasNext()){
			Person person=(Person)iterator.next();
			person.talk();
		}
	}
	
}

 

package com.ez;
/**
 * 观察者接口
 * @author 窗外赏雪（EZ编程网）
 */
public interface Observer {
	void update(PersonObservable person);
}

 

package com.ez.impl;

import com.ez.Observer;
import com.ez.PersonObservable;
/**
 * 观察者，可以观察被观察者（人）
 * @author 窗外赏雪（EZ编程网）
 */
public class Screen implements Observer{
	
	@Override
	public void update(PersonObservable person) {
		System.out.println("观察到说话了"+person.toString());
	}
}

 

package com.ez;
/**
 * 被观察者接口，主题，可以订阅观察者，通知观察者。
 * @author 窗外赏雪（EZ编程网）
 */
public interface PersonObservable {
	void registerObserver(Observer observer);
	void notifyObservers();
}

 

package com.ez.impl;

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

import com.ez.Observer;
import com.ez.PersonObservable;
/**
 * 被观察者实现类，通过组合此类。
 * @author 窗外赏雪（EZ编程网）
 */
public class Observable implements PersonObservable{
	private List<Observer> observers=new ArrayList<Observer>();
	private PersonObservable person;
	
	public Observable(PersonObservable person) {
		this.person=person;
	}
	
	@Override
	public void registerObserver(Observer observer) {
		observers.add(observer);
	}

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

  

MVC是复合模式，结合了观察者模式、策略模式和组合模式。

 

我们通过MVC，来学习复合模式。

视图：用来呈现模型。视图通常直接从模型中取得它需要显示的状态和数据。

控制器：取得用户的输入并解读其对模型的意思。

模型：模型持有所有的数据、状态和程序逻辑。

 

非web版MVC（Model1）

 

模型利用“观察者”让控制器和视图可以随最新的状态改变而更新。

 

视图和控制器实现了“策略模式”，视图是一个对象，可以被调整使用不同的策略，而控制器提供了策略。

视图只关心系统中的可视部分，对于任何界面行为，都委托给控制器处理。

使用策略模式也可以让视图和模型之间的关系解耦，因为控制器负责和模型交互来传递用户的请求。对于工作是怎么完成的，视图豪不知情。

 

视图内部使用组合模式来管理窗口、按钮以及其他显示组件。