English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriel de base Java

Contrôle de flux Java

Java Tableau

Java Programmation Orientée Objet (I)

Java Programmation Orientée Objet (II)

Java Programmation Orientée Objet (III)

Gestion des exceptions Java

Java Liste (List)

Java Queue (File d'attente)

Java Map Collection

Java Set Collection

Java Entrée/Sortie (I/O)

Java Reader/Writer

Autres sujets Java

Types de données de base Java

Une variable est une demande de mémoire pour stocker une valeur. Autrement dit, lors de la création d'une variable, il faut demander de l'espace en mémoire.

Le gestionnaire de mémoire alloue de l'espace de stockage aux variables en fonction de leur type, et l'espace alloué ne peut être utilisé que pour stocker des données de ce type.

Par conséquent, en définissant différents types de variables, il est possible de stocker des entiers, des décimaux ou des caractères en mémoire.

Les deux principaux types de données de Java :

  • Types de données intégrés

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

Types de données intégrés

Le langage Java fournit huit types de données de base. Six types numériques (quatre types d'entiers, deux types de flottants), un type de caractères et un type booléen.

byte :

  • Le type de données byte est8Entier, signé, représenté par le complément à deux bits en binaire ;

  • 最小值是 -128(-2^7);

  • 最大值是 127(2^7-1);

  • 默认值是 0;

  • Le type de données byte est utilisé pour économiser de l'espace dans les grandes arrays, principalement pour remplacer les entiers, car la variable byte occupe seulement un quart de l'espace de type int ;

  • Exemple : byte a = 100, byte b = -50.

short:

  •  short 数据类型是 16 位、有符号的以二进制补码表示的整数

  •  最小值是 -32768(-2^15);

  •  最大值是 32767(2^15 - 1);

  •  Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一;

  •  默认值是 0;

  • 实例:short s = 1000,short r = -20000。

int:

  • int 数据类型是32位、有符号的以二进制补码表示的整数;

  • 最小值是 -2,147,483,648(-2^31);

  • 最大值是 2,147,483,647(2^31 - 1);

  • 一般地整型变量默认为 int 类型;

  • 默认值是 0 ;

  • 实例:int a = 100000, int b = -200000。

long:

  • long 数据类型是 64 位、有符号的以二进制补码表示的整数;

  • 最小值是 -9,223,372,036,854,775,808(-2^63);

  • 最大值是 9,223,372,036,854,775,807(2^63 -1);

  • 这种类型主要使用在需要比较大整数的系统上;

  • 默认值是 0L;

  •  实例: long a = 100000L,Long b = -200000L。
    "L"理论上不分大小写,但是若写成"l"容易与数字"1"混淆,不容易分辩。所以最好大写。

float:

  • float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;

  • float 在储存大型浮点数组的时候可节省内存空间;

  •  默认值是 0.0f;

  •  浮点数不能用来表示精确的值,如货币;

  •  实例:float f1 = 234.5f。

double:

  • double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;

  •  浮点数的默认类型为double类型;

  •  double类型同样不能表示精确的值,如货币;

  •  默认值是 0.0d;

  •  实例:double d1 = 123.4.

boolean:

  •  boolean数据类型表示一位的信息;

  • 只有两个取值:true 和 false;

  •  这种类型只作为一种标志来记录 true/false 情况;

  •  默认值是 false;

  •  实例:boolean one = true。

char:

  •  char类型是一个单一的 16 位 Unicode 字符;

  •   最小值是 \u0000(即为0);

  •  最大值是 \uffff(即为65,535);

  •  char 数据类型可以储存任何字符;

  •  实例:char letter = 'A';。

Example

对于数值类型的基本类型的取值范围,我们无需强制去记忆,因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的实例:

public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte  
        System.out.println("基本类型:byte 二进制位数:") + Byte.SIZE)  
        System.out.println("Classe d'emballage : java.lang.Byte")  
        System.out.println("Valeur minimale : Byte.MIN_VALUE=") + Byte.MIN_VALUE)  
        System.out.println("Valeur maximale : Byte.MAX_VALUE=") + Byte.MAX_VALUE)  
        System.out.println();  
  
        // short  
        System.out.println("Type de base : short, nombre de bits binaires : ") + Short.SIZE)  
        System.out.println("Classe d'emballage : java.lang.Short")  
        System.out.println("Valeur minimale : Short.MIN_VALUE=") + Short.MIN_VALUE)  
        System.out.println("Valeur maximale : Short.MAX_VALUE=") + Short.MAX_VALUE)  
        System.out.println();  
  
        // int  
        System.out.println("Type de base : int, nombre de bits binaires : ") + Integer.SIZE)  
        System.out.println("Classe d'emballage : java.lang.Integer")  
        System.out.println("Valeur minimale : Integer.MIN_VALUE=") + Integer.MIN_VALUE)  
        System.out.println("Valeur maximale : Integer.MAX_VALUE=") + Integer.MAX_VALUE)  
        System.out.println();  
  
        // long  
        System.out.println("Type de base : long, nombre de bits binaires : ") + Long.SIZE)  
        System.out.println("Classe d'emballage : java.lang.Long")  
        System.out.println("Valeur minimale : Long.MIN_VALUE=") + Long.MIN_VALUE)  
        System.out.println("Valeur maximale : Long.MAX_VALUE=") + Long.MAX_VALUE)  
        System.out.println();  
  
        // float  
        System.out.println("Type de base : float, nombre de bits binaires : ") + Float.SIZE)  
        System.out.println("Classe d'emballage : java.lang.Float")  
        System.out.println("La valeur minimale : Float.MIN_VALUE=") + Float.MIN_VALUE);  
        System.out.println("Maximum value: Float.MAX_VALUE="); + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("Basic type: double Binary bits:"); + Double.SIZE);  
        System.out.println("Packaging class: java.lang.Double");  
        System.out.println("Minimum value: Double.MIN_VALUE="); + Double.MIN_VALUE);  
        System.out.println("Maximum value: Double.MAX_VALUE="); + Double.MAX_VALUE);  
        System.out.println();  
  
        // char  
        System.out.println("Basic type: char Binary bits: "); + Character.SIZE);  
        System.out.println("Packaging class: java.lang.Character");  
        // Output Character.MIN_VALUE to the console in numerical form rather than character form  
        System.out.println("Minimum value: Character.MIN_VALUE=");  
                + (int) Character.MIN_VALUE);  
        // Output Character.MAX_VALUE to the console in numerical form rather than character form  
        System.out.println("Maximum value: Character.MAX_VALUE=");  
                + (int) Character.MAX_VALUE);  
    }  
}

