抽象工厂模式AbstractFactory

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

 

2. 结构图

AbstractFactory：抽象工厂，定义创建一系列产品对象的操作接口。
ConcreteFactory：具体的工厂，实现抽象工厂定义的方法，具体实现一系列产品对象的创建。
AbstractProduct：定义一类产品对象的接口。
ConcreteProduct：具体的产品实现对象，通常在具体工厂里面，会选择具体的产品实现对象，来创建符合抽象工厂定义的方法返回的产品类型的对象。
Client：客户端，主要使用抽象工厂来获取一系列所需要的产品对象，然后面向这些产品对象的接口编程，以实现需要的功能。

 

3. 本质
抽象工厂模式的本质是：选择产品簇的实现。

 

4. Code Demo

AbstractProductA.java

package org.fool.pattern.abstractfactory;

/**
 * 抽象产品A的接口
 */
public interface AbstractProductA {
	// 定义抽象产品A相关的操作
}

AbstractProductB.java

package org.fool.pattern.abstractfactory;

/**
 * 抽象产品B的接口
 */
public interface AbstractProductB {
	// 定义抽象产品B相关的操作
}

AbstractFactory.java

package org.fool.pattern.abstractfactory;

/**
 * 抽象工厂的接口，声明创建抽象产品对象的操作
 */
public interface AbstractFactory {
	/**
	 * 示例方法，创建抽象产品A的对象
	 * 
	 * @return 抽象产品A的对象
	 */
	public AbstractProductA createProductA();

	/**
	 * 示例方法，创建抽象产品B的对象
	 * 
	 * @return 抽象产品B的对象
	 */
	public AbstractProductB createProductB();
}

 ProductA1.java

package org.fool.pattern.abstractfactory;

/**
 * 产品A的具体实现
 */
public class ProductA1 implements AbstractProductA {
	// 实现产品A的接口中定义的操作
	public ProductA1() {
		System.out.println("ProductA1 Created");
	}
}

ProductA2.java

package org.fool.pattern.abstractfactory;

/**
 * 产品A的具体实现
 */
public class ProductA2 implements AbstractProductA {
	// 实现产品A的接口中定义的操作
	public ProductA2() {
		System.out.println("ProductA2 Created");
	}
}

 ProductB1.java

package org.fool.pattern.abstractfactory;

/**
 * 产品B的具体实现
 */
public class ProductB1 implements AbstractProductB {
	// 实现产品B的接口中定义的操作
	public ProductB1() {
		System.out.println("ProductB1 Created");
	}
}

ProductB2.java

package org.fool.pattern.abstractfactory;

/**
 * 产品B的具体实现
 */
public class ProductB2 implements AbstractProductB {
	// 实现产品B的接口中定义的操作
	public ProductB2() {
		System.out.println("ProductB2 Created");
	}
}

 ConcreteFactory1.java

package org.fool.pattern.abstractfactory;

/**
 * 具体的工厂实现对象，实现创建具体的产品对象的操作
 */
public class ConcreteFactory1 implements AbstractFactory {

	public AbstractProductA createProductA() {
		return new ProductA1();
	}

	public AbstractProductB createProductB() {
		return new ProductB1();
	}

}

 ConcreteFactory2.java

package org.fool.pattern.abstractfactory;

/**
 * 具体的工厂实现对象，实现创建具体的产品对象的操作
 */
public class ConcreteFactory2 implements AbstractFactory {

	public AbstractProductA createProductA() {
		return new ProductA2();
	}

	public AbstractProductB createProductB() {
		return new ProductB2();
	}

}

 Client.java

package org.fool.pattern.abstractfactory;

public class Client {

	public static void main(String[] args) {
		// 创建抽象工厂对象
		AbstractFactory factory = new ConcreteFactory1();
		// 通过抽象工厂来获取一系列的对象，如产品A和产品B
		factory.createProductA();
		factory.createProductB();
		
		factory = new ConcreteFactory2();
		factory.createProductA();
		factory.createProductB();
	}
}