How to create immutable class in java

• In Java String and all wrapper classes are immutable classes.
• So how to create custom immutable class in java?
• Lets see how to make a class object immutable.

  Immutable class:

• Make class final so that it should not be inherited.
• All the variables should be private so should not be accessible outside of class. 
• Make all variables final so that value can not be changed.
• A constructor to assign values to variables in class.
• Do not add any setter methods.

1. Java Program to create custom immutable class object in java.

1. package com.instaceofjava;
2. 
   
3.  
4. public final class ImmutableClass{
5.   
6. private final int a;
7. private final int b;
8.  
9. ImmutableClass( int x, int y){
10.  
11.  a=x;
12.  b=y; 
13. 
    
14. } 
15.  
16. public getA(){
17.  
18.  return a;
19. 
    
20. }
21.  
22. public getB(){
23.  
24.  return b;
25. 
    
26. }
27.  
28. public static void main(String[] args) {
29.  
30. ImmutableClass obj= new ImmutableClass(10,20);
31.  
32. System.out.println("a="+obj.getA());
33.  
34. System.out.println("b="+obj.getB());
35.  
36. }
37. }

Output:

1. a=10
2. b=20

String class in java: Immutable

1. public final class String
2.         implements java.io.Serializable, Comparable<String>, CharSequence
3. {  
4.   
5. //String class variables
6. 
   
7.   private final char value[];
8.   private final int offset;
9.   private final int count;
10.   private int hash; // Default to 0
11.   private static final ObjectStreamField[] serialPersistentFields =
12.       new ObjectStreamField[0];
13.   
14. //String class constructor
15. public String(String original) {
16.  
17.             int size = original.count;
18.              char[] originalValue = original.value;
19.              char[] v;
20.              if (originalValue.length > size) {
21.                 // The array representing the String is bigger than the new
22.               // String itself.  Perhaps this constructor is being called
23.                 // in order to trim the baggage, so make a copy of the array.
24.                  int off = original.offset;
25.                 v = Arrays.copyOfRange(originalValue, off, off+size);
26.             } else {
27.                  // The array representing the String is the same
28.                  // size as the String, so no point in making a copy.
29.                  v = originalValue;
30.            }
31.             this.offset = 0;
32.              this.count = size;
33.             this.value = v;
34.         } 
35. 
    
36. }