多重继承没有多重继承，没有代码重复(Multiple inheritance without mul

我有一个关于如何在不允许多重继承语言处理以下情形的理论问题。

想象一下，我有一个基类Foo和从中我希望创建三个子类：

酒吧类继承Foo和执行功能“A”
类继承巴兹 Foo和实现功能“B”
类继承Qux Foo和实现的功能“A”和“B”

试想一下，代码来实现功能的“A”和“B”是永远不变的。有没有写一个“A”和“B”只有一次的代码，然后有相应的类应用（或“继承”），它的方法吗？

Answer 1:

那么我可以看到你在C＃实现这一目标的唯一途径/ Java是由组成。试想一下：

class Foo {

}

interface A {
    public void a();
}

interface B {
    public void b();
}

class ImplA implements A {
    @Override
    public void a() {
        System.out.println("a");
    }
}

class ImplB implements B {
    @Override
    public void b() {
        System.out.println("b");
    }
}

class Bar extends Foo {
    A a = new ImplA();

    public void a() {
        a.a();
    }
}

class Baz extends Foo {
    B b = new ImplB();

    public void b() {
        b.b();
    }       
}

class Qux extends Foo {

    A a = new ImplA();
    B b = new ImplB();

    public void b() {
        b.b();
    }

    public void a() {
        a.a();          
    }       
}

现在Qux兼具的功能Foo经由正常继承而且的实现A和B通过组合物。

Answer 2:

这样做的更通用的术语是一个的Mixin 。有些语言提供开箱即用支持，如Scala和D的有各种不同的方式来实现在其他语言相同的结果，虽然。

您可以创建在C＃中的伪混入一种方法是使用空的接口，并提供扩展方法的方法。

interface A { }
static class AMixin {
    public static void aFunc(this A inst) {
        ... //implementation to work for all A.
    }
}

interface B { }
static class BMixin {
    public static void bFunc(this B inst) {
        ...
    }
}

class Qux : Foo, A, B {
    ...
}

Answer 3:

这是在提供性状（这里：语言实现的斯卡拉）：

class Foo {
    def fooM() {}
}

trait A {
    def aFunc() {}
}

trait B {
    def bFunc() {}
}

class Bar extends Foo with A {}

class Baz extends Foo with B {}

class Qux extends Foo with A with B {}

因为Scala于Java之上运行（既没有多重继承，也不特质）它被翻译成像这样（简体） - 这可能是一个暗示如何实现它在手动的Java / C＃：

class Foo {
}

interface A {
    void aFunc();
}

interface B {
    void bFunc();
}

class Bar extends Foo implements A {

    public void aFunc() {
        $A.aFunc();
    }
}

class Baz extends Foo implements B {

    public void bFunc() {
        $B.bFunc();
    }
}

class Qux extends Foo implements A, B {

    public void aFunc() {
        $A.aFunc();
    }

    public void bFunc() {
        $B.bFunc();
    }
}

class $A {

    public static void aFunc() {}
}

class $B {

    public static void bFunc() {}
}