【设计模式】工厂模式

什么是工厂模式

工厂模式变体

工厂模式优缺点

优点

缺点

简单工厂模式的实现

代码实现

工厂模式方法的实现

代码实现

抽象工厂模式的实现

代码实现

什么是工厂模式

工厂模式是一种设计模式，用于创建对象的过程与对象使用者解耦，从而提高代码的灵活性和可维护性。在工厂模式中，将对象的创建过程封装在一个工厂类中，使用者不需要直接实例化对象，而是通过工厂类来获取所需的对象实例。

简单来说就是，封装工厂类，工厂类获取实例。

工厂模式变体

简单工厂模式（Simple Factory Pattern）：简单工厂模式由一个工厂类负责创建所有对象实例，使用者通过调用工厂类的静态方法来获取对象实例。这种模式简单易懂，但违背了开放-封闭原则，因为每次新增一个产品都需要修改工厂类。
工厂方法模式（Factory Method Pattern）：工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。这样可以将实例化的过程延迟到子类中，符合开放-封闭原则，但需要为每个具体产品定义一个工厂类。
抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。它将一组具有相似主题的工厂封装起来，对于增加新的产品族很方便，但是难以增加新的产品等级结构。

工厂模式优缺点

优点

降低耦合性：使用者只需要知道工厂类及其接口，无需关心具体的产品实现，降低了对象之间的耦合性。
提高可维护性：当需要更改产品类时，只需修改工厂类的代码，而不需要修改使用者的代码。

增加扩展性：可以根据需求轻松添加新的产品类，而无需更改现有代码。

缺点

增加了类的数量：引入了额外的工厂类，可能会增加类的数量，使得代码结构变得复杂。

增加了系统的抽象性和理解难度：对于初学者来说，理解工厂模式的思想和实现可能会比较困难，特别是在涉及多层次的抽象工厂时。

简单工厂模式的实现

代码实现

/**
 * @description:
 * @author: 黎剑
 * @create: 2024-04-16 22:32
 **/
// 定义产品接口
interface Product {
    void operation();
}
// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("具体产品A的操作");
    }
}
// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("具体产品B的操作");
    }
}
// 简单工厂类
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");
        Product productB = SimpleFactory.createProduct("B");
        // 调用产品实例的操作方法
        productA.operation();
        productB.operation();
    }
}

在这个示例中，Product 是一个产品接口，定义了产品的操作方法。ConcreteProductA 和 ConcreteProductB 是具体的产品类，实现了 Product 接口。

SimpleFactory 是工厂类，负责根据传入的参数来创建具体的产品实例。在 Client 类中，通过调用工厂类的 createProduct 方法来获取所需的产品实例，并调用产品实例的操作方法。

这样，客户端代码与具体产品类之间解耦，客户端只需要与工厂类打交道，可以根据需要轻松切换不同的产品类型。

工厂模式方法的实现

工厂方法模式的核心思想是定义一个抽象的工厂类，该工厂类包含一个抽象方法，用于创建产品对象。具体的产品类需要实现这个抽象方法，以创建具体的产品实例。

工厂方法模式通常包括以下角色：

抽象产品（Abstract Product）：定义了产品的接口，描述了产品的特性和行为。
具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的具体行为。
抽象工厂（Abstract Factory）：定义了一个抽象方法，用于创建产品对象，客户端通过调用这个方法来获取产品对象。
具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体的产品对象。

代码实现

/**
 * @description:
 * @author: 黎剑
 * @create: 2024-04-16 22:32
 **/
// 定义抽象产品接口
interface Product {
    void operation();
}
// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("具体产品A的操作");
    }
}
// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("具体产品B的操作");
    }
}
// 抽象工厂接口
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();
        Factory factoryB = new ConcreteFactoryB();
        // 使用具体工厂创建产品实例
        Product productA = factoryA.createProduct();
        Product productB = factoryB.createProduct();
        // 调用产品实例的操作方法
        productA.operation();
        productB.operation();
    }
}

在这个示例中，Product 是抽象产品接口，定义了产品的操作方法。ConcreteProductA 和 ConcreteProductB 是具体的产品类，分别实现了 Product 接口。

Factory 是抽象工厂接口，定义了一个抽象方法 createProduct()，用于创建产品实例。ConcreteFactoryA 和 ConcreteFactoryB 是具体的工厂类，分别实现了 Factory 接口，并实现了 createProduct() 方法以创建具体的产品实例。

在客户端代码 Client 中，通过创建具体工厂实例，并调用其 createProduct() 方法来获取产品实例，然后调用产品实例的操作方法。

这样，客户端代码与具体产品类之间解耦，客户端只需要与抽象工厂打交道，可以根据需要轻松切换不同的具体工厂和产品类型。

抽象工厂模式的实现

抽象工厂模式的主要目的是提供一个接口，用于创建相关对象的家族，而不需要指定具体的类。

在抽象工厂模式中，有两个关键的抽象概念：

抽象产品（Abstract Product）：定义了一系列产品的接口，描述了产品的特性和行为。
抽象工厂（Abstract Factory）：定义了一个用于创建一系列产品的接口，包括创建产品的方法。

抽象工厂模式通常包括以下角色：

抽象产品接口（Abstract Product）：定义了一系列产品的接口，描述了产品的特性和行为。
具体产品类（Concrete Product）：实现了抽象产品接口，定义了具体产品的具体行为。
抽象工厂接口（Abstract Factory）：定义了一个用于创建一系列产品的接口，包括创建产品的方法。
具体工厂类（Concrete Factory）：实现了抽象工厂接口，负责创建一系列相关的产品。

抽象工厂模式的核心思想是提供一个接口，用于创建一系列相关的产品对象，而不需要指定具体的类。客户端通过调用抽象工厂的方法来获取产品对象，从而实现了客户端代码与具体产品类之间的解耦。

代码实现

// 定义抽象产品接口A
interface AbstractProductA {
    void operationA();
}
// 具体产品类A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("具体产品A1的操作");
    }
}
// 具体产品类A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("具体产品A2的操作");
    }
}
// 定义抽象产品接口B
interface AbstractProductB {
    void operationB();
}
// 具体产品类B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("具体产品B1的操作");
    }
}
// 具体产品类B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("具体产品B2的操作");
    }
}
// 定义抽象工厂接口
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();
        AbstractFactory factory2 = new ConcreteFactory2();
        // 使用具体工厂创建产品实例
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        // 调用产品实例的操作方法
        productA1.operationA();
        productB1.operationB();
        productA2.operationA();
        productB2.operationB();
    }
}

在这个示例中，AbstractProductA 和 AbstractProductB 是抽象产品接口，定义了产品的操作方法。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是具体的产品类，分别实现了 AbstractProductA 和 AbstractProductB 接口。

AbstractFactory 是抽象工厂接口，定义了创建一系列产品的方法。ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类，分别实现了 AbstractFactory 接口，并实现了 createProductA() 和 createProductB() 方法以创建具体的产品实例。

在客户端代码 Client 中，通过创建具体工厂实例，并调用其 createProductA() 和 createProductB() 方法来获取产品实例，然后调用产品实例的操作方法。

这样，客户端代码与具体产品类之间解耦，客户端只需要与抽象工厂打交道，可以根据需要轻松切换不同的具体工厂和产品类型。

分类:热门推荐日期:2024-05-09浏览:1评论:0

什么是工厂模式

工厂模式变体

工厂模式优缺点

优点

缺点

简单工厂模式的实现

代码实现

工厂模式方法的实现

代码实现

抽象工厂模式的实现

代码实现

工厂 产品

相关推荐