కొత్త డేటా రకం: ఎన్యుమ్ లేదా ఎన్యుమరేషన్

1. నేపథ్యం ఎలా enumవచ్చింది

ఈ రోజు మనం జావాలో మరొక రకమైన డేటా రకాన్ని అన్వేషిస్తాము: enum. పేరు గణన అనేenum పదం నుండి వచ్చింది . ఈ డేటా రకం ఏమిటి మరియు ఇది దేని కోసం?

కొన్నిసార్లు ప్రోగ్రామర్ కొత్త డేటా రకాన్ని సృష్టించాలి, దీని సాధ్యమయ్యే విలువలు చిన్న స్థిర జాబితాకు పరిమితం చేయబడతాయి.

ఉదాహరణకు, ఒక DayOfTheWeekరకం విలువలను మాత్రమే తీసుకోగలదు MONDAY, TUESDAY, WEDNESDAY, ... మొత్తం 7 విలువలు ఉన్నాయి. లేదా ఒక Monthరకం విలువలను మాత్రమే తీసుకోగలదు JANUARY, FEBRUARY, MARCH, ... మొత్తం 12 విలువలు ఉన్నాయి.

వాస్తవానికి, మీరు చేయగలిగిన సంఖ్యలను ( intరకం) ఉపయోగిస్తారు: 1- సోమవారం, - మంగళవారం, మొదలైనవి. కానీ ఎవరైనా అనుకోకుండా మీ వేరియబుల్ వంటి లేదా 2చెల్లని విలువలను కేటాయించవచ్చు .80

ఒక ప్రోగ్రామర్ వారంలోని రోజులు (లేదా సంవత్సరంలోని నెలలు) సున్నా నుండి ప్రారంభించబడిందని భావించే పరిస్థితిని మీరు సులభంగా కలిగి ఉండవచ్చు, మరికొందరు వారి సంఖ్య ఒకటి నుండి మొదలవుతుందని ఆశించారు.

అందుకే పరిమిత విలువలనుenum కలిగి ఉండే డేటా రకాన్ని జావా పరిచయం చేసింది .

2. ఒక రకాన్ని ప్రకటించడం

కొత్త enumడేటా రకాన్ని ప్రకటించడం ఇలా కనిపిస్తుంది:

enum TypeName
{
   VALUE1,
   VALUE2,
   VALUE3
}

TypeNameకొత్త రకం (తరగతి) పేరు ఎక్కడ ఉంది మరియు సాధ్యమయ్యే విలువలు కామాలతో వేరు చేయబడతాయి మరియు కర్లీ జంట కలుపులతో చుట్టబడతాయి: Value1, Value2, Value3.

ఉదాహరణగా, మన స్వంతంగా సృష్టించుకుందాం DayOfTheWeek enum:

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

మా కొత్త రకం వేరియబుల్‌కి మీరు విలువను ఎలా కేటాయిస్తారో ఇక్కడ ఉంది:

Day day = Day.MONDAY;

ఉదాహరణ:

Day day = Day.FRIDAY;
System.out.println(day);

FRIDAY

3. ఒక యొక్క పద్ధతులుenum

ఒక enumరకానికి అనేక అంతర్నిర్మిత పద్ధతులు ఉన్నాయి, వాటిలో రెండు చాలా ఆసక్తికరమైనవి:

స్టాటిక్ values()పద్ధతి రకం యొక్క అన్ని విలువల శ్రేణిని అందిస్తుంది enum:

Day[] days = Day.values();

for (Day day: days)
   System.out.println(day);







System.out.println(days[2]);

MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
SUNDAY

WEDNESDAY

పద్ధతి ordinal()స్థిరాంకం యొక్క ఆర్డినల్ సంఖ్యను అందిస్తుంది. మీరు దానిని క్లాస్‌గా enumకాకుండా విలువతో పిలుస్తారు enum:

System.out.println(Day.MONDAY.ordinal());
System.out.println(Day.FRIDAY.ordinal());
System.out.println(Day.SUNDAY.ordinal());

0
4
6

4. తరగతికి మార్చడం

వాస్తవానికి, ఇక్కడ మాయాజాలం ఏమీ లేదు. కంపైలర్ మాకు కొన్ని వాక్యనిర్మాణ చక్కెరను అందించింది. కంపైల్ సమయంలో, Dayenum సాధారణ తరగతికి మార్చబడుతుంది:

public class Day
{
   public static final Day MONDAY = new Day(0);
   public static final Day TUESDAY = new Day(1);
   public static final Day WEDNESDAY = new Day(2);
   public static final Day THURSDAY = new Day(3);
   public static final Day FRIDAY = new Day(4);
   public static final Day SATURDAY = new Day(5);
   public static final Day SUNDAY = new Day(6);

    private static final Day[] array = {MONDAY, TUESDAY,
      WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};

   private final int value;

   private Day (int value)
   {
      this.value = value;
   }

   public int ordinal()
   {
      return this.value;
   }

   public static Day[] values()
   {
      return array;
   }
}

