Référence Java à comprendre dans la figure

Vous avez peut-être appris les «références» en programmation Java. Certaines personnes peuvent le comprendre facilement, d'autres ne peuvent le comprendre que d'une manière ou d'une autre, ou certaines personnes ne peuvent pas le comprendre et sont en difficulté. Cet article utilise des diagrammes pour expliquer les «références» Java à ceux qui pensent «Je le comprends d'une manière ou d'une autre, mais je ne peux pas l'expliquer aux autres» ou «Je ne peux pas obtenir une image même si elle est expliquée par des mots». Ce sera un article à faire. Concernant la figure, elle n'est pas précise car elle exprime en fait ce qui est invisible à l'oeil et elle est composée du minimum d'informations. Notez s'il vous plaît.

Types primitifs et de référence

Il existe deux types de types Java: les types primitifs (types de données de base) et les types de référence. Les types primitifs sont des types qui commencent par toutes les lettres minuscules et peuvent se voir attribuer des valeurs de données spécifiques (valeurs numériques et caractères) qui sont écrites directement dans la mémoire. C'est aussi l'une des caractéristiques qu'il n'a pas de méthode contrairement au type de référence.

Les huit ci-dessus sont des types primitifs et tous les autres sont des types de référence. Contrairement au type primitif, le type de référence se voit attribuer un pointeur (adresse en mémoire) sur l'objet nouvellement créé en tant que valeur de référence au lieu d'une valeur spécifique. L'objet ici est synonyme d'instance.

Tableau et chaîne

Ceux que je trouve personnellement faciles à mal comprendre sont les tableaux et les chaînes. Créez un objet car le tableau et la chaîne sont des types de référence.

//Type primitif
int i = 1;
//Type de référence
int[] array = {1, 2, 3};
String string = "pomme";

Le type int [] est exprimé en ajoutant à int, il est donc facile de se méprendre. Soyez prudent car le type int et le type int [] sont différents. Le type String attribue une chaîne, mais sachez que la chaîne est traitée comme un tableau de caractères à l'intérieur de l'objet String. Les trois derniers ont des notations différentes pour la création d'objets, mais ils sont tous équivalents. Veuillez noter que la même valeur et l'équivalent ont des significations différentes. Je vous serais reconnaissant de bien vouloir lire cet article pour l'équivalent et l'équivalent.

String a = "pomme";
String b = new String("pomme");
String c = new String(new char[]{'Ri', 'Hmm', 'Aller'});
System.out.println(a); //pomme
System.out.println(b); //pomme
System.out.println(c); //pomme

Je pense que la plupart des types String seront mémorisés avec les types primitifs lorsque vous commencerez à apprendre Java. Par conséquent, les personnes inexpérimentées en programmation ne comprennent souvent pas profondément la différence. Maintenant, utilisons un diagramme pour exprimer la différence entre le type primitif et le type de référence. Les variables de type Int affectent directement des valeurs de données de mémoire. Le type int [] crée un objet, le développe en mémoire et affecte le pointeur de cet objet à une variable comme valeur de référence. Le type String ressemble à ceci car la variable interne char [] a une valeur de référence pour l'objet char []. Après tout, comme il s'agit d'un ordinateur, la majeure partie est en mémoire, mais pour la lisibilité, les variables et les valeurs sont écrites séparément.

Qu'est-ce qui est nul

Null peut être affecté à une variable de type référence et il peut être exprimé qu'il n'y a pas de destination de référence pour cette variable. L'exception java.lang.NullPointerException (appelée nullpo) se produit lorsque vous essayez d'exécuter une méthode d'une variable qui n'a pas de référence.

Affecter à une variable

Une variable est une zone de mémoire allouée avec un nom, et le stockage d'une valeur dans cette zone est appelé affectation. L'affectation entre les variables signifie copier la valeur sur le côté droit et la stocker sur le côté gauche pour partager les données. Si vous ne comprenez pas les références, vous ne pourrez pas programmer correctement, alors ayons une idée solide. Maintenant, écrivons le code et voyons comment les valeurs sont transmises.

//[A] Type primitif
int intA = 1;
int intB = intA;
intB = 2;
System.out.println(intA); // 1
System.out.println(intB); // 2

//[B] Type de référence
char[] arrayA = {'A', 'B', 'C'};
char[] arrayB = arrayA;
arrayB[0] = 'D';
System.out.println(arrayA[0]); // D
System.out.println(arrayB[0]); // D

 //[C] Type de référence (immuable)
String stringA = "Chaîne";
String stringB = stringA;
stringB = "Chaîne";
System.out.println(stringA); //Chaîne
System.out.println(stringB); //Chaîne

Aucune explication n'est requise pour [A]. Il convient de noter [B] et [C]. [B] est assigné à arrayB et affecte arrayA, mais [C] n'affecte pas stringA. J'utiliserai également un diagramme pour expliquer ce qui se passe. Dans ③ de [B], la valeur des données est affectée au tableau de arrayB, mais puisque l'objet référencé est le même que arrayA (cela s'appelle la même valeur pour arrayA et arrayB), la sortie de arrayA et arrayB est la même. .. Dans [C], un nouvel objet String avec "Mojiretsu" est créé dans ③ et la valeur de référence est affectée à stringB, de sorte que la référence à l'objet "String" est coupée. Par conséquent, la sortie de stringA et stringB sera différente. En d'autres termes, si vous souhaitez modifier la valeur de l'objet String, vous devez affecter la valeur de données au tableau de caractères interne. Cependant, comme la variable char array à l'intérieur de la classe String est définie en private final, elle ne peut pas être réécrite. Une conception dans laquelle la valeur d'un objet ne peut pas être modifiée de cette manière est appelée immuable </ b>.

void main() {

  String string = "Chaîne";
  sub(string);
  System.out.println(string); //Chaîne

}
void sub(String string) {

  string = "Chaîne";

}