[JAVA] Este artículo lo lleva a comprender los tipos de datos y variables de Java

Página de inicio del autor: blog de paper jie

Autor de este artículo: Hola a todos, soy paper jie, gracias por leer este artículo, bienvenidos a construir tres empresas.

Este artículo está incluido en la columna "Serie de gramática JAVASE", que está cuidadosamente diseñada para estudiantes universitarios y principiantes en programación. El autor gastó mucho dinero (tiempo y energía) para construirlo y eliminó el conocimiento básico de javaSE, con la esperanza de ayudar a los lectores.

Otras columnas: "Explicación detallada del algoritmo", "Lenguaje C", etc.

Uso compartido de contenido: este problema explicará los tipos de datos y las variables del lenguaje JAVA ~

constante literal

La salida de helloworld en nuestro código es una constante de carácter. Las constantes son aquellas que permanecen constantes durante la ejecución del programa. Por ejemplo, 12 meses al año, el género de un niño es masculino, el género de una niña es femenino, hay siete días en una semana, etc.

public class Test {
    public static void main(String[] args){
        System.out.println("hello world");
        System.out.println(100);
        System.out.println(3.14);
        System.out.println('A');
        System.out.println(true);
        System.out.println(false);
    }
    
}

100, 3.14, 'A' y verdadero/falso son todas constantes y se denominan constantes literales.

Clasificación de constantes literales:

Constante de cadena: delimitada por " ", por ejemplo: "123" "hola", etc.

Constantes enteras: números escritos directamente: 1, 2, 3, 4, etc.

Constantes de coma flotante: números con decimales: 3,14 5,29, etc.

Constante de carácter: un carácter encerrado entre comillas simples: 'A' 'B' etc.

Operaciones booleanas: solo dos: verdadero y falso

Constante vacía: nulo

tipo de datos

Hay dos tipos principales de tipos de datos en java: tipos de datos básicos y tipos de datos de referencia.

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

Cuatro tipos: Entero Flotante Carácter Booleano

Ocho tipos:

tipo de datos	palabras clave	uso de memoria	alcance
Byte	byte	1 byte	-128~127
entero corto	corto	2 bytes	-32768~32767
entero	En t	4 bytes	-2^31~2^31-1
Entero largo	largo	8 bytes	-2^63~2^63-1
punto flotante de precisión simple	flotar	4 bytes	Hay un rango, generalmente no prestas atención.
punto flotante de precisión doble	doble	8 bytes	Hay un rango, generalmente no prestas atención.
tipo de caracter	carbonizarse	2 bytes	0~65535
booleano	booleano	No especificado	verdadero y falso

Nota:
independientemente de si se trata de un sistema de 32 bits o de 64 bits, int ocupa cuatro bytes y long ocupa 8 bytes

Tanto los tipos enteros como los de punto flotante están firmados

El valor predeterminado de entero es de tipo int y el valor predeterminado de punto flotante es de tipo doble

String es un tipo de referencia

¿Qué es Byte Pinch?

Un byte es la unidad básica de espacio en una computadora. Las computadoras usan binario para representar datos. Pensamos en 8 bits binarios (bit) como un byte (Byte). Nuestra computadora habitual tiene 8GB de memoria, lo que significa 8G bytes. Entre ellos , 1 KB = 1024 Byte, 1 MB = 1024 KB, 1 GB = 1024 MB, por lo que 8 GB equivalen a más de 8 mil millones de bytes  

 variable

concepto variable

En el programa, además de las constantes constantes, algunos contenidos pueden cambiar con frecuencia, como: altura humana, puntajes de calificaciones, resultados de cálculos de funciones matemáticas, etc. Para estos contenidos que cambian con frecuencia, en los programas Java, se denomina variable . El tipo de datos se utiliza para definir diferentes tipos de variables.  

formato gramatical 

La sintaxis para definir variables es:

