Quelles sont les différences entre les types référence et les types primitifs en Java

Le tableau suivant répertorie les types primitifs et leurs classes de wrapper d'objet. # 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 # Type primitif # 🎜🎜 ## 🎜🎜 # Classe encapsulée # 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 # booléen # 🎜🎜#

Boolean# 🎜 🎜# octet Octetshort Short# 🎜 🎜#intlong 　

int i = 5; // 原始类型  Integer j = new Integer（10）; // 对象引用

Tous les objets en Java sont accessibles via des références d'objet. Une référence d'objet est un pointeur vers une zone du tas où l'objet est stocké. Lorsque vous déclarez un type primitif, vous déclarez le stockage du type lui-même.

int j = 5;  j.hashCode（）; // 错误  //。..  Integer i = new Integer（5）;  i.hashCode（）; // 正确

L'utilisation de types primitifs ne nécessite pas d'appeler new ou de créer un objet. Cela permet d'économiser du temps et de l'espace. Le mélange de types primitifs et d'objets peut également conduire à des résultats inattendus liés à l'affectation. Un code qui semble exempt de bogues peut ne pas faire le travail que vous souhaitez. Par exemple :

import java.awt.Point;  class Assign  {  public static void main（String args［］）  {  int a = 1;  int b = 2;  Point x = new Point（0，0）;  Point y = new Point（1，1）; //1  System.out.println（“a is ” + a）;  System.out.println（“b is ” + b）;  System.out.println（“x is ” + x）;  System.out.println（“y is ” + y）;  System.out.println（“Performing assignment and ” +  “setLocation.。.”）;  a = b;  a++;  x = y; //2  x.setLocation（5，5）; //3  System.out.println（“a is ”+a）;  System.out.println（“b is ”+b）;  System.out.println（“x is ”+x）;  System.out.println（“y is ”+y）;  }  }

a is 1  b is 2  x is java.awt.Point［x=0，y=0］  y is java.awt.Point［x=1，y=1］  Performing assignment and setLocation.。.  a is 3  b is 2  x is java.awt.Point［x=5，y=5］  y is java.awt.Point［x=5，y=5］

Cette confusion est causée par l'utilisation de types et d'objets primitifs. L'affectation ne fonctionne pas différemment pour les deux types. Mais tout cela peut paraître différent. L'affectation rend la valeur du côté gauche du signe égal (=) égale à la valeur du côté droit. Ceci est évident pour les types primitifs tels que int a et b plus tôt. Pour les types non primitifs (tels que les objets Point), l'affectation modifie la référence de l'objet, pas l'objet lui-même. Par conséquent, après la déclaration

x = y;

Lorsque setLocation est appelé at //3, Cette méthode est exécutée sur l'objet référencé par x. Comme l'objet Point référencé par x est également l'objet référencé par y, nous obtenons maintenant les résultats suivants : les méthodes agissent toutes sur le même objet.

char	Character
Integer
	Long#🎜 🎜# # 🎜🎜 ## 🎜🎜 ## 🎜🎜 # float # 🎜🎜 ## 🎜🎜 # float # 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 # double # 🎜🎜 ## 🎜🎜 # double # 🎜 🎜 🎜#
Les types référence et les types primitifs se comportent complètement différemment et ont une sémantique différente. Par exemple, supposons qu'il y ait deux variables locales dans une méthode, une variable est de type primitif int et l'autre variable est une référence d'objet à un objet Integer :	Les deux variables sont stockées dans le fichier local. table de variables , et les deux fonctionnent sur la pile d'opérandes Java, mais leurs représentations sont complètement différentes. (Le terme générique pile sera utilisé dans la suite de cet article à la place de pile d'opérandes ou de table de variables locales.) Le type primitif int et la référence d'objet occupent chacun 32 bits de la pile. (Pour représenter un int ou une référence d'objet, une implémentation de machine virtuelle Java nécessite l'utilisation d'au moins 32 bits de stockage.) L'entrée de pile pour un objet Integer n'est pas l'objet lui-même, mais une référence d'objet.
Les types de référence et les types primitifs ont des caractéristiques et des utilisations différentes, ils incluent : des problèmes de taille et de vitesse, le type de structure de données dans lequel ce type est stocké, quand les types de référence et les types primitifs sont utilisés comme certains. La valeur par défaut valeur spécifiée pour les données d'instance de la classe. La valeur par défaut des variables d'instance de référence d'objet est nulle, tandis que la valeur par défaut des variables d'instance de type primitif dépend de leur type. Le code de nombreux programmes contient à la fois des types primitifs et leurs wrappers d'objet. Travailler avec les deux types et comprendre comment ils interagissent et coexistent correctement sera problématique pour vérifier s'ils sont égaux. Les programmeurs doivent comprendre comment ces deux types fonctionnent et interagissent pour éviter les erreurs dans leur code.	Par exemple, les méthodes ne peuvent pas être appelées sur des types primitifs, mais les méthodes peuvent être appelées sur des objets :
Ce code génère le résultat suivant :	Il n'y a rien de surprenant dans le résultat de la modification des entiers a et b. La valeur de b est attribuée à la variable entière a, ce qui entraîne une augmentation de la valeur de a de 1. Ce résultat reflète ce que nous voulons qu’il se produise. Ce qui est surprenant, cependant, c'est la sortie des objets x et y après l'attribution et l'appel de setLocation. Nous avons spécifiquement appelé setLocation sur x après avoir terminé l'affectation de x = y. Comment les valeurs de x et y peuvent-elles être les mêmes ? Après tout, nous avons attribué y à x, puis modifié x, ce qui n’est pas différent de ce que nous avons fait avec les entiers a et b.
, x est égal à y. En d’autres termes, comme x et y sont des références d’objet, ils font désormais référence au même objet. Par conséquent, toute modification de x modifie également y. Voici la situation après l'exécution du code en //1 :	La situation après l'exécution de l'affectation en //2 est la suivante :

Il est important de distinguer les types référence des types primitifs et de comprendre la sémantique des références. Si vous ne le faites pas, le code en cours d’écriture ne pourra pas faire le travail prévu.

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!