De principiante a experto: una guía completa de tipos de datos y variables de Java

En Java, un tipo de datos se refiere al tipo de datos almacenados en una variable.Java admite una variedad de tipos de datos básicos, incluidos enteros, coma flotante, caracteres, booleanos, etc. Para diferentes tipos de datos, Java también proporciona diferentes constantes literales para representar sus valores. Comprender los tipos de datos y sus características es muy importante al programar en Java.

1. Constantes literales

1.1 ¿Qué constante?

Las constantes literales se refieren a valores constantes que se usan directamente en el programa sin cálculo ni procesamiento. En Java, las constantes literales incluyen los siguientes tipos:

1.2 Seis tipos de constantes comunes

1. Constantes enteras
Las constantes enteras representan valores enteros, que se pueden expresar en decimal, octal o hexadecimal .


int decimalValue = 10; // 十进制
int octalValue = 012; // 八进制
int hexValue = 0xA; // 十六进制

2. Constantes de punto flotante
Las constantes de punto flotante representan valores reales, incluidos el punto flotante de precisión simple y el punto flotante de precisión doble .


float floatValue = 3.14f; // 单精度浮点型
double doubleValue = 3.14; // 双精度浮点型

3. Constantes de carácter
Una constante de carácter representa un solo carácter, encerrado entre comillas simples .

char charValue = 'a'; // 字符常量

4. Constante de cadena
Una constante de cadena representa una cadena compuesta de varios caracteres, entre comillas dobles .

String stringValue = "Hello, World!"; // 字符串常量

5. Constantes booleanas
Las constantes booleanas representan verdadero o falso , expresado con palabras clave verdadero y falso .

boolean boolValue_1 = true; // 布尔型常量
boolean boolValue_2 = false; // 布尔型常量

6. Constante nula
La constante nula representa una referencia de objeto nulo .

String strValue = null; // null常量

2. Tipo de datos

2.1 ¿Qué es un tipo de dato?

Los tipos de datos de Java se dividen en dos categorías: tipos de datos primitivos y tipos de datos de referencia. Los tipos de datos básicos incluyen enteros, coma flotante, caracteres y booleanos, que son tipos integrados proporcionados por el lenguaje Java. Los tipos de datos de referencia incluyen clases, interfaces, matrices, etc., que son todos los tipos definidos en el programa.

2.2 Tipos de datos básicos:

1. Entero
Los tipos de datos enteros incluyen byte, corto, int y largo cuatro tipos, que ocupan 1, 2, 4 y 8 bytes respectivamente, y tienen diferentes rangos de valores. El siguiente formulario:

tipo de dato entero
tipo	ocupar espacio	Rangos
byte	1 byte	-128~127
corto	2 bytes	-32768~32767
En t	4 bytes	-2147483648~2147483647
largo	8 bytes	-9223372036854775808~9223372036854775807

2. Tipo de punto flotante
Los tipos de datos de punto flotante incluyen float y double , que ocupan 4 y 8 bytes respectivamente, y tienen diferentes rangos de precisión y valores.

float f = 3.14f; 
double d = 3.14;

tipo de datos de punto flotante
tipo	ocupar espacio	Rango de precisión
flotar	4 bytes	La precisión es de 6~7 dígitos
doble	8 bytes	La precisión es de 15~16 dígitos

3. Tipo de carácter
El tipo de datos de carácter char ocupa 2 bytes y se utiliza para representar caracteres codificados en Unicode.

char c = 'a'; // 字符型数据类型

4. Boolean
El tipo de datos Boolean boolean tiene solo dos valores: verdadero y falso , ocupando 1 byte.

boolean b1 = true; // 布尔型数据类型
boolean b2 = false; // 布尔型数据类型

2.3 Tipos de datos de referencia

Los tipos de datos de referencia en Java incluyen clases, interfaces, matrices, enumeraciones, anotaciones, etc. Estos tipos de datos se almacenan en la memoria del montón por referencia.

1. clase

Las clases son la base de la programación orientada a objetos y todas las clases en Java son tipos de datos de referencia. Una clase puede contener miembros como propiedades, métodos y constructores, y los miembros de la clase se utilizan para crear objetos.

public class lhy {
    public static void main(String[] args) {
        class Person {
 String name;
 int age;

    void sayHello() {
 System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
}
        }

        Person p = new Person(); // 创建Person类的对象p
        p.name = "Tom";
        p.age = 25;
        p.sayHello(); // 输出：Hello, my name is Tom, I'm 25 years old.

    }
}

La salida es la siguiente:

2. Interfaz

