Question

我有一个界面

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使用不同的类。

请建议我应该如何处理此问题，因为我需要对AbstractDoable和T以及U进行多次实施。例如：

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

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

同样在Java（字节码）中，说

之间没有区别

GenericClass<A,B> foo;

和

GenericClass<C,D> bar;

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

如何在java中继续使用Generics

5 个答案: