工厂模式 (Factory Pattern)

工厂模式 (Factory Pattern)

工厂模式（Factory Pattern）是一种创建型设计模式，用于封装对象的实例化过程。在该模式中，我们将对象的创建交给一个工厂类来处理，而不是在客户端直接实例化对象。工厂模式提供了一种创建对象的接口，通过这个接口可以创建不同类型的对象，而无需暴露具体实现类的细节。

在Java中，工厂模式可以通过多种方式实现，其中最常见的方式包括简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式（Simple Factory Pattern）：

简单工厂模式由一个工厂类负责创建不同类型的对象。客户端通过传递不同的参数给工厂类，来获得所需的对象实例。简单工厂模式的主要作用是隐藏对象的创建逻辑，使得客户端只需要关注对象的使用，而无需关注对象的具体创建过程。

// 定义一个简单工厂类，负责创建对象
public 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("Invalid product type.");
        }
    }
}

// 定义产品接口
public interface Product {
    void operate();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void operate() {
        System.out.println("Operating Product A.");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void operate() {
        System.out.println("Operating Product B.");
    }
}

// 客户端使用简单工厂创建对象
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operate();
        
        Product productB = SimpleFactory.createProduct("B");
        productB.operate();
    }
}

工厂方法模式（Factory Method Pattern）：

工厂方法模式将对象的创建委托给具体的子类工厂。每个子类工厂负责创建特定类型的对象，从而实现了对象的多态性。客户端通过调用工厂方法来创建对象，而具体实现由子类工厂来完成。工厂方法模式的优势在于可以为每个对象类型定义独立的工厂类，增加了系统的灵活性和可扩展性。

// 定义产品接口
public interface Product {
    void operate();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void operate() {
        System.out.println("Operating Product A.");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void operate() {
        System.out.println("Operating Product B.");
    }
}

// 定义一个工厂接口
public interface Factory {
    Product createProduct();
}

// 具体工厂A，负责创建产品A
public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B，负责创建产品B
public 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.operate();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operate();
    }
}

抽象工厂模式（Abstract Factory Pattern

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体的类。客户端通过使用工厂接口来创建对象，从而使得对象的创建与使用解耦。抽象工厂模式适用于需要一次性创建一组相关对象的场景，如创建不同操作系统下的界面元素。

// 定义产品族A的接口
public interface ProductA {
    void operate();
}

// 定义产品族B的接口
public interface ProductB {
    void operate();
}

// 具体产品A1
public class ConcreteProductA1 implements ProductA {
    @Override
    public void operate() {
        System.out.println("Operating Product A1.");
    }
}

// 具体产品A2
public class ConcreteProductA2 implements ProductA {
    @Override
    public void operate() {
        System.out.println("Operating Product A2.");
    }
}

// 具体产品B1
public class ConcreteProductB1 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating Product B1.");
    }
}

// 具体产品B2
public class ConcreteProductB2 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating Product B2.");
    }
}

// 定义抽象工厂接口
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1，负责创建产品族1的产品
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2，负责创建产品族2的产品
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端使用抽象工厂创建对象
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.operate();
        productB1.operate();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.operate();
        productB2.operate();
    }
}

工厂模式适用于以下场景：

• 当一个类不知道它所需对象的确切类名时，可以使用工厂模式来创建对象。

• 当一个类希望将对象的创建逻辑委托给其他类时，可以使用工厂模式。

• 当一个类需要创建多个相互依赖的对象时，可以使用抽象工厂模式。

• 当希望通过修改工厂类来改变具体实例化对象的方式时，可以使用工厂模式。

工厂模式相比直接实例化对象的优势包括：

• 封装对象的创建逻辑：工厂模式将对象的创建过程封装在工厂类中，客户端无需关心对象的具体创建过程，只需通过工厂类来获取所需对象。这样可以使客户端代码更加简洁，同时也提高了代码的可维护性和可扩展性。

• 提供灵活性和可扩展性：通过使用工厂模式，可以轻松地替换具体的实现类或扩展工厂类，而无需修改客户端代码。这种灵活性和可扩展性使得系统更易于维护和升级。

• 降低耦合性：工厂模式将对象的创建与使用解耦，客户端只需要与工厂接口进行交互，而无需与具体的实现类直接交互。这种低耦合性使得系统的组件更加独立，易于测试和维护。

总结来说，工厂模式是一种优秀的设计模式，它通过封装对象的创建过程，提供了灵活性、可扩展性和低耦合性的优势。在Java中，工厂模式的不同变体适用于不同的场景，可以根据具体需求选择合适的工厂模式来创建对象。