ఎనుమ్. ఆచరణాత్మక ఉదాహరణలు. కన్స్ట్రక్టర్లు మరియు పద్ధతులను జోడించడం

హాయ్! ఈ రోజు మనం జావా యొక్క ప్రత్యేక డేటా రకాల్లో ఒకదాని గురించి మాట్లాడుతాము: Enum("గణన" కోసం చిన్నది). దీని ప్రత్యేకత ఏమిటి? ఒక ప్రోగ్రామ్‌లో "నెలలు" ఏమి అమలు చేయాలో మనం ఊహించుకుందాం. సమస్యాత్మకంగా అనిపించడం లేదు, సరియైనదా? ఏ నెలలో ఏ లక్షణాలు ఉన్నాయో మనం గుర్తించాలి. బహుశా మనకు మొదట నెల పేరు మరియు దానిలోని రోజుల సంఖ్య అవసరం కావచ్చు. పరిష్కారం చాలా సరళంగా కనిపిస్తుంది:

public class Month {

   private String name;
   private int daysCount;

   public Month(String name, int daysCount) {
       this.name = name;
       this.daysCount = daysCount;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getDaysCount() {
       return daysCount;
   }

   public void setDaysCount(int daysCount) {
       this.daysCount = daysCount;
   }

   @Override
   public String toString() {
       return "Month{" +
               "name='" + name + '\'' +
               ", daysCount=" + daysCount +
               '}';
   }
}

మొత్తం షాబాంగ్! మాకు Monthతరగతి, అవసరమైన ఫీల్డ్‌లు, గెటర్/సెట్టర్‌లు మరియు toString(). తప్ప, మేము జోడించాలి equals()మరియుhashCode()పూర్తి ఆనందాన్ని సాధించడానికి :) కానీ ఇక్కడ మనకు సంభావిత సమస్య ఉంది. మీరు బహుశా గుర్తుంచుకున్నట్లుగా, OOP యొక్క ప్రధాన ప్రయోజనాల్లో ఒకటి వాస్తవ ప్రపంచం నుండి మోడల్ ఎంటిటీలను సులభతరం చేస్తుంది. ఒక కుర్చీ, కారు, ఒక గ్రహం - సాధారణ జీవితంలోని ఈ భావనలన్నీ నైరూప్యత సహాయంతో ప్రోగ్రామ్‌లో సులభంగా సూచించబడతాయి. సమస్య ఏమిటంటే కొన్ని వాస్తవ-ప్రపంచ సంస్థలు ఖచ్చితంగా పరిమితమైన విలువలను కలిగి ఉంటాయి. సంవత్సరంలో కేవలం 4 సీజన్లు మాత్రమే ఉంటాయి. ఒక అష్టపదిలో కేవలం 8 నోట్లు మాత్రమే ఉంటాయి. క్యాలెండర్‌లో కేవలం 12 నెలలు మాత్రమే ఉన్నాయి. మరియు ఓషన్స్ 11కి చెందిన డానీ ఓషన్‌కు కేవలం 11 మంది స్నేహితులు ఉన్నారు (అయితే ఇది పట్టింపు లేదు :)) ముఖ్యమైన విషయం ఏమిటంటే, ఒక సాధారణ జావా తరగతి ఈ ఎంటిటీలను మోడల్ చేయడం మరియు వాటి సహజ పరిమితులను అమలు చేయడం సాధ్యం కాదు. మాMonthతరగతికి అవసరమైన అన్ని ఫీల్డ్‌లు ఉన్నాయి. కానీ మరొక ప్రోగ్రామర్ దానిని ఉపయోగిస్తే, అతనిని లేదా ఆమెను పూర్తిగా పిచ్చి వస్తువులను సృష్టించకుండా ఎవరూ ఆపలేరు:

public class Main {

   Month month1 = new Month("lolkek", 322);
   Month month2 = new Month("yahoooooooooooo", 12345);

}

ఇది మా కోడ్‌లో కనిపిస్తే, నేరస్థుడిని కనుగొనడం అంత సులభం కాదు! ఒక వైపు, ఆబ్జెక్ట్‌లను సృష్టించే ప్రోగ్రామర్ Monthక్లాస్ అంటే "సంవత్సరంలో నెల" అని అర్థం చేసుకోవచ్చు మరియు అలాంటి అర్ధంలేని విధంగా వ్రాయకూడదు. మరోవైపు, ప్రోగ్రామర్ క్లాస్ డిజైనర్ అందించిన సామర్థ్యాలను మాత్రమే ఉపయోగించుకుంటున్నారు. ఏకపక్ష పేర్లు మరియు రోజుల సంఖ్యలను కేటాయించడం సాధ్యమేనా? సరిగ్గా అదే మనకు వచ్చింది. ఈ పరిస్థితిలో మనం ఏమి చేయాలి? నిజాయితీగా, జావా 1.5 విడుదలయ్యే ముందు, ప్రోగ్రామర్లు సృజనాత్మకతను పొందవలసి వచ్చింది :) ఆ రోజుల్లో, వారు ఇలాంటి నిర్మాణాలను సృష్టించారు:

