java中设计模式之工厂模式（创建型模式）

 什么是工厂模式？

为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，通过一个工厂类来实现对象的创建，而无需直接暴露对象的创建逻辑给客户端。

简单工厂模式

在工厂模式中，简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它通过一个单独的工厂类来实现对象的创建，而无需使用具体的工厂类。简单工厂模式将对象的创建逻辑封装在一个工厂方法中，客户端通过调用工厂方法来获取所需的对象。

简单工厂模式通常由以下几个主要组件构成：

1. 工厂类（Factory）：负责创建产品对象的类。它包含一个工厂方法，根据客户端的请求创建相应的产品对象。

2. 抽象产品（Product）：定义产品对象的共同接口或抽象类，声明了产品对象的通用属性和方法。

3. 具体产品（Concrete Product）：实现抽象产品接口，定义具体的产品对象。

// 抽象产品
interface Product {
    void doSomething();
}
// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductA.");
    }
}
// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductB.");
    }
}
// 简单工厂
class SimpleFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("Invalid product type.");
    }
}
// 客户端使用简单工厂创建产品
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        productA.doSomething();

        Product productB = factory.createProduct("B");
        productB.doSomething();
    }
}

简单工厂模式可以根据客户端的需要，将对象的创建逻辑封装在一个工厂类中，提供了一种灵活且简单的方式来创建对象。然而，当需要添加新的产品类型时，需要修改工厂类的代码，可能导致工厂类的职责过于臃肿，不符合开闭原则。

工厂方法模式

它通过定义一个用于创建对象的工厂方法，让子类决定实例化哪个具体类。工厂方法模式将对象的创建延迟到子类中进行，从而实现了将对象的创建与使用解耦的效果。

工厂方法模式通常由以下几个主要组件构成：

1. 抽象产品（Product）：定义产品对象的共同接口或抽象类，声明了产品对象的通用属性和方法。

2. 具体产品（Concrete Product）：实现抽象产品接口，定义具体的产品对象。

3. 抽象工厂（Factory）：定义一个工厂方法，用于创建抽象产品对象。可以是接口或抽象类。

4. 具体工厂（Concrete Factory）：实现抽象工厂，具体的工厂类负责实例化具体产品对象。

// 抽象产品
interface Product {
    void doSomething();
}
// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductA.");
    }
}
// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductB.");
    }
}
// 抽象工厂
interface Factory {
    Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
// 客户端使用工厂方法创建产品
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.doSomething();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.doSomething();
    }
}

客户端根据需要选择合适的具体工厂来创建产品，通过调用工厂的 createProduct 方法来获取所需的产品对象，并调用其方法。

工厂方法模式遵循开闭原则，当需要添加新的产品时，可以创建新的具体产品和相应的具体工厂，无需修改已有的代码。这种灵活性是工厂方法模式的一个优点。

抽象工厂模式 

抽象工厂模式可以被看作是工厂方法模式的升级版，它通过抽象工厂接口来创建一系列相关的产品对象。与工厂方法模式只能创建单一类型产品不同，抽象工厂模式支持创建一组相关的产品。因此，抽象工厂模式比较适用于创建具有多个产品系列的情况。

在抽象工厂模式中，主要有以下角色：

1. 抽象工厂（Abstract Factory）：定义创建一组相关产品对象的接口，它包含多个创建产品的方法。

2. 具体工厂（Concrete Factory）：实现抽象工厂接口，具体工厂负责创建具体的产品对象。

3. 抽象产品（Abstract Product）：定义产品的共同接口，声明产品的通用方法。

4. 具体产品（Concrete Product）：实现抽象产品接口，具体产品是抽象工厂模式中创建的对象。

// 抽象产品A
interface AbstractProductA {
    void doSomethingA();
}
// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void doSomethingA() {
        System.out.println("Doing something in ConcreteProductA1.");
    }
}
// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void doSomethingA() {
        System.out.println("Doing something in ConcreteProductA2.");
    }
}
// 抽象产品B
interface AbstractProductB {
    void doSomethingB();
}
// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void doSomethingB() {
        System.out.println("Doing something in ConcreteProductB1.");
    }
}
// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void doSomethingB() {
        System.out.println("Doing something in ConcreteProductB2.");
    }
}
// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}
// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}
// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}
// 客户端使用抽象工厂创建产品
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.doSomethingA();
        productB1.doSomethingB();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.doSomethingA();
        productB2.doSomethingB();
    }
}

通过抽象工厂，客户端可以创建属于同一个产品族的产品对象。通过调用抽象工厂的不同方法，可以创建不同种类的产品对象。这样可以保证创建的产品对象是相互关联、兼容的。

抽象工厂模式可以提供更高层次的抽象，使得客户端代码与具体产品无关，更加灵活和可扩展。同时也遵循了开闭原则，对新的产品族扩展时只需要添加新的具体工厂类，而不需要修改已有代码。