tipo de datos y nombre de variable = valor inicial

    public static void main2(String[] args){
        int a = 10;
        double b= 10.0;
        char c = 'a';
        boolean d = true;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }

variable entera

tipo int

public class Test {
    public static void main(String[] agrs){
        //方法一： 在定义的时候给出初值
        int a = 10;
        System.out.println(a);

        //方法二： 先定义 再给值
        int b;
        b = 5;
        System.out.println(b);

        //如果定义后没有赋值，则编译期间会报错
//        int c;
//        System.out.println(c);

        //int类型的范围：
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }


}

Aviso:

Int es de 4 bytes sin importar en qué sistema se encuentre

Se recomienda usar la definición del método 1, pero si no hay una definición de valor adecuada, se puede establecer en 0

Al establecer el valor inicial de la variable, el valor no puede exceder el rango de representación de int, de lo contrario causará un desbordamiento

Las variables deben inicializarse antes de su uso; de lo contrario, el compilador informará un error.

El tipo de empaquetado de int es Integer

tipo largo 

int a = 10;
long b = 10; // long定义的长整型变量
long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分
// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
System.Out.println(Long.MIN_VALUE);
System.Out.println(Long.MAX_VALUE);

Aviso:

El valor inicial de la variable entera larga va seguido de L y l, y se recomienda L

El entero largo es de 8 bytes independientemente del sistema

El rango de representación de un entero largo es -2^63~2^63-1

El tipo de envoltura de long es Long

tipo corto

        short a = 10;
        System.out.println(a);
        
        //short的范围：
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);

Aviso:

short ocupa dos bytes en cualquier sistema

El rango de corto es -32768~32767

Tenga cuidado de no exceder el rango cuando utilice

La clase contenedora de tipo corto es Corta  

tipo de byte

byte b = 10;
System.Out.println(b);
// byte型变量所能表示的范围：
System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);

Aviso:

byte ocupa 1 byte en cualquier sistema

El rango de bytes es -128~127

El tipo de empaquetado de bytes es Byte

variable de coma flotante   

punto flotante de precisión doble

double a = 1.1;
System.out.println(a);

En Java, el valor de int excepto el tipo int sigue siendo int, redondeará directamente la parte decimal. Si desea obtener decimales, debe utilizar cálculos de coma flotante.

        double b = 2.2;
        double c = 1.13;
        System.out.println(b/c);

Nota:
el doble es de 8 bytes en cualquier sistema

Los números de coma flotante y los enteros se almacenan de diferentes maneras en la memoria, por lo que no se pueden calcular simplemente en forma de 2^n

El tipo doble solo puede tener una precisión de 6 decimales, y habrá un pequeño error después, porque el diseño de memoria del tipo doble cumple con el estándar IEEE 754 (igual que el lenguaje C), trate de usar espacio de memoria para representar un posible infinito Para los decimales, es probable que haya un cierto error de precisión, por lo que los números de punto flotante son valores aproximados, no valores exactos.

El tipo de contenedor de doble es Doble

punto flotante de precisión simple

        float d = 10.2f;
        System.out.println(d);

Aviso:

El tipo flotante ocupa 4 bytes en Java

También cumple con el estándar IEEE 754. Debido al pequeño rango de precisión de los datos representados, generalmente se prefiere el doble cuando se usan números de punto flotante en ingeniería, y no se recomienda el valor flotante. 

El tipo de envoltura de flotador es Flotante

variable de tipo de caracter

char c1 = 'a'; // 大写字母
char c2 = '1'; // 数字字符
System.out.println(c1);
System.out.println(c2);
// 注意：java中的字符可以存放整形
char c3 = '棒';
System.out.println(c3);

Nota:
1. Las comillas simples + una sola letra se usan en Java para representar caracteres literales.
2. Un carácter en una computadora es esencialmente un número entero. ASCII se usa para representar caracteres en lenguaje C, mientras que Unicode se usa para representar caracteres en Java. Por lo tanto, los caracteres ocupan dos bytes, lo que representa más tipos de caracteres, incluidos los chinos. 

