Question

似乎Java 8允许使用如下的简单框架进行完全成熟的继承，在接口上使用Static和Default方法。

虽然它总是可能滥用和编写愚蠢的代码，但这些新功能使得实现多重继承变得非常容易，即使该语言的设计者意图远离它。

这是使用Interfaces作为基类或滥用语言的多重继承的简单实现吗？ Java设计师在允许这样做方面走得太远了吗？

package PseudoMultipleInheritance;
import java.util.HashMap;

abstract class InstanceMap<T,T2>
{ 
     HashMap<Object,Object> instances = new HashMap<Object, Object>();
     abstract T2 createMembersInstance();
     T2 getMembersInstance(T thisObject )
     {
         if ( !instances.containsKey(thisObject) )
             instances.put(thisObject,createMembersInstance());
         return (T2) instances.get(thisObject);      
     }  
}

interface A  
{
 class Members
 {
    int x;  // just an example of an inheritable member 
 }
 InstanceMap<A,A.Members> instanceMap = new InstanceMap<A, A.Members>() {   A.Members createMembersInstance() {return new A.Members();  }};
 default A.Members thisA() { return instanceMap.getMembersInstance(this); }
 default int getX()
 {
     return thisA().x;  // // just an example of an inheritable getter
 }
 default void setX(int x)
 {
     thisA().x = x;  // just an example of an inheritable setter
 }
}

interface B 
{
 class Members
 {
    int y;  // just an example of an inheritable member
 }  
 InstanceMap<B,B.Members> instanceMap = new InstanceMap<B, B.Members>() {   B.Members createMembersInstance() {return new B.Members();} };  
 default B.Members thisB() { return instanceMap.getMembersInstance(this); }
 default int getYLastDigit()
 {
     return thisB().y % 10;  // just an example of an inheritable function
 }
 default void incrementY(int x)
 {
     thisB().y += x; // just an example of an inheritable function
 }
}

class C implements A, B
{
}

public class Example04AlmostMultipleInheritance {

 public static void main(String[] args) {
     C c1 = new C();
     C c2 = new C();
     c1.setX(5);
     c2.setX(3);
     System.out.println(c1.getX());   // prints 5
     System.out.println(c2.getX());   // prints 3
     c1.incrementY(99);
     System.out.println(c1.getYLastDigit());  // prints 9 

}
}

/////////////////////////////////////////////// ////

或者是另一种选择：

interface A  
{
 class Members
 {
    public int x;  // just an example of an inheritable member
    void showX() { System.out.println(x); }  // just an example of an inheritable function
 }
 InstanceMap<A,A.Members> instanceMap = new InstanceMap<A, A.Members>() {   A.Members createMembersInstance() {return new A.Members();  }};
 default A.Members getA() { return instanceMap.getMembersInstance(this); }
}

interface B 
{
 class Members
 {
    int y;  // just an example of an inheritable member
 }  
 InstanceMap<B,B.Members> instanceMap = new InstanceMap<B, B.Members>() {   B.Members createMembersInstance() {return new B.Members();} };  
 default B.Members getB() { return instanceMap.getMembersInstance(this); }
}

class C implements A, B
{
}

public class Example04AlmostMultipleInheritance {

 public static void main(String[] args) {
     C c1 = new C();
     C c2 = new C();
     c1.getA().x = 5;
     c2.getA().x = 3;
     c1.getA().showX();   // prints 5
     c2.getA().showX();   // prints 3
     c1.getB().y = 99;
     System.out.println(c1.getB().y % 10);  // prints 9 

}
}

Answer 1

实现接口不是继承。就这么简单。

如果有人实现了你的接口但是提供了与默认接口不同的实现呢？

所以不，这不是多重继承，它只是一种编写代码的方法，这取决于没有人实际实现自己版本的默认方法。这意味着它依赖于人们实际上没有按照他们应该的方式使用接口，因为他们应该能够实现他们自己的方法而不是默认方法，但是如果他们真的这样做，那么你的“多重继承”是行不通的如预期的那样。

所以我实际上认为这是误用语言。

Answer 2

它是一种多重继承的形式，但它不是通常在讨论多重继承时提出的“钻石问题”。 Java的实现与Scala的同一个解决方案几乎相同，这有点类似于Python实现多重继承的方式。

Answer 3

不，请参阅此处的多重继承示例：http://java.dzone.com/articles/interface-default-methods-java

Java 8中完全成熟的多重继承

3 个答案: