Methoden überladen / überschreiben auf Basis eines unterschiedlichen Return types.

Gerade ist mir dieser Artikel untergekommen:
http://today.java.net/pub/a/today/20...erloading.html
Hier wird gezeigt wie man (mit ein wenig Aufwand) mehrere Methoden mit den gleichen Parametertypen aber unterschiedlicher Return-Typen angeben kann.

Unter der Haube macht der Java Compiler einen ahnlichen Trick generische Methoden bei der Implementierung passend zu typen,
in dem sogenannte Bridge Methods eingefügt werden.
http://www.tutorials.de/forum/java/2...e-methods.html
Beispiel:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

/**  *  */ package de.tutorials;   import java.lang.reflect.Method;   /**  * @author Tom  *  */ public class BridgeMethodExample {       /**      * @param args      */     public static void main(String[] args) {         for(Method method : Foo.class.getDeclaredMethods()){             System.out.printf("Method: %s is synthetic: %s / is bridge: %s \n", method.toString(),method.isSynthetic(),method.isBridge());         }     }         static interface IFoo<T>{         T op();     }         static class Foo implements IFoo<Integer>{         @Override         public Integer op() {             return null;         }     } }

Ausgabe:

Code :

1 2	Method: public java.lang.Integer de.tutorials.BridgeMethodExample$Foo.op() is synthetic: false / is bridge: false Method: public java.lang.Object de.tutorials.BridgeMethodExample$Foo.op() is synthetic: true / is bridge: true

Hier ein Beispiel wie man Methoden mit unterschiedlichen Return Types überschreiben kann:
(Das geht seit Java 5. Der Return Typ der überschreibenden Methode muss ein zu dem Return Type der
überschriebenen Methode kompatibel sein)

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

/**  *  */ package de.tutorials;   /**  * @author Tom  *  */ public class ReturnTypeCovariance {       /**      * @param args      */     public static void main(String[] args) {         System.out.println(new A().op());         System.out.println(new B().op());         System.out.println(new C().op());         A a = new C();         System.out.println(a.op());     }         static class A{         Number op(){             return 4711;         }     }         static class B extends A{         @Override         Long op(){             return 1234L;         }     }         static class C extends A{         @Override         Double op(){             return Math.PI;         }     } }

Ausgabe:

Code :

1 2 3 4

4711 1234 3.141592653589793 3.141592653589793

Gruß Tom

Jo, das funktioniert, solang die Rückgabetypen der überschreibenden Methoden Subklassen des definierten Rückgabetyps sind. Man spart sich dadurch in vielen Fällen den cast auf einen konkreten Typ, wenn der Supertyp schon eine Methode deklariert hat die einen recht abstrakten Rückgabetyp hat.

REINHAUN!