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:

public final class Person {
    // class implementation
}

Step 2: Declare Fields as Final

Make sure that all fields are final:

public final class Person {
    private final String name;
    private final int age;
    // constructor and methods
}

Step 3: Provide a Constructor

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

public final class Person {
    private final String name;
    private final int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // methods
}

Step 4: No Setter Methods

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

public final class Person {
    private final String name;
    private final int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // getters, but no setters
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    // no mutator methods
}

Step 5: Defensive Copy

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

public final class Person {
    private final String name;
    private final Date birthDate; // mutable object
    public Person(String name, Date birthDate) {
        this.name = name;
        this.birthDate = new Date(birthDate.getTime()); // defensive copy
    }
    public String getName() {
        return name;
    }
    public Date getBirthDate() {
        return new Date(birthDate.getTime()); // defensive copy
    }
}

Step 6: Return Clones or Immutable Objects

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

public final class Person {
    private final String name;
    private final List<String> hobbies; // mutable list
    public Person(String name, List<String> hobbies) {
        this.name = name;
        this.hobbies = new ArrayList<>(hobbies); // defensive copy
    }
    public String getName() {
        return name;
    }
    public List<String> getHobbies() {
        return new ArrayList<>(hobbies); // defensive copy
    }
}

Step 7: Override equals() and hashCode()

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

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
    return Objects.hash(name, age);
}

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:

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

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:

public final class LazyPerson {
    private final String name;
    private final Supplier<String> lazyComputedValue;
    public LazyPerson(String name, Supplier<String> lazyComputedValue) {
        this.name = name;
        this.lazyComputedValue = lazyComputedValue;
    }
    public String getName() {
        return name;
    }
    public String getLazyComputedValue() {
        return lazyComputedValue.get();
    }
}

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.

public final class ImmutableClass {
    private final int value;
    public ImmutableClass(int value) {
        this.value = value;
    }
    public final int getValue() {
        return value;
    }
}

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.

public final class ImmutablePerson {
    private final String name;
    private final List<String> hobbies; // mutable list
    public ImmutablePerson(String name, List<String> hobbies) {
        this.name = name;
        this.hobbies = Collections.unmodifiableList(new ArrayList<>(hobbies));
    }
    public String getName() {
        return name;
    }
    public List<String> getHobbies() {
        return hobbies; // returning unmodifiable view
    }
}

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.

import java.io.Serializable;
public final class SerializablePerson implements Serializable {
    private final String name;
    private final int age;
    public SerializablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

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:

import java.util.Objects;
public final class Person {
    private final String name;
    private final int age;
    public Person(String name, int age) {
        this.name = Objects.requireNonNull(name, "Name cannot be null");
        this.age = age;
    }
    // other methods
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Step 14: Consistency in Naming Conventions

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

public final class ImmutablePerson {
    private final String fullName; // Use clear and meaningful names
    private final int personAge;
    public ImmutablePerson(String fullName, int personAge) {
        this.fullName = fullName;
        this.personAge = personAge;
    }
    public String getFullName() {
        return fullName;
    }
    public int getPersonAge() {
        return personAge;
    }
}

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: Person.java

import java.util.Objects;
public final class Person {
    private final String name;
    private final int age;
    public Person(String name, int age) {
        this.name = Objects.requireNonNull(name, "Name cannot be null");
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

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

File Name: CustomImmutable.java

public class CustomImmutable {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);
        System.out.println("Person 1: " + person1);
        System.out.println("Person 2: " + person2);
        // Attempt to modify the state of the Person object
        // person1.setName("Carol"); // This line would result in a compilation error
        // Demonstrate equality
        System.out.println("Are person1 and person2 equal? " + person1.equals(person2));
        // Demonstrate hashCode
        System.out.println("HashCode of person1: " + person1.hashCode());
        System.out.println("HashCode of person2: " + person2.hashCode());
    }
}

Output:

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 Person.java and CustomImmutable.java code provided above and paste them into separate files in your text editor. Save the Person.java file as Person.java and the CustomImmutable.java file as CustomImmutable.java.

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 Person.java and CustomImmutable.java 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:

import com.google.common.collect.ImmutableList;
import java.time.LocalDateTime;
public final class Appointment {
    private final String title;
    private final LocalDateTime dateTime;
    private final ImmutableList<String> attendees;
    public Appointment(String title, LocalDateTime dateTime, ImmutableList<String> attendees) {
        this.title = title;
        this.dateTime = dateTime;
        this.attendees = attendees;
    }
    public String getTitle() {
        return title;
    }
    public LocalDateTime getDateTime() {
        return dateTime;
    }
    public ImmutableList<String> getAttendees() {
        return attendees;
    }
}

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:

import java.util.concurrent.atomic.AtomicInteger;
public final class Counter {
    private final AtomicInteger count = new AtomicInteger(0);
    public int getCount() {
        return count.get();
    }
    public void increment() {
        count.incrementAndGet();
    }
    public void decrement() {
        count.decrementAndGet();
    }
}

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:

public final class Product {
    private final String name;
    private final double price;
    private final int quantity;
    private Product(String name, double price, int quantity) {
        this.name = name;
        this.price = price;
        this.quantity = quantity;
    }
    public String getName() {
        return name;
    }
    public double getPrice() {
        return price;
    }
    public int getQuantity() {
        return quantity;
    }
    public static class Builder {
        private String name;
        private double price;
        private int quantity;
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        public Builder price(double price) {
            this.price = price;
            return this;
        }
        public Builder quantity(int quantity) {
            this.quantity = quantity;
            return this;
        }
        public Product build() {
            return new Product(name, price, quantity);
        }
    }
}

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:

import java.util.ArrayList;
import java.util.List;
public final class ShoppingCart {
    private final List<Product> items;
    public ShoppingCart(List<Product> items) {
        this.items = new ArrayList<>(items); // Defensive copying
    }
    public List<Product> getItems() {
        return new ArrayList<>(items); // Defensive copying
    }
}

Conclusion

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

← prev next →