标签: open-closed-principle

适用于以下代码的规则如下:

    try {
        assert (false) : "jane";
    } catch (Exception e2) {
        System.out.print("ae2 ");
    } finally {
        throw new IllegalArgumentException();
    }

已启用资产.

为什么报告IllegalArgumentException而不是AssertionError？在这种情况下是否有适用的规则？

编辑: 对不起!在这个例子中应该有断言(假)

在封装中，想法是通过将变量声明为私有来隐藏类对其变量所做的事情，从而实现了 OCP。但是，为什么要添加 getter 和 setter，然后打开变量进行修改呢？

为什么要经历将变量设置为私有的整个麻烦，然后在它们上添加公共设置器？这似乎不是很严格，这是封装的思想之一。

我是设计模式的初学者.

我正在尝试使用抽象工厂模式,同时保持开放封闭原则.

Plz看下面的代码:

public interface IAbstractFormFactory
    {
        void ShowOSName();        
    }

public class VistaForm : IAbstractFormFactory
    {
        public void ShowOSName()
        {
            Console.WriteLine("Vista");
        }
    }

public class WinXpForm : IAbstractFormFactory
    {
        public void ShowOSName()
        {
            Console.WriteLine("Win XP");
        }
    }

public static class Application
    {
        public static void Run(IAbstractFormFactory factory)
        {
            factory.ShowOSName();
        }
    }

public class Program 
    {
        public static void Main() 
        {
            IAbstractFormFactory form;

            int sys = 0;

            if (sys == 0) 
            {
                form = new WinXpForm();
            } 
            else 
            {
                form = …

我深入研究了一个新项目,我用一堆模板和专业知识来解决这个问题.现在,在没有编程的一天之后,我发现自己在询问是否真的值得额外的代码行.

问题是:专业化有哪些优势？

这是:

template <int i> class A {};
template <> class A <1> { void foo() {/* something */}  };
template <> class A <2> { void foo() {/* something else*/}  };
template <> class A <3> { void foo() {/* even different*/}  };

以任何方式更好(更快的执行)

template <int i> class A { 
   void foo() {
      if (i==1) {/* something */}
      else if (i==2) {/* something else*/}
      else if (i==3) {/* even different*/}
   }
};

？

编辑:

该代码是其他人使用的库的一部分.我正在使用gcc 4.6.3但最终代码将与不同的编译器一起使用.

编辑:

这两段代码使用gcc …

我知道开闭原则意味着对扩展开放，对修改封闭。考虑如下示例

public class Vehicle{
    public void service(){
        //vehicle servicing code
    }
}

public class Bike extends Vehicle{

    public void service(){
        // bike specific servicing 
    }
}

现在我明白Bike该类Vehicle使用开放封闭原则扩展并添加了新功能。

考虑我创建Vehicle类的jar 文件，然后类从 jarBike扩展Vehicle类。在这种情况下，我们不能修改Vehicle类并Bike扩展它。这是开闭原则的一个很好的例子吗？我想知道 OCP 与继承有何不同

开放/封闭原则规定类对于修改是封闭的，但对于扩展是开放的。假设我们想要设计一个支付系统，其中支付可以由多个处理器处理，如下所示：

    class Payment {
        void pay(paymentMethod) {
            switch (paymentMethod) {
               case 'PayPal':
               break;
               case 'Swift':
               break;
               default:
               break;
            }
        }
    }

    class PayPal {
        void pay() {
               //implement payment1
        }
    }

    class Swift {
        void pay() {
               //implement payment2
        }
    }

假设我们是第一次实施这两种支付系统。现在如果由于某种原因任何支付系统的实现过程发生了变化，我们是不是应该修改相关的类？例如，如果我们实现PayPal，2-3年后PayPal的工作流程发生了变化，修改PayPal类是否会破坏开放/封闭原则？如果解决的话有什么解决办法？

我正在尝试使用Head First Design Pattern学习面向对象的设计模式.这是本书中工厂模式的一个例子,我想在不违反开放封闭原则的情况下添加新的披萨项目.在书中给出的示例代码中,如果我添加新的披萨项类,我需要修改PizzaStore和PizzaOrder类.但我只是想添加新的Pizza Item而不修改其他类.

public class ChicagoPizzaStore extends PizzaStore {

Pizza createPizza(String item) {
        if (item.equals("cheese")) {
                return new ChicagoStyleCheesePizza();
        } else if (item.equals("veggie")) {
                return new ChicagoStyleVeggiePizza();
        } else if (item.equals("clam")) {
                return new ChicagoStyleClamPizza();
        } 
            else return null;
}

}

这个pizzaStore类是创建和订购披萨.

public abstract class PizzaStore {

    abstract Pizza createPizza(String item);

public Pizza orderPizza(String type) {
    Pizza pizza = createPizza(type);
    System.out.println("--- Making a " + pizza.getName() + " ---");
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();
    return pizza;
}

}

这是抽象的Pizza课程: …

我正在尝试创建一种优雅且可扩展的查询字典的方法,该字典将枚举映射到一组字符串.

所以我有这个SearchFragments包含字典的类.然后我想要一个方法,其中这个类的消费者可以简单地问"HasAny",这是我正在努力的位,只需传递一些查询,如表达式并获得布尔答案.

public class SearchFragments
{
    private readonly IDictionary<SearchFragmentEnum, IEnumerable<string>> _fragments;

    public SearchFragments()
    {
        _fragments = new Dictionary<SearchFragmentEnum, IEnumerable<string>>();
    }

    public bool HasAny(IEnumerable<SearchFragmentEnum> of)
    {
        int has = 0;
        _fragments.ForEach(x => of.ForEach(y => has += x.Key == y ? 1 : 0));
        return has >= 1;
    }
}

目前的问题是,这个类的消费者现在必须构建一个IEnumerable<SearchFragmentEnum>可能非常混乱的消费者.

我正在寻找的是消费代码将能够写出以下内容:

searchFragments.HasAny(SearchFragmentEnum.Name, SearchFragmentEnum.PhoneNumber)

但是这个参数列表的大小可能会有所不同(没有我必须在SearchFragments类中为每个可能的组合编写方法重载(这样如果SearchFragmentEnum在将来的日期添加新值,我将不必更新类.

我理解这个原则声明一个模块是开放的扩展但是关闭以进行修改,当我们想要在某个类中升级/修改一个方法时,这是很明显的 - 我们创建另一个继承基类然后覆盖基本方法的类这里是为了保持两种功能.

但是当我们想要为基类添加另一种不同的方法时呢？这被认为是基类的修改或扩展 - 可以将方法添加到基类,还是我们还应该创建继承基类然后将新方法放在那里的新类？

此外,向基类添加属性和字段的问题也一样.

有一个库提供了一个通用函数和一些要使用的实现：

#include <iostream>

namespace lib {
  struct Impl1 {};
  struct Impl2 {};

  void process(Impl1) { std::cout << 1; }
  void process(Impl2) { std::cout << 2; }

  template<typename T> void generalize(T t) { process(t); }
}

我想通过外部代码扩展它。以下是 C++ 允许这样做的方式：

#include <lib.h> // the previous snippet

namespace client {
  struct Impl3 {};

  void process(Impl3) { std::cout << 3; }
}

int main() { // test
  lib::generalize(client::Impl3{}); // it couts 3
}

注意：lib的代码对 的一无所知，client并且不执行动态调度。如何在我的 Rust 代码中实现相同的目标？（如果我不能，是否有类似计划？）

您能否检查以下代码是否正确？事实是,我在推进代码中找到了类似的东西,我怀疑它是否与开放/封闭原则相匹配.

public abstract class CustomClass {

    private ClassThatSetEnvironmentProperty sysProp = new ClassThatSetEnvironmentProperty("SYS_PROPETY", "SYS_PROPERTY_VALUE");

    // some code here

    void setSysProp(ClassThatSetEnvironmentProperty sysProp) {
        this.sysProp = sysProp;
    }
}

我的理解是setter仅为单元测试可能性定义(模拟ClassThatSetEnvironmentProperty).但在这种情况下,setter允许具体的继承者改变定义的状态.从我的角度来看,它违反了封装.更多我认为它也违反了开放/封闭的原则.坦率地说,我的一些同事采取了相反的观点.我真的没有多少经验,所以我很难认识到它.请在这里分享您的意见.谢谢.

关于OCP的维基百科文章说(强调我的):

...开放/封闭原则规定"软件实体(类,模块,功能等)应该是可以扩展的,但是关闭以进行修改"......这在生产环境中特别有价值,在这种环境中,源代码发生了变化可能需要代码审查,单元测试和其他此类程序才能使其符合产品使用要求:遵守原则的代码在扩展时不会发生变化,因此不需要这样的努力.

所以,我在正确的阅读它,如果有OCP将是有价值的无自动化单元测试,但不一定,如果有是？或维基百科的文章错了吗？