U Javi nepromjenjivost znači da kada je objekt kreiran, njegovo unutarnje stanje se ne može promijeniti. Nepromjenjive klase u Javi pružaju mnoge prednosti kao što je sigurnost niti, lako otklanjanje pogrešaka i sve ostalo. U Javi sve klase omotača (poput Integer Boolean Byte Short) i klasa String je nepromjenjiva. Možemo kreirati i vlastitu nepromjenjivu klasu.

U ovom članku ćemo naučiti:

• Što znači nepromjenjivost
• Zašto je to korisno
• Kako stvoriti vlastitu nepromjenjivu klasu
• Zašto je duboko kopiranje važno
• Koja su ograničenja vrste Java zapisa

Što je nepromjenjiva klasa?

Nepromjenjiva klasa je klasa čiji se objekti ne mogu mijenjati nakon što su stvoreni. Ako napravimo bilo kakvu modifikaciju, to rezultira novim objektom. Ova se metoda koristi u istodobnim aplikacijama.

Pravila za stvaranje nepromjenjive klase

• Klasa mora biti deklarirana kao konačni tako da se ne mogu kreirati podređene klase.
• Članovi podataka u klasi moraju biti deklarirani privatni tako da izravan pristup nije dopušten.
• Članovi podataka u klasi moraju biti deklarirani kao konačni tako da im ne možemo promijeniti vrijednost nakon stvaranja objekta.
• Parametrizirani konstruktor treba inicijalizirati sva polja koja izvode a duboka kopija tako da se podatkovni članovi ne mogu mijenjati s referencom objekta.
• Duboko kopiranje objekata trebalo bi se izvesti u getter metodama radi vraćanja kopije umjesto vraćanja stvarne reference objekta.

Bilješka : Ne bi trebalo postojati postavljači ili jednostavnije rečeno ne bi trebalo postojati opcija za promjenu vrijednosti varijable instance.

Primjer: Implementacija nepromjenjive klase

Student.java

// Java Program to Create An Immutable Class import java.util.HashMap; import java.util.Map; // declare the class as final final class Student {  // make fields private and final  private final String name;  private final int regNo;  private final Map<String String> metadata;  // initialize all fields via constructor  public Student(String name int regNo Map<String String> metadata) {  this.name = name;  this.regNo = regNo;  // deep copy of mutable object (Map)  Map<String String> tempMap = new HashMap<>();  for (Map.Entry<String String> entry : metadata.entrySet()) {  tempMap.put(entry.getKey() entry.getValue());  }  this.metadata = tempMap;  }  // only provide getters (no setters)  public String getName() {  return name;  }  public int getRegNo() {  return regNo;  }  // return deep copy to avoid exposing internal state  public Map<String String> getMetadata() {  Map<String String> tempMap = new HashMap<>();  for (Map.Entry<String String> entry : this.metadata.entrySet()) {  tempMap.put(entry.getKey() entry.getValue());  }  return tempMap;  } } 

U ovom smo primjeru stvorili konačnu klasu pod nazivom Student. Ima tri konačna podatkovna člana, parametrizirani konstruktor i getter metode. Imajte na umu da ovdje ne postoji metoda postavljača. Također imajte na umu da ne moramo izvoditi dubinsko kopiranje ili kloniranje članova podataka tipova omotača jer su oni već nepromjenjivi.

Geeks.java:

import java.util.HashMap; import java.util.Map; public class Geeks {  public static void main(String[] args) {  // create a map and adding data  Map<String String> map = new HashMap<>();  map.put('1' 'first');  map.put('2' 'second');  // create an immutable Student object  Student s = new Student('GFG' 101 map);  // accessing data  System.out.println(s.getName());   System.out.println(s.getRegNo());   System.out.println(s.getMetadata());   // try to modify the original map  map.put('3' 'third');  System.out.println(s.getMetadata());   // try to modify the map returned by getMetadata()  s.getMetadata().put('4' 'fourth');  System.out.println(s.getMetadata());   } } 

Čak i nakon izmjene izvorne ili vraćene mape, unutarnje stanje studentskog objekta ostaje nepromijenjeno. Ovo potvrđuje koncept nepromjenjivosti.

Izlaz:

chmod 755

GFG  
101  
{1=first 2=second}  
{1=first 2=second}  
{1=first 2=second}

Ograničenje Java zapisa s promjenjivim poljima

Predstavljena Java 14 snimiti . Ovo je jasan i koncizan način za definiranje nepromjenjivih klasa:

zapis Student(String name int regNo Mapmetapodaci) {}

Ali ovo samo nudi plitku nepromjenjivost. Ako se Karta modificira izvana, unutarnje stanje zapisa se mijenja:

Kartakarta = novi HashMap<>();

map.put('1' 'prvi');

Student s = new Student('ABC' 101 karta);

// Mijenja unutarnje stanje — NIJE sigurno

map.put('2' 'drugi');

s.metadata().put('3' 'treći');

Bilješka : Koristite zapis samo ako su sva polja nepromjenjive vrste poput String int ili drugih zapisa.