Clases Envoltorio.

Buenas amigos, en este nuevo tema vamos a ver las clases Envoltorio. Como bien deberíais saber, existen 8 tipo de datos primitivos (byte,short,int,long, float,double,char y boolean). Estos tipos de datos son llamados primitivos por ser los más básicos que nos presenta Java, pero hay casos, situaciones, métodos, en las que no podremos utilizar este tipo de dato, como por ejemplo las colecciones, que no aceptan tipo de datos primitivos, pero, ¿cómo hacemos para guardar en una colección una serie de números, si no aceptan los tipos básicos? Con las clases Envoltorio.


Estas clases nos permiten envolver un tipo da dato básico en un objeto. Existen 8 tipos:

• byte------------------->Byte

• short------------------>Short

• int--------------------->Integer

• long------------------->Long

• float------------------->Float

• double---------------->Double

• char------------------->Character

• boolean--------------->Boolean

Estas clases envoltorio son todas finales e inmutables y disponen de 2 constructores cada uno, uno de tipo primitivo y otro de tipo String, excepto "Character" que sólo posee el de tipo primitivo.

Las clases envoltorio se construyen de la siguiente manera:

• Byte nombreVariable=new Byte(parametros);

• Short nombreVariable=new Short(parametros);

• Integer nombreVariabe=new Integer(parametros);

• Long nombreVariable=new Long(parametros);

• Float nombreVariable=new Float(parametros);

• Double ombreVariable=new Double(parametros);

• Character nombreVariable=new Character(parametros);

• Boolean nombreVariable=new Boolean(parametros);

Aquí tenemos la construcción de las 8 clases. Le pasamos un parámetro por la lista de argumentos, ya que, como ya he mencionado, tienen 2 constructores, uno para tipos primitivos y otro para tipo String, EXCEPTO "character" que solo tiene el primer tipo. Un ejemplo muy sencillo para tenerlo claro del todo.

• int i=5;-----------------> Número entero almacenado en tipo primitivo

• Integer i=new Integer(5)->Número entero almacenado en un objeto.

Los métodos utilizados por estas clases son:

• static tipoObjeto valueOf(String): Devuelve un tipo de objeto (de las clases envoltorio) a partir de una String:
• Para todas las clases es igual, para float sería (Float.valueOf(s), etc), EXCEPTO para "Character" que no tiene este método.

• tipo XXXvalue(): Devuelve el valor envuelto por el objeto en el tipo especificado, siendo XXX el nombre del tipo que se quiere obtener:
• Podéis observar, que utilizo el segundo tipo de constructor de la clase Integer, pasando una String numérica, posteriormente le pasamos ese valor numérico a un tipo básico por el método "intValue()". Si fuese un float, utilizaríamos el "floatValue()", y así con todas las clases.

• static tipoObjeto parseXXX(String s): Es u método disponible solamente en las clases numéricas. Permite convertir la representación en forma de cadena de texto en el valor numérico que corresponda.
• Para otras clases, como float, sería float t=Float.parseFloat(s), y así con el resto.

• String toString(): Disponible para todas las clases de envoltorio. Devuelve la representación String del tipo envuelto.

• Este método está sobrecargado, y le podemos pasar por parámetro el objeto que queremos pasar a cadena.

Una cosa más que decir de las clases de envoltorio, y es que tiene 2 propiedades que es importante conocer: AutoBoxing y AutoUnBoxing.

• AutoBoxing permite encapsular automáticamente un dato básico en una clase de envoltorio
• int p=5
• Integer i=p;
• De esta forma no tenemos que crear la instancia (Java la crea aunque no se nos muestre)

• AutoUnBoxing nos permite recuperar el tipo primitivo de un número almacenado en una clase de envoltorio sin utilizar "XXXvalue()" de esta forma:
• Integer i=new Integer(5);
• int n=i;
• Con esto no nos hace falta invocar métodos para obtener el valor del número almacenado.

Dicho lo anterior muchos os preguntaréis el por que he explicado algunos métodos si el AutoBoxing y el AutoUnBoxing nos hace lo mismo sin tener que utilizarlos. Bien, cabe mencionar, que esta cualidad fue introducida en la versión de Java 1.5 y por lo tanto en versiones anteriores a ésta habrá que utilizar los métodos, si alguien sigue funcionando en alguna versión anterior a la 1.5, que lo dudo mucho, pero el mundo es muy grande, y a saber...

Con esto acabamos este pequeño tema, que aunque no requiere mucha historia, son cosas que hay que saber, y más aún ahora que comenzamos con las colecciones, que vuelvo a repetir, no permiten el uso de tipos primitivos, y deberemos de utilizar las clases envoltorio para jugar con ellas.

Un saludo.