English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriales básicos de Java

Java 流程控制

Java 数组

Java 面向对象(I)

Java 面向对象(II)

Java 面向对象(III)

Manejo de excepciones en Java

Java 列表(List)

Java Queue(队列)

Java Map集合

Java Set集合

Java 输入输出(I/O)

Java Reader/Writer

Java 其他主题

Tipos de datos básicos de Java

变量就是申请内存来存储值。也就是说,当创建变量的时候,需要在内存中申请空间。

内存管理系统根据变量的类型为变量分配存储空间,分配的空间只能用来储存该类型数据。

因此,通过定义不同类型的变量,可以在内存中储存整数、小数或者字符。

Java 的两大数据类型:

  • 内置数据类型

  • 引用数据类型

内置数据类型

Java 语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。

byte:

  • byte 数据类型是8位、有符号的,以二进制补码表示的整数;

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

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

  • El valor predeterminado es 0;

  • byte 类型用在大型数组中节约空间,主要代替整数,因为 byte 变量占用的空间只有 int 类型的四分之一;

  • 实例:byte a = 100,byte b = -50。

short:

  •  El tipo de datos short es 16 enteros enteros, representados en complemento a dos

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

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

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

  •  El valor predeterminado es 0;

  • Ejemplo: short s = 1000, short r = -20000。

int:

  • El tipo de datos int es32enteros enteros, representados 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 son del tipo int por defecto;

  • El valor predeterminado es 0;

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

long:

  • El tipo de datos long es 64 enteros enteros, representados 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 grandes enteros;

  • El valor predeterminado es 0L;

  •  Ejemplo: long a = 100000L, Long b = -200000L。
    "L" teóricamente no distingue entre mayúsculas y minúsculas, pero si se escribe como "l", es fácil confundirse con el número"1"Ambiguo, difícil de distinguir. Por lo tanto, es mejor escribirlo en mayúsculas."

float:

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

  • El tipo de datos float puede ahorrar espacio de memoria al almacenar grandes matrices de números flotantes;

  •  El valor predeterminado es 0.0f;

  •  Los números flotantes no se pueden usar para representar valores precisos, como el dinero;

  •  Ejemplo: float f1 = 234.5f。

double:

  • El tipo de datos double es de precisión doble,64 bits, cumple con el estándar IEEE 754Número flotante estándar;

  •  El tipo de datos flotante por defecto es double;

  •  El tipo de datos double no puede representar valores precisos, como el dinero;

  •  El valor predeterminado es 0.0d;

  •  Ejemplo: double d1 = 123.4.

boolean:

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

  • Tiene solo dos valores: true y false;

  •  Este tipo se utiliza solo como una señal para registrar true/condición false;

  •  El valor predeterminado es false;

  •  Ejemplo: boolean one = true。

char:

  •  El tipo de datos char es un solo 16 carácter Unicode;

  •   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: char letter = 'A';.

Ejemplo

Para los rangos de valores de los tipos básicos numéricos, no es necesario memorizarlos a la fuerza, ya que sus valores ya están definidos como constantes en las clases de envoltorio correspondientes. Vea el siguiente ejemplo:

public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte  
        System.out.println("Tipos básicos: byte, bits binarios: ") + Byte.SIZE)  
        System.out.println("Clase envolvente: java.lang.Byte")  
        System.out.println("El valor mínimo: Byte.MIN_VALUE=") + Byte.MIN_VALUE)  
        System.out.println("El valor máximo: Byte.MAX_VALUE=") + Byte.MAX_VALUE)  
        System.out.println();  
  
        // short  
        System.out.println("Tipo básico: short,位数 en binario:") + Short.SIZE)  
        System.out.println("Clase envolvente: java.lang.Short")  
        System.out.println("El valor mínimo: Short.MIN_VALUE=") + Short.MIN_VALUE)  
        System.out.println("El valor máximo: Short.MAX_VALUE=") + Short.MAX_VALUE)  
        System.out.println();  
  
        // int  
        System.out.println("Tipo básico: int,位数 en binario:") + Integer.SIZE)  
        System.out.println("Clase envolvente: java.lang.Integer")  
        System.out.println("El valor mínimo: Integer.MIN_VALUE=") + Integer.MIN_VALUE)  
        System.out.println("El valor máximo: Integer.MAX_VALUE=") + Integer.MAX_VALUE)  
        System.out.println();  
  
        // long  
        System.out.println("Tipo básico: long,位数 en binario:") + Long.SIZE)  
        System.out.println("Clase envolvente: java.lang.Long")  
        System.out.println("El valor mínimo: Long.MIN_VALUE=") + Long.MIN_VALUE)  
        System.out.println("El valor máximo: Long.MAX_VALUE=") + Long.MAX_VALUE)  
        System.out.println();  
  
        // float  
        System.out.println("Tipo básico: float,位数 en binario:") + Float.SIZE)  
        System.out.println("Clase envolvente: java.lang.Float")  
        System.out.println("El valor mínimo: Float.MIN_VALUE=") + Float.MIN_VALUE);  
        System.out.println("Valor máximo: Float.MAX_VALUE="); + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("Tipo básico: double位数 binario:"); + Double.SIZE);  
        System.out.println("Clase de envoltura: 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();  
  
        // char  
        System.out.println("Tipo básico: char位数 binario:"); + Character.SIZE);  
        System.out.println("Clase de envoltura: java.lang.Character");  
        // Salida de Character.MIN_VALUE en forma numérica en lugar de como carácter en la consola  
        System.out.println("Valor mínimo: Character.MIN_VALUE=");  
                + (int) Character.MIN_VALUE);  
        // Salida de Character.MAX_VALUE en forma numérica en lugar de como carácter en la consola  
        System.out.println("Valor máximo: Character.MAX_VALUE=");  
                + (int) Character.MAX_VALUE);  
    }  
}

El resultado de la compilación del código anterior se muestra a continuación:

Tipo básico: byte位数 binario:8
Clase de envoltura: java.lang.Byte
Valor mínimo: Byte.MIN_VALUE=-128
Valor máximo: Byte.MAX_VALUE=127
Tipo básico: short位数 binario:16
Clase de envoltura: java.lang.Short
Valor mínimo: Short.MIN_VALUE=-32768
Valor máximo: Short.MAX_VALUE=32767
Tipo básico: int位数 binario:32
Clase de envoltura: java.lang.Integer
Valor mínimo: Integer.MIN_VALUE=-2147483648
Valor máximo: Integer.MAX_VALUE=2147483647
Tipo básico: long位数 binario:64
Clase de envoltura: java.lang.Long
Valor mínimo: Long.MIN_VALUE=-9223372036854775808
Valor máximo: Long.MAX_VALUE=9223372036854775807
Tipo de datos básico: float Tamaño en bits:32
Clase de envoltura: java.lang.Float
Valor mínimo: Float.MIN_VALUE=1.4E-45
Valor máximo: Float.MAX_VALUE=3.4028235E38
Tipo de datos básico: double Tamaño en bits:64
Clase de envoltura: java.lang.Double
Valor mínimo: Double.MIN_VALUE=4.9E-324
Valor máximo: Double.MAX_VALUE=1.7976931348623157E308
Tipo de datos básico: char Tamaño en bits:16
Clase de envoltura: java.lang.Character
Valor mínimo: Character.MIN_VALUE=0
Valor máximo: Character.MAX_VALUE=65535

Los valores máximos y mínimos de Float y Double se muestran en forma de notación científica, y el "E" al final+número "E" representa que el número antes de "E" debe multiplicarse por10cuántas veces. Por ejemplo3.14E3es3.14 × 103 =3140,3.14E-3 es 3.14 x 10-3 =0.00314.

En realidad, en JAVA también existe otro tipo de datos básicos void, que también tiene su clase de envoltura java.lang.Void, pero no podemos operar directamente con ellos.

Valores por defecto de los tipos

A continuación se muestra una tabla con los valores por defecto de los tipos de datos en Java:

Tipo de datosValor por defecto
byte0
short0
int0
long0L
float0.0f
double0.0d
char'u0000'
String (o cualquier objeto)null
booleanfalse

Ejemplo en línea

public class Test {
    static boolean bool;
    static byte by;
    static char ch;
    static double d;
    static float f;
    static int i;
    static long l;
    static short sh;
    static String str;
 
    public static void main(String[] args) {
        System.out.println("Bool: ") + bool);
        System.out.println("Byte: ") + by);
        System.out.println("Character: ") + ch);
        System.out.println("Double: ") + d);
        System.out.println("Float: ", + f);
        System.out.println("Integer: ", + i);
        System.out.println("Long: ", + l);
        System.out.println("Short: ", + sh);
        System.out.println("String: ", + str);
    }
}

El resultado de la salida de ejemplo es:

Bool: false
Byte: 0
Character:
Double: 0.0
Float: 0.0
Integer: 0
Long: 0
Short: 0
String: null

 Tipos de datos de referencia

  •  En Java, las variables de tipo de referencia son muy similares a las de C/C++Punteros. Los tipos de datos de referencia apuntan a un objeto, y las variables que apuntan al objeto son variables de referencia. Estas variables se especifican como un tipo específico en el momento de la declaración, como Employee, Puppy, etc. Una vez declaradas, el tipo no puede cambiarse.

  • Los objetos y los arrays son tipos de datos de referencia.

  •  El valor predeterminado de todos los tipos de datos de referencia es null.

  •  Una variable de referencia se puede usar para referir a cualquier tipo compatible.

  •  Ejemplo: Site site = new Site("w3codebox")

Constantes de Java

Las constantes no pueden modificarse durante la ejecución del programa.

En Java, se utiliza la palabra clave final para modificar las constantes, con un formato de declaración similar al de las variables:

final double PI = 3.1415927;

Aunque los nombres de las constantes también pueden usarse en minúsculas, se utiliza generalmente en mayúsculas para facilitar su identificación.

Los literales pueden asignarse a cualquier tipo de variable integrado. Por ejemplo:

byte a = 68;
char a = 'A'

byte, int, long y short pueden usar decimal,16Sistemas de numeración y8manera de sistema de numeración.

Al usar constantes, el prefijo 0 representa 8 Sistemas de numeración, mientras que el prefijo 0x representa 16 Sistemas de numeración, por ejemplo:

int decimal = 100;
int octal = 0144;
int hexa = 0x64;

Al igual que en otros lenguajes, las constantes de cadena en Java son secuencias de caracteres que se encierran entre comillas dobles. A continuación se muestra un ejemplo de literal de tipo cadena:

"Hello World"
"two\nlines"
"\"This is in quotes\""

Las constantes de cadena y los caracteres constantes pueden contener cualquier carácter Unicode. Por ejemplo:

char a = '\u000'1';
String a = "\u0001";

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

                        Símbolo                        Significado del carácter
                        \n                        Salto de línea (0x0a)
                        \r                        Retorno de carro (0x0d)
                        \f                        Página de cambio (0x0c)
                        \b                        Retroceso (0x08)
                        \0                        Carácter de espacio en blanco (0x0)
                        \s                        Espacio (0x20)
                        \t                        Tabulador
                        \"                        Comilla doble
                        \'                        Comilla simple
                        \\                        Barra invertida
                        \ddd                        Carácter octal (ddd)
                        \uxxxx                        16Carácter Unicode en sistema de numeración decimal (xxxx)

Conversión automática de tipo

Los datos de tipo entero, real (constante) y carácter pueden mezclarse en operaciones. En las operaciones, los datos de diferentes tipos se convierten primero en el mismo tipo y luego se realizan las operaciones.

La conversión es de bajo a alto.

Bajo  ------------------------------------> Alto
byte,short,char -> int -> long -> float -> double

La conversión de tipos de datos debe cumplir con las siguientes reglas:

  • 1. No se puede realizar la conversión de tipo en el tipo boolean.

  • 2. No se puede convertir un tipo de objeto en un objeto de clase no relacionada.

  • 3. Al convertir tipos de datos de gran capacidad a tipos de datos de pequeña capacidad debe utilizarse la conversión de tipo forzada.

  • 4. Durante el proceso de conversión puede ocurrir desbordamiento o pérdida de precisión, por ejemplo:

    int i =128;   
    byte b = (byte)i;

    porque el tipo de datos byte es 8 bits, el valor máximo es127por lo que al convertir forzadamente int a byte, el valor 128 puede causar desbordamiento.

  • 5. La conversión de flotante a entero se realiza mediante la eliminación de los decimales, no redondeando, por ejemplo:

    (int)23.7 == 23;        
    (int)-45.89f == -45

Conversión automática de tipo

Deben cumplirse las condiciones de que el número de bits del tipo de datos antes de la conversión sea menor que el número de bits del tipo de datos después de la conversión, por ejemplo: el tipo de datos short tiene un número de bits de16bits, por lo que se puede convertir en bits32de tipo int, y los datos de tipo float tienen un número de bits de32puede convertirse automáticamente en64de tipo double.

public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//Definir un tipo de dato char
            int i1 = c1;//La conversión automática de char a int
            System.out.println("El valor igual a después de convertir char a int automáticamente"+i1);
            char c2 = 'A';//Definir un tipo de dato char
            int i2 = c2+1;//El cálculo de char y int
            System.out.println("El valor calculado de char y int es igual a"+i2);
        }
}

El resultado de la ejecución es:

El valor igual a después de convertir char a int automáticamente97
El valor calculado de char y int es igual a66

Análisis:c1 el valor es el carácter a , y según la tabla ASCII, el valor del tipo int correspondiente es 97corresponde a 65por lo que i2=65+1=66.

Conversión explícita

  • 1. La condición es que el tipo de datos a convertir debe ser compatible.

  • 2. Formato: (type)value, donde type es el tipo de datos al que se realizará la conversión explícita   Ejemplo:

    public class QiangZhiZhuanHuan{
        public static void main(String[] args){
            int i1 = 123;
            byte b = (byte)i1;//Conversión explícita a byte
            System.out.println("El valor de int que se convierte a byte es igual a ")+b);
        }
    }

    Resultados de ejecución:

    El valor de int que se convierte a byte es igual a123

Conversión implícita de tipos

  • 1. El tipo de datos predeterminado para los enteros es int.

  • 2. No existe este caso para los números de punto flotante, ya que al definir el tipo float es necesario agregar F o f después del número.

Esta sección explica los tipos de datos básicos de Java. La próxima sección abordará diferentes tipos de variables y su uso.