Clases Envoltorio y Boxing

Clases Envoltorio

En Java los datos numéricos, de caracteres, lógicos se tratan de forma primitiva por eficiencia.
Normalmente usamos tipos primitivos y no objetos.

Sin embargo, existe una manera de que estos datos puedan ser objetos, usando las llamadas clases envoltorio. Cada tipo primitivo en Java tiene su correspondiente clase envoltorio.

Son las siguientes:

Tipo primitivo	Clase envoltorio
boolean	Boolean
byte	Byte
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double

Los objetos se construyen pasando el valor al constructor correspondiente.

int entero = 500;
Integer Entero = new Integer(entero); //de primitivo a objeto se llama boxing.
int aEntero = Entero.intValue();            //de objeto a primitivo se llama unboxing.

Muchas veces es útil convertir a estas clases ya que tienen muchos métodos interesantes.

String str = “1000”;
int x = Integer.parseInt(str);

En este último ejemplo hemos podido convertir de String a int utilizando su clase envoltorio Integer y el método parseInt.

Constructores:

Cada clase envoltorio (menos Character) tienen dos constructores: uno que admite el tipo primitivo como parámetro y otro que admite un String.

Integer a = new Integer(500);
Integer b = new Integer(“500”);

Float c = new Float(7.5f);
Float d = new Float(“7.5f”);

Character e = new Character(‘t’);

Para el constructor Boolean cuando el String es true (sin importar mayúsculas o minúsculas) será true, cualquier otro valor será falso.

Boolean f = new Boolean(false);
Boolean g = new Boolean(“TrUe”); //g será true.

Boolean h = new Boolean (“NO”); //h será false.

ValueOf:

Otra forma de construir un objeto de una clase envoltorio es mediante este método estático, valueOf. Este método puede aceptar un String, o un String y un parámetro que indique la base numérica.

Integer nuevo = Integer.valueOf(“150”);
Integer binario = Integer.valueOf(“1010”, 2);

Métodos Útiles:

• Convierte un Envoltorio en primitivo:
  byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
• Convertir un String en primitivo:
  parseByte(), parseShort(), parseInt(), parseLong(), parseFloat(), parseDouble()
• Convertir números a otras bases. Con objetos Integer y Long se pueden utilizar: toBinaryString(), toOctalString(), toHexString():

Autoboxing y unboxing:

Para pasar de un tipo primitivo a su objeto equivalente se necesita utilizar las clases envoltorio (boxing).
Para obtener de la referencia del objeto su tipo primitivo (unboxing) se necesitan usar los métodos de las clases envoltorio.

Todas estas operaciones complicaban excesivamente el código. Por ello a partir de J2SE 5.0 se introdujo una conversión automática (autoboxing) que permite asignar y obtener los tipos primitivos sin necesidad de utilizar las clases envoltorio.

Por ejemplo:

int enteroPrimitivo = 420;
Integer Entero = enteroPrimitivo;  //Se permite la asignación directa. Se llama autoboxing.
int otroEnteroPrimitivo = Entero;  //Se asigna directamente. Se llama autounboxing.

De modo que ahora el compilador según el caso se encarga de crear el objeto envoltorio o de extraer el tipo primitivo.

También se permite en el paso de parámetros y en expresiones aritméticas.

Preguntas típicas de examen

¿Cuál es la salida del siguiente código Java?

package es.javahispano;

public class Envoltorios {

    public void metodoEnvoltorio(Integer a){
        System.out.println("Integer "+a);
    }    
    public void metodoEnvoltorio(int a){
        System.out.println("int " +a);
    }
    public void metodoEnvoltorio(double a){
        System.out.println("double " +a);
    }
    public void metodoEnvoltorio(Double a){
        System.out.println("Double " +a);
    }    
    
    public static void main (String args[]){
        Envoltorios e = new Envoltorios();
        Integer a1 = new Integer(1);
        int a2 = 1;
        Double b1 = new Double(1);
        int b2 = 1;
        e.metodoEnvoltorio(a1);
        e.metodoEnvoltorio(a2);
        e.metodoEnvoltorio(b1);
        e.metodoEnvoltorio(b2);                
    }
    
}

La respuesta es:

Integer 1
int 1
Double 1.0
int 1

Pues la Java Virtual Machine conoce el tipo primitivo que estamos tratando, y al existir un método que, directamente, se adapta en este caso, a esa variable, automáticamente es llamado dicho método.

¿Cuál es la salida del siguiente código Java?

package es.javahispano;

public class Envoltorios {

    public void metodoEnvoltorio(Integer a){
        System.out.println("Integer "+a);
    }    
        
    public static void main (String args[]){
        Envoltorios e = new Envoltorios();
        int a1 = 1;        
        e.metodoEnvoltorio(a1);            
    }
}

La respuesta es:

Integer 1

Pues la JVM puede conocer que el tipo pasado por parámetro es un int, y sabe adaptar este int a su tipo wrapper, un Integer, al no existir un método que acepte como parámetro un int.

¿Cuál es la salida del siguiente código Java?

 package es.javahispano;

public class Envoltorios {

    public void metodoEnvoltorio(Integer a){
        System.out.println("Integer "+a);
    }    
        
    public static void main (String args[]){
        Envoltorios e = new Envoltorios();
        short a1 = 1;        
        e.metodoEnvoltorio(a1);            
    }
}

La respuesta es que este código no compila, pues no existe un método short, y la JVM no es capaz de hacer un wrapper directo de short al tipo Integer, sin embargo, el siguiente código si compilaría y ejecutaría:

package es.javahispano;

public class Envoltorios {

    public void metodoEnvoltorio(Short a){
        System.out.println("Short "+a);
    }    
        
    public static void main (String args[]){
        Envoltorios e = new Envoltorios();
        short a1 = 1;        
        e.metodoEnvoltorio(a1);            
    }

}

Siendo la salida:

Short 1

Más código práctico....

package es.javahispano;

public class Envoltorios {    
        
    public static void main (String args[]){
        Integer a = new Integer(1);
        int b = a;
        System.out.println(b);
        a = b;
        System.out.println(a);
        short c = 2;
        //a = c; Esta conversión no es posible, la comentamos para que el código compile, si no no compilaría
        Double d = (double) 2; //Nota, es obligatorio hacer el casting, pues si no la JVM interpreta este número
        //como int y no se podría hacer la conversión
        //d = a; Esta conversión no es posible, la comentamos para que el código compile, si no no compilaría
    }
}

La salida, una vez comentadas las líneas conflictivas, sería entonces la siguiente:

1
1