Una interfaz es un tipo abstracto que define la firma de un conjunto de métodos, pero no un código concreto que implemente esos métodos. Las interfaces pueden implementarse por clases, y una clase puede implementar múltiples interfaces.

interface Flyable {
  void fly();
}

class Bird implements Flyable {
  public void fly() {
    System.out.println("I'm a bird, I'm flying.");
  }
}

Bird b = new Bird(); // 创建Bird类的对象b
b.fly(); // 输出：I'm a bird, I'm flying.

La salida es la siguiente:

3. Matrices

Una matriz es un contenedor que almacena varios datos del mismo tipo. Una matriz en Java puede almacenar cualquier tipo de datos, incluidos los tipos básicos y los tipos de referencia.

int[] nums = new int[]{1, 2, 3}; // 声明一个int类型的数组nums
String[] names = new String[]{"Tom", "Jerry", "Alice"}; // 声明一个String类型的数组names

4. Enumeración

La enumeración es un tipo especial, que limita las variables para que solo tomen los valores definidos en la enumeración, lo que puede evitar errores en situaciones como el uso de números o cadenas para representar el estado.

enum Color {
  RED, GREEN, BLUE
}

Color c = Color.RED; // 声明一个Color类型的变量c

5. Notas

La anotación es una etiqueta utilizada para proporcionar información de metadatos, que se puede utilizar en elementos como clases, métodos, variables, etc. para describir sus atributos y características. Las anotaciones se pueden obtener a través del mecanismo de reflexión.

Además de los tipos de datos de referencia mencionados anteriormente, Java tiene muchos otros tipos de datos, como colecciones, mapas, etc. Estos tipos de datos también se usan con mucha frecuencia en el desarrollo de Java. En el desarrollo real, los desarrolladores deben seleccionar los tipos de datos apropiados de acuerdo con las necesidades comerciales específicas para completar las tareas de desarrollo.

3. Variables

3.1 ¿Qué es una variable?

En el programa, además de las constantes constantes, algunos contenidos pueden cambiar con frecuencia, como: la edad de una persona, la altura, las calificaciones, los resultados de los cálculos de las funciones matemáticas, etc. Para denominan variables . El tipo de datos se utiliza para definir diferentes tipos de variables .

La sintaxis para definir variables es:

tipo de datos nombre de variable = valor inicial;

public class lhy {
    public static void main(String[] args) {
        int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10

        double d = 3.14;
        char c = 'A';
        boolean b = true;
        System.out.println(a);
        System.out.println(d);
        System.out.println(c);
        System.out.println(b);
        a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
        System.out.println(a);
// 注意：在一行可以定义多个相同类型的变量
        int a1 = 10, a2 = 20, a3 = 30;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);

    }
}

Como sigue:

3.2 Reglas de nomenclatura de variables

El nombre de las variables debe seguir ciertas reglas. El nombre de la variable debe constar de letras, números, guiones bajos o signos de dólar, no puede comenzar con un número y no puede ser una palabra clave de Java.

int myNumber; // 正确的变量名
double $price; // 正确的变量名
char _firstChar; // 正确的变量名
boolean isOK; // 正确的变量名
String 1stString; // 错误的变量名，不能以数字开头

3.3 El alcance de las variables

El alcance de una variable se refiere al alcance al que puede acceder la variable en el programa.Las variables en Java tienen alcance, es decir, la variable solo es visible en el bloque de código en el que se declara.

public void foo() {
    int a = 10; // 只在foo()方法中可见
    if (a > 5) {
        int b = 20; // 只在if语句块中可见
    }
    System.out.println(a); // 可以访问变量a
    System.out.println(b); // 错误，无法访问变量b
}

3.4 las variables se modifican por última vez

En Java, una variable también se puede modificar por final, lo que indica que la variable es una constante y, una vez asignada, no se puede cambiar.

final int a = 10; // 声明一个常量a，不能再被改变
final double PI = 3.14; // 声明一个常量PI，不能再被改变

Cuatro Conversión de tipo

4.1 ¿Qué es la conversión de tipos?

Como lenguaje de programación fuertemente tipado , Java tiene comprobaciones más estrictas cuando se asignan entre sí variables de diferentes tipos .

int a = 10;
long b = 100L;
b = a; // 可以通过编译
a = b; // 编译失败

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 automática de tipo

4.2 Conversión automática de tipo

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 .

El siguiente código:

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的数据范围，有数据丢失

4.3 Conversión de tipo obligatoria

Conversión de tipo obligatoria: al realizar operaciones, el código debe someterse a cierto procesamiento de formato, que no se puede completar automáticamente. Características: desde un rango de datos grande hasta un rango de datos pequeño.

