PJJ - přednáška 7

Programovací jazyk Java

7. přednáška

Obsah

Enumerace (výčty)
Generické typy v třídách a metodách

Enumerace (výčty)

Enumerace jsou datový typ definující symbolická jména a jejich hodnoty. Enumerace mohou nahrazovat konstanty (int, String), které nejsou typově bezpečné. Například:

public class Obdobi {
   public static final int JARO = 0;
   public static final int LÉTO = 1;
   public static final int PODZIM = 2;
   public static final int ZIMA = 3;
}

Enumerace se vytvářejí pro skupiny souvisejících konstant. Uvozují se klíčovým slovem enum. V nejjednodušší variantě může být enumerace definována pouhým výčtem hodnot:
```
public enum Obdobi {
   JARO, LÉTO, PODZIM, ZIMA;
}
	
```
Překladač skrytě vytvoří potomka třídy Enum, avšak nelze použít zápis public class Obdobi extends Enum {...}.

Konstanty výčtových typů je možné používat nejenom k uchovávání hodnot a k jejich případnému porovnávání v příkazech if nebo while, ale je je možné použít také v příkazu switch a cyklu for:

public class Jablon {

   static Obdobi o;

   public static String cinnost(Obdobi obdobi) {
      switch (obdobi) {
         case JARO:
            return "kvete";
         case LÉTO:
            return "zraje";
         case PODZIM:
            return "plodí";
         case ZIMA:
            return "spí";
         default:
            // Překladač nekontroluje, zda jsme vyčerpali všechny možnosti, a může se chybně
            // domnívat, že existuje ještě nějaká cesta, kterou jsme nepokryli.
            throw new IllegalArgumentException("Neočekávaná hodnota parametru období = " + obdobi);
      }
   }

   public static String vyjmenuj() {
      String s = "";
      for (Obdobi obd : Obdobi.values()) {
         s += obd + " ";
      }
      return s;
   }

  public static void main(String[] args) {
    o = Obdobi.PODZIM;                 // Přístup ke konstantě je skrze název třídy.
    System.out.println(cinnost(o));    // Vypíše plodí
    System.out.println(o.name());      // Vypíše PODZIM
    System.out.println(o.ordinal());   // Vypíše 2
    System.out.println(o.toString());  // Vypíše PODZIM

    System.out.println(vyjmenuj());    // Vypíše JARO LÉTO PODZIM ZIMA
  }
}

Přestože každá proměnná typu enumerace je referencí na objekt (typu enum), nevoláme při jejím vytvoření konstruktor.
Každý výčtový typ dědí z třídy Enum několik metod.
Enumerace jsou v Javě od verze 5.

Složitější definice výčtového typu

Výčtové typy mohou obsahovat i vlastní metody a definované konstanty mohou využívat konstruktory s dalšími parametry. Podmínkou je, aby
- výčet konstant byl v enumeraci uveden jako první a
- výčet konstant byl zakončen středníkem.

Všimněte si, jak jsou předávány parametry konstruktoru – za definovanou konstantu se pouze vloží závorky a za ně se vypíší hodnoty předávaných parametrů:

public enum Smer8 {

   VÝCHOD(1, 0, "S", "VYCHOD"),
   SEVEROVÝCHOD(1, -1, "SV", "SEVEROVYCHOD"),
   SEVER(0, -1, "S", "SEVER"),
   SEVEROZÁPAD(-1, -1, "SZ", "SEVEROZAPAD"),
   ZÁPAD(-1, 0, "Z", "ZAPAD"),
   JIHOZÁPAD(-1, 1, "JZ", "JIHOZAPAD"),
   JIH(0, 1, "J", "JIH"),
   JIHOVÝCHOD(1, 1, "JV", "JIHOVYCHOD"),
   ŽÁDNÝ(0, 0, "@", "ZADNY");

   private int dx, dy;
   private String zkratkaSmeru, smer;

