Java通用函数，用于对整数、双精度进行计算？

这可能吗？当然，如果您传入了一个double，任何将对象强制转换为整数的函数实现代码都将无法工作，除非专门使用强制转换“Integer”？我有一个类似于：

public static void increment(Object o){
    Integer one = (Integer)o;
    system.out.println(one++);
}

我看不出这怎么能成为双人间的通用？我试过了

public static <E> void increment(E obj){
    E one = (E)obj;
    system.out.println(one++);
}

公共静态无效增量（E obj）{
E one=（E）obj；
system.out.println（one++）；
}

---

但它不喜欢它？

如果你把它降到一个双人档怎么办

public static void increment(Object o) {
    Double d= (Double) o;
    System.out.println(d + 1.0);
}

更新：我尝试了这个方法，效果很好：

public static void increment(Object o) {
    Double d = Double.parseDouble(o.toString());
    System.out.println(d + 1.0);
}

---

您可能需要阅读高级专门语言通过跨类型算术定义的语义。我推荐的一个好例子是JSPEL规范

它基本上说明了如何实现这样的功能

---

在Java中，方法参数是按值传递的。因此，增加方法参数不会更改调用方的值。因此，必须返回新值：

double increment(double x) {
    return x + 1;
}

或传递包含以下值的引用类型：

class MutableDouble {
    double value;
}

void increment(MutableDouble d) {
    d.value++;
}

在Java中，类型参数必须是引用类型，因此double不是类型参数的有效值。如果需要原始类型，请考虑重载方法：

float increment(float f) {
    return f + 1;
}

double increment(double d) {
    return d + 1;
}

如果您确实想要泛型，可以执行以下操作：

@SuppressWarnings("unchecked")
<N extends Number> N increment(N n) {
    if (n instanceof Double) {
        return (N) (Double) (((Double)n) + 1);
    } else if (n instanceof Float) {
        return (N) (Float) (((Float)n) + 1);
    } else if ( ...
        // handle remaining cases
    } else if (n == null) {
        throw new NullPointerException();
    } else {
        throw new IllegalArgumentException("Unexpected number type: " + n.getClass());
    }
}

@SuppressWarnings（“未选中”）
N增量（N）{
if（n个双精度实例）{
返回（N）（双）（（双）N）+1；
}else if（n个浮点实例）{
返回（N）（浮动）（（浮动）N）+1；
}否则如果。。。
//处理余下的个案
}else if（n==null）{
抛出新的NullPointerException（）；
}否则{
抛出新的IllegalArgumentException（“意外的数字类型：+n.getClass（））；
}
}

这真是太难看了。你想通过定义这样一个方法来实现什么？也许有一个更简单的方法

public static double increment(double d)
{
  return d+1;
}

---

这将适用于所有基元值类型。然后，您只需强制转换结果；-）

假设您希望递增并获取新值（而不是更改不可变整数实例），您可以执行以下操作：

interface Arithmetics<T> {
    T inc(T val);
}

class IntegerArithmetics implements Arithmetics<Integer> {
    Integer inc(Integer val) { return val+1; }
}

//similarly DoubleArithmetics, BigIntegerArithmetics, ...

接口算法{
T公司（T val）；
}
类IntegerArithmetics实现算术{
整数inc（整数val）{return val+1；}
}
//类似地，双算术、双整数算术。。。

并调用它以获取您的方法：

public static <E> void increment(E obj, Arithmetics<E> arit){
    System.out.println(arit.inc(obj));
}

publicstaticvoidincrement（E-obj，Arithmetics-arit）{
系统输出打印（arit.inc（obj））；
}

图书馆正是为你们这样做的

---

唯一的问题是，您需要传递

算术

对象。如果这是一个大问题，您可以初始化一个

Map

，并使用

Map.get（obj.getClass（））

来获取相应的

算术

，然后如果将

整数

作为参数传递，那么它将失败。正如上面提到的，这是否意味着您不能对修改数据的操作使用泛型函数，仅显示/排序数据？我的第二个代码有效，不是吗？你想让它退货吗？Stephen的评论是关于第一个代码段的。我想要一个可以接受整数或双精度和增量的函数：）第二个代码会打印增量值，但实际上不会增加任何值。正如meriton和Tom Hawtin指出的，

Integer

、

Double

等类是不可变的，因此您必须使用递增的值返回一个新对象。无论如何，您不能递增

Integer

。您可以使用自动装箱/取消装箱。只要有足够的时间，我就可以编写一个方法，例如

公共静态数字递增（数字n）

返回与

n

参数传入的数字相同的子类。执行

公共静态编号添加（编号n1，编号n2）

无法保证实际的返回类型。