How to solve "bad operand for binary operator '+' " when used with Generics?

here is my code :

class MyExample {

    public static <T,R> R myMethod(T x,R y){
        R z= x+y;// error occurs here
        
        return z;
    }

    public static void main(String args[])
    {
        Integer val = 10;
        String str="Hello World!";
        System.out.println(val+str);// this prints the expected result
        System.out.println(myMethod(10," Hello World!"));
    }

}

This code gives error:

> bad operand for binary operator +

When I concat val and str with + it works fine within the main block, But not inside the myMethod.

I don't understand why it happens.

Java does not support operator overloading. The operator + is defined on seven of the eight primitive types (char, byte, short, int, long, float and double), as well as on String.

The types T and R are unbounded, therefore they are erased with Object. Since + is not defined on Object, the compiler generates a compiler error.

System.out.println(val + str); works because the right side (str) of the expression is a String, hence the compiler tries to convert the left side (val) into a String. Every class (at least implicitly) inherits from Object, therefore every class has an instance method toString() that is used to convert its instances to Strings.

As many people point out already Java does not allow operator overloading so you are bound to use the generic method where + is define. T and R are erased with object meaning they are treated as object because the only common things between T and R are properties available in object, remember T and R for the compiler could be any arbitrary types.

The code below is not something i will suggest using, is more of a hack than anything else but it will let you compile, however is prone to many errors in runtime consider yourself warned

class MyExample {

    public static <T ,R > R myMethod(T x, R y){
        return (R) (x.toString() + y.toString());
    }
    public static void main(String args[])
    {
        Integer val = 10;
        String str="Hello World!";
        System.out.println(val+str);// this prints the expected result
        System.out.println(myMethod(10," Hello World!"));
        System.out.println(myMethod("Hello World!", 10));
    }
}

the way that works is by using one of the 8 types where + is defined. In the case above we are using String because any object has an string representation with the toString() method and then casting the type back to the return type R

Now I just to be completely clear the code posted here is just a hack to let you compile please do not use that code for any important code.

So to be honest I would recommend you to rather ask for the behavior you are trying to archive and not about how to fix your current solution since this will only lead to extremely advance code and who knows maybe you need something way simpler.