Explication détaillée du code graphique des types de données de base Java (disposition des nœuds de puissance)

Les

Java types de données (type) peuvent être divisés en deux grandes catégories : les types primitifs (types primitifs) et les référence types (types de référence). Ce qui suit est un nœud puissant pour organiser les connaissances sur les types de données de base de Java. Les amis intéressés peuvent apprendre ensemble

1. > Dans le code source Java, chaque variable doit déclarer un type. Les types de données Java (types) peuvent être divisés en deux grandes catégories : les types primitifs et les types de référence. Les types primitifs incluent les types booléens et les

(types numériques). Les types numériques sont divisés en types entiers et types à virgule flottante. Il existe 5 types d'entiers : byte short int long char (char est essentiellement un type spécial d'int). Les types à virgule flottante incluent float et double. La relation est organisée comme suit :

2. Les types de base :

Java est. les types de base fournissent une prise en charge au niveau du langage, c'est-à-dire qu'ils sont déjà prédéfinis en Java et sont représentés par des mots-clés réservés correspondants. Le type de base est une valeur unique, pas un objet complexe. Le type de base n'est pas

C'est principalement pour des raisons d'efficacité, mais il fournit également des versions objet de basic. types, c’est-à-dire le wrapper Type de base. Vous pouvez utiliser ces types de base directement ou utiliser des types de base pour construire des tableaux ou d'autres types personnalisés. Les types primitifs ont des plages de valeurs explicites et un comportement mathématique. 2.1 Type entier

Le type entier comprend les caractères octets courts et longs, qui sont représentés respectivement par 8, 16, 32, 64 et 16 bits. À certains endroits, char peut ne pas être inclus dans la catégorie des entiers, mais le type char est essentiellement un sous-ensemble de int. La largeur d'un entier ne doit pas être considérée comme la taille de l'espace mémoire occupé par le entier, mais doit être comprise comme le comportement d'une variable ou d'une

définie comme un entier. Les JVM sont libres d'utiliser la taille d'espace mémoire qu'elles souhaitent, à condition que le type se comporte conformément à la spécification. byte short int long sont tous signés, représentés par le complément à 2 (complément à deux). Char est représenté par 16 bits, qui ne sont pas signés et représentent le jeu de codage UTF-16. 2.1.1 octet

l'octet est représenté par 1 octet de 8 bits et est le plus petit type entier. Principalement utilisé pour économiser de l'espace mémoire clé. Le type d'octet est particulièrement utile lors d'opérations sur des flux de données provenant du réseau, de fichiers ou d'autres E/S. La plage de valeurs est : [-128, 127]. La valeur par défaut de l'octet est (octet)0. Si nous essayons d'attribuer une valeur en dehors de la plage de valeurs à une variable de type octet, une erreur de compilation se produira, comme l'octet b. = 128 ; Cette instruction ne peut pas être compilée. Une question intéressante, si nous avons une méthode : public void test(byte b). C'est une erreur d'essayer d'appeler cette méthode comme ceci : test(0); Le compilateur signalera une erreur, incompatibilité de type ! ! ! Nous nous souvenons de l'octet b =0 ; ce n'est pas un problème du tout, pourquoi cela se passe-t-il mal ici ?

Cela implique un problème appelé valeur littérale. La valeur littérale est la valeur en surface. Par exemple, la valeur littérale entière dans le code source est telle que 5, 0, -200. Si L ou l est ajouté à la fin de l'entier, la valeur littérale est de type long. Par exemple : 1000L représente une valeur de type long. Si L ou l n'est pas ajouté, il est de type int. Parmi les types de base, byte short int long peut être créé par des littéraux entiers sans ajouter L (appelons-les littéraux int), par exemple, byte b = 100 short s = 5 pour le type long, si la taille dépasse la plage ; que int peut représenter (32 bits) doit être exprimé avec une terminaison L. Les littéraux entiers peuvent être représentés de différentes manières : hexadécimal [0X ou 0x], décimal [rien], octal [0] binaire [0B ou 0b], etc. Les littéraux binaires ne sont disponibles qu'après la fonction JDK 7. Dans l'opération d'affectation, la valeur littérale int peut être attribuée à l'octet short int long, et le langage Java gérera automatiquement ce processus. Si les appels de méthode sont différents, lorsque test(0) est appelé, la méthode à laquelle elle peut correspondre est test(int), et bien sûr, elle ne peut pas correspondre à la méthode test(byte) Quant à savoir pourquoi Java ne prend pas en charge les appels de méthode comme celui-ci. prend en charge les opérations d'affectation, il n'a pas le choix de savoir. Notez la différence entre les wrappers et la conversion automatique des types primitifs (anto-boxing, auto-unboxing). l'octet d = 'A' est également légal, les caractères littéraux peuvent être automatiquement convertis en entiers de 16 bits.
Lors de l'exécution d'opérations mathématiques sur le type byte, il sera automatiquement promu au type int S'il y a des types tels que double ou float dans l'expression, il sera également automatiquement promu. Le code suivant est donc faux :

