如何在java中继续使用泛型

Question

我有一个接口

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

我有一个实现 Doable 的抽象类

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

Answer 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 中的用途是什么。你能解释一下它的用途吗？

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

Answer 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){...}
}

Answer 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;
    }   
}

Answer 5

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

You之间没有区别，

GenericClass<A,B> foo;

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

GenericClass<C,D> bar;

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