Qu'est-ce qu'un type de retour covariant?
Qu'est-ce qu'un type de retour covariant en Java? En programmation orientée objet en général?
Retour covariant, cela signifie que lorsque l'on substitue une méthode, le type de retour de la méthode de substitution est autorisé à être un sous-type du type de retour de la méthode remplacée.
Pour clarifier cela avec un exemple, un cas courant est Object.clone() - qui est déclaré comme renvoyant un type de Object. Vous pouvez remplacer ceci 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 capable d'appeler clone() et de savoir (sans transtypage) que la valeur de retour est une instance de MyFoo. Sans les types de retour covariants, la méthode surchargée dans MyFoo devrait être déclarée pour renvoyer Object - et le code appelant devrait donc explicitement convertir le résultat de l'appel de la méthode (même si les deux parties le savent) MyFoo).
Notez que clone() n'a rien de spécial et que toute méthode substituée peut avoir un retour covariant - je l'ai utilisé à titre d'exemple ici car c'est une méthode standard où cela est souvent utile.
Voici un autre exemple simple:
Animal classe
public class Animal {
protected Food seekFood() {
return new Food();
}
}
Dog classe
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 Dog ’s seekFood() en DogFood - une sous-classe de Food, comme indiqué ci-dessous:
@Override
protected DogFood seekFood() {
return new DogFood();
}
C’est parfaitement une solution légale, et le type de résultat de la méthode Dog ’s seekFood() est appelé type de retour covariant .
Depuis la sortie de JDK 1.5, les types covariants ont été introduits en Java. et je vous expliquerai cela avec un cas simple,: Lorsque nous remplaçons une fonction, celle-ci est autorisée à modifier son comportement, ce que vous pouvez lire dans la plupart des livres, mais ce qu'ils {auteurs } rater est que nous pouvons aussi changer le type de retour. Vérifiez le lien ci-dessous pour plus de précisions, nous pouvons changer le type de retour tant qu'il peut être affecté au type de retour de la version de base de la méthode.
Donc, cette fonctionnalité de retour des types dérivés s'appelle COVARIANT ...
Les méthodes substituées peuvent-elles différer en type de retour?
types de retour covariant signifie simplement renvoyer sa 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();
}
}
Le type de retour covariant spécifie 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 Java 5, il n'était pas possible de remplacer une méthode .__ en modifiant le type de retour. Mais maintenant, depuis Java5,
il est possible de remplacer une méthode en modifiant le type de retour si la sous-classe remplace toute méthode dont le type de retour est Non-primitif
- Cela permet d’éviter la confusion des transformations typographiques présentes dans la hiérarchie de classes Et ainsi de rendre le code lisible, utilisable et maintenable.
Nous obtenons la liberté d’avoir des types de retour plus spécifiques lors du remplacement
méthodes.Aide pour empêcher les ClassCastExceptions au moment de l'exécution sur les retours
référence: www.geeksforgeeks.org
- Le type de retour covariant en Java permet de réduire le type de retour de la méthode substituée.
- Cette fonctionnalité aidera à éviter le casting côté client. Il permet au programmeur de programmer sans avoir besoin de de vérification de type et de coulée.
- 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();
}
}
Un autre exemple vient 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;
}
}
Fonction.Java
@FunctionalInterface
public interface Function<T, R> {
........
........
........
........
static <T> Function<T, T> identity() {
return t -> t;
}
}
Avant Java5, il n'était pas possible de remplacer une méthode en modifiant le type de retour. Mais maintenant, depuis Java5, il est possible de remplacer une méthode en modifiant le type de retour si la sous-classe redéfinit toute méthode dont le type de retour est Non-Primitif, mais son type de retour est remplacé par le type de sous-classe.