Java is een objectgeoriënteerde programmeertaal. Omdat het een objectgeoriënteerde programmeertaal is, draaien alle methoden en mechanismen rond de objecten. Eén objectgebaseerd concept is veranderlijk en onveranderlijk op Java . Objecten in Java zijn veranderlijk of onveranderlijk; het hangt af van hoe het object kan worden herhaald.
In deze sectie bespreken we veranderlijke en onveranderlijke objecten in Java. Verder zullen we het verschil tussen hen zien.
Wat zijn veranderlijke objecten
De veranderlijke objecten zijn objecten waarvan de waarde na initialisatie kan worden gewijzigd. We kunnen de waarden van het object, zoals veld en statussen, wijzigen nadat het object is gemaakt. Bijvoorbeeld, java.util.Datum , StringBuilder , StringBuffer , enz.
Wanneer we een wijziging hebben aangebracht in bestaande veranderlijke objecten, wordt er geen nieuw object gemaakt; in plaats daarvan zal het de waarde van het bestaande object veranderen. De klassen van dit object bieden methoden om er wijzigingen in aan te brengen.
De Getters en Setters ( get() en set() methoden ) zijn beschikbaar in veranderlijke objecten. Het Mutable-object kan wel of niet thread-safe zijn.
string naar booleaanse java
Wat zijn onveranderlijke objecten
De onveranderlijke objecten zijn objecten waarvan de waarde na initialisatie niet kan worden gewijzigd. We kunnen niets meer veranderen zodra het object is gemaakt. Bijvoorbeeld, primitieve voorwerpen zoals int, lang , vlot , dubbele , alle oudere klassen, Wrapper-klasse , String-klasse , enz.
In een notendop betekent onveranderlijk ongewijzigd of onveranderlijk. Zodra de onveranderlijke objecten zijn gemaakt, kunnen de objectwaarden en status ervan niet meer worden gewijzigd.
Alleen Getters (methode get()) zijn beschikbaar, geen Setters (methode set()) voor onveranderlijke objecten.
Laten we eens kijken hoe we klassen kunnen maken voor veranderlijke en onveranderlijke objecten.
Hoe u een veranderlijke klasse kunt maken
De volgende twee dingen zijn essentieel voor het maken van een veranderlijke klasse:
- Methoden voor het wijzigen van de veldwaarden
- Getters en Setters van de objecten
Beschouw het onderstaande voorbeeld van de veranderlijke klasse:
java-arraylijst
public class JtpExample { private String s; JtpExample(String s) { this.s = s; } public String getName() { return s; } public void setName(String coursename) { this.s = coursename; } public static void main(String[] args) { JtpExample obj = new JtpExample('JavaTpoint'); System.out.println(obj.getName()); // Here, we can update the name using the setName method. obj.setName('Java Training'); System.out.println(obj.getName()); } } Uitgang:
JavaTpoint Java Training
In het bovenstaande voorbeeld wijzigen we de naamwaarde met behulp van de setName-methode.
Hoe een onveranderlijke klasse te creëren
De volgende dingen zijn essentieel voor het creëren van een onveranderlijke klasse:
- Laatste klasse, die als definitief wordt verklaard, zodat deze niet kan worden verlengd.
- Alle velden moeten privé zijn, zodat directe toegang tot de velden wordt geblokkeerd.
- Geen Setters
- Alle veranderlijke velden moeten definitief zijn, zodat ze niet kunnen worden herhaald nadat ze zijn geïnitialiseerd.
Beschouw het onderstaande voorbeeld:
public class JtpExample1 { private final String s; JtpExample1(final String s) { this.s = s; } public final String getName() { return s; } public static void main(String[] args) { JtpExample obj = new JtpExample('Core Java Training'); System.out.println(obj.getName()); } } Uitgang:
Core Java Training
Daarom hebben we de veranderlijke en onveranderlijke objecten en klassen besproken. Laten we de verschillen tussen hen bespreken:
Verschil tussen veranderlijke en onveranderlijke objecten
Hieronder volgen enkele belangrijke verschillen tussen veranderlijke en onveranderlijke objecten in Java :
Java Lambda-expressies
- De veranderlijke objecten kunnen in elke waarde of status worden gewijzigd zonder een nieuw object toe te voegen. Terwijl de onveranderlijke objecten niet kunnen worden gewijzigd in hun waarde of staat zodra ze zijn gemaakt. In het geval van onveranderlijke objecten zal er telkens wanneer we de status van het object veranderen, een nieuw object worden gecreëerd.
- Veranderlijke objecten bieden een methode om de inhoud van het object te wijzigen. Ter vergelijking: de onveranderlijke objecten bieden geen enkele methode om de waarden te wijzigen.
- De veranderlijke objecten ondersteunen zowel de setters als de getters. Ter vergelijking: de onveranderlijke objecten ondersteunen alleen setters, geen getters.
- De veranderlijke objecten zijn al dan niet thread-safe, maar de onveranderlijke objecten zijn standaard thread-safe.
- De voorbeelden van veranderlijke klassen zijn StringBuffer, Java.util.Date, StringBuilder, enz. Terwijl de onveranderlijke objecten oudere klassen, wrapper-klassen, String-klasse, enz. zijn.
Beschouw de onderstaande tabel:
| Veranderlijk | Onveranderlijk |
|---|---|
| We kunnen de waarde van veranderlijke objecten na initialisatie wijzigen. | Zodra een onveranderlijk object is geïnitieerd; We kunnen de waarden ervan niet veranderen. |
| De staat kan worden gewijzigd. | De staat kan niet worden veranderd. |
| In veranderlijke objecten worden geen nieuwe objecten gevormd. | Bij onveranderlijke objecten wordt een nieuw object gevormd wanneer de waarde van het object wordt gewijzigd. |
| Het biedt methoden om het object te wijzigen. | Het biedt geen enkele methode om de objectwaarde te wijzigen. |
| Het ondersteunt de methoden get() en set() om met het object te communiceren. | Het ondersteunt alleen de get()-methode om de waarde van het object door te geven. |
| Veranderlijke klassen kunnen wel of niet thread-safe zijn. | Onveranderlijke klassen zijn thread-safe. |
| De essentie voor het maken van een veranderlijke klasse zijn methoden voor het wijzigen van velden, getters en setters. | De essentie voor het creëren van een onveranderlijke klasse zijn de laatste klasse, privévelden en de laatste veranderlijke objecten. |
Waarom zijn strings in Java onveranderlijk?
String in Java is een heel speciale klasse, omdat deze bijna in elk Java-programma wordt gebruikt. Daarom is het onveranderlijk om de prestaties en veiligheid te verbeteren. Laten we het in detail begrijpen:
In Java gebruiken tekenreeksen het concept van letterlijke waarden. Stel dat we een object hebben met veel referentievariabelen. Als we in een dergelijk scenario de waarde van een referentievariabele wijzigen, heeft dit invloed op het hele object en al zijn waarden.
log4j
Naast de bovengenoemde redenen zijn ook de volgende redenen verantwoordelijk voor het onveranderbaar maken van de String:
Onveranderlijke objecten zijn heel eenvoudig; er is geen noodzaak voor synchronisatie en zijn inherent thread-safe. Maar onveranderlijke objecten zijn goede bouwstenen voor andere objecten, dus we moeten er speciale zorg aan besteden.
De meeste ontwikkelaars maken de String tot het uiteindelijke object, zodat deze later niet kan worden gewijzigd.
Conclusie
We hebben veranderlijke en onveranderlijke objecten in Java besproken, nu hebben we een duidelijk begrip van zowel veranderlijke als onveranderlijke objecten en klassen. Verder hebben we gezien hoe we een veranderlijke en onveranderlijke klasse kunnen creëren.
Opgemerkt wordt dat onveranderlijke objecten kunnen worden gewijzigd in hun waarde en staat zodra ze zijn geïnitieerd, en al dan niet thread-safe kunnen zijn. Ter vergelijking: de onveranderlijke objecten kunnen niet worden gewijzigd in hun staat en waarde en standaard thread-safe.