标签: multiple-inheritance

我正在研究多重继承的概念(自从我在愤怒中编写C++以来已经差不多10年了,并且只是在学术上对这个概念感兴趣).我在维基百科上找到了这个参考.

他们列出的对MI的批评是"无法从单个类中明确地继承多次".我对这个陈述感到困惑,并不是百分之百地确定这是指什么.

当然,一个类继承描述了一个类的结构,并且从同一个类继承多次只会重复相同的类契约,所以我看不出它会给批评辩护的好处.显式继承是否会假设类函数和属性的多个实例？

我想了解这个批评所指的是什么,以及为什么启用多重继承的语言隐含无法使用它.

在我的班级设计中遇到了以下问题:

class MyData
{   
   int foo;
};

class AbstraktA
{
public:
    virtual void A() = 0;
};

class AbstraktB : public AbstraktA
{
public:
    virtual void B() = 0;
};

template<class T>
class ImplA : public AbstraktA
{
public:
    void A(){ cout << "ImplA A()";  }       
};

class ImplB : public ImplA<MyData>, public AbstraktB
{
public:
     void B(){ cout << "ImplB B()"; }   
};

void TestAbstrakt()
{
    AbstraktB *b = (AbstraktB *) new ImplB;
    b->A();
    b->B();
};

上面代码的问题是编译器会抱怨AbstraktA :: A()没有定义. …

我有一个项目,其中包含一些非常小的类,这些类充当了较大类的最小接口.有时我的对象需要几个这样的接口.有时这些接口共享相同的派生基类.无论如何,我可以构造我的代码,以便我只有一个所有接口共享的派生基类的副本？

这是一个代码示例:

class A {
public:
  virtual void f(int a)=0;
  virtual int g() const {
    return m_inner;
  }
protected:
  int m_inner;
};

class B : public A {
public:
  virtual void f(int a)=0;
  virtual void h(int b) {
    m_stuff = b;
    m_inner = 0;
  }
protected:
  int m_stuff;
};

class C : public A {
public:
  virtual void f(int a)=0;
  virtual int i() const {
    return m_otherstuff;
  }
protected:
  int m_otherstuff;
};

class D : public B, public C { …

我知道这个问题已被问了一百万次,但我找不到合适的答案.

我有一大堆的使者方法,比如debug(String)和tell(CommandSender, String)我想使用各种类.这听起来简单易行,但是Java缺乏对多重继承的支持,这使得这个问题非常困难,因为那些已经不得不扩展其他东西的类.

接口将无法正常工作,因为接口不允许您实际实现放在其中的方法.

我曾考虑增加额外的参数的方法,使他们从一个静态的公共事业类工作,但是这使得该方法的调用,从去debug(String)到MessageUtil.debug(Plugin, String),这是更为庞大的比我想的.

我已经考虑过制作一个可以处理这些消息的Messenger对象,这样我就可以打电话messenger.debug(String),这更好,但是我不能动摇那种必须有更好的方法来debug(String)独处的感觉.

有什么建议？

编辑:遗憾的是,如果不添加额外的参数,这些方法就不能成为静态的.因此,静态导入将无法正常工作.

编辑:这是我尝试在多个类中使用的方法之一的示例.正如您可以通过使用非静态全局变量(如"plugin"和"debuggers")看到的那样,它不能成为静态的.

protected myPlugin plugin;
private myList<String> debuggers = new myList<String>();

public void debug(String message) {
    if (debuggers.size() == 0)
        return;
    if (debuggers.contains("\\console")) {
        plugin.getServer().getConsoleSender().sendMessage(plugin.getColor() + message);
        if (debuggers.size() == 1)
            return;
    }
    for (Player player : plugin.getServer().getOnlinePlayers())
        if (debuggers.contains(player.getName()))
            player.sendMessage(plugin.getColor() + message);
}

这是另一个示例,使用与上面相同的全局变量向服务器上的每个播放器和控制台广播消息:

public void broadcast(String message) {
    for (Player player : mCL.getServer().getOnlinePlayers())
        player.sendMessage(plugin.getColor() + message);

    mCL.getServer().getConsoleSender().sendMessage(message);
} …

我有以下内容:

class Abstract
{
    virtual void AbstractMethod() = 0;
};

class Implementer
{
    void AbstractMethod() {};
};

class Concrete : public Abstract, private Implementer
{};

我无法实例化,Concrete因为AbstractMethod不会覆盖纯虚方法.我究竟做错了什么？

有这个代码:

class Base{
    public:
    void disp(){
    cout<<"base"<<endl;
    }
};

class Der1:public Base{
    public:
    void test1(){
    cout<<"der1 test1"<<endl;
    }
};

class Der2:public Base{
    public:
    void test2(){
    cout<<"der2 test2"<<endl;
    }
};

class Der3:public Der1,Der2{
    public:
    void fun(){
    cout<<"Der3 fun"<<endl;
    }
};


int main()
{
    Der3 d;
    d.test1();
}

OUTPUT:der1 test1 //成功打印

但对于

int main()
{
    Der3 d;
    d.test2();
}

它给出了Der2无法访问的错误......

但是,当我将代码更改为

class Base{
        public:
        void disp(){
        cout<<"base"<<endl;
        }
    };

class Der1:public Base{
    public:
    void test1(){
    cout<<"der1 test1"<<endl;
    }
};

class Der2:public Base{ …

所以这让我感到困惑.
假设有两个接口.

public interface a
{
    void foo();
}

public interface b
{
    void foo();
}

这两个接口都有一个函数foo,我有一个提供显式实现的类:

public class alpha : a, b
{
    // why can't I put an access modifier here?
    // How would you be able to hide this from a derived class
    void a.foo()
    {
        Console.WriteLine("a");
    }

   void b.foo()
    {
        Console.WriteLine("b");
    }
}

还有一个派生自alpha的类

public class beta : alpha
{
}

你如何使foo私有或受保护,因为alpha不允许在显式的imlementation上访问修饰符,什么可以阻止某人调用:

var be = new beta();
(be as b).foo();

编辑

为什么我没有明确提供实现我可以提供访问修饰符？

public class alpha : …

我有3个类MetaA,MetaB和MetaC.每个都有许多属性.

在某些情况下,只有一个类包含所有三个Meta类的属性(例如,MetaComposite)会很好.在复合类中,我尝试了每个MetaA,B和C的创建和实例,希望我可以像这样访问属性:

Meta Composite mc = new MetaComposite();
mc.MetaA.Property1 = "Hello";

由于C#不允许多重继承,因此创建一个由其他类组合的类的最佳方法是什么？我可以在复合类中放置字段并编写getter和setter来传递属性值,但这将是很多重复的代码.

这里的正确方法是什么？

我有一个类层次结构:

abstract class BaseThing
{
    public abstract void doSomething();
}

class Thing1 extends BaseThing
{
    @Override
    public void doSomething()
    {
        doSomethingWithThing1();
    }
}

class Thing2 extends BaseThing
{
    @Override
    public void doSomething()
    {
        doSomethingWithThing2();
    }
}

// A dozen more classes that extend the BaseThing class. 

我需要创建整个树的扩展版本.Java中没有多重继承,因此我将其创建为:

interface BaseThingExt
{
   public void doSomethingElse();
}

class Thing1Ext extends Thing1 implements BaseThingExt
{
    @Override
    public void doSomethingElse()
    {
        doSomethingElseWithThing1();
    }
}

//   All Thing.. classes are extended by ThingExt... classes

现在的问题.我在哪里可以为所有ThingExt类添加一些公共字段？ …

我有一个包含4个类的C++程序:Person,Student,Employee和PartTimeStudent.

Student和Employee都派生自Person,而PartTimeStudent派生自所有3个类(使其成为派生程度最高的类).Person,Student和Employee也有一个名为VDescribe()的派生函数.

请参阅以下代码:

class Person
{
    ...    
    virtual void VDescribe();
    ...
};

class Student : virtual public Person
{
    ...    
    virtual void VDescribe();
    ...
};

class Employee : virtual public Person
{
    ...    
    virtual void VDescribe();
    ...
};

class PartTimeStudent : virtual public Person,
    virtual public Student,
    virtual public Employee
{
    ...
};

注意:在上面的代码片段中,我省略了构造函数,析构函数和成员变量,因为它们与手头的问题无关.

当我尝试编译代码时,我收到以下错误:

override of virtual function "Person::VDescribe" is ambiguous

'PartTimeStudent': ambiguous inheritance of 'void Person::VDescrive(void)'

'PartTimeStudent': ambiguous inheritance of 'void Person::VDescribe(void)'

但是,仅当Student和Employee都实现VDescribe()时才会出现这种情况.如果其中一个类未实现VDescribe(),则编译成功.我仍然会收到警告,例如,如果我从Employee中省略VDescribe(),则会出现以下警告:

'PartTimeStudent': inherits 'Student::Student::VDescribe' via dominance …