The output result of compiling the above code is as follows:

Basic type: byte Binary bits:8
Packaging class: java.lang.Byte
Minimum value: Byte.MIN_VALUE=-128
Maximum value: Byte.MAX_VALUE=127
Basic type: short Binary bits:16
Packaging class: java.lang.Short
Minimum value: Short.MIN_VALUE=-32768
Maximum value: Short.MAX_VALUE=32767
Basic type: int Binary bits:32
Packaging class: java.lang.Integer
Minimum value: Integer.MIN_VALUE=-2147483648
Maximum value: Integer.MAX_VALUE=2147483647
Basic type: long Binary bits:64
Packaging class: java.lang.Long
Valeur minimale : Long.MIN_VALUE=-9223372036854775808
Valeur maximale : Long.MAX_VALUE=9223372036854775807
Type de base : float Taille binaire :32
Classe enveloppe : java.lang.Float
Valeur minimale : Float.MIN_VALUE=1.4E-45
Valeur maximale : Float.MAX_VALUE=3.4028235E38
Type de base : double Taille binaire :64
Classe enveloppe : java.lang.Double
Valeur minimale : Double.MIN_VALUE=4.9E-324
Valeur maximale : Double.MAX_VALUE=1.7976931348623157E308
Type de base : char Taille binaire :16
Classe enveloppe : java.lang.Character
Valeur minimale : Character.MIN_VALUE=0
Valeur maximale : Character.MAX_VALUE=65535

Les valeurs minimales et maximales des Float et Double sont exprimées sous forme de notation scientifique, et la fin "E+Le nombre "représente que le nombre avant E doit être multiplié par10puissance. Par exemple3.14E3est3.14 × 103 =3140,3.14E-3 est 3.14 x 10-3 =0.00314.

En réalité, JAVA comporte également un autre type de base void, qui a également une classe de wrapping java.lang.Void, mais nous ne pouvons pas les manipuler directement.

Valeur par défaut du type

Le tableau suivant liste les valeurs par défaut de tous les types de Java :

Type de donnéesValeur par défaut
byte0
short0
int0
long0L
float0.0f
double0.0d
char'u0000'
String (ou tout objet)null
booleanfalse

Exemple en ligne

public class Test {
    static boolean bool;
    static byte by;
    static char ch;
    static double d;
    static float f;
    static int i;
    static long l;
    static short sh;
    static String str;
 
    public static void main(String[] args) {
        System.out.println("Bool :") + bool);
        System.out.println("Byte :") + by);
        System.out.println("Character:") + ch);
        System.out.println("Double :" + d);
        System.out.println("Float : ", + f);
        System.out.println("Integer : ", + i);
        System.out.println("Long : ", + l);
        System.out.println("Short : ", + sh);
        System.out.println("String : ", + str);
    }
}

Le résultat de la sortie de l'exemple est :

