如何在java中继续使用泛型

我有一个接口

public interface Doable<T,U> {
    public U doStuff(T t);
}

或

ConvertDoable扩展了AbstractDoable
<>代码> 如果你担心班级臃肿，考虑匿名类——按你所需要的“即时”定义的类：

public static void main(String[] args) {
    Doable<String, Integer> myDoable = new AbstractDoable<String, Integer>() {
        public Integer doStuff(String t) {
           return new Integer(t); // for example
        }
    }

    Integer i = myDoable.doStuff("0");
}

publicstaticvoidmain（字符串[]args）{
Doable myDoable=新的AbstractDoable（）{
公共整数doStuff（字符串t）{
返回新的整数（t）；//例如
}
}
整数i=myDoable.doStuff（“0”）；
}
<>代码> 如果你担心班级臃肿，考虑匿名类——按你所需要的“即时”定义的类：

public static void main(String[] args) {
    Doable<String, Integer> myDoable = new AbstractDoable<String, Integer>() {
        public Integer doStuff(String t) {
           return new Integer(t); // for example
        }
    }

    Integer i = myDoable.doStuff("0");
}

publicstaticvoidmain（字符串[]args）{
Doable myDoable=新的AbstractDoable（）{
公共整数doStuff（字符串t）{
返回新的整数（t）；//例如
}
}
整数i=myDoable.doStuff（“0”）；
}
您可以创建所需的
Doable
或
AbstractDoable
的任何子类。例如：

ConvertDoable<String,Integer> extends AbstractDoable

public class DoNothing implements Doable<String, String> {
    public String doStuff(String input) {
        return input;
    }
}

public类没有实现任何可行的{
公共字符串doStuff（字符串输入）{
返回输入；
}
}

或

公共类DoSomething扩展了AbstractDoable{
公共字符串doStuff（整数i）{
返回i.toString（）；
}
}

我不确定您的
someClass
成员在
AbstractDoable
中的目的是什么。你能解释一下它的用途吗？
你可以创建你想要的
Doable
或
AbstractDoable
的任何子类。例如：

ConvertDoable<String,Integer> extends AbstractDoable

public class DoNothing implements Doable<String, String> {
    public String doStuff(String input) {
        return input;
    }
}

public类没有实现任何可行的{
公共字符串doStuff（字符串输入）{
返回输入；
}
}

或

公共类DoSomething扩展了AbstractDoable{
公共字符串doStuff（整数i）{
返回i.toString（）；
}
}

我不确定您的
someClass
成员在
AbstractDoable
中的目的是什么。你能解释一下它的用途吗？
泛型的全部思想是创建一个支持所有类型类（或至少支持从类继承或实现接口的所有类）的单一类

同样在Java（字节码）中，say和

GenericClass<A,B> foo;

通用类foo；

及

通用类栏；

因此，您需要定义一个可以处理可能提供给它的所有不同对象的类。
泛型的全部思想是创建一个支持所有类型类（或至少支持从类继承或实现接口的所有类）的单个类

同样在Java（字节码）中，say和

GenericClass<A,B> foo;

通用类foo；

及

通用类栏；

因此，您需要定义一个类来处理可能提供给它的所有不同对象。
您的具体实现应该指定
AbstractDoable

public class ConvertDoable extends AbstractDoable<String,Integer>
{
    public Integer doStuff(String arg){...}
}

公共类ConvertDoable扩展了AbstractDoable
{
公共整数doStuff（字符串arg）{…}
}

或者继续传递参数化泛型：

public class ConvertDoable<T,U> extends AbstractDoable<T,U>
{
    public U doStuff(T arg){...}
}

公共类ConvertDoable扩展了AbstractDoable
{
公共U-doStuff（T-arg）{…}
}
您的具体实现应该指定
AbstractDoable

public class ConvertDoable extends AbstractDoable<String,Integer>
{
    public Integer doStuff(String arg){...}
}

公共类ConvertDoable扩展了AbstractDoable
{
公共整数doStuff（字符串arg）{…}
}

或者继续传递参数化泛型：

public class ConvertDoable<T,U> extends AbstractDoable<T,U>
{
    public U doStuff(T arg){...}
}

公共类ConvertDoable扩展了AbstractDoable
{
公共U-doStuff（T-arg）{…}
}
接口可行{
公共U-doStuff（T）；
}
抽象类AbstractDoable实现了Doable{
}
类ConvertDoableStringInteger扩展了AbstractDoable{
公共整数doStuff（字符串t）{
返回null；
}   
}
类ConvertDoableIntergerFloat扩展了AbstractDoable{
公共浮点数（整数t）{
返回0.0f；
}   
}
接口可行{
公共U-doStuff（T）；
}
抽象类AbstractDoable实现了Doable{
}
类ConvertDoableStringInteger扩展了AbstractDoable{
公共整数doStuff（字符串t）{
返回null；
}   
}
类ConvertDoableIntergerFloat扩展了AbstractDoable{
公共浮点数（整数t）{
返回0.0f；
}   
}
我可以这样做吗
公共类ConvertDoable扩展AbstractDoable{}@甘肃：不，你不能。字符串和整数都是
final
classes@Gansu：是的，应该可以。@Bohemian:这并不能阻止您使用
extends
表示法声明泛型类型-对于final类来说，这是没有意义的。您可能会收到编译器警告，但如果是错误，我会感到惊讶。也就是说，我自己没有试过，所以我很高兴被证明是错的。@Bohemian，@Cameron。。。我不会使用任何最后的类，这是一个例子。请考虑<代码>类1>代码> <代码>类2<代码>，而不是<代码>字符串< /代码>和<代码>整数< /代码>。但我知道这里不能使用期末班。。。谢谢你带来我喜欢的印加
公共类ConvertDoable扩展了AbstractDoable{}@甘肃：不，你不能。字符串和整数都是
final
classes@Gansu：是的，应该可以。@Bohemian:这并不能阻止您使用
extends
表示法声明泛型类型-对于final类来说，这是没有意义的。您可能会收到编译器警告，但如果是错误，我会感到惊讶。也就是说，我自己没有试过，所以我很高兴被证明是错的。@Bohemian，@Cameron。。。我不会使用任何最后的类，这是一个例子。请考虑<代码>类1>代码> <代码>类2<代码>，而不是<代码>字符串< /代码>和<代码>整数< /代码>。但我知道这里不能使用期末班。。。谢谢你带来了我希望它是具体的…不是在飞行中那么我的代码将在控制器中，而不是在实际的实现中…@甘肃：这仍然是具体的。疗法