标签: open-closed-principle

开放/封闭原则似乎是关于防止对象或方法中的回归.鉴于您的代码被测试覆盖,因为您正在练习BDD,这似乎是一个多余的要求.此外,它似乎通过要求API级别而不是语言级别的可扩展性来引入额外的复杂性.

我一直在研究开放的闭合原理,听起来不错,所以我想练习它的教导.我看着将我新发现的知识应用到现有项目中,并且立刻变得有点卡住了.

如果出现了新的UserType(这很可能),则需要更改,尚未关闭修改.怎么能绕过这个呢？

从我所看到的,听起来我应该在这里实施工厂而不是应用OCP？

打破封闭原则的工厂

 private void BuildUserTree(User user)
    {
        switch (user.UserType)
        {
            case UserType.FreeLoader:
                BuildFreeLoaderTree();
                break;
            case UserType.Premium:
                BuildPremiumTree();
                break;
            case UserType.Unlimited:
                BuildUnlimitedTree();
                break;
            default:
                throw new Exception("No UserType set");

        }
    }

谢谢,Kohan

我一直在阅读单元测试,TDD和SOLID原理,我需要一些澄清.我的理解是,如果遵循开放/封闭原则,单元测试可能在很大程度上变得不必要,因为代码无法修改 - 因此,如果代码被正确隔离和解耦,则无需重新测试.如果一旦代码通过相关的单元测试就不会改变单元测试所增加的前期成本的长期好处.代码将永远通过,因为它永远不会改变,对吧？需要测试继承的类,但是一旦它们通过相关的测试,它们也将被关闭以进行修改,并且不需要重新测试.关于OCP的维基百科文章强化了第一段中的这一思路(我意识到这并不能成为法律).
我发现在OCP和谐和TDD生活最好的解释是在这里,但它似乎是嫩说,OCP恭维TDD中,开发商从修改源代码的沮丧,因为修改,以测试新的时,现有的测试方法会变得复杂功能.
这就是它的全部吗？请注意,我不是在寻找一个论点,我是新手,我正在寻找那些对这个主题有更多经验的人的澄清.

我读过有关SOLID的文章但我没有看到OCP和DIP之间有任何区别.看看这个OCP的例子:

http://www.oodesign.com/open-close-principle.html

持有OCP的代码也满足DIP.任何人都可以给我一个持有OCP但不是DIP的代码示例吗？

在我用来准备新的Oracle认证专家 - Java SE7程序员考试的书中,在处理方法覆盖的部分中,我遇到了以下内容:

重写方法应具有与基本版本相同的参数列表类型(或兼容类型).

"兼容类型"是什么意思？我的意思是,一旦参数列表类型不同,你就会超载,而不是覆盖.

我只能想到覆盖一个采用varargs参数的方法,一个采用相同类型的数组.编译器发出警告,但仍然编译.

兼容类型是什么意思？这是书中的错误吗？

在学习Java认证测试时,我了解到静态初始化块在加载类时按照源代码中的外观顺序运行一次,每次创建实例时运行实例初始化块,并且构造函数中的代码每次运行之后创建一个实例.为了测试我创建了一个带有一些静态和实例初始化块的类以及一个带有打印内容的构造函数.一切都按预期工作 - 除了我认为"加载"意味着只是在运行时,但我想它发生在第一个实例创建时,因为我根本没有得到任何输出,除非我创建至少1个类的实例.然后我用enum尝试了同样的命令并且命令全部关闭.首先,初始化块对枚举在代码中首次引用时枚举所具有的每个值运行一次,其次是在我假设为实例初始化块之后标记为静态的init块!这与我的预期相反.这是我的问题的细分.

1. 为什么标记为static的init块在枚举中最后运行？
2. 枚举可以有实例init块吗？
3. 为什么我认为的块是实例初始化块只在加载枚举时运行一次,而不是每次引用新的枚举值时？
4. 类"静态"初始化块在"加载"类时运行.加载是什么意思？当一个对象在类中实例化时,它只出现一次吗？

谢谢!这对我来说非常困惑.

public class EnumInit {
public static void main(String[] args) {
    System.out.println(Color.RED.toString() + " Main");
    MyInit myInit = new MyInit();
    System.out.println(Color.BLUE.toString() + " Main");
    MyInit mySecondInit = new MyInit();

}
}

enum Color {    
RED, BLUE, GREEN;
String instanceVar = "Enum Instance Variable Text";
static { System.out.println("Enum Static init block 1"); }
{ System.out.println("Enum Instance init block 1"); }
static { System.out.println("Enum Static static init block 2"); }
Color() { 
    System.out.println(instanceVar);
    System.out.println("Enum String …

据我所知,Factory Method比Simple Factory的主要优点之一是它不违反Open-Closed SOLID原则.也就是说,前者不需要在添加新类型时修改switch语句.

有一件我希望得到澄清.如果我要使用一个简单的工厂,我会有一个像这样的工厂(简化):

public class ObjectFactory {
    public static IObject CreateObject(ObjectTypeEnum objectType) {
        switch (objectType) {
            case TypeA:
                return ObjectA;
                break;
            case TypeB:
                return ObjectB;
                break;
            case TypeC:
                return ObjectC;
                break;
        }
    }
}

并且客户端会这样称呼它:

IObject myObject = ObjectFactory.CreateObject(objectType);

文献中的缺点是在添加新对象类型时需要修改CreateObject.

但是使用Factory方法,我们不会将此修改从工厂移动到客户端,就像这样(客户端代码):

IObject myObject;
switch (objectType) {
            case TypeA:
                myObject = ObjectAFactory.CreateObject();
                break;
            case TypeB:
                myObject = ObjectBFactory.CreateObject();
                break;
            case TypeC:
                myObject = ObjectCFactory.CreateObject();
                break;
}

在这种情况下,每次添加新类型时都需要修改客户端,而在之前的情况下需要修改工厂.那么一个优于另一个的优势是什么？请不要将此标记为重复,我已经查看了很多关于工厂的SO帖子,没有一个解决这个特定的区别.

是否有更好的解决方案不会违反客户或工厂方面的开放/封闭原则？

在java中,如果我们使用枚举并且最终我们想要从该枚举中添加/删除属性,因此它的用法,我们在实体原则中违反了开放/封闭原则.

如果是这样,枚举的更好用法是什么？

我正在研究子类与接口和组合的关系。当涉及到代码重复时，我最终对一些事情感到困惑。众所周知，在很多情况下，子类化和继承都不是可行的方法，但是在减少代码重复方面有效。

接口功能强大，如果正确完成操作，将提供很好的可读性，但是我无法解决这样的事实，即它实际上并不能帮助我减少代码重复。我们可能会遇到子类无效的情况。但是，扩展程序的可能性很大，并且每当这样做时，尝试维护Open封闭的主体，我们最终都会以荒谬的数量进行接口的实现/实现。粘贴代码，通过子类化（在代码重复方面）可以避免这种情况。

我们如何通过接口和组合构建出色的策略，从而避免一遍又一遍地编写相同的方法？这样，我们就可以保持模块性，并同时遵守开放式封闭原则。我们是否有任何准则来指导我们如何快速而有效地决定实际上是否值得进行代码重复？

干杯

</ wallOfText>

在我看来，Bob Martin 需要一些以 O 开头的东西来制作 SOLID，并在一些旧书中找到了这个（可能没用的）开/闭原则。

开放/封闭如何与单一职责共存，即一个类应该有一个改变的原因？

如果我想在一个长期存在的系统中遵循 Open/Closed，我是否应该有几十个/几百个类的链，每个类都扩展前一个？