Types de données de référence en Java

Sans comprendre la syntaxe Java, il est impossible de devenir un développeur sérieux, c'est pourquoi nous continuons aujourd'hui à apprendre la syntaxe. Dans l'un des articles précédents, nous avons parlé des variables primitives, mais comme il existe deux types de variables, nous parlerons aujourd'hui du deuxième type - les types de référence en Java. Alors c'est quoi? Pourquoi les types de données de référence sont-ils nécessaires en Java ? Imaginons que nous ayons un objet TV avec certaines caractéristiques, telles que le numéro de chaîne, le volume sonore et le drapeau :

public class TV {
   int numberOfChannel;
   int soundVolume;
   boolean isOn;
}

Comment un type simple comme , peut-il intstocker ces données ? Rappelons-nous : une variable intfait 4 octets. Mais à l'intérieur il y a deux variables (4 octets + 4 octets) du même type, et aussi boolean(+1 octet)... Total - 4 à 9, mais en règle générale, beaucoup plus d'informations sont stockées dans un objet. Ce qu'il faut faire? Vous ne pouvez pas mettre un objet dans une variable. À ce stade de notre histoire, des variables de référence apparaissent. Les variables de référence stockent l'adresse de l'emplacement mémoire dans lequel se trouve un objet spécifique. C'est-à-dire qu'il s'agit d'une « carte de visite » avec une adresse, avec laquelle nous pouvons retrouver notre objet en mémoire partagée et effectuer quelques manipulations avec lui. Une référence à n’importe quel objet en Java est une variable de référence. Voici à quoi cela ressemblerait avec notre objet TV :

TV telly = new TV();

Nous définissons une variable de type TV avec un nom tellyvers un lien vers l'objet créé de type TV. Autrement dit, la JVM alloue de la mémoire sur le tas pour l'objet TV, le crée et l'adresse de son emplacement en mémoire, la place dans la variable tellyqui est stockée sur la pile. Vous pouvez en savoir plus sur la mémoire, à savoir la pile et de nombreuses autres informations utiles, dans cette conférence . Une variable de type TV et un objet de type TV, vous avez remarqué ? Ce n'est pas sans raison : les objets d'un certain type doivent avoir des variables correspondantes du même type (sans compter l'héritage et les implémentations d'interface, mais maintenant nous n'en tenons pas compte). Après tout, on ne va pas verser de la soupe dans des verres, n’est-ce pas ? Il s'avère que notre objet est un téléviseur et que sa variable de référence est comme un panneau de commande. Grâce à cette télécommande, nous pouvons interagir avec notre objet et ses données. Par exemple, définissez les caractéristiques de notre téléviseur :

telly.isOn = true;
telly.numberOfChannel = 53;
telly.soundVolume = 20;

Ici, nous avons utilisé l'opérateur point .pour accéder et commencer à utiliser les éléments internes de l'objet auquel la variable fait référence. Par exemple, dans la première ligne, nous avons dit à la variable telly: « Donnez-nous une variable interne isOnde l'objet que vous référencez et définissez-la sur true » (allumez la télé pour nous).

Redéfinir les variables de référence

Disons que nous avons deux variables d'un type référence et les objets auxquels elles font référence :

TV firstTV = new TV();
TV secondTV = new TV();

Si on écrit :

firstTV = secondTV;

cela signifie que nous avons attribué à la première variable comme valeur une copie de l'adresse (la valeur des bits d'adresse) au deuxième objet, et maintenant les deux variables font référence au deuxième objet (en d'autres termes, deux télécommandes pour le même LA TÉLÉ). Dans le même temps, le premier objet est resté sans variable qui y fait référence. En conséquence, nous avons un objet auquel nous ne pouvons pas accéder, car la variable était un thread tellement conditionnel, sans lequel elle se transforme en poubelle, reste simplement en mémoire et prend de la place. Cet objet sera ensuite détruit de la mémoire par le garbage collector . Vous pouvez rompre le fil de connexion avec un objet sans autre lien :

secondTV = null;

En conséquence, il n'y aura qu'un seul lien vers l'objet - firstTV, et secondTVne pointera plus vers personne (ce qui ne nous empêche pas de lui attribuer un lien vers un objet comme la télévision à l'avenir).

Classe de chaîne

Séparément, je voudrais mentionner la classe String . Il s'agit d'une classe de base conçue pour stocker et utiliser des données stockées sous forme de chaîne. Exemple:

String text = new String("This TV is very loud");

Ici, nous avons passé une chaîne à stocker dans le constructeur de l'objet. Mais personne ne fait ça. Après tout, des chaînes peuvent être créées :

String text = "This TV is very loud";

Beaucoup plus pratique, non ? En termes de popularité d'utilisation, Stringil n'est pas inférieur aux types primitifs, mais c'est toujours une classe, et la variable qui y fait référence n'est pas un type primitif, mais un type de référence. Nous Stringavons cette merveilleuse capacité à concaténer des chaînes :

String text = "This TV" + " is very loud";

En conséquence, nous obtiendrons à nouveau le texte : This TV is very loud, puisque les deux lignes seront combinées en un tout, et la variable fera référence à ce texte intégral. Une nuance importante est qu’il Strings’agit d’une classe immuable. Qu'est-ce que ça veut dire? Prenons cet exemple :

String text = "This TV";
text = text + " is very loud";

Il semble que tout soit simple : on déclare une variable, on lui donne une valeur. Sur la ligne suivante, nous le modifions. Mais nous ne changeons pas vraiment. Puisqu'il s'agit d'une classe immuable, sur la deuxième ligne, la valeur initiale n'est pas modifiée, mais une nouvelle est créée, qui à son tour comprend la première + " is very loud".

Constantes de référence

Dans l'article sur les types primitifs, nous avons abordé le sujet des constantes. Comment se comportera une variable de référence lorsque nous la déclarerons finale ?

final TV telly = new TV();

Vous pourriez penser que cela rendra l'objet immuable. Mais non, ce n'est pas vrai. Une variable de référence avec un modificateur finalsera liée à un objet spécifique sans possibilité de la dissocier de quelque manière que ce soit (la redéfinir ou l'assimiler à null). Autrement dit, après avoir défini la valeur d'une telle variable, codez comme :

telly = new TV();

ou

telly = null;

provoquera une erreur de compilation. Autrement dit, finalil n'agit que sur le lien et n'a aucun effet sur l'objet lui-même. Si nous le rendons initialement mutable, nous pouvons changer son état interne sans aucun problème :

telly.soundVolume = 30;

Parfois, les variables sont désignées comme finales même dans les arguments de la méthode !

public void enableTV (final TV telly){
   telly.isOn = true;
}

Ceci est fait pour que pendant le processus d'écriture d'une méthode, ces arguments ne puissent pas être remplacés et, par conséquent, créent moins de confusion. Et si nous notions finalune variable de référence qui fait référence à un objet immuable ? Par exemple String:

final String PASSWORD = "password";

En conséquence, nous obtiendrons une constante, un analogue des constantes de type primitif, car ici nous ne pouvons ni redéfinir la référence ni changer l'état interne de l'objet (données internes).

Résumons-le

1. Alors que les variables simples stockent les bits de valeur, les variables de référence stockent les bits qui représentent la manière dont un objet est récupéré.
2. Les références d'objet sont déclarées pour un seul type d'objet.
3. Toute classe en Java est un type référence.
4. La valeur par défaut de toute variable de référence en Java est null.
5. Stringest un exemple standard de type référence. Cette classe est également immuable.
6. Les variables de référence avec un modificateur finalsont liées à un seul objet sans possibilité de redéfinition.