主页 / 问题 / 1217225
Accepted
Mikhail Murugov
Asked:2021-12-11 17:21:05 +0000 UTC2021-12-11 17:21:05 +0000 UTC

如何在java中替换多重继承？

  • 772

我想实现大约以下架构：

解释：

  • Base- 类似于存储一些基本对象的存储实体；
  • ChildN- 对存储在Base. 事实上，它们是接口，因为 不存储任何状态；
  • static Mixin- 一个结合了所有方法的类ChildN。方法名称之间没有冲突。它的所有方法（即从 继承的方法ChildN）必须是静态的，无需实例化即可调用。

在中，这个任务很容易通过多重继承来解决，在中没有这样的事情。怎样成为？

我要实现的示例伪代码：

class Base {
    static protected final String someString = "01";
}

class Child1 extends Base {
    static public char get_0() {
        return someString.charAt(0);
    }
}

class Child2 extends Base {
    static public char get_1() {
        return someString.charAt(1);
    }
}

class MixIn extends Child1, Child2 {  // Так сделать нельзя

}

public class Main {
    public static void main(String[] args) {
        System.out.println(MixIn.get_0());  // Итоговое использование должно быть таким
        System.out.println(MixIn.get_1());
    }
}
java

1 个回答

  1. Best Answer

    事实证明，您需要将功能分成几个类，并重新合并为一个类，仅用于逻辑分组。您的问题的可能解决方案：

    使用接口

    你可以做child-ы接口。Java没有多重继承，但可以实现多个接口。要直接在接口中实现方法（以便它们不需要在实现它们的类中实现），您可以使用关键字default：

    class Base {
    static public final String str = "01";
}

interface Child1 {
    default char get0() {
        return Base.str.charAt(0);
    }
}

interface Child2 {
    default char get1() {
        return Base.str.charAt(1);
    }
}

class MixIn implements Child1, Child2 {
}

class Main {
    public static void main(String[] args) {
        MixIn mixIn = new MixIn();
        System.out.println(mixIn.get0());
        System.out.println(mixIn.get1());
    }
}

    拒绝功能分离

    您正在使用一个 Base 存储库。在我看来，在这里使用一个没有任何接口的类就绰绰有余了。此外，您可以将所有这些方法放在 Base 类中。

    例如：

    class Base {
    private final String str = "01";

    public String getStr() {
        return str;
    }
}

class MixIn {
    private Base base;

    public MixIn(Base base) {
        this.base = base;
    }

    public char get0() {
        return base.getStr().charAt(0);
    }

    public char get1() {
        return base.getStr().charAt(1);
    }
}

public class Main {
    public static void main(String[] args) {
        MixIn mixIn = new MixIn(new Base());
        System.out.println(mixIn.get0());
        System.out.println(mixIn.get1());
    }
}

    使用静态内部类

    你说你需要一个逻辑分组。Java 有一个称为静态内部或嵌套类的构造。在该类内部，创建了另一个类，并用 标记static。这样就可以实现逻辑分组。例子：

    class Base {
    static public final String someString = "01";
}

class MixIn {
    public static class Child1 {
        static char get1() {
            return Base.someString.charAt(1);
        }
    }

    public static class Child2 {
        static char get0() {
            return Base.someString.charAt(0);
        }
    }
}

    你看，我创建了一个通用的 MixIn 类，里面有两个静态类。它们是这样称呼的：

    class Main {
    public static void main(String[] args) {
        System.out.println(MixIn.Child1.get1());
        System.out.println(MixIn.Child2.get0());
    }
}

    如您所见，没有实例化，并且类/方法在逻辑上进行了分组。

    • 2

相关问题