Java 在子类中重新定义泛型类型

有没有一种方法可以扩展一个类，该类已经为泛型类型定义了类，但是在子类中为该类型提供了一个新的定义

abstract class A<T>{
    abstract public void foo(T input);
}
class B extends A<Integer>{
    public void foo(String input){ ...}

}
class C extends B<String>{
    public void foo(String input){
        //.. convert int to string
        super.foo(Integer.valueof(input));
    }
}

抽象类A{
抽象公共void foo（T输入）；
}
B类扩展了A类{
公共void foo（字符串输入）{…}
}
C类扩展到B类{
公共void foo（字符串输入）{
//..将int转换为字符串
super.foo（Integer.valueof（input））；
}
}

这是不可能的

如果一个类是a

B

，那么它提供了一个

foo（Integer）

方法<代码>C不执行此操作，因此不能用作

B

试图在字里行间阅读，似乎你想要的是像a B一样的东西，除了它需要字符串而不是整数。在这种情况下，

A

是常见的键-对于任何合适的类型，您都需要使用

foo

方法。当您想要一个基于字符串的等价物

B

时，您实际上是在寻找

a

，而

C

可以完成这项工作

一个简单的定义可能是：

class C extends A<String> {
    private final B delegate;  // Set up in constructor or whatever

    public void foo(String input) {
        //.. convert int to string
        delegate.foo(Integer.valueof(input));
    }
}

C类扩展了{
private final B delegate；//在构造函数中设置
公共void foo（字符串输入）{
//..将int转换为字符串
delegate.foo（Integer.valueof（input））；
}
}

这是不可能的

如果一个类是a

B

，那么它提供了一个

foo（Integer）

方法<代码>C不执行此操作，因此不能用作

B

试图在字里行间阅读，似乎你想要的是像a B一样的东西，除了它需要字符串而不是整数。在这种情况下，

A

是常见的键-对于任何合适的类型，您都需要使用

foo

方法。当您想要一个基于字符串的等价物

B

时，您实际上是在寻找

a

，而

C

可以完成这项工作

一个简单的定义可能是：

class C extends A<String> {
    private final B delegate;  // Set up in constructor or whatever

    public void foo(String input) {
        //.. convert int to string
        delegate.foo(Integer.valueof(input));
    }
}

C类扩展了{
private final B delegate；//在构造函数中设置
公共void foo（字符串输入）{
//..将int转换为字符串
delegate.foo（Integer.valueof（input））；
}
}

这是不可能的

如果一个类是a

B

，那么它提供了一个

foo（Integer）

方法<代码>C不执行此操作，因此不能用作

B

试图在字里行间阅读，似乎你想要的是像a B一样的东西，除了它需要字符串而不是整数。在这种情况下，

A

是常见的键-对于任何合适的类型，您都需要使用

foo

方法。当您想要一个基于字符串的等价物

B

时，您实际上是在寻找

a

，而

C

可以完成这项工作

一个简单的定义可能是：

class C extends A<String> {
    private final B delegate;  // Set up in constructor or whatever

    public void foo(String input) {
        //.. convert int to string
        delegate.foo(Integer.valueof(input));
    }
}

C类扩展了{
private final B delegate；//在构造函数中设置
公共void foo（字符串输入）{
//..将int转换为字符串
delegate.foo（Integer.valueof（input））；
}
}

这是不可能的

如果一个类是a

B

，那么它提供了一个

foo（Integer）

方法<代码>C不执行此操作，因此不能用作

B

试图在字里行间阅读，似乎你想要的是像a B一样的东西，除了它需要字符串而不是整数。在这种情况下，

A

是常见的键-对于任何合适的类型，您都需要使用

foo

方法。当您想要一个基于字符串的等价物

B

时，您实际上是在寻找

a

，而

C

可以完成这项工作

一个简单的定义可能是：

class C extends A<String> {
    private final B delegate;  // Set up in constructor or whatever

    public void foo(String input) {
        //.. convert int to string
        delegate.foo(Integer.valueof(input));
    }
}

C类扩展了{
private final B delegate；//在构造函数中设置
公共void foo（字符串输入）{
//..将int转换为字符串
delegate.foo（Integer.valueof（input））；
}
}

进一步

class C extends B<String>

C类扩展了B类

不可能，因为

B

不接受参数

进一步

class C extends B<String>

C类扩展了B类

不可能，因为

B

不接受参数

进一步

class C extends B<String>

C类扩展了B类

不可能，因为

B

不接受参数

进一步

class C extends B<String>

C类扩展了B类

---

这是不可能的，因为

B

不带参数。

我不这么认为，但是那些更了解JLS的人可能会告诉您原因。但是

B

没有任何模板参数，

A

有。你能解释一下你想在那里做什么吗？现在，在编写时，您会遇到一个甚至两个错误，因为您实际上没有重写A的

foo

。请阅读“有界通配符”一节，了解这些通配符可能有助于您编写所需的代码，如果您不需要将

B

限制为

整数

，你可以让通用的

B

：

B类扩展A

，然后你可以用你想要的任何

T

扩展它。我不这么认为，但是那些更了解JLS的人可能会告诉你原因。但是

B

没有任何模板参数，

A

有。你能解释一下你想在那里做什么吗？现在，在编写时，您会遇到一个甚至两个错误，因为您实际上没有重写A的

foo

。请阅读“有界通配符”一节，了解这些通配符可能有助于您编写所需的代码，如果您不需要将

B

限制为

整数

，你可以让通用的

B

：

B类扩展A

，然后你可以用你想要的任何

T

扩展它。我不这么认为，但是那些更了解JLS的人可能会告诉你原因。但是

B

没有任何模板参数，

A

有。你能解释一下你想在那里做什么吗？现在，当您编写它时，您将得到一个甚至两个错误，因为您实际上没有重写A的