Ce este un tip de retur covariant? (Programare, Java, Oop, Covarianță)

Pops a intrebat.

Ce este un tip de retur covariant în Java? În programarea orientată pe obiecte în general?

Comentarii

  • această postare pe blog(blogs.oracle.com/sundarararajan/entry/…) explică, doar adaug la baza de cunoștințe aici. –  > Por Akhil Jain.
  • @AkhilJain: Această postare pe blog este genială și simplă. Este cea mai bună explicație prin exemple pe care am văzut-o vreodată pentru modul în care Java acceptă tipurile de returnare covariante. –  > Por kevinarpe.
  • @kevinarpe mulțumesc, mă bucur că este de ajutor pentru atât de mulți oameni. –  > Por Akhil Jain.
9 răspunsuri
Andrzej Doyle

Returnarea covariantă înseamnă că, atunci când se suprascrie o metodă, tipul de return al metodei suprascrise poate fi un subtip al tipului de return al metodei suprascrise.

Pentru a clarifica acest lucru cu un exemplu, un caz obișnuit este Object.clone() – care este declarată pentru a returna un tip de Object. Puteți suprascrie acest lucru în propria clasă, după cum urmează:

public class MyFoo
{

   ...

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

Avantajul este că orice metodă care deține o referință explicită la un obiect MyFoo va putea invoca clone() și să știe (fără a face casting) că valoarea returnată este o instanță a lui MyFoo. Fără tipuri de returnare covariante, metoda suprascrisă din MyFoo ar trebui să fie declarată ca returnând Object – și, astfel, codul de apelare ar trebui să facă în mod explicit un downcast al rezultatului apelului metodei (chiar dacă ambele părți „știu” că acesta poate fi doar o instanță a lui MyFoo).

Rețineți că nu există nimic special în legătură cu clone() și că orice metodă suprascrisă poate avea o returnare covariantă – am folosit-o ca exemplu aici deoarece este o metodă standard în care acest lucru este adesea util.

Comentarii

  • nu ar trebui să fie legată de List<Foo> și List<FooBar> ? –  > Por zinking.
  • Este vorba de tipurile covariante într-un sens mai larg, mai degrabă decât doar covarianta return despre care s-a întrebat aici. Totuși, este același principiu de bază – vă puteți gândi la definiția de nivel superior a clone() ca fiind un Method<Void, Object>, , și să ne întrebăm dacă cea mai specifică Method<Void, MyFoo> poate fi atribuit acelui tip părinte. Ceea ce este, dacă și numai dacă metodele Java sunt covariante în tipul lor de returnare. –  > Por Andrzej Doyle.
Mohamed ALOUANE

Iată un alt exemplu simplu :

Animal clasa

public class Animal {

    protected Food seekFood() {

        return new Food();
    }
}

Dog clasa

public class Dog extends Animal {

    @Override
    protected Food seekFood() {

        return new DogFood();
    }
}

Este posibil să modificăm tipul de returnare al clasei Dog‘s seekFood() în DogFood – o subclasă de Food, , așa cum se arată mai jos:

@Override
protected DogFood seekFood() {

    return new DogFood();
}

Aceasta este o suprascriere perfect legală, iar tipul de returnare al metodei Dog‘s seekFood() este cunoscut ca tip de returnare covariantă.

PreședintePratik

De la lansarea JDK 1.5, tipurile covariante au fost introduse în Java. și vă voi explica cu un caz simplu, : Atunci când suprascriem o funcție, funcția are voie să facă schimbări în comportamentul său. asta este ceea ce puteți citi în majoritatea cărților, dar ceea ce ei { autorii } omit este că putem schimba și tipul de returnare. consultați link-ul de mai jos pentru clarificări putem schimba tipul de returnare atâta timp cât poate fi atribuit tipului de returnare al versiunii de bază a metodei.

Așadar, această caracteristică de returnare a tipurilor derivate se numește COVARIANT…

Metodele suprascrise pot avea un tip de returnare diferit?

Dhiraj

Tipuri de returnare covariante înseamnă pur și simplu returnarea propriei referințe de clasă sau a referinței clasei sale copil.

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

}

Comentarii

  • Include, de asemenea, cazul în care Parent.foo() returnează un fără legătură între ele de tip A și Child.foo() returnează un tip B derivat din A. –  > Por Davis Herring.
Viața lui Pai

Pentru a adăuga la răspunsurile de mai sus, suprapunerea este posibilă între tipuri de retur covariante, cu constrângerea ca tipul de retur al metodei suprapuse (metoda subclasă) să fie o subclasă a tipului de retur al metodei suprapuse (metoda superclasă). Acest lucru este valabil începând cu Java 5.

Keshav Gera

Tipul de returnare covariant specifică faptul că tipul de returnare poate varia în aceeași direcție ca și subclasa

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

Înainte de Java 5, nu era posibilă suprascrierea unei metode prin modificarea tipului de returnare. Dar acum, de la Java5,

este posibilă suprascrierea metodei prin modificarea tipului de returnare dacă subclasa suprascrie orice metodă al cărei tip de returnare este Non-Primitive, dar își schimbă tipul de returnare în tipul subclasei.

Arun Raaj
  • Ajută la evitarea confuziei de tip prezent în ierarhia claselor și, astfel, face codul lizibil, utilizabil și ușor de întreținut.
  • Avem libertatea de a avea tipuri de returnare mai specifice atunci când suprascriem
    metode.

  • Ajută la evitarea excepțiilor ClassCastExceptions în timpul execuției la returnări.

referință: www.geeksforgeeks.org

snr
  • Tipul de retur covariant din java permite restrângerea tipului de retur al metodei suprascrise.
  • Această caracteristică va ajuta la evitarea downcasting-ului pe partea clientului. Aceasta permite programatorului să programeze fără a avea nevoie de verificarea tipurilor și de down casting.
  • Tipul de returnare covariant funcționează întotdeauna numai pentru tipurile de returnare neprimitive.
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 alt exemplu este cel din 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;
    }
}

user11198642

Înainte de Java5, nu era posibil să se suprascrie nicio metodă prin schimbarea tipului de returnare. Dar acum, începând cu Java5, este posibilă suprascrierea unei metode prin schimbarea tipului de returnare dacă subclasa suprascrie orice metodă al cărei tip de returnare este Non-Primitive, dar își schimbă tipul de returnare în tipul subclasei.