Zobrazit zdroj

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Java]]


== K&nbsp;čemu je? ==
* Výčtový typ slouží zejména v situacích, kdy některý datový typ může nabývat jenom malý počet předem známých hodnot.

<div class="Priklad">
; Příklady využití výčtového typu:
* Dny v týdnu
* Pohlaví
* Typy platby (zde zvážíme, zda radši nepoužít samostatnou třídu s podtřídami)
</div>



== Deklarace výčtového typu ==
* Výčtový typ v Javě se vytváří podobně jako třída.
<div class="Priklad">
 public enum Pohlavi {
     Muz, Zena, Neuvedeno
 }
</div>

== Vytvoření proměnné ==
<div class="Priklad">
 Pohlavi pohlavi = Pohlavi.Muz;
</div>


== Použití výčtového typu ==
<div class="Priklad">
 switch (pohlavi) {
     case Pohlavi.Muz: 
         ''...''
         break;
     case Pohlavi.Zena:
         ''...''
         break;
     case Pohlavi.Neuvedeno:
         ''...''
         break;
 }

 if (pohlavi == Pohlavi.Muz) {...}
</div>


== Šlo by situaci řešit jinak? ==

=== Samostatná třída ===
* Jinou variantou řešení by bylo založit samostatnou třídu a vytvořit pevně definovaný počet instancí.
* Toto řešení vyžaduje více psaní a&nbsp;větší zkušenosti s&nbsp;objektovým programováním.
* Toto řešení je vhodnější, pokud se jednotlivé varianty výrazně liší ve svém chování. Umožní nám vytvořit podtřídy, které si implementují vlastní metody.

<div class="Priklad">
Složitější deklarace:
 public abstract class TypPlatby {
     static TypPlatby Hotove = new TypPlatbyHotove();
     static TypPlatby NaUcet = new TypPlatbyNaUcet();
     
     private TypPlatby() {} ''// Aby si nikdo nemohl svévolně vytvářet nové typy platby''
 
     public abstract void provedPlatbu();
 }

 public class TypPlatbyHotove extends TypPlatby {
     public void provedPlatbu() {
         ''...''
     }
 }

 public class TypPlatbyNaUcet extends TypPlatby {
     public void provedPlatbu() {
         ''...''
     }
 }

Obdobné vytvoření proměnné:
 TypPlatby typPlatby = TypPlatby.Hotove;

A jednoduché použití:
 typPlatby.provedPlatbu();

</div>

* Vidíme, že zápis vyžaduje více řádků kódu, ale použití jednotlivých podtříd úplně odstraní nutnost používat větvení (<code>if</code> nebo <code>switch</code>). Jednotlivé podtřídy jsou proto mnohem přehlednější a řeší vždy jen jeden konkrétní typ platby. 
* Použití bude také snadnější. Srovnejte:

<div class="Priklad">
Jednoduchoučká deklarace
 public enum TypPlatby { Hotove, NaUcet };  

Obdobné vytvoření proměnné:
 TypPlatby typPlatby = TypPlatby.Hotove;

Ale při každém použití pak velký nepřehledný kód (zvláště pokud bude variant placení více a kód platby delší):
 switch (typPlatby) {
     case TypPlatby.Hotove:
         ''...''
         break;
     case TypPlatby.NaUcet:
         ''...''
         break;
 };
</div>

=== Náhrada typem <code>int</code> nebo <code>String</code> ===
* Někoho by možná napadlo použít typ <code>int</code> a&nbsp;každé hodnotě přiřadit číselnou konstantu.
* Tomuto řešení se ale raději vyhneme:
*# svádí zavést do kódu konstanty, jejich význam zná pouze autor,
*# případné překlepy či špatně zadané hodnoty se nezjistí v&nbsp;době překladu, ale až po spuštění aplikace.


== Zdroje ==
* [https://www.algoritmy.net/article/30320/Enum-19 Algoritmy.net &rarr; Java: Enum]