Java泛型方法的继承和覆盖规则

Question

我有一个具有泛型方法的抽象类，我想通过用特定类型替换泛型参数来覆盖泛型方法。所以在伪代码中我有以下内容：

public abstract class GetAndParse {
  public SomeClass var;

  public abstract <T extends AnotherClass> void getAndParse(T... args);
}

public class Implementor extends GetAndParse {
  // some field declarations

  // some method declarations

  @Override
  public <SpecificClass> void getAndParse(SpecificClass... args) {
    // method body making use of args
  }
}

但由于某种原因我不允许这样做？我是否犯了某种语法错误，或者不允许这种继承和覆盖？具体来说，我收到有关 @Override 的错误，因为 eclipse IDE 不断提醒我实现 getAndParse。

这就是我希望上面的代码如何工作。在我的代码的其他地方，有一个方法需要实现 GetAndParse 的对象实例，这特别意味着它们有一个我可以使用的 getAndParse 方法。当我在该实例上调用 getAndParse 时，编译器会检查我是否以正确的方式使用了 T 的特定实例，特别是 T应该扩展AnotherClass并且它应该是SpecificClass。

Answer 1

我们这里有两种不同的方法，每个方法都有单独的类型参数。

public abstract <T extends AnotherClass> void getAndParse(Args... args);

这是一个带有名为 T 的类型参数的方法，并以 AnotherClass 为界，这意味着 AnotherClass 的每个子类型都可以作为类型参数。

public <SpecificClass> void getAndParse(Args... args)

这是一个带有名为 SpecificClass 的类型参数的方法，以 Object 为界（意味着每种类型都可以作为类型参数）。你真的想要这个吗？

Args 内部使用了类型参数吗？我想问题就在那里。

---

的含义

public abstract <T extends AnotherClass> void getAndParse(T... args);

是，方法的调用者可以决定使用哪种类型参数来调用该方法，只要这是AnotherClass的某个子类型。这意味着实际上可以使用 AnotherClass 类型的任何对象调用该方法。

由于调用者可以决定类型参数，因此您不能在子类中将参数类型缩小为 SpecificClass - 这不是该方法的实现，而是另一个同名的方法（重载） 。

也许您想要这样的东西：

public abstract class GetAndParse<T extends AnotherClass> {
  public SomeClass var;

  public abstract void getAndParse(T... args);
}

public class Implementor extends GetAndParse<SpecificClass> {
  // some field declarations

  // some method declarations

  @Override
  public void getAndParse(SpecificClass... args) {
    // method body making use of args
  }
}

现在 getAndParse 方法实现了父类的方法。

Answer 2

您之所以会遇到此问题，是因为 Java 泛型中称为“擦除”的概念。
Java使用“擦除”来支持向后兼容性。即没有使用泛型的Java 代码。

擦除程序：
编译器将首先进行类型检查，然后尽可能地删除（擦除）所有类型参数，并在必要时插入 TypeCasting。

例如：

public abstract <T extends AnotherClass> void getAndParse(T paramAnotherClass);

会变成

public abstract void getAndParse(AnotherClass paramAnotherClass);

在类“Implementor.java”中，

代码

public <SpecificClass> void getAndParse(T paramAnotherClass)

​​会变成

public void getAndParse(SpecificClass paramAnotherClass){  }

编译器会看到你没有正确实现抽象方法。
抽象方法和实现方法之间存在类型不匹配。这就是您看到错误的原因。

更多详细信息可以在这里找到。
http://today.java.net/pub/a /today/2003/12/02/explorations.html

Answer 3

您不能覆盖特定类型T，因为实际上（如果您愿意，在字节码级别）由于类型擦除而只有一种方法getAndParse（请参阅其他答案）

public abstract void getAndParse(AnotherClass... args); // (1)

：每种类型的T，都使用相同的方法。

你可以重载它（我认为）：

public void getAndParse(SpecificClass... args); // (2)

但这与（1）ant的方法没有什么不同，它将不会被通用代码调用：

T x = whatever;
object.getAndParse(x); // Calls (1) even if T is derived from SpecificClass

Answer 4

不，这是无效的。如果拥有 GetAndParse 引用的人使用扩展 AnotherClass 的不同类来调用它，会发生什么？

Answer 5

当有人引用类型 GetAndParse 并尝试调用 getAndParse 方法时，这就变得毫无意义了。如果 Cat 和 Dog 扩展 AnotherClass。我应该期望能够使用 Cat 或 Dog 调用 GetAndParse#getAndParse。但实现却试图限制它并使其兼容性降低！

Answer 6

静态方法无法重写

class Vehicle{
static void park(int location){
    System.out.println("Vehicle parking..");
}}

class Car extends  Vehicle{
@Override //error
void park(int location) { //error
    System.out.println("Car Parking..");
}}

私有方法无法重写

class Vehicle{
private void park(int location){
    System.out.println("Vehicle parking..");
}
void callPark(){
    park(100);
}}

class Car extends  Vehicle{
//@Override
void park(int location) {
    System.out.println("Car Parking..");
}}

class Demo {
public static void main(String[] args) {
    Vehicle v1=new Car();
   v1.callPark();
}}

最终方法无法重写

class Vehicle{
final void park(int location){
    System.out.println("Vehicle parking..");
}}

class Car extends  Vehicle{
//@Override
void park(int location) { //error
    System.out.println("Car Parking..");
}}