Java Data Types : aperçu de tous les types de données du langage de pro­gram­ma­tion

Java propose huit types de données pri­mi­tives et de nombreux autres types de données complexes. Ils dé­ter­mi­nent les valeurs qui peuvent être stockées et re­pré­sen­tées dans une variable. En langage Java, toutes les variables sont associées à certains types de données.

Quels sont les dif­fé­rents types de données en Java ?

Dans chaque langage de pro­gram­ma­tion, il existe dif­fé­rents types de données qui con­tien­nent certains objets ainsi que des opé­ra­tions définies. Bien qu’elles aient souvent des si­mi­la­ri­tés, il y a néanmoins de grandes dif­fé­rences entre les options offertes d’un langage à l’autre. Si vous comparez par exemple Python vs Java, vous re­mar­que­rez, outre les si­mi­li­tudes, de nom­breuses dif­fé­rences qui pré­des­ti­nent chaque langage à des tâches spé­ci­fiques. Java s’appuie sur deux sortes de types de données : primitifs et complexes (également appelés « types de référence »). Ces dif­fé­rents types de données Java se dis­tin­guent par leur taille et dé­ter­mi­nent quelles valeurs peuvent être stockées dans une variable.

Si les types de données primitifs ne peuvent que stocker des valeurs simples, les types de référence, eux, sont utilisés pour créer des struc­tures plus complexes et organiser et manipuler de grandes quantités de données. Si vous souhaitez apprendre à pro­gram­mer, il est important non seulement de connaître les dif­fé­rents types, mais aussi de savoir comment les utiliser le mieux possible. Cela concerne d’une part l’étendue des fonctions et d’autre part l’espace mémoire occupé ou économisé par le bon type de données.

Java Data Types : les types de données primitifs en langage Java

En langage Java, il existe en tout huit dif­fé­rents types de données primitifs qui con­tien­nent des plages de valeurs bien définies. Ils peuvent être classés en quatre ca­té­go­ries : type de données logique, type de données entier, type de données à virgule flottante et type de données à ca­rac­tères. Ils n’ont pas de capacités sup­plé­men­taires spéciales et sont aussi appelés « types de données élé­men­taires ». Chaque type de données possède un nombre déterminé de bits. Trouvez ci-dessous une pré­sen­ta­tion plus détaillée de ces types de données primitifs. Java comprend les types élé­men­taires suivants :

• boolean
• byte
• short
• int ou integer
• long
• float
• double
• char

boolean

Le booléen Java n’est pas un type numérique. Il ne propose que deux valeurs possibles : true et false. Il peut donc être utilisé pour dé­ter­mi­ner si une condition est vraie (true) ou fausse (false). Sa valeur par défaut est false ; il fait partie des types de données logiques. Il comprend 1 bit et sa syntaxe prend la forme suivante :

boolean booleanVar;

byte

byte est un type de données entier et une valeur de com­plé­ment à deux ayant une taille de 8 bits ou 1 octet. Il est surtout utilisé pour éco­no­mi­ser de la mémoire dans les grands arrays. Sa plage de valeurs est comprise entre -128 et 127 et sa valeur par défaut est 0. Voici sa syntaxe :

byte byteVar;

short

short fait également partie des types de données entiers en langage Java ; il est surtout utilisé pour éco­no­mi­ser de la mémoire dans les grands arrays. La valeur de com­plé­ment à deux, en soi, a une taille de 16 bits ou 2 octets ; sa plage de valeurs va de -32768 à 32767 inclus. Par défaut, sa valeur est 0. Voici comment l’appliquer :

short shortVar;

int ou integer

int ou integer est également une valeur de com­plé­ment à deux et un type de données entier avec une taille de 4 octets ou 32 bits. Sa plage de valeurs comprend des nombres entiers entre -2147483648 et 2147483647 ; sa valeur par défaut est 0. Sa syntaxe ressemble à ceci :

int intVar;

long

Le plus grand type de données entier est long. Cela vaut d’une part pour sa plage de valeurs qui se situe entre -9223372036854775808 et 9223372036854775807, et d’autre part pour sa propre taille qui est de 8 octets ou 64 bits. La valeur de com­plé­ment à deux est donc utilisée lorsque les autres types de données entiers ne suffisent pas. En revanche, il est de loin celui qui nécessite le plus de mémoire. Sa valeur par défaut est 0. Voici sa syntaxe :

long longVar;

float

float est un type de données à virgule flottante. Il est utilisé pour stocker des nombres réels. Il a une taille de 32 bits et est conforme à la norme IEEE 754 qui définit la re­pré­sen­ta­tion standard des nombres binaires et décimaux à virgule flottante dans les or­di­na­teurs. La valeur par défaut de float est 0,0 et sa plage de valeurs permet d’afficher jusqu’à sept décimales. Cependant, comparé à double, float n’est pas aussi précis et ne devrait donc pas être utilisé pour des valeurs né­ces­si­tant une grande précision. Si ce n’est pas le cas, vous pouvez utiliser float pour gagner de la place. Voici la syntaxe cor­res­pon­dante :

float floatVar;

double

double est à peu près deux fois plus précis que float et remplit d’ailleurs un objectif similaire. Il a une taille de 64 bits et peut afficher jusqu’à 16 décimales. Sa valeur par défaut est aussi 0,0. Si vous avez besoin de valeurs plus précises, il est fortement re­com­mandé d’utiliser double, bien que ce type de données n’offre pas non plus une précision maximale jusque dans les moindres détails. Si vous souhaitez tra­vail­ler avec des valeurs par­fai­te­ment exactes, utilisez plutôt la classe Big­De­ci­mal. La syntaxe du type de données double est la suivante :

double doubleVar;

char

char est un type de données de ca­rac­tères. Il stocke les ca­rac­tères sur la base du jeu de ca­rac­tères Unicode et permet ainsi une por­ta­bi­lité sur de nom­breuses plates-formes dif­fé­rentes. Chaque caractère nécessite 2 octets de mémoire. Sa plage de valeurs cor­res­pond à l’ASCII (American Standard Code for In­for­ma­tion In­ter­change) et se situe donc entre « \u0000 » (donc 0) et « \uffff » (cor­res­pond à 65535). La valeur par défaut de char est « \u0000 » ; sa syntaxe prend la forme suivante :

char charVar;

Java Data Types : les types de données complexes en langage Java

Les deuxièmes sortes de types de données en langage Java sont les types dits de référence ou types de données complexes. Ils portent ce nom parce qu’ils se réfèrent à des objets. En général, con­trai­re­ment aux types de données primitifs, ils ne sont pas pré­dé­fi­nis, mais dé­ter­mi­nés par le pro­gram­meur ou la pro­gram­meuse (à l’exception de String). Ils sont capables d’utiliser des méthodes et peuvent également avoir la valeur 0 (dans le sens de vide). Alors que les types de données primitifs com­men­cent par une lettre minuscule, les types de référence com­men­cent par une lettre majuscule. Découvrez ci-après les prin­ci­paux types de référence.

Strings

String est une classe qui permet de re­pré­sen­ter une séquence de ca­rac­tères. C’est ce qui distingue ce type de données complexe du type primitif char. La chaîne de ca­rac­tères existe en tant qu’objet dans la classe java.lang.String. Les dif­fé­rentes méthodes de la classe string per­met­tent d’examiner les dif­fé­rents ca­rac­tères de la chaîne, de comparer les chaînes, de parcourir les chaînes et de copier les chaînes. Les chaînes de ca­rac­tères sont indiquées par des guil­le­mets placés en haut. Ce type de référence a la syntaxe suivante :

String nomDeLaVariable = "valeur de la chaîne";

Les strings fonc­tion­nent, par exemple, comme dans cet extrait de code :

// Pour créer un string sans nouvel opérateur, procédez comme suit
String a = "Ceci est votre nouveau string";
// Pour créer un string avec un nouvel opérateur, procédez comme suit
String a1 = new String ("Ceci est votre nouveau string");

Arrays

Les arrays sont utilisés pour stocker plusieurs valeurs dans une variable, plutôt que de créer des variables dif­fé­rentes pour chaque valeur. Ils sont indiqués par des crochets. Les valeurs déposées sont à leur tour placées entre accolades et séparées par des virgules. La syntaxe d’un array ressemble à ceci :

typededonnées[] arrayName = {valeur1, valeur2, valeur3,…};

Si vous souhaitez créer un array avec des strings, procédez comme dans cet exemple :

String[] couleurs = {"bleu", "rouge", "jaune", "violet"};

Si vous souhaitez créer un array avec des nombres entiers, vous pouvez procéder comme suit :

int[] nombres = {5, 10, 15, 20};

Classes

En Java, les classes sont des types de données qui servent de modèle dans lequel des objets sont ensuite créés. Elles con­tien­nent dif­fé­rents com­po­sants, notamment, entre autres, le nom de la classe, son mo­di­fi­ca­teur et un corps dans des accolades. En pratique, cela ressemble à ceci :

public class Main {
    int a = 10;
}

In­ter­faces

En Java, une interface est définie comme un type spécial qui est com­plè­te­ment abstrait et peut contenir des méthodes abs­traites ainsi que des cons­tantes. Con­trai­re­ment à une classe abstraite, une interface ne peut pas contenir de méthodes concrètes (avec une im­plé­men­ta­tion). Les classes ou d’autres in­ter­faces qui adoptent une interface doivent im­plé­men­ter toutes ses méthodes abs­traites. Leur syntaxe prend la forme suivante :

interface NomDeLInterface {
    // Déclaration de méthodes abstraites
    void uneMethode();
    int uneAutreMethode(int parametre);
}

Pour expliquer le fonc­tion­ne­ment des in­ter­faces, voici un exemple simple :

interface Pizza {
    public void listeIngrédients();
    public void préparation();
}
class Funghi implements Pizza {
    public void listeIngrédients() {
        System.out.println("champignons, sauce tomate, origan, mozzarella");
}
    public void préparation() {
        System.out.println("La pizza est prête au bout d’un quart d’heure");
}
}
class Main {
    public static void main(String[] args) {
        Funghi myFunghi = new Funghi();
        myFunghi.listeIngrédients();
        myFunghi.préparation();
    }
}

L’in­di­ca­tion cor­res­pon­dante obtenue par la commande Java System.out.println ressemble à ceci :

champignons, sauce tomate, origan, mozzarella
La pizza est prête au bout d’un quart d’heure

Objets

En langage Java, les objets font également partie des types de données qui sont plus complexes. Les objets sont des instances de classes qui peuvent ensuite interagir entre elles par le biais de méthodes. Dans l’exemple suivant, nous créons plusieurs objets au sein d’une classe prin­ci­pale Main :

public class Main {
    int a = 10;
public static void main(String[] args) {
    Main myObj1 = new Main();
    Main myObj2 = new Main();
    System.out.println(myObj1.a);
    System.out.println(myObj2.a);
        }
}

L’in­di­ca­tion obtenue prend la forme suivante :

10
10

Enums

Les enums sont une classe spéciale qui vous permet d’inclure des valeurs cons­tantes dans votre code. Ces variables reçoivent des valeurs fixes qui ne peuvent pas être modifiées ul­té­rieu­re­ment. Ce type de données est par­ti­cu­liè­re­ment utile si vous avez besoin de variables qui ne doivent avoir que quelques états possibles. La syntaxe d’un enum est comme suit :

enum NomClasse {
    VALEUR1,
    VALEUR2,
    VALEUR3
}