¡Hola! Ya conoce bien los tipos primitivos y ha trabajado bastante con ellos. En programación (y Java en particular), las primitivas tienen muchas ventajas: usan poca memoria (y por lo tanto hacen que el programa sea más eficiente) y tienen un rango de valores claramente delineado. Sin embargo, mientras aprendemos Java, ya hemos repetido a menudo el mantra "todo en Java es un objeto". Pero los primitivos contradicen directamente esas palabras. No son objetos. Entonces, ¿es falso nuestro principio de "todo es un objeto"? En realidad, no lo es. En Java, cada tipo primitivo tiene un hermano gemelo, una clase contenedora.
¿Qué es una clase contenedora?
Un contenedor es una clase especial que almacena una primitiva internamente. Pero debido a que es una clase, puede crear instancias de ella. Almacenan los valores primitivos internamente, pero siguen siendo objetos reales. Los nombres de las clases contenedoras son muy similares (o exactamente iguales) a los nombres de sus primitivos correspondientes. Por lo tanto, son fáciles de recordar.
Clases contenedoras para tipos de datos primitivos |
Tipos de datos primitivos |
Clases contenedoras |
En t |
Entero |
corto |
Corto |
largo |
Largo |
byte |
Byte |
flotar |
Flotar |
doble |
Doble |
carbonizarse |
Personaje |
booleano |
booleano |
Los objetos contenedor se crean de la misma manera que cualquier otro objeto:
public static void main(String[] args) {
Integer i = new Integer(682);
Double d = new Double(2.33);
Boolean b = new Boolean(false);
}
Las clases contenedoras nos permiten mitigar las deficiencias de los tipos primitivos. La más obvia es que las primitivas no tienen métodos. Por ejemplo, no tienen un método
toString() , por lo que no puede, por ejemplo, convertir un
int en un
String . Pero la clase contenedora
Integer lo hace fácil.
public static void main(String[] args) {
Integer i = new Integer(432);
String s = i.toString();
}
Sin embargo, convertir en la otra dirección puede ser más complicado. Digamos que tenemos un
String , que sabemos con seguridad que contiene un número. Independientemente, no hay una forma nativa de usar un
int primitivo para extraer el número de
String y convertirlo en un número. Pero, podemos hacerlo con las clases contenedoras.
public static void main(String[] args) {
String s = "1166628";
Integer i = Integer.parseInt(s);
System.out.println(i);
}
Producción:
1166628
Extrajimos con éxito un número de
String y lo asignamos a la variable de referencia
Integer i . Por cierto, en cuanto a las referencias. Ya sabes que los argumentos se pasan a los métodos de diferentes maneras: primitivas por valor y objetos por referencia. Puede usar este conocimiento al crear sus propios métodos: por ejemplo, si su método usa números fraccionarios pero necesita lógica para pasar por referencia, puede pasar argumentos
Double /
Float al método en lugar de
double /
float . Además de los métodos de las clases contenedoras, sus campos estáticos también pueden ser muy convenientes. Por ejemplo, imagina que tienes la siguiente tarea: mostrar el máximo posible
valor int , seguido del valor mínimo posible. Este problema parece bastante básico. Pero sin Google, es poco probable que puedas hacerlo. Pero los envoltorios le permiten manejar fácilmente tales "tareas mundanas":
public class Main {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
}
}
Estos campos evitan que te distraigas de realizar tareas más serias. ¡Sin mencionar el hecho de que escribir
2147483647 (que resulta ser el valor de MAX_VALUE) no es una hazaña menor! :) Además, en una lección anterior, señalamos que los objetos de envoltorio son inmutables.
public static void main(String[] args) {
Integer a = new Integer(0);
Integer b = new Integer(0);
b = a;
a = 1;
System.out.println(b);
}
Producción:
0
El estado del objeto señalado originalmente por
a no cambió (porque el valor de
b también habría cambiado). Al igual que con
String s, en lugar de cambiar el estado del objeto contenedor, se crea un objeto completamente nuevo en la memoria. Entonces, ¿por qué los creadores de Java finalmente decidieron dejar los tipos primitivos en el lenguaje? Ya que todo debería ser un objeto, y tenemos clases contenedoras que pueden expresar todo lo que expresan las primitivas, ¿por qué no mantener las envolturas en el lenguaje y eliminar las primitivas? La respuesta es simple: rendimiento. Los tipos primitivos se denominan primitivos porque carecen de muchas de las características de "peso pesado" de los objetos. Sí, los objetos tienen muchos métodos convenientes, pero no siempre los necesitas. A veces, todo lo que necesitas es el número 33, o 2,62, o
verdadero /
falso . En situaciones donde las ventajas de los objetos no importan y no son necesarias para que el programa funcione, las primitivas se adaptan mucho mejor a la tarea.
GO TO FULL VERSION