抽象工厂

抽象工厂是为一系列相关对象或相互依赖的对象创建一个接口，该接口内的方法不是随意的，各方法所返回的对象是相关或相互依赖的。

简单工厂，工厂方法，抽象工厂，三者之间的关系是：后者包含前者的特性，后者比前者更复杂一些，更进一步。简单工厂就是“选择实现”，面向接口编程，将接口对象的创建隔离起来。工厂方法在简单工厂的基础上，将接口对象的创建“延迟”到子类中去实现，工厂方法一般不对外使用，只在工厂类中使用。工厂方法一般只有一个抽象方法，用于创建某种接口对象，或者有多个抽象方法，但抽象方法创建的接口对象间没什么联系，但抽象工厂会有多个抽象方法，每个抽象方法创建的接口对象是相互关联的，也可以这么说，工厂方法只创建一种接口的对象，而抽象工厂创建多种接口的对象，且其对象是关联的。

实例化client需要的接口对象的工作并不是这3种工厂模式做的，而是由其他接口和接口的实现类完成的（叫这些类产品类吧），只是在工厂类中选择下用哪个具体的产品类而已，工厂模式相当于在client和产品类中加的一层，没有这一层，也一样完全可以工作，只是增加了这一层后，“据说”可以提高灵活性，可扩展可维护性（我没还在实际开发中用过，所以“据说”）。

示例代码

public class Abstract_Factory {
	public static void main(String[] args) {
		AbstractFactory f1 = new ConcreteFactory1();
		//"配套的"一组产品
		AbstractProductA pa = f1.createProductA();
		AbstractProductB pb = f1.createProductB();
		
		//"配套的"另一组产品
		AbstractFactory f2 = new ConcreteFactory2();
		AbstractProductA pa2 = f2.createProductA();
		AbstractProductB pb2 = f2.createProductB();
	}
}

interface AbstractFactory{
	public AbstractProductA createProductA();
	public AbstractProductB createProductB();
}

class ConcreteFactory1 implements AbstractFactory{

	@Override
	public AbstractProductA createProductA() {
		// TODO Auto-generated method stub
		return new ProductA1();
	}

	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB1();
	}
	
}

class ConcreteFactory2 implements AbstractFactory{
	
	@Override
	public AbstractProductA createProductA() {
		// TODO Auto-generated method stub
		return new ProductA2();
	}
	
	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	}
	
}

interface AbstractProductA {
	
}

interface AbstractProductB {
	
}

class ProductA1 implements AbstractProductA{
	
}

class ProductA2 implements AbstractProductA{
	
}

class ProductB1 implements AbstractProductB{
	
}

class ProductB2 implements AbstractProductB{
	
}

这种方式的缺点是当要扩展产品时，比如在AbstractFactory里增加产品AbstractProductC，那么所有实现了 AbstractFactory的子类都需要修改，这显然是不好的，糟糕的设计！一个不太安全的解决办法是：

public class Abstract_Factory2 {
	public static void main(String[] args) {
		AbstractFactory f1 = new ConcreteFactory1();
		AbstractProductA pa = (AbstractProductA) f1.createProduct(1);
		AbstractProductB pb = (AbstractProductB) f1.createProduct(2);
		AbstractProductC pc = (AbstractProductC) f1.createProduct(3);
	}
}

interface AbstractFactory{
	public Object createProduct(int type);
}

class ConcreteFactory1 implements AbstractFactory{

	@Override
	public Object createProduct(int type) {
		if(type == 1){ //约定type为1时，返回产品 AbstractProductA
			return new ProductA1();
		}else if(type == 2){//约定type为2时，返回产品 AbstractProductB
			return new ProductB1();
		}
	}
	
}

class ConcreteFactory2 implements AbstractFactory{
	
	@Override
	public Object createProduct(int type) {
		if(type == 1){
			return new ProductA2();
		}else if(type == 2){
			return new ProductB2();
		}else if(type == 3){ //返回扩展的产品
			return new ProductC2(); 
		}
	}
	
}

interface AbstractProductA {
	
}

interface AbstractProductB {
	
}

class ProductA1 implements AbstractProductA{
	
}

class ProductA2 implements AbstractProductA{
	
}

class ProductB1 implements AbstractProductB{
	
}

class ProductB2 implements AbstractProductB{
	
}


interface AbstractProductC { //增加了产品 AbstractProductC
	
}

class ProductC1 implements AbstractProductC{
	
}

class ProductC2 implements AbstractProductC{
	
}