Bool : false
Byte : 0
Character :
Double : 0.0
Float : 0.0
Integer : 0
Long : 0
Short : 0
String : null

 types de données de référence

  •  Dans Java, les variables de type de référence sont très similaires à celles de C/C++Les types de données de référence sont des types de données de pointeur. Les types de données de référence pointent vers un objet, et les variables qui pointent vers l'objet sont des variables de référence. Ces variables sont spécifiées comme un type spécifique lors de leur déclaration, par exemple Employee, Puppy, etc. Une fois déclarées, le type ne peut pas être modifié.

  • Les objets et les tableaux sont des types de données de référence.

  •  La valeur par défaut de tous les types de référence est null.

  •  Une variable de référence peut être utilisée pour référencer n'importe quel type compatible.

  •  Exemple : Site site = new Site("w3codebox)。

Constantes Java

Les constantes ne peuvent pas être modifiées au cours de l'exécution du programme.

En Java, le mot-clé final est utilisé pour modifier les constantes, de la même manière que pour les variables :

final double PI = 3.1415927;

Bien que les noms de constantes puissent également être en minuscules, ils sont généralement utilisés en majuscules pour faciliter l'identification.

Les littéraux peuvent être assignés à n'importe quel type intégré. Par exemple :

byte a = 68;
char a = 'A'

byte, int, long, et short peuvent être représentés en décimal,16systèmes de numération ainsi que8manière de numération.

Lorsque vous utilisez des constantes, le préfixe 0 représente 8 systèmes de numération, tandis que le préfixe 0x représente 16 systèmes de numération, par exemple :

int decimal = 100;
int octal = 0144;
int hexa = 0x64;

Comme dans d'autres langages, les constantes de chaîne en Java sont une séquence de caractères entourés de guillemets doubles. Voici des exemples de littéraux de type chaîne :

"Hello World"
"two\nlines"
"\"This is in quotes\""

Les constantes de chaîne et les constantes de caractères peuvent contenir n'importe quel caractère Unicode. Par exemple :

char a = '\u000'1';
String a = "\u0001";

Le langage Java prend en charge certaines séquences de caractères d'échappement spéciales.

                        Symbole                        Signification du caractère
                        \n                        Retour ligne (0x0a)
                        \r                        Retour chariot (0x0d)
                        \f                        Retour à la ligne (0x0c)
                        \b                        Retour d'effacement (0x08)
                        \0                        Caractère de fin de chaîne (0x0)
                        \s                        Espace (0x20)
                        \t                        Tabulation
                        \"                        Guillemet double
                        \'                        Guillemet simple
                        \\                        Barre oblique
                        \ddd                        Caractère octal (ddd)
                        \uxxxx                        16Caractère binaire Unicode (xxxx)

Conversion automatique de type

Les types de données entiers, réels (constantes) et caractères peuvent être combinés. Dans l'opération, les types de données différents sont d'abord convertis en même type, puis opérés.

Conversion de bas en haut.

Bas  ------------------------------------>  Haut
byte,short,char—> int —> long—> float —> double

La conversion de type de données doit respecter les règles suivantes :

  • 1. Il ne peut pas convertir le type boolean.

  • 2. Il ne peut pas convertir un type d'objet en un objet de classe non pertinente.

  • 3. Il est nécessaire d'utiliser la conversion de type forcé lors de la conversion d'un type de capacité plus grande en un type de capacité plus petite.

  • 4. La conversion peut entraîner un dépassement de capacité ou une perte de précision, par exemple :

    int i =128;   
    byte b = (byte)i;

    parce que le type byte est 8 bits, la valeur maximale est127donc, lors de la conversion forcée de int en byte, la valeur 128 causera un dépassement de capacité.

  • 5. La conversion de nombre à virgule flottante en nombre entier se fait en arrondissant à l'inférieur, par exemple :

    (int)23.7 == 23;        
    (int)-45.89f == -45

Conversion automatique de type

Le type de données doit être inférieur au type de données après la conversion, par exemple : le type de données short a16bits, on peut automatiquement convertir32bits, la valeur float a également32peut être converti automatiquement en64bits de type double.

public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//Définir un type de char
            int i1 = c1;//Conversion automatique de char en int
            System.out.println("La valeur égale après la conversion automatique de char en int est"+i1);
            char c2 = 'A';//Définir un type de char
            int i2 = c2+1;//Calcul de char et int de type
            System.out.println("La valeur calculée après la soustraction de char et int est égale à"+i2);
        }
}

Le résultat de l'exécution est :

La valeur égale après la conversion automatique de char en int est97
La valeur calculée après la soustraction de char et int est égale à66

Analyse :c1 La valeur est un caractère a , by consulting the ASCII code table, the corresponding int type value is 97, A corresponds to the value 65, so i2=65+1=66.

Type casting

  • 1. The condition is that the data type to be converted must be compatible.

  • 2. Format: (type)value where type is the data type to be cast   Example:

    public class QiangZhiZhuanHuan{
        public static void main(String[] args){
            int i1 = 123;
            byte b = (byte)i1;//Type casting to byte
            System.out.println("The value of int after converting to byte type is equal to"+b);
        }
    }

    Running result:

    The value of int after converting to byte type is equal to123

Implicit type conversion

  • 1. The default type for integers is int.

  • 2. There is no such thing as a floating-point type because it is necessary to follow the number with F or f when defining the float type.

This section explains the basic data types of Java. The next section will discuss different variable types and their usage.