标签: multiple-inheritance

我只是潜入一些更高级的python主题(好吧,至少先进了我).我现在正在阅读有关多继承以及如何使用super()的内容.我或多或少地理解了使用超级函数的方式,但是(1)这样做会有什么问题？:

class First(object):
    def __init__(self):
        print "first"

class Second(object):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        First.__init__(self)
        Second.__init__(self)
        print "that's it"

关于super(),Andrew Kuchlings关于Python Warts的论文说:

当Derived类从多个基类继承并且其中一些或全部具有init 方法时,super()的使用也将是正确的

所以我重写了上面的例子如下:

class First(object):
    def __init__(self):
        print "first"

class Second(object):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__(self)
        print "that's it"

但是,这只运行它可以找到的第一个initFirst.(2)可以super()用来运行init的First和Second,如果是的话,如何运行？运行super(Third, self).__init__(self)两次只运行First.init()两次..

增加一些混乱.如果继承类的init()函数采用不同的参数,该怎么办？例如,如果我有这样的东西怎么办:

class First(object): …

这是代码:

struct Biology
{    
    Biology() { cout << "Biology CTOR" << endl; }
};

struct Human : Biology
{    
    Human() { cout << "Human CTOR" << endl; }
};

struct Animal : virtual Biology
{
    Animal() { cout << "Animal CTOR" << endl; }
};

struct Centaur : Human, Animal
{
    Centaur() { cout << "Centaur CTOR" << endl; }
};

int main()
{   
   Centaur c;

   return 0;
}

此代码打印:

Biology CTOR
Biology CTOR
Human CTOR
Animal CTOR
Centaur CTOR …

我有一个抽象的基类作为接口.

我有两个派生类的"集合",它们实现了抽象类的一半.(一个"set"定义与初始化相关的抽象虚拟方法,另一个"set"定义与实际"工作"相关的那些.)

然后,我得到了使用多继承来构造完全定义的类的派生类(并且本身不添加任何东西).

所以:(坏伪代码)

class AbsBase {
  virtual void init() = 0;
  virtual void work() = 0;
}

class AbsInit : public AbsBase {
  void init() { do_this(); }
  // work() still abs
}

class AbsWork : public AbsBase {
  void work() { do_this(); }
  // init() still abs
}

class NotAbsTotal : public AbsInit, public AbsWork {
  // Nothing, both should be defined
}

首先,我可以这样做吗？我可以继承两个派生自同一Base的类吗？(希望如此).

虽然这是"真正的问题"(我在上面撒谎以简化示例).

我真正做的是将非抽象访问器方法添加到基类:

