With generics, the return type is part of the method signature.

I recently came across this odd behaviour in Java. The JVM has always treated the return type as part of the signature but before Generics Java did not. Here is an example of where it does.

This was tested using Oracle JDK 6 update 23, OpenJDK 6 update 20, and IBM's JDK R9 2.4. Apparently Java 5.0 update 22 doesn't not compile this code, but given Java 5.0 is EOL, I would have hoped Java 6 would have the correct behaviour.

public class Main {
    public static void main(String... args) {
        Main.<Integer>print();
        Main.<Short>print();
        Main.<Byte>print();
        Main.<Void>print();
    }

    public static <T extends Integer> int print() {
        System.out.println("here - Integer");
        return 0;
    }
    public static <T extends Short> short print() {
        System.out.println("here - Short");
        return 0;
    }
    public static <T extends Byte> byte print() {
        System.out.println("here - Byte");
        return 0;
    }
    public static <T extends Void> void print() {
        System.out.println("here - Void");
    }
}

Prints

here - Integer
here - Short
here - Byte
here - Void

Note: all these print() methods have the same method name and parameters after erasure, but importantly they have different return types and the JVM can distiguish them based on that. If you make the return types the same, the program will not compile.

I was sceptical that this would compile at first and wanted to look at the compiled byte code.

$ javap -classpath . -c Main
Compiled from "Main.java"
public class Main extends java.lang.Object{
public Main();
  Code:
   0: aload_0
   1: invokespecial #1; //Method java/lang/Object."":()V
   4: return

public static void main(java.lang.String[]);
  Code:
   0: invokestatic #2; //Method print:()I
   3: pop
   4: invokestatic #3; //Method print:()S
   7: pop
   8: invokestatic #4; //Method print:()B
   11: pop
   12: invokestatic #5; //Method print:()V
   15: return

public static int print();
  Code:
   0: getstatic #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   3: ldc #7; //String here - Integer
   5: invokevirtual #8; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8: iconst_0
   9: ireturn

public static short print();
  Code:
   0: getstatic #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   3: ldc #9; //String here - Short
   5: invokevirtual #8; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8: iconst_0
   9: ireturn

public static byte print();
  Code:
   0: getstatic #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   3: ldc #10; //String here - Byte
   5: invokevirtual #8; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8: iconst_0
   9: ireturn

public static void print();
  Code:
   0: getstatic #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   3: ldc #11; //String here - Void
   5: invokevirtual #8; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8: return

}

Update

This doesn't compile with Oracle Java 7. You get an error

    Error:Error:line (20)error: name clash: print() and print() have the same erasure
where T#1,T#2 are type-variables:
T#1 extends Short declared in method print()
T#2 extends Integer declared in method print()