Why do generic types have the same signature?

Question

I have the following generic class:

class Or<A,B>
{
  Or (A a) {}
  Or (B b) {}
}

Why do I get the following error when I try to compile it:

Or(A) is already defined in Or
    Or (B b)
    ^

It seems to me that the two constructors share the same signature although they have different generic type arguments. Why? And how to work around this problem?

Update

I understood the problem now. The compiler needs a way to distinguish the two types. Adding such a constrain would be ok for my use case. So I would like to add another question:

How to specify that the two types A and B may be anything but different?

Answer 1

It seems to me that the two constructors share the same signature although they have different generic type arguments.

They do. The signature is

Or(Object o);

Why?

Because of type erasure implementation of generics in Java: references to generic types are converted to System.Object in all contexts where they are used; the generic type is known only to the compiler.

And how to work around this problem?

Unfortunately, you cannot easily work around this problem in a constructor. You can replace the overloaded constructors with factory methods, and give different names, say OrWithA and OrWithB:

// Hide the constructor
private Or(...) {
    ...
}
// Publish factory methods
public static <X> Or OrWithA(X a) {
    return new Or(...);
}
public static <X> Or OrWithB(X a) {
    return new Or(...);
}

Answer 2

They just do. That's the nature of generics; they provide syntatic sugar used only at compile time. There is no way round it.

(Acknowledge question comments) This is called type erasure: see http://en.wikipedia.org/wiki/Type_erasure

Answer 3

This is because A or B can be anything, they can be same also as generics is just for compile time. At runtime, they are lost due to type erasure

Answer 4

This is due to type erasure. The Eclipse compiler gives a more detailed error: Method Or(A) has the same erasure Or(Object) as another method in type Or

If you apply restrictions to the generics it compiles just fine:

class Or<A extends String, B extends Integer>
{
    Or(A a) {}

    Or(B b) {}
}

Answer 5

To say it differently: You have 2 types, A and B, and nothing is known about both of them. So one completely unknown type is as good as another one. How should the constructor calls be dispatched?

Answer 6

This is not legal, since generics are discarded at runtime (this is type erasure). Both of your methods would have a prototype of Or(Object).

The only solution would be to have a OrA() and OrB() method -- or review your class entirely.

Answer 7

That's because of a type erasure: generics are replaced with Object type on compilation, so your methods do have the same signature. As a workaound you may choose to narrow the types of A and B:

public class Test<A extends String, B extends Number> {

public Test(A arg){

}

public Test(B arg){

}
}

Answer 8

These constructors will be seen as having the same signatures since their types cannot be identified at runtime.

Try specifying a bounds on at least one of the type parameters if possible.

class Or<A extends Number,B>
{
  Or (A a) {}
  Or (B b) {}
}

Answer 9

1. Consider this, which constructor to call?

   Or<Integer,Integer> o = new Or<>(5);
   

2. Your problem really comes from Type erasure, it make your code look like this after compilation:

   class Or
   {
       Or (Object a) {}
       Or (Object b) {}
   }