Polimorfismo en Java

La palabra polimorfismo significa tener muchas formas. En palabras simples, podemos definir el polimorfismo como la capacidad de un mensaje para mostrarse en más de una forma. 

Ilustración de la vida real: polimorfismo

Una persona al mismo tiempo puede tener diferentes características. Como un hombre al mismo tiempo es padre, esposo, empleado. Entonces, la misma persona posee un comportamiento diferente en diferentes situaciones. Esto se llama polimorfismo. 
El polimorfismo se considera una de las características importantes de la programación orientada a objetos. El polimorfismo nos permite realizar una sola acción de diferentes maneras. En otras palabras, el polimorfismo le permite definir una interfaz y tener múltiples implementaciones. La palabra «poli» significa muchos y «morfos» significa formas, por lo que significa muchas formas.

Tipos de polimorfismo

En Java, el polimorfismo se divide principalmente en dos tipos: 

• Polimorfismo en tiempo de compilación
• Polimorfismo en tiempo de ejecución

Tipo 1: polimorfismo en tiempo de compilación

También se conoce como polimorfismo estático. Este tipo de polimorfismo se logra mediante sobrecarga de funciones o sobrecarga de operadores. 

Nota: Pero Java no admite la sobrecarga de operadores.

Sobrecarga de métodos : cuando hay múltiples funciones con el mismo nombre pero diferentes parámetros, se dice que estas funciones están sobrecargadas . Las funciones se pueden sobrecargar por un cambio en el número de argumentos o/y un cambio en el tipo de argumentos.

Ejemplo 1 

// Java Program for Method overloading
// By using Different Types of Arguments 
 
// Class 1
// Helper class
class Helper {
 
    // Method with 2 integer parameters
    static int Multiply(int a, int b)
    {
 
        // Returns product of integer numbers
        return a * b;
    }
 
    // Method 2
    // With same name but with 2 double parameters
    static double Multiply(double a, double b)
    {
 
        // Returns product of double numbers
        return a * b;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Calling method by passing
        // input as in arguments
        System.out.println(Helper.Multiply(2, 4));
        System.out.println(Helper.Multiply(5.5, 6.3));
    }
}

8
34.65

Ejemplo 2

// Java program for Method Overloading
// by Using Different Numbers of Arguments
 
// Class 1
// Helper class
class Helper {
 
    // Method 1
    // Multiplication of 2 numbers
    static int Multiply(int a, int b)
    {
 
        // Return product
        return a * b;
    }
 
    // Method 2
    // // Multiplication of 3 numbers
    static int Multiply(int a, int b, int c)
    {
 
        // Return product
        return a * b * c;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Calling method by passing
        // input as in arguments
        System.out.println(Helper.Multiply(2, 4));
        System.out.println(Helper.Multiply(2, 7, 3));
    }
}

8
42

Tipo 2: polimorfismo en tiempo de ejecución

También se conoce como envío de método dinámico. Es un proceso en el que una llamada de función al método anulado se resuelve en tiempo de ejecución. Este tipo de polimorfismo se logra mediante la anulación de métodos. La anulación de métodos , por otro lado, ocurre cuando una clase derivada tiene una definición para una de las funciones miembro de la clase base. Se dice que esa función base está anulada .

Ejemplo

// Java Program for Method Overriding
 
// Class 1
// Helper class
class Parent {
 
    // Method of parent class
    void Print()
    {
 
        // Print statement
        System.out.println("parent class");
    }
}
 
// Class 2
// Helper class
class subclass1 extends Parent {
 
    // Method
    void Print() { System.out.println("subclass1"); }
}
 
// Class 3
// Helper class
class subclass2 extends Parent {
 
    // Method
    void Print()
    {
 
        // Print statement
        System.out.println("subclass2");
    }
}
 
// Class 4
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of class 1
        Parent a;
 
        // Now we will be calling print methods
        // inside main() method
 
        a = new subclass1();
        a.Print();
 
        a = new subclass2();
        a.Print();
    }
}

subclass1
subclass2

Explicación de salida: 

Aquí en este programa, cuando se crea un objeto de clase secundaria, se llama al método dentro de la clase secundaria. Esto se debe a que el método de la clase principal está anulado por la clase secundaria. Dado que el método se anula, este método tiene más prioridad que el método principal dentro de la clase secundaria. Entonces, se ejecuta el cuerpo dentro de la clase secundaria.