constante de cadena	Rodeado de "", como "12345", "hola", "hola"
constante entera	Números escritos directamente en el programa (tenga en cuenta que no hay punto decimal), como: 100, 1000
constante de punto flotante	Decimales escritos directamente en el programa, tales como: 3.14, 0.49
constante de caracter	Un carácter entre comillas simples, por ejemplo: 'A', '1'
constante booleana	Solo hay dos clases de verdadero y falso.
constante vacía	nulo

2. Tipo de datos

Los tipos de datos de Java se dividen principalmente en dos categorías: tipos de datos básicos y tipos de datos de referencia

Hay ocho tipos de datos básicos en cuatro categorías:

Cuatro categorías:

Entero, Flotante, Char, Booleano

Ocho tipos:

tipo de datos	palabras clave	uso de memoria	alcance
tipo de caracter	byte	1 byte	-128~127
tipo de caracter	byte	1 byte	-128~127
Entero	En t	4 bytes	-2^31~ 2^32-1
Entero largo	largo	8 bytes	-2^63~ 2^63-1
número de punto flotante de precisión simple	flotar	4 bytes	Hay alcance, generalmente no se trata
número de punto flotante de precisión doble	doble	8 bytes	Hay alcance, generalmente no se trata
tipo de caracter	carbonizarse	2 bytes	0 ~ 65535 (Unicódigo)
booleano	booleano	no está claramente especificado	verdadero Falso

Tipo de datos de referencia :

Matrices, cadenas, clases, interfaces, enumeraciones...

3. Variables

3.1 El concepto y la sintaxis de las variables

Las constantes son siempre las mismas, y en un programa, algunos contenidos pueden cambiar con frecuencia. Para este contenido que cambia con frecuencia, en Java, se denomina variable . Los tipos de datos se utilizan para definir diferentes tipos de variables.

Una variable es equivalente a una caja pequeña, en la que se pueden poner cosas, y la caja puede ser grande o pequeña.

Clase contenedora: cada tipo de datos básico corresponde a un tipo de clase, y este tipo de clase es la clase contenedora

El formato de sintaxis para definir variables es:
tipo de datos nombre de variable = valor inicial;

3.2 Variables enteras

3.2.1 Variable entera (int)

1. Tamaño: int es de 4 bytes (el tipo portátil es fuerte , ya sea de 4 bytes en sistemas de 32 o 64 bits);

Representa el rango (-2^31 ~ 2^31-1)

2. Clase contenedora: el tipo contenedor de int es Integer

3. En Java, int no tiene los llamados números sin signo, por lo que int puede representar números tanto positivos como negativos.

public class TestDemo {
    public static void main(String[] args) {
        //1.在定义时给出初始值
        int a = 10;
        System.out.println(a);
 
        //2.在定义时没有给初始值，但使用时必须设置初始值
        int b;
        b = 10;
        System.out.println(b);
 
        //3.int 型变量的表示范围
        System.out.println("最大值"+Integer.MAX_VALUE);
        System.out.println("最小值"+Integer.MIN_VALUE);
 
        //4.在定义int 性变量时，所赋值不能超过int的范围
        int d = 1234566702334;//编译时报错，初值超过int的范围
 
    }
}

3.2.2 Variable entera larga (larga)

1. Tamaño: long ocupa 8 bytes independientemente del sistema operativo que se utilice

Representa el rango (-2^63 ~ 2^63-1)

2. Agregue L o l después del valor inicial de la variable entera larga

3. Clase de embalaje: El tipo de embalaje de largo es Largo

 public calss TestDemo{
   public static void main1(String[] args) {
        //1.long 为了区分int和long,一般给long类型变量的初始值之后加上L或l
        long a = 10L;
        System.out.println(a);
        //2.long类型表示的范围
        System.out.println("最大值"+Long.MAX_VALUE);
        System.out.println("最小值"+Long.MIN_VALUE);
    }
}

3.2.2 Variables enteras cortas (cortas)

