Tipos de datos básicos de Java

Las variables solicitan memoria para almacenar valores. En otras palabras, al crear una variable, es necesario solicitar espacio en la memoria.

El sistema de gestión de memoria asigna espacio de almacenamiento a las variables según su tipo, y el espacio asignado solo se puede utilizar para almacenar datos de este tipo.

Por lo tanto, al definir variables de diferentes tipos, se pueden almacenar en la memoria números enteros, decimales o caracteres.

Los dos tipos de datos principales de Java:

• Tipos de datos integrados

• Tipo de datos de referencia

Tipos de datos integrados

El lenguaje Java proporciona ocho tipos básicos. Seis tipos numéricos (cuatro enteros, dos tipos de punto flotante), un tipo de carácter y un tipo booleano.

tipo de byte:

• El tipo de datos byte es un entero de 8 bits con signo representado en complemento a dos;

• El valor mínimo es -128 (-2^7);

• El valor máximo es 127 (2^7-1);

• El valor predeterminado es 0;

• El tipo byte se utiliza para ahorrar espacio en matrices grandes, principalmente reemplazando números enteros, porque la variable byte ocupa solo una cuarta parte del espacio del tipo int;

• Ejemplo: byte a = 100, byte b = -50.

tipo corto (tipo entero corto):

• El tipo de datos cortos es un entero en complemento a dos con signo de 16 bits.

• El valor mínimo es -32768 (-2^15);

• El valor máximo es 32767 (2^15 - 1);

• El tipo de datos Corto también puede ahorrar espacio como un byte. Una variable corta ocupa la mitad del espacio que ocupa una variable de tipo int;

• El valor predeterminado es 0;

• Ejemplo: s corto = 1000, r corto = -20000.

tipo int (tipo entero):

• El tipo de datos int es un entero con signo de 32 bits representado en complemento a dos;

• El valor mínimo es -2.147.483.648 (-2^31);

• El valor máximo es 2.147.483.647 (2^31 - 1);

• Generalmente, las variables enteras por defecto escriben int;

• El valor predeterminado es 0;

• Ejemplo: int a = 100000, int b = -200000.

largo (tipo entero largo):

• El tipo de datos largos es un entero con signo de 64 bits representado en complemento a dos;

• El valor mínimo es -9.223.372.036.854.775.808 (-2^63);

• El valor máximo es 9.223.372.036.854.775.807 (2^63 -1);

• Este tipo se utiliza principalmente en sistemas que necesitan comparar números enteros grandes;

• El valor predeterminado es 0L;

• Ejemplo: largo a = 100000L, largo b = -200000L.

float (tipo de punto flotante de precisión simple):

• El tipo de datos flotante es un número de punto flotante de 32 bits de precisión simple que cumple con el estándar IEEE 754;

• float puede ahorrar espacio en la memoria al almacenar grandes matrices de punto flotante;

• El valor predeterminado es 0,0f;

• Los números de coma flotante no se pueden utilizar para representar valores precisos como la moneda;

• Ejemplo: flotador f1 = 234,5f.

doble (tipo coma flotante de doble precisión):

• El tipo de datos doble es un número de coma flotante compatible con IEEE 754, de 64 bits y de doble precisión;

• El tipo predeterminado de números de coma flotante es doble;

• El tipo doble tampoco puede representar valores precisos, como la moneda;

• El valor predeterminado es 0,0d;

• Ejemplo: doble d1 = 123,4.

booleano:

• El tipo de datos booleano representa un bit de información;

• Sólo hay dos valores: verdadero y falso;

• Este tipo sólo se utiliza como indicador para registrar situaciones de verdadero/falso;

• El valor predeterminado es falso;

• Ejemplo: booleano uno = verdadero.

char (tipo de carácter):

• El tipo char es un único carácter Unicode de 16 bits;

• El valor mínimo es 'u0000' (es decir, 0);

• El valor máximo es 'uffff' (es decir, 65.535);

• El tipo de datos char puede almacenar cualquier carácter;

• Ejemplo: letra char = 'A'.

Ejemplo

