Java抽象类使用泛型实现接口

Question

我想要定义一个实现Comparable的抽象类。当我定义，定义如下类：

public abstract class MyClass implements Comparable <MyClass> 

子类必须实现compareTo(MyClass object)。相反，我希望每个子类都实现compareTo(SubClass object)，接受它自己类型的对象。当我尝试用类似的方式定义抽象类时：

public abstract class MyClass implements Comparable <? extends MyClass> 

它抱怨说“超类型不能指定任何通配符”。

有没有解决方案？

Answer 1

这在我看来有点太冗长，但工作原理：

public abstract class MyClass<T extends MyClass<T>> implements Comparable<T> { 

} 

public class SubClass extends MyClass<SubClass> { 

    @Override 
    public int compareTo(SubClass o) { 
     // TODO Auto-generated method stub 
     return 0; 
    } 

} 

Answer 2

我不知道你需要捕获：

首先，添加的compareTo抽象类...

public abstract class MyClass implements Comparable <MyClass> { 

@Override 
public int compareTo(MyClass c) { 
... 
}  
} 

然后添加实现...

public class MyClass1 extends MyClass { 
... 
} 

public class MyClass2 extends MyClass { 
... 
} 

呼叫比较会调用超类方法......

MyClass1 c1 = new MyClass1(); 
MyClass2 c2 = new MyClass2(); 

c1.compareTo(c2); 

Answer 3

除了你遇到声明签名机械的困难，我们的目标没有太大的意义。你正试图建立一个协变比较函数，这个函数打破了建立派生类可以定制的接口的想法。

如果你定义一些子类​​使得它的情况下，只能相对于其他​​实例，则如何​​满足MyClass定义的合同吗？回想一下MyClass是说它和它的任何类型可以与其他MyClass实例进行比较。您正试图使​​不正确，这意味着​​不符合MyClass的合同：由于​​的要求更严格，因此您不能用​​替代MyClass。

这个问题主要集中在协方差和反变量上，以及它们如何通过类型派生来改变函数签名。您可以放宽对参数类型的要求 - 接受比超类型的签名要求更宽的类型 - 您可以加强对返回类型的要求 - 承诺返回比超类型签名更窄的类型。这些自由中的每一个仍然允许超类型的派生类型的完美替换;当通过超类型的接口使用派生类型时，调用者无法区分差异，但具体使用派生类型的调用者可以利用这些自由。

Willi's answer教导一些关于泛型声明的内容，但我希望你在接受技术之前重新考虑你的目标，而不要牺牲语义。

Answer 4

看到Java的自己的例子：在SEH的评论

public abstract class Enum<E extends Enum<E>> implements Comparable<E> 
    public final int compareTo(E o) 

：通常的说法是正确的。但泛型使得类型关系更加复杂。子类可以不是MyClass在威利的溶液亚型....

SubClassA是MyClass<SubClassA>一个亚型，但不是MyClass<SubClassB>

类型MyClass<X>的子类型定义了一个合同compareTo(X)其中所有其亚型的绝荣誉。那里没有问题。

Answer 5

public abstract class MyClass<T> implements Comparable<T> { 

} 

public class SubClass extends MyClass<SubClass> { 

    @Override 
    public int compareTo(SubClass o) { 
     // TODO Auto-generated method stub 
     return 0; 
    } 

} 

Answer 6

我知道你说你想“的compareTo（子类对象），接受自己的类型的对象”，但我还是建议声明抽象类是这样的：

public abstract class MyClass implements Comparable <Object> 

，做一个instanceof检查在MySubClass覆盖的compareTo时：

@Override 
public int compareTo(Object o) { 
    if (o instanceof MySubClass)) { 
     ... 
    } 
    else throw new IllegalArgumentException(...) 
} 

类似 '等于' 或 '克隆'

Answer 7

发现了另一个解决方案：

1. 定义在其上构成comaprable（例如ComparableFoo）的字段的接口
2. 实现父类的接口
3. 实现对父类具有可比性。
4. 编写您的实施。

解决方案应该是这样的：

public abstract class MyClass implements ComparableFoo,Comparable<ComparableFoo> { 
    public int compareTo(ComparableFoo o) { 
    // your implementation 
    } 
} 

这种解决方案意味着更多的东西有可能实现的ComparableFoo - 这很可能并非如此，但那么你的编码到一个接口和仿制药的表达很简单。