Wrapper Class

5/11/2018 Wrapper Class - slidepdf.com

http://slidepdf.com/reader/full/wrapper-class 1/9

Clases envoltorio (Wrapper)

Definición y uso de clases envoltorio

En ocasiones es muy conveniente poder tratar los datos primitivos (int, boolean,

etc.) como objetos. Por ejemplo, los contenedores definidos por el API en el

package java.util (Arrays dinámicos, listas enlazadas, colecciones, conjuntos,

etc.) utilizan como unidad de almacenamiento la clase Object. Dado que Object

es la raíz de toda la jerarquía de objetos en Java, estos contenedores pueden

almacenar cualquier tipo de objetos. Pero los datos primitivos no son objetos, con

lo que quedan en principio excluidos de estas posibilidades.

Para resolver esta situación el API de Java incorpora las clases envoltorio(wrapper class), que no son más que dotar a los datos primitivos con un

envoltorio que permita tratarlos como objetos. Por ejemplo podríamos definir una

clase envoltorio para los enteros, de forma bastante sencilla, con:

public class Entero {

private int valor;

Entero(int valor) {

this.valor = valor;

}

int intValue() {

return valor;

}

}

La API de Java hace innecesario esta tarea al proporcionar un conjunto completo

de clases envoltorio para todos los tipos primitivos. Adicionalmente a la

funcionalidad básica que se muestra en el ejemplo las clases envoltorio

proporcionan métodos de utilidad para la manipulación de datos primitivos(conversiones de / hacia datos primitivos, conversiones a String, etc.)

Las clases envoltorio existentes son:

Byte para byte.

Short para short.



Integer para int.

Long para long.

Boolean para boolean

Float para float.

Double para double y

Character para char.

Observese que las clases envoltorio tienen siempre la primera letra en

mayúsculas.

Las clases envoltura se usan como cualquier otra:

Integer i = new Integer(5);

int x = i.intValue();

Hay que tener en cuenta que las operaciones aritméticas habituales (suma, resta,

multiplicación ...) están definidas solo para los datos primitivos por lo que las

clases envoltura no sirven para este fin.

Las variables primitivas tienen mecanismos de reserva y liberación de memoria

más eficaces y rápidos que los objetos por lo que deben usarse datos primitivos

en lugar de sus correspondientes envolturas siempre que se pueda.

Resumen de métodos de Integer

Las clases envoltorio proporcionan también métodos de utilidad para la

manipulación de datos primitivos. La siguiente tabla muestra un resumen de los

métodos disponibles para la clase Integer

Método Descripción

Integer(int valor)

Integer(String valor) Constructores a partir de int y String

int intValue()

/ byte byteValue()

/ float floatValue() . . .

Devuelve el valor en distintos formatos, int,

long, float, etc.

boolean equals(Object obj) Devuelve true si el objeto con el que se

compara es un Integer y su valor es el

mismo.

static Integer

getInteger(String s) Devuelve un Integer a partir de una cadena

de caracteres. Estático

static int parseInt(String s) Devuelve un int a partir de un String.



Estático.

static String

toBinaryString(int i)

static String

toOctalString(int i)

static StringtoHexString(int i)

static String toString(int i)

Convierte un entero a su representación en

String en binario, octal, hexadecimal, etc.

Estáticos

String toString()

static Integer valueOf(String

s) Devuelve un Integer a partir de un String.

Estático.

El API de Java contiene una descripción completa de todas las clases envoltorio

en el package java.lang.



Código Fuente Capsulas.java

public class Capsulas {

public static void main(String[] args) {

// Inicializar Primitivos

int i1 = 12;

int i2 = 300;

long l1 = 200L; // sufijo para primitivo long

long l2 = 200l; // sufijo para primitivo long

long l3 = 200;

float f1 = 1e-39F; // sufijo para primitivo float

float f2 = 1e+11f; // sufijo para primitivo float

float f3 = 1;

double d1 = 32e46d; // sufijo para primitivo

double

double d2 = 14D; // sufijo para primitivo double

double d3 = 1;

// Inicializar "Wrappers" con primitivos

Integer wi1 = new Integer(i1);

Long wl1 = new Long(l1);

Float wf1 = new Float(f1);

Double wd1 = new Double(d1);

// Convertir/Imprimir Valores de "Wrappers" como

double (primitivo)

prt(wi1.doubleValue());

prt(wl1.doubleValue());



prt(wf1.doubleValue());

prt(wd1.doubleValue());


float (primitivo)

prt(wi1.floatValue());

prt(wl1.floatValue());

prt(wf1.floatValue());

prt(wd1.floatValue());


long (primitivo)

prt(wi1.longValue());

prt(wl1.longValue());

prt(wf1.longValue());

prt(wd1.longValue());


integer (primitivo)

prt(wi1.intValue());

prt(wl1.intValue());

prt(wf1.intValue());

prt(wd1.intValue());

// Inicializar "String's" con valores numericos

String str1 = "7";

String str2 = "57";

String str3 = "3.23";

String str4 = "797.43";



// Inicializar "Wrappers" con "String's"

Integer wi2 = new Integer(str1);

Long wl2 = new Long(str2);

Float wf2 = new Float(str3);

Double wd2 = new Double(str4);

// Imprimir Valores

prt(wi2);

prt(wl2);

prt(wf2);

prt(wd2);


String's

prt(wi2.toString());

prt(wl2.toString());

prt(wf2.toString());

prt(wd2.toString());

// Inicializar "Wrappers" con primitivos

Integer wi3 = new Integer(0);

Long wl3 = new Long(0);

Float wf3 = new Float(0);

Double wd3 = new Double(0);

// Convertir/Imprimir Valores de "Wrappers" a

través de "String's"// a su respectivo primitivo

prt(wi3.parseInt(str1));

prt(wl3.parseLong(str2));

prt(wf3.parseFloat(str3));



prt(wd3.parseDouble(str4));

}

static void prt(String s) {

System.out.println("Un String con valor " + s);

}

static void prt(Integer i) {

System.out.println("Un Integer (\"Wrapper\") con

valor " + i);

}

static void prt(Long l) {System.out.println("Un Long (\"Wrapper\") con

valor " + l);

}

static void prt(Float f) {

System.out.println("Un Float (\"Wrapper\") con

valor " + f);

}

static void prt(Double d) {

System.out.println("Un Double (\"Wrapper\") con

valor " + d);

}

static void prt(int i) {

System.out.println("Un int (primitivo) con valor "

+ i);

}

static void prt(long l) {

System.out.println("Un long (primitivo) con valor

" + l);

}

static void prt(float f) {

System.out.println("Un float (primitivo) con valor



" + f);

}

static void prt(double d) {

System.out.println("Un double (primitivo) con

valor " + d);

}

}

Clase Capsulas

Como en todo programa Java , primeramente se define la Clase através del vocablo class.

Se define el método principal main y dentro de éste se generan

diversos campos ("fields"), nótese que en algunas declaraciones seemplea un sufijo para definir el valor del primitivo (L,l,F,f,D,d), loanterior se hace con la finalidad de asignar un espacio apropiadopara futuras manipulaciones numéricas.

Uso de Sufijos

Aunque el uso de sufijos no es obligatorio, su uso se hace másevidente cuando los primitivos son empleados para realizaroperaciones matemáticas con mayor precisión.

Tomemos un número definido como14D

, aunque el número catorcebien pudiera ser un entero (int) éste se esta definiendo como unnúmero double a través del sufijo, esto permite que el número seamanipulado con otros primitivos double sin perder precisión, estapérdida de precisión será ilustrada a continuación.

Posteriormente, se inicializan cuatro "Wrappers" a través de losprimitivos definidos anteriormente.

Seguido se emplean una serie de declaraciones con elmétodo prt para imprimir valores a pantalla; en esta serie de

declaraciones se manda imprimir el valor de los "Wrappers"definidos anteriormente a través de métodos auxiliares xxxxValue().

Dichos métodos auxiliares se encuentran disponibles para todo"Wrapper" de primitivo y permiten restringir el rango del mismo,esto en términos computacionales es conocido como "Casting"(Concepto ilustrado a más detalle en otra sección de este curso);mediante esta utilización de "Casting" se puede ilustrar la pérdida



de exactitud en primitivos, tal sería el caso al realizar un "Cast"de double a int.

Posteriormente son definidos cuatro "String's" con valoresnuméricos.

Se declara otra serie de "Wrappers" que son inicializados a travésde los "String's" definidos anteriormente.

Son impresos a pantalla (a través de prt) los valores de los"Wrappers", en la primer serie como "Wrappers" directamente y enla segunda serie manipulados hacia "String's" mediante el métodoauxiliartoString() disponible en todo "Wrapper".

Se inicializan otra serie de "Wrappers" con primitivos 0 (cero)

Son impresos a pantalla los valores de estos últimos "Wrappers"como primitivos a través de los "String's" definidos previamente,

dicha impresión de "String's" como primitivos se logra a través delos métodos auxiliares parseXXX.

Finalmente son definidos una serie de métodos prt que tomandistintos argumentos de entrada ; el diseño de estosmétodos prt es conocido como overloading, concepto que seráilustrado a detalle en una futura sección del curso.

Wrapper Class

Documents

Transcript of Wrapper Class