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 રીતચર્યા પણ પ્રદાન કરે છે.

सरल સ્થિરાંક સૂચિ કરતાં વધુ enums સમજવું — સંપૂર્ણ વર્ગો જેમાં અવસ્થા અને વર્તણૂક હોય — સ્વચ્છતર, સુરક્ષિત ડોમેન મોડેલિંગ સક્ષમ કરે છે અને તે વારંવાર-અન્તર્ગત પરંતુ મૂલ્યવાન Java ફીચર છે, તેમજ સામાન્ય ઇન્ટરવ્યુ વિષય પણ છે.