Du débutant à l'expert : un guide complet sur les types de données et les variables Java

En Java, un type de données fait référence au type de données stockées dans une variable. Java prend en charge divers types de données de base, notamment les entiers, les virgules flottantes, les caractères, les booléens, etc. Pour différents types de données, Java fournit également différentes constantes littérales pour représenter leurs valeurs. Comprendre les types de données et leurs caractéristiques est très important lors de la programmation en Java.

1. Constantes littérales

1.1 Quelle constante ?

Les constantes littérales font référence à des valeurs constantes qui sont utilisées directement dans le programme sans calcul ni traitement. En Java, les constantes littérales incluent les types suivants :

1.2 Six types de constantes communes

1. Constantes entières
Les constantes entières représentent des valeurs entières, qui peuvent être exprimées en décimal, octal ou hexadécimal .


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

2. Constantes à virgule flottante
Les constantes à virgule flottante représentent des valeurs réelles, y compris la virgule flottante simple précision et la virgule flottante double précision .


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

3. Constantes caractères
Une constante caractère représente un seul caractère, entouré de guillemets simples .

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

4. Constante de chaîne
Une constante de chaîne représente une chaîne composée de plusieurs caractères, entre guillemets .

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

5. Constantes booléennes
Les constantes booléennes représentent true ou false , exprimées avec les mots clés true et false .

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

6. Constante nulle
La constante nulle représente une référence d'objet nulle .

String strValue = null; // null常量

2. Type de données

2.1 Qu'est-ce qu'un type de données ?

Les types de données Java sont divisés en deux catégories : les types de données primitifs et les types de données de référence. Les types de données de base incluent les entiers, les virgules flottantes, les caractères et les booléens, qui sont des types intégrés fournis par le langage Java. Les types de données de référence incluent les classes, les interfaces, les tableaux, etc., qui sont tous des types définis dans le programme.

2.2 Types de données de base :

1. Entier
Les types de données entiers incluent les quatre types byte, short, int et long , qui occupent respectivement 1, 2, 4 et 8 octets et ont des plages de valeurs différentes. Le formulaire suivant :

type de données entier
taper	prendre de l'espace	Gammes
octet	1 octet	-128~127
court	2 octets	-32768~32767
entier	4 octets	-2147483648~2147483647
long	8 octets	-9223372036854775808~9223372036854775807

2. Type à virgule flottante
Les types de données à virgule flottante incluent float et double , qui occupent respectivement 4 et 8 octets et ont des précisions et des plages de valeurs différentes.

float f = 3.14f; 
double d = 3.14;

type de données à virgule flottante
taper	prendre de l'espace	Plage de précision
flotter	4 octets	La précision est de 6 à 7 chiffres
double	8 octets	La précision est de 15 à 16 chiffres

3. Type de caractère
Le type de données caractère char occupe 2 octets et est utilisé pour représenter les caractères codés Unicode.

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

4. Boolean
Le type de données Boolean boolean n'a que deux valeurs : true et false , occupant 1 octet.

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

2.3 Types de données de référence

Les types de données de référence en Java incluent les classes, les interfaces, les tableaux, les énumérations, les annotations, etc. Ces types de données sont stockés dans la mémoire de tas par référence.

1. classe

Les classes sont la base de la programmation orientée objet et toutes les classes en Java sont des types de données de référence. Une classe peut contenir des membres tels que des propriétés, des méthodes et des constructeurs, et les membres de la classe sont utilisés pour créer des objets.

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 sortie est la suivante :

2. Interface

Une interface est un type abstrait qui définit la signature d'un ensemble de méthodes, mais pas de code concret qui implémente ces méthodes. Les interfaces peuvent être implémentées par des classes et une classe peut implémenter plusieurs 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 sortie est la suivante :

3. Tableaux

Un tableau est un conteneur qui stocke plusieurs données du même type. Un tableau en Java peut stocker n'importe quel type de données, y compris les types de base et les types de référence.

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

4. Énumération

L'énumération est un type spécial, qui limite les variables à prendre uniquement les valeurs définies dans l'énumération, ce qui peut éviter les erreurs dans des situations telles que l'utilisation de nombres ou de chaînes pour représenter l'état.

enum Color {
  RED, GREEN, BLUE
}

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

5. Remarques

L'annotation est une balise utilisée pour fournir des informations de métadonnées, qui peuvent être utilisées sur des éléments tels que des classes, des méthodes, des variables, etc. pour décrire leurs attributs et leurs caractéristiques. Les annotations peuvent être obtenues grâce au mécanisme de réflexion

En plus des types de données de référence mentionnés ci-dessus, Java possède également de nombreux autres types de données, tels que des collections, des cartes, etc. Ces types de données sont également très couramment utilisés dans le développement Java. Dans le développement réel, les développeurs doivent sélectionner les types de données appropriés en fonction des besoins spécifiques de l'entreprise pour effectuer les tâches de développement.

3. variables

3.1 Qu'est-ce qu'une variable ?

Dans le programme, en plus des constantes constantes, certains contenus peuvent changer fréquemment, tels que : l'âge, la taille, les notes, les résultats de calcul des fonctions mathématiques, etc. d'une personne. Pour appelés variables . Le type de données est utilisé pour définir différents types de variables .

La syntaxe pour définir les variables est :

nom de la variable de type de données = valeur initiale ;

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);

    }
}

Comme suit:

3.2 Règles de nommage des variables

La dénomination des variables doit suivre certaines règles. Le nom de la variable doit être composé de lettres, de chiffres, de traits de soulignement ou de signes dollar, ne peut pas commencer par un chiffre et ne peut pas être un mot clé Java.

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

3.3 La portée des variables

La portée d'une variable fait référence à la portée à laquelle la variable peut accéder dans le programme. Les variables en Java ont une portée, c'est-à-dire que la variable n'est visible que dans le bloc de code dans lequel elle est déclarée.

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 les variables sont finalement modifiées

En Java, une variable peut également être modifiée par final, indiquant que la variable est une constante, et une fois assignée, elle ne peut pas être changée.

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

4. Conversion de type

4.1 Qu'est-ce que la conversion de type ?

En tant que langage de programmation fortement typé , Java a des contrôles plus stricts lorsque des variables de types différents sont assignées les unes aux autres .

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

En Java , lorsque les types de données impliqués dans l'opération sont incohérents, une conversion de type sera effectuée. La conversion de type en Java est principalement divisée en deux catégories : la conversion de type automatique ( implicite) et la conversion de type obligatoire ( explicite ) .

conversion de type automatique

4.2 Conversion automatique des types

Le code n'a pas besoin de subir de traitement, et le compilateur le traitera automatiquement lorsque le code sera compilé . Caractéristiques : Il sera automatiquement converti d'une petite plage de données en une grande plage de données .

Le code suivant :

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 Conversion de type obligatoire

Conversion de type obligatoire : lors de l'exécution d'opérations, le code doit subir un certain traitement de format, qui ne peut pas être effectué automatiquement. Caractéristiques : De la grande plage de données à la petite plage de données.

Le code suivant :

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 Précautions

1. L'affectation entre des variables de types numériques différents signifie qu'un type avec une plage plus petite peut être implicitement converti en un type avec une plage plus grande

2. Si vous devez affecter un type avec une grande plage à un type avec une petite plage , vous devez convertir le type , mais la précision peut être perdue

3. Lors de l'attribution d'une constante de valeur littérale , Java vérifiera automatiquement la plage de nombres

4. La conversion de type obligatoire peut échouer, les types non pertinents ne peuvent pas être convertis les uns aux autres

4.5 Type de promotion

Qu'est-ce que la promotion de type ?

Lorsque différents types de données sont exploités les uns sur les autres, le plus petit type de données sera promu au plus grand type de données .

Comme suit

1. Entre int et long : int sera promu 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. Le fonctionnement de l'octet et de l'octet

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

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

Analyse:

byte et byte sont du même type , mais une erreur de compilation se produit . La raison en est que bien que a et b soient tous les deux des octets, le calcul de a + b va d'abord promouvoir a et b en int, puis effectuer le calcul , et le résultat est également int. Ceci est assigné à c, et l'erreur ci-dessus se produira .

Étant donné que le processeur de l'ordinateur lit et écrit généralement les données de la mémoire en unités de 4 octets . Pour la commodité de l'implémentation matérielle , les types tels que byte et short qui sont inférieurs à 4 octets seront d'abord promus int, puis participeront à le calcul.

Manière correcte d'écrire :

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

résumé:

1. Opérations mixtes de différents types de données , la petite plage sera mise à niveau vers une grande plage .

2. Pour les types inférieurs à 4 octets, tels que short et byte , ils seront promus en entiers de 4 octets avant l'opération .

Cinq. Type de chaîne

5.1 Qu'est-ce que le type de chaîne Java ?

En Java, une chaîne est un objet composé d'une série de caractères pouvant contenir des lettres, des chiffres, des symboles, etc. Le type Java String est immuable, ce qui signifie qu'une fois qu'un objet String est créé, il ne peut plus être modifié. Si vous devez modifier une chaîne, vous devez créer un nouvel objet chaîne.

5.2 Comment créer et utiliser des chaînes ?

Pour créer un objet chaîne, utilisez un littéral de chaîne ou un constructeur de chaîne . Un littéral de chaîne est une séquence de caractères entre guillemets doubles, par exemple :

String str1 = "Hello, World!";

Le constructeur de chaîne peut créer un nouvel objet chaîne en lui transmettant un tableau de caractères ou une autre chaîne , par exemple :

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

Pour accéder aux caractères d'une chaîne, vous pouvez utiliser des indices de caractères ou des méthodes de chaîne. Par exemple, pour obtenir le premier caractère d'une chaîne, vous pouvez utiliser le code suivant :

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

5.3 Opérations courantes sur les chaînes

Java fournit de nombreuses méthodes pour manipuler les chaînes, notamment les exemples courants suivants :

comparaison de chaînes

Pour comparer deux chaînes d'égalité, vous pouvez utiliser la méthode equals() , par exemple :

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

concaténation de chaînes

Deux chaînes peuvent être concaténées à l'aide de l'opérateur plus ou de la méthode concat() , par exemple :

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

Longueur de chaine

Vous pouvez utiliser la méthode length() pour obtenir le nombre de caractères dans une chaîne , par exemple :

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

Interception de cordes

Vous pouvez utiliser la méthode substring() pour obtenir une sous-chaîne d'une chaîne , par exemple :

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

conversion de chaîne

Vous pouvez utiliser les méthodes toUpperCase() et toLowerCase() pour convertir une chaîne en majuscule ou en minuscule , par exemple :

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

5.3 Conversion entre chaînes et différents types

chaîne en entier

Vous pouvez utiliser la méthode pour convertir une chaîne en entier. Par exemple: Integer.parseInt()

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

Convertir une chaîne en flottant

Vous pouvez utiliser la méthode pour convertir une chaîne en flottant. Par exemple: Double.parseDouble()

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

Entier ou flottant converti en chaîne

Vous pouvez utiliser String.valueOf() la méthode pour convertir un entier ou un nombre à virgule flottante en une chaîne. Par exemple:

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

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

chaîne en tableau de caractères

Vous pouvez utiliser toCharArray() la méthode pour convertir une chaîne en un tableau de caractères. Par exemple:

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

tableau de caractères en chaîne

Un tableau de caractères peut être converti en chaîne à l'aide String(char[] data) du constructeur. Par exemple:

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

Eh bien, c'est la fin ici, s'il y a quelque chose qui ne va pas, veuillez le signaler dans la zone de commentaire, merci.

Ce n'est pas facile à créer, si possible, merci de me soutenir trois fois. Le professeur Wutiao serait tout à fait d'accord