variable booleana

El tipo booleano se usa a menudo para representar verdadero y falso, y también en la vida: la respuesta matemática es correcta o incorrecta...

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

Aviso:

 Una variable de tipo booleano tiene solo dos valores, verdadero significa verdadero y falso significa falso.   

El tipo booleano y el int de Java no se pueden convertir entre sí. No existe tal uso como 1 significa verdadero y 0 significa falso.

3. En la especificación de la máquina virtual de Java, no estipula claramente cuántos bytes ocupa el valor booleano, y no existe una instrucción de código de bytes especialmente utilizada para procesar el valor booleano. En la implementación de la máquina virtual de Oracle, el valor booleano ocupa 1 byte.

4. El tipo de empaquetado de booleano es booleano.

conversión de tipos 

En Java, cuando los tipos de datos involucrados en la operación son inconsistentes, se realizará la conversión de tipo. La conversión de tipo en Java se divide principalmente en dos categorías: conversión de tipo automática (implícita) y conversión de tipo obligatoria (explícita).

conversión de tipo automática (implícita)

Significa: 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: se convertirá automáticamente de un rango de datos pequeño a un rango de datos grande.

System.Out.println(1024); // 整型默认情况下是int
System.Out.println(3.14); // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
float f = 3.14F;
double d = 5.12;
d = f; // 编译器会将f转换为double，然后进行赋值
f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

emitir (explícito) 

El tipo obligatorio significa que al escribir código, el código debe procesarse en un formato determinado y no puede completarse automáticamente. Características: desde un rango de datos grande hasta un rango de datos pequeño.

int a = 10;
long b = 100L;
b = a; // int-->long，数据范围由小到大，隐式转换
a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
float f = 3.14F;
double d = 5.12;
d = f; // float-->double，数据范围由小到大，隐式转换
f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
a = d; // 报错，类型不兼容
a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
boolean flag = true;
a = flag; // 编译失败：类型不兼容
flag = a; // 编译失败：类型不兼容

Aviso:

 La asignación entre variables de diferentes tipos numéricos significa que un tipo con un rango más pequeño se puede convertir implícitamente en un tipo con un rango más grande     

 Si necesita asignar un tipo con un rango grande a un tipo con un rango pequeño, debe convertir el tipo, pero se puede perder la precisión. 

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

La conversión de tipo obligatoria puede no tener éxito, los tipos irrelevantes no se pueden convertir entre sí  

tipo de promoción 

Cuando diferentes tipos de datos se operan entre sí, el tipo de datos más pequeño se promoverá al tipo de datos más grande.

 Entre int y long: int se promocionará a long

int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

operación de byte y byte  

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失

Razón: byte y byte son ambos del mismo tipo, pero ocurre un error de compilación. La razón es que aunque a y b son bytes, el cálculo de a + b primero promoverá a y b a int, y luego realizará el cálculo , y el resultado también es int, que se asigna a c, ocurrirá el error anterior.
Debido a que la CPU de la computadora generalmente lee y escribe datos de la memoria en unidades de 4 bytes. Para la conveniencia de la implementación de hardware, como byte y short son menos de 4 El tipo de byte se promoverá a int primero y luego participará en el cálculo

Método de escritura correcto:

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

Aviso:

Diferentes tipos de operaciones mixtas de datos, el rango pequeño se promoverá a un rango grande.

Para tipos de menos de 4 bytes, como short y byte, se promocionará a un int de 4 bytes antes de la operación.

tipo de cadena 

El tipo de cadena se define en Java usando la clase de cadena:

public class Test
{
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "nihao";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2);//拼接方法
        System.out.println(10+20+s1+100+20);
    }

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

int en cadena

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

Convertir cadena a int

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

Aquí hay una breve introducción a la clase de cadena, que se discutirá en detalle más adelante.

---