类工厂模式（Factory Pattern）

Covirtue

已于 2024-08-21 14:22:56 修改

阅读量328

点赞数 12

于 2024-08-21 13:49:26 首次发布

本文链接：https://blog.csdn.net/weixin_47695827/article/details/141391551

版权

python 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

Java

9 篇文章 0 订阅

订阅专栏

工厂模式（Factory Pattern）是一种常用的设计模式，用于创建对象时不会将客户端代码与类构造代码直接关联起来，而是通过一个共同的接口指向新创建的对象。这样可以在不修改客户端代码的情况下更改所创建的具体类实例。在Python中，实现工厂模式可以通过多种方式，包括简单工厂、工厂方法模式、抽象工厂模式等。

1. 简单工厂模式

简单工厂模式通常通过一个静态方法来创建对象，这个静态方法接收一个参数（通常是类名或其他标识符），然后根据这个参数返回相应的类实例。

class ProductA:
    def operation(self):
        return "Result of the Product A"

class ProductB:
    def operation(self):
        return "Result of the Product B"

class Factory:
    @staticmethod
    def get_product(product_type):
        if product_type == "A":
            return ProductA()
        elif product_type == "B":
            return ProductB()
        else:
            raise ValueError("Unsupported product type")

# 使用
productA = Factory.get_product("A")
print(productA.operation())

productB = Factory.get_product("B")
print(productB.operation())

2. 工厂方法模式

工厂方法模式将对象的创建延迟到子类中进行。工厂方法让类的实例化推迟到子类中进行。

class Product:
    def operation(self):
        pass

class ConcreteProductA(Product):
    def operation(self):
        return "Result of the ConcreteProduct A"

class ConcreteProductB(Product):
    def operation(self):
        return "Result of the ConcreteProduct B"

class Creator:
    def factory_method(self):
        raise NotImplementedError("Subclass must implement abstract method")

    def an_operation(self):
        product = self.factory_method()
        return product.operation()

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

# 使用
creatorA = ConcreteCreatorA()
print(creatorA.an_operation())

creatorB = ConcreteCreatorB()
print(creatorB.an_operation())

3. 抽象工厂模式

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

class AbstractProductA:
    def __init__(self):
        pass

    def use(self):
        raise NotImplementedError("Subclasses must implement abstract method")

class AbstractProductB:
    def __init__(self):
        pass

    def another(self):
        raise NotImplementedError("Subclasses must implement abstract method")

class ProductA1(AbstractProductA):
    def use(self):
        return "Product A1"

class ProductA2(AbstractProductA):
    def use(self):
        return "Product A2"

class ProductB1(AbstractProductB):
    def another(self):
        return "Product B1"

class ProductB2(AbstractProductB):
    def another(self):
        return "Product B2"

class AbstractFactory:
    def create_product_a(self):
        raise NotImplementedError("Subclasses must implement abstract method")

    def create_product_b(self):
        raise NotImplementedError("Subclasses must implement abstract method")

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ProductA1()

    def create_product_b(self):
        return ProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ProductA2()

    def create_product_b(self):
        return ProductB2()

# 使用
factory1 = ConcreteFactory1()
prod_a1 = factory1.create_product_a()
prod_b1 = factory1.create_product_b()

print(prod_a1.use())
print(prod_b1.another())

factory2 = ConcreteFactory2()
prod_a2 = factory2.create_product_a()
prod_b2 = factory2.create_product_b()

print(prod_a2.use())
print(prod_b2.another())

这些示例展示了Python中实现工厂模式的不同变体。每种变体都有其适用场景和优缺点。以下是对上述模式的简要总结及一些额外说明。

简单工厂模式

简单工厂模式是最简单直观的实现方式，它通过一个中心化的工厂类来创建对象。虽然这种方法实现简单，但它也存在一些缺点，如：

工厂类需要知道所有产品的类，这违反了开闭原则（软件实体应对扩展开放，对修改关闭）。每当添加新产品时，都需要修改工厂类。
客户端代码和工厂类之间可能存在紧密耦合。

工厂方法模式

工厂方法模式通过定义一个创建对象的接口（即工厂方法），让子类决定实例化哪一个类。这样，一个类的实例化延迟到其子类中进行。相比简单工厂模式，它的优点包括：

遵循开闭原则，可以通过添加新的工厂子类来扩展系统，而无需修改现有代码。
客户端代码只需与抽象工厂和抽象产品打交道，减少了与具体类的耦合。

抽象工厂模式

抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象的家族，而无需指定它们具体的类。这种模式非常适用于需要创建一系列相关对象（通常是一组产品族）的场景。它的优点包括：

可以在类的内部创建对象，这些对象通常相互关联或属于同一个产品族。
遵循开闭原则，增加新的产品族时，只需添加新的具体工厂类，而无需修改现有的类。

然而，抽象工厂模式也有其缺点：

难以支持新种类的产品。如果系统中需要增加新的产品类型（即新的抽象产品），则需要对所有的工厂类进行修改，这违背了开闭原则（尽管对于产品族而言，它仍然是开放的）。
增加了系统的复杂性和理解难度，因为涉及到了多个抽象层和多个产品族。

实际应用

在实际应用中，应根据具体需求选择合适的工厂模式。例如，如果系统中需要创建的对象类型较少，且不会频繁变化，可以使用简单工厂模式。如果系统中存在多个产品族，且需要创建的对象类型具有较大的变化性，那么抽象工厂模式可能是更好的选择。而工厂方法模式则适用于需要创建的对象类型较少，但创建逻辑较为复杂，且希望将对象的创建责任交给子类来决定的场景。

总的来说，工厂模式是一种非常有用的设计模式，它有助于解耦对象的创建和使用，提高系统的灵活性和可扩展性。在Python中，由于其动态类型系统的特性，实现这些模式通常比较直观和灵活。

Java抽象工厂模式例子

假设我们需要开发一个跨平台的图形用户界面（GUI）库，该库需要支持Windows和Mac OS两个操作系统。每个操作系统都有自己的一套控件，如按钮（Button）、文本框（TextBox）等。我们可以使用抽象工厂模式来设计这个GUI库。

1. 定义抽象产品

首先，我们定义一系列抽象产品接口，这些接口代表了不同操作系统上共有的控件。

// 抽象按钮接口
public interface Button {
    void paint();
}

// 抽象文本框接口
public interface TextBox {
    void setText(String text);
    String getText();
}

2. 实现具体产品

然后，我们为每种操作系统实现这些接口。

// Windows按钮实现
public class WindowsButton implements Button {
    @Override
    public void paint() {
        System.out.println("绘制Windows按钮");
    }
}

// Mac OS按钮实现
public class MacButton implements Button {
    @Override
    public void paint() {
        System.out.println("绘制Mac OS按钮");
    }
}

// Windows文本框实现
public class WindowsTextBox implements TextBox {
    private String text;

    @Override
    public void setText(String text) {
        this.text = text;
    }

    @Override
    public String getText() {
        return text;
    }
}

// Mac OS文本框实现
public class MacTextBox implements TextBox {
    private String text;

    @Override
    public void setText(String text) {
        this.text = text;
    }

    @Override
    public String getText() {
        return text;
    }
}

3. 定义抽象工厂

接下来，我们定义一个抽象工厂接口，该接口声明了创建不同操作系统控件的方法。

public interface GUIFactory {
    Button createButton();
    TextBox createTextBox();
}

4. 实现具体工厂

然后，我们为每种操作系统实现一个具体工厂类。

// Windows GUI工厂
public class WindowsGUIFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public TextBox createTextBox() {
        return new WindowsTextBox();
    }
}

// Mac OS GUI工厂
public class MacGUIFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public TextBox createTextBox() {
        return new MacTextBox();
    }
}

5. 客户端代码

最后，客户端代码可以通过使用抽象工厂接口来创建不同操作系统的控件，而无需关心具体实现的细节。

public class Application {
    public static void main(String[] args) {
        // 使用Windows GUI工厂
        GUIFactory factory = new WindowsGUIFactory();
        Button button = factory.createButton();
        button.paint(); // 输出：绘制Windows按钮

        TextBox textBox = factory.createTextBox();
        textBox.setText("Hello, Windows!");
        System.out.println(textBox.getText()); // 输出：Hello, Windows!

        // 切换到Mac OS GUI工厂（假设）
        // factory = new MacGUIFactory();
        // ...
    }
}

抽象工厂模式的优势

封装性：客户端代码只需要知道抽象工厂和抽象产品的接口，不需要知道具体实现类，降低了客户端与具体实现类之间的耦合。
扩展性：如果需要支持新的操作系统，只需要添加新的具体产品和具体工厂类，而不需要修改现有的客户端代码，符合开闭原则。
系列产品的创建：抽象工厂模式能够创建一系列相关的产品对象，这些产品对象构成一个产品族，便于管理和使用。

通过这个例子，我们可以看到抽象工厂模式在处理需要创建一系列相关或相互依赖的对象时非常有用。

Covirtue

关注

12
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
类工厂模式（Factory Pattern）

工厂模式（Factory Pattern）是一种常用的设计模式，用于创建对象时不会将客户端代码与类构造代码直接关联起来，而是通过一个共同的接口指向新创建的对象。这样可以在不修改客户端代码的情况下更改所创建的具体类实例。在Python中，实现工厂模式可以通过多种方式，包括简单工厂、工厂方法模式、抽象工厂模式等。
复制链接

扫一扫