How To Compare Two Enums In Java: Equals vs ==?

Comparing enums in Java can be achieved using both the equals() method and the == operator, but understanding their nuances is crucial for writing robust and efficient code, so compare.edu.vn helps you to compare them. Choosing the right approach ensures type safety, avoids potential NullPointerException errors, and leverages compile-time checks for enhanced code reliability. For further insights, explore enum comparison techniques and Java enum best practices.

1. Can The == Operator Be Used On Enums In Java?

Yes, the == operator can be used to compare enum instances in Java. Enums have tight instance control, which allows safe use of the == operator. The Java Language Specification (JLS) guarantees that an enum type has no instances other than those defined by its enum constants. Attempting to explicitly instantiate an enum type results in a compile-time error. The final clone method in Enum ensures that enum constants can never be cloned, and special treatment by the serialization mechanism prevents duplicate instances from being created as a result of deserialization. Reflective instantiation of enum types is also prohibited. These measures ensure that no instances of an enum type exist beyond those defined by the enum constants.

Because there is only one instance of each enum constant, it is permissible to use the == operator in place of the equals method when comparing two object references, provided that at least one of them refers to an enum constant. The equals method in Enum is a final method that merely invokes super.equals on its argument and returns the result, thus performing an identity comparison. Josh Bloch recommends using a single-element enum to implement the singleton pattern because of this guarantee.

2. What Are The Differences Between == And Equals() In Java?

Generally, == is not a viable alternative to equals() in Java. However, when it is applicable (such as with enums), there are key differences to consider:

• NullPointerException: The == operator never throws a NullPointerException.
• Type Compatibility: The == operator is subject to type compatibility checks at compile time.

enum Color { BLACK, WHITE }
enum Chiral { LEFT, RIGHT }

Color nothing = null;

if (nothing == Color.BLACK) { // Runs fine
    // Code to execute
}

if (nothing.equals(Color.BLACK)) { // Throws NullPointerException
    // Code to execute
}

if (Color.BLACK.equals(Chiral.LEFT)) { // Compiles fine
    // Code to execute
}

if (Color.BLACK == Chiral.LEFT) { // Doesn't compile: Incompatible types
    // Code to execute
}

The first if statement runs without issues because == checks if nothing is the same instance as Color.BLACK. The second if statement throws a NullPointerException because you are trying to call the equals() method on a null reference. The third if statement compiles because equals() can compare objects of different types. The fourth if statement does not compile because == requires type compatibility, and Color and Chiral are different enum types.

2.1. Detailed Comparison of == and equals()

Feature	== Operator	equals() Method
Purpose	Checks if two references point to the same object.	Checks if two objects are logically equal.
NullPointerException	Does not throw NullPointerException.	May throw NullPointerException if the object is null.
Type Compatibility	Requires type compatibility at compile time.	No strict type compatibility requirement.
Performance	Generally faster.	Generally slower.
Use with Enums	Safe to use due to instance control.	Safe to use, but == is preferred.
Immutability	Suitable for immutable objects with instance control.	Suitable for comparing the state of objects.
Compile-time Safety	Provides compile-time type checking.	No compile-time type checking.

2.2. Advantages of Using == with Enums

• It works: Enums in Java are designed to ensure that each enum constant is a singleton instance.
• It’s faster: The == operator performs a direct reference comparison, which is faster than the equals() method.
• It’s safer at runtime: The == operator avoids the risk of a NullPointerException when comparing with a null reference.
• It’s safer at compile time: The == operator provides compile-time type checking, ensuring that you are comparing enums of the same type.

2.3. Considerations When Choosing Between == and equals()

• Consistency: If you use == for enums, maintain consistency throughout your codebase.
• Null checks: When using equals(), ensure you perform null checks to avoid NullPointerException errors.
• Type safety: Use == to leverage compile-time type checking for enums.
• Performance: If performance is critical, prefer == for enum comparisons.

3. Should The == Operator Be Used When Applicable In Java?

Yes, Josh Bloch specifically mentions that immutable classes that have proper control over their instances can guarantee to their clients that == is usable. Enum types are specifically mentioned to exemplify this.

3.1. Josh Bloch’s Recommendation

In “Effective Java,” Bloch highlights that immutable classes with proper instance control can guarantee that a.equals(b) if and only if a == b. If a class makes this guarantee, its clients can use the == operator instead of the equals(Object) method, potentially improving performance. Enum types provide this guarantee.

3.2. Benefits of Using == for Enum Comparison

