Überschreiben von Methoden

[tanechka]

Hallo,
ich habe Frage zum Thema "Covariant returns" beim Überschreiben von den Methoden. Ich habe ein Beispiel, was ich nicht nachvollziehen kann:

class Parent {
    Integer get() {
        return 1;
    }
}

class Child extends Parent {
    Number get() {
        return 2;
    }
}

public class Test {
    public static void main(String[] args) {
        Parent yo = new Child();
        System.out.println(yo.get());
    }
}

Es gibt einen Kompilierungsfehler in diesem Fall. Obwohl Integer ein Subclass von Number ist. Genauso wie hier auch:

class Parent {
    Number get() {
        return 1;
    }
}

class Child extends Parent {
    Integer get() {
        return 2;
    }
}

public class Test {
    public static void main(String[] args) {
        Parent yo = new Child();
        System.out.println(yo.get());
    }
}

Könntet ihr mir bitte helfen, die Regeln dafür zu verstehen?

 

[kaoZ]

Wie und woher kommst du darauf das Number eine Subklasse von Integer ist ?

Das hier wäre korrekt

public class Parent{
	
	public int get(){
		return 1;
	}
}

class Children extends Parent{
	
	@Override
	public int get(){
		return 2;
	}
}

zudem sollte das Überschreiben von Methoden mit der @Override Annotation gekennzeichnet werden damit man nicht ausversehen eine Bestehende Methode überlädt.

 

[tanechka]

Number ist eine abstrakte Klasse und die ist die Superklasse von Integer. Aufgrunddessen habe ich mir gedacht, das wäre auch "covariante return" für die Klasse.

 

[kaoZ]

Dann sehe das ganze aber so aus , nicht wie in deinem Beispiel

public class Parent{
	
	Number get(){
		return 1;
	}
}

class Children extends Parent{
	
	@Override
	Integer get(){
		return 2;
	}
}

ungetestet.

Das hier funktioniert fehlerfrei übrigends

public class Parent{
	
	Number get(){
		return 1;
	}
	
	public static void main(String[] args){
		Parent p = new Parent();
		System.out.println(p.get());
		
		Children c = new Children();
		System.out.println(c.get());
	}
}

class Children extends Parent{
	
	@Override
	Integer get(){
		return 2;
	}
}

Du kannst einfach keinen Supertyp als Rückgabe deklarieren wenn du in der Superklasse schon mit einer Subklasse arbeitest.

 

[tanechka]

ja, das wird kompiliert. Nur dieses Beispiel wird nicht kompilieren:

    class Parent {
    Integer get() {
    return 1;
    }
    }
     
    class Child extends Parent {
    Number get() {
    return 2;
    }
    }
     
    public class Test {
    public static void main(String[] args) {
    Parent yo = new Child();
    System.out.println(yo.get());
    }
    }

return parameter von dem Subclass soll wahrscheinlich der Subclass von dem Superclass return type.

 

[Natac]

Es wird daher nicht kompiliert, da nicht nur Integer eine Number ist, sondern bspw. auch Double.

In der Superklasse steht aber, dass get() einen Integer zurückgibt. Darum kann die Kindklasse nicht anfangen, das zu verallgemeinern.

Folgends geht ja auch nicht (vielleicht ist das offensichtlicher):

class Parent {
   Integer get() {return 1;}
}
class Child extends Parent {
    Object get() {return 2;}
}

Ist die Superklasse hingegen schon allgemein (bspw: Number), so kann die Kindklasse da gerne konkreter werden (bspw. Integer), da damit die Signatur ja nicht verletzt wird.

 

[arilou]

Lieber tanechka, Deine Fragestellung ist missverständlich. Dein zweite Beispiel funktioniert ja durchaus.