Java mainīgums nozīmē, ka pēc objekta izveides tā iekšējo stāvokli nevar mainīt. Nemainīgās Java klases nodrošina daudzas priekšrocības, piemēram, pavedienu drošību, vieglu atkļūdošanu un visu. Java visi iesaiņojuma nodarbības (piemēram, Integer Būla baita īss) un String klase ir nemainīga. Mēs varam izveidot arī savu nemainīgo klasi.

Šajā rakstā mēs uzzināsim:

• Ko nozīmē nemainīgums
• Kāpēc tas ir noderīgi
• Kā izveidot savu nemainīgo klasi
• Kāpēc dziļa kopēšana ir svarīga
• Kādi ir Java ierakstu tipu ierobežojumi?

Kas ir nemainīga klase?

Nemainīga klase ir klase, kuras objektus nevar mainīt pēc izveides. Ja mēs veicam izmaiņas, tas rada jaunu objektu. Šo metodi izmanto vienlaicīgās lietojumprogrammās.

Nemainīgas klases izveides noteikumi

• Klase ir jādeklarē kā galīgais lai nevarētu izveidot bērnu klases.
• Datu dalībnieki klasē ir jādeklarē privāts lai tieša piekļuve nebūtu atļauta.
• Datu dalībnieki klasē ir jādeklarē kā galīgais lai mēs nevarētu mainīt to vērtību pēc objekta izveides.
• Parametrētam konstruktoram ir jāinicializē visi lauki, kas veic a dziļa kopija lai datu dalībniekus nevarētu modificēt ar objekta atsauci.
• Objektu padziļinātā kopēšana ir jāveic getter metodēs, lai atgrieztu kopiju, nevis atgrieztu faktisko objekta atsauci.

Piezīme : nedrīkst būt iestatītāji vai vienkāršāk sakot, nevajadzētu būt iespējai mainīt instances mainīgā vērtību.

Piemērs: nemaināma klases ieviešana

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

Šajā piemērā mēs esam izveidojuši pēdējo klasi ar nosaukumu Students. Tam ir trīs gala datu elementi, parametrizēts konstruktors un ieguvēja metodes. Lūdzu, ņemiet vērā, ka šeit nav iestatītas metodes. Ņemiet vērā arī to, ka mums nav jāveic iesaiņojuma veidu datu dalībnieku dziļa kopēšana vai klonēšana, jo tie jau ir nemainīgi.

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

Pat pēc sākotnējās vai atgrieztās kartes modificēšanas studenta objekta iekšējais stāvoklis paliek nemainīgs. Tas apstiprina nemainīguma koncepciju.

Izvade:

 GFG   
 101   
 {1=first 2=second}   
 {1=first 2=second}   
 {1=first 2=second}  
  
 Java ieraksta ierobežojums ar mainīgiem laukiem  
 
 Ieviesta Java 14    ieraksts    . Šis ir skaidrs un kodolīgs veids, kā definēt nemainīgas līdzīgas klases:  
 
 
 ieraksts Student(virknes nosaukums int regNē Karte metadati) {}  
 
 
  
 
 
 Bet tas piedāvā tikai seklu nemainīgumu. Ja karte tiek pārveidota ārēji, mainās ieraksta iekšējais stāvoklis:  
 
 
 Karte karte = jauna HashMap <>();  
 
 map.put('1' 'pirmais');  
 
  
 
 
 Students s = new Student('ABC' 101 karte);  
 
  
 
 
 // Maina iekšējo stāvokli — NAV drošs  
 
 map.put('2' 'otrais');  
 
 s.metadata().put('3' 'trešā');  
 
 
      Piezīme         : izmantojiet ierakstu tikai tad, ja visi lauki ir nemainīgi, piemēram, String int vai citi ieraksti.