Despacho de método dinámico o polimorfismo en tiempo de ejecución en Java

Requisito previo: anular en java , herencia

La anulación de métodos es una de las formas en que Java admite el polimorfismo en tiempo de ejecución. El envío de métodos dinámicos es el mecanismo por el cual una llamada a un método anulado se resuelve en tiempo de ejecución, en lugar de en tiempo de compilación.

• Cuando se llama a un método anulado a través de una referencia de superclase, Java determina qué versión (superclase/subclases) de ese método se ejecutará en función del tipo de objeto al que se hace referencia en el momento en que se produce la llamada. Por lo tanto, esta determinación se realiza en tiempo de ejecución.
• En tiempo de ejecución, depende del tipo de objeto al que se hace referencia (no del tipo de la variable de referencia) que determina qué versión de un método anulado se ejecutará
• Una variable de referencia de superclase puede hacer referencia a un objeto de subclase. Esto también se conoce como upcasting. Java usa este hecho para resolver las llamadas a métodos anulados en tiempo de ejecución.

Por lo tanto, si una superclase contiene un método que es reemplazado por una subclase, cuando se hace referencia a diferentes tipos de objetos a través de una variable de referencia de superclase, se ejecutan diferentes versiones del método. Aquí hay un ejemplo que ilustra el envío de métodos dinámicos:

// A Java program to illustrate Dynamic Method
// Dispatch using hierarchical inheritance
class A
{
    void m1()
    {
        System.out.println("Inside A's m1 method");
    }
}
  
class B extends A
{
    // overriding m1()
    void m1()
    {
        System.out.println("Inside B's m1 method");
    }
}
  
class C extends A
{
    // overriding m1()
    void m1()
    {
        System.out.println("Inside C's m1 method");
    }
}
  
// Driver class
class Dispatch
{
    public static void main(String args[])
    {
        // object of type A
        A a = new A();
  
        // object of type B
        B b = new B();
  
        // object of type C
        C c = new C();
  
        // obtain a reference of type A
        A ref;
          
        // ref refers to an A object
        ref = a;
  
        // calling A's version of m1()
        ref.m1();
  
        // now ref refers to a B object
        ref = b;
  
        // calling B's version of m1()
        ref.m1();
  
        // now ref refers to a C object
        ref = c;
  
        // calling C's version of m1()
        ref.m1();
    }
}

Producción:

Inside A's m1 method
Inside B's m1 method
Inside C's m1 method

Explicación :

El programa anterior crea una superclase llamada A y sus dos subclases B y C. Estas subclases anulan el método m1().

1. Dentro del método main() en la clase Dispatch, inicialmente se declaran objetos de tipo A, B y C.

   A a = new A(); // object of type A
   B b = new B(); // object of type B
   C c = new C(); // object of type C
   

   

2. Ahora también se declara una referencia de tipo A, llamada ref, inicialmente apuntará a nulo.

   A ref; // obtain a reference of type A
   

   

3. Ahora estamos asignando una referencia a cada tipo de objeto (ya sea A, B o C) a ref , uno por uno, y usamos esa referencia para invocar m1(). Como muestra el resultado, la versión de m1( ) ejecutada está determinada por el tipo de objeto al que se hace referencia en el momento de la llamada.

   ref = a; // r refers to an A object
   ref.m1(); // calling A's version of m1()
   

   

   ref = b; // now r refers to a B object
   ref.m1(); // calling B's version of m1()
   

   

   ref = c; // now r refers to a C object
   ref.m1(); // calling C's version of m1()
   

   

Polimorfismo en tiempo de ejecución con miembros de datos

En Java, solo podemos anular los métodos, no las variables (miembros de datos), por lo que los miembros de datos no pueden lograr el polimorfismo en tiempo de ejecución. Por ejemplo :

// Java program to illustrate the fact that
// runtime polymorphism cannot be achieved
// by data members
  
// class A
class A
{
    int x = 10;
}
  
// class B
class B extends A
{
    int x = 20;
}
  
// Driver class
public class Test
{
    public static void main(String args[])
    {
        A a = new B(); // object of type B
  
        // Data member of class A will be accessed
        System.out.println(a.x);
    }
}

Producción:

10

Explicación: en el programa anterior, tanto la clase A (superclase) como la B (subclase) tienen una variable común ‘x’. Ahora hacemos un objeto de la clase B, referido por ‘a’ que es del tipo de la clase A. Dado que las variables no se anulan, la declaración «ax» siempre se referirá al miembro de datos de la superclase.

Ventajas del envío de métodos dinámicos

1. El envío de métodos dinámicos permite que Java admita la anulación de métodos, lo cual es fundamental para el polimorfismo en tiempo de ejecución.
2. Permite que una clase especifique métodos que serán comunes a todos sus derivados, mientras permite que las subclases definan la implementación específica de algunos o todos esos métodos.
3. También permite que las subclases agreguen sus subclases de métodos específicos para definir la implementación específica de algunos.

Enlace estático vs dinámico

• El enlace estático se realiza durante el tiempo de compilación, mientras que el enlace dinámico se realiza durante el tiempo de ejecución.
• Los métodos y variables privados, finales y estáticos utilizan enlace estático y están vinculados por el compilador, mientras que los métodos anulados se vinculan durante el tiempo de ejecución en función del tipo de objeto de tiempo de ejecución.

Este artículo es una contribución de Gaurav Miglani . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.