Clases envolventes - Wrapper classes

 Conceptos
Muchas veces nos encontramos con problemas de conversión de tipos de datos, principalmente
cuando le solicitamos datos al usuario el API de java nos provee clases útiles para manejar estas
situaciones.

Las clases envolventes tienen dos principales

funciones en java:
Proveen un mecanismo para envolver (wrapper) valores primitivos en un objeto, de esta manera
los datos primitivos pueden tener actividades o comportamientos que son reservados solo para los
objetos (como ser agregados a una colección o ser retornados de un método como simple Object).
Proveen útiles funciones para realizar conversiones: a cadena, cambiar de base numérica(octal,
hexadecimal), u otros tipos primitivos.
Existe para cada tipo primitivo una clase envolvente, nombrada igual que su dato primitivo pero su
nombre empieza con mayúscula.
Tabla de primitivos, envolventes y sus constructores:

Primitive - Wrapper - Constructors

boolean - Boolean - boolean or String
byte - Byte - byte or String
char - Character - char
double - Double - double or String
float - Float - float, double, or String
int - Integer - int or String
long - Long - long or String
short - Short - short or String

Para realizar conversiones podemos utilizar algunos métodos:

 xxxValue()
 parseXxx()
 valueOf()
 toString()

xxxValue()
Cuando se necesita el valor númerico de un envolvente a un primitivo podemos utilizar cualquiera
de los muchos métodos xxxValue().
Ejemplo:
Integer var = new Integer(42);

byte b = var.byteValue();
 short s = var.shortValue();
double d = var.doubleValue();
parseXxx() y valueOf()
Ambos parseXxx() y valueOf() toman un String como argumento y arrojan NumberFormatException
si la cadena no esta formada propiamente, y pueden convertir objetos String a diferentes bases
numéricas (radix). La principal diferencia de estos métodos es:

 parseXxx() - regresa el primitivo nombrado.

 valueOf() - regresa un nuevo objeto wrapped del tipo del que fue invocado.

Ejemplo:
double d4 = Double.parseDouble("3.14");
long L2 = Long.parseLong("101010", 2); // El resultado es 42

Long L3 = Long.valueOf("101010", 2); // // El resultado es 42

toString()
la clase Object la clase principal de java contiene el método toString(). La idea de este método es
obtener una representación significativa de un objeto dado. Este método nos regresa una cadena
con el valor del primitivo envuelto en el objeto.
Ejemplo:
Double d = new Double("3.14");
System.out.println("d = "+ d.toString() ); //El resuktado es: d = 3.14
Final del formulario

autoboxing
Submitted by ezamudio on Jue, 01/20/2011 - 13:24.
También valdría la pena hablar de autoboxing, característica introducida en Java 5, donde se
hacen conversiones "automágicas" entre por ejemplo int e Integer, long y Long, boolean y Boolean,
etc...

Uso de "Wrappers" y primitivos en

Java
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());

// Convertir/Imprimir Valores de "Wrappers" como float (primitivo)

prt(wi1.floatValue());
prt(wl1.floatValue());
prt(wf1.floatValue());
prt(wd1.floatValue());

// Convertir/Imprimir Valores de "Wrappers" como long (primitivo)

prt(wi1.longValue());
prt(wl1.longValue());
prt(wf1.longValue());
prt(wd1.longValue());

// Convertir/Imprimir Valores de "Wrappers" como 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);

// Convertir/Imprimir Valores de "Wrappers" como 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 a travé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 se emplea un sufijo para definir el valor
del primitivo (L,l,F,f,D,d), lo anterior se hace con la finalidad de asignar un espacio
apropiado para futuras manipulaciones numéricas.

Uso de Sufijos
Aunque el uso de sufijos no es obligatorio, su uso se hace más evidente cuando los primitivos
son empleados para realizar operaciones matemáticas con mayor precisión.
Tomemos un número definido como 14D, aunque el número catorce bien pudiera ser un entero
(int) éste se esta definiendo como un número double a través del sufijo, esto permite que el
número sea manipulado con otros primitivos double sin perder precisión, esta pérdida de
precisión será ilustrada a continuación.
 Posteriormente, se inicializan cuatro "Wrappers" a través de los primitivos definidos
anteriormente.
 Seguido se emplean una serie de declaraciones con el mé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 valores numéricos.
 Se declara otra serie de "Wrappers" que son inicializados a través de 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 en la segunda serie manipulados hacia
"String's" mediante el método auxiliar toString() 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 de los métodos auxiliares parseXXX.
 Finalmente son definidos una serie de métodos prt que toman distintos argumentos
de entrada ; el diseño de estos métodos prt es conocido como overloading, concepto
que será ilustrado a detalle en una futura sección del curso.

Clase de envoltura primitiva

De Wikipedia, la enciclopedia libre
Saltar a navegaciónSaltar a búsqueda
En la programación orientada a objetos, una clase envoltura es una clase que encapsula tipos, de modo
que esos tipos se pueden usar para crear instancias de objetos y métodos en otra clase que necesita esos
tipos. Por lo tanto, una clase de envoltorio primitivo es una clase de envoltorio que encapsula, oculta
o envuelve los tipos de datos de los ocho tipos de datos primitivos, [1] para que puedan usarse para crear
objetos instanciados con métodos en otra clase o en otras clases. [2][3] Las clases primitivas de envoltorio
se encuentran en la API de Java.
Las clases primitivas de envoltorio se usan para crear un Object que necesita representar tipos
primitivos en las clases de Collection (es decir, en la API de Java), en el paquete java.util y en
el paquete de reflexión java.lang.reflect . Las clases de colección son clases definidas por la API
de Java que pueden almacenar objetos de una manera similar a como las estructuras de datos como las
matrices almacenan tipos de datos primitivos como int , double, long o char , etc., [2] pero las matrices
almacenan tipos de datos primitivos mientras que las colecciones en realidad almacenar objetos
Las clases primitivas de envoltura y sus tipos primitivos correspondientes son:

Tipo primitivo Clase de envoltura Argumentos del constructor

byte Byte byte o String

short Short short o de String

int Integer int o String

long Long long o String

float Float float , double o String

double Double double o de String

char Character char

boolean Boolean boolean o String

Contenido

 1La diferencia entre clases de envoltura y tipos primitivos.

 2clases de envoltura atómica
 3vea también
 4referencias

La diferencia entre las clases de

envoltorio y los tipos primitivos [ editar ]
Las clases primitivas de envoltorio no son lo mismo que los tipos
primitivos. Mientras que las variables, por ejemplo, se pueden
declarar en Java como tipos de datos double , short , int , etc., las
clases primitivas de contenedor crean objetos y métodos instanciados
que heredan pero ocultan los tipos de datos primitivos, no como las
variables a las que se asigna el tipo de datos. valores. [2]
Por lo tanto, el término clase de envoltorio primitivo no significa que
las clases de envoltorio sean tipos primitivos. Debe entenderse como
una clase que envuelve tipos primitivos. Las clases de contenedor se
pueden usar para almacenar el mismo valor que para una variable de
tipo primitiva, pero las instancias / objetos de las clases de contenedor
en sí mismas no son primitivas . No podemos decir que las clases
Wrapper en sí mismas sean tipos primitivos. Simplemente envuelven
los tipos primitivos.
 Las
clases Byte , Short , Integer , Long , Float y Double so
n la subclase de la clase Number .
Las clases de envoltura BigDecimal y BigInteger no son una
de las clases de envoltura primitivas, pero son inmutables.[4] [5]

Clases de envoltorios atómicos [ editar ]

Con Java 5.0, se introdujeron clases de envoltura adicionales en el
paquete java.util.concurrent.atomic . Estas clases son
mutables y no se pueden usar como un reemplazo para las clases de
envoltorios normales. En su lugar, proporcionan operaciones
atómicas para adición, incremento y asignación.
Las clases de envoltorios atómicos y sus tipos correspondientes son:

Tipo primitivo Clase de envoltura

int AtomicInteger

long AtomicLong

boolean AtomicBoolean

V AtomicReference<V>

Las clases AtomicInteger y AtomicLong son subclases

de la clase Number . La clase AtomicReference acepta
el parámetro de tipo V que especifica el tipo de referencia
del objeto. (Consulte " Genéricos en Java " para obtener una
descripción de los parámetros de tipo en Java). V

Véase también [ editar ]

 java.lang
 java.lang.reflect
 Lenguaje de programación Java
 Sintaxis de Java
 Compilador de Java

Referencias [ editar ]
 1. Jump up^ SJ Chapman, Introducción a Java , Prentice Hall,
1999.
2. ^ Jump up to:a b c J. Murach, Programación Java de Murach ,
4ª edición, Mike Murach and Associates, Inc., 2011.
3. Jump up^ JR Hubbard, Programación con Java , serie de
contornos de Schaum / McGraw Hill, 1998.
4. Jump up^ David O'Meara (abril de 2003). "Objetos
mutables e inmutables: ¿qué clases son inmutables?" . Java
Ranch . Consultado el 2012-05-14 . Las clases
java.math.BigInteger y BigDecimal tampoco son inmutables,
aunque quizás deberían haberlo sido.
5. Jump up^ Oracle. "Documentación de Java desde
Oracle" . Enteros de precisión arbitraria inmutables.
Categorías :
Java (lenguaje de programación)