• 设计模式:抽象工厂


    定义

    抽象工厂模式是一种创建型设计模式,它提供了一个接口,用于创建一系列相关或相互依赖的对象,而无需指定它们具体的类。这种模式特别适用于处理产品族,但在不可能修改的情况下扩展产品族是困难的。

    应用场景

    抽象工厂模式通常在以下情况下使用:

    • 当存在多个产品系列,且产品之间存在一定的关系时。
    • 系统需要配置多个产品族中的一个产品族。
    • 系统需要提供多个产品族的对象,而你希望在设计时不需要指定具体产品的类。

    示例

    以下是一个简单的Java示例,演示了抽象工厂模式的应用。在这个例子中,我们有两个产品族:Windows和MacOS,并且每个产品族都有两种产品:Button和Checkbox。

    首先,我们定义产品接口和具体产品:

    // Button接口
    public interface Button {
        void paint();
    }
    
    // Windows风格的Button
    public class WinButton implements Button {
        @Override
        public void paint() {
            System.out.println("Render a button in a Windows style.");
        }
    }
    
    // MacOS风格的Button
    public class MacButton implements Button {
        @Override
        public void paint() {
            System.out.println("Render a button in a MacOS style.");
        }
    }
    
    // Checkbox接口
    public interface Checkbox {
        void paint();
    }
    
    // Windows风格的Checkbox
    public class WinCheckbox implements Checkbox {
        @Override
        public void paint() {
            System.out.println("Render a checkbox in a Windows style.");
        }
    }
    
    // MacOS风格的Checkbox
    public class MacCheckbox implements Checkbox {
        @Override
        public void paint() {
            System.out.println("Render a checkbox in a MacOS style.");
        }
    }
    
    • 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
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    接下来,我们定义抽象工厂和具体工厂:

    // 抽象工厂
    public interface GUIFactory {
        Button createButton();
        Checkbox createCheckbox();
    }
    
    // Windows工厂
    public class WinFactory implements GUIFactory {
        @Override
        public Button createButton() {
            return new WinButton();
        }
    
        @Override
        public Checkbox createCheckbox() {
            return new WinCheckbox();
        }
    }
    
    // MacOS工厂
    public class MacFactory implements GUIFactory {
        @Override
        public Button createButton() {
            return new MacButton();
        }
    
        @Override
        public Checkbox createCheckbox() {
            return new MacCheckbox();
        }
    }
    
    • 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

    最后,客户端代码可以这样使用抽象工厂来创建不同风格的UI元素:

    public class Application {
        private Button button;
        private Checkbox checkbox;
    
        public Application(GUIFactory factory) {
            button = factory.createButton();
            checkbox = factory.createCheckbox();
        }
    
        public void paint() {
            button.paint();
            checkbox.paint();
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            GUIFactory factory;
            String osName = System.getProperty("os.name").toLowerCase();
            if (osName.contains("windows")) {
                factory = new WinFactory();
            } else {
                factory = new MacFactory();
            }
            Application app = new Application(factory);
            app.paint();
        }
    }
    
    • 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

    原则间的权衡与冲突

    抽象工厂模式遵守开闭原则,因为新增产品族时,无需修改已有代码,只需添加新的工厂和产品实现。同时,它也支持依赖倒置原则,因为客户端代码依赖于抽象接口,而不是具体实现。

    然而,如果需要向现有产品族中添加新产品,可能需要修改工厂接口和所有实现类,这违反了开闭原则。

    设计模式的局限性

    抽象工厂模式的局限性主要体现在难以支持新产品的添加。每当添加一个新产品时,都需要更新抽象工厂及其所有子类,这会导致代码变得复杂,增加维护成本。

    总结与建议

    抽象工厂模式是一个强大的设计模式,适合用于产品族的创建。它提高了系统的可扩展性和可维护性,同时也隐藏了具体产品的实现细节。不过,设计者应该在产品族相对稳定,不太可能频繁变更时使用抽象工厂模式。对于经常变化的产品结构,考虑使用更灵活的模式可能更为合适,如工厂方法模式或者简单工厂模式。

  • 相关阅读:
    vue 复杂的流程图实现--antv/g6
    RabbitMQ(四):RabbitMQ高级特性
    Go开发基础环境搭建
    OpenJudge NOI 2.1 1661:Bomb Game
    Vue中的懒加载是什么,如何实现懒加载?
    【共读】企业信息安全建设与运维指南(二)
    TSINGSEE视频AI智能分析技术:水泥厂安全生产智能监管解决方案
    【论文笔记】LoRA LOW-RANK ADAPTATION OF LARGE LANGUAGE MODELS
    关于torch.cat()与torch.stack()
    进制转换0
  • 原文地址:https://blog.csdn.net/liu_rockefeller/article/details/137368985