జావాలో ఎనుమ్ క్లాస్

హాయ్! ఈ వ్యాసంలో మేము మీకు జావా ఎనమ్స్ గురించి చెప్పబోతున్నాము . మీకు కింది టాస్క్ ఇవ్వబడిందని ఊహించుకోండి: వారంలోని రోజులను అమలు చేసే తరగతిని సృష్టించండి . మొదటి చూపులో, ఇది చాలా సూటిగా అనిపిస్తుంది. మీ కోడ్ ఇలా కనిపిస్తుంది:

public class DayOfWeek {

   private String title;

   public DayOfWeek(String title) {
       this.title = title;
   }

   public static void main(String[] args) {
       DayOfWeek dayOfWeek = new DayOfWeek("Saturday");
       System.out.println(dayOfWeek);
   }

   @Override
   public String toString() {
       return "DayOfWeek{" +
               "title='" + title + '\'' +
               '}';
   }
}

అంతా బాగానే ఉంది, కానీ ఒక సమస్య ఉంది: మీరు DayOfWeek క్లాస్ యొక్క కన్స్ట్రక్టర్‌కి ఏదైనా వచనాన్ని పంపవచ్చు. అంటే ఎవరైనా "ఫ్రాగ్", "క్లౌడ్" లేదా "అజాజా322" పేరుతో వారంలో ఒక రోజుని సృష్టించవచ్చు. ఇది స్పష్టంగా మేము ఆశించే ప్రవర్తన కాదు, ఎందుకంటే వారంలో 7 నిజమైన రోజులు మాత్రమే ఉన్నాయి మరియు వాటిలో ప్రతిదానికి నిర్దిష్ట పేరు ఉంటుంది. అందువల్ల, DayOfWeek తరగతికి సాధ్యమయ్యే విలువల పరిధిని ఏదో ఒకవిధంగా పరిమితం చేయడం మా పని . జావా 1.5 రావడానికి ముందు, డెవలపర్లు ఈ సమస్యకు స్వతంత్రంగా వారి స్వంత పరిష్కారాలను కనుగొనవలసి ఉంటుంది, ఎందుకంటే భాషలో సిద్ధంగా ఉన్న పరిష్కారం లేదు. ఆ రోజుల్లో, ప్రోగ్రామర్లు విలువల సంఖ్యను పరిమితం చేయవలసి వస్తే, వారు ఇలా చేసారు:

public class DayOfWeek {

   private String title;

   private DayOfWeek(String title) {
       this.title = title;
   }

   public static DayOfWeek SUNDAY = new DayOfWeek("Sunday");
   public static DayOfWeek MONDAY = new DayOfWeek("Monday");
   public static DayOfWeek TUESDAY = new DayOfWeek("Tuesday");
   public static DayOfWeek WEDNESDAY = new DayOfWeek("Wednesday");
   public static DayOfWeek THURSDAY = new DayOfWeek("Thursday");
   public static DayOfWeek FRIDAY = new DayOfWeek("Friday");
   public static DayOfWeek SATURDAY = new DayOfWeek("Saturday");

   @Override
   public String toString() {
       return "DayOfWeek{" +
               "title='" + title + '\'' +
               '}';
   }
}

మీరు గమనించవలసినది ఇక్కడ ఉంది:

• కన్స్ట్రక్టర్ ప్రైవేట్. ఒక కన్స్ట్రక్టర్ ప్రైవేట్ మాడిఫైయర్‌తో గుర్తించబడితే , అది ఒక వస్తువును సృష్టించడానికి ఉపయోగించబడదు. మరియు తరగతికి ఒకే కన్స్ట్రక్టర్ ఉన్నందున, DayOfWeek ఆబ్జెక్ట్‌లు సృష్టించబడవు.

  
  	public class Main {
  
     		public static void main(String[] args) {
        
         			DayOfWeek sunday = new DayOfWeek(); // Error!
     		}
  }
  




• వాస్తవానికి, తరగతికి అవసరమైన పబ్లిక్ స్టాటిక్ ఆబ్జెక్ట్‌లు ఉన్నాయి , అవి సరిగ్గా ప్రారంభించబడ్డాయి (వారం రోజుల సరైన పేర్లను ఉపయోగించి).

  ఇది ఈ వస్తువులను ఇతర తరగతులలో ఉపయోగించడానికి అనుమతించింది.

  
  	public class Person {
  
     		public static void main(String[] args) {
  
         			DayOfWeek sunday = DayOfWeek.SUNDAY;
  
         			System.out.println(sunday);
    		 }
  }
  

  అవుట్‌పుట్:

  DayOfWeek{title = 'ఆదివారం'}

ఈ విధానం చాలావరకు సమస్యను పరిష్కరిస్తుంది. మా వద్ద వారంలో 7 రోజులు ఉన్నాయి మరియు ఎవరూ కొత్త వాటిని సృష్టించలేరు. ఈ పరిష్కారాన్ని జాషువా బ్లాచ్ తన పుస్తకం ఎఫెక్టివ్ జావాలో అందించారు . మార్గం ద్వారా, ఆ పుస్తకం చాలా బాగుంది మరియు ఏ జావా డెవలపర్ అయినా తప్పనిసరిగా చదవాలి. జావా 1.5 విడుదలతో, భాష అటువంటి పరిస్థితులకు సిద్ధంగా ఉన్న పరిష్కారాన్ని పొందింది: జావా ఎనమ్స్ . జావాలో ఎనుమ్ కూడా ఒక తరగతి. ఇలాంటి సమస్యలను పరిష్కరించడానికి ఇది ప్రత్యేకంగా "ఫైన్-ట్యూన్" చేయబడింది, అంటే నిర్దిష్ట పరిమిత శ్రేణి విలువలను సృష్టించడం. Java సృష్టికర్తలు ఇప్పటికే సిద్ధంగా ఉన్న ఉదాహరణలను కలిగి ఉన్నారు (ఉదాహరణకు, C ఇప్పటికే enum కలిగి ఉంది ), కాబట్టి వారు ఉత్తమ వేరియంట్‌ను సృష్టించగలిగారు.

కాబట్టి జావా ఎనుమ్ అంటే ఏమిటి?

మన DayOfWeek ఉదాహరణను మళ్లీ సందర్శిద్దాం :

public enum DayOfWeek {

   SUNDAY,
   MONDAY,
   TUESDAY,
   WEDNESDAY,
   THURSDAY,
   FRIDAY,
   SATURDAY
}

ఇప్పుడు అది చాలా సరళంగా కనిపిస్తోంది :) అంతర్గతంగా, మా Enum 7 స్టాటిక్ స్థిరాంకాలను కలిగి ఉంది. మరియు మేము దానిని ఉపయోగించవచ్చు ఏదో ఒక కార్యక్రమం అమలు. ఉదాహరణకు, ఒక విద్యార్థి ఈరోజు పాఠశాలకు వెళ్లాలా వద్దా అని నిర్ణయించే ప్రోగ్రామ్‌ను వ్రాద్దాం. మా విద్యార్థికి రోజువారీ షెడ్యూల్ ఉంటుంది, ఇది విద్యార్థి షెడ్యూల్ క్లాస్ ద్వారా ప్రాతినిధ్యం వహిస్తుంది:

public class StudentSchedule {

   private DayOfWeek dayOfWeek;
   // ... other fields


   public DayOfWeek getDayOfWeek() {
       return dayOfWeek;
   }

   public void setDayOfWeek(DayOfWeek dayOfWeek) {
       this.dayOfWeek = dayOfWeek;
   }
}

షెడ్యూల్ ఆబ్జెక్ట్ యొక్క dayOfWeek వేరియబుల్ ఈ రోజు ఏ రోజు అని నిర్ణయిస్తుంది. మరియు ఇక్కడ మా విద్యార్థి తరగతి ఉంది:

public class Student {

   private StudentSchedule schedule;
   private boolean goToSchool;

   public void wakeUp() {
      
       if (this.schedule.getDayOfWeek() == DayOfWeek.SUNDAY) {
           System.out.println("Hooray, you can sleep more!");
       } else {
           System.out.println("Damn, time for school again :(");
       }
   }
}

వేక్‌అప్() పద్ధతిలో , విద్యార్థి తర్వాత ఏమి చేయాలో నిర్ణయించడానికి మేము జావా ఎనమ్‌ని ఉపయోగిస్తాము. మేము DayOfWeek లో ప్రతి ఫీల్డ్ గురించిన వివరాలను కూడా అందించలేదు మరియు మాకు ఇది అవసరం లేదు: వారంలోని రోజులు ఎలా పని చేయాలో స్పష్టంగా ఉంది. మేము దానిని ప్రస్తుత రూపంలో ఉపయోగిస్తే, మన కోడ్‌లో ఏమి జరుగుతుందో ఏ డెవలపర్ అయినా అర్థం చేసుకుంటారు. ఎనమ్ యొక్క సౌలభ్యానికి మరొక ఉదాహరణ ఏమిటంటే, దాని స్థిరాంకాలు స్విచ్ స్టేట్‌మెంట్‌తో ఉపయోగించవచ్చు. ఉదాహరణకు, కఠినమైన ఆహారం కోసం ఒక ప్రోగ్రామ్‌ను వ్రాద్దాం, దీనిలో రోజు వారీగా వంటకాలు షెడ్యూల్ చేయబడతాయి:

public class VeryStrictDiet {
   public void takeLunch(DayOfWeek dayOfWeek) {
       switch (dayOfWeek) {
           case SUNDAY:
               System.out.println("Sunday Dinner! You can even enjoy something a little sweet today.");
               break;
           case MONDAY:
               System.out.println("Lunch for Monday: chicken noodle soup!");
               break;
           case TUESDAY:
               System.out.println("Tuesday, today it's celery soup :(");
               break;
               //... and so on to the end
       }
   }
}

జావా 1.5కి ముందు ఉపయోగించిన పాత సొల్యూషన్ కంటే ఇది Enums ప్రయోజనాల్లో ఒకటి — స్విచ్‌తో పాత సొల్యూషన్‌ని ఉపయోగించలేరు . Enum గురించి మీరు ఇంకా ఏమి తెలుసుకోవాలి ? ఎనమ్ అనేది అన్ని అవకాశాలతో కూడిన నిజమైన తరగతి. ఉదాహరణకు, వారం రోజుల ప్రస్తుత అమలు సరిపోకపోతే, మీరు DayOfWeek కి వేరియబుల్స్, కన్స్ట్రక్టర్‌లు మరియు పద్ధతులను జోడించవచ్చు :

public enum DayOfWeek {
  
   SUNDAY ("Sunday"),
   MONDAY ("Monday"),
   TUESDAY ("Tuesday"),
   WEDNESDAY ("Wednesday"),
   THURSDAY ("Thursday"),
   FRIDAY ("Friday"),
   SATURDAY ("Saturday");

   private String title;

   DayOfWeek(String title) {
       this.title = title;
   }

   public String getTitle() {
       return title;
   }

   @Override
   public String toString() {
       return "DayOfWeek{" +
               "title='" + title + '\'' +
               '}';
   }
}

ఇప్పుడు మా ఎనమ్ స్థిరాంకాలు టైటిల్ ఫీల్డ్, గెటర్ మరియు ఓవర్‌రైడ్ టు స్ట్రింగ్ పద్ధతిని కలిగి ఉన్నాయి. సాధారణ తరగతులతో పోలిస్తే, ఎనమ్‌పై ఒక తీవ్రమైన పరిమితి విధించబడింది - ఇది వారసత్వంగా పొందబడదు. అదనంగా, గణనలు లక్షణ పద్ధతులను కలిగి ఉంటాయి:

• విలువలు() : Enum లోని అన్ని విలువల శ్రేణిని అందిస్తుంది :

  
  public static void main(String[] args) {
     		System.out.println(Arrays.toString(DayOfWeek.values()));
  }
  

  అవుట్‌పుట్:

  [DayOfWeek{title = 'ఆదివారం'}, DayOfWeek{title = 'సోమవారం'}, DayOfWeek{title = 'మంగళవారం'}, DayOfWeek{title = 'బుధవారం'}, DayOfWeek{title = 'గురువారం'}, DayOfWeek{title = 'శుక్రవారం'}, డేఆఫ్‌వీక్{title = 'శనివారం'}]

• ordinal() : స్థిరాంకం యొక్క ఆర్డినల్ సంఖ్యను అందిస్తుంది. సంఖ్య సున్నా నుండి ప్రారంభమవుతుంది:

  
  	public static void main(String[] args) {
  
     		int sundayIndex = DayOfWeek.SUNDAY.ordinal();
     		System.out.println(sundayIndex);
  }
  

  అవుట్‌పుట్:

  0

• valueOf() : పాస్ చేసిన పేరుకు అనుగుణంగా ఉండే Enum ఆబ్జెక్ట్‌ను అందిస్తుంది:

  
  public static void main(String[] args) {
     DayOfWeek sunday = DayOfWeek.valueOf("SUNDAY");
     System.out.println(sunday);
  }
  

  అవుట్‌పుట్:

  DayOfWeek{title = 'ఆదివారం'}

గమనిక:మేము Enum ఫీల్డ్‌లను పేర్కొనడానికి పెద్ద అక్షరాలను ఉపయోగిస్తాము . ఇవి స్థిరాంకాలు కాబట్టి కామెల్‌కేస్ కాకుండా ఆల్-క్యాప్‌లను ఉపయోగిస్తాయి .