Understanding Mutability in OOP

Mutability is closely related to object-oriented programming. When an object is created, if it cannot be modified afterward, we call it an immutable object. Have you encountered something like this before? If you’re a C# programmer, you’ve likely come across the difference between String and StringBuilder.

In C#, the String class is immutable, meaning once you create a String object, it cannot be modified (though you can assign a new String to the same variable). In contrast, StringBuilder is mutable. You can modify a StringBuilder object without creating a new instance.

If the idea isn’t entirely clear yet, let's explore it with a practical C# example.

Example 1: Immutable String

When you work with a String, any modification creates a new object, leaving the original one unchanged.

using System;

class Program
{
    static void Main()
    {
        // String is immutable
        string greeting = "Hello";
        Console.WriteLine("Original String: " + greeting);

        // Modifying the string creates a new object
        greeting += ", World!";
        Console.WriteLine("Modified String: " + greeting);
    }
}        

Explanation:

• Initially, the greeting variable is set to "Hello".
• When you append ", World!" to it, a new string is created, and greeting is assigned the new value. The original "Hello" string remains unchanged in memory.

Example 2: Mutable StringBuilder

In contrast, StringBuilder allows you to modify the contents of an object without creating new instances.

using System;
using System.Text;

class Program
{
    static void Main()
    {
        // StringBuilder is mutable
        StringBuilder greeting = new StringBuilder("Hello");
        Console.WriteLine("Original StringBuilder: " + greeting);

        // Modify the StringBuilder in place
        greeting.Append(", World!");
        Console.WriteLine("Modified StringBuilder: " + greeting);
    }
}        

Explanation:

• StringBuilder starts with "Hello".
• When you append ", World!", it modifies the same object in memory, making it more efficient for situations where you need to perform multiple modifications to the same string.

Why Does Mutability Matter?

-Memory Efficiency

• String: Every modification creates a new object, leading to potential memory overhead if you're making frequent changes.
• StringBuilder: Modifies the string in place, which is more efficient when dealing with multiple modifications.

-Performance:

• String: Not ideal for scenarios involving frequent string manipulation (e.g., building long strings in a loop).
• StringBuilder: Best for scenarios where you need to append, insert, or modify a string frequently.

Regardless of the language you're using, it’s essential to understand which data structures or objects are mutable and which are immutable. Not knowing this can lead to bugs that are hard to track down.

Conclusion

Knowing when and how to use mutable and immutable objects is crucial in programming. Different languages have their own data structures or libraries that define which objects are mutable or immutable. Make sure to familiarize yourself with these characteristics in the language you're using.

Understanding the differences and knowing when to use which will help you write safer, more efficient, and bug-free code.

The effectiveness of mutable and immutable objects in different scenarios has been beautifully discussed in this answer on StackOverflow.