标签: multiple-inheritance

我不太熟悉javascript继承,我试图让一个对象从另一个继承,并定义自己的方法:

function Foo() {}
Foo.prototype = {
    getColor: function () {return this.color;},
};
function FooB() {}
FooB.prototype = new Foo();
FooB.prototype = {
    /* other methods here */
};

var x = new FooB().getColor();

但是,第二个会覆盖第一个(FooB.prototype = new Foo() is cancelled out).有什么方法可以解决这个问题,还是我朝错误的方向走？

在此先感谢,抱歉任何不好的术语.

一个人可以是一个钢琴家,有一个.play()方法,一个歌手,有一个.sing()方法,无论是钢琴家还是歌手,在后一种情况下他都可以. )以及.play()

对于这种情况,可能的设计是什么？

interface i1{
    int test();
}

interface i2{
    String test();
}

class Test implements i1,i2{
    <Return type> test(){
         //code here
    }
}

如果实现方法的返回类型为int,则错误表示返回类型与i2.test()不兼容 如果实现方法的返回类型为String,则错误表示返回类型与i1.test()不兼容

我应该如何在我的类Test中实现这两个接口

任何帮助都很明显.

请不要在这里对这段代码中真正奇怪的工人层级提出质疑,我不知道为什么有人会想要这样的东西,但我决定给自己一个多重继承的练习,只是为了确保我完全理解它.所以这是结果.

using namespace std;

class Employee
{
protected:
    string name;
public:
    string getname()
    {
        return name;
    }
    void setname(string name2)
    {
        name = name2;
    }
    Employee(string name2)
    {
        name = name2;
    }
    Employee(){}
};

class Manager : public Employee
{
public:
    string getname()
    {
        return ("Manager" + name);
    }
    Manager(string name2) : Employee(name2){}
    Manager() : Employee(){}
};

class Supervisor : public Manager,public Employee
{
public:
    Supervisor(string name2) : Manager(name2) , Employee(name2){}
    Supervisor() : Manager() , Employee(){}
    string getname()
    {
        return …

我有以下几组课程:

以下代码:

A* a;
if(condition)
{
    a = new E();
}
else
{
    a = new D();
}

现在假设有这样的功能F::foo(),为了调用它,我必须转换a为E*或者D*:

if(condition)
{
    ((E*)a)->foo();
}
else
{
    ((D*)a)->foo();
}

据我所知,铸造a到F*以打电话F::foo,因为是非法a的类型的A*; 对我来说,在打电话之前检查一下情况foo,听起来像是一个设计问题.有人可以就如何改进这个类层次结构提出一些建议吗？

ps使用此工具绘制图表.

考虑C#中的以下结构:

interface I1
interface I2

abstract class A
- class A1 : A
  - class A11 : A1, I1
  - class A12 : A1, I2
- class A2 : A
  - class A21 : A2, I1
  - class A22 : A2, I2

现在我有一个B类,它在构造函数中接受一个参数.该参数必须是以某种方式从A派生并实现接口I2的类,即它可以是类型A12或A22,但不是A11或A21.我该如何定义该参数？此外,我想稍后将参数存储为B中的属性(以供以后使用).

我无法将A重新定义为接口,因为它提供了许多虚拟方法.我也不能跳过树状继承方案,因为A1和A2提供了许多在别处使用的特定方法(不在B中).所以,我需要在B中处理的是来自A和I2的东西.

我已经看过了接口,抽象类和继承的用法.我看到每个都有它们的用途,但我仍然有点困惑.

我知道通常一个类只能扩展另一个类,虽然有些可能支持多重继承,但它可以实现多个接口(这可能是使用接口的主要原因).但是,如果我是正确的,这个类也可以被另一个类扩展.我还看到抽象类可能比接口更快,并且可以有非静态的最终变量.

所以,我仍然不确定何时使用哪个更好.也许通过举一些例子可以更好地理解这一点.我并不反对使用任何东西,但我认为有些东西是我看不到的.进一步的解释也许有帮助.提前致谢.

最终类用户可能想创建一个由Base和组成的类Mixin（Mixin在第三方库类上提供了其他通用功能）。

但是，Mixin.__init__当按以下方式使用时不会调用。仅Base.__init__称为：

>>> class Base(object): #3rd party library class
...     def __init__(self): print "Base"
... 
>>> class Mixin(object): #my features useful as addendum for a few classes
...     def __init__(self): print "Mixin"
... 
>>> class C(Base, Mixin): pass
... 
>>> c = C()
Base

如何执行调用都Mixin.__init__和Base.__init__在这种情况下，无需用户记住把一个构造函数super()在C级呼叫？

>>> class Base(object):
...     def __init__(self): print "Base"
... 
>>> class Mixin(object):
...     def __init__(self): print "Mixin"
... 
>>> …

我们可以通过使用抽象类来实现与接口相同的功能,那么为什么java不允许以下代码呢？

abstract class Animals
{
    public abstract void run();
}

abstract class Animals1
{
    public abstract void run1();
}

class Dog extends Animals,Animals1
{
  public void run() {System.out.println("Run method");}
  public void run1() {System.out.println("Run1 method");}
}

我知道只使用接口可以实现多重继承,但上面的代码与接口完成的工作相同.

在以下代码中:

生活

#include <iostream>
#include <thread>
#include <mutex>
#include <functional>

struct IView {
    virtual void setOnClick() = 0;
};
struct ITextView : IView {
    virtual void setText() = 0;
};
struct IButton : ITextView {
    virtual void setRadius() = 0;
};

struct View : IView {
    int i = 1;
    virtual void setOnClick() override {
        std::cout << "setting OnClick! i: " << i << std::endl;
    };
};

/// Works as is
/// But if make "TextView : View, ITextView" - …