Java mutable ou immuable

Les objets mutables ont des champs qui peuvent être modifiés ; les objets immuables n'ont aucun champ pouvant être modifié après la création de l'objet. Les objets immuables sont des objets dont l'état ne peut pas changer après leur création. Mutable et Immutable sont deux catégories d'objets en Java. Dans cet article, nous verrons les différences entre les objets mutables et immuables en Java. Nous verrons également des exemples de code Java montrant les différences entre les classes mutables et immuables en Java.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Comparaison face à face entre Java mutable et immuable (infographie)

Vous trouverez ci-dessous les 6 principales différences entre Java mutable et immuable :

Différences clés entre Java mutable et immuable

Voici les principales différences entre les objets mutables et immuables en Java :

• Les objets mutables sont des objets dans lesquels nous pouvons modifier l'état d'un objet sans créer de nouvel objet. Autrement dit, un objet mutable peut être modifié après sa création. Dans le cas d’objets immuables, chaque fois que l’état d’un objet change, nous obtenons un nouvel objet. Lorsqu'il s'agit d'objets immuables, nous ne sommes pas autorisés à changer l'état d'un objet après sa création.
• Les objets mutables, dans les cas généraux, fournissent des méthodes par lesquelles le contenu des objets peut être modifié, tandis que les objets immuables ne fournissent aucune méthode pour modifier leur contenu.
• Dans les classes Java mutables, les méthodes getter et setter sont présentes, alors que, dans les classes immuables, seules les méthodes getter sont disponibles et non les méthodes setter.
• Les classes mutables peuvent ou non être thread-safe, alors que les classes immuables sont par défaut thread-safe.
• Des exemples de classes mutables en Java sont java.util.Date, StringBuffer, StringBuilder, etc., tandis que les classes héritées Java, les classes wrapper, la classe String sont des exemples de classes immuables en Java.

Tableau de comparaison Java mutable et immuable

Parlons de la meilleure comparaison entre Java mutable et immuable :

 Mutable

Mutable	Immutable
Java Mutable object can be modified after its creation.	Java Immutable object cannot be modified after its creation.
No new object is formed when changes are made to an existing object.	Whenever an existing object is changed, a new object is formed.
It provides methods to change the content of an object.	It does not provide methods for changing the content of an object.
Getter and setter methods are present in mutable classes.	Only getter methods are present and not setter methods.
Mutable classes may or may not be thread-safe.	Immutable classes are thread-safe by default.
Some common examples of mutable classes in java are StringBuffer, StringBuilder, and java.util.Date.	All Legacy classes, Wrapper classes, String class, are common examples of Immutable classes in java.

Immuable

L'objet Java Mutable peut être modifié après sa création.

L'objet Java Immuable ne peut pas être modifié après sa création.

Aucun nouvel objet n'est formé lorsque des modifications sont apportées à un objet existant.

Chaque fois qu'un objet existant est modifié, un nouvel objet est formé.

Il fournit des méthodes pour modifier le contenu d'un objet.

Il ne fournit pas de méthodes pour modifier le contenu d'un objet.

Les méthodes Getter et Setter sont présentes dans les classes mutables.

Seules les méthodes getter sont présentes et non les méthodes setter.

Les classes mutables peuvent ou non être thread-safe.

Les classes immuables sont thread-safe par défaut.

Quelques exemples courants de classes mutables en Java sont StringBuffer, StringBuilder et java.util.Date.

Toutes les classes Legacy, les classes Wrapper et la classe String sont des exemples courants de classes immuables en Java.

Java mutable et immuable avec exemples

Java mutable et immuable avec des exemples sont donnés ci-dessous :

Exemple n°1 – Classe mutable en Java

Nous allons maintenant voir des exemples de code Java montrant la création de classes mutables et immuables en Java.

Code :

package com.edubca.mutabledemo;
public class MutableDemo {
private String studentName;
private int rollNumber;
MutableDemo (String studentName, int rollNumber) {
this.studentName = studentName;
this.rollNumber = rollNumber;
}
public String getStudentName() {
return studentName;
}
// this setter can modify the name
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public int getRollNumber() {
return rollNumber;
}
// this setter can modify roll number
public void setRollNumber(int rollNumber) {
this.rollNumber = rollNumber;
}
public static void main(String[] args) {
MutableDemo obj = new MutableDemo ("John" , 100);
System.out.println("Original Name is " + obj.getStudentName());
System.out.println("Original Roll Number is " + obj.getRollNumber());
// update the name, and roll number as  is mutable
obj.setStudentName("James");
obj.setRollNumber(102);
System.out.println("Modified Name is " + obj.getStudentName());
System.out.println("Modified Roll Number is " + obj.getRollNumber());
}
}

Sortie :

Le code ci-dessus montre la création d'une classe mutable en Java avec des getters et des setters.

Exemple n°2 – Classe immuable en Java

Nous allons maintenant voir comment créer des classes immuables en Java.

Code :

package com.edubca.immutabledemo;
public final class ImmutableDemo {
final String studentName;
final int rollNumber;
public ImmutableDemo  (String studentName, int rollNumber) {
this.studentName = studentName;
this.rollNumber = rollNumber;
}
public String getStudentName() {
return studentName;
}
public int getRollNumber() {
return rollNumber;
}
public static void main(String[] args) {
ImmutableDemo obj = new ImmutableDemo  ("John" , 100);
// Since no getters are available contents cannot be modified.
// Also as variables are declared final they cannot be modified
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
}
}

Sortie :

Le code ci-dessus montre la création de la classe immuable Java. Les points suivants doivent être gardés à l'esprit lors de la création d'une classe immuable :

• Une classe immuable doit être définitive car elle ne doit pas être héritée.
• Tous les champs d'une classe immuable doivent être rendus définitifs.
• Si un objet mutable est utilisé comme champ dans une classe immuable, alors un traitement spécial doit être implémenté afin d'empêcher que son contenu ne soit modifié.
• Un constructeur public doit être présent.
• Les méthodes Getter pour toutes les variables doivent être définies.
• Les méthodes Setter ne doivent être présentes pour aucune variable.

Conclusion

D'après la discussion ci-dessus, nous comprenons clairement les différences entre mutable et immuable en Java. Nous avons également vu des exemples Java montrant comment les classes mutables et immuables sont créées. Il est important de noter que les classes immuables sont par défaut thread-safe, alors que les classes mutables peuvent ou non être thread-safe.

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!