Java లో enums ఎలా పని చేస్తాయి?

Question

Accepted Answer

**enum** అనేది **స్థిర పేరుతో ఉన్న స్థిరాంకాల సమితి**ని నిర్వచించే టైప్. Java enums ఇతర భాషల్లో ఉన్న సాధారణ స్థిరాంక జాబితల కంటే చాలా శక్తిశాలీ — అవి క్షేత్రాలు, కన్‌స్ట్రక్టర్‌లు మరియు పద్ధతులను కలిగి ఉన్న పూర్ణ-నిర్మిత తరగతులు.

## ప్రాథమిక 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 **టైప్ సేఫ్‌టీ** ని అందిస్తాయి — `Day today = Day.MONDAY` కేవలం చెల్లుబాటు అయ్యే `Day` విలువలను మాత్రమే కలిగి ఉంటుంది, స్థిరాంకాలుగా ఏకపక్ష పూర్ణాంకాలు లేదా స్ట్రింగ్‌లను ఉపయోగించడం వలె కాకుండా (ఇవి చెల్లని విలువలు మరియు టైపోలను అనుమతిస్తాయి).

## అంతర్నిర్మిత enum పద్ధతులు

```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
```

## క్షేత్రాలు, కన్‌స్ట్రక్టర్‌లు మరియు పద్ధతులతో 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 స్థిరాంకం ఒక ఉదాహరణ, కన్‌స్ట్రక్టర్ ద్వారా కాన్ఫిగర్ చేయబడింది — ప్రతి స్థిరాంకంతో డేటా మరియు ప్రవర్తనను అనుబంధించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది చాలా భాషల enums కంటే ప్రత్యేకమైనది మరియు శక్తిశాలీ.

## Enums ఇంటర్‌ఫేసులను చేపట్టవచ్చు మరియు స్థిర-విశేష ప్రవర్తనను కలిగి ఉండవచ్చు

```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 స్థిర సంబంధిత స్థిరాంకాల సమితులను (స్థితులు, రోజులు, పాత్రలు, కార్యకలాపాలు) సూచించడానికి ఒక సంపూర్ణ, టైప్-సేఫ్ మార్గం — `int`/`String` స్థిరాంకాల యొక్క లోపభరితమైన ప్రత్యామ్నాయం కంటే చాలా ఉత్తమం, ఇది చెల్లని విలువలను అనుమతిస్తుంది మరియు టైప్ తనిఖీని అందించదు.

వాటి ప్రత్యేక శక్తి — క్షేత్రాలు, కన్‌స్ట్రక్టర్‌లు, పద్ధతులు, ఇంటర్‌ఫేస్ చేపట్టడం మరియు స్థిర-విశేష ప్రవర్తన — ప్రతి స్థిరాంకంతో డేటా మరియు తర్కం జతచేయడానికి మిమ్మల్ని అనుమతిస్తుంది, డొమైన్ భావనలను సొగसుగా మోడల్ చేయడం (ఉదా. ద్రవ్యరాశి/గురుత్వాకర్షణ కలిగిన గ్రహాలు, వాటి గణితంతో కార్యకలాపాలు).

వారు సేఫ్‌టమైన singleton idiomను కూడా అందిస్తారు.

సాధారణ స్థిరాంక జాబితల కంటే ఆગળ ఉన్న enumలను అర్థం చేసుకోవడం — స్థితి మరియు ప్రవర్తనతో కూడిన పూర్ణ తరగతులుగా — క్లీనర్, సేఫ్ డొమైన్ మోడలింగ్ మరియు తరచుగా-ఉపయోగించని కానీ విలువైన Java లక్షణం, అలాగే సాధారణ ఇంటర్‌వ్యూ విషయాన్ని ప్రారంభించడానికి సక్షమ చేస్తుంది.