byte s2 = 'a'; 
 byte sum = s1 + s2;//should cast by (byte)</span></span></span>

2.1.2 short

est représenté par 16, et la plage de valeurs est : [- 2^15, 2 ^15 - 1]. short est probablement le type le moins couramment utilisé. Les valeurs peuvent être attribuées via des littéraux entiers ou des littéraux de caractères, à condition qu'elles ne dépassent pas la plage (16 bits). Lorsque le type court participe à des opérations, il est également promu au rang int ou à un type supérieur. (L'ordre est byte short int long float double).

2.1.3 int

32 bits, [- 2^31, 2^31 - 1 ]. Entier représenté par signé complément à deux . Les expressions couramment utilisées contrôlent boucle Notez que byte et short seront promus au type int ou supérieur pendant les opérations. Après Java 8, vous pouvez utiliser le type int pour représenter des entiers 32 bits non signés [0, 2^31 - 1].

2.1.4 long

64 bits, [- 2^63, 2^63 - 1, la valeur par défaut est 0L]. Lorsque vous devez calculer de très grands nombres, si int n'est pas assez grand pour s'adapter à la taille, vous pouvez utiliser le type long. Si long ne suffit pas, vous pouvez utiliser la classe BigInteger.

2.1.5 caractères

16 bits, [0, 65535], [0, 2^16 -1], de 'u0000 'à 'uffff'. Non signé, la valeur par défaut est « u0000 ». Java utilise le jeu de caractères Unicode pour représenter les caractères. Unicode est un jeu de caractères complètement international qui peut représenter des caractères dans toutes les langues humaines. Unicode nécessite une largeur de 16 bits, donc le type char en Java est également représenté par 16 bits. L'affectation pourrait ressembler à ceci :

char ch1 = 88;
char ch2 = 'A';

Le jeu de caractères ASCII occupe les 127 premières valeurs d'Unicode. La raison pour laquelle char est classé comme type entier est que Java fournit une prise en charge des opérations arithmétiques pour char, par exemple ch2++, alors ch2 devient Y ; Lorsque char effectue des opérations d'addition, de soustraction, de multiplication et de division, il est également converti en type int et doit être reconverti explicitement.

2.2 Type à virgule flottante

Comprend un flottant simple précision et un double double précision, exprimés respectivement en 32 et 64 bits, conformément à la spécification IEEE 754.

2.2.1 float

est représenté par 32 bits, correspondant à des nombres à virgule flottante simple précision. Il s'exécute plus vite que le double et occupe moins de mémoire. la valeur est très Elle devient inexacte lorsqu'elle est grande ou très petite. Lorsque les exigences de précision ne sont pas élevées, vous pouvez utiliser le type float. Exemple d'affectation de déclaration :

f1 = 10L; 
 f1 = 10.0f; 
 //f1 = 10.0;默认为double</span></span></span>

Vous pouvez attribuer byte, short, int, long et char au type float, et java<. 🎜> termine automatiquement la conversion .

2.2.2 double

fonctions de java.lang.Math adoptent toutes un type double.

2.3 type booléen

3. Valeur littérale

String peut être considérée comme un type. Bien sûr, la valeur spéciale null peut également être considérée comme une valeur littérale. Les valeurs littérales peuvent être grossièrement divisées en littéraux entiers, littéraux à virgule flottante, littéraux de caractères et de chaînes et littéraux spéciaux.

3.1. 整型字面值

从形式上看是整数的字面值归类为整型字面值。例如： 10, 100000L, 'B'、0XFF这些都可以称为字面值。整型字面值可以用十进制、16、8、2进制来表示。十进制很简单，2、8、16进制的表示分别在最前面加上0B（0b）、0、0X（0x）即可，当然基数不能超出进制的范围，比如09是不合法的，八进制的基数只能到7。一般情况下，字面值创建的是int类型，但是int字面值可以赋值给byte short char long int，只要字面值在目标范围以内，Java会自动完成转换，如果试图将超出范围的字面值赋给某一类型（比如把128赋给byte类型），编译通不过。而如果想创建一个int类型无法表示的long类型，则需要在字面值最后面加上L或者l。通常建议使用容易区分的L。所以整型字面值包括int字面值和long字面值两种。

3.2. 浮点字面值

浮点字面值简单的理解可以理解为小数。分为float字面值和double字面值，如果在小数后面加上F或者f，则表示这是个float字面值，如11.8F。如果小数后面不加F（f），如10.4。或者小数后面加上D（d），则表示这是个double字面值。另外，浮点字面值支持科学技术法表示。下面是一些例子：

double d2 = 11.4; 
 double d3 = 1.23E3; 
 double d4 = 10D; 
 double d5 = 0.4D; 
 float f1 = 10; 
 float f2 = 11.1F; 
 float f3 = 1.23e-4F; 
 float f4 = 1.23E0F;</span>

3.3 字符及字符串字面值

Java中字符字面值用单引号括起来，如‘@'‘1'。所有的UTF-16字符集都包含在字符字面值中。不能直接输入的字符，可以使用转义字符，如‘\n'为换行字符。也可以使用八进制或者十六进制表示字符，八进制使用反斜杠加3位数字表示，例如'\141'表示字母a。十六进制使用\u加上4为十六进制的数表示，如'\u0061'表示字符a。也就是说，通过使用转义字符，可以表示键盘上的有的或者没有的所有字符。常见的转义字符序列有：

\ddd(八进制) 、 \uxxxx(十六进制Unicode字符)、\'（单引号）、\"（双引号）、\\ （反斜杠）\r（回车符） \n（换行符） \f（换页符） \t（制表符） \b（回格符）

字符串字面值则使用双引号，字符串字面值中同样可以包含字符字面值中的转义字符序列。字符串必须位于同一行或者使用+运算符，因为java没有续行转义序列。

3.4 特殊字面值

null是一种特殊的类型（type），可以将它赋给任何引用类型变量，表示这个变量不引用任何东西。如果一个引用类型变量为null，表示这个变量不可用。

还有一种特殊的class literal，用type name加上.class表示,例如String.class。首先，String是类Class（java.lang.Class)的一个实例（对象），而"This is a string"是类String的一个对象。然后，class literal用于表示类Class的一个对象，比如String.class用于表示类Class的对象String。简单地说，类子面子（class literal）就是诸如String.class 、Integer.class这样的字面值，它所表示的就是累String、类Integer。如果输出Integer.class，你会得到class java.lang.Integer。List.class的输出为interface java.util.List。总之，class literal用于表示类型本身！

3.5 在数值型字面值中使用下划线。

JDK7开始，可以在数值型字面值（包括整型字面值和浮点字面值）插入一个或者多个下划线。但是下划线只能用于分隔数字，不能分隔字符与字符，也不能分隔字符与数字。例如 int x = 123_456_789.在编译的时候，下划线会自动去掉。可以连续使用下划线，比如float f = 1.22_3344.二进制或者十六进制的字面值也可以使用下划线，记住一点，下划线只能用于数字与数字之间，初次以外都是非法的。例如1._23是非法的，_123、11000_L都是非法的。

4. 基本类型之间的转换

我们看到，将一种类型的值赋给另一种类型是很常见的。在Java中，boolean类型与所有其他7种类型都不能进行转换，这一点很明确。对于其他7中数值类型，它们之间都可以进行转换，但是可能会存在精度损失或者其他一些变化。转换分为自动转换和强制转换。对于自动转换（隐式），无需任何操作，而强制类型转换需要显式转换，即使用转换操作符（type）。首先将7种类型按下面顺序排列一下：

byte <（short=char）< int < long < float < double

如果从小转换到大，可以自动完成，而从大到小，必须强制转换。short和char两种相同类型也必须强制转换。

4.1 自动转换

自动转换时发生扩宽（widening conversion）。因为较大的类型（如int）要保存较小的类型（如byte），内存总是足够的，不需要强制转换。如果将字面值保存到byte、short、char、long的时候，也会自动进行类型转换。注意区别，此时从int（没有带L的整型字面值为int）到byte/short/char也是自动完成的，虽然它们都比int小。在自动类型转化中，除了以下几种情况可能会导致精度损失以外，其他的转换都不能出现精度损失。

》int--> float
》long--> float
》long--> double
》float -->double without strictfp

除了可能的精度损失外，自动转换不会出现任何运行时（run-time）异常。

4.2 强制类型转换

如果要把大的转成小的，或者在short与char之间进行转换，就必须强制转换，也被称作缩小转换（narrowing conversion）,因为必须显式地使数值更小以适应目标类型。强制转换采用转换操作符（）。严格地说，将byte转为char不属于narrowing conversion），因为从byte到char的过程其实是byte-->int-->char，所以widening和narrowing都有。强制转换除了可能的精度损失外，还可能使模（overall magnitude）发生变化。强制转换格式如下：

 byte b;  
 b = (byte)a;//1</span>

如果整数的值超出了byte所能表示的范围，结果将对byte类型的范围取余数。例如a=256超出了byte的[-128,127]的范围，所以将257除以byte的范围（256）取余数得到b=1；需要注意的是，当a=200时，此时除了256取余数应该为-56，而不是200.

将浮点类型赋给整数类型的时候，会发生截尾（truncation）。也就是把小数的部分去掉，只留下整数部分。此时如果整数超出目标类型范围，一样将对目标类型的范围取余数。

7种基本类型转换总结如下图： 

4.3 赋值及表达式中的类型转换：

4.3.1 字面值赋值

在使用字面值对整数赋值的过程中，可以将int literal赋值给byte short char int，只要不超出范围。这个过程中的类型转换时自动完成的，但是如果你试图将long literal赋给byte，即使没有超出范围，也必须进行强制类型转换。例如 byte b = 10L；是错的，要进行强制转换。

4.3.2 表达式中的自动类型提升

除了赋值以外，表达式计算过程中也可能发生一些类型转换。在表达式中，类型提升规则如下：

》所有byte/short/char都被提升为int。

》如果有一个操作数为long，整个表达式提升为long。float和double情况也一样。

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!