复合模式:结合两个或以上的模式,组成一个解决方案,解决一再发生的一般性问题。
男人、机器人、狗。人都可以说话,狗不会说话。
通过适配器模式,让狗也可以说话。
通过装饰者模式,统计说话次数。
通过工厂模式,来创建人。
通过组合模式,管理一群人。
通过观察者模式,观察机器人说话。
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)
模型利用“观察者”让控制器和视图可以随最新的状态改变而更新。
视图和控制器实现了“策略模式”,视图是一个对象,可以被调整使用不同的策略,而控制器提供了策略。
视图只关心系统中的可视部分,对于任何界面行为,都委托给控制器处理。
使用策略模式也可以让视图和模型之间的关系解耦,因为控制器负责和模型交互来传递用户的请求。对于工作是怎么完成的,视图豪不知情。
视图内部使用组合模式来管理窗口、按钮以及其他显示组件。