0

我有一个界面

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
4

5 回答 5

2

你可以创建任何你想要的子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。你能解释一下它的用途吗？

于 2011-06-28T06:06:24.217 回答
1

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

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");
}
于 2011-06-28T06:05:37.473 回答
1

您的具体实现应该指定类型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){...}
}
于 2011-06-28T06:06:51.830 回答
1 
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;
    }   
}
于 2011-06-28T06:10:06.670 回答
0

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

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

GenericClass<A,B> foo;

和

GenericClass<C,D> bar;

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

于 2011-06-28T06:06:32.823 回答