Qu'est-ce qu'un type de retour covariant?

Question

Qu'est-ce qu'un type de retour covariant en Java? Dans la programmation orientée objet en général?

Answer 1

covariante retour, signifie que, quand on l'emporte sur un procédé, le type de retour de la méthode absolue est autorisé à être un sous-type de type de retour de la méthode substituée.

, une affaire commune Afin de clarifier cela par un exemple est Object.clone() - qui est déclarée renvoyer un type de Object. Vous pouvez remplacer dans votre propre classe comme suit:

public class MyFoo
{

   ...

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

L'avantage ici est que toute méthode qui contient une référence explicite à un objet MyFoo sera en mesure d'invoquer clone() et savoir (sans coulée) que la valeur de retour est une instance de MyFoo. Sans types de retour covariants, la méthode surchargée dans MyFoo devrait être déclaré retourner Object - et donc le code appelant aurait explicitement transtyper le résultat de l'appel de méthode (même la pensée des deux côtés « savent » il ne peut jamais être une instance de MyFoo).

Notez que sur les clone() il n'y a rien de spécial et que toute méthode surchargée peut avoir un retour covariant -. Je l'ai utilisé comme un exemple ici car il est une méthode standard lorsque cela est souvent utile

Answer 2

Voici un autre exemple simple:

classe Animal

public class Animal {

    protected Food seekFood() {

        return new Food();
    }
}

classe Dog

public class Dog extends Animal {

    @Override
    protected Food seekFood() {

        return new DogFood();
    }
}

Il est possible de modifier le type de retour de la méthode de Dog du seekFood() à DogFood - une sous-classe de Food, comme indiqué ci-dessous:

@Override
protected DogFood seekFood() {

    return new DogFood();
}

C'est tout à fait une dominante juridique, et le type de retour de la méthode de Dog de seekFood() est connu comme type de retour covariant .

Answer 3

De la sortie de JDK 1.5, types covariantes ont été introduits en Java. et je vais vous l'expliquer avec un cas simple,: Lorsque nous remplaçons une fonction la fonction est autorisée à apporter des modifications à son comportement c'est ce que vous obtenez à lire dans la plupart des livres, mais ce ils {} auteurs manquer sur est que nous pouvons changer le type de retour aussi. vérifier lien ci-dessous des précisions aussi longtemps qu'il peut être affecté à retourner le type de la version de base de la méthode que nous pouvons changer le type de retour.

Cette fonction de retour types dérivés est appelé Covariant ...

Peut méthodes diffèrent de substitution type de retour?

Answer 4

types de retour covariants signifie simplement retourner propre référence de classe ou sa référence de classe enfant.

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

covariante type de retour indique que le type de retour peut varier dans le même sens que la sous-classe

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();  
}  
}

Avant de Java 5, il n'a pas été possible override toute méthode en changeant le type de retour. Mais maintenant, depuis Java5,

il est possible de remplacer la méthode en changeant le type de retour si la sous-classe remplace toute méthode dont le type de retour est non primitif mais il change de type de retour au type de sous-classe.

Answer 6

• Il permet d'éviter le type de confusion présente dans des moulages la hiérarchie des classes et rendant ainsi le code lisible, utilisable et maintenable.

• Nous obtenons une liberté d'avoir des types de retour plus précis lors de la substitution
  méthodes.

• Aide à prévenir ClassCastExceptions d'exécution sur le rendement

Référence: www.geeksforgeeks.org

Answer 7

  

  
• Le type de retour covariant en Java, permet rétrécissement type de retour   de la méthode substituée.
  
• Cette fonction permettra d'éviter la coulée vers le bas   sur le côté client. Il permet programmeur de programme, sans   de vérification de type et renversons.
  
• Le type de retour covariant toujours   ne fonctionne que pour les types de retour non primitifs.
  

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();
    }
}

  

Autre exemple est de 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

Avant Java5, il n'a pas été possible de passer outre toute méthode en changeant le type de retour. Mais maintenant, depuis Java5, il est possible de remplacer la méthode en changeant le type de retour si la sous-classe l'emporte sur toute méthode dont le type de retour est non primitif, mais il change de type de retour au type de sous-classe.