   private Smer8(int dx, int dy, String zkratkaSmeru, String smer) {
      this.dx = dx;
      this.dy = dy;
      this.zkratkaSmeru = zkratkaSmeru;
      this.smer = smer;
   }
  
   public double delkaPosunu() {
      return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
   }
}

Ukázka použití:

public class Posun {

   public static void main(String[] args) {
      Smer8 smer = Smer8.SEVER;
      System.out.println(smer.delkaPosunu());  // Vypíše 1
      smer = Smer8.JIHOVÝCHOD;
      System.out.println(smer.delkaPosunu());  // Vypíše 1.4142135623730951
      System.out.println(smer.name());         // Vypíše JIHOVÝCHOD
      System.out.println(smer.ordinal());      // Vypíše 7
      System.out.println(smer.toString());     // Vypíše JIHOVÝCHOD. Tuto metodu lze (jako jednu z mála) v enumeraci překrýt.
   }
}

Jelikož každá proměnná typu enumerace je referencí na objekt (typu enum), můžeme přistupovat k jejím metodám a atributům.

Konstanty anonymních typů

Někdy potřebujeme, aby instance výčtového typu nepředstavovaly datový, ale funkční objekt, tj. aby se jednotlivé instance lišily chováním svých metod.
Příslušné metody pak uvedeme přímo u každé konstanty ve výčtu konstant.
Výsledkem pak bude to, že jednotlivé instance výčtového typu budou různých typů. Budou se vzájemně lišit chováním svých metod, neboť se ve skutečnosti bude jednat o instance různých anonymních tříd.

Příklad:

public enum Operator {

  SOUČET('+') {
    @Override
    double proved(double x, double y) {
      return x + y;
    }
  },

  ROZDÍL('-') {
    @Override
    double proved(double x, double y) {
      return x - y;
    }
  },
  
  SOUČIN('×') {
    @Override
    double proved(double x, double y) {
      return x * y;
    }
  },

  PODÍL(':') {
    @Override
    double proved(double x, double y) {
      return x / y;
    }
  },

  MOCNĚNÍ('^') {
    @Override
    double proved(double x, double y) {
      return Math.pow(x, y);
    }
  },

  ODMOCNĚNÍ('\u221A') { //Znak pro odmocninu
    @Override
    double proved(double x, double y) {
      return Math.pow(y, 1 / x);
    }
  };
  
  private final char znak;

  private Operator(char znak) {
    this.znak = znak;
  }

  @Override
  public String toString() {
    return "" + znak;
  }
  
  abstract double proved(double x, double y);
}

Program

public class VyzkousejOperator {

  public static void main(String[] args) {
    int x = 2, y = 10;
    for (Operator o : Operator.values()) {
      System.out.println(x + " " + o.toString() + " " + y + " = " + o.proved(x, y));
    }

    for (Operator o : Operator.values()) {
      System.out.println(o.name()
          + " je konstantou třídy " + o.getDeclaringClass().getName()
          + ", ale instancí třídy " + o.getClass().getName());
    }
  }
}

pak vypíše:

2 + 10 = 12.0
2 - 10 = -8.0
2 × 10 = 20.0
2 : 10 = 0.2
2 ^ 10 = 1024.0
2 √ 10 = 3.1622776601683795
SOUČET je konstantou třídy Operator, ale instancí třídy Operator$1
ROZDÍL je konstantou třídy Operator, ale instancí třídy Operator$2
SOUČIN je konstantou třídy Operator, ale instancí třídy Operator$3
PODÍL je konstantou třídy Operator, ale instancí třídy Operator$4
MOCNĚNÍ je konstantou třídy Operator, ale instancí třídy Operator$5
ODMOCNĚNÍ je konstantou třídy Operator, ale instancí třídy Operator$6

Výčtový typ a datové struktury