• Performance Improvement: Using == instead of equals() can lead to improved performance due to its simplicity.
• Type Safety: Compile-time checks ensure that you are only comparing enums of the same type, reducing runtime errors.
• Null Safety: == avoids NullPointerException when comparing with a null reference.

3.3. Practical Example

Consider the following enum:

enum Status {
    OPEN,
    CLOSED,
    IN_PROGRESS
}

Using == for comparison:

Status currentStatus = Status.OPEN;
if (currentStatus == Status.OPEN) {
    System.out.println("Status is OPEN");
}

Using equals() for comparison:

Status currentStatus = Status.OPEN;
if (currentStatus.equals(Status.OPEN)) {
    System.out.println("Status is OPEN");
}

In this case, == is more efficient and safer because it avoids the overhead of method invocation and the potential for NullPointerException.

4. How To Compare Two Enums In Java Using Equals() Method

The equals() method in Java is used to compare the equality of two objects. When comparing enums, the equals() method checks if two enum instances are the same. Here’s how to use it effectively:

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

public class EnumComparison {
    public static void main(String[] args) {
        Day day1 = Day.MONDAY;
        Day day2 = Day.MONDAY;
        Day day3 = Day.FRIDAY;

        // Using equals() method to compare enums
        boolean areDaysEqual1 = day1.equals(day2); // true
        boolean areDaysEqual2 = day1.equals(day3); // false

        System.out.println("Are day1 and day2 equal? " + areDaysEqual1);
        System.out.println("Are day1 and day3 equal? " + areDaysEqual2);

        // Handling null with equals()
        Day day4 = null;
        boolean areDaysEqual3 = Day.MONDAY.equals(day4); // false, no NullPointerException
        System.out.println("Is Day.MONDAY equal to day4? " + areDaysEqual3);
    }
}

4.1. Advantages of Using equals()

• Readability: The equals() method is widely understood and makes the code more readable.
• Consistency: Using equals() aligns with general object comparison practices in Java.

4.2. Disadvantages of Using equals()

• Performance: Slightly slower than == due to method invocation overhead.
• Null Handling: Requires care to avoid NullPointerException if one of the enums is null.

4.3. Best Practices for Using equals() with Enums

• Null Checks: Ensure that you are not calling equals() on a null enum instance.
• Consistency: Maintain a consistent approach throughout your codebase for enum comparisons.
• Consider ==: In most cases, == is a better choice for enums due to its safety and performance benefits.

5. How To Compare Two Enums In Java Using == Operator

The == operator in Java checks if two references point to the same object in memory. For enums, this is a direct and efficient way to compare values because each enum constant is a singleton instance.

enum Status {
    OPEN,
    CLOSED,
    IN_PROGRESS
}

public class EnumComparison {
    public static void main(String[] args) {
        Status status1 = Status.OPEN;
        Status status2 = Status.OPEN;
        Status status3 = Status.CLOSED;

        // Using == operator to compare enums
        boolean areStatusesEqual1 = status1 == status2; // true
        boolean areStatusesEqual2 = status1 == status3; // false

        System.out.println("Are status1 and status2 equal? " + areStatusesEqual1);
        System.out.println("Are status1 and status3 equal? " + areStatusesEqual2);

        // No need to worry about NullPointerException with ==
        Status status4 = null;
        boolean areStatusesEqual3 = Status.OPEN == status4; // false, no NullPointerException
        System.out.println("Is Status.OPEN equal to status4? " + areStatusesEqual3);
    }
}

5.1. Advantages of Using ==

• Performance: Faster than equals() because it directly compares references.
• Safety: No risk of NullPointerException.
• Compile-Time Check: Ensures type compatibility at compile time.

5.2. Disadvantages of Using ==

• Limited Applicability: Only suitable for enums and cases where you need to check if two references point to the same object.
• Potential Confusion: May confuse developers who are not familiar with enum behavior in Java.

5.3. Best Practices for Using == with Enums

• Consistency: Always use == for enum comparisons to maintain consistency and clarity.
• Understandability: Ensure that your team understands why == is preferred for enums.
• Avoid Mixing: Do not mix == and equals() for enum comparisons to prevent confusion.

6. Performance Comparison: Equals() Vs == For Enums In Java

When comparing enums in Java, performance is a key consideration. The == operator generally outperforms the equals() method due to its simplicity and directness.

6.1. Microbenchmark Results

Microbenchmarks consistently show that == is faster than equals() for enum comparisons. The difference in execution time is often small but can be significant in performance-critical applications.

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class EnumComparisonBenchmark {

    enum Status {
        OPEN,
        CLOSED,
        IN_PROGRESS
    }

    private Status status1;
    private Status status2;

    @Setup(Level.Trial)
    public void setup() {
        status1 = Status.OPEN;
        status2 = Status.OPEN;
    }

    @Benchmark
    public void compareWithEquals(Blackhole blackhole) {
        blackhole.consume(status1.equals(status2));
    }

    @Benchmark
    public void compareWithEqualsOperator(Blackhole blackhole) {
        blackhole.consume(status1 == status2);
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(EnumComparisonBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(5)
                .measurementIterations(5)
                .build();

        new Runner(opt).run();
    }
}

6.2. Explanation of Performance Differences

• Direct Reference Comparison: The == operator performs a direct reference comparison, which is a simple and fast operation.
• Method Invocation Overhead: The equals() method involves method invocation, which adds overhead compared to the direct comparison of ==.
• JVM Optimization: The JVM can optimize == operations more effectively than method calls, especially for enums.

6.3. When Does Performance Matter?

• High-Frequency Operations: In applications where enum comparisons are performed frequently (e.g., within loops or critical sections of code), the performance difference between == and equals() can become significant.
• Resource-Constrained Environments: In environments with limited resources (e.g., embedded systems or mobile devices), the efficiency of == can be advantageous.

6.4. Practical Implications

While the performance difference may be negligible in many applications, using == for enum comparisons is generally recommended due to its efficiency, safety, and compile-time checks.

7. Type Safety: How == Provides Compile-Time Checks For Enums In Java

Type safety is a critical aspect of software development, ensuring that operations are performed on compatible data types. The == operator provides compile-time checks for enums in Java, enhancing type safety and reducing the risk of runtime errors.

7.1. Compile-Time Type Checking

The == operator in Java enforces type compatibility at compile time. When comparing two enums using ==, the compiler checks if the enums are of the same type. If they are not, a compile-time error is generated, preventing the code from being compiled.

enum Color {
    RED,
    GREEN,
    BLUE
}

enum Size {
    SMALL,
    MEDIUM,
    LARGE
}

public class EnumComparison {
    public static void main(String[] args) {
        Color color = Color.RED;
        Size size = Size.SMALL;

        // Compile-time error: Incompatible types
        // if (color == size) {
        //     System.out.println("Color and Size are equal");
        // }

        // Correct comparison
        if (color == Color.RED) {
            System.out.println("Color is RED");
        }
    }
}

In this example, the commented-out if statement results in a compile-time error because color is of type Color and size is of type Size, which are incompatible for comparison using ==.

7.2. Benefits of Compile-Time Checks

• Early Error Detection: Compile-time checks catch type-related errors early in the development process, preventing them from reaching runtime.
• Improved Code Reliability: By ensuring type compatibility, compile-time checks enhance the reliability and robustness of the code.
• Reduced Debugging Effort: Identifying type errors at compile time reduces the effort required to debug the code.

7.3. Contrast with equals()

The equals() method does not provide compile-time type checking. It allows comparison of objects of different types, which can lead to unexpected behavior or runtime errors if not handled carefully.

enum Color {
    RED,
    GREEN,
    BLUE
}

enum Size {
    SMALL,
    MEDIUM,
    LARGE
}

public class EnumComparison {
    public static void main(String[] args) {
        Color color = Color.RED;
        Size size = Size.SMALL;

        // No compile-time error, but potentially incorrect behavior
        if (color.equals(size)) {
            System.out.println("Color and Size are equal");
        } else {
            System.out.println("Color and Size are not equal"); // This will be executed
        }
    }
}

In this example, the equals() method does not generate a compile-time error, but the comparison is likely to be incorrect because color and size are of different types.

7.4. Best Practices for Type Safety with Enums

• Always Use ==: Prefer the == operator for enum comparisons to leverage compile-time type checking.
• Avoid Mixing Types: Ensure that you are only comparing enums of the same type to prevent unexpected behavior.
• Educate Developers: Make sure that your team understands the importance of type safety and the benefits of using == for enum comparisons.

8. Null Safety: How == Avoids NullPointerException For Enums In Java

Null safety is a critical concern in Java programming, as NullPointerException errors can cause unexpected program termination. The == operator provides null safety when comparing enums, avoiding the risk of NullPointerException errors.

8.1. No NullPointerException with ==

The == operator in Java does not throw a NullPointerException when one of the operands is null. Instead, it evaluates to false, providing a safe way to compare enums without the risk of a null-related exception.

enum Status {
    OPEN,
    CLOSED,
    IN_PROGRESS
}

public class EnumComparison {
    public static void main(String[] args) {
        Status status1 = Status.OPEN;
        Status status2 = null;

        // No NullPointerException with ==
        boolean isEqual = status1 == status2; // false
        System.out.println("Is status1 equal to status2? " + isEqual);

        // No NullPointerException even if both are null
        Status status3 = null;
        boolean areBothNull = status2 == status3; // true
        System.out.println("Are status2 and status3 both null? " + areBothNull);
    }
}

In this example, the == operator safely compares status1 with status2, even though status2 is null. The result is false, and no NullPointerException is thrown.

8.2. Contrast with equals()

The equals() method throws a NullPointerException if it is called on a null reference. This requires explicit null checks to avoid the exception.

enum Status {
    OPEN,
    CLOSED,
    IN_PROGRESS
}

public class EnumComparison {
    public static void main(String[] args) {
        Status status1 = Status.OPEN;
        Status status2 = null;

        // NullPointerException if status2 is null
        try {
            boolean isEqual = status1.equals(status2); // Throws NullPointerException
            System.out.println("Is status1 equal to status2? " + isEqual);
        } catch (NullPointerException e) {
            System.out.println("NullPointerException caught!");
        }

        // Safe comparison with null check
        boolean isEqualSafe = status2 != null && status1.equals(status2); // false
        System.out.println("Is status1 equal to status2 (safe)? " + isEqualSafe);
    }
}

In this example, calling equals() on status2 results in a NullPointerException. To avoid this, you must perform an explicit null check before calling equals().

8.3. Benefits of Null Safety

• Reduced Risk of Exceptions: The == operator eliminates the risk of NullPointerException errors, making the code more robust.
• Simplified Code: No need for explicit null checks when comparing enums with ==, simplifying the code and improving readability.
• Improved Reliability: By avoiding null-related exceptions, the == operator enhances the reliability of the code.

8.4. Best Practices for Null Safety with Enums

• Always Use ==: Prefer the == operator for enum comparisons to ensure null safety.
• Avoid equals(): Unless there is a specific reason to use equals(), avoid it to prevent potential NullPointerException errors.
• Educate Developers: Make sure that your team understands the importance of null safety and the benefits of using == for enum comparisons.

9. Immutability: How Enum’s Immutability Affects Comparison In Java

Immutability is a key characteristic of enums in Java, meaning that once an enum constant is created, its state cannot be changed. This immutability has significant implications for how enums are compared, particularly when using the == operator.

9.1. Enums Are Immutable

In Java, enums are inherently immutable. Each enum constant is a singleton instance, and its state remains constant throughout the program’s execution. This immutability is guaranteed by the Java Language Specification (JLS).

9.2. Impact on Comparison

The immutability of enums simplifies comparison because you only need to check if two references point to the same instance. This is precisely what the == operator does, making it a natural and efficient choice for enum comparisons.

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

public class EnumComparison {
    public static void main(String[] args) {
        Day day1 = Day.MONDAY;
        Day day2 = Day.MONDAY;
        Day day3 = Day.FRIDAY;

        // Using == operator to compare enums
        boolean areDaysEqual1 = day1 == day2; // true
        boolean areDaysEqual2 = day1 == day3; // false

        System.out.println("Are day1 and day2 equal? " + areDaysEqual1);
        System.out.println("Are day1 and day3 equal? " + areDaysEqual2);
    }
}

In this example, the == operator accurately compares the enum constants because each constant is a unique instance.

9.3. Why Immutability Matters

• Simplified Comparison: Immutability allows for direct reference comparison using ==, which is faster and safer than comparing the state of mutable objects.
• Thread Safety: Immutable objects are inherently thread-safe, eliminating the need for synchronization when comparing enums in a multi-threaded environment.
• Predictable Behavior: Immutability ensures that the state of an enum constant does not change, leading to predictable and reliable behavior.

9.4. Contrast with Mutable Objects

When comparing mutable objects, you must compare their state (i.e., their fields) to determine equality. This requires using the equals() method and ensuring that the equals() method is implemented correctly.

class MutableObject {
    private int value;

    public MutableObject(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        MutableObject that = (MutableObject) obj;
        return value == that.value;
    }

    @Override
    public int hashCode() {
        return value;
    }
}

public class MutableObjectComparison {
    public static void main(String[] args) {
        MutableObject obj1 = new MutableObject(10);
        MutableObject obj2 = new MutableObject(10);

        // == compares references, not state
        boolean areEqualReferences = obj1 == obj2; // false
        System.out.println("Are obj1 and obj2 the same reference? " + areEqualReferences);

        // equals() compares state
        boolean areEqualState = obj1.equals(obj2); // true
        System.out.println("Are obj1 and obj2 equal in state? " + areEqualState);
    }
}

In this example, == compares the references, while equals() compares the state of the MutableObject instances.

9.5. Best Practices for Immutability and Enum Comparison

• Always Use ==: For enum comparisons, always use the == operator to leverage the immutability of enums.
• Understand the Implications: Ensure that you understand the implications of immutability when comparing enums and other immutable objects.
• Avoid Unnecessary equals(): Avoid using the equals() method for enum comparisons unless there is a specific reason to do so.

10. Alternatives to Equals() and == For Enum Comparison In Java

While equals() and == are the primary methods for comparing enums in Java, there are alternative approaches that can be used in specific scenarios. These alternatives may offer additional flexibility or functionality depending on the requirements.

10.1. EnumMap and EnumSet

EnumMap and EnumSet are specialized collection classes in Java that are designed to work with enums. They can be used to compare enums indirectly by checking if they are present in a particular EnumMap or EnumSet.

import java.util.EnumMap;
import java.util.EnumSet;

enum Status {
    OPEN,
    CLOSED,
    IN_PROGRESS
}

public class EnumComparison {
    public static void main(String[] args) {
        Status status1 = Status.OPEN;
        Status status2 = Status.CLOSED;

        // Using EnumSet to check if an enum is in a set
        EnumSet<Status> openStatuses = EnumSet.of(Status.OPEN, Status.IN_PROGRESS);
        boolean isOpen1 = openStatuses.contains(status1); // true
        boolean isOpen2 = openStatuses.contains(status2); // false

        System.out.println("Is status1 open? " + isOpen1);
        System.out.println("Is status2 open? " + isOpen2);

        // Using EnumMap to associate enums with values
        EnumMap<Status, String> statusDescriptions = new EnumMap<>(Status.class);
        statusDescriptions.put(Status.OPEN, "The issue is open and waiting for resolution.");
        statusDescriptions.put(Status.CLOSED, "The issue has been resolved.");
        statusDescriptions.put(Status.IN_PROGRESS, "The issue is currently being worked on.");

        String description1 = statusDescriptions.get(status1);
        String description2 = statusDescriptions.get(status2);

        System.out.println("Description for status1: " + description1);
        System.out.println("Description for status2: " + description2);
    }
}

In this example, EnumSet is used to check if a status is in a set of open statuses, and EnumMap is used to associate enums with descriptions.

10.2. Custom Comparison Methods

You can define custom methods within the enum to perform specific comparisons based on the enum’s properties or behavior. This allows for more complex comparison logic than simple equality checks.

enum Role {
    ADMIN(1),
    MANAGER(2),
    USER(3);

    private final int priority;

    Role(int priority) {
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    public boolean hasHigherPriorityThan(Role otherRole) {
        return this.priority < otherRole.priority;
    }
}

public class EnumComparison {
    public static void main(String[] args) {
        Role role1 = Role.MANAGER;
        Role role2 = Role.USER;

        // Using a custom comparison method
        boolean hasHigherPriority = role1.hasHigherPriorityThan(role2); // true
        System.out.println("Does role1 have higher priority than role2? " + hasHigherPriority);
    }
}

In this example, the hasHigherPriorityThan method defines a custom comparison based on the priority of the roles.

10.3. Using a Switch Statement

A switch statement can be used to compare enums by explicitly handling each enum constant. This approach can be useful when you need to perform different actions based on the enum value.

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

public class EnumComparison {
    public static void main(String[] args) {
        Day day = Day.WEDNESDAY;

        // Using a switch statement to compare enums
        switch (day) {
            case SUNDAY:
                System.out.println("It's Sunday!");
                break;
            case MONDAY:
                System.out.println("It's Monday!");
                break;
            case WEDNESDAY:
                System.out.println("It's Wednesday!");
                break;
            default:
                System.out.println("It's another day.");
        }
    }
}

In this example, the switch statement compares the day enum and executes different code blocks based on its value.

10.4. Considerations When Choosing Alternatives

• Complexity: Consider the complexity of the alternative approach compared to using equals() or ==.
• Performance: Evaluate the performance implications of the alternative approach.
• Readability: Ensure that the alternative approach is readable and maintainable.
• Specific Requirements: Choose an alternative approach based on the specific requirements of your application.

11. Real-World Examples Of Enum Comparison In Java

Enum comparison is a common task in Java programming, with applications in various domains. Here are some real-world examples of how enum comparison is used:

11.1. State Management in E-Commerce Applications

In e-commerce applications, enums are often used to represent the state of an order, such as PENDING, PROCESSING, SHIPPED, and DELIVERED. Enum comparison is used to determine the current state of an order and perform actions accordingly.

enum OrderStatus {
    PENDING,
    PROCESSING,
    SHIPPED,
    DELIVERED
}

public class Order {
    private OrderStatus status;

    public Order(OrderStatus status) {
        this.status = status;
    }

    public void processOrder() {
        if (status == OrderStatus.PENDING) {
            // Perform processing tasks
            status = OrderStatus.PROCESSING;
            System.out.println("Order is now processing.");
        } else if (status == OrderStatus.SHIPPED) {
            // Send delivery notification
            status = OrderStatus.DELIVERED;
            System.out.println("Order has been delivered.");
        } else {
            System.out.println("Order status is " + status);
        }
    }

    public static void main(String[] args) {
        Order order = new Order(OrderStatus.PENDING);
        order.processOrder();
    }
}

In this example, enum comparison is used to manage the state of an order and perform actions based on its current status.

11.2. Role-Based Access Control (RBAC) in Security Systems

In security systems, enums are used to represent user roles, such as ADMIN, MANAGER, and USER. Enum comparison is used to determine a user’s role and grant or deny access to specific resources.

enum Role {
    ADMIN,
    MANAGER,
    USER
}

public class AccessControl {
    private Role userRole;

    public AccessControl(Role userRole) {
        this.userRole = userRole;
    }

    public boolean canAccessResource(String resource) {
        if (userRole == Role.ADMIN) {
            return true; // Admin can access all resources
        } else if (userRole == Role.MANAGER && resource.equals("reports")) {
            return true; // Manager can access reports
        } else {
            return false; // User cannot access this resource
        }
    }

    public static void main(String[] args) {
        AccessControl accessControl = new AccessControl(Role.MANAGER);
        boolean canAccess = accessControl.canAccessResource("reports");
        System.out.println("Can access reports? " + canAccess);
    }
}

In this example, enum comparison is used to implement role-based access control and determine whether a user can access a specific resource.

11.3. Event Handling in GUI Applications

In GUI applications, enums are used to represent different types of events, such as BUTTON_CLICKED, MOUSE_OVER, and KEY_PRESSED. Enum comparison is used to handle specific events and perform actions accordingly.

enum EventType {
    BUTTON_CLICKED,
    MOUSE_OVER,
    KEY_PRESSED
}

public class EventHandler {
    public void handleEvent(EventType event) {
        if (event == EventType.BUTTON_CLICKED) {
            System.out.println("Button clicked event handled.");
        } else if (event == EventType.MOUSE_OVER) {
            System.out.println("Mouse over event handled.");
        } else {
            System.out.println("Key pressed event handled.");
        }
    }

    public static void main(String[] args) {
        EventHandler eventHandler = new EventHandler();
        eventHandler.handleEvent(EventType.BUTTON_CLICKED);
    }
}

In this example, enum comparison is used to handle different types of events and perform actions based on the event type.

11.4. Game Development

In game development, enums can represent game states (e.g., PLAYING, PAUSED, GAME_OVER), player actions (e.g., JUMP, RUN, ATTACK), or object types (e.g., PLAYER, ENEMY, ITEM).

enum GameState {
    PLAYING,
    PAUSED,
    GAME_OVER
}

public class Game {
    private GameState currentState = GameState.PLAYING;

    public void update() {
        if (currentState == GameState.PLAYING) {
            // Update game logic
            System.out.println("Game is running.");
        } else if (currentState == GameState.PAUSED) {
            // Handle pause logic
            System.out.println("Game is paused.");
        } else if (currentState == GameState.GAME_OVER) {
            // Handle game over logic
            System.out.println("Game over!");
        }
    }

    public void pauseGame() {
        if (currentState == GameState.PLAYING) {
            currentState = GameState.PAUSED;
            System.out.println("Game paused.");
        }
    }

     public