Was ist ein kovarianten Rückgabetyp?

Question

Was ist ein kovariante Rückgabetyp in Java? In der objektorientierten Programmierung im Allgemeinen?

Answer 1

Covariant Gegenzug bedeutet, dass, wenn man ein Verfahren außer Kraft setzt, wird der Rückgabetyp des übergeordneten Verfahrens erlaubt ein Untertyp von der überschriebenen Methode des Rückgabetypen sein.

Um dies an einem Beispiel zu verdeutlichen, ein häufiger Fall ist Object.clone() - was erklärt, ist eine Art von Object zurückzukehren. Sie könnten dies in der eigenen Klasse überschreiben, wie folgt:

public class MyFoo
{

   ...

   // Note covariant return here, method does not just return Object
   public MyFoo clone()
   {
       // Implementation
   }
}

Der Vorteil hierbei ist, dass jedes Verfahren, das eine ausdrückliche Bezugnahme auf eine MyFoo Objekt hält in der Lage, clone() aufrufen und wissen (ohne Guss), dass der Rückgabewert eine Instanz von MyFoo ist. Ohne kovarianten Rückgabetypen, würde die überschriebene Methode in MyFoo haben erklärt werden Object zurückzukehren - und so Code aufrufen würde das Ergebnis des Methodenaufruf explizit niedergeschlagenen (auch gedacht beide Seiten „wissen“, es kann immer nur eine Instanz sein MyFoo).

Beachten Sie, dass es nichts Besonderes clone() und dass jede überschriebene Methode eine kovariante Rückkehr haben kann -. Ich kann es als Beispiel hier, wie es eine Standardmethode ist, wo diese oft nützlich ist,

Answer 2

Hier ist ein weiteres einfaches Beispiel:

Animal Klasse

public class Animal {

    protected Food seekFood() {

        return new Food();
    }
}

Dog Klasse

public class Dog extends Animal {

    @Override
    protected Food seekFood() {

        return new DogFood();
    }
}

Es ist möglich, den Rückgabetyp des Dog des seekFood() Verfahrens zu modifizieren, um DogFood - eine Unterklasse von Food, wie unten dargestellt:

@Override
protected DogFood seekFood() {

    return new DogFood();
}

Das ist vollkommen gesetzlich zwingender, und der Rückgabetyp von Dog Methode des seekFood() ist bekannt als kovarianten Rückgabetyp .

Answer 3

Von der Veröffentlichung von JDK 1.5 wurden covariant Typen in Java eingeführt. und ich werde es Ihnen mit einem einfachen Fall erklären,: Wenn wir eine Funktion außer Kraft setzen die Funktion erlaubt ist, Änderungen vorzunehmen, um es Verhalten ist das ist, was Sie in den meisten der Bücher zu lesen, aber was sie {Autoren} verpassen ist, dass wir den Rückgabetyp zu ändern. überprüft Link unten zur Klärung können wir den Rückgabetyp ändern, solange es zugeordnet werden kann Art von Basisversion des Verfahrens zurückzukehren.

So diese Funktion abgeleitete Arten von Rückkehr heißt kovariante ...

Kann Methoden Rückgabetyp überschrieben unterscheiden?

Answer 4

kovarianten Rückgabetypen bedeuten einfach eigene Klasse Referenz oder deren Kindklassenreferenz zurück.

class Parent {
 //it contain data member and data method
}

class Child extends Parent { 
//it contain data member and data method
 //covariant return
  public Parent methodName() {
     return new Parent();
          or 
     return Child();
  }

}

Answer 5

Covariant Rückgabetyp gibt an, dass der Rückgabetyp in der gleichen Richtung wie die Unterklasse variiert

class One{  
    One get(){return this;}  
}  

class Two extends One{  
  Two get(){return this;}  

void message(){
  System.out.println("After Java5 welcome to covariant return type");
}  

public static void main(String args[]){  
    new Two().get().message();  
}  
}

Vor Java 5, war es nicht möglich, überschreibt jede Methode durch den Rückgabetyp ändern. Aber jetzt, da Java5,

ist es möglich Methode außer Kraft setzen, indem Sie den Rückgabetyp zu ändern wenn Unterklasse überschreibt jede Methode deren Rückgabetyp ist Non-Primitive aber es ändert seine Rückkehr Typ Unterklasse-Typ.

Answer 6

• Es hilft verwirrende Art zu vermeiden, wirft in der Klassenhierarchie und wodurch der Code lesbar, verwendbar und wartbar.

• Wir bekommen eine Freiheit spezifischere Rückgabetypen zu haben, wenn
  zwingende Methoden.

• Hilfe der Laufzeit auf Classcastexceptions kehrt zu verhindern

Referenz: www.geeksforgeeks.org

Answer 7

  

  
• Der kovariante Rückgabetyp in Java, Rückgabetyp ermöglicht die Eingrenzung   die überschriebenen Methode.
  
• Diese Funktion wird dazu beitragen, Gießen zu vermeiden unten   auf der Client-Seite. Es ermöglicht Programmierer Programm ohne die Notwendigkeit   der Typprüfung und unten Guss.
  
• Der kovariante Rückgabetyp immer   funktioniert nur für nicht-primitive Rückgabetypen.
  

interface Interviewer {
    default Object submitInterviewStatus() {
        System.out.println("Interviewer:Accept");
        return "Interviewer:Accept";
    }
}
class Manager implements Interviewer {
    @Override
    public String submitInterviewStatus() {
        System.out.println("Manager:Accept");
        return "Manager:Accept";
    }
}
class Project {
    public static void main(String args[]) {
        Interviewer interviewer = new Manager();
        interviewer.submitInterviewStatus();
        Manager mgr = new Manager();
        mgr.submitInterviewStatus();
    }
}

  

Ein anderes Beispiel ist aus Java,

UnaryOperator.java

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    /**
     * Returns a unary operator that always returns its input argument.
     *
     * @param <T> the type of the input and output of the operator
     * @return a unary operator that always returns its input argument
     */
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

Function.java

@FunctionalInterface
public interface Function<T, R> {

    ........
    ........
    ........
    ........

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Answer 8

Vor Java5, war es nicht möglich, jede Methode außer Kraft setzen, indem Sie den Rückgabetyp ändern. Aber jetzt, da Java5 ist es möglich, Verfahren außer Kraft zu setzen, indem Sie den Rückgabetyp ändern, wenn Unterklasse jede Methode überschreibt, dessen Rückgabetyp ist ein Nicht Primitive, aber es ändert seine Rückkehr Typ Unterklasse-Typen.