Java-வில் enums எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

ஒரு **enum** என்பது **பெயரிடப்பட்ட constants-இன் நிலையான தொகுப்பு** கொண்ட ஒரு type-ஐ வரையறுக்கிறது. Java enums மற்ற languages-இல் உள்ள எளிய constant lists-ஐ விட மிகவும் சக்திவாய்ந்தவை — அவை fields, constructors, மற்றும் methods கொண்டிருக்கக்கூடிய முழுமையான classes ஆகும்.

## அடிப்படை enum

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

Day today = Day.MONDAY;

// works great in switch
switch (today) {
    case MONDAY -> System.out.println("start of week");
    case SATURDAY, SUNDAY -> System.out.println("weekend");
    default -> System.out.println("weekday");
}
```

Enums **type safety**-ஐ வழங்குகின்றன — `Day today = Day.MONDAY` சரியான `Day` values-ஐ மட்டுமே வைத்திருக்க முடியும், தன்னிச்சையான ints அல்லது strings-ஐ constants ஆகப் பயன்படுத்துவது போல் அல்ல (இவை தவறான values மற்றும் typos-ஐ அனுமதிக்கின்றன).

## உள்ளமைக்கப்பட்ட enum methods

```java
Day.MONDAY.name();        // "MONDAY"
Day.MONDAY.ordinal();     // 0 — position in the declaration
Day.values();             // array of all constants (iterate them)
Day.valueOf("FRIDAY");    // get a constant by name
for (Day d : Day.values()) { ... }   // iterate all values
```

## Fields, constructors, மற்றும் methods கொண்ட Enums (சக்திவாய்ந்த பகுதி)

```java
public enum Planet {
    MERCURY(3.3e23, 2.4e6),    // each constant calls the constructor with arguments
    EARTH(5.97e24, 6.37e6),
    JUPITER(1.9e27, 7.1e7);

private final double mass;       // enums can have FIELDS
    private final double radius;

Planet(double mass, double radius) {   // constructor (implicitly private)
        this.mass = mass;
        this.radius = radius;
    }
    public double surfaceGravity() {        // and METHODS
        return 6.67e-11 * mass / (radius * radius);
    }
}

Planet.EARTH.surfaceGravity();   // compute using EARTH's data
```

ஒவ்வொரு enum constant-ம் ஒரு instance ஆகும், constructor மூலம் configure செய்யப்படுகிறது — ஒவ்வொரு constant-உடனும் data மற்றும் behavior-ஐ இணைக்க உங்களை அனுமதிக்கிறது. பெரும்பாலான languages-இன் enums-உடன் ஒப்பிடும்போது இது தனித்துவமானது மற்றும் சக்திவாய்ந்தது.

## Enums interfaces-ஐ implement செய்து per-constant behavior கொண்டிருக்கலாம்

```java
public enum Operation {
    PLUS { public int apply(int a, int b) { return a + b; } },
    TIMES { public int apply(int a, int b) { return a * b; } };
    public abstract int apply(int a, int b);   // each constant implements it differently
}
Operation.PLUS.apply(2, 3);   // 5
```

## Enums சிறந்த singletons

```java
public enum Config { INSTANCE; /* fields/methods */ }
// enum singletons are thread-safe and serialization-safe by design
```

## இது ஏன் முக்கியம்

Java enums தொடர்புடைய constants-இன் நிலையான தொகுப்புகளை (states, days, roles, operations) பிரதிநிதித்துவப்படுத்த ஒரு வலுவான, type-safe வழியாகும் — `int`/`String` constants என்ற பிழைக்கு வாய்ப்புள்ள மாற்றுக்கு மிகவும் மேலானது, அவை தவறான values-ஐ அனுமதித்து type checking வழங்காது.

அவற்றின் தனித்துவமான சக்தி — fields, constructors, methods, interface implementation, மற்றும் per-constant behavior — ஒவ்வொரு constant-உடனும் data மற்றும் logic-ஐ இணைக்க உங்களை அனுமதிக்கிறது, domain concepts-ஐ நேர்த்தியாக மாதிரியாக்குகிறது (எ.கா. mass/gravity கொண்ட planets, அவற்றின் math கொண்ட operations).

அவை பாதுகாப்பான singleton idiom-ஐயும் வழங்குகின்றன.

enums-ஐ எளிய constant lists-க்கு அப்பால் புரிந்துகொள்வது — state மற்றும் behavior கொண்ட முழு classes ஆக — சுத்தமான, பாதுகாப்பான domain modeling-ஐ சாத்தியமாக்குகிறது மற்றும் அடிக்கடி-குறைவாகப் பயன்படுத்தப்படும் ஆனால் மதிப்புமிக்க Java feature ஆகும், அத்துடன் ஒரு பொதுவான interview தலைப்பும் ஆகும்.