Apprendre Best Practices and Common Pitfalls | Enums in Control Flow and Collections

When working with enums in Java, following best practices helps you avoid common pitfalls and write maintainable, reliable code. Here is a concise list of dos and don'ts to guide your use of enums:

Do:

Use uppercase letters with underscores for enum constants;
Document each enum constant and the enum itself for clarity;
Keep enum fields immutable and final;
Use enums to represent a fixed set of related constants;
Leverage methods and fields only when they clarify intent.

Don't:

Add mutable fields or allow modification of enum state after construction;
Use enums for sets of values that may change at runtime or require extensibility;
Overload enums with unrelated responsibilities or behaviors;
Use enums where polymorphism or inheritance is required;
Rely on ordinal values for logic, as their order can change.

MutableEnumDemo.java


              12345678910111213141516171819202122232425262728293031
            
package com.example;

public class Main {
    public enum Status {
        ACTIVE, INACTIVE;

        // Mutable field (bad practice)
        private int counter = 0;

        public void increment() {
            counter++;
        }

        public int getCounter() {
            return counter;
        }
    }

    public static void main(String[] args) {
        Status.ACTIVE.increment();
        Status.ACTIVE.increment();
        System.out.println("ACTIVE counter: " + Status.ACTIVE.getCounter());

        Status.INACTIVE.increment();
        System.out.println("INACTIVE counter: " + Status.INACTIVE.getCounter());

        // The mutable state is shared across all usages of each constant,
        // leading to unpredictable behavior in concurrent or multi-user contexts.
    }
}

Enums should always be immutable, meaning their state cannot change after creation. Allowing mutability can introduce bugs, make code harder to reason about, and cause thread-safety issues. To design enums for future-proofing, declare all fields as final and avoid providing setters or methods that modify the state. If you need to associate data with an enum, pass it in through the constructor and expose it only via getters. This approach ensures that enums remain reliable, readable, and safe to use in collections or as keys in maps.

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738394041424344454647
            
package com.example;

/**
 * Represents the days of the week.
 * This enum is immutable and safe for use in collections.
 */
public class Main {
    public enum Day {
        /**
         * Monday - first day of the work week.
         */
        MONDAY("Workday"),
        /**
         * Saturday - weekend.
         */
        SATURDAY("Weekend"),
        /**
         * Sunday - weekend.
         */
        SUNDAY("Weekend");

        private final String type;

        /**
         * Constructs a Day enum constant with a type.
         * @param type the type of day ("Workday" or "Weekend")
         */
        Day(String type) {
            this.type = type;
        }

        /**
         * Gets the type of the day.
         * @return the type as a String
         */
        public String getType() {
            return type;
        }
    }

    public static void main(String[] args) {
        for (Day d : Day.values()) {
            System.out.println(d + ": " + d.getType());
        }
    }
}

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 3

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Glissez pour afficher le menu