1. Tamaño: corto ocupa 2 bytes bajo cualquier sistema

Representa el rango (-2^15 ~ 2^15-1)

2. No hay números cortos sin firmar que pueden representar números positivos o negativos

3. Tipo de clase contenedora: el tipo de clase contenedora de short es Short

public class TestDome{
public static void main(String[] args) {
 
    short a = 10;
    System.out.println(a);
 
    //short型表示的范围
    System.out.println("最大值"+Short.MAX_VALUE);
    System.out.println("最小值"+Short.MIN_VALUE);
}
}

3.2.4 Variable de byte (byte)

1. Tamaño: el byte ocupa 1 byte en cualquier sistema

Rango (-2^7 ~ 2^7-1, es decir, -128~127)

2. Tipo de clase de empaquetado: el tipo de clase de empaquetado de bytes es Byte

public class TestDome{
public static void main(String[] args) {
    
    byte b = 10;
    System.out.println(b);
    
    //byte型所表示的范围
    System.out.println(Byte.MAX_VALUE);
    System.out.println(Byte.MIN_VALUE);
}
 
}

3.3 Variables de coma flotante

3.3.1 Punto flotante de precisión simple (float)

1. Tamaño: float ocupa 4 bytes en cualquier sistema de tamaño

2. Tipo de clase contenedora: el tipo de clase contenedora de float es Float

3. Agregue F o f después del valor inicial de la variable flotante

public class TestDome{
    public static void main(String[] args) {
        
        float num = 1.0F;
        System.out.println(num);
    }
}

3.3.2 Tipo de punto flotante de precisión doble (doble)

1. Tamaño: doble ocupa 8 bytes bajo cualquier sistema

2. Tipo de clase contenedora: el tipo de clase contenedora de double es Double

3. El tipo doble sigue el estándar IEEE 754 para el diseño de la memoria. El número de coma flotante es un valor aproximado, no un valor exacto.

public static void main4(String[] args) {
    
    double d = 3.14;
    System.out.println(d);
    
}

3.4 Variables de carácter (char)

1. Tamaño: char ocupa 2 bytes en cualquier sistema de tamaño y no puede representar números negativos

2. ASCII se usa para representar caracteres en lenguaje C, mientras que Unicode se usa para representar caracteres en Java

Por lo tanto, hay más tipos de representación (0~65535), incluidos muchos idiomas chino, latín, etc.

3. Tipo de clase de empaque: el tipo de clase de empaque de char es Carácter

public static void main(String[] args) {
    
    char ch = 'a';
    char ch2 = '高';
    char ch3 = '1';
    System.out.println(ch);
    System.out.println(ch2);
    System.out.println(ch3);
}

3.5 Variables booleanas

1. La variable de tipo booleano tiene solo dos valores, verdadero significa verdadero o falso significa falso

2. El tipo booleano y el tipo int de Java no se pueden convertir entre sí. No hay 1 para verdadero ni 0 para falso.

3. Tipo de clase contenedora: el tipo de clase contenedora de booleano es booleano

4. En la máquina virtual Java no se especifica claramente cuántos bytes ocupa Boolean

public class TestDome{
public static void main(String[] args) {
    
    boolean value = true;
    System.out.println(value);
}
}

3.6 Conversión de tipos

3.6.1 Conversión automática de tipos (Conversión implícita de tipos)

La conversión automática de tipos significa que el código no necesita someterse a ningún procesamiento y el compilador lo procesará automáticamente cuando se compile el código . Características: cuando el rango de datos es pequeño y el rango de datos es grande, se llevará a cabo automáticamente .

Es decir, pequeña escala -> gran escala puede

Gran escala -> pequeña escala No

public class TestDome{
   public static void main(String[] args) {
        System.out.println(1024);//整型情况下默认为int
        System.out.println(3.14);//浮点型情况下默认为double
        
        int a = 100;
        long b = 10L;
        
        b = a;//a是int 小范围，b是long 大范围 ，把小范围赋给大范围，会自动将a提升为大范围也就是long类型
        
        a =b;//这样反过来的话就是 大范围-》小范围 会有数据丢失不安全
        
        float f = 3.14F;
        double d = 5.12;
        
        d = f;//小范围-》大范围，可以，f会自动转化为double
        
        f = d;//大范围-》小范围，不可以，会有数据丢失不安全
        
        byte b1 = 100;//编译通过
        byte b2 = 257;//编译失败，257超过byte的数据范围，有数据丢失
    }
}

3.6.2 Coerción (Conversión de tipo explícita)

Conversión de tipo obligatoria: al realizar una operación, el código debe procesarse en un formato determinado, lo que no se puede hacer automáticamente. Características: desde un rango de datos grande hasta un rango de datos pequeño.

cual es

Cuando ocurre el lanzamiento: rango grande -> rango pequeño

public class TestDome{   
public static void main(String[] args) {
 
        int a = 10;
        long b = 100L;
        b = a;//小范围-》大范围   可以
        a = (int)b;//大范围-》小范围 需要强制转化
 
        float f = 3.14F;
        double d = 5.12;
        d = f;//小范围-》大范围   可以
        f = (float)d;// 大范围-》小范围  需要强制转化
 
        a = d;//报错，类型不兼容
        a = (int)d;//大范围-》小范围 ，需要强转，小数点之后全部丢弃
 
        byte b1 = 100;//100默认为int，隐式转换后，没有超过byte范围
        byte b2 = (byte)257;//257默认为int，超过了byte范围，需要强制转化
        
        boolean flag = true;
        a = flag;//编译失败
        flag = a;//编译失败 类型不兼容
    }
}

Darse cuenta:

1. Conversión implícita a pequeña escala -> a gran escala

2. A gran escala -> se debe forzar a pequeña escala, de lo contrario, la compilación fallará y la precisión también se puede perder

3. Al asignar una constante de valor literal, Java verificará automáticamente el rango de números

4. La conversión forzada no es necesariamente exitosa, y los tipos que no quieren hacer no se pueden convertir entre sí

3.6.3 Análisis del tema

int i = 10;
float f = 19.9F;
i = f;//会报错吗

La respuesta es: se informará un error, porque aunque i y f son ambos de 4 bytes, el ancho de datos que puede representar float, además de la parte entera, también tiene una parte fraccionaria. ¿Qué pasa si la parte entera se le da a int? y la parte fraccionaria? Existe el peligro de perder datos.

3.7 Tipo de promoción

1. Cuando se utilizan dos tipos de datos diferentes para la operación, uno de los tipos de datos más pequeños se convertirá en uno más grande para participar en la operación.

int a = 10;
long b = 20;
 
int c = a + b;//编译失败 a+b->int+long->long+long 赋值给int会丢失数据
long d = a + b;//编译通过 赋值给long就可以

2. Para tipos de menos de 4 bytes, la operación se actualizará a int primero y luego participará en la operación

byte a = 10;
byte b = 20;
byte c = a + b;
system.out.printfln(c);//编译失败，从a+b-》提升为 int+int-》byte 可能会有损失
 
byte c = (byte)(a + b);
system.out.printfln(c);//编译通过，将int强制转化为byte

4. Tipo de cadena

Use la clase String para definir el tipo de cadena en Java,

Es un poco diferente de C, no hay terminación '\0', no existe tal declaración en absoluto

public static void main(String[] args) {
    
    String s1 = "hello";
    String s2 = "world";
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s1+s2);//s1+s2表示：s1和s2进行拼接
}

En algunos casos, es necesario convertir entre cadenas y números enteros:

1. Convertir int a Cadena

    int num = 10;
    String str1 = num + "";//法1
    String str2 = String.valueOf(num);//法2

2. Convertir cadena a int

    String str = "100";
    int num = Integer.parseInt(str);

Tipos de datos y variables_Java SE

1. Constantes literales