Types de données Java : définition et utilisation

Identifiants et mots-clés

Identifiant

pronunciation biao zhi fu

Qu'est-ce qu'un identifiant

#🎜🎜 #Package, classe, variable, méthode...etc., tant qu'elle est nommée, le nom est l'identifiant

Règles de définition des identifiants

Quatre sont OK : OK Ils sont chiffres, lettres, traits de soulignement (_) et signes dollar ($). Nous essayons généralement d'utiliser des lettres anglaises pour nommer.

Deux non-non : il ne peut pas commencer par un nombre et il ne peut pas utiliser de mots-clés en Java.

Connaître la signification par le nom : pour que les lecteurs puissent comprendre ce qu'il fait à travers le nom, par exemple : tri à bulles (

), on peut clairement savoir que cette méthode est un tri à bulles. bubble_Sort

Nom du cas Camel :

• Nom de la classe : la première lettre est en majuscule et le reste suit le nom du cas Camel

  #🎜 🎜#

Nom de la méthode/nom de la variable : la première lettre est en minuscule et le reste suit la dénomination en casse chameau
Nom du package : tout en minuscules

• #🎜🎜 #

  Limite de longueur : Il n'y a pas de limite de longueur, mais il n'est pas recommandé d'être trop long

Keyword

#🎜 🎜#

reçoit une signification particulière par le langage Java, les mots utilisés à des fins spéciales

• Caractéristiques : Tous les mots-clés en Java sont en minuscules # 🎜🎜#

• Site officiel : https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
  #🎜🎜 #

#🎜🎜 #

Constantes et variables

Constante

Il existe deux types de constantes : #🎜 🎜#Constant fait généralement référence à une valeur fixe, telle que : 1, 2, 3, ’a’, ’b’, true, false, "helloWorld", etc.

Dans le langage Java, le mot clé final est principalement utilisé pour définir une constante. Une fois qu'une constante est initialisée, sa valeur ne peut plus être modifiée.

Afin de mieux distinguer et exprimer, 1, 2, 3, ’a’, ’b’, vrai, faux, "helloWorld", etc. sont généralement appelés constantes littérales, et finale est utilisé PI modifié, etc. sont appelés constantes symboliques (constantes de caractères).

Type de constante littérale :

Constante entière : 123 23

Constante réelle : 3.1415926

#🎜 🎜 # Constantes de caractère : «a» ‘b’

Constantes logiques : vrai faux

Constantes de chaîne : "helloworld"

# 🎜🎜# Remarque : les constantes logiques ont deux valeurs, l'une est vraie et l'autre est fausse

Variable

Les variables représentent essentiellement un espace de stockage et un emplacement d'espace utilisables. C'est certain, mais la valeur placé dedans est incertain. On peut accéder à l'espace de stockage correspondant via le nom de la variable, manipulant ainsi la valeur stockée dans cet espace de stockage.

Java est un langage fortement typé, et chaque variable doit déclarer son type de données. type détermine la taille de l'espace de stockage occupé par la variable. Par exemple, int a=3; signifie que la taille de l'espace d'une variable est de 4 octets. En tant qu'unité de stockage la plus élémentaire du programme, ses éléments incluent le nom de la variable. type et fonction.Les variables doivent être déclarées avant utilisation.Ce n'est qu'après la déclaration de la variable que la longueur correspondante de l'espace de stockage peut être allouée. #Type de données Nom de la variable = valeur initiale, nom de la variable = valeur initiale... ##🎜 🎜#

Si vous définissez uniquement une variable et n'attribuez pas de valeur à la variable, alors la variable n'est en fait pas définie

Variable s'il y a ; n'y a pas d'affectation, alors une erreur se produira lors de son utilisation, vous indiquant : la variable n'a pas été initialisée ; Peut être définie à plusieurs reprises

Type de données de base ;

Type entier

Type de données entier : # 🎜🎜#

Ce qui suit est le code à titre d'exemple :

public class TestCode01{
        public static void main(String[] args){
            int a=3,b=4,c=5;
            //也可以先定义不赋值
            int a,b,c;                        
        }
}

Type à virgule flottante

Constante de type à virgule flottante# 🎜🎜#
• (1) Forme de nombre décimal, par exemple : 3,14 314,0 0,314
  (2) Forme de notation scientifique, par exemple :