class AbsBase {
public:
  void init() { init_impl(); }
  void work() { …

编辑3:请务必在回答之前清楚地了解我的要求(有EDIT2和很多评论).有(或有)许多答案清楚地表明对问题的误解(我知道这也是我的错,对不起)

嗨,我class B: public virtual A {...}在C++中查看了关于虚拟继承()的问题,但没有找到我的问题的答案.

我知道虚拟继承存在一些问题,但我想知道的是虚拟继承被认为是一种好的设计.

我看到人们提到类似IUnknownor的接口ISerializable,而且该iostream设计也基于虚拟继承.那些是很好地利用虚拟继承的好例子,是因为没有更好的选择,或者因为在这种情况下虚拟继承是正确的设计？谢谢.

编辑:澄清,我问的是现实生活中的例子,请不要抽象.我知道虚拟继承是什么以及哪种继承模式需要它,我想知道的是何时它是做事的好方法而不仅仅是复杂继承的结果.

EDIT2:换句话说,我想知道钻石层次结构(这是虚拟继承的原因)何时是一个好的设计

我使用 Java 8的功能还是滥用它？

请参阅下面的代码和说明,了解为什么选择它是这样的.

public interface Drawable {
    public void compileProgram();

    public Program getProgram();

    default public boolean isTessellated() {
        return false;
    }

    default public boolean isInstanced() {
        return false;
    }

    default public int getInstancesCount() {
        return 0;
    }

    public int getDataSize();

    public FloatBuffer putData(final FloatBuffer dataBuffer);

    public int getDataMode();

    public boolean isShadowReceiver();

    public boolean isShadowCaster();    //TODO use for AABB calculations

    default public void drawDepthPass(final int offset, final Program depthNormalProgram, final Program depthTessellationProgram) {
        Program depthProgram = (isTessellated()) …

对于Java人来说,这个问题可能听起来很奇怪,但如果你试图解释这个问题,那就太好了.

在这些日子里,我正在清除Java的一些非常基本的概念.所以我来谈谈Java的继承和接口主题.

在阅读本文时,我发现Java不支持多重继承,并且也明白,我无法理解为什么到处都会出现Diamond图形问题(至少有4个类来创建钻石)来解释这种行为,我们不能仅使用3个类来理解此问题.

说,我有A类和B类,这两个类是不同的(它们不是普通类的子类)但是它们有一个共同的方法,它们看起来像:

class A {
    void add(int a, int b) {

    }
}

class B {
    void add(int a, int b) {

    }
}

好的,现在说Java是否支持多重继承,如果有一个类是A和B的子类,如下所示: -

class C extends A,B{ //If this was possible
    @Override
    void add(int a, int b) { 
        // TODO Auto-generated method stub
        super.add(a, b); //Which version of this, from A or B ?
    }
 }

然后编译器将无法找到从A或B调用哪个方法,这就是Java不支持多重继承的原因.那么这个概念有什么问题吗？

当我读到这个主题时,我能够理解钻石问题,但是我无法理解为什么人们没有给出三个类的例子(如果这是有效的一个,因为我们只使用了3个类来演示问题所以它很容易通过将其与钻石问题进行比较来理解.)

让我知道这个例子是否不适合解释问题,或者这也可以参考理解问题.

编辑: 我在这里得到一个近距离投票,说明问题不明确.这是一个主要问题: -

我能理解为什么"Java不支持多重继承"只有3个类,如上所述,或者我必须要有4个类(Diamond结构)来理解这个问题.

我从这个条目中看到虚拟继承将sizeof(指针)添加到对象的内存占用.除此之外,默认情况下使用虚拟继承是否有任何缺点,只有在需要时才使用常规继承？这似乎会带来更具前瞻性的课堂设计,但也许我错过了一些陷阱.

如果我有三个这样的课程:

class BaseClass(object):
    def __init__(self, base_arg, base_arg2=None):
        ...

class MixinClass(object):
    def __init__(self, mixin_arg):
        ...

class ChildClass(BaseClass, MixinClass):
    def __init__(self, base_arg, mixin_arg, base_arg2=None):
        ???

什么是初始化的正确方法MixinClass和BaseClass？

它看起来不像我可以使用,super因为它MixinClass和BaseClass两者都接受不同的参数......而且,两次调用,MixinClass.__init__(...)并且BaseClass.__init__(...),可能会导致钻石继承问题super被设计为阻止.

更新:在我对这个问题的思考中并不孤单,这似乎确实是一个错误.看到这里.它修复的那一天将是一个美好的一天!:)

这开始了I love PHP traits! I'm going to use them everywhere! ^_^,现在它变成了一个Thought Exercise / Learning Experience >_<.

请考虑以下示例:

trait TheErrorOfYourWays{

   public function booboo(){
       echo 'You had a booboo :(';
   }
}

trait SpectacularStuff1 {
    use TheErrorOfYourWays; 
}

trait SpectacularStuff2 {
    use TheErrorOfYourWays;
}

class DoSomethingSpectacular {
    use SpectacularStuff1, SpectacularStuff2;
}

这导致(显然不那么明显):

致命错误:Trait方法booboo尚未应用,因为在DoSomethingSpectacular上存在与其他特征方法的碰撞.

所以我的问题是:如何解决特征中的方法冲突？是否有可能实现重叠特质"继承"？如果是这样,那么"正确"的方法是什么？

为什么我要这样做:

1. 我想创建自包含的特征和类(混合和匹配样式).如果可能的话,我想说"使用"然后必须发生神奇的东西.没有必要抓住我的想法,"现在又有什么命名空间？"等等等等.
2. 当我做一些"冒险"的事情并发现我无意中造成了冲突时,不必动态编辑类和特征.
3. 当时看起来像个好主意.

我尝试过的:

1. PHP手册.
2. 谷歌.
3. 所以包括这个问题 - >这个场景的答案不正确.
4. 发现这个,但我使用的是PHP 5.5.1版.这是固定的,对吗？对？ …

首先,考虑一下这个C++代码:

#include <stdio.h>

struct foo_int {
    void print(int x) {
        printf("int %d\n", x);
    }    
};

struct foo_str {
    void print(const char* x) {
        printf("str %s\n", x);
    }    
};

struct foo : foo_int, foo_str {
    //using foo_int::print;
    //using foo_str::print;
};

int main() {
    foo f;
    f.print(123);
    f.print("abc");
}

正如根据标准所预期的那样,这无法编译,因为print为了重载解析的目的在每个基类中单独考虑,因此调用是不明确的.这是Clang(4.0),gcc(6.3)和MSVC(17.0)的情况 - 请参阅此处的 godbolt结果.

现在考虑以下片段,唯一的区别是我们使用operator()而不是print:

#include <stdio.h>

struct foo_int {
    void operator() (int x) {
        printf("int %d\n", x);
    }    
};

struct foo_str {
    void operator() (const …