మేము తరగతి నుండి అన్ని స్టాటిక్ పద్ధతులు మరియు వేరియబుల్‌లను తీసివేస్తే Day, మేము ఈ క్రింది వాటిని పొందుతాము:

public class Day
{
  private int value;

  private Day (int value)
  {
    this.value = value;
  }

  public int ordinal()
  {
    return this.value;
  }
}

మరో మాటలో చెప్పాలంటే, ఇక్కడ భయంకరమైనది ఏమీ జరగదు. కంపైలర్ Dayతరగతిని సృష్టిస్తుంది, విలువలను సూచించే స్థిరాంకాలను జోడిస్తుంది enum, అవసరమైన పద్ధతులను జోడిస్తుంది మరియు క్లాస్ కన్స్ట్రక్టర్‌ను చేస్తుంది private. మేము కొంచెం తర్వాత కన్స్ట్రక్టర్లు ఎలా పని చేస్తారో చూద్దాం.

ఆశాజనక, మనం ఈ విధంగా వేరియబుల్‌కు ఎందుకు విలువను కేటాయించాలో ఇప్పుడు స్పష్టంగా తెలుస్తుంది:

Day day = Day.MONDAY;

MONDAYతరగతిలో స్థిరమైన ఫీల్డ్ (స్థిరమైన) మాత్రమే Day. క్లాస్ వెలుపలి నుండి స్టాటిక్ మెథడ్స్ మరియు ఫీల్డ్‌లను యాక్సెస్ చేస్తున్నప్పుడు, ఫీల్డ్ లేదా మెథడ్ పేరుకు ముందు మీరు క్లాస్ పేరును తప్పనిసరిగా సూచించాలి.

5. ఒక యొక్క మరిన్ని పద్ధతులుenum

ప్రతి enumతరగతి అనేక ఆసక్తికరమైన లక్షణాలను కలిగి ఉంటుంది.

స్ట్రింగ్‌కు మరియు స్ట్రింగ్ నుండి మార్చడం

enum వస్తువును స్ట్రింగ్‌గా మార్చడానికి, మీరు దాని toString()పద్ధతిని కాల్ చేయాలి.

String str = Day.MONDAY.toString();

ఇతర దిశలో (స్ట్రింగ్ నుండి వస్తువుకు Day) మార్చడానికి, మీరు స్టాటిక్ పద్ధతిని ఉపయోగించవచ్చు valueOf():

Day day = Day.valueOf("MONDAY");

ఇది చాలా సౌకర్యవంతంగా ఉంటుంది మరియు చాలా సందర్భాలలో ఉపయోగకరంగా ఉంటుంది.

నంబర్‌కి మార్చడం మరియు మళ్లీ తిరిగి రావడం

enumఆబ్జెక్ట్‌ను నంబర్‌గా ఎలా మార్చాలో మీకు ఇప్పటికే తెలుసు : ఈ ordinal()పద్ధతికి కాల్ చేయండి:

int index = Day.MONDAY.ordinal();

ఇతర దిశలో (సంఖ్య నుండి వస్తువుకు Day) మార్చడానికి, మీకు మరింత పారదర్శక నిర్మాణం అవసరం:

Day day = Day.values()[2];

ఉదాహరణలు:

Day day = Day.MONDAY;
int index = day.ordinal();
Day newDay = Day.values()[index+2];

ముఖ్యమైన అంశం:enum విలువలు స్థిరమైన స్థిరాంకాల సమితి కాబట్టి , వాటిని == ఉపయోగించి పోల్చవచ్చు . MONDAYమరో మాటలో చెప్పాలంటే, మీరు వేర్వేరు చిరునామాలతో ఒకేలాంటి రెండు వస్తువులను కలిగి ఉండకూడదు . ప్రతి enum విలువకు ఒకే ఒక్క ఉదాహరణ మాత్రమే ఉంది. మరియు దాని అర్థం == ఉపయోగించి enum వేరియబుల్స్ పోల్చడం ఎల్లప్పుడూ పని చేస్తుంది.

6. మీ స్వంత పద్ధతులను జోడించడంenum

కంపైల్ సమయంలో ఒక సాధారణ తరగతిగా మారుతుంది కాబట్టి enum, మీరు దానిలోని పద్ధతులను ప్రకటించవచ్చు. ఈ పద్ధతులు కంపైలర్ ఉత్పత్తి చేసే తరగతికి జోడించబడతాయి. ఉదాహరణకు, మేము Day enumశ్రేణికి బదులుగా enum విలువల జాబితాను తిరిగి ఇవ్వాలనుకుంటున్నాము.

అప్పుడు మనం ఈ క్రింది కోడ్‌ను జోడించవచ్చు:

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

   public static List<Day> asList()
   {
      ArrayList<Day> list = new ArrayList<Day>();

      Collections.addAll(list, values());

      return list;
   }

}

ఇప్పుడు ఈ పద్ధతిని కోడ్‌లో పిలవవచ్చు:

List<Day> list = Day.asList();