Immutable Class In Java

Hello again, students! In our previous lesson, we learned about the String class in Java. We noticed the concept of immutable string of Java, which might seem unusual at first. In this article, we will delve into the reasons behind this design choice, and discuss its implications. An immutable class in Java is a class whose instances cannot be modified after they are created. Once an immutable object is created, its state remains constant for the lifetime of the object. Immutable classes provide several benefits, including thread safety, easier debugging, and enhanced security.

Let’s consider a simple code snippet

String message = "Hello, ";
message += "world!";

It seems like message changed from “Hello, ” to “Hello, world!”. But in reality, Java created a new String object with the value “Hello, world!” and made message refer to this new object. The original “Hello, ” string still exists in memory until it’s eventually garbage collected.

Here’s a detailed explanation of immutable classes in Java

Characteristics of Immutable Class in Java

1. Final Class: Immutable classes are often declared as final to prevent inheritance and subclassing, which could potentially violate immutability by allowing modification through subclassing.
2. Private Fields: Immutable classes typically have private fields that cannot be directly accessed or modified from outside the class.
3. No Setter Methods: Immutable classes usually lack setter methods or methods that modify the state of the object. Instead, they provide methods for accessing the state (getters) or performing operations that return a new instance with modified state.
4. No Mutable Objects: Immutable classes avoid using mutable objects or mutable fields in their state. If an immutable class contains references to other objects, those objects should also be immutable or effectively immutable.

Advantages of Immutable Class in Java

1. Thread Safety: Immutable objects are inherently thread-safe because their state cannot be modified once created. They can be safely shared among multiple threads without the need for synchronization.
2. Simplified Debugging: Immutable classes make debugging easier since the state of an object remains constant throughout its lifetime, eliminating potential side effects caused by state changes.
3. Security: Immutable objects are resistant to tampering and unintentional modification, making them suitable for scenarios involving sensitive data or cryptography.
4. Caching and Reusability: Immutable objects can be cached and reused efficiently since their state does not change. This can lead to performance optimizations and reduced memory usage.

Examples of Immutable Class in Java

1. String

Strings in Java are immutable. Once created, their values cannot be changed.

Example

public class ImmutableStringExample {
    public static void main(String[] args) {
        String str = "Hello";
        String modifiedStr = str.concat(" World"); // Creates a new string
        System.out.println("Original String: " + str); // Output: Hello
        System.out.println("Modified String: " + modifiedStr); // Output: Hello World
    }
}

2. Wrapper Classes

Wrapper classes such as Integer, Double, and Boolean are immutable. Operations on these objects return new objects with the modified state.

Example

public class ImmutableWrapperExample {
    public static void main(String[] args) {
        Integer num1 = 10;
        Integer num2 = num1 + 5; // Creates a new Integer object
        System.out.println("Original Number: " + num1); // Output: 10
        System.out.println("Modified Number: " + num2); // Output: 15
    }
}

3. LocalDate, LocalTime, LocalDateTime

Classes from the java.time package introduced in Java 8 are immutable and represent dates, times, and date-time combinations.

Example

import java.time.LocalDate;

public class ImmutableLocalDateExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        LocalDate nextWeek = date.plusWeeks(1); // Creates a new LocalDate object
        System.out.println("Original Date: " + date); // Output: current date
        System.out.println("Modified Date: " + nextWeek); // Output: current date + 1 week
    }
}

4. BigInteger, BigDecimal

These classes from the java.math package are immutable and represent arbitrarily large integers and decimal numbers with arbitrary precision.

immutable class in javaExample

import java.math.BigInteger;

public class ImmutableBigIntegerExample {
    public static void main(String[] args) {
        BigInteger num1 = BigInteger.valueOf(100);
        BigInteger num2 = num1.add(BigInteger.TEN); // Creates a new BigInteger object
        System.out.println("Original Number: " + num1); // Output: 100
        System.out.println("Modified Number: " + num2); // Output: 110
    }
}

Conclusion

Understanding and leveraging immutable classes in Java can lead to more robust, reliable, and efficient software solutions. By following best practices for immutable class design, developers can create codebases that are easier to reason about, maintain, and scale, contributing to the overall quality and longevity of their Java applications.

Frequently Asked Questions