Java

Appelez-nous au numéro (+212) 616 374 790 ou écrivez-nous à essaddouki@gmail.com

Demander le soutien en ligne de l'un de nos professeurs, à toute heure et où vous voulez, de 8h à minuit (GMT) Détails

Types de données intégrés en Java

Une variable est un nom donné à un emplacement de mémoire. C'est l'unité de base de stockage dans un programme.

  •     La valeur stockée dans une variable peut être modifiée pendant l'exécution du programme.
  •     Une variable est seulement un nom donné à un emplacement de mémoire, toutes les opérations effectuées sur la variable affectent cet emplacement de mémoire.
  •     En Java, toutes les variables doivent être déclarées avant utilisation.

Sur la base du type de données d'une variable, le système d'exploitation alloue de la mémoire et décide de ce qui peut être stocké dans la mémoire réservée. Par conséquent, en affectant différents types de données aux variables, vous pouvez stocker des entiers, des décimales ou des caractères dans ces variables.

Types de données de base

Il existe deux types de données disponibles en Java

  •     Types primitifs
  •     Types de données références/objets

Types primitifs

Java prend en charge huit types primitifs. Les types primitifs sont prédéfinis par le langage et nommés par un mot clé. Voyons maintenant les huit types primitifs en détail.

boolean
  •     Le type de données booléen représente un bit d'information
  •     Il n'y a que deux valeurs possibles: true et false
  •     Ce type de données est utilisé pour les indicateurs simples qui suivent les conditions vraies/fausses.
  •     La valeur par défaut est false
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        boolean etat=true;
                                        System.out.println(etat);
                                    }
                                }
                                
                            
char
  •     C'est un caractère Unicode 16 bits.
  •     La valeur minimale est '\ u0000' (ou 0)
  •     La valeur maximale est '\uffff' (ou 65 535 inclus)
  •     Le type de données Char est utilisé pour stocker n'importe quel caractère
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        char ch='a';
                                        System.out.println(ch);
                                    }
                                }
                            
byte
  •     Le type de données byte peut avoir des valeurs comprises entre -128 et 127 (entier signé en en complément à 2 de 8 bits).
  •     Il est utilisé à la place de int ou d'autres types de données entiers pour économiser de la mémoire s'il est certain que la valeur d'une variable sera comprise entre [-128, 127].
  •     Valeur par défaut: 0
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        byte i=2;
                                        System.out.println(i);
                                    }
                                }
                                
                            
short
  •     Le type de données court peut avoir des valeurs de -32768 à 32767 (entier signé en complément à 2 de 16 bits).
  •     Il est utilisé à la place d'autres types de données entiers pour économiser de la mémoire s'il est certain que la valeur de la variable sera comprise entre [-32768, 32767].
  •     Valeur par défaut: 0
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        short val=3;
                                        System.out.println(val);
                                    }
                                }
                            
int
  •     Le type de données Int est un entier signé en en complément à 2 de 32 bits.
  •     La valeur minimale est de - 2 147 483 648 (-231)
  •     La valeur maximale est de 2 147 483 647 (inclus) (231 -1)
  •     int est généralement utilisé comme type de données par défaut pour les valeurs entières, sauf en cas de problème de mémoire.
  •     La valeur par défaut est 0
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        int val=50;
                                        System.out.println(val);
                                    }
                                }
                            
long
  •     Le type de données long est un entier signé en en complément à 2 de 64 bits
  •     La valeur minimale est -9 223 372 036 854 775 808 (-263)
  •     La valeur maximale est 9 223 372 036 854 775 807 (inclus) (263 -1)
  •     Ce type est utilisé quand une plage plus large que int
  •     La valeur par défaut est 0
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        long val=453453456666;
                                        System.out.println(val);
                                    }
                                }
                            
float
  •     Le type de données float est une virgule flottante 32 bits à simple précision.
  •     Il ne devrait jamais être utilisé pour des valeurs précises telles que la devise.
  •     Valeur par défaut est 0.0 (0.0f)
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        float val = -42.3f;
                                        System.out.println(val);
                                    }
                                }
                            
double
  •     le type de données double est une virgule flottante IEEE 754 64 bits double précision
  •     Ce type de données est généralement utilisé comme type de données par défaut pour les valeurs décimales, généralement le choix par défaut.
  •     Le type de données double ne doit jamais être utilisé pour des valeurs précises telles que la devise
  •     La valeur par défaut est 0.0d
Exemple :
                                public class Types{
                                    public static void main(String args[]){

                                        double val = 5.95;
                                        System.out.println(val);
                                    }
                                }
                            

Types de données références/objets

  •     Les variables de référence sont créées en utilisant des constructeurs définis des classes. Ils sont utilisés pour accéder aux objets. Ces variables sont déclarées d'un type spécifique qui ne peut être changé. Par exemple, etudiant, cours, etc.
  •     Les objets de classe et les différents types de variables de tableau se trouvent sous le type de données de référence.
  •     La valeur par défaut de toute variable de référence est null.
  •     Une variable de référence peut être utilisée pour faire référence à tout objet du type déclaré ou de tout type compatible.

Littéraux Java

Un littéral est une représentation d'un élément syntaxique d'une valeur fixe. Ils sont représentés directement dans le code sans aucun calcul.
Les exemples sont 1 , 0.333F , false , 'X' et "Hello world\n" .

Les littéraux peuvent être affectés à n'importe quelle variable de type primitif. Par exemple

Exemple 1 :
                                public class Types{
                                    public static void main(String args[]){

                                        double val = 5.95;
                                        int a=2;
                                        char ch='a';
                                    }
                                }
                            

byte, int, long et short peuvent également être exprimés en numération décimale (base 10), hexadécimale (base 16) ou octale (base 8).

Le préfixe 0 est utilisé pour indiquer l'octal et le préfixe 0x indique l'hexadécimal lors de l'utilisation de ces systèmes de numération pour les littéraux. Par exemple

Exemple 2 :
                                public class Types{
                                    public static void main(String args[]){

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

Les littéraux de chaîne en Java sont spécifiés comme dans la plupart des autres langues en entourant une séquence de caractères entre une paire de guillemets doubles.
Pour les littéraux de caractères, un seul guillemet est utilisé.

Les types de littéraux chaîne et caractère peuvent contenir tous les caractères Unicode.

Exemple 3 :
                                public class Types{
                                    public static void main(String args[]){

                                        char myChar = 'g';
                                        char newLine = '\n';
                                        String myString = "Java 8";
                                    }
                                }
                            

Le langage Java prend également en charge quelques séquences d'échappement spéciales pour les littéraux String et Char. Elles sont :

NotationCaractère représenté
\nretour à la ligne (0x0a)
\rRetour chariot (0x0d)
\fSaut(0x0c)
\bRetour arrière (0x08)
\sEspace (0x20)
\ttabulation
\"doublbe Guillemets
\'Guillemets
\\oblique inverse
\dddCaractère octal (ddd)
\uxxxxCaractère UNICODE hexadécimal (xxxx)

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :