Una clase Wrapper es una clase cuyo objeto envuelve o contiene tipos de datos primitivos. Cuando creamos un objeto para una clase contenedora, contiene un campo y en este campo podemos almacenar tipos de datos primitivos. En otras palabras, podemos envolver un valor primitivo en un objeto de clase contenedora.
Necesidad de clases contenedoras
- Convierten tipos de datos primitivos en objetos. Los objetos son necesarios si deseamos modificar los argumentos pasados a un método (porque los tipos primitivos se pasan por valor).
- Las clases en el paquete java.util manejan solo objetos y, por lo tanto, las clases contenedoras también ayudan en este caso.
- Las estructuras de datos en el marco de Collection, como ArrayList y Vector , almacenan solo objetos (tipos de referencia) y no tipos primitivos.
- Se necesita un objeto para admitir la sincronización en subprocesos múltiples.
Tipos de datos primitivos y su clase contenedora correspondiente
Autoboxing y Unboxing
Autoboxing: la conversión automática de tipos primitivos al objeto de sus clases contenedoras correspondientes se conoce como autoboxing. Por ejemplo: conversión de int a Integer, long a Long, double a Double, etc.
Ejemplo:
// Java program to demonstrate Autoboxing
import java.util.ArrayList;
class Autoboxing
{
public static void main(String[] args)
{
char ch = 'a';
// Autoboxing- primitive to Character object conversion
Character a = ch;
ArrayList<Integer> arrayList = new ArrayList<Integer>();
// Autoboxing because ArrayList stores only objects
arrayList.add(25);
// printing the values from object
System.out.println(arrayList.get(0));
}
}
Producción:
25
Unboxing: Es simplemente el proceso inverso al autoboxing. La conversión automática de un objeto de una clase contenedora a su tipo primitivo correspondiente se conoce como unboxing. Por ejemplo: conversión de Integer a int, Long a long, Double a double, etc.
// Java program to demonstrate Unboxing
import java.util.ArrayList;
class Unboxing
{
public static void main(String[] args)
{
Character ch = 'a';
// unboxing - Character object to primitive conversion
char a = ch;
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(24);
// unboxing because get method returns an Integer object
int num = arrayList.get(0);
// printing the values from primitive data types
System.out.println(num);
}
}
Producción:
24
Implementación
// Java program to demonstrate Wrapping and UnWrapping
// in Java Classes
class WrappingUnwrapping
{
public static void main(String args[])
{
// byte data type
byte a = 1;
// wrapping around Byte object
Byte byteobj = new Byte(a);
// int data type
int b = 10;
//wrapping around Integer object
Integer intobj = new Integer(b);
// float data type
float c = 18.6f;
// wrapping around Float object
Float floatobj = new Float(c);
// double data type
double d = 250.5;
// Wrapping around Double object
Double doubleobj = new Double(d);
// char data type
char e='a';
// wrapping around Character object
Character charobj=e;
// printing the values from objects
System.out.println("Values of Wrapper objects (printing as objects)");
System.out.println("Byte object byteobj: " + byteobj);
System.out.println("Integer object intobj: " + intobj);
System.out.println("Float object floatobj: " + floatobj);
System.out.println("Double object doubleobj: " + doubleobj);
System.out.println("Character object charobj: " + charobj);
// objects to data types (retrieving data types from objects)
// unwrapping objects to primitive data types
byte bv = byteobj;
int iv = intobj;
float fv = floatobj;
double dv = doubleobj;
char cv = charobj;
// printing the values from data types
System.out.println("Unwrapped values (printing as data types)");
System.out.println("byte value, bv: " + bv);
System.out.println("int value, iv: " + iv);
System.out.println("float value, fv: " + fv);
System.out.println("double value, dv: " + dv);
System.out.println("char value, cv: " + cv);
}
}
Producción:
Values of Wrapper objects (printing as objects) Byte object byteobj: 1 Integer object intobj: 10 Float object floatobj: 18.6 Double object doubleobj: 250.5 Character object charobj: a Unwrapped values (printing as data types) byte value, bv: 1 int value, iv: 10 float value, fv: 18.6 double value, dv: 250.5 char value, cv: a
Artículo relacionado:
Comparación de objetos enteros en caja automática en Java
Este artículo es una contribución de Nishant Sharma . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@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.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA