Java Data Types : aperçu de tous les types de données du langage de programmation

Java propose huit types de données primitives et de nombreux autres types de données complexes. Ils déterminent les valeurs qui peuvent être stockées et représentées dans une variable. En langage Java, toutes les variables sont associées à certains types de données.

Quels sont les différents types de données en Java ?

Dans chaque langage de programmation, il existe différents types de données qui contiennent certains objets ainsi que des opérations définies. Bien qu’elles aient souvent des similarités, il y a néanmoins de grandes différences entre les options offertes d’un langage à l’autre. Si vous comparez par exemple Python vs Java, vous remarquerez, outre les similitudes, de nombreuses différences qui prédestinent chaque langage à des tâches spécifiques. Java s’appuie sur deux sortes de types de données : primitifs et complexes (également appelés « types de référence »). Ces différents types de données Java se distinguent par leur taille et déterminent 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 structures plus complexes et organiser et manipuler de grandes quantités de données. Si vous souhaitez apprendre à programmer, il est important non seulement de connaître les diffé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 différents types de données primitifs qui contiennent des plages de valeurs bien définies. Ils peuvent être classés en quatre catégories : type de données logique, type de données entier, type de données à virgule flottante et type de données à caractères. Ils n’ont pas de capacités supplémentaires spéciales et sont aussi appelés « types de données élémentaires ». Chaque type de données possède un nombre déterminé de bits. Trouvez ci-dessous une présentation plus détaillée de ces types de données primitifs. Java comprend les types élémentaires 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éterminer 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 complément à deux ayant une taille de 8 bits ou 1 octet. Il est surtout utilisé pour économiser 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 économiser de la mémoire dans les grands arrays. La valeur de complé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 complé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 complé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 représentation standard des nombres binaires et décimaux à virgule flottante dans les ordinateurs. 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écessitant une grande précision. Si ce n’est pas le cas, vous pouvez utiliser float pour gagner de la place. Voici la syntaxe correspondante :

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 recommandé 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 travailler avec des valeurs parfaitement exactes, utilisez plutôt la classe BigDecimal. La syntaxe du type de données double est la suivante :

double doubleVar;

char

char est un type de données de caractères. Il stocke les caractères sur la base du jeu de caractères Unicode et permet ainsi une portabilité sur de nombreuses plates-formes différentes. Chaque caractère nécessite 2 octets de mémoire. Sa plage de valeurs correspond à l’ASCII (American Standard Code for Information Interchange) et se situe donc entre « \u0000 » (donc 0) et « \uffff » (correspond à 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, contrairement aux types de données primitifs, ils ne sont pas prédéfinis, mais déterminés par le programmeur ou la programmeuse (à 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 commencent par une lettre minuscule, les types de référence commencent par une lettre majuscule. Découvrez ci-après les principaux types de référence.

Strings

String est une classe qui permet de représenter une séquence de caractères. C’est ce qui distingue ce type de données complexe du type primitif char. La chaîne de caractères existe en tant qu’objet dans la classe java.lang.String. Les différentes méthodes de la classe string permettent d’examiner les différents caractè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 caractères sont indiquées par des guillemets placés en haut. Ce type de référence a la syntaxe suivante :

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

Les strings fonctionnent, 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 diffé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 contiennent différents composants, notamment, entre autres, le nom de la classe, son modificateur et un corps dans des accolades. En pratique, cela ressemble à ceci :

public class Main {
    int a = 10;
}

Interfaces

En Java, une interface est définie comme un type spécial qui est complètement abstrait et peut contenir des méthodes abstraites ainsi que des constantes. Contrairement à une classe abstraite, une interface ne peut pas contenir de méthodes concrètes (avec une implémentation). Les classes ou d’autres interfaces qui adoptent une interface doivent implémenter toutes ses méthodes abstraites. Leur syntaxe prend la forme suivante :

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

Pour expliquer le fonctionnement des interfaces, 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’indication correspondante 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 principale 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’indication obtenue prend la forme suivante :

10
10

Enums

Les enums sont une classe spéciale qui vous permet d’inclure des valeurs constantes dans votre code. Ces variables reçoivent des valeurs fixes qui ne peuvent pas être modifiées ultérieurement. Ce type de données est particulièrement 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
}