How to make class immutable Java?

Making Classes Immutable in Java: A Comprehensive Guide

Introduction

In Java, classes are objects that encapsulate data and behavior. However, one of the most fundamental aspects of object-oriented programming is the concept of immutability. Immutable classes are those that cannot be changed once they are created. In this article, we will explore how to make classes immutable in Java.

Why Immutable Classes are Important

Immutable classes are essential in many areas of Java programming, including:

• Data Storage: Immutable classes are perfect for storing data in databases or files, as they cannot be modified once created.
• Configuration Files: Immutable classes are ideal for configuration files, where data is not intended to be changed.
• Caching: Immutable classes can be used to cache data, as changes to the data would invalidate the cache.

Creating Immutable Classes

To create an immutable class in Java, you can use the following steps:

• Use the final keyword: The final keyword is used to indicate that a class cannot be subclassed. This ensures that the class cannot be modified once created.
• Use the private keyword: The private keyword is used to restrict access to the class’s data. This ensures that the data cannot be accessed or modified from outside the class.
• Use the volatile keyword: The volatile keyword is used to ensure that changes to the class’s data are visible to all threads.

Example: Immutable Integer Class

Here is an example of an immutable integer class in Java:

public final class ImmutableInteger {

    private final int value;



    /**

     * Constructs an immutable integer with the given value.

     *

     * @param value the value of the integer

     */

    public ImmutableInteger(int value) {

        this.value = value;

    }



    /**

     * Returns the value of the integer.

     *

     * @return the value of the integer

     */

    public int getValue() {

        return value;

    }



    /**

     * Returns a copy of the integer.

     *

     * @return a copy of the integer

     */

    public ImmutableInteger copy() {

        return new ImmutableInteger(value);

    }



    /**

     * Returns a new immutable integer with the given value.

     *

     * @param value the value of the new integer

     * @return a new immutable integer

     */

    public static ImmutableInteger of(int value) {

        return new ImmutableInteger(value);

    }

}

Example: Immutable String Class

Here is an example of an immutable string class in Java:

public final class ImmutableString {

    private final String value;



    /**

     * Constructs an immutable string with the given value.

     *

     * @param value the value of the string

     */

    public ImmutableString(String value) {

        this.value = value;

    }



    /**

     * Returns the value of the string.

     *

     * @return the value of the string

     */

    public String getValue() {

        return value;

    }



    /**

     * Returns a copy of the string.

     *

     * @return a copy of the string

     */

    public ImmutableString copy() {

        return new ImmutableString(value);

    }



    /**

     * Returns a new immutable string with the given value.

     *

     * @param value the value of the new string

     * @return a new immutable string

     */

    public static ImmutableString of(String value) {

        return new ImmutableString(value);

    }

}

Example: Immutable List Class

Here is an example of an immutable list class in Java:

import java.util.ArrayList;

import java.util.List;



public final class ImmutableList<T> {

    private final List<T> value;



    /**

     * Constructs an immutable list with the given value.

     *

     * @param value the value of the list

     */

    public ImmutableList(T value) {

        this.value = new ArrayList<>(List.of(value));

    }



    /**

     * Returns the value of the list.

     *

     * @return the value of the list

     */

    public T getValue() {

        return value.get(0);

    }



    /**

     * Returns a copy of the list.

     *

     * @return a copy of the list

     */

    public ImmutableList<T> copy() {

        return new ImmutableList<>(value);

    }



    /**

     * Returns a new immutable list with the given value.

     *

     * @param value the value of the new list

     * @return a new immutable list

     */

    public static <T> ImmutableList<T> of(T value) {

        return new ImmutableList<>(List.of(value));

    }

}

Example: Immutable Map Class

Here is an example of an immutable map class in Java:

import java.util.HashMap;

import java.util.Map;



public final class ImmutableMap<K, V> {

    private final Map<K, V> value;



    /**

     * Constructs an immutable map with the given key-value pairs.

     *

     * @param key the key of the map

     * @param value the value of the map

     */

    public ImmutableMap(K key, V value) {

        this.value = new HashMap<>(Map.of(key, value));

    }



    /**

     * Returns the value of the map.

     *

     * @return the value of the map

     */

    public V getValue() {

        return value.get(key);

    }



    /**

     * Returns a copy of the map.

     *

     * @return a copy of the map

     */

    public ImmutableMap<K, V> copy() {

        return new ImmutableMap<>(value);

    }



    /**

     * Returns a new immutable map with the given key-value pairs.

     *

     * @param key the key of the new map

     * @param value the value of the new map

     * @return a new immutable map

     */

    public static <K, V> ImmutableMap<K, V> of(K key, V value) {

        return new ImmutableMap<>(Map.of(key, value));

    }

}

Conclusion

In conclusion, making classes immutable in Java is a simple and effective way to ensure data integrity and prevent unintended modifications. By using the final keyword, private keyword, and volatile keyword, you can create immutable classes that are resistant to changes. Additionally, using immutable classes can improve code readability and maintainability, as changes to the data are clearly visible to all threads. By following these guidelines, you can create robust and reliable immutable classes in Java.