Java: anulación del método covariante con ejemplos

El enfoque de anulación del método covariante, implementado en Java 5, ayuda a eliminar el encasillamiento del lado del cliente al permitirle devolver un subtipo del tipo de retorno real del método anulado.

La anulación del método covariante significa que al anular un método en la clase secundaria, el tipo de devolución puede variar. Antes de Java 5, no se permitía anular ninguna función si se cambiaba el tipo de devolución en la clase secundaria. Pero ahora es posible que solo el tipo de retorno sea la clase de subtipo.

La anulación del enfoque Covariant proporciona una forma de devolver el subtipo de la clase de devolución real del método anulado. Ayuda a eliminar la carga de encasillamiento del programador. Este método se usa a menudo cuando el método de anulación devuelve un objeto.

Pongamos un ejemplo para entenderlo. La función clon() devuelve el objeto de la clase Object. Pero dado que cada clase es hija de la clase de objeto, devolveremos el objeto de nuestra propia clase. Supongamos que aún no se ha implementado el concepto primordial del mecanismo covariante. Entonces todavía tenemos que lanzar el objeto. Si no se utiliza la conversión, se produce el error «El objeto no se puede convertir en estudiante».

Ejemplo 1:

// Covariant Method Overriding of Java
import java.util.ArrayList;
// Student class
class Student implements Cloneable {
    int rollNo;
    String className;
    String name;
  
    // Getters and setters
    public int getRollNo() { return rollNo; }
    public void setRollNo(int rollNo)
    {
        this.rollNo = rollNo;
    }
    public String getClassName() { return className; }
    public void setClassName(String className)
    {
        this.className = className;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
  
    // Class constructor
    public Student(int rollNo, String className,
                   String name)
    {
        this.rollNo = rollNo;
        this.className = className;
        this.name = name;
    }
  
    // Print method
    public void printData()
    {
        System.out.println("Name : " + name
                           + ", RollNo: " + rollNo
                           + ", Class Name : " + className);
    }
  
    // Override the clone method
    @Override
    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}
  
// Driver code
public class GFG {
    public static void main(String arg[])
        throws CloneNotSupportedException
    {
        // new student object created
        Student student1 = new Student(1, "MCA", "Kapil");
        student1.printData();
  
        // Student object created using clone method
        // assuming type casting is required
        Student student2 = (Student)student1.clone();
        student2.setName("Sachin");
        student2.setRollNo(2);
        student2.printData();
    }
}

Name : Kapil, RollNo: 1, Class Name : MCA
Name : Sachin, RollNo: 2, Class Name : MCA

En el ejemplo anterior, cuando usamos el método clone(), devuelve el objeto de la clase Object y luego lo encasillamos en la clase Student.

Student student2 = (Student) student1.clone();

Supongamos que usamos el método de clonación en el programa 10 veces, por lo que debemos escribirlo cada vez. Deberíamos anular el enfoque covariante para resolver este tipo de problemas. Devolveremos el objeto de la clase de estudiante en lugar de la clase de objeto utilizando el concepto de covariante.

Veamos cómo lo vamos a usar.

Ejemplo 2:

// Covariant Method Overriding of Java
import java.util.ArrayList;
// Student class
class Student implements Cloneable {
    int rollNo;
    String className;
    String name;
  
    // Getters and setters
    public int getRollNo() { return rollNo; }
    public void setRollNo(int rollNo)
    {
        this.rollNo = rollNo;
    }
    public String getClassName() { return className; }
    public void setClassName(String className)
    {
        this.className = className;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
  
    // Class constructor
    public Student(int rollNo, String className,
                   String name)
    {
        this.rollNo = rollNo;
        this.className = className;
        this.name = name;
    }
  
    // Print method
    public void printData()
    {
        System.out.println("Name : " + name
                           + ", RollNo: " + rollNo
                           + ", Class Name : " + className);
    }
  
    // Override the clone method
    @Override
    public Student clone() throws CloneNotSupportedException
    {
        return (Student) super.clone();
    }
}
  
// Driver code
public class GFG {
    public static void main(String arg[])
        throws CloneNotSupportedException
    {
        // new student object created
        Student student1 = new Student(1, "MCA", "Kapil");
        student1.printData();
  
        // Student object created using clone method
        Student student2 = student1.clone();
        student2.setName("Sachin");
        student2.setRollNo(2);
        student2.printData();
    }
}

Name : Kapil, RollNo: 1, Class Name : MCA
Name : Sachin, RollNo: 2, Class Name : MCA

Podemos ver arriba, dado que estamos devolviendo un objeto de clase Student en lugar de una clase Object, no necesitamos escribir el objeto devuelto por el método clone() en Student.