设计模式-工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们创建对象而不会将创建逻辑暴露给客户端，并使用一个公共接口引用新创建的对象。

工厂模式有三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。其中，简单工厂模式是最简单的一种工厂模式，它通过一个工厂类来创建不同类型的对象，而不需要客户端直接创建对象。工厂方法模式是将工厂类抽象化，使得每个具体工厂类只能创建一种类型的对象。抽象工厂模式则是将工厂类和产品类都抽象化，使得每个具体工厂类可以创建一组相关的产品。

工厂模式的优点是将对象的创建和使用分离，使得代码更加灵活和可扩展。同时，它也可以隐藏对象的创建细节，使得客户端不需要了解创建对象的具体过程。缺点是增加了代码的复杂度，需要额外的工厂类来创建对象。

在实际应用中，工厂模式经常被用于创建复杂对象，例如数据库连接池、日志记录器等。

简单工厂模式

首先，我们需要定义一个抽象产品类，例如：

public abstract class Product {
    public abstract void use();
}

然后，我们定义两个具体产品类，分别实现抽象产品类：

public class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

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

接下来，我们定义一个简单工厂类，用于创建产品对象：

public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unsupported product type: " + type);
        }
    }
}

最后，我们可以使用简单工厂类来创建产品对象：

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

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

这样，我们就成功地使用简单工厂模式创建了产品对象。

工厂方法模式

工厂方法模式是一种常用的对象创建型设计模式，它通过定义工厂接口和工厂实现类来实现对象的创建。

首先定义一个抽象产品类：

public abstract class Product {
    public abstract void use();
}

然后定义具体产品类：

public class ConcreteProductA extends Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

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

接着定义一个工厂接口：

public interface Factory {
    public Product createProduct();
}

最后定义具体工厂类：

public class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public 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，以及具体工厂类ConcreteFactoryA和ConcreteFactoryB。客户端通过具体工厂类来创建具体产品对象，从而实现了工厂方法模式。

抽象工厂模式

在抽象工厂模式中，我们定义一个抽象工厂接口，该接口声明了一组用于创建一系列产品的方法。每个具体工厂都实现了这个接口，并负责创建一组具体产品，这些产品通常是相关的。

首先，我们定义一个抽象工厂接口，它声明了两个用于创建产品A和产品B的方法：

public interface AbstractFactory {
    public ProductA createProductA();
    public ProductB createProductB();
}

然后，我们定义两个具体工厂类，它们实现了抽象工厂接口，并负责创建一组相关的产品：

public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

最后，我们定义两个产品族，每个产品族包含一个产品A和一个产品B：

public interface ProductA {
    public void operationA();
}

public interface ProductB {
    public void operationB();
}

public class ConcreteProductA1 implements ProductA {
    public void operationA() {
        System.out.println("ConcreteProductA1.operationA()");
    }
}

public class ConcreteProductB1 implements ProductB {
    public void operationB() {
        System.out.println("ConcreteProductB1.operationB()");
    }
}

public class ConcreteProductA2 implements ProductA {
    public void operationA() {
        System.out.println("ConcreteProductA2.operationA()");
    }
}

public class ConcreteProductB2 implements ProductB {
    public void operationB() {
        System.out.println("ConcreteProductB2.operationB()");
    }
}

现在，我们可以使用这些类来创建一组相关的产品：

AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.operationA();
productB1.operationB();

AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.operationA();
productB2.operationB();

输出结果为：

ConcreteProductA1.operationA()
ConcreteProductB1.operationB()
ConcreteProductA2.operationA()
ConcreteProductB2.operationB()

这个例子展示了如何使用抽象工厂模式创建一组相关的产品。客户端只需要知道要创建哪个产品族，而不需要知道具体的产品类。这样可以使客户端代码更加灵活和可维护。

应用场景

1. 简单工厂模式的应用场景：

- 当需要创建的对象较少时，可以使用简单工厂模式，将对象的创建集中在一个工厂类中，便于管理和维护。
- 当客户端不需要知道对象的创建过程时，可以使用简单工厂模式，客户端只需要知道工厂类即可。

2. 工厂方法模式的应用场景：

- 当需要创建的对象较多时，可以使用工厂方法模式，每个对象的创建都由对应的工厂类来完成，便于扩展和维护。
- 当客户端需要知道对象的创建过程时，可以使用工厂方法模式，客户端需要知道对应的工厂类和产品类。

3. 抽象工厂模式的应用场景：

- 当需要创建一组相关或相互依赖的对象时，可以使用抽象工厂模式，每个工厂类负责创建一组对象，便于管理和维护。
- 当客户端需要知道对象的创建过程时，可以使用抽象工厂模式，客户端需要知道对应的抽象工厂类和抽象产品类。

总的来说，工厂模式适用于对象的创建过程比较复杂，或者需要根据不同的条件创建不同的对象的情况。在实际开发中，根据具体的需求选择不同的工厂模式可以提高代码的可维护性和可扩展性。