El siguiente código:

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; // 编译失败：类型不兼容

4.4 Precauciones

1. La asignación entre variables de diferentes tipos digitales 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

2. 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.

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

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

4.5 Tipo de promoción

¿Qué es la promoción de tipos?

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 .

Como sigue

1. 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

2. La 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可能会有损失
byte c = a + b;
       ^

Análisis:

Tanto el byte como el byte son del mismo tipo , pero se produce un error de compilación . El motivo es que , aunque a y b son ambos 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. Esto se asigna a C y se producirá el error anterior .

Debido a que la CPU de la computadora generalmente lee y escribe datos de la memoria en unidades de bytes 4. Para la conveniencia de la implementación del hardware , los tipos como byte y short que tienen menos de 4 bytes se promoverán a int primero, y luego participarán en el calculo

Forma correcta de escribir:

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

resumen:

1. Operaciones mixtas de diferentes tipos de datos , el rango pequeño se actualizará a un rango grande .

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

Cinco Tipo de cadena

5.1 ¿Qué es el tipo de cadena de Java?

En Java, una cadena es un objeto, que se compone de una serie de caracteres, que pueden contener letras, números, símbolos, etc. El tipo String de Java es inmutable, lo que significa que una vez que se crea un objeto String, no se puede cambiar. Si necesita modificar una cadena, debe crear un nuevo objeto de cadena.

5.2 ¿Cómo crear y usar cadenas?

Para crear un objeto de cadena, use un literal de cadena o un constructor de cadena . Un literal de cadena es una secuencia de caracteres entre comillas dobles, por ejemplo:

String str1 = "Hello, World!";

El constructor de cadenas puede crear un nuevo objeto de cadena pasándole una matriz de caracteres u otra cadena , por ejemplo:

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str2 = new String(charArray);
String str3 = new String("Hello");

Para acceder a los caracteres de una cadena, puede utilizar índices de caracteres o métodos de cadena. Por ejemplo, para obtener el primer carácter de una cadena, puede usar el siguiente código:

String str1 = "Hello, World!";
char firstChar = str1.charAt(0);

5.3 Operaciones comunes con cadenas

Java proporciona muchos métodos para manipular cadenas, incluidos los siguientes ejemplos comunes:

comparación de cadenas

Para comparar la igualdad de dos cadenas, puede usar el método equals() , por ejemplo:

String str4 = "Hello";
boolean isEqual = str3.equals(str4); // true

concatenación de cadenas

Se pueden concatenar dos cadenas usando el operador más o el método concat() , por ejemplo:

String str5 = "Hello";
String str6 = "World";
String str7 = str5 + " " + str6; // "Hello World"
String str8 = str5.concat(" ").concat(str6); // "Hello World"

longitud de la cuerda

Puede usar el método length() para obtener la cantidad de caracteres en una cadena , por ejemplo:

int length = str1.length(); // 13

interceptación de cadenas

Puede usar el método substring() para obtener una subcadena de una cadena , por ejemplo:

String subStr = str1.substring(0, 5); // "Hello"

conversión de cadenas

Puede usar los métodos toUpperCase() y toLowerCase() para convertir una cadena a mayúsculas o minúsculas , por ejemplo:

String str9 = "Hello";
String str10 = str9.toUpperCase(); // "HELLO"
String str11 = str9.toLowerCase(); // "hello"

5.3 Conversión entre cadenas y diferentes tipos

cadena a entero

Puede utilizar el método para convertir una cadena en un número entero. Por ejemplo: Integer.parseInt()

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

Convertir cadena en flotante

Puede usar el método para convertir una cadena en un flotante. Por ejemplo: Double.parseDouble()

String str = "3.14";
double num = Double.parseDouble(str);

Entero o flotante convertido a cadena

Puede usar String.valueOf() el método para convertir un número entero o de coma flotante en una cadena. Por ejemplo:

int num = 123;
String str1 = String.valueOf(num);

double num2 = 3.14;
String str2 = String.valueOf(num2);

cadena a matriz de caracteres

Puede usar toCharArray() el método para convertir una cadena en una matriz de caracteres. Por ejemplo:

String str = "Hello";
char[] charArray = str.toCharArray();

matriz de caracteres a cadena

Una matriz de caracteres se puede convertir en una cadena usando String(char[] data) el constructor. Por ejemplo:

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray);

Bueno, este es el final aquí, si hay algo mal, indíquelo en el área de comentarios, gracias.

No es fácil de crear, si es posible, ayúdame tres veces. El maestro Wutiao estaría muy de acuerdo.