如何让我的代码与泛型一起工作？

Question

我目前正在学习泛型，首先我制作了一个类，它用整数制作了一个 stackArrayList，之后我希望它被每个数字使用，所以我确实把数字放在方法的任何地方，它有点工作，但我认为这个不是安静正确，我最大的问题是我不能对班级编号使用任何加法或减法。

因此，我尝试实现 N extends Number 但这也不起作用，因此我什至不能将从 Method pop() 返回的 Number 放入变量中，告诉我 pop() 必须返回一个 int 然后。

有人可以向我解释一下，我在那里做了什么吗？ 我能理解它背后的逻辑，但不能完全理解它。

public class StackArrayList<N extends Number> {

    private ArrayList<N> stackList = new ArrayList<>();
    
    
    
    public void push (N value) {
        if(value == null) {
            System.out.println("value null not allowed");
            return;
        }
        stackList.add(0,value);
        
    }
    public N pop() {
        N popInt = stackList.get(0);
        stackList.remove(0);
        return popInt;
    }
    public N addFirstTwo() {
        if(stackList.size()==1) {
            return stackList.get(0);
        }
        if (stackList.size() == 0) {return null;}
        
        
        if(stackList.get(0) instanceof Integer) {
            N summe;
            summe = 
            push(summe);
            return summe;
        }else if(stackList.get(0) instanceof Double){
            summe = pop().doubleValue()+pop().doubleValue();
            push(summe);
            return summe;
        }else if(stackList.get(0) instanceof Float){
            summe = pop().floatValue()+pop().floatValue();
            push(summe);
            return summe;
        }else if(stackList.get(0) instanceof Long){
            summe = pop().longValue()+pop().longValue();
            push(summe);
            return summe;
        }
        
        push(summe);
        return summe;
    }
    
}

Answer 1

问题是Number不支持+运算符，即使它的所有实现（ Double 、 Float等）都支持它。

您可以做的是为您的类定义一个内部接口，该接口公开一个sum方法：

interface SumPerformer<N> {
    N sum(N n1, N n2);
}

然后，您将在StackArrayList<N extends Number>类中声明一个字段，该类包含此接口的实现：

private final SumPerformer<N> sumPerformer;

因此，您将使用此实现返回addFirstTwo()方法中前两个数字的总和：

public N addFirstTwo() {
    if (stackList.isEmpty()) {
        return null;
    }
    if (stackList.size() == 1) {
        return stackList.get(0);
    }
    return sumPerformer.sum(stackList.get(0), stackList.get(1));
}

当需要使用Number的具体实现初始化StackArrayList时，您只需通过方法引用将实现的sum传递给它：

    StackArrayList<Double> stackArrayListDoubles = new StackArrayList<>(Double::sum);
    StackArrayList<Long> stackArrayListLongs = new StackArrayList<>(Long::sum);
    StackArrayList<Integer> stackArrayListInts = new StackArrayList<>(Integer::sum);

---

完整代码：

public static final class StackArrayList<N extends Number> {

    private final List<N> stackList = new ArrayList<>();
    private final SumPerformer<N> sumPerformer;

    public StackArrayList(SumPerformer<N> sumPerformer) {
        this.sumPerformer = sumPerformer;
    }

    public N pop() {
        N popInt = stackList.get(0);
        stackList.remove(0);
        return popInt;
    }

    public void push(N value) {
        if (value == null) {
            System.out.println("value null not allowed");
            return;
        }
        stackList.add(0, value);

    }

    public N addFirstTwo() {
        if (stackList.isEmpty()) {
            return null;
        }
        if (stackList.size() == 1) {
            return stackList.get(0);
        }
        N sum = sumPerformer.sum(stackList.get(0), stackList.get(1));
        push(sum);
        return sum;
    }

    interface SumPerformer<N> {
        N sum(N n1, N n2);
    }

}

对评论中提出的问题的回答

变量不需要在 <> 内吗？

不。 <> （称为菱形运算符）用于将特定类型推断为采用“泛型”类型的类（您可以阅读 有关泛型的更多信息）。

在 Java 8 之前，您需要在变量的声明和实例化中指定类型。 例如，接口List<T>由类ArrayList<T> 。

在 Java 8 之前，如果您想要一个Integer列表，您需要执行以下操作：

List<Integer> list = new ArrayList<Integer>();

在 Java 8 之后，您可以简单地声明：

List<Integer> list = new ArrayList<>();

实际上，类型Integer将通过声明List<Integer>推断为ArrayList 。

这就是为什么当我初始化我的StackArrayList<> ，我没有将Double传递给它，因为我已经将它传递给了声明，所以变量已经知道它的类型是什么。

它不应该只是传递我用它初始化对象的数字吗？

小心，你把东西弄混了。 上面解释了为什么不应该通过Double的原因。 但是，在这里我正在做其他事情。

如果您检查StackArrayList的新构造StackArrayList ，我添加了一个成员，它是private final SumPerformer<N> sumPerformer; .

这个成员是final ，这意味着它应该在你初始化类时被初始化，我通过将它传递给构造函数来实现。

但是我传递给构造函数的是什么？ 我正在传递我定义的抽象接口的具体实现。

具体来说，我已经声明了接口SumPerformer<N>只公开一个称为sum方法，返回一个N并接受输入两个不同的N 。

因此，该接口的具体实现应该是具有相同签名的方法。

而这个方法，是所有Number孩子（ Double ， Integer ...）的sum()方法

如果你进入类Double ，你会看到有这个方法：

public static double sum(double a, double b) {
    return a + b;
}

当类型N extends Number是Double时，上述方法的签名与您的接口匹配。

因此，在您的课程中，您只需调用接口.sum()来总结您的两个数字，并将实现细节（基本上是a + b ）留给具体实现，这不是由您完成的，而是由 Java 完成的本身在扩展Number的 JDK 类中。