工厂模式详解

工厂模式和单例模式可以说是开发中最常见的设计模式，这两个都是创建型的设计模式。其中工厂模式又可以分为三种，分别是：简单工厂（又称为静态工厂模式）、工厂方法、抽象工厂三种，如下图，下面分别介绍这三种。

简单工厂

简单工厂方法定义了一个具体工厂类，里面可以生产不同的产品，根据传入的参数的不同生成不同的产品。例如下面代码：

// 抽象产品类
interface Product {
    void printName();
}

// 具体产品类A
class ProductA implements Product {
    public void printName() {
        System.out.println("ProductA");
    }
}

// 具体产品类B
class ProductB implements Product {
    public void printName() {
        System.out.println("ProductB");
    }
}

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if(type.equals("A")) {
            return new ProductA();
        } else if(type.equals("B")) {
            return new ProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product product = factory.createProduct("A");
        product.printName();
    }
}

工厂方法

将工厂方法定义在接口中，让实现类来决定创建哪个产品实例，这样可以实现创建对象和使用对象的分离。

// 抽象产品类
interface Product {
    void printName();
}

// 具体产品类A
class ProductA implements Product {
    public void printName() {
        System.out.println("ProductA");
    }
}

// 具体产品类B
class ProductB implements Product {
    public void printName() {
        System.out.println("ProductB");
    }
}

// 抽象工厂类
interface Factory {
    Product createProduct();
}

// 具体工厂类A
class FactoryA implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
class FactoryB implements Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        Product product = factory.createProduct();
        product.printName();
    }
}

抽象工厂

定义一系列产品接口，每个工厂负责创建一组相关产品的具体实例，可以扩展产品簇而不需要修改代码。

// 抽象产品A
interface ProductA {
    void printName();
}

// 具体产品A1
class ProductA1 implements ProductA {
    public void printName() {
        System.out.println("ProductA1");
    }
}

// 具体产品A2
class ProductA2 implements ProductA {
    public void printName() {
        System.out.println("ProductA2");
    }
}

// 抽象产品B
interface ProductB {
    void printName();
}

// 具体产品B1
class ProductB1 implements ProductB {
    public void printName() {
        System.out.println("ProductB1");
    }
}

// 具体产品B2
class ProductB2 implements ProductB {
    public void printName() {
        System.out.println("ProductB2");
    }
}

// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA2();
    }
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();
        productA.printName();
        productB.printName();
    }
}

适用场景

这几个分类是根据不同的实现方式和应用场景来划分的，以下是它们的区别：

简单工厂模式(Simple Factory Pattern)：简单工厂模式是最简单的创建型模式之一，它只有一个工厂类，根据传入的参数，动态决定应该创建哪个产品类的实例。所以又叫作静态工厂方法模式。优点是创建对象及其简单，缺点是不够灵活，扩展性不好。

工厂方法模式(Factory Method Pattern)：工厂方法模式是定义了一个创建对象的接口，在子类中实现该接口，从而可以有多个工厂子类来创建不同的产品对象。它通过让子类决定要创建什么对象来解决了工厂模式中工厂方法单一的问题，扩展性更好。但对于每个新的对象都需要写一个相应的工厂类，代码量也相应增加。

抽象工厂模式(Abstract Factory Pattern)：抽象工厂模式也叫作工厂组合模式或超级工厂模式，它是一种对象创建型模式。在抽象工厂模式中，工厂类不再只是负责单一的产品生产，而是负责一个产品族的生产。这样子类就不必对每个新产品都重新定义一个工厂类了，它更好地符合“开放-封闭”原则。缺点是如果需要增加一类产品族，则需要修改抽象工厂和所有具体工厂的代码。

总之，三种工厂模式的区别在于它们创建对象的方式和能否适应扩展。简单工厂模式能够动态创建一个对象；工厂方法模式提供了一个接口，让子类实现创建工厂；抽象工厂模式能够创建一个产品族的对象。因此我们需要根据实际需求来选择合适的工厂模式实现相应的功能。