Cos'è un tipo restituito covariante?

Che cos'è un tipo restituito covariante in Java? Nella programmazione orientata agli oggetti in generale?

Restituzione covariante, significa che quando si sovrascrive un metodo, il tipo restituito del metodo sovrascritto può essere un sottotipo del tipo restituito del metodo sostituito.

Per chiarire questo con un esempio, un caso comune è Object.clone()- che viene dichiarato restituire un tipo di Object. Puoi sovrascriverlo nella tua classe 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 contiene un riferimento esplicito a un oggetto MyFoo sarà in grado di invocare clone()e sapere (senza casting) che il valore restituito è un'istanza di MyFoo. Senza i tipi restituiti covarianti, il metodo sovrascritto in MyFoo dovrebbe essere dichiarato per restituire Object- e quindi chiamare il codice dovrebbe esplicitamente abbassare il risultato della chiamata al metodo (anche se entrambe le parti "sanno" che può essere sempre e solo un'istanza di MyFoo ).

Nota che non c'è niente di speciale clone()e che qualsiasi metodo sovrascritto può avere un ritorno covariante: l'ho usato come esempio qui perché è un metodo standard in cui questo è spesso utile.

Ecco un altro semplice esempio:

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

È possibile modificare il tipo di ritorno del Dog's seekFood()metodo DogFood- una sottoclasse di Food, come mostrato di seguito:

@Override
protected DogFood seekFood() {

    return new DogFood();
}

Questo è perfettamente un imperativo legale, e il tipo di ritorno di Dog's seekFood()metodo è noto come tipo restituito covariante .

Dal rilascio di JDK 1.5, i tipi covarianti sono stati introdotti in Java. e te lo spiegherò con un semplice caso: quando sovrascriviamo una funzione, la funzione può apportare modifiche al suo comportamento questo è ciò che puoi leggere nella maggior parte dei libri, ma ciò che gli {autori} perdono è che possiamo cambiare anche il tipo di ritorno. controlla sotto il link per chiarimenti possiamo cambiare il tipo di ritorno purché possa essere assegnato al tipo di ritorno della versione Base del metodo.

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

I metodi sostituiti possono differire nel tipo restituito?

Tipi restituiti covarianti significa semplicemente restituire il proprio riferimento alla classe o il suo riferimento alla classe figlia.

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

}

Per aggiungere alle risposte precedenti, è possibile eseguire l'override tra i tipi restituiti co-variant, con il vincolo che il tipo restituito del metodo sovrascritto (metodo della sottoclasse) dovrebbe essere una sottoclasse del tipo restituito del metodo sostituito (metodo della superclasse). Questo è valido da Java 5 in poi.

Il tipo restituito covariante specifica che il tipo restituito può variare nella stessa direzione della sottoclasse

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 possibile sovrascrivere alcun metodo modificando il tipo restituito. Ma ora, da Java5,

è possibile sovrascrivere il metodo cambiando il tipo restituito se la sottoclasse sovrascrive qualsiasi metodo il cui tipo restituito è Non primitivo ma cambia il tipo restituito in tipo sottoclasse.

• Aiuta a evitare di confondere i tipi di cast presenti nella gerarchia di classi e quindi a rendere il codice leggibile, utilizzabile e gestibile.

• Abbiamo la libertà di avere tipi di restituzione più specifici quando sovrascriviamo i
  metodi.

• Aiuta a prevenire ClassCastExceptions in fase di esecuzione sui resi

riferimento: www.geeksforgeeks.org

• Il tipo restituito covariante in java, consente di restringere il tipo restituito del metodo sostituito.
• Questa funzione aiuterà a evitare il down casting dal lato client. Consente al programmatore di programmare senza la necessità di controllo del tipo e down casting.
• Il tipo restituito covariante funziona sempre solo per i tipi restituiti 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();
    }
}

Un altro esempio è da 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;
    }
}

Prima di Java5, non era possibile sovrascrivere alcun metodo modificando il tipo restituito. Ma ora, a partire da Java5, è possibile sovrascrivere il metodo cambiando il tipo restituito se la sottoclasse sovrascrive qualsiasi metodo il cui tipo restituito è Non primitivo ma cambia il tipo restituito in tipo sottoclasse.