Pro použití výčtových typů v množinách (rozhraní Set) či mapách (rozhraní Map), poskytuje Java v balíčku java.util speciální rychlé implementace množiny a mapy – třídy EnumSet a EnumMap.
Kolekce EnumMap představuje mapu, jejímiž klíči jsou konstanty nějakého výčtového typu. Hodnotami mohou být libovolné objekty.

Ukázka použití třídy EnumMap:

import java.util.EnumMap;

enum Obdobi {
   JARO, LÉTO, PODZIM, ZIMA;
}

public class EnumMapPokus {

   public static void main(String[] args) {
      EnumMap em = new EnumMap(Obdobi.class);
      em.put(Obdobi.JARO, "Otepluje se");
      em.put(Obdobi.PODZIM, "Ochlazuje se");
                
   }
}

Kolekce EnumSet představuje množinu, jejíž prvky jsou konstanty výčtového typu.
Metody třídy EnumSet:
- allOf(Class e) – vytvoří množinu obsahující všechny konstanty výčtového typu určeného class-objektem e.
- noneOf(Class e) – Vytvoří prázdnou množinu hodnot výčtového typu určeného classobjektem e.
- of(E p, E... o) – Vytvoří množinu obsahující zadané konstanty výčtového typu E.
- range(E od, E do) –Vytvoří množinu obsahující všechny konstanty výčtového typu E ze zadaného rozsahu.

Pokud budeme mít např. výčtový typ public enum DnyVTydnu {PO, UT, ST, CT, PA, SO, NE}, můžeme vyzkoušet provést následující metody:

import java.util.EnumSet;

public class Mnozina {
   public static void main(String[] args) {
      EnumSet vsechny = EnumSet.allOf(DnyVTydnu.class);
      EnumSet nektere = EnumSet.of(DnyVTydnu.PA, DnyVTydnu.SO, DnyVTydnu.NE);
      EnumSet rozsah = EnumSet.range(DnyVTydnu.PO, DnyVTydnu.PA);
      System.out.println(vsechny);
      System.out.println(nektere);
      System.out.println(rozsah);
   }
}

Generické typy

Používají se k bližší specifikaci typu objektu.
Nejčastější použití je právě v kontejnerech.
Pracujeme-li v programu s nějakým seznamem, víme jenom, že je to seznam objektů a nic víc. Samozřejmě si můžeme bokem pamatovat, že tam ukládáme jenom řetězce, ale to nic nemění na tom, že runtime systému je srdečně jedno, jaké objekty do seznamu vkládáme. Stejně tak, chceme-li z tohoto seznamu číst, získáváme zase jenom obecné objekty, které musíme explicitně přetypovat na řetězec (tj. třídu String). A opět – ačkoliv jako programátoři víme, co v seznamu má být, obecně si nemůžeme být jisti, zda to tam skutečně je. Což vede buď k tomu, že se budeme ptát, zda získávaný objekt je skutečně řetězcem, a až poté jej přetypujeme, nebo budeme „riskovat“ runtime výjimku ClassCastException. Jak vidíme, nevýhody jsou, a to docela významné.
Použití generických typů zaručuje typovou bezpečnost kolekce, to znamená, že pokud se pokusíme přidat do těchto kolekcí něco jiného, než jsme nadefinovali, je ohlášena chyba již při kompilaci. Bez použití generických typů by se při snaze přetypovat prvek seznamu na nekompatibilní objektový typ projevila chyba až při běhu programu).
Pro vytvoření seznamu s generickým typem použijeme následující příkaz:
List <String> seznam = new ArrayList<String>();
Takto vytvořený seznam pracuje jen s objekty typu String. Při získávání prvků ze seznamu je tedy nemusíme přetypovat.
Při procházení kolekcí můžeme použít „foreach“ cyklus:
for (String s : seznam) { ... }

Obecná metoda na výpis prvků seznamu; prvky mohou být libovolného typu:

public static void printList(List<?> list) {
   for (Object elem: list) {
      System.out.print(elem + " ");
   }
}
	  
List<Integer> li = Arrays.asList(1, 2, 3);
List<String>  ls = Arrays.asList("one", "two", "three");
printList(li);
printList(ls);

Nyní si představme, že chceme metodu, která udělá z nějakého seznamu čísel jeho sumu. Uvažujme tedy následující (a pomiňme možné přetečení nebo podtečení rozsahu double):
```
public static double suma(List<Number> cisla) {
   double result = 0;
   for (Number e : cisla) {
      result += e.doubleValue()
   }
   return result;
}
```
Chceme-li však použit seznam List<Integer> jako parametr metody suma, nelze jej použít!!!

Proč?

Třída Integer je sice podtřídou třídy Number, avšak třída (kolekce) List<Integer> není podtřídou třídy List<Number>. Správná definice hlavičky metody suma je:
public static double suma(List<? extends Number> cisla) { ... }
Pak je možné při volání metody suma použít jako parametr seznam jakýchkoliv objektů, které jsou potomky třídy Number. (Pokud by třída Number nebyla abstraktní, bylo by možné použít i její instance.)

Generické třídy

Generické třídy umožňují ponechal volbu typu objektu (tedy třídy), se kterou bude třída pracovat, až na okamžik vytvoření instance. Pak se ale lze již spolehnout na kompilátor, který zabrání použití nekompatibilních typů.

Příklad, kdy NENÍ použit generický typ:

class Trida {

   private Object prvekX;
   private Object prvekY;

   public Trida(Object valX, Object valY) {
      prvekX = valX;
      prvekY = valY;
   }

   public void setElements(Object valX, Object valY) {
      prvekX = valX;
      prvekY = valY;
   }

   public Object getElementX() {return prvekX;}
   
   public Object getElementY() {return prvekY;}
   
   public static void main(String[] args) {
      Trida t = new Trida("A", "B");
      ...
      Integer i = (Integer)t.getElementX();
      // Předchozí příkaz půjde zkompilovat,
      // ale za běhu způsobí výjimku ClassCastException.
      }
   
}

Příklad, kdy JE použit generický typ:

class GenerickaTrida<T> {

   private T prvekX;
   private T prvekY;

   public GenerickaTrida(T valX, T valY) {
      prvekX = valX;
      prvekY = valY;
    }

    public void setElements(T valX, T valY) {
        prvekX = valX;
        prvekY = valY;
    }

   public T getElementX() {return prvekX;}
   
   public T getElementY() {return prvekY;}
    
   public static void main(String[] args) {
      GenerickaTrida<String> t = new GenerickaTrida<String>("A", "B");
      Integer i = (Integer)t.getElementX();
      // Předchozí příkaz nepůjde zkompilovat
      // kvůli chybě "incorvetible types".
   }
}

Generické metody

Příklad 1:

static void fromArrayToCollection(Object[] a, Collection<?> c) {
   for (Object o : a) {
      c.add(o);	// chyba při překladu: incompatible types
   }
}

static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
   for (T o : a) {
      c.add(o); // kompilátor OK
   }
}

Příklad 2:

public static <U> void zjistiTridu(U u){
   System.out.println("U: " + u.getClass().getName());
}
    
public static void main(String[] args) {
   zjistiTridu(5); // vypíše "U: java.lang.Integer"
   zjistiTridu(5L); // vypíše "U: java.lang.Long"
   zjistiTridu(5.0); // vypíše "U: java.lang.Double"
   zjistiTridu(5F); // vypíše "U: java.lang.Float"
   zjistiTridu(5 + ""); // vypíše "U: java.lang.String"
}

Příklad 3:

static <T extends Comparable> T max(T t1, T t2) {
   if (t1.compareTo(t2) > 0) {
      return t1;
   } else {
      return t2;
   }
}

public static void main(String[] args) {
   System.out.println(max("A", "B"));
   System.out.println(max(9, 4));
}

Příklad 4:

public <T, S extends T> void copy(List<T> dest, List<S> source) {
	...
}

Wildcards (The Java™ Tutorials)

The End