Che cos’è un tipo di ritorno covariante?

Che cos’è un tipo di ritorno covariante in Java? Nella programmazione orientata agli oggetti in generale?

Restituisce covariante, significa che quando si sostituisce un metodo, il tipo di restituzione del metodo di sovrascrittura può essere un sottotipo del tipo di ritorno del metodo sottoposto a override.

Per chiarire questo con un esempio, un caso comune è Object.clone() – che viene dichiarato per restituire un tipo di Object . Potresti scavalcare questo nella tua class come segue:

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

Il vantaggio qui è che qualsiasi metodo che abbia un riferimento esplicito a un object MyFoo sarà in grado di invocare clone() e sapere (senza casting) che il valore di ritorno è un’istanza di MyFoo . Senza i tipi di ritorno covarianti, il metodo sottoposto a override in MyFoo dovrebbe essere dichiarato per restituire Object – e quindi chiamare il codice dovrebbe ridurre in modo esplicito il risultato della chiamata al metodo (anche se entrambe le parti “sanno” che può essere sempre un’istanza di MyFoo).

Nota che non c’è niente di speciale su clone() e che qualsiasi metodo sottoposto a override può avere un ritorno covariante – l’ho usato qui come esempio in quanto è un metodo standard in cui spesso è utile.

Ecco un altro semplice esempio:

Classe di Animal

 public class Animal { protected Food seekFood() { return new Food(); } } 

Classe di Dog

 public class Dog extends Animal { @Override protected Food seekFood() { return new DogFood(); } } 

È ansible modificare il tipo di ritorno del metodo Dog ‘s seekFood() in DogFood , una sottoclass di Food , come mostrato di seguito:

 @Override protected DogFood seekFood() { return new DogFood(); } 

Questo è perfettamente un override legale, e il tipo di ritorno del metodo seekFood() di Dog è noto come tipo di ritorno covariante .

Dal rilascio di JDK 1.5, i tipi covarianti sono stati introdotti in Java. e te lo spiegherò con un caso semplice: quando eseguiamo l’override di una funzione, la funzione è in grado di apportare modifiche al suo comportamento che è ciò che leggi nella maggior parte dei libri, ma a cosa mancano {author} è che possiamo cambiare anche il tipo di ritorno. controlla sotto il link per chiarimenti possiamo cambiare il tipo di reso purché possa essere assegnato per restituire il tipo di versione Base del metodo.

Quindi questa caratteristica di restituire i tipi derivati ​​è chiamata COVARIANT …

I metodi sovrascritti possono differire nel tipo restituito?

Tipi di ritorno covarianti significa semplicemente restituire il proprio riferimento di class o il suo riferimento di class figlio.

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

Il tipo di restituzione covariant specifica che il tipo restituito può variare nella stessa direzione della sottoclass

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

Prima di Java 5, non era ansible sovrascrivere alcun metodo cambiando il tipo di ritorno. Ma ora, dal momento che Java5,

è ansible sovrascrivere il metodo modificando il tipo restituito se la sottoclass sovrascrive qualsiasi metodo il cui tipo restituito è Non-Primitivo ma modifica il tipo restituito in tipo sottoclass.

  • Aiuta a evitare di confondere i cast di tipi presenti nella gerarchia delle classi e quindi rende il codice leggibile, utilizzabile e mantenibile.
  • Otteniamo la libertà di avere tipi di rendimento più specifici quando prevalgono
    metodi.

  • Aiuta a prevenire ClassCastException in fase di runtime sui resi

riferimento: http://www.geeksforgeeks.org

  • Il tipo di ritorno covariante in java, consente di restringere il tipo di ritorno del metodo sottoposto a override.
  • Questa funzione aiuterà a evitare il down casting sul lato client. Permette al programmatore di programmare senza la necessità di eseguire il controllo dei tipi e il down casting.
  • Il tipo restituito covariante funziona sempre solo per i tipi di ritorno non primitivi.
 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(); } } 

Altro esempio è da Java,

UnaryOperator.java

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

Function.java

 @FunctionalInterface public interface Function { ........ ........ ........ ........ static  Function identity() { return t -> t; } }