Types primitifs vs références en Java et immuabilité des chaînes

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. Long a 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 la plage de valeurs que possède 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 < 10){
            j = 5;
        }

        System.out.println(j);
    }

Dans cet exemple, même si l'on sait que "2 < 10" renvoie "true", le compilateur, qui n'exécute jamais les codes qu'il traduit au cours de son processus, ne sait pas que la condition est vraie et que la variable primitive "j" sera toujours initialisé. De cette façon, lorsque vous tenterez d'exécuter le code, une erreur de compilation apparaîtra : "erreur : la variable j n'a peut-être pas été initialisée".

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
• Shorts pour shorts
• Entier à entier
• Long à long
• Flotter pour flotter
• Doubler pour doubler
• Caractère à char
• 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 + " é menor que " + num2);
        } else 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).

String a cependant une particularité que les autres classes n'ont pas. Elle 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".

안녕하세요, 그런데 참조 변수는 리터럴 값 대신 메모리 주소를 저장하지 않나요? 네, 저장해요. Java 언어 개발자는 문자열 변수를 불변으로 두기로 결정했습니다. 즉, 일단 정의된 String 객체의 값은 다른 객체에 의해 간접적으로 변경될 수 없습니다.

따라서 이 예에서는 text1이 이전에 참조한 객체의 값을 변경하지 않습니다(String은 변경할 수 없으므로). 대신, "Weird" 값을 가진 새로운 String 객체를 생성하고 text1이 이 새로운 객체를 가리키도록 만듭니다. Text2는 여전히 원래 "Hello" 개체를 가리키므로 "Hello" 값을 유지합니다.

간단히 말하면 문자열에 새 값을 할당해도 기존 개체의 값은 수정되지 않고 새 개체에 대한 참조만 변경됩니다.

TestClass와 같은 사용자 정의 클래스의 객체는 변경 가능합니다. test1 및 test2 참조는 모두 동일한 개체를 가리키므로 둘 중 하나의 상태를 변경하면 다른 개체에도 반영됩니다.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!