抽象工厂模式

阅读《研磨设计模式》笔记。之后若有所感，再补充。
抽象工厂模式目的：是为一系列相关对象或者相互依赖的对象创建一个接口，这个接口不是任意堆砌的，而是一系列相关或相互依赖的方法。从某种意义来说，抽象工厂其实是一个产品簇。
示例：

/**
 * @description抽象产品A的接口
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public interface AbstractProductA {
	//定义抽象产品A的相关操作
	public void methodA();
}

/**
 * @description抽象产品B的接口
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public interface AbstractProductB {
	//定义抽象产品A的相关ctProduc操作
	public void methodB();
}

/**
 * @description抽象工厂的接口，声明创建抽象产品的操作
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public interface AbstractFactory {
	public AbstractProductA createProductA();
	public AbstractProductB createProductB();
}

/**
 * @description
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ProductA1 implements AbstractProductA {
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractProductA#methodA()
	 */
	@Override
	public void methodA() {
		System.out.println("This is ProductA1!");
	}
}

/**
 * @description
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ProductA2 implements AbstractProductA {
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractProductA#methodA()
	 */
	@Override
	public void methodA() {
		System.out.println("This is ProductA2!");
	}
}

/**
 * @description
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ProductB1 implements AbstractProductB {
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractProductA#methodA()
	 */
	@Override
	public void methodB() {
		System.out.println("This is ProductB1!");
	}
}

/**
 * @description
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ProductB2 implements AbstractProductB {
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractProductA#methodA()
	 */
	@Override
	public void methodB() {
		System.out.println("This is ProductB2!");
	}
}

/**
 * @description 其实就是 产品簇1
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ConcreteFactory1 implements AbstractFactory{
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractFactory#createProductA()
	 */
	@Override
	public AbstractProductA createProductA() {
		return new ProductA1();
	}
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractFactory#createProductB()
	 */
	@Override
	public AbstractProductB createProductB() {
		return new ProductB1();
	}
}

/**
 * @description其实就是 产品簇2
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ConcreteFactory2 implements AbstractFactory{
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractFactory#createProductA()
	 */
	@Override
	public AbstractProductA createProductA() {
		return new ProductA2();
	}
	/* (non-Javadoc)
	 * @see abstractfactory.AbstractFactory#createProductB()
	 */
	@Override
	public AbstractProductB createProductB() {
		return new ProductB2();
	}
}

/**
 * @description 其实抽象工厂的核心在于创造一系列有关联的对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class Client {
	public static void main(String[] strs){
		//创建抽象工厂对象
		AbstractFactory af = new ConcreteFactory1();
		//通过抽象工厂创建一系列对象，如产品A和B
		af.createProductA();
		af.createProductB();
	}
}