Sobrecarga de métodos con Autoboxing y Widening en Java

Repasemos los requisitos previos básicos, como la sobrecarga de métodos, el autoboxing y el unboxing. Por lo tanto, la sobrecarga de métodos en Java se basa en el número y el tipo de los parámetros que se pasan como argumento a los métodos. No podemos definir más de un método con el mismo nombre, orden y tipo de argumentos. Sería un error del compilador. El compilador no considera el tipo de retorno al diferenciar el método sobrecargado. Pero no puede declarar dos métodos con la misma firma y diferentes tipos de devolución. Lanzará un error en tiempo de compilación. Si ambos métodos tienen los mismos tipos de parámetros, pero diferentes tipos de devolución, entonces no es posible.

Autoboxing es el proceso de convertir un valor primitivo en un objeto de la clase contenedora correspondiente que se denomina autoboxing. Por ejemplo, convertir int a Integer class . Mientras que Unboxing es un proceso de convertir un objeto de tipo contenedor a su valor primitivo correspondiente, se denomina unboxing. Por ejemplo, conversión de Integer a int.

En Java, hay dos tipos de variables: 

• tipo primitivo
• Tipo de referencia.

La conversión de un tipo primitivo a su objeto contenedor correspondiente se denomina Autoboxing y el objeto Wrapper a su tipo primitivo correspondiente se conoce como unboxing.

Sobrecarga de métodos con Autoboxing

En la sobrecarga de métodos, puede encontrarse con una situación en la que una firma toma un tipo de referencia o un tipo primitivo como argumento formal. El compilador primero busca un método con parámetros del mismo tipo de datos. Si está utilizando la clase contenedora Objeto como argumento real y el compilador no encuentra el método con parámetro(s) del mismo tipo de referencia (es decir, clase o tipo de interfaz), entonces comienza a buscar un método con parámetro(s) que tenga(n) el mismo tipo de referencia. tipo de datos primitivo correspondiente.

Ejemplo 

// Java Program to Illustrate Autoboxing
// While resolving data type as:
// (a) reference
// (b) primitive
 
// Importing required classes
import java.io.*;
 
// Class 1
// Helper class
class Conversion {
 
    // Method 1
    // Overloading method with primitive formal argument
    public void method(int i)
    {
 
        // Print statement
        System.out.println(
            "Primitive type int formal argument :" + i);
    }
 
    // Method 2
    // Overloading method with reference formal argument
    public void method(Integer i)
    {
 
        // Print statement
        System.out.println(
            "Reference type Integer formal argument :" + i);
    }
 
    // Method 2
    // Overloading method primitive formal argument
    // and to be invoked for wrapper Object as overloaded
    // method with wrapper object of same(Long) type as an
    // argument is not available.
    public void method(long i)
    {
 
        // Print statement
        System.out.println(
            "Primitive type long formal argument :" + i);
    }
}
 
// Class 2
// Main class
class GFG {
 
    // main driver method
    public static void main(String[] args)
    {
 
        // Creating instance of class 1 inside main() method
        Conversion c = new Conversion();
 
        // Invoking the method with different signature
        c.method(10);
        c.method(new Integer(15));
        c.method(new Long(100));
 
        // Using short will give, argument mismatch;
        // possible lossy conversion from int to short
        // c.method(new Short(15));
    }
}

Producción:

Método de sobrecarga con ensanchamiento

Si el compilador no encuentra ningún método correspondiente al autoboxing, comienza a buscar un parámetro de método del tipo de datos primitivo ampliado.

Implementación: 

En el siguiente ejemplo, invocamos el método sobrecargado con un argumento formal primitivo ( int ) que tiene el mismo tipo de datos que el tipo de datos del argumento real. Estamos invocando otro método con el argumento de Long wrapper Object. El compilador comienza a buscar el método que tiene el mismo tipo de referencia (clase contenedora larga). Dado que no hay ningún método que tenga el parámetro de la clase de contenedor largo . Por lo tanto, busca un método que pueda aceptar el parámetro más grande que el tipo de datos primitivo largo como argumento. En este caso, encuentra un método con tipo de datos primitivo flotante y lo invoca.

