java设计模式---抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。

组成：

抽象工厂：接口或者抽象类，创建相互依赖对象。

具体工厂：具体类，实现或继承抽象工厂，负责组合相应的产品。

抽象产品：接口或者抽象类，产品的抽象。

具体产品：具体类，抽象产品的具体化。

类图关系：

具体实例：（模拟不同汽车的生产）

抽象产品类1：AbstractEngine.java

public abstract class AbstractEngine {
	
	public abstract void print();

}

抽象产品类2：AbstractWheel.java

public abstract class AbstractWheel {
	
	public abstract void print();

}

抽象产品类1的具体产品：BenzEngine.java和BmwEngine.java

public class BenzEngine extends AbstractEngine {

	@Override
	public void print() {
		System.out.println("已经生产BENZ引擎发动机~~~");
	}

}

 

public class BmwEngine extends AbstractEngine {

	@Override
	public void print() {
		System.out.println("已经生产BMW引擎发动机~~~");
	}

}

抽象产品类2的具体产品：BenzWheel.java和BmwWheel.java

public class BenzWheel extends AbstractWheel {

	@Override
	public void print() {
		System.out.println("已经生产BENZ轮子~~~");
	}

}

 

public class BmwWheel extends AbstractWheel {

	@Override
	public void print() {
		System.out.println("已经生产BMW轮子~~~");
	}

}

抽象工厂类：AbstractFactory.java

public interface AbstractFactory {
	
	public abstract void createCar();
	
}

具体工厂类：BenzFactory.java和BmwFactory.java

public class BenzFactory implements AbstractFactory {

	@Override
	public void createCar() {
		AbstractEngine benzEngine = new BenzEngine();
		benzEngine.print();
		
		AbstractWheel benzWheel = new BenzWheel();
		benzWheel.print();
		
		System.out.println("BENZ已经成功生产！！！");
	}

}

 

public class BmwFactory implements AbstractFactory {

	@Override
	public void createCar() {
		AbstractEngine bmwEngine = new BmwEngine();
		bmwEngine.print();
		
		AbstractWheel bmwWheel = new BmwWheel();
		bmwWheel.print();	
		
		System.out.println("BMW已经成功生产！！！");
	}

}

客户端：Client.java

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		AbstractFactory bmwFactory = new BmwFactory();
		bmwFactory.createCar();
	}

}

运行结果：

当有新的发动机和新的轮子出现时，可以创建一个新的类继承抽象工厂来创建新的汽车。

应用场景：

一个系统要独立于它的产品的创建、组合和表示时；

一个系统由多个产品系列中的一个来配置时；

强调一系列相关产品对象的设计以便进行联合使用时；

提供一个产品类库，只想显示接口而不是实现时。