public class Month {

   private String name;
   private int daysCount;

   private Month(String name, int daysCount) {
       this.name = name;
       this.daysCount = daysCount;
   }

   public static Month JANUARY = new Month("January", 31);
   public static Month FEBRUARY = new Month("February", 28);
   public static Month MARCH = new Month("March", 31);

   @Override
   public String toString() {
       return "Month{" +
               "name='" + name + '\'' +
               ", daysCount=" + daysCount +
               '}';
   }
}

ఉదాహరణను చిన్నదిగా చేయడానికి ఇక్కడ మేము నెలల సంఖ్యను పన్నెండు నుండి మూడుకి తగ్గించాము. ఇటువంటి నమూనాలు సమస్యను పరిష్కరించడానికి సాధ్యపడ్డాయి. వస్తువులను సృష్టించే సామర్థ్యం ప్రైవేట్ కన్స్ట్రక్టర్‌కు పరిమితం చేయబడింది:

private Month(String name, int daysCount) {
       this.name = name;
       this.daysCount = daysCount;
   }

తరగతిని ఉపయోగించే ప్రోగ్రామర్లు కేవలం వస్తువులను సృష్టించలేరు Month. వారు క్లాస్ డెవలపర్ అందించిన చివరి స్టాటిక్ ఆబ్జెక్ట్‌లను ఉపయోగించాల్సి వచ్చింది. ఉదాహరణకు, ఇలా:

public class Main {

   public static void main(String[] args) {

       Month january = Month.JANUARY;
       System.out.println(january);
   }

}

కానీ, జావా డెవలపర్లు ఇప్పటికే ఉన్న సమస్యపై దృష్టిని ఆకర్షించారు. వాస్తవానికి, ప్రోగ్రామర్లు భాషలో అందుబాటులో ఉన్న సాధనాలను ఉపయోగించి ఒక పరిష్కారాన్ని కనుగొనగలిగారు, కానీ ఇది చాలా సులభం కాదు! అనుభవం లేని వారికి కూడా స్పష్టమైన పరిష్కారం అవసరం. మరియు Enumజావాలో కనిపించింది. ప్రాథమికంగా, Enumపరిమిత ఆబ్జెక్ట్ విలువలను అందించే జావా క్లాస్. ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:

public enum Month {
  
   JANUARY,
   FEBRUARY,
   MARCH
}

నిర్వచనంలో, అది Enumజావా క్లాస్ అని మేము సూచించాము, అయితే ఇది నిజంగా నిజమేనా? అవును, మరియు మేము దానిని ధృవీకరించవచ్చు కూడా. ఉదాహరణకు, మా Monthఎన్యుమ్‌ను ఇతర తరగతిని వారసత్వంగా పొందేలా ప్రయత్నించండి:

public abstract class AbstractMonth {
}

// Error! The extends clause cannot be used with an enum
public enum Month extends AbstractMonth {

   JANUARY,
   FEBRUARY,
   MARCH
}

అలా ఎందుకు జరుగుతుంది? మేము వ్రాసేటప్పుడు:

public enum Month

కంపైలర్ ఈ స్టేట్‌మెంట్‌ను క్రింది కోడ్‌గా మారుస్తుంది:

public Class Month extends Enum

మీకు ఇప్పటికే తెలిసినట్లుగా, Java బహుళ వారసత్వానికి మద్దతు ఇవ్వదు. కాబట్టి, మనం వారసత్వంగా పొందలేము AbstractMonth. ఈ కొత్త నిర్మాణం, Enum, ఎలా ఉపయోగించవచ్చు? మరియు క్షేత్రాలతో పాత నిర్మాణం నుండి ఇది ఎలా భిన్నంగా ఉంటుంది static final? సరే, ఉదాహరణగా, పాత నిర్మాణం స్టేట్‌మెంట్‌లలో మన స్వంత విలువలను ఉపయోగించనివ్వలేదు switch. మేము ప్రతి నెల జరుపుకునే సెలవులను గుర్తుచేసే ప్రోగ్రామ్‌ను రూపొందించాలనుకుంటున్నామని ఊహించండి:

public class HolidayReminder {

   public void printHolidays(Month month) {

       switch (month) {

           // Error!
           case JANUARY:
       }
   }
}

మీరు చూడగలిగినట్లుగా, కంపైలర్ ఇక్కడ లోపాన్ని విసురుతుంది. కానీ ఒకసారి enumజావా 1.5 లో కనిపించినప్పుడు, ప్రతిదీ చాలా సరళంగా మారింది:

public enum Month {

   JANUARY,
   FEBRUARY,
   MARCH
}

public class HolidayReminder {

   public void printHolidays(Month month) {

       switch (month) {
          
           case JANUARY:
               System.out.println("New Year's Day is January 1st!");
               break;
           case FEBRUARY:
               System.out.println("Valentine's Day is February 14th!");
               break;
           case MARCH:
               System.out.println("Saint Patrick's Day is March 17th!");
               break;
       }
   }
}


public class Main {

   public static void main(String[] args) {

       HolidayReminder reminder = new HolidayReminder();
       reminder.printHolidays(Month.JANUARY);

   }

}

కన్సోల్ అవుట్‌పుట్:

New Year's Day is January 1st!

Enumజావా 1.5కి ముందు ఉన్నట్లే ఆబ్జెక్ట్‌లకు యాక్సెస్ స్థిరంగా ఉందని గమనించండి . Monthనెలలను యాక్సెస్ చేయడానికి మేము ఆబ్జెక్ట్‌ని సృష్టించాల్సిన అవసరం లేదు . Enumఎనమ్‌లతో పని చేస్తున్నప్పుడు, పూర్తి స్థాయి తరగతి అని మర్చిపోకుండా ఉండటం చాలా ముఖ్యం . దీని అర్థం, అవసరమైతే, మీరు దానిలో కన్స్ట్రక్టర్లు మరియు పద్ధతులను నిర్వచించవచ్చు. ఉదాహరణకు, మునుపటి కోడ్ ఫ్రాగ్‌మెంట్‌లో, మేము కేవలం విలువలను పేర్కొన్నాము: జనవరి, ఫిబ్రవరి, మార్చి. Monthఅయితే, మేము మా ఎన్యూమ్ను ఇలా విస్తరించవచ్చు :

public enum Month {

   JANUARY("January", 31),
   FEBRUARY("February", 28),
   MARCH("March", 31),
   APRIL("April", 30),
   MAY("May", 31),
   JUNE("June", 30),
   JULY("July", 31),
   AUGUST("August", 31),
   SEPTEMBER("September", 30),
   OCTOBER("October", 31),
   NOVEMBER("November", 30),
   DECEMBER("December", 31);

   private String name;
   private int daysCount;

   Month(String name, int daysCount) {
       this.name = name;
       this.daysCount = daysCount;
   }

   public static Month[] getWinterMonths() {

       return new Month[]{DECEMBER, JANUARY, FEBRUARY};
   }

   public static Month[] getSummerMonths() {

       return new Month[]{JUNE, JULY, AUGUST};
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getDaysCount() {
       return daysCount;
   }

   public void setDaysCount(int daysCount) {
       this.daysCount = daysCount;
   }

   @Override
   public String toString() {
       return "Month{" +
               "name='" + name + '\'' +
               ", daysCount=" + daysCount +
               '}';
   }
}

ఇక్కడ మేము మా enum2 ఫీల్డ్‌లను (నెల పేరు మరియు రోజుల సంఖ్య), ఈ ఫీల్డ్‌లను ఉపయోగించే కన్స్ట్రక్టర్, గెటర్/సెట్టర్‌లు, పద్ధతి toString()మరియు 2 స్టాటిక్ పద్ధతులను అందించాము. మీరు గమనిస్తే, దీనితో ఎటువంటి సమస్యలు లేవు. మళ్ళీ, Enumనిజంగా పూర్తి స్థాయి తరగతి:

import java.util.Arrays;

public class Main {

   public static void main(String[] args) {

       System.out.println(Arrays.toString(Month.getSummerMonths()));

   }

}

కన్సోల్ అవుట్‌పుట్:

[Month{name='June', daysCount=30}, Month{name='July', daysCount=31}, Month{name='August', daysCount=31}]

చివరగా, నేను జాషువా బ్లాచ్ రాసిన "ఎఫెక్టివ్ జావా" అనే అత్యంత ఉపయోగకరమైన జావా పుస్తకాన్ని సిఫార్సు చేయాలనుకుంటున్నాను . రచయిత జావా సృష్టికర్తలలో ఒకరు, కాబట్టి మీరు భాష యొక్క సాధనాలను సరిగ్గా మరియు సమర్ధవంతంగా ఎలా ఉపయోగించాలో అతని సలహాను ఖచ్చితంగా విశ్వసించవచ్చు :) మా పాఠానికి సంబంధించి, మీరు పుస్తకంలోని అధ్యాయానికి ప్రత్యేక శ్రద్ధ వహించాలని నేను సిఫార్సు చేస్తున్నాను Enum. సంతోషంగా చదవండి! :)