Javatpoint Logo
Javatpoint Logo

Creating Immutable Custom Classes in Java

Immutability in Java is the concept of creating objects whose state cannot be changed after they are created. Immutability is particularly useful in concurrent programming, as it eliminates the need for synchronization and provides some thread protection. One way to achieve consistent improvement is to create custom courses that follow a set of guidelines to ensure that their patterns remain consistent over their lifecycle.

Characteristics of Immutable Objects

Immutable objects in Java exhibit the following characteristics:

State cannot be modified: Once an immutable object is created, its state cannot be changed. All fields are final, and there are no setter methods.

No mutator methods: Immutable objects do not have methods that modify their state. Any operation that appears to modify the object returns a new instance with the updated values.

Fields are final: All fields in an immutable class are declared as final to ensure they cannot be reassigned after object creation.

No subclassing for modification: To prevent potential modification through subclassing, the class is often marked as final or its constructors are made private with static factory methods.

Creating an Immutable Custom Class

Let's go through the steps to create an immutable custom class in Java using a hypothetical Person class as an example.

Step 1: Declare Class as Final

To prevent subclassing, mark the class as final:

Step 2: Declare Fields as Final

Make sure that all fields are final:

Step 3: Provide a Constructor

Initialize all fields in the constructor, and avoid exposing mutable objects directly:

Step 4: No Setter Methods

Avoid providing setter methods or any methods that modify the state:

Step 5: Defensive Copy

If the class contains mutable objects, ensure that they are not directly accessible and provide defensive copies if needed:

Step 6: Return Clones or Immutable Objects

When returning mutable objects from methods, return clones or immutable instances to maintain immutability:

Step 7: Override equals() and hashCode()

Override equals() and hashCode() methods to ensure correct behavior when instances are used in collections:

Step 8: Immutability with Enums

Enums in Java are implicitly final and have fixed instances, making them a natural fit for immutability. If we have a set of constant values, consider using enums:

Step 9: Lazy Initialization

If an object's creation is expensive and its value may not always be needed, we can employ lazy initialization. Compute and cache the value only when it is requested:

Step 10: Effective Use of final Keyword

Apart from marking fields as final, consider using the final keyword for methods and classes when applicable. Marking methods as final prevents them from being overridden by subclasses, adding an extra layer of protection to your design.

Step 11: Immutability and Collections

When dealing with collections, ensure that the elements within the collection are also immutable, or provide defensive copies to maintain the immutability of the class. Java provides utility classes like Collections.unmodifiableList() and Collections.unmodifiableMap() to create unmodifiable views of collections.

Step 12: Serialization

For an immutable class to be serialized correctly, ensure that all fields are serializable. Implement the Serializable interface and make sure the fields are marked as transient if they refer to non-serializable objects.

Step 13: Effective Use of Objects Class

Java's Objects class provides utility methods for dealing with null values and handling equals and hash code operations. Use these methods to simplify your code and make it more concise:

Step 14: Consistency in Naming Conventions

Follow consistent naming conventions for immutable classes, methods, and fields. It contributes to code readability and maintainability.

Let's create a complete example of an immutable Person class along with a simple program to demonstrate its usage. Here's the code:

File Name:

Now let's create a simple Main class to demonstrate how to use the Person class:

File Name:


Person 1: Person{name='Alice', age=30}
Person 2: Person{name='Bob', age=25}
Are person1 and person2 equal? false
HashCode of person1: -1061542078
HashCode of person2: -595926066

As we can see, we successfully created instances of the Person class, demonstrated that their state cannot be modified after creation, and showed how to implement equality and hashCode() methods. The output also confirms that the instances are immutable, as attempting to modify their state results in a compilation error.

To save and run the Java programs, follow these steps:

Saving the Programs

Open a text editor: We can use any text editor of your choice, such as Notepad (on Windows), TextEdit (on macOS), or any code editor like Visual Studio Code, IntelliJ IDEA, or Eclipse.

Copy the code: Copy the and code provided above and paste them into separate files in your text editor. Save the file as and the file as

Choose a directory: Save both files in a directory (folder) of your choice on your computer. It's a good practice to create a dedicated folder for your Java projects.

Running the Programs

Open a terminal or command prompt: Navigate to the directory where we saved your Java files. We can do this using the cd command in the terminal or command prompt.

Compile the Java files: Use the javac command to compile the and files. It will generate corresponding .class files.

Run the program: After successful compilation, run the program by executing the CustomImmutable class using the java command.

View the output: The program will execute, and we will see the output printed in the terminal or command prompt.

Let's delve into some advanced concepts and best practices for immutable classes in Java.

1. Effective Use of LocalDateTime and ImmutableList

When dealing with date and time in Java, consider using LocalDateTime from the java.time package, which is immutable and thread-safe. Similarly, when working with collections, utilize ImmutableList from the Guava library to ensure immutability:

2. Thread Safety with java.util.concurrent

For concurrent applications, ensure thread safety by using classes from the java.util.concurrent package. For instance, AtomicInteger and AtomicReference provide atomic operations for integer values and object references, respectively:

3. Immutable Objects with Builders

Utilize the Builder pattern to construct complex immutable objects with many attributes. This pattern allows for flexible object creation while ensuring immutability:

4. Immutability and Performance

Immutability can sometimes improve performance by reducing the need for synchronization and enabling better optimization by the JVM. However, be cautious when dealing with large objects or frequent state changes, as creating new instances may lead to increased memory usage and garbage collection overhead.

5. Defensive Copying and External Mutability

When returning mutable objects from immutable classes, ensure that defensive copies are made to prevent external mutation. This applies to collections, arrays, and other mutable objects:


Creating immutable custom classes in Java requires careful policy selection to ensure that class instances cannot be changed after creation. Following the above-mentioned guidelines results in robust and simple rules in strings, which is important in concurrent programming. Embracing immutability allows developers to write code that is easy to understand, maintain, and evaluate.

Next TopicmapToInt() in Java

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA