Qu'est-ce qu'un type de retour covariant?
7 réponses
Covariant retour, signifie que lorsque l'on remplace une méthode, le type de retour de la méthode de remplacement est autorisé à être un sous-type de la méthode de remplacement du type de retour.
Pour clarifier cela avec un exemple, un cas courant est Object.clone() - qui est déclarée pour retourner un type de Object . Vous pourriez 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 détient une référence explicite à un L'objet MyFoo pourra invoquer clone() et savoir (sans lancer) que la valeur de retour est une instance de MyFoo . Sans les types de retour covariants, la méthode overridden dans MyFoo devrait être déclarée pour retourner Object - et donc le code appelant devrait explicitement downcast le résultat de l'appel de méthode (même si les deux parties "savent" qu'il ne peut être qu'une instance de MyFoo).
notez qu'il n'y a rien de spécial dans clone() et que toute méthode outrepassée peut avoir un retour covariant - Je l'ai utilisé comme 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();
}
qui est parfaitement un passe-partout légal, et le type de retour de la méthode Dog ’s seekFood() est connu sous le nom de covariant return type .
de la version de JDK 1.5, les types covariants ont été introduits en Java. et je vais vous l'expliquer avec un cas simple,: quand nous outrepassons une fonction la fonction est autorisée à apporter des changements à son comportement c'est ce que vous obtenez à lire dans la plupart des livres, mais ce qu'ils { auteurs } manquer est que nous pouvons changer le type de retour aussi. nous pouvons changer le type de retour aussi longtemps qu'il peut être assigné au type de retour de la Base version de la méthode.
Cette caractéristique des types dérivés retournés est appelée covariante...
covariante des types de Retour signifie simplement le retour de la même Catégorie de référence ou de son enfant de la classe de référence.
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();
}
}
Covariant type de retour spécifie que le type de retour peut varier dans la même direction 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 passer outre n'importe quelle méthode en changeant le type de retour. Mais maintenant, depuis Java5,
il est possible d'outrepasser la méthode en changeant le type de retour si la sous-classe l'emporte sur toute méthode dont le type de retour N'est pas primitif mais il change son type de retour en type de sous-classe.
- il aide à éviter les casts de type confus présents dans la hiérarchie de classe et ainsi rendre le code lisible, utilisable et maintenable.
-
nous obtenons la liberté d'avoir des types de retour plus spécifiques lorsque l'on remplace
méthode. -
Aide dans la prévention de l'exécution ClassCastExceptions 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 de remplacement.
- cette fonctionnalité aidera à éviter le casting vers le bas sur le côté client. Il permet au programmeur de programme sans avoir de vérification de type et de fonderie vers le bas.
- le type de retour covariant toujours fonctionne uniquement 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;
}
}
de la Fonction.java
@FunctionalInterface
public interface Function<T, R> {
........
........
........
........
static <T> Function<T, T> identity() {
return t -> t;
}
}