public class TestCode01{
        public static void main(String[] args){
            int a;
            System.out.println(a);//会报错，未初始化变量a
        }
}

• Type à virgule flottante Variable
  Le type flottant est également appelé type simple précision, et la mantisse peut être précis jusqu'à 7 chiffres significatifs. Dans de nombreux cas, la précision du type flottant est difficile à répondre à la demande. Double signifie que la précision numérique de ce type est environ le double de celle du type flottant. type. La plupart des applications utilisent le type double

Le type float a un suffixe F ou f, les valeurs à virgule flottante sans suffixe F/f sont de type double. # Vous pouvez également ajouter le suffixe D ou d après la valeur à virgule flottante pour indiquer clairement qu'il s'agit d'un type double

PS : Les chiffres valides font référence au premier nombre. n'est pas 0 de la gauche au dernier chiffre

public class TestCode02{
        public static void main(String[] args){
                //浮点类型的常量有两种形式：
                //十进制形式：
                double num1 = 3.14;
                System.out.println(num1);
                //科学计数法形式：
                double num2 = 314E-2;
                System.out.println(num2);
                
                //浮点类型的变量：
                //注意：浮点型默认是double类型的，要想将一个double类型的数赋给float类型，必须后面加上F或者f
                float f1 = 3.14234567898623F;
                System.out.println(f1);
                //注意：double类型后面可以加D或者d，但是一般我们都省略不写
                double d1 = 3.14234567898623D;
                System.out.println(d1);
                
                //注意：我们最好不要进行浮点类型的比较：
                float f2 = 0.3F;
                double d2 = 0.3;
                System.out.println(f2==d2);
                /*
                区别：
                = 赋值运算：  将等号右侧的值赋给等号左侧
                == 判断==左右两侧的值是否相等  ：结果要么相等 要么不相等
                ==运算符的结果就是要么是true，要么是false
                */
                
        }
}

字符类型

字符型

Java的字符使用16位的Unicode编码表示，而计算机语言通常使用ASCII码，用8位表示一个字符。

字符型是用两个单引号括起来的一个字符，如’a’，’1’，’A’等。其中，’a’和’A’分别表示ASCII码中的字符a和A，而’1’表示字符型1，而不是整数的数值1。除了一般字符外，Java还定义了一些特殊字符，如图：

字符型除了常数值的表示方式与整数型不同外，在其他方面几乎可以将它视为一般整数来处理。

字符串型

字符串是指括在两个双引号之间0个或多个字符组成的序列。若两个双引号之间没有任何字符，则为空串。下面是有关字符串的一些例子：

""
"hello world!"
"hello java"

Java语言把字符串当作String类型的一个对象来处理。

布尔类型

boolean类型有两个常量值，true和false，在内存中占一位（不是一个字节），不可以使用 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。 boolean 类型用来判断逻辑条件，一般用于程序流程控制 。

public class TestCode03{
        public static void main(String[] args){
                //创建一个布尔类型的变量：
                boolean flag1 = true;
                System.out.println(flag1);
                boolean flag2 = false;
                System.out.println(flag2);
                boolean flag3 = 5==9;
                System.out.println(flag3);
                boolean flag4 = 5<9;
                System.out.println(flag4);
        }
}

基本数据类型的转换

自动类型转换

即精度小的类型自动转换为精度大的数据类型

数据类型按精度大小排序为：

在类型转换的时候需要遵循哪些规则:

第一条：八种基本数据类型中，除boolean 类型不能转换，剩下七种类型之间都可以进行转换；

第二条：小容量向大容量转换称为自动类型转换,大容量转换小容量必须使用强制类型转，但运行时可能出现精度损失，谨慎使用

第三条：byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；

第四条：整数的默认类型是 int，小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

第五条：浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

当一个表达式中有多种数据类型的时候，要找出当前表达式中级别最高的那个类型，然后其余的类型都转换为当前表达式中级别最高的类型进行计算。

 double d2 = 12+1294L+8.5F+3.81+'a';//都转换成最高的double类型，相当于= 12.0+1294.0+8.5+3.81+97.0

强制类型转换

把精度大的数据类型的数据赋值给精度小的数据类型。

double b=3.1415926;
int a=(int)b;//强制转换  高-->低

在进行运算的时候：

左=右 : 直接赋值

左

左>右 ：直接自动转换

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!