Mga enumerasyon sa Java (java enum)

Kapag nagprograma, madalas nating nakatagpo ang pangangailangan na limitahan ang hanay ng mga wastong halaga para sa isang tiyak na uri ng data. Kaya, halimbawa, ang araw ng linggo ay maaaring magkaroon ng 7 magkakaibang mga halaga, ang buwan ng taon ay maaaring magkaroon ng 12, at ang panahon ay maaaring magkaroon ng 4. Upang malutas ang mga naturang problema, maraming mga statically typed programming languages ​​​​ay nagbibigay ng isang espesyal na uri ng data - enumeration ( enum). Hindi agad lumabas ang enumerasyon sa Java. Ang isang espesyal na pagbuo ng wika enumay ipinakilala simula sa bersyon 1.5. Hanggang sa puntong ito, ang mga programmer ay gumamit ng iba pang mga pamamaraan upang ipatupad ang mga enumerasyon.

pagtatayo ng enum

Magsimula tayo sa isang halimbawa. Ilarawan natin enumang uri ng data para sa pag-iimbak ng season gamit ang:

enum Season { WINTER, SPRING, SUMMER, AUTUMN }

Well, isang simpleng halimbawa ng paggamit nito:

Season season = Season.SPRING;
if (season == Season.SPRING) season = Season.SUMMER;
System.out.println(season);

Bilang resulta kung saan ang SUMMER ay ipi-print sa console . Sa tingin ko ang halimbawa ay halata at hindi nangangailangan ng paliwanag.

Ang Enum ay isang klase

Sa pamamagitan ng pagdedeklara enum, tahasan kaming lumikha ng isang klase na nagmula sa java.lang.Enum. Conventionally, ang construction enum Season { ... }ay katumbas ng class Season extends java.lang.Enum { ... }. At kahit na hindi kami pinapayagan ng compiler na tahasang magmana mula sa java.lang.Enumamin, madali pa ring i-verify na enumminana ito gamit ang reflection:

System.out.println(Season.class.getSuperclass());

Ang mga sumusunod ay ipapakita sa console:

class java.lang.Enum

Ang aktwal na pamana ay awtomatikong ginagawa para sa amin ng Java compiler. Susunod, sumang-ayon tayo na tawagan ang klase na nilikha ng compiler upang ipatupad ang enumeration na enum-class, at ang mga posibleng halaga ng enumerated type bilang enum-a elements.

Ang mga miyembro ng Enum ay mga instance enumng isang -class na statically accessible

Ang mga elemento enum Season (WINTER, SPRING и т.д.)ay statically accessible instance enumng -class Season. Ang kanilang static na availability ay nagpapahintulot sa amin na magsagawa ng mga paghahambing gamit ang reference na operator ng paghahambing ==. Halimbawa:

Season season = Season.SUMMER;
if (season == Season.AUTUMN) season = Season.WINTER;

Pangalan at serial number ng elemento ng enum

Gaya ng nabanggit kanina, any enum-class inherits java.lang.Enum, na naglalaman ng ilang mga pamamaraan na kapaki-pakinabang para sa lahat ng enumerations. Halimbawa:

Season season = Season.WINTER;
System.out.println("season.name()=" + season.name() + " season.toString()=" + season.toString() + " season.ordinal()=" + season.ordinal());

Ang magiging output ay:

season.name()=WINTER season.toString()=WINTER season.ordinal()=0

Ang mga pamamaraan name(), toString()at ipinapakita dito ordinal(). Ang semantika ng mga pamamaraan ay halata. Dapat tandaan na ang mga pamamaraang ito enumay minana mula sa klase java.lang.Enum. Pagkuha ng isang elemento enumsa pamamagitan ng string na representasyon ng pangalan nito Medyo madalas ang gawain arises ng pagkuha ng isang elemento enumsa pamamagitan ng string na representasyon. Para sa mga layuning ito, sa bawat enum-class, ang compiler ay awtomatikong lumilikha ng isang espesyal na static na pamamaraan: public static EnumClass valueOf(String name), na nagbabalik ng isang elemento ng enumeration EnumClassna may pangalan na katumbas ng name. Halimbawa ng paggamit:

String name = "WINTER";
Season season = Season.valueOf(name);

