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



## Thomas Darimont (3. August 2008)

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

Gerade ist mir dieser Artikel untergekommen:
http://today.java.net/pub/a/today/2008/07/31/return-type-based-method-overloading.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/247624-bridge-methods.html
Beispiel:

```
/**
 * 
 */
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:

```
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)

```
/**
 * 
 */
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:

```
4711
1234
3.141592653589793
3.141592653589793
```

Gruß Tom


----------



## Oliver Gierke (3. August 2008)

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!


----------

