Veranderlijk vs Onveranderlijk Java

Verschil Tussen Veranderlijk vs Onveranderlijk Java

Beweeglijke objecten velden die kunnen worden gewijzigd, de onveranderlijke objecten hebben geen velden die kunnen worden gewijzigd nadat het object is gemaakt. Onveranderlijke objecten zijn objecten waarvan de toestand niet kan veranderen nadat ze zijn gemaakt. Veranderlijk en onveranderlijk zijn twee categorieën van objecten in de java. In dit artikel zien we de verschillen tussen veranderlijke en onveranderlijke objecten in de java. Ook zullen we java-codevoorbeelden zien met verschillen tussen veranderlijke en onveranderlijke klasse in java.

Head to Head vergelijking tussen veranderlijk vs onveranderlijk Java (Infographics)

hieronder vindt u de top 6 verschillen tussen veranderlijk vs onveranderlijk Java:

Belangrijkste Verschillen tussen Veranderlijk vs Onveranderlijk Java

de Volgende zijn belangrijke verschillen tussen veranderlijke en onveranderlijke objecten in Java:

• Beweeglijke objecten zijn die objecten, die we kunnen wijzigingen aanbrengen aan de staat van een object zonder het aanmaken van een nieuw object. Dat is een veranderlijk object kan worden gewijzigd na de creatie ervan. In het geval van onveranderlijke objecten krijgen we een nieuw object wanneer de toestand van een object wordt gewijzigd. Terwijl we te maken hebben met onveranderlijke objecten is het ons niet toegestaan om de toestand van een object te veranderen na de creatie ervan.
• veranderbare objecten bieden in het algemeen methoden waarmee de inhoud van objecten kan worden gewijzigd, terwijl onveranderlijke objecten geen methode bieden om de inhoud ervan te wijzigen.
• in veranderlijke java klassen zijn getter en setter methoden aanwezig terwijl in onveranderlijke klassen alleen getter methoden beschikbaar zijn en niet setter methoden.
• veranderlijke klassen kunnen al dan niet thread-safe zijn, terwijl onveranderlijke klassen standaard thread-safe zijn.
• voorbeelden van veranderbare klassen in java zijn java.util.Date, StringBuffer, StringBuilder, etc overwegende dat java legacy classes, wrapper classes, String class zijn voorbeelden van onveranderlijke klassen in java.

veranderlijk Versus onveranderlijk Java vergelijkingstabel

laten we de belangrijkste vergelijking tussen veranderlijk Versus onveranderlijk Java bespreken:

veranderlijk	onveranderlijk
Java Mutable object kan worden gewijzigd na de creatie ervan.	Java onveranderlijk object kan niet gewijzigd worden na het aanmaken.
er wordt geen nieuw object gevormd wanneer wijzigingen worden aangebracht aan een bestaand object.	wanneer een bestaand object wordt gewijzigd, wordt een nieuw object gevormd.
het biedt methoden om de inhoud van een object te wijzigen.	het biedt geen methoden voor het wijzigen van de inhoud van een object.
Getter en setter methoden zijn aanwezig in veranderlijke klassen.	alleen getter methoden zijn aanwezig en niet setter methoden.
veranderlijke klassen kunnen wel of niet thread-safe zijn.	onveranderlijke klassen zijn standaard thread-safe.
enkele veel voorkomende voorbeelden van veranderlijke klassen in java zijn StringBuffer, StringBuilder en java.util.Datum.	alle oudere klassen, Wrapper classes, String class zijn veelvoorkomende voorbeelden van onveranderlijke klassen in java.

Mutable and Immutable Java with Examples

Mutable and Immutable Java with Examples worden hieronder gegeven:

Voorbeeld # 1-Mutable Class in Java

nu zullen we java code voorbeelden zien die de creatie van mutable and immutable classes in java laten zien.

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());
}
}

uitvoer:

de bovenstaande code toont de creatie van een veranderlijke klasse in java met getters en setters.

Voorbeeld # 2-onveranderlijke klasse in Java

nu zullen we zien hoe we onveranderlijke klassen in Java kunnen maken.

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());
}
}

uitvoer:

de bovenstaande code toont de creatie van java onveranderlijke klasse. De volgende punten moeten in gedachten worden gehouden bij het creëren van een onveranderlijke klasse:

• een onveranderlijke klasse moet definitief zijn omdat deze niet mag worden overgenomen.
• alle velden van een onveranderlijke klasse moeten definitief worden gemaakt.
• als een veranderlijk object wordt gebruikt als een veld in een onveranderlijke klasse, moet speciale behandeling worden geïmplementeerd om te voorkomen dat de inhoud ervan wordt gewijzigd.
• een openbare constructeur moet aanwezig zijn.
• Getter methoden voor alle variabelen moeten worden gedefinieerd.
• Settermethoden mogen voor geen enkele variabele aanwezig zijn.

conclusie

uit de bovenstaande discussie hebben we een duidelijk begrip van de verschillen tussen veranderlijk en onveranderlijk in java. Ook hebben we java-voorbeelden gezien die laten zien hoe veranderlijke en onveranderlijke klassen worden gemaakt. Het is belangrijk op te merken dat onveranderlijke klassen standaard thread-safe zijn, terwijl veranderlijke klassen wel of niet thread-safe kunnen zijn.

Aanbevolen artikelen

Dit is een gids voor veranderlijk Versus onveranderlijk Java. Hier bespreken we ook de veranderlijke vs onveranderlijke Java key verschillen met infographics en vergelijkingstabel. U kunt ook een kijkje op de volgende artikelen om meer te leren–

1. Java BufferedReader
2. StringBuffer Class in Java
3. Java RuntimeException
4. Java newInstance()