[设计模式] 抽象工厂模式简易案例

定义：提供一个接口来创建一系列相关或依赖对象，而无需指定其具体类。
痛点：当需要创建一组相关对象，例如操作系统的不同界面组件（按钮、文本框等）时，抽象工厂模式非常有用。

以下是一个简单的抽象工厂模式的 Java 示例，假设你要创建不同类型的按钮和窗口组件。

首先，定义抽象按钮类 Button 和抽象窗口类 Window：

// 抽象按钮类
public abstract class Button {
    public abstract void paint();
}

// 抽象窗口类
public abstract class Window {
    public abstract void render();
}
1
2
3
4
5
6
7
8
9

然后，创建具体的按钮类 LinuxButton 和 WindowsButton，以及具体的窗口类 LinuxWindow 和 WindowsWindow：

// 具体的 Linux 按钮类
public class LinuxButton extends Button {
    @Override
    public void paint() {
        System.out.println("Linux 按钮");
    }
}

// 具体的 Windows 按钮类
public class WindowsButton extends Button {
    @Override
    public void paint() {
        System.out.println("Windows 按钮");
    }
}

// 具体的 Linux 窗口类
public class LinuxWindow extends Window {
    @Override
    public void render() {
        System.out.println("Linux 窗口");
    }
}

// 具体的 Windows 窗口类
public class WindowsWindow extends Window {
    @Override
    public void render() {
        System.out.println("Windows 窗口");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

接下来，定义抽象工厂类 UIFactory，它包含创建按钮和窗口的抽象方法：

public abstract class UIFactory {
    public abstract Button createButton();
    public abstract Window createWindow();
}
1
2
3
4

创建具体的工厂类 LinuxUIFactory 和 WindowsUIFactory，分别用于创建 Linux 风格和 Windows 风格的按钮和窗口组件：

// 具体的 Linux UI 工厂
public class LinuxUIFactory extends UIFactory {
    @Override
    public Button createButton() {
        return new LinuxButton();
    }

    @Override
    public Window createWindow() {
        return new LinuxWindow();
    }
}

// 具体的 Windows UI 工厂
public class WindowsUIFactory extends UIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Window createWindow() {
        return new WindowsWindow();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

最后，你可以使用抽象工厂模式来创建不同风格的按钮和窗口组件：

public class Main {
    public static void main(String[] args) {
        // 创建 Linux 风格的 UI 组件
        UIFactory linuxFactory = new LinuxUIFactory();
        Button linuxButton = linuxFactory.createButton();
        Window linuxWindow = linuxFactory.createWindow();

        linuxButton.paint(); // 输出：Linux 按钮
        linuxWindow.render(); // 输出：Linux 窗口

        // 创建 Windows 风格的 UI 组件
        UIFactory windowsFactory = new WindowsUIFactory();
        Button windowsButton = windowsFactory.createButton();
        Window windowsWindow = windowsFactory.createWindow();

        windowsButton.paint(); // 输出：Windows 按钮
        windowsWindow.render(); // 输出：Windows 窗口
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这个示例演示了抽象工厂模式的用法，根据不同的工厂对象创建了不同风格的按钮和窗口组件，而不需要关心它们的具体实现类。这种方式有助于创建一组相关或依赖的对象，同时保持代码的灵活性和可维护性。