Question

在下面的程序中我传递了2种类型的参数uisng single方法。我得到“运算符+未定义参数类型T，K”，同时添加2个参数。

import java.util.*;
class Multipletypeparameters<T,K>{
    T obj1;
    K obj2;
    public void setting(T obj1,K obj2){
        this.obj1=obj1;
        this.obj2=obj2;
    }
    public T add(){
        //Here While adding I am getting The operator + is undefined for the argument type(s) T, K error
        return obj1 + obj2;
    }
}
public class MultipleTypeParametersExample {

    public static void main(String[] args) {
        MultipleTypeParametersExample<String,String> g1=new MultipleTypeParametersExample <String,String>();
        g1.setting("A","B");
        System.out.println(g1.add());

        MultipleTypeParametersExample <Integer,Integer> g2=new MultipleTypeParametersExample <Integer,Integer>();
        g2.setting(10,10);
        System.out.println(g2.add());
    }

}

Answer 1

您的问题与您将运算符+与对象一起使用这一事实有关，而编译器只能使用原始类型和/或String来理解它。

解决问题的一种方法是提出此操作的实现。

假设您使用Java 8，您的代码可能是这样的：

班级Multipletypeparameters

class Multipletypeparameters<T, K> {
    T obj1;
    K obj2;
    private final BiFunction<T, K, T> add;

    public Multipletypeparameters(BiFunction<T, K, T> add) {
        this.add = add;
    }
    public void setting(T obj1, K obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    public T add(){
        return add.apply(obj1, obj2);
    }
}

您的测试代码：

Multipletypeparameters<String, String> g1 = new Multipletypeparameters<>((a, b) -> a + b);
g1.setting("A", "B");
System.out.println(g1.add());

Multipletypeparameters<Integer, Integer> g2 = new Multipletypeparameters<>(
    (a, b) -> a + b
);
g2.setting(10, 10);
System.out.println(g2.add());

<强>输出：

AB
20

这种方法适用于Strategy pattern，它允许您在Runtime指定要使用的实现（采用的策略），但您也可以将此方法抽象化并提出将实现此方法的子类，如下：

abstract class Multipletypeparameters<T, K> {
    ...
    public abstract T add();
}

实施：

class MultipleStringparameters extends Multipletypeparameters<String, String> {

    @Override
    public String add() {
        return this.obj1 + this.obj2;
    }
}

class MultipleIntegerparameters extends Multipletypeparameters<Integer, Integer> {

    @Override
    public Integer add() {
        return this.obj1 + this.obj2;
    }
}

测试代码：

Multipletypeparameters<String, String> g1 = new MultipleStringparameters();
g1.setting("A", "B");
System.out.println(g1.add());

Multipletypeparameters <Integer, Integer> g2 = new MultipleIntegerparameters();
g2.setting(10, 10);
System.out.println(g2.add());

<强>输出：

AB
20

Answer 2

您的问题是您使用的是您不了解的语言元素！

你看，你宣布了

public T add(){
  return obj1 + obj2;
}

含义：该方法应该返回类型为T的对象。但是您的代码尝试在T和K对象上使用仅原始运算符+。那根本无法奏效。因为该运算符仅适用于原始类型;当然，即使它起作用，谁说你可以＆＃34;添加＆＃34;两个任意 T和K对象会产生一个类型为T的对象？！唯一可行的方法是：

public String asStrings(){
  return obj1.toString() + obj2.toString();
}

而你实际上想要添加数字;你必须考虑将你的泛型类型改为扩展 Number 的东西！然后你可以在它们上面调用intValue（）或doubleValue（）等方法。然后使用＆＃34; +＆＃34;再次成为可能。

Answer 3

您可以将add方法更改为此类似的方法。注意我已经将类更改为单个泛型类型，否则您需要添加更多选项以满足Integer，String组合，并且我不知道您为什么要添加不同类型。我发现这不是一个优雅的解决方案，你最好使用策略模式，你可以定义添加时执行的操作。

public class Example<T> {
    T obj1;
    T obj2;

    public void setting(T obj1,T obj2){
        this.obj1=obj1;
        this.obj2=obj2;
    }

    public T add(){
        if (obj1 instanceof String) {
            return (T) ((String) obj1 + (String) obj2);
        } else if (obj1 instanceof Integer) {
            return (T) ((Integer) ((Integer) obj1 + (Integer) obj2));
        } else {
            return null;
        }
    }
}

Answer 4

你想在“添加”方法中完全想要什么？我想如果你的obj是int你想要添加两个数字，或者你想要后缀字符串。总之，您应该检查对象我的意思是您必须使用instanceOf关键字。例如，obj1 instanceof String

使用java泛型添加两种类型的参数

4 个答案: