En Java, nous avons deux types de données (ou variables) : primitives et non primitives (également appelées références).

Les types primitifs ont leurs valeurs littérales stockées dans la Stack, mémoire de stockage temporaire et à court terme, gérée par la machine virtuelle Java (JVM). [en savoir plus sur les types de mémoire ici]

Les variables primitives sont divisées en quatre groupes :

1. Types entiers : utilisé pour stocker des entiers (sans partie décimale). Ce sont : octet, court, int, long. Le long comporte la lettre « L » ou « l » à la fin du numéro, pour la différenciation.

2. Types à virgule flottante :  : Utilisé pour stocker des nombres avec une partie décimale (nombres réels). Ce sont : float, double. Le flotteur porte la lettre « F » ou « f » à la fin du numéro, pour la différenciation.

3. Type de caractère : Utilisé pour stocker des caractères uniques (tels que des lettres, des chiffres ou des symboles) : char. Ils sont initialisés avec des guillemets simples '', au lieu de doubles "".

4. Type booléen : Utilisé pour stocker des valeurs logiques (vrai ou faux) : bool

Voir le tableau ci-dessous pour connaître la plage de valeurs prise en charge par chaque type, en plus de leurs valeurs « par défaut » :

Au format scientifique, E représente un exposant. Par exemple, 1,23E 10 est égal à 1,23 x 10^10

Qu'est-ce qu'une valeur par défaut ? C'est la valeur que prendra la variable si elle n'a pas été initialisée. Cependant, pour assumer cette valeur, elle doit être globale ou constante (finale).

public final boolean isTrue;

Dans cette ligne de code, la variable "isTrue" n'a pas été initialisée, mais le compilateur ne présentera pas d'erreur, car il considérera la valeur par défaut "false" pour la variable booléenne.

Ici, un avertissement important : si la portée de la variable est locale, c'est-à-dire si elle a été déclarée au sein d'une fonction, nous, programmeurs, serons obligés de lui attribuer une valeur. Sinon, il y aura une erreur de compilation.

public void teste(){
        int i = 2;
        int j;

        if (i 



Dans cet exemple, même si l'on sait que "2 


  
  
  Adresses mémoire


Le deuxième type de données en Java est appelé référence. Ces variables stockent une référence, c'est-à-dire l'adresse mémoire d'un objet, au lieu de stocker directement sa valeur, comme cela se produit avec les types primitifs. Ce stockage s'effectue dans la mémoire Heap.

Les types de référence sont des classes, des interfaces, des énumérations et des objets, en général. 

Ici, un addendum. La chaîne que nous utilisons largement dans nos codes est une classe et non un type primitif. Notez que même le nom est en majuscule, tout comme la convention de dénomination des classes en Java.

La String a même des méthodes, telles que length(), qui renvoie la taille du texte qui y est stocké, charAt(int index), qui renvoie l'index d'un caractère dans le texte, ou substring(int startIndex, int endIndex), qui renvoie un morceau de chaîne.

Mais si vous souhaitez faciliter la manipulation des données primitives, Java le permet également. Pour cela, il dispose de la classe Wrapper, qui est déjà livrée avec une série de méthodes intégrées pour travailler avec les types de base.

Les wrappers ont fondamentalement le même nom que la variable primitive, cependant, avec la première lettre en majuscule : 

• Octet à octet
• Abréviation de court
• Entier à entier
• Long à long
• Flotter pour flotter
• Doubler pour doubler
• Caractère à caractère
• Booléen à booléen

public class WrapperExample {
    public static void main(String[] args) {
        String numeroStr = "123";
        Integer num1 = Integer.parseInt(numeroStr);
        Integer num2 = 200;

        int resultadoComparacao = Integer.compare(num1, num2);

        if (resultadoComparacao  0) {
            System.out.println(num1   " é maior que "   num2);
        } else {
            System.out.println(num1   " é igual a "   num2);
        }
    }
}

Dans cet exemple de code, le wrapper int est utilisé pour convertir une chaîne en nombre (Integer.parse), puis la comparer avec un autre nombre (Integer.compare).

Une String a cependant une particularité que les autres classes n'ont pas. C'est immuable.

Réfléchissons à travers cet exemple de base :

public class Main {
  public static void main(String[] args) {

    String text1 = "Hello";
    String text2 = text1;

    System.out.println(text1); //output: Hello
    System.out.println(text2); //output: Hello

    text1 = "Weird";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: Hello

    text2 = "World";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: World

    TestClass test1 = new TestClass("propertyValue");
    TestClass test2 = test1;

    System.out.println(test1.getProperty()); //output: propertyValue
    System.out.println(test2.getProperty()); //output: propertyValue

    test2.setProperty("newValue");

    System.out.println(test1.getProperty()); //output: newValue
    System.out.println(test2.getProperty()); //output: newValue   
  }

}

Dans ce cas, notez que, même si la chaîne "text2" pointe vers "text1", les modifications apportées à "text2" ne reflètent pas les modifications apportées à "text1". Désormais, lorsqu'une propriété de l'objet "test2" pointait vers "test1" était modifiée, ce changement se reflétait également dans "test1".

Hé, mais les variables de référence ne stockent-elles pas les adresses mémoire, au lieu des valeurs littérales ? Oui. Ils le stockent. Ce qui se passe, c'est que les développeurs du langage Java ont pris la décision de laisser les variables String immuables. Cela signifie qu'une fois définie, la valeur d'un objet String ne peut pas être modifiée indirectement par un autre objet.

Par conséquent, dans l'exemple, nous ne modifions pas la valeur de l'objet précédemment référencé par text1 (puisque String est immuable). Au lieu de cela, nous créons un nouvel objet String avec la valeur "Weird" et faisons pointer text1 vers ce nouvel objet. Alors que text2 pointe toujours vers l'objet "Hello" d'origine et c'est pourquoi il conserve la valeur "Hello".

En bref, attribuer une nouvelle valeur à une chaîne ne modifie pas la valeur de l'objet existant, cela change simplement la référence à un nouvel objet.

Les objets des classes personnalisées, telles que TestClass, sont modifiables. Les références test1 et test2 pointent vers le même objet, donc la modification de l'état de l'une d'elles se reflète sur l'autre.