Do iniciante ao especialista: um guia completo para tipos e variáveis de dados Java

Em Java, um tipo de dados refere-se ao tipo de dados armazenados em uma variável.Java suporta uma variedade de tipos básicos de dados, incluindo inteiro, ponto flutuante, caractere, booleano e assim por diante. Para diferentes tipos de dados, Java também fornece diferentes constantes literais para representar seus valores. Compreender os tipos de dados e suas características é muito importante ao programar em Java.

1. Constantes literais

1.1 Que constante?

Constantes literais referem-se a valores constantes que são usados diretamente no programa sem cálculo ou processamento. Em Java, as constantes literais incluem os seguintes tipos:

1.2 Seis tipos constantes comuns

1. Constantes inteiras
As constantes inteiras representam valores inteiros, que podem ser expressos em decimal, octal ou hexadecimal .


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

2. Constantes de ponto flutuante
As constantes de ponto flutuante representam valores reais, incluindo ponto flutuante de precisão simples e ponto flutuante de precisão dupla .


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

3. Constantes de caracteres
Uma constante de caractere representa um único caractere, colocado entre aspas simples .

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

4. Constante de string
Uma constante de string representa uma string composta de vários caracteres, entre aspas duplas .

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

5. Constantes booleanas
As constantes booleanas representam true ou false , expressas com as palavras-chave true e false .

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

6. Constante nula
A constante nula representa uma referência de objeto nulo .

String strValue = null; // null常量

2. Tipo de dados

2.1 O que é um tipo de dado?

Os tipos de dados Java são divididos em duas categorias: tipos de dados primitivos e tipos de dados de referência. Os tipos de dados básicos incluem inteiro, ponto flutuante, caractere e booleano, que são tipos integrados fornecidos pela linguagem Java. Os tipos de dados de referência incluem classes, interfaces, arrays, etc., que são todos tipos definidos no programa.

2.2 Tipos de dados básicos:

1. Inteiro
Tipos de dados inteiros incluem quatro tipos byte, short, int e long , que ocupam 1, 2, 4 e 8 bytes, respectivamente, e possuem diferentes faixas de valores. O seguinte formulário:

tipo de dado inteiro
tipo	ocupar espaço	Gamas
byte	1 byte	-128~127
curto	2 bytes	-32768~32767
int	4 bytes	-2147483648~2147483647
longo	8 bytes	-9223372036854775808~9223372036854775807

2. Tipo de ponto flutuante
Os tipos de dados de ponto flutuante incluem float e double , que ocupam 4 e 8 bytes, respectivamente, e possuem intervalos de valores e precisão diferentes.

float f = 3.14f; 
double d = 3.14;

tipo de dados de ponto flutuante
tipo	ocupar espaço	Faixa de precisão
flutuador	4 bytes	A precisão é de 6 a 7 dígitos
dobro	8 bytes	A precisão é de 15 a 16 dígitos

3. Tipo de caractere
O tipo de dado de caractere char ocupa 2 bytes e é usado para representar caracteres codificados em Unicode.

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

4. Boolean
O tipo de dados Boolean boolean possui apenas dois valores: true e false , ocupando 1 byte.

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

2.3 Tipos de dados de referência

Tipos de dados de referência em Java incluem classes, interfaces, arrays, enumerações, anotações, etc. Esses tipos de dados são armazenados na memória heap por referência.

1. classe

As classes são a base da programação orientada a objetos e todas as classes em Java são tipos de dados de referência. Uma classe pode conter membros como propriedades, métodos e construtores, e os membros da classe são usados para criar 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.

    }
}

A saída é a seguinte:

2. Interface

Uma interface é um tipo abstrato que define a assinatura de um conjunto de métodos, mas nenhum código concreto que implementa esses métodos. As interfaces podem ser implementadas por classes e uma classe pode implementar várias 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.

A saída é a seguinte:

3. Matrizes

Uma matriz é um contêiner que armazena vários dados do mesmo tipo.Uma matriz em Java pode armazenar qualquer tipo de dados, incluindo tipos básicos e tipos de referência.

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

4. Enumeração

A enumeração é um tipo especial, que limita as variáveis a assumirem apenas os valores definidos na enumeração, o que pode evitar erros em situações como o uso de números ou strings para representar estados.

enum Color {
  RED, GREEN, BLUE
}

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

5. Notas

A anotação é uma tag usada para fornecer informações de metadados, que podem ser usadas em elementos como classes, métodos, variáveis, etc., para descrever seus atributos e características. As anotações podem ser obtidas através do mecanismo de reflexão

Além dos tipos de dados de referência mencionados acima, Java também possui muitos outros tipos de dados, como coleções, mapas, etc. Esses tipos de dados também são muito usados no desenvolvimento Java. No desenvolvimento real, os desenvolvedores precisam selecionar os tipos de dados apropriados de acordo com as necessidades comerciais específicas para concluir as tarefas de desenvolvimento.

3. Variáveis

3.1 O que é uma variável?

No programa, além das constantes constantes, alguns conteúdos podem mudar com frequência, como matemáticas , etc. O tipo de dados é usado para definir diferentes tipos de variáveis .

A sintaxe para definir variáveis é:

nome da variável do tipo de dados = 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);

    }
}

Do seguinte modo:

3.2 Regras de nomenclatura de variáveis

A nomenclatura das variáveis precisa seguir certas regras: o nome da variável deve consistir em letras, números, sublinhados ou cifrões, não pode começar com um número e não pode ser uma palavra-chave Java.

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

3.3 O escopo das variáveis