Para el rango de valores de los tipos básicos de tipos numéricos, no es necesario que nos obliguen a recordarlos, porque sus valores se han definido en la clase contenedora correspondiente en forma de constantes. Consulte el siguiente ejemplo:

 prueba de tipo primitivo de clase pública {
público estático vacío principal (String [] argumentos) {
//byte
System.out.println("Tipo básico: byte Dígitos binarios: " + Byte.SIZE);
System.out.println("Clase de empaquetado: java.lang.Byte");
System.out.println("Valor mínimo: Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("Valor máximo: Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();

// corto
System.out.println("Tipo básico: dígitos binarios cortos: " + Short.SIZE);
System.out.println("Clase de empaquetado: java.lang.Short");
System.out.println("Valor mínimo: Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("Valor máximo: Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();

//int
System.out.println("Tipo básico: int Dígitos binarios: " + Integer.SIZE);
System.out.println("Clase de empaquetado: java.lang.Integer");
System.out.println("Valor mínimo: Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("Valor máximo: Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();

// largo
System.out.println("Tipo básico: largo Número de dígitos binarios: " + Long.SIZE);
System.out.println("Clase de empaquetado: java.lang.Long");
System.out.println("Valor mínimo: Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("Valor máximo: Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();

// flotar
System.out.println("Tipo básico: float Número de dígitos binarios: " + Float.SIZE);
System.out.println("Clase de empaquetado: java.lang.Float");
System.out.println("Valor mínimo: Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("Valor máximo: Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();

//doble
System.out.println("Tipo básico: doble Dígitos binarios: " + Double.SIZE);
System.out.println("Clase de empaquetado: java.lang.Double");
System.out.println("Valor mínimo: Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("Valor máximo: Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();

// carácter
System.out.println("Tipo básico: char Dígitos binarios: " + Carácter.SIZE);
System.out.println("Clase de empaquetado: java.lang.Character");
// Salida Character.MIN_VALUE a la consola en forma numérica en lugar de caracteres System.out.println("Valor mínimo: Character.MIN_VALUE="
+ (int) Carácter.MIN_VALUE);
// Salida Character.MAX_VALUE a la consola en forma numérica en lugar de caracteres System.out.println("Valor máximo: Character.MAX_VALUE="
+ (int) Carácter.MAX_VALUE);
}
}

El resultado de compilar el código anterior es el siguiente:

 Tipo básico: byte Dígitos binarios: 8
Clase de ajuste: java.lang.Byte
Valor mínimo: Byte.MIN_VALUE=-128
Valor máximo: Byte.MAX_VALUE=127
Tipo básico: corto Dígitos binarios: 16
Clase de ajuste: java.lang.Short
Valor mínimo: Short.MIN_VALUE=-32768
Valor máximo: Short.MAX_VALUE=32767


Tipo básico: int Dígitos binarios: 32
Clase de ajuste: java.lang.Integer
Valor mínimo: Entero.MIN_VALUE=-2147483648
Valor máximo: Integer.MAX_VALUE=2147483647


Tipo básico: largo Número de dígitos binarios: 64
Clase de ajuste: java.lang.Long
Valor mínimo: Long.MIN_VALUE=-9223372036854775808
Valor máximo: Long.MAX_VALUE=9223372036854775807


Tipo básico: flotante Número de dígitos binarios: 32
Clase de ajuste: java.lang.Float
Valor mínimo: Float.MIN_VALUE=1.4E-45
Valor máximo: Float.MAX_VALUE=3.4028235E38


Tipo básico: doble Dígitos binarios: 64
Clase de ajuste: java.lang.Double
Valor mínimo: Double.MIN_VALUE=4.9E-324
Valor máximo: Double.MAX_VALUE=1.7976931348623157E308


Tipo básico: char Dígitos binarios: 16
Clase de ajuste: java.lang.Character
Valor mínimo: Carácter.MIN_VALUE=0
Valor máximo: Character.MAX_VALUE=65535

Los valores mínimo y máximo de Float y Double se generan en forma de notación científica. El "número E +" al final significa que el número antes de E debe multiplicarse por la potencia del "número" de 10. Por ejemplo, 3,14E3 es 3,14×1000=3140 y 3,14E-3 es 3,14/1000=0,00314.

De hecho, existe otro tipo básico de vacío en JAVA, que también tiene una clase de empaquetado correspondiente java.lang.Void, pero no podemos operarlo directamente.

tipo de referencia

• Las variables de tipo de referencia las crea el constructor de una clase y puede usarlas para acceder al objeto referenciado. Estas variables se especifican como un tipo específico cuando se declaran, como Empleado, Pubby, etc. Una vez declarada una variable, su tipo no se puede cambiar.

• Los objetos y las matrices son tipos de datos de referencia.

• El valor predeterminado para todos los tipos de referencia es nulo.

• Se puede utilizar una variable de referencia para hacer referencia a cualquier tipo compatible.

• Ejemplo: Animal animal = nuevo Animal("jirafa").

constantes de java

Una constante es un valor fijo. No requieren cálculo y representan directamente los valores correspondientes.

Una constante se refiere a una cantidad que no se puede cambiar. El indicador final se usa en Java y el método de declaración es similar al de las variables:

 doble IP final = 3,1415927;

Aunque los nombres de las constantes también pueden estar en minúsculas, para facilitar la identificación, normalmente se utilizan letras mayúsculas para representar las constantes.

Los literales se pueden asignar a variables de cualquier tipo integrado. Por ejemplo:

 byte a = 68;
carácter a = 'A'

Byte, int, long y short se pueden representar en notación decimal, hexadecimal y octal.

Cuando se utilizan constantes, el prefijo 0 indica octal y el prefijo 0x indica hexadecimal. Por ejemplo:

 entero decimal = 100;
entero octal = 0144;
int hexadecimal = 0x64;

Al igual que otros lenguajes, las constantes de cadena de Java son secuencias de caracteres encerrados entre dos comillas. El siguiente es un ejemplo de una cadena literal:

 "Hola Mundo"
"dosnlíneas"
""Esto está entre comillas""

Tanto las constantes de cadena como las constantes de caracteres pueden contener cualquier carácter Unicode. Por ejemplo:

 char a = 'u0001';
Cadena a = "u0001";

El lenguaje Java admite algunas secuencias especiales de caracteres de escape.

Esta sección explica los tipos de datos básicos de Java. La siguiente sección explora los diferentes tipos de variables y sus usos.