Polimorfismo de tiempo de compilación en Java

El polimorfismo en Java se refiere a la capacidad de un objeto para tomar varias formas. El polimorfismo nos permite realizar la misma acción de múltiples formas en Java.

El polimorfismo se divide en dos tipos:

1. Polimorfismo en tiempo de compilación
2. Polimorfismo de tiempo de ejecución

Nota: El polimorfismo en tiempo de ejecución se implementa a través de la anulación de métodos. Mientras que el polimorfismo del tiempo de compilación se implementa a través de la sobrecarga de métodos y la sobrecarga de operadores . 

En este artículo, veremos el polimorfismo de tiempo de compilación.

Polimorfismo en tiempo de compilación

El polimorfismo en tiempo de compilación también se conoce como polimorfismo estático o enlace anticipado. El polimorfismo en tiempo de compilación es un polimorfismo que se resuelve durante el proceso de compilación. La sobrecarga de métodos se llama a través de la variable de referencia de una clase. El polimorfismo en tiempo de compilación se logra mediante la sobrecarga de métodos y la sobrecarga de operadores.

1. Sobrecarga de métodos

Podemos tener uno o más métodos con el mismo nombre que solo se distinguen por números de argumento, tipo u orden.

La sobrecarga de métodos ocurre cuando una clase tiene muchos métodos con el mismo nombre pero diferentes parámetros. Dos o más métodos pueden tener el mismo nombre si tienen otros números de parámetros, diferentes tipos de datos o diferentes números de parámetros y diferentes tipos de datos. 

Ejemplo: 

void gfg() { ... }
void gfg(int num1 ) { ... }
void gfg(float num1) { ... }
void gfg(int num1 , float num2 ) { ... } 

(a). Sobrecarga de métodos cambiando el número de parámetros 

 En este tipo, la sobrecarga de métodos se realiza mediante la sobrecarga de métodos en la llamada de función con un número variado de parámetros.

 Ejemplo:

show( char a )
show( char a ,char b )

 En el ejemplo dado, el primer método show tiene un parámetro y el segundo método show tiene dos métodos. Cuando se llama a una función, el compilador observa la cantidad de parámetros y decide cómo resolver la llamada al método.

// Java program to demonstrate the working of method
// overloading by changing the number of parameters
 
public class MethodOverloading {
     
      // 1 parameter
    void show(int num1)
    {
        System.out.println("number 1 : " + num1);
    }
 
    // 2 parameter
    void show(int num1, int num2)
    {
        System.out.println("number 1 : " + num1
                           + "  number 2 : " + num2);
    }
 
    public static void main(String[] args)
    {
        MethodOverloading obj = new MethodOverloading();
       
          // 1st show function
        obj.show(3);
       
          // 2nd show function
        obj.show(4, 5);
    }
}

number 1 : 3
number 1 : 4  number 2 : 5

En el ejemplo anterior, implementamos la sobrecarga de métodos cambiando varios parámetros. Hemos creado dos métodos, show(int num1 ) y show(int num1, int num2 ). En la visualización del método show (int num1), un número y el void show (int num1, int num2) muestran dos números

(b). Sobrecarga de método cambiando el tipo de datos del parámetro

En este tipo, la sobrecarga de métodos se realiza mediante la sobrecarga de métodos en la llamada de función con diferentes tipos de parámetros.

Ejemplo:

show( float a float b)
show( int a, int b ) 

En el ejemplo anterior, el primer método show tiene dos parámetros flotantes y el segundo método show tiene dos parámetros int. Cuando se llama a una función, el compilador observa el tipo de datos de los parámetros de entrada y decide cómo resolver la llamada al método.

Programa:

// Java program to demonstrate the working of method
// overloading by changing the Datatype of parameter
 
public class MethodOverloading {
   
    // arguments of this function are of integer type
    static void show(int a, int b)
    {
        System.out.println("This is integer function ");
    }
   
    // argument of this function are of float type
    static void show(double a, double b)
    {
        System.out.println("This is double function ");
    }
   
    public static void main(String[] args)
    {
        // 1st show function
        show(1, 2);
       
        // 2nd show function
        show(1.2, 2.4);
    }
}

This is integer function 
This is double function 

En el ejemplo anterior, cambiamos el tipo de datos de los parámetros de ambas funciones. En la primera función show(), el tipo de datos del parámetro es int. Después de dar una entrada de tipo entero, la salida será ‘Esta es una función entera.’ En la segunda función show(), el tipo de datos de un parámetro es doble. Después de dar una entrada de tipo doble, la salida sería ‘Esta es una función doble’. 

(C). Al cambiar la secuencia de parámetros 

En este tipo, la sobrecarga depende de la secuencia de los parámetros 

Ejemplo:

show( int a, float b ) 
show( float a, int b )

Aquí, en este ejemplo, los parámetros int y float se usan en la primera declaración. Los parámetros son int y float en la segunda declaración, pero su orden en la lista de parámetros es diferente.

// Java program to demonstrate the working of method
// overloading by changing the sequence of parameters
 
public class MethodOverloading {
 
    // arguments of this function are of int and char type
    static void show(int a, char ch)
    {
        System.out.println("integer : " + a
                           + " and character : " + ch);
    }
 
    // argument of this function are of char and int type
    static void show(char ch, int a)
    {
        System.out.println("character : " + ch
                           + " and integer : " + a);
    }
 
    public static void main(String[] args)
    {
        // 1st show function
        show(6, 'G');
 
        // 2nd show function
        show('G', 7);
    }
}

integer : 6 and character : G
character : G and integer : 7

En el ejemplo anterior, en el primer programa, los parámetros de función son int y char , y en el segundo zapato, los parámetros de función son char e int . cambió la secuencia del tipo de datos. 

Casos no válidos de sobrecarga de métodos

La sobrecarga de métodos no permite cambiar el tipo de devolución del método (función); se produce ambigüedad.

Ejemplos

int sum(int, int);
String sum(int, int);

Debido a que los argumentos coinciden, el código anterior no se compilará. Ambos métodos tienen la misma cantidad de tipos de datos y la misma secuencia de tipos de datos en los parámetros.

2. Sobrecarga del operador 

Se dice que un operador está sobrecargado si puede usarse para realizar más de una función. La sobrecarga de operadores es un método de sobrecarga en el que se da un nuevo significado a un operador existente. En Java, el operador + está sobrecargado. Java, por otro lado, no permite la sobrecarga de operadores definidos por el usuario. Para sumar números enteros, el operador + se puede emplear como operador de suma aritmética. También se puede utilizar para unir cuerdas.

// Java program to demonstrate the
// working of operator overloading
 
public class GFG {
 
    // function for adding two integers
    void add(int a, int b)
    {
        int sum = a + b;
        System.out.println(" Addition of two integer :"
                           + sum);
    }
 
    // function for concatenating two strings
    void add(String s1, String s2)
    {
        String con_str = s1 + s2;
        System.out.println("Concatenated strings :"
                           + con_str);
    }
 
    public static void main(String args[])
    {
        GFG obj = new GFG();
       
        // addition of two numbers
        obj.add(10, 10);
       
        // concatenation of two string
        obj.add("Operator ", " overloading ");
    }
}

 Addition of two integer :20
Concatenated strings :Operator  overloading 

En el ejemplo anterior, el operador ‘+’ se ha sobrecargado. Cuando enviamos dos números al método sobrecargado, obtenemos una suma de dos enteros, y cuando pasamos dos strings, obtenemos el texto concatenado.

Ventajas del polimorfismo en tiempo de compilación:

1. Mejora la claridad del código y permite el uso de un solo nombre para procedimientos similares.
2. Tiene un tiempo de ejecución más rápido ya que se descubre temprano en el proceso de compilación.

La única desventaja del polimorfismo en tiempo de compilación es que no incluye la herencia.