java设计模式之抽象工厂

抽象工厂模式（Abatract Factory Pattern）是一种比较常用的模式，其定义如下：Provide an interface for creating families of related or dependent objects without specifying their concrere classes.(为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。)

下面是抽象工厂的通用代码：

抽象产品类：

package com.jaynol.designpatterns.abstractfactory;

public abstract class AbstractProductA {
	/**
	 * 产品类公共方法 
	 * 可以考虑增加final关键字，防止子类重写，因为重写后会破坏封装性
	 */
	public void shareMethod(){
		//业务逻辑实现
	}
	
	//抽象方法，供子类做个性化扩展
	public abstract void doSomething();

}

package com.jaynol.designpatterns.abstractfactory;

public abstract class AbstractProductB {
	/**
	 * 产品类公共方法 
	 * 可以考虑增加final关键字，防止子类重写，因为重写后会破坏封装性
	 */
	public void shareMethod(){
		//业务逻辑实现
	}
	
	//抽象方法，供子类做个性化扩展
	public abstract void doSomething();

}

产品实现类：

package com.jaynol.designpatterns.abstractfactory;

public class ProductA1 extends AbstractProductA{

	@Override
	public void doSomething() {
		System.out.println("产品A1的实现方法");
	}

	
}

package com.jaynol.designpatterns.abstractfactory;

public class ProductA2 extends AbstractProductA{

	@Override
	public void doSomething() {
		System.out.println("产品A2的实现方法");
	}

	
}

package com.jaynol.designpatterns.abstractfactory;

public class ProductB1 extends AbstractProductB{

	@Override
	public void doSomething() {
		System.out.println("产品B1的实现方法");
	}

	
}

package com.jaynol.designpatterns.abstractfactory;

public class ProductB2 extends AbstractProductB{

	@Override
	public void doSomething() {
		System.out.println("产品B2的实现方法");
	}

	
}

抽象工厂类：

package com.jaynol.designpatterns.abstractfactory;

public abstract class AbstractCreator {
	
	//产生A产品家族
	public abstract AbstractProductA createProductA();
	
	//产生B产品家族
	public abstract AbstractProductB createProductB();

}

生产产品等级1的工厂实现类：

package com.jaynol.designpatterns.abstractfactory;

public abstract class AbstractProductA {
	/**
	 * 产品类公共方法 
	 * 可以考虑增加final关键字，防止子类重写，因为重写后会破坏封装性
	 */
	public void shareMethod(){
		//业务逻辑实现
	}
	
	//抽象方法，供子类做个性化扩展
	public abstract void doSomething();

}

生产产品等级2的工厂实现类：

package com.jaynol.designpatterns.abstractfactory;

public abstract class AbstractProductB {
	/**
	 * 产品类公共方法 
	 * 可以考虑增加final关键字，防止子类重写，因为重写后会破坏封装性
	 */
	public void shareMethod(){
		//业务逻辑实现
	}
	
	//抽象方法，供子类做个性化扩展
	public abstract void doSomething();

}

场景类：

package com.jaynol.designpatterns.abstractfactory;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//定义两个工厂
		AbstractCreator creator1 =  new Creator1();
		AbstractCreator creator2 =  new Creator2();
		
		//产生A1对象
		AbstractProductA a1 =  creator1.createProductA();
		//产生B1对象
		AbstractProductB b1 =  creator1.createProductB();
		
		//产生A2对象
		AbstractProductA a2 =  creator2.createProductA();
		//产生B2对象
		AbstractProductB b2 =  creator2.createProductB();
		
	}

}

抽象工厂模式的优点：
1.封装性，只需要知道工厂类是谁，就可以生产出具体的产品

2.产品族内的约束非公开状态，例如我需要约束生产的1级产品的数量为2级产品数量的1.2倍，这样的生产过程对于调用工厂类的高层模块来说是透明的，它不需要去知道这个约束。

抽象工厂模式的缺点：

抽象工厂模式的最大缺点就是产品族扩展非常困难，在上面的例子中，如果需要增加一个C系列的产品族的话，就需要增加一个AbstractProductC类，修改AbstractCreator类，增加生成C系列产品的方法，这样会导致每一个集成了AbstractCreator子类都需要修改，这样就严重违反了开闭原则，而且我们说接口和抽象类是一个契约。改变契约，所有与契约相关的代码都要修改，那就产生有毒代码了。

抽象工厂VS工厂方法：

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。  
一个抽象工厂类，可以派生出多个具体工厂类。  
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。  
一个抽象工厂类，可以派生出多个具体工厂类。  
每个具体工厂类可以创建多个具体产品类的实例。  
   
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。  
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。