Bilang resulta ng pagpapatupad ng code, ang season variable ay magiging katumbas ng Season.WINTER. Pakitandaan na kung hindi matagpuan ang elemento, isang IllegalArgumentException ang itatapon , at kung ito ay namepantay null, isang NullPointerException ang itatapon . Sa pamamagitan ng paraan, ito ay madalas na nakalimutan. Para sa ilang kadahilanan, marami ang matatag na kumbinsido na kung ang isang function ay tumatagal ng isang argumento at sa ilalim ng ilang mga kundisyon ay nagtatapon ng isang IllegalArgumentException , pagkatapos kapag ipinasa ito doon , isang IllegalArgumentExceptionnull ay tiyak na itatapon din . Ngunit iyon ay lampas sa punto. Ituloy natin. Pagkuha ng lahat ng elemento ng isang enumeration Minsan kailangan mong kumuha ng listahan ng lahat ng elemento ng isang -class sa oras ng pagtakbo. Para sa mga layuning ito, ang compiler ay lumilikha ng isang pamamaraan sa bawat -class . Halimbawa ng paggamit: enumenumpublic static EnumClass[] values()

System.out.println(Arrays.toString(Season.values()));

Nakukuha namin ang output:

[WINTER, SPRING, SUMMER, AUTUMN]

Tandaan na alinman sa pamamaraan valueOf()o pamamaraan values()ay hindi tinukoy sa klase java.lang.Enum. Sa halip, sila ay awtomatikong idinagdag ng tagatala kapag enumang -class ay pinagsama-sama. Pagdaragdag ng iyong sariling mga pamamaraan sa enum-class May pagkakataon kang magdagdag ng iyong sariling mga pamamaraan kapwa sa enum-class at sa mga elemento nito: Pareho, ngunit may polymorphism: Ang huling halimbawa ay nagpapakita ng paggamit ng mana sa enum. Higit pa tungkol dito mamaya. Ang inheritanceenum sa Java enumay nagbibigay-daan sa iyo na magpatupad ng isang class hierarchy, ang mga bagay na kung saan ay nilikha sa isang pagkakataon at ito ay statically accessible. Sa kasong ito, ang mga elemento enumay maaaring maglaman ng kanilang sariling mga konstruktor. Magbigay tayo ng halimbawa: Dito ipinapahayag natin ang isang enumeration Typena may tatlong elemento INT, INTEGERat STRING. Ang compiler ay lilikha ng mga sumusunod na klase at mga bagay:

• Type- klase na nagmula sajava.lang.Enum
• INT— object ng 1st class na nagmula saType
• INTEGER— object ng 2nd class na nagmula saType
• STRING— object ng 3rd class na nagmula saType

Tatlong nagmula na mga klase ay malilikha gamit ang isang polymorphic na pamamaraan Object parse(String)at constructor Type(..., boolean). Kasabay nito, ang mga bagay ng mga klase INT, INTEGERat STRINGumiiral sa isang kopya at static na naa-access. Maaari mong i-verify ito:

System.out.println(Type.class);
System.out.println(Type.INT.getClass() + " " + Type.INT.getClass().getSuperclass());
System.out.println(Type.INTEGER.getClass() + " " + Type.INTEGER.getClass().getSuperclass());
System.out.println(Type.STRING.getClass()  + " " + Type.STRING.getClass().getSuperclass());

Nakukuha namin ang sumusunod na output:

class Type
class Type$1 class Type
class Type$2 class Type
class Type$3 class Type

Makikita na ang compiler ay lumikha ng isang klase Typeat 3 nestedklase na nagmula sa Type.

Na-decompiled ang enum-class na may mana

Upang kumpirmahin ang nasa itaas, ipinapakita rin namin ang resulta ng pag-decompile ng enumeration Typemula sa halimbawa sa itaas:

Mga enumerasyon at parametric polymorphism

Maaaring magtaka ang mambabasa: " Bakit hindi gumagamit ng generics ang Type enumeration sa itaas ? Ang katotohanan ay sa Java ang paggamit ng mga generic ay enumipinagbabawal. Kaya ang sumusunod na halimbawa ay hindi mag-compile:

enum Type<T> {}

Karagdagang Pag-aaral

Para sa mas malalim na pag-unawa sa kung paano gumagana ang mga enumerasyon sa Java, inirerekumenda kong pamilyar ka sa source code ng klase java.lang.Enum, at gamitin din ang Jad decompiler upang pag-aralan ang nabuong code. Bukod dito, ang pag-aaral sa source code ng Java library ay talagang kailangan para maunawaan kung gaano karaming mga mekanismo sa Java ang gumagana at ito ay kapaki-pakinabang bilang isang sanggunian para sa object-oriented na disenyo. Link sa orihinal na pinagmulan: http://alexander.lds.lg.ua/