Question

我有一个理论问题,涉及如何用不允许多重继承的语言处理以下情形。

试想一下,我有一个基础级 Foo ,我想从中创建三个子级:

Class Bar inherits Foo and implements functionality "A"
Class Baz inherits Foo and implements functionality "B"
Class Qux inherits Foo and implements functionalities "A" and "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();          
    }       
}

现在 ux 既具有通过正常继承 Foo 的功能,也具有根据组成实施 A 和 B 的功能。

Answer 2

更一般的术语是 < a href=" "http://en.wikipedia.org/wiki/Mixin" rel="nofollow" >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

这在提供特性的语言中是可以实现的(此处:scala 的标有 scala “ rel='tag' > scala 的问题 ):

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跑在爪哇山顶(既无多个遗产,也无特征),

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() {}
}

Answer 4

有几种方法可以做这样的事情。更具体地说,如果我们暂时放弃继承问题,就会有办法在不同阶层引入相同的功能单位,而只写一次。

好吧,我love AOP 框架,它有多种语言(C#和Java有几种语言)。AOP框架基本上允许您在整个继承结构中将自足功能添加到不同的类别中。

对于C#,您有"http://www.sharrpcrafters.com/"rel="nofollow" >PostSharp ,对于爪哇,您有AspectJ ,等等。

许多AOP框架允许在不使用继承的情况下劫持或压倒使用方法的电话。

友情链接