如何在java中继续使用泛型答案

【问题标题】：How to proceed using Generics in java如何在java中继续使用泛型
【发布时间】：2011-06-28 05:57:43
【问题描述】：

我有一个界面

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

我有一个实现Doable<T,U>的抽象类

public abstract class AbstractDoable<T,U> implements Doable<T, U> {
    private SomeClass someClass;

}

现在我需要实现上面的类，但是我需要为T和U使用不同的类。

请建议我应该如何进行此操作，因为我需要使用不同的T 和U 实现AbstractDoable 的多个实现。例如：

ConvertDoable<String,Integer> extends AbstractDoable

或

ConvertDoable<A,B> extends AbstractDoable

【问题讨论】：

我可以有这样的
public class ConvertDoable extends AbstractDoable {}
@Gansu：不，你不能。 String 和 Integer 都是 final 类
@Gansu：是的，应该可以。
@Bohemian：这并不能阻止您使用 extends 表示法声明泛型类型 - 在 final 类的情况下它只是有点没有意义。您可能会收到编译器警告，但如果这是一个错误，我会感到惊讶。也就是说，我自己没有尝试过，所以我很高兴被证明是错误的。
@Bohemian, @Cameron ...我不会使用任何最终类，这只是一个例子。请考虑Class1 和Class2 而不是String 和Integer。但是我知道最终类不能在这里使用...感谢您将其引入

标签： java generics inheritance implementation extends

【解决方案1】：

您可以根据需要创建Doable 或AbstractDoable 的任何子类。例如：

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

或

public class DoSomething extends AbstractDoable<Integer, String> {
    public String doStuff(Integer i) {
        return i.toString();
    }
}

我不确定someClass 成员在AbstractDoable 中的用途。你能解释一下它的用途吗？

【讨论】：

someClass 对于所有实现来说都是通用的，它是一种帮助类，将保存值以完成 doStuff 方法。
好的。那么好像不影响答案。

【解决方案2】：

如果您担心类膨胀，请考虑匿名类 - 根据需要“动态”定义的类：

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");
}

【讨论】：

我希望它是具体的......不是即时的，那么我的代码将在控制器中而不是在实际的实现中......
@Gansu：这仍然是具体的。 AbstractDoable 的具体实现恰好是一个匿名内部类。

【解决方案3】：

您的具体实现应该指定 AbstractDoable 上的类型

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

或继续传递参数化泛型：

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

【讨论】：

【解决方案4】：

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

abstract class AbstractDoable<T,U> implements Doable<T, U> {
}

class ConvertDoableStringInteger extends AbstractDoable<String, Integer>{
    public Integer doStuff(String t) {
        return null;
    }   
}

class ConvertDoableIntergerFloat extends AbstractDoable<Integer, Float> {
    public Float doStuff(Integer t) {
        return 0.0f;
    }   
}

【讨论】：

【解决方案5】：

关于泛型的整个想法是创建一个支持所有类型的类（或至少支持从类继承或实现接口的所有类）的单个类。

同样在Java（字节码）中说没有区别

GenericClass<A,B> foo;

和

GenericClass<C,D> bar;

因此，您需要定义一个类来处理可能赋予它的所有不同对象。

【讨论】：