புதிய தரவு வகை: எண் அல்லது கணக்கீடு

enum1. எப்படி உருவானது என்பதற்கான பின்னணி

இன்று நாம் ஜாவாவில் மற்றொரு வகையான தரவு வகையை ஆராய்வோம்: 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();