大话设计模式6 建造者模式 观察者模式

1.建造者模式

感觉和模板模式有些相似，不过模板模式是通过继承，实现具体细节实现的变化，而建造者模式则是在一个指挥者的指导下，进行建造，对外封装了实现的细节。

package builder;

import java.util.ArrayList;

class Product {
	private ArrayList<String> mPartList=new ArrayList<String>();

	public void add(String part)
	{
		mPartList.add(part);
	}
	
	public void show()
	{
		for(String p:mPartList)
		{
			System.out.println(p);
		}
	}
}

abstract class Builder {
	public abstract void buildPartA();
	public abstract void buildPartB();
	public abstract Product getProduct();
	
}

class ConcreteBuilderA extends Builder{
	private Product mProduct=new Product();
	@Override
	public void buildPartA() {
		// TODO Auto-generated method stub
		mProduct.add("ConcreteBuilderA.buildPartA");
	}

	@Override
	public void buildPartB() {
		// TODO Auto-generated method stub
		mProduct.add("ConcreteBuilderA.buildPartB");
	}

	@Override
	public Product getProduct() {
		// TODO Auto-generated method stub
		return mProduct;
	}
	
}

class ConcreteBuilderB extends Builder{
	private Product mProduct=new Product();
	@Override
	public void buildPartA() {
		// TODO Auto-generated method stub
		mProduct.add("ConcreteBuilderB.buildPartA");
	}

	@Override
	public void buildPartB() {
		// TODO Auto-generated method stub
		mProduct.add("ConcreteBuilderB.buildPartB");
	}

	@Override
	public Product getProduct() {
		// TODO Auto-generated method stub
		return mProduct;
	}
	
}

class Director{
	public void construct(Builder builder)
	{
		builder.buildPartA();
		builder.buildPartB();
	}
}

public abstract class BuilderPattern {
	public static void main(String[] args) {
		Director director=new Director();
		Builder builder1=new ConcreteBuilderA();
		Builder builder2=new ConcreteBuilderB();
		
		director.construct(builder1);
		Product product1=builder1.getProduct();
		product1.show();
		
		director.construct(builder2);
		Product product2=builder2.getProduct();
		product2.show();
		
	}
}

2.观察者模式

貌似是一个蛮重要的设计模式，感觉主要是在Subject的实现里，维护一个Observer的链表，以实现一对多的通知的关系，通知Observer实现更新。

package observer;

import java.util.ArrayList;

abstract class Observer{
	public Subject mSubject;
	
	public Observer(Subject subject){
		mSubject=subject;
	}
	
	public abstract void update();
}

abstract class Subject{
	String mInfo;
	public abstract void attach(Observer o);
	
	public abstract void detach(Observer o);
	
	public abstract void notifyThem();
	
}

class NBAObserver extends Observer{

	public NBAObserver(Subject subject) {
		super(subject);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("NBA hear:"+mSubject.mInfo);
	}
	
}

class FIFAObserver extends Observer{

	public FIFAObserver(Subject subject) {
		super(subject);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("FIFA hear:"+mSubject.mInfo);
	}
	
}

class Boss extends Subject{
	ArrayList<Observer> mList=new ArrayList<Observer>();
	
	public Boss(String info){
		mInfo=info;
	}
	
	public void attach(Observer o){
		mList.add(o);
	}
	
	public void detach(Observer o){
		mList.remove(o);
	}
	
	public void notifyThem(){
		for(Observer o:mList){
			o.update();
		}
	}
}

public class ObserverPattern {
	public static void main(String[] args){
		Boss boss=new Boss("Mr.Gates comes back");
		
		boss.attach(new NBAObserver(boss));
		boss.attach(new FIFAObserver(boss));
		
		boss.notifyThem();
	}
}