O escopo de uma variável refere-se ao escopo que a variável pode acessar no programa.Variáveis em Java possuem escopo, ou seja, a variável só é visível no bloco de código em que é declarada.

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 as variáveis são modificadas no final

Em Java, uma variável também pode ser modificada por final, indicando que a variável é uma constante e, uma vez atribuída, não pode ser alterada.

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

Quatro. Conversão de tipo

4.1 O que é conversão de tipos?

Como uma linguagem de programação fortemente tipada , Java tem verificações mais rígidas quando variáveis de tipos diferentes são atribuídas umas às outras .

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

Em Java , quando os tipos de dados envolvidos na operação forem inconsistentes, será realizada a conversão de tipo. A conversão de tipo em Java é dividida principalmente em duas categorias: conversão de tipo automática ( implícita) e conversão de tipo obrigatória ( explícita ) .

conversão automática de tipo

4.2 Conversão automática de tipo

O código não precisa passar por nenhum processamento e o compilador irá processá-lo automaticamente quando o código for compilado . Recursos: Ele será convertido automaticamente de um pequeno intervalo de dados para um grande intervalo de dados .

O seguinte 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 Conversão de tipo obrigatória

Conversão de tipo obrigatória: Ao realizar operações, o código precisa passar por determinado processamento de formato, que não pode ser concluído automaticamente. Características: De grande intervalo de dados a pequeno intervalo de dados.

O seguinte 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 Precauções

1. A atribuição entre variáveis de diferentes tipos digitais significa que um tipo com um intervalo menor pode ser implicitamente convertido em um tipo com um intervalo maior

2. Se você precisar atribuir um tipo com um intervalo grande a um tipo com um intervalo pequeno , será necessário converter o tipo , mas a precisão pode ser perdida

3. Ao atribuir uma constante de valor literal , o Java verificará automaticamente o intervalo de números

4. A conversão obrigatória de tipo pode não ser bem-sucedida, tipos irrelevantes não podem ser convertidos entre si

4.5 Tipo de promoção

O que é promoção de tipo?

Quando diferentes tipos de dados são operados entre si, o tipo de dados menor será promovido para o tipo de dados maior .

Do seguinte modo

1. Entre int e long : int será promovido 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. A operação de byte e 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álise:

Ambos byte e byte são do mesmo tipo , mas ocorre um erro de compilação . O motivo é que , embora a e b sejam ambos bytes, o cálculo de a + b primeiro promoverá a e b para int e, em seguida, executará o cálculo e o resultado também é int. Isso é atribuído a c, e o erro acima ocorrerá .

Como a CPU do computador geralmente lê e grava dados da memória em unidades de 4 bytes . Para a conveniência da implementação de hardware , tipos como byte e short com menos de 4 bytes serão promovidos para int primeiro e depois participarão do o cálculo.

Forma correta de escrever:

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

resumo:

1. Operações mistas de diferentes tipos de dados , o pequeno intervalo será atualizado para um grande intervalo .

2. Para tipos menores que 4 bytes, como short e byte , eles serão promovidos para ints de 4 bytes antes da operação .

Cinco. Tipo de string

5.1 Qual é o tipo de string Java?

Em Java, uma string é um objeto composto por uma série de caracteres, que podem conter letras, números, símbolos, etc. O tipo Java String é imutável, o que significa que uma vez que um objeto String é criado, ele não pode ser alterado. Se você precisar modificar uma string, precisará criar um novo objeto de string.

5.2 Como criar e usar strings?

Para criar um objeto de string, use uma string literal ou um construtor de string . Uma string literal é uma sequência de caracteres entre aspas duplas, por exemplo:

String str1 = "Hello, World!";

O construtor de string pode criar um novo objeto string passando para ele um array de caracteres ou outra string , por exemplo:

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

Para acessar caracteres em uma string, você pode usar índices de caracteres ou métodos de string. Por exemplo, para obter o primeiro caractere de uma string, você pode usar o seguinte código:

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

5.3 Operações Comuns de String

Java fornece muitos métodos para manipular strings, incluindo os seguintes exemplos comuns:

comparação de strings

Para comparar duas strings quanto à igualdade, você pode usar o método equals() , por exemplo:

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

concatenação de strings

Duas strings podem ser concatenadas usando o operador plus ou o método concat() , por exemplo:

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

comprimento da corda

Você pode usar o método length() para obter o número de caracteres em uma string , por exemplo:

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

Interceptação de string

Você pode usar o método substring() para obter uma substring de uma string , por exemplo:

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

conversão de string

Você pode usar os métodos toUpperCase() e toLowerCase() para converter uma string em letras maiúsculas ou minúsculas , por exemplo:

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

5.3 Conversão entre strings e diferentes tipos

string para inteiro

Você pode usar o método para converter uma string em um número inteiro. Por exemplo: Integer.parseInt()

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

Converter String em Flutuante

Você pode usar o método para converter uma string em float. Por exemplo: Double.parseDouble()

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

Número inteiro ou float convertido em string

Você pode usar String.valueOf() o método para converter um número inteiro ou ponto flutuante em uma string. Por exemplo:

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

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

string para matriz de caracteres

Você pode usar toCharArray() o método para converter uma string em uma matriz de caracteres. Por exemplo:

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

matriz de caracteres para string

Uma matriz de caracteres pode ser convertida em uma string usando String(char[] data) o construtor. Por exemplo:

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

Bem, este é o fim aqui, se houver algo errado, por favor, aponte na área de comentários, obrigado.

Não é fácil criar, se possível, por favor, me apoie três vezes. O professor Wutiao concordaria muito