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

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

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

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

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

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

解决方法

问题是 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));
}

当需要使用 StackArrayList 的具体实现初始化您的 Number 时，您只需通过方法引用将实现的 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);
    }

}

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

变量不需要在内吗？

没有。 <>（称为菱形运算符）用于将特定类型推断为采用“通用”类型的类（您可以阅读 more about generics）。

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

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

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

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

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

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

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

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

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

如果你检查 StackArrayList 的新构造函数，我已经添加了一个成员，它是 private final SumPerformer<N> sumPerformer;。

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

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

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

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

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

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

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

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

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

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

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

解决方法

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

相关推荐