设计模式之工厂模式-简单工厂、工厂方法、抽象工厂模式

工厂模式是一种常见的创建型设计模式，它提供了一种创建对象的方法，将对象的创建与使用分离开来，可以减少代码的耦合度。在工厂模式中，我们通过一个工厂类来创建对象，而不是直接在代码中实例化对象。

工厂模式有三种常见的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。下面我将简单介绍一下这三种模式的实现方式。

1. 简单工厂模式

简单工厂模式又称为静态工厂模式，它通过一个工厂类来创建对象，客户端只需要知道要创建的产品的类型，而不需要知道具体的实现细节。简单工厂模式适用于创建的对象比较少的情况。

下面是一个简单工厂模式的示例代码：

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

// 具体产品类
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("不支持的产品类型");
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();

        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

上面的代码中，我们定义了一个抽象产品类 Product 和两个具体产品类 ConcreteProductA 和 ConcreteProductB。然后我们定义了一个工厂类 SimpleFactory，其中的 createProduct 方法根据传入的参数创建不同的产品对象。

客户端只需要调用 SimpleFactory.createProduct 方法，传入对应的参数，就可以得到不同的产品对象。

2. 工厂方法模式

工厂方法模式是指定义一个抽象工厂接口，具体的工厂类实现这个工厂接口，并且每个具体工厂类只能创建对应的产品。工厂方法模式适用于创建的对象比较多的情况。

下面是一个工厂方法模式的示例代码：

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

// 具体产品类
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

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

// 具体工厂类
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

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

上面的代码中，我们定义了一个抽象产品类 Product 和两个具体产品类 ConcreteProductA 和 ConcreteProductB。然后我们定义了一个抽象工厂类 Factory，其中的 createProduct 方法用于创建产品对象。

接着我们定义了两个具体工厂类 ConcreteFactoryA 和 ConcreteFactoryB，它们分别实现了 Factory 接口，并且每个工厂类只能创建对应的产品。

客户端需要先创建对应的具体工厂类对象，然后通过工厂对象的 createProduct 方法来创建产品对象。

3. 抽象工厂模式

抽象工厂模式是指定义一个抽象工厂接口，具体的工厂类实现这个工厂接口，并且每个工厂类可以创建一组产品。抽象工厂模式适用于创建的对象有多个产品族的情况。

下面是一个抽象工厂模式的示例代码：

// 抽象产品类
interface ProductA {
    void use();
}

interface ProductB {
    void eat();
}

// 具体产品类
class ConcreteProductA1 implements ProductA {
    public void use() {
        System.out.println("使用产品A1");
    }
}

class ConcreteProductA2 implements ProductA {
    public void use() {
        System.out.println("使用产品A2");
    }
}

class ConcreteProductB1 implements ProductB {
    public void eat() {
        System.out.println("吃产品B1");
    }
}

class ConcreteProductB2 implements ProductB {
    public void eat() {
        System.out.println("吃产品B2");
    }
}

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

// 具体工厂类
class ConcreteFactory1 implements Factory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 implements Factory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.use();

        ProductB productB1 = factory1.createProductB();
        productB1.eat();

        Factory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.use();

        ProductB productB2 = factory2.createProductB();
        productB2.eat();
    }
}

上面的代码中，我们定义了两个抽象产品类 ProductA 和 ProductB，以及四个具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2。

然后我们定义了一个抽象工厂类 Factory，其中的 createProductA 和 createProductB 方法分别用于创建 ProductA 和 ProductB 对象。

接着我们定义了两个具体工厂类 ConcreteFactory1 和 ConcreteFactory2，它们分别实现了 Factory 接口，并且每个工厂类可以创建一组产品。

客户端需要先创建对应的具体工厂类对象，然后通过工厂对象的 createProductA 和 createProductB 方法来创建产品对象。