相关疑难解决方法(0)

为什么喜欢构图而不是继承呢？每种方法都有哪些权衡取舍？什么时候应该选择继承而不是作文？

我想知道.Net框架中大量密封类背后的动机是什么.密封课程有什么好处？我无法理解如何不允许继承有用,而且很可能不是唯一一个与这些类斗争的人.

那么,为什么框架以这种方式设计并且不会是开启一切的不间断的变化？必须有另一个原因,但只是邪恶？

.Net框架中的大量类被标记为"已密封",从而阻止您使用自己的类继承这些类.当然,这违背了面向对象的本质,您可以在其中扩展和重新定义现有对象的行为.

是否有充分的理由存在'sealed'关键字？

例如,Silverlight中的NotifyCollectionChangedEventArgs是密封的.我想创建自己的ObservableCollection版本,它支持AddRange和RemoveRange,但NCCEA的Silverlight版本不提供支持NewItems和OldItems属性的多个项目的构造函数,这些项目已经被定义为IList.通常,我只是用我自己的变体扩展了类,它覆盖了NewItems和OldItems属性,但是在这种情况下我不能,而且我看不出为什么会出现这种情况.

假设我有这样一个类:

public sealed class Foo
{
    public void Bar
    {
       // Do Bar Stuff
    }
}

我想扩展它以添加超出扩展方法可以做的事情....我唯一的选择是组合:

public class SuperFoo
{
    private Foo _internalFoo;

    public SuperFoo()
    {
        _internalFoo = new Foo();        
    }

    public void Bar()
    {
        _internalFoo.Bar();
    }

    public void Baz()
    {
        // Do Baz Stuff
    }
}

虽然这有效,但它还有很多工作......但是我仍遇到一个问题:

  public void AcceptsAFoo(Foo a)

我可以在这里传递一个Foo,但不是超级Foo,因为C#不知道SuperFoo确实符合Liskov替换意义......这意味着我的扩展类通过组合使用非常有限.

因此,解决它的唯一方法是希望原始的API设计者留下一个界面:

public interface IFoo
{
     public Bar();
}

public sealed class Foo : IFoo
{
     // etc
}

现在,我可以在SuperFoo上实现IFoo(因为SuperFoo已经实现了Foo,只需要更改签名).

public class SuperFoo : IFoo

在完美的世界中,消耗Foo的方法将消耗IFoo:

public …

密封课程不是我过去常常注意到的事情,但我发现自己想知道什么是最佳实践.如果你知道一个课程不会或不应该从中得出你是否会密封它作为一个预防措施,只需留下密封的关键字,知道有人试图从中获取的机会很小.

我想我要问的是,你是否应该密封所有不用于继承的课程,只是作为一种良好的做法？

python是否有类似于密封类的东西？我相信它在java中也被称为final类.

换句话说,在python中,我们可以标记一个类,以便它永远不会被继承或扩展吗？python曾经考虑过有这样的功能吗？为什么？

免责声明

^{实际上试图理解为什么密封课程甚至存在.答案在这里(和很多,很多,很多,很多,很多,真的很多其他地方)没有满足我的人,所以我试图从不同的角度看.请避免对这个问题的理论答案,并专注于标题!或者,如果你坚持,至少请给出csharp中密封类的一个非常好的实用例子,指出如果它是未密封的话会破坏大的时间.}

^{我不是两种语言的专家,但我确实知道两种语言.就在昨天,在使用csharp进行编码时,我了解了密封类的存在.现在我想知道python是否有相同的东西.我相信它的存在是有充分理由的,但我真的没有得到它.}

在C#中,类A包含一个公共方法Foo(),它执行一些处理并返回一个值. protected方法Bar(),也在类中A执行相同的逻辑Foo(),然后进行一些额外的处理,然后返回一个值.

为了避免重复代码,Bar()调用Foo()并使用return作为中间值.

class A
{
  public virtual String Foo()
  {
     String computedValue;
     // Compute the value.
     return computedValue;
  }

  protected String Bar()
  {
     String computedValue;
     String intermediateValue = Foo();
     /// More processing to create computedValue from intermediateValue.
     return computedValue;
  }
}

类B继承A和覆盖Foo().覆盖调用的基类实现Bar().

class B : A
{
   public override String Foo()
   {
     base.Bar();
   }
}

这(当然)进入无限循环,直到计算机内存不足然后产生堆栈溢出异常. …