设计模式——工厂方法模式和抽象工厂模式

工厂方法模式和抽象工厂模式

---

工厂方法模式（Factory Method）

工厂方法模式是创建型设计模式之一。工厂方法模式是一种结构简单的设计模式。

定义

定义一个用于创建对象的接口，让子类决定实例化哪个类。

使用场景

在任何需要生成复杂对象的地方，都可以使用工厂模式。

UML 图

代码演示

抽象产品类定义Product

/**
 * 抽象产品定义
 */
public abstract class Product {

    public abstract void method();
}

具体产品A ConcreteAProduct

/**
 * 具体产品A
 */
public class ConcreteAProduct extends Product {
    @Override
    public void method() {
        System.out.println("具体的产品A");
    }
}

具体产品B ConcreteBProduct

/**
 * 具体产品B
 */
public class ConcreteBProduct extends Product {
    @Override
    public void method() {
        System.out.println("具体的产品B");
    }
}

抽象工厂 Factory

/**
 * 抽象工厂类
 */
public abstract class Factory {

    public abstract Product createProduct();
}

具体工厂实现 ConcreteFactory

/**
 * 具体工厂实现
 */
public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteAProduct();
    }
}

客户端

/**
 * 客户端
 */
public class Client {

    public static void main(String[] args) {
        Factory factory=new ConcreteFactory();
        Product product=factory.createProduct();
        product.method();
    }
}

输出

具体的产品A

采用反射简化对象构造

public abstract class Factory2 {

    public abstract  T createProduct(Class clz);
}

public class ConcreteFactory2 extends Factory2 {

    @Override
    public  T createProduct(Class clz) {

        Product p = null;
        try {
            p = clz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) p;
    }
}

客户端使用

/**
 * 客户端
 */
public class Client2 {

    public static void main(String[] args) {
        Factory2 factory=new ConcreteFactory2();
        Product product=factory.createProduct(ConcreteBProduct.class);
        product.method();
    }
}

简单工厂模式(静态工厂模式)

当只需要一个工厂时，可以不需要定义 抽象工厂基类，只需提供一个静态创建方法即可。此时退化为简单工厂模式或者叫静态工厂模式。

public class FactorySimple {

    public static Product createProduct(){
        return new ConcreteAProduct();
    }
}

抽象工厂模式(Abstract Factory)

抽象工厂模式也是创建型设计模式的一种。

定义

为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定具体的类。

使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。比如Android，IOS，Windows Phone 都有短信和拨号软件，两者都属于Software的范畴，但是他们操作系统平台不一样，即便是同一家公司出品的软件，代码逻辑也是不相同的，这个时候就可以考虑使用抽象工厂模式 来产生Android,IOS ,Windows Phone 下的短信和拨号软件。

UML图

代码演示

抽象产品A 定义

/**
 * 抽象产品A 定义
 */
public abstract class AbstractProductA {

    public abstract void method();
}

抽象产品B定义

/**
 * 抽象产品B定义
 */
public abstract class AbstractProductB {

    public abstract void method();
}

具体产品A1

/**
 * 具体产品A1
 */
public  class ConcreteA1Product extends AbstractProductA{

    @Override
    public void method() {
        System.out.println("生产了A1");
    }
}

具体产品A2

/**
 * 具体产品A2
 */
public  class ConcreteA2Product extends AbstractProductA{

    @Override
    public void method() {
        System.out.println("生产了A2");
    }
}

具体产品B1

/**
 * 具体产品B1
 */
public  class ConcreteB1Product extends AbstractProductB{

    @Override
    public void method() {
        System.out.println("生产了B1");
    }
}

具体产品B2

/**
 * 具体产品B2
 */
public class ConcreteB2Product extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("生产了B2");
    }
}

抽象工厂类,定义生产产品的方法

/**
 * 抽象工厂类,定义生产产品的方法
 */
public abstract class AbstractFactory {

    public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();

}

具体工厂实现1

/**
 * 具体工厂实现1
 */
public class ConcreteFactory1 extends AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteA1Product();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteB1Product();
    }
}

具体工厂2

/**
 * 具体工厂2
 */
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteA2Product();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteB2Product();
    }
}

客户端使用

public class Client {

    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA pA1 = factory1.createProductA();
        AbstractProductB pB1 = factory1.createProductB();
        pA1.method();
        pB1.method();
        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA pA2 = factory2.createProductA();
        AbstractProductB pB2 = factory2.createProductB();
        pA2.method();
        pB2.method();
    }
}

输出

生产了A1
生产了B1
生产了A2
生产了B2

工厂方法模式和抽象工厂模式的异同点

从这两种设计模式的定义和使用来看，都是为了方便外部调用，屏蔽程序内部设计细节，减少耦合，便于扩展。

工厂方法模式 简单来说只有一个工厂，抽象工厂模式则有多个工厂，用于产生相同类别但是不同属性的产品。