Hi! Sa artikulong ito sasabihin namin sa iyo ang tungkol sa Java Enums . Isipin na binigyan ka ng sumusunod na gawain: lumikha ng klase na nagpapatupad ng mga araw ng linggo . Sa unang sulyap, ito ay tila diretso. Magiging ganito ang hitsura ng iyong code:
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 + '\'' +
'}';
}
}
Mukhang maayos ang lahat, ngunit may isang problema: maaari mong ipasa ang anumang teksto sa tagabuo ng klase ng DayOfWeek . Ibig sabihin, maaaring gumawa ang isang tao ng araw ng linggo na pinangalanang "Frog", "Cloud" o "azaza322". Malinaw na hindi ito ang pag-uugali na inaasahan namin, dahil mayroon lamang 7 totoong araw ng linggo, at bawat isa sa kanila ay may partikular na pangalan. Samakatuwid, ang aming gawain ay upang kahit papaano ay limitahan ang hanay ng mga posibleng halaga para sa klase ng DayOfWeek . Bago dumating ang Java 1.5, kinailangan ng mga developer na mag-iisa na mag-imbento ng sarili nilang mga solusyon sa problemang ito, dahil ang wika ay walang handa na solusyon. Noong mga panahong iyon, kung kailangan ng mga programmer na limitahan ang bilang ng mga halaga, ginawa nila ito:
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 + '\'' +
'}';
}
}
Narito ang dapat mong mapansin:
Ang constructor ay pribado. Kung ang isang constructor ay minarkahan ng pribadong modifier, hindi ito magagamit upang lumikha ng isang bagay. At dahil ang klase ay may isang constructor lamang, walang DayOfWeek object ang maaaring malikha.
public class Main {
public static void main(String[] args) {
DayOfWeek sunday = new DayOfWeek(); // Error!
}
}
Siyempre, ang klase ay mayroong kinakailangang bilang ng mga pampublikong static na bagay, na wastong nasimulan (gamit ang mga tamang pangalan ng mga araw ng linggo).
Pinayagan nito ang mga bagay na ito na magamit sa ibang mga klase.
public class Person {
public static void main(String[] args) {
DayOfWeek sunday = DayOfWeek.SUNDAY;
System.out.println(sunday);
}
}
Output:
DayOfWeek{title = 'Linggo'}
Ang pamamaraang ito ay higit na malulutas ang problema. Mayroon kaming 7 araw ng linggo sa aming pagtatapon, at walang makakagawa ng mga bago. Ang solusyon na ito ay inaalok ni Joshua Bloch sa kanyang aklat na Effective Java . Siyanga pala, ang aklat na iyon ay napaka-cool at kailangang basahin para sa sinumang developer ng Java. Sa paglabas ng Java 1.5, nakakuha ang wika ng isang handa na solusyon para sa mga ganitong sitwasyon: Java Enums . Ang Enum sa Java ay isa ring klase. Ito ay espesyal na "pinong-tune" sa paglutas ng mga problemang tulad nito, ibig sabihin, paglikha ng isang partikular na limitadong hanay ng mga halaga. Ang mga tagalikha ng Java ay mayroon nang mga handang halimbawa (halimbawa, ang C ay mayroon nang enum ), kaya nagawa nilang lumikha ng pinakamahusay na variant.
Ngayon na mukhang mas simple :) Sa panloob, ang aming Enum ay may 7 static na pare-pareho. At iyon ay isang bagay na maaari nating gamitin upang ipatupad ang isang programa. Halimbawa, sumulat tayo ng isang programa na tumutukoy kung ang isang mag-aaral ay kailangang pumasok sa paaralan ngayon. Ang aming mag-aaral ay magkakaroon ng pang-araw-araw na iskedyul, na kinakatawan ng klase ng StudentSchedule :
public class StudentSchedule {
private DayOfWeek dayOfWeek;
// ... other fields
public DayOfWeek getDayOfWeek() {
return dayOfWeek;
}
public void setDayOfWeek(DayOfWeek dayOfWeek) {
this.dayOfWeek = dayOfWeek;
}
}
Tinutukoy ng variable na dayOfWeek ng object ng iskedyul kung aling araw ang ngayon. At narito ang aming klase ng mag-aaral:
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 :(");
}
}
}
Sa paraan ng wakeUp() , ginagamit namin ang Java Enum upang matukoy kung ano ang susunod na dapat gawin ng mag-aaral. Hindi man lang kami nagbigay ng mga detalye tungkol sa bawat field sa DayOfWeek , at hindi namin kailangan: malinaw kung paano dapat gumana ang mga araw ng linggo. Kung gagamitin namin ito sa kasalukuyang anyo nito, mauunawaan ng sinumang developer kung ano ang nangyayari sa aming code. Ang isa pang halimbawa ng kaginhawaan ng Enum ay ang mga constant nito ay maaaring gamitin kasama ang switch statement. Halimbawa, magsulat tayo ng isang programa para sa isang mahigpit na diyeta, kung saan naka-iskedyul ang mga pagkaing ayon sa araw:
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
}
}
}
Isa ito sa mga bentahe ng Enums sa lumang solusyon na ginamit bago ang Java 1.5 — ang lumang solusyon ay hindi magagamit sa switch . Ano pa ang kailangan mong malaman tungkol sa Enum ? Ang Enum ay isang tunay na klase na may lahat ng mga posibilidad na kasama nito. Halimbawa, kung ang kasalukuyang pagpapatupad ng mga araw ng linggo ay hindi sapat, maaari kang magdagdag ng mga variable, constructor, at pamamaraan sa DayOfWeek :
Ngayon ang aming mga Enum constant ay may field ng pamagat , getter, at na-override na toString na paraan. Kung ikukumpara sa mga regular na klase, isang seryosong limitasyon ang inilagay sa Enum — hindi ito maaaring mamana. Bilang karagdagan, ang mga enumerasyon ay may mga katangiang pamamaraan:
values() : nagbabalik ng array ng lahat ng value sa Enum :
public static void main(String[] args) {
System.out.println(Arrays.toString(DayOfWeek.values()));
}
Tandaan:gumagamit kami ng malalaking titik upang tukuyin ang mga field ng Enum . Ang mga ito ay mga constant kaya gumamit sila ng mga all-caps kaysa sa camelCase .
Sa paglabas ng Java 1.5, nakakuha ang wika ng isang handa na solusyon para sa mga ganitong sitwasyon: Java Enums . Ang Enum sa Java ay isa ring klase. Ito ay espesyal na "pinong-tune" sa paglutas ng mga problemang tulad nito, ibig sabihin, paglikha ng isang partikular na limitadong hanay ng mga halaga. Ang mga tagalikha ng Java ay mayroon nang mga handang halimbawa (halimbawa, ang C ay mayroon nang enum ), kaya nagawa nilang lumikha ng pinakamahusay na variant.
GO TO FULL VERSION