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(); } }