Ejemplo

// Java Program to Illustrate method Overloading
// In case of Widening
 
// Importing required classes
import java.io.*;
 
// Class 1
// Helper class
class Conversion {
 
    // Method
    // overloaded method
    public void method(int i) {
 
        // Print statement
        System.out.println(
            "Primitive type int formal argument :" + i);
    }
 
    // Method 2
    // overloaded method primitive formal argument
    // and to be invoked for wrapper Object as
    public void method(float i) {
 
        // Print statement
        System.out.println(
            "Primitive type float formal argument :" + i);
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args) {
 
        // Creating instance of class 1
        Conversion c = new Conversion();
 
        // Invoking(calling) method with signature
        // has widened data type
        c.method(10);
        c.method(new Long(100));
    }
}

Producción:

Método de sobrecarga con ensanchamiento y boxeo juntos

Nota:

• Orden de prioridad para tipos primitivos: Mismo tipo > Ampliación automática > Boxing > Upcasting (clase principal) > Superclase
• Orden de prioridad para los tipos de referencia: Mismo tipo > Upcasting (clase principal) > Super clase > Unboxing

Geeks, ¿alguna vez se preguntaron qué sucede si la ampliación y el boxeo ocurren juntos? ¿Qué método de invocación podrá hacer el compilador? La ampliación de los tipos primitivos ha tenido prioridad sobre el encuadre y los var-args. Pero la ampliación y el encajonamiento de tipos primitivos no pueden funcionar juntos.

Ejemplo 1A    

// Java program  to illustrate Method Overloading for
// Widening and autoboxing Together
 
// Importing required classes
import java.io.*;
 
// Class 1
// Helper class
public class Conversion {
 
    // Method
    // Overloading method with
    // reference type formal argument
    public void method(Integer a)
    {
 
        // Print statement
        System.out.println(
            "Primitive type byte formal argument :" + a);
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of above class
        Conversion c = new Conversion();
 
        // Calling method defined in above class
        // inside main() method
        byte val = 5;
        c.method(val);
    }
}

Producción:

Nota: Frikis, pero boxing seguido de Upcasting es aceptable si esto se pasa a una referencia de tipo Object para lo cual estaremos proponiendo otro ejemplo de la siguiente manera:  

Ejemplo 1B

// Java program to illustrate Autoboxing Followed by
// Widening in Reference Type Variables
 
// Importing required classes
import java.io.*;
 
// Class 1
// helper class
public class Conversion {
 
    // Method
    // Overloading method with reference type
    // formal argument
    public void method(Object b)
    {
 
        // Object b is typecasted to Byte and then printed
        Byte bt = (Byte)b;
 
        // Print statement
        System.out.println(
            "reference type formal argument :" + bt);
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an instance of class 1 inside main()
        // method
        Conversion c = new Conversion();
 
        byte val = 5;
 
        // b is first widened to Byte
        // and then Byte is passed to Object
        c.method(val);
    }
}

reference type formal argument :5

Sobrecarga de método con argumento Var-args

Nota : la ampliación del tipo primitivo tiene más prioridad que var-args. 

Ejemplo 

// Java program to illustrate Method Overloading
// for var-args and Widening concept Together
 
// Importing required classes
import java.io.*;
 
// Class 1
// Helper class
public class Conversion {
 
    // Overloading method primitive(byte) var-args formal
    // argument
    public void method(byte... a)
    {
 
        // Print statement
        System.out.println(
            "Primitive type byte formal argument :" + a);
    }
 
    // Method 2
    // Overloading method primitive(int) formal arguments
    public void method(long a, long b)
    {
 
        // Print statement
        System.out.println(
            "Widening type long formal argument :" + a);
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an instance of class 1 inside main()
        // method
        Conversion c = new Conversion();
 
        // Invokes the method having widening
        // primitive type parameters
        byte val = 5;
        c.method(val, val);
    }
}

Widening type long formal argument :5

Este artículo es una contribución de Nitsdheerendra . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@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.