Using getters is a significant issue. Exposing internals is a major problem TL;DR: Don't expose your internals and lose control Problems Mutability
Unexpected Changes
Ripple Effects
Thread unsafety
Encapsulation Principle violation Solutions Return shallow copies of your collections Context Immutable objects are essential in functional and object-oriented programming. Once created, their state cannot be altered. This is key to keeping object integrity and ensuring thread safety in multithreaded applications. Mutable getters allow callers to access and modify the internal state of an object, leading to potential corruption and unexpected behavior. When you break encapsulation, you take responsibility away from an object. Integrity is lost. Returning a page in a book is like an immutable copy. It cannot be edited, like a human memory. You can edit some memories by bringing them from long-term memory. Sample Code Wrong public class Person {
    private List<String> hobbies;

    public Person(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public List<String> getHobbies() {
        return hobbies;
    }
} Right public class Person {
    private List<String> hobbies;

    public Person(List<String> hobbies) {
        this.hobbies = new ArrayList<>(hobbies);
    }

    public List<String> hobbies() {
        // This returns a shallow copy
        // This is usually not a big performance issue
        return new ArrayList<>(hobbies);
    }
} Detection [x]Semi-Automatic You can detect mutable getters by examining the return types of your getters. If they return mutable collections or objects, you need to refactor them to return immutable copies or use immutable data structures. Tags Mutability Level [x]Intermediate AI Generation AI generators might create this smell if they prioritize simplicity and brevity over best practices. They not always consider the implications of returning mutable objects. AI Detection AI tools can detect this smell if you instruct them to look for getters returning mutable objects or collections. They can suggest returning copies or using immutable types to fix the issue. Conclusion Getters are a code smell, but something you need to return objects you hold. You can do it at your own risk, but retain the tracking of those collections. Avoid mutable getters to protect your object integrity and encapsulation. By returning immutable copies or using immutable types, you can prevent unintended modifications and ensure your objects remain reliable and predictable. Relations Code Smell 68 - Getters Code Smell 109 - Automatic Properties More Info
The Evil Power of Mutants
Nude Models - Part II: Getters Disclaimer: Code Smells are my opinion. Credits: Photo by Suzanne D. Williams on Unsplash The best programmers write only easy programs. Michael A. Jackson Software Engineering Great Quotes This article is part of the CodeSmell Series.
How to Find the Stinky Parts of your Code Using getters is a significant issue. Exposing internals is a major problem Using getters is a significant issue. Exposing internals is a major problem TL;DR: Don't expose your internals and lose control TL;DR: Don't expose your internals and lose control Problems Mutability Unexpected Changes Ripple Effects Thread unsafety Encapsulation Principle violation Mutability Unexpected Changes Ripple Effects Thread unsafety Encapsulation Principle violation Solutions Return shallow copies of your collections Return shallow copies of your collections Context Immutable objects are essential in functional and object-oriented programming. Immutable objects Once created, their state cannot be altered. This is key to keeping object integrity and ensuring thread safety in multithreaded applications. Mutable getters allow callers to access and modify the internal state of an object, leading to potential corruption and unexpected behavior. When you break encapsulation, you take responsibility away from an object. Integrity is lost. When you break encapsulation, you take responsibility away from an object. Integrity is lost. Returning a page in a book is like an immutable copy. It cannot be edited, like a human memory. You can edit some memories by bringing them from long-term memory. Sample Code Wrong public class Person {
    private List<String> hobbies;

    public Person(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public List<String> getHobbies() {
        return hobbies;
    }
} public class Person {
    private List<String> hobbies;

    public Person(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public List<String> getHobbies() {
        return hobbies;
    }
} Right public class Person {
    private List<String> hobbies;

    public Person(List<String> hobbies) {
        this.hobbies = new ArrayList<>(hobbies);
    }

    public List<String> hobbies() {
        // This returns a shallow copy
        // This is usually not a big performance issue
        return new ArrayList<>(hobbies);
    }
} public class Person {
    private List<String> hobbies;

    public Person(List<String> hobbies) {
        this.hobbies = new ArrayList<>(hobbies);
    }

    public List<String> hobbies() {
        // This returns a shallow copy
        // This is usually not a big performance issue
        return new ArrayList<>(hobbies);
    }
} Detection [x]Semi-Automatic [x] Semi-Automatic [x] You can detect mutable getters by examining the return types of your getters. If they return mutable collections or objects, you need to refactor them to return immutable copies or use immutable data structures. Tags Mutability Mutability Level [x]Intermediate [x] Intermediate [x] AI Generation AI generators might create this smell if they prioritize simplicity and brevity over best practices. They not always consider the implications of returning mutable objects. AI Detection AI tools can detect this smell if you instruct them to look for getters returning mutable objects or collections. They can suggest returning copies or using immutable types to fix the issue. Conclusion Getters are a code smell , but something you need to return objects you hold. code smell You can do it at your own risk, but retain the tracking of those collections. Avoid mutable getters to protect your object integrity and encapsulation. By returning immutable copies or using immutable types, you can prevent unintended modifications and ensure your objects remain reliable and predictable. Relations Code Smell 68 - Getters Code Smell 68 - Getters Code Smell 109 - Automatic Properties Code Smell 109 - Automatic Properties More Info The Evil Power of Mutants Nude Models - Part II: Getters More Info The Evil Power of Mutants The Evil Power of Mutants Nude Models - Part II: Getters Nude Models - Part II: Getters Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credits: Photo by Suzanne D. Williams on Unsplash Credits: Photo by Suzanne D. Williams on Unsplash Suzanne D. Williams Unsplash The best programmers write only easy programs. The best programmers write only easy programs. Michael A. Jackson Michael A. Jackson Software Engineering Great Quotes Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

This story contains new, firsthand information uncovered by the writer.

Finding the Stinky Parts of Your Code: Code Smell 256 - Mutable Getters

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

From Helpful to Harmful: How AI Recommendations Destroyed My OS

Custom Logic in Webflow: How to Push No-Code to Its Limits

Clean Code in Go (Part 4): Package Architecture, Dependency Flow, and Scalability

The "Comment" Fallacy: Why Self-Documenting Code is Still the Goal

Flip the Script: Write the Tests, Let AI Write the Implementation

Clean Code: Interfaces in Go - Why Small Is Beautiful [Part 3]

From Helpful to Harmful: How AI Recommendations Destroyed My OS

Custom Logic in Webflow: How to Push No-Code to Its Limits

Clean Code in Go (Part 4): Package Architecture, Dependency Flow, and Scalability

The "Comment" Fallacy: Why Self-Documenting Code is Still the Goal

Flip the Script: Write the Tests, Let AI Write the Implementation

Clean Code: Interfaces in Go - Why Small Is Beautiful [Part 3]

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps