Java泛型类型

此代码不编译：

public class Calculadora<T> {
    T suma(T a, T b) {
        return (a + b);
    }
}

Calculadora<Integer> c = new Calculadora<Integer>();
System.out.println(c.suma(3, 5));

公共类Calculadora{
T suma（T a，T b）{
返回（a+b）；
}
}
Calculadora c=新Calculadora（）；
系统输出println（c.suma（3,5））；

这给了我一个错误

未为参数类型T，T定义运算符+

---

我怎样才能解决它呢？

T可以是任何类。它甚至可以是一个数组。无法确保“+”运算符对给定的类有效。

---

为什么要对计算器使用泛型？

T可以是任何类。它甚至可以是一个数组。无法确保“+”运算符对给定的类有效。

---

为什么还要对计算器使用泛型？

编译器不知道

T

的类型，因此

+

在某些情况下可能无效

但是，如果您希望使用泛型实现这一点，下面可以是一个解决方案：

public class Calculadora<T> {

    Double suma(T a, T b) {
        if (a instanceof Number && b instanceof Number) {
            return (Double.parseDouble(a.toString()) +  Double.parseDouble(b.toString()));
        }
        return 0d;
    }

}

公共类Calculadora{
双suma（ta，tb）{
if（a instanceof Number&&b instanceof Number）{
return（Double.parseDouble（a.toString（））+Double.parseDouble（b.toString（））；
}
返回0d；
}
}

---

必须重写

T

的

toString

方法以返回数字。

编译器不知道

T

的类型，因此

+

在某些情况下可能无效

但是，如果您希望使用泛型实现这一点，下面可以是一个解决方案：

public class Calculadora<T> {

    Double suma(T a, T b) {
        if (a instanceof Number && b instanceof Number) {
            return (Double.parseDouble(a.toString()) +  Double.parseDouble(b.toString()));
        }
        return 0d;
    }

}

公共类Calculadora{
双suma（ta，tb）{
if（a instanceof Number&&b instanceof Number）{
return（Double.parseDouble（a.toString（））+Double.parseDouble（b.toString（））；
}
返回0d；
}
}

---

您必须重写

T的
toString
方法以返回号码。
好的，您尝试实现的方法是不可能的。至少对我来说是这样。我不知道怎么解决它。但无论如何，我会尽力解释为什么会出现错误：

未为参数类型T，T定义运算符+

这仅仅意味着，
+
如何处理类型
T

嗯，当我们尝试做一些事情时，这是有意义的，比如：

Calculadora<Integer> c = new Calculadora<Integer>();

Calculadora<Cat> c = new Calculadora<Cat>();

//Limit only the Generics to subtypes of Number
class Calculadora<T extends Number> {

    //Return a specific type (Can be Double, Float, Long, etc.)
    Integer suma(T a, T b) {        
        //Change this based on your return type (Can be double, float, long, etc.)
        int sum = 0;
        if (a instanceof Number && b instanceof Number) {
            //Change this accordingly too (Can be doubleValue(), floatValue(), longValue(), etc.)
            sum = a.intValue() + b.intValue();
        }
        return sum;
    }
}

很明显，我们不知道你会如何用另一个
Cat
添加一个
Cat
。这就是为什么编译器会给你这个错误，它告诉你，我不知道如何把这个类型加在一起。我只能添加数字和字符串

希望这能有所帮助。：）

编辑2:

在我看来，如果你真的需要做这样的事情，你必须稍微改变你的类和方法声明，比如：

Calculadora<Integer> c = new Calculadora<Integer>();

Calculadora<Cat> c = new Calculadora<Cat>();

//Limit only the Generics to subtypes of Number
class Calculadora<T extends Number> {

    //Return a specific type (Can be Double, Float, Long, etc.)
    Integer suma(T a, T b) {        
        //Change this based on your return type (Can be double, float, long, etc.)
        int sum = 0;
        if (a instanceof Number && b instanceof Number) {
            //Change this accordingly too (Can be doubleValue(), floatValue(), longValue(), etc.)
            sum = a.intValue() + b.intValue();
        }
        return sum;
    }
}

//仅将泛型限制为Number的子类型
加尔各拉多拉类{
//返回特定类型（可以是双精度、浮点型、长型等）
整数suma（ta，tb）{
//根据您的返回类型（可以是双精度、浮动、长精度等）更改此选项
整数和=0；
if（a instanceof Number&&b instanceof Number）{
//也相应地更改此值（可以是doubleValue（）、floatValue（）、longValue（）等）
总和=a.intValue（）+b.intValue（）；
}
回报金额；
}
}

这仅适用于
整数
。如果需要，您可以将其更改为
Number
的任何子类型。
好的，您尝试实现的方法是不可能的。至少对我来说是这样。我不知道怎么解决它。但无论如何，我会尽力解释为什么会出现错误：

未为参数类型T，T定义运算符+

这仅仅意味着，
+
如何处理类型
T

嗯，当我们尝试做一些事情时，这是有意义的，比如：

Calculadora<Integer> c = new Calculadora<Integer>();

Calculadora<Cat> c = new Calculadora<Cat>();

//Limit only the Generics to subtypes of Number
class Calculadora<T extends Number> {

    //Return a specific type (Can be Double, Float, Long, etc.)
    Integer suma(T a, T b) {        
        //Change this based on your return type (Can be double, float, long, etc.)
        int sum = 0;
        if (a instanceof Number && b instanceof Number) {
            //Change this accordingly too (Can be doubleValue(), floatValue(), longValue(), etc.)
            sum = a.intValue() + b.intValue();
        }
        return sum;
    }
}

很明显，我们不知道你会如何用另一个
Cat
添加一个
Cat
。这就是为什么编译器会给你这个错误，它告诉你，我不知道如何把这个类型加在一起。我只能添加数字和字符串

希望这能有所帮助。：）

编辑2:

在我看来，如果你真的需要做这样的事情，你必须稍微改变你的类和方法声明，比如：

Calculadora<Integer> c = new Calculadora<Integer>();

Calculadora<Cat> c = new Calculadora<Cat>();

//Limit only the Generics to subtypes of Number
class Calculadora<T extends Number> {

    //Return a specific type (Can be Double, Float, Long, etc.)
    Integer suma(T a, T b) {        
        //Change this based on your return type (Can be double, float, long, etc.)
        int sum = 0;
        if (a instanceof Number && b instanceof Number) {
            //Change this accordingly too (Can be doubleValue(), floatValue(), longValue(), etc.)
            sum = a.intValue() + b.intValue();
        }
        return sum;
    }
}

//仅将泛型限制为Number的子类型
加尔各拉多拉类{
//返回特定类型（可以是双精度、浮点型、长型等）
整数suma（ta，tb）{
//根据您的返回类型（可以是双精度、浮动、长精度等）更改此选项
整数和=0；
if（a instanceof Number&&b instanceof Number）{
//也相应地更改此值（可以是doubleValue（）、floatValue（）、longValue（）等）
总和=a.intValue（）+b.intValue（）；
}
回报金额；
}
}

这仅适用于
整数
。如果需要，您可以将其更改为
Number
的任何子类型。
这看起来根本不像是该问题的重复。目标是增加，但是尝试的技术和随之而来的问题是完全不同的。这看起来根本不像这个问题的重复。目标是加法，但是尝试的技术和随之而来的问题是完全不同的。它会导致这个结果