====== Reversi III ======

  * Reversi 
    * diskuse problémů prvního odevzdání
  * Java tutoriálek
  * Testík
  * Hádanka

===== Reversi =====
  * Individuální kontrola hráčů




====== Java tutoriálek ======
V této části jsme pro vás sromáždili informace, o kterých si myslíme, že by se vám mohly hodit. 
===== Komparátory a další užitečné konstrukce v Javě =====



== Interface ==

  * Java nepodporuje vícenásobnou dědičnost (jedna třída nemůže mít více než jednoho rodiče) -> místo toho rozhraní (interface)
  * Interface může definovat pouze abstraktní metody (bez těla) nebo konstanty (od Javy 8 přibyly tzv. [[http://zeroturnaround.com/rebellabs/java-8-explained-default-methods/|defaultní metody]]).
  * Třída může implementovat (pomocí klíčového slova //implements//) i více rozhraní. 
  * Třída musí implementovat všechny metody, jejichž hlavičky jsou v rozhraní.

++++ Příklad |
<code java>
public interface Predator {
       boolean chasePrey(Prey p);
       void eatPrey(Prey p);
}

public interface Prey {
       void hide();
       void run();
}

abstract public class Animal {
      abstract public void talk();
      public Position getLocation(){...}
}

/** Trida implementujici dve interface a dedici od abstraktni tridy */
public class Frog extends Animal implements Predator, Prey { 
      /** nutna definice metod abstraktni tridy */
      public void talk(){...}
      
      /** nutna definice metod od interface */
      public boolean chasePrey(Prey p) {...} 
      public void eatPrey (Prey p) {...}      
      public void hide() {...}      
      public void run() {...}     
}
</code>
++++

   * **Abstraktní třída vs. Interface**

|            ^ Interface    ^ Abstraktní třída  ^
^ Dědičnost  | Lze implementovat více než jedno //interface//  | Třída může rozšiřovat pouze jednu //abstract// třídu  |
^ Implementace metod  | Žádné metody nemohou být implementovány (od Javy 8 mohou!)  | Lze implementovat těla metod neoznačených jako //abstract//  |
^ Proměnné  | Lze definovat pouze //static final// konstanty  | Lze definovat jak konstanty tak členské proměnné  |
^ Použití  | Většinou definuje spíše vlastnosti třídy než rozšíření vlastností jiné třídy. Např. //Comparable//, //Iterable//, //Runnable//  | Definuje příslušnost třídy k super třídě, rozšiřuje její vlastnosti. Např. //List// -> //LinkedList//, //Player// -> //MyPlayer//|

==Vybrané metody třídy Collections ==
V třídě [[http://docs.oracle.com/javase/6/docs/api/java/util/Collections.html|Collections]] se nacházejí užitečné statické metody pro páci s třídami typu //Set//, //List//, //Map// a třídami od nich odvozenými.
> {{page>courses:a4b99rph:internal:cviceni:tyden11#Collections}}

   * void **copy**(List<? super T> dest, List<? extends T> src) 
       * zkopíruje všechny prvky ze seznamu //src// (typu T nebo odvozených od T) do seznamu //dest// (typu T nebo nadtřídy T)
++++ příklad |
 <code java>
List<String> src = new ArrayList<String>();
src.add("a");	src.add("b");	src.add("c");

List<String> dst = new ArrayList<String>();
dst.add("e");	dst.add("f");	dst.add("g");

Collections.copy(dst,src);
System.out.println(dst.toString());  // [a, b, c]
</code>
++++
   * T **max**(Collection<? extends T> coll) 
       * vrátí maximální prvek ze seznamu. Uvažuje přirozené řazení (tj. buď podle abecedy nebo velikosti)
   * T **max**(Collection<? extends T> coll, Comparator<? super T> comp) 
       * vrátí maximální prvek ze seznamu, kde pořadí prvků je definováno třídou //Comparator//
   * void **reverse**(List<?> list) 
       * obrátí pořadí prvků v listu
   * void **sort**(List<T> list) 
       * seřadí prvky listu vzestupně podle přirozeného řazení (tj. buď podle abecedy nebo s rostoucí velikostí)
   * void **sort**(List<T> list, Comparator<? super T> c) 
       * seřadí prvky listu podle pořadí definovaného třídou //Comparator//

== Comparator a Comparable interface ==
Pro porovnávání dvou prvků a zároveň i definici jejich pořadí v seznamech lze v Javě použít dva přístupy.

  * **Comparable** objekt je schopen porovnat sám sebe s jiným objektem. Takovýto objekt musí implementovat //Comparable// interface. Konkrétně musí definovat metodu //int compareTo(Object obj)// - ta porovná daný objekt s objektem //obj// a vrátí <0, 0 nebo >0 podle toho, jetli je daný objekt menší, roven nebo větší než //obj//. Implmentací metody //compareTo// definujeme přirozené uspořádání objektů.

  * **Comparator** je objekt který umožňuje porovnat dva různé objekty. Při jeho implementaci je potřeba přepsat jedinou metodu - //int compare(T o1, T o2)// a to tak, že vrací <0, 0 nebo >0 podle toho, jestli objekt //o1// je menší, roven nebo větší než objekt //o2//.

++++ příklad třídy implementující Comparable |
<code java>
public class Employee implements Comparable<Employee> {
  private int empId;
  private String name;
  private int age;

  /** Porovnani podle cisla zamestnance */
  public int compareTo(Employee o) {
     return this.empId - o.empId ;
  }
  ...
}
</code>
++++
++++   příklad Comparatoru |
<code java>
public class EmpSortByNameComparator implements Comparator<Employee>{

  /** Porovna jmena zamestnancu - String implementuje Comparable, proto lze pouzit compareTo() */
  public int compare(Employee o1, Employee o2) {
     return o1.getName().compareTo(o2.getName());
  }
}
</code>
++++
++++   použití: |
<code java>
List<Employee> employees = new ArrayList<Employee>();
employees.add(new Employee(4, "Tomáš", 28));
employees.add(new Employee(1, "Zdeněk", 19));
employees.add(new Employee(2, "Bořek", 34));
employees.add(new Employee(3, "Adam", 40));

Collections.sort(employees); // natural ordering
System.out.println(employees); 

Collections.sort(employees, new EmpSortByNameComparator()); // defined ordering
System.out.println(employees);
</code>
++++

====== Ukázka na práci s datovými strukturami ======
Teď si některé z těchto věcí vyzkoušíte sami. Vaším úkolem bude napsat funkce vyhledávající a třídící automobily v jednoduché databázi.
Stáhněte si připravený {{:courses:a4b99rph:cviceni:files:cars.zip|projekt}}, naimportujte si ho do Vašeho IDE a doplňte těla metod ve třídě **CarsDatabase**. Při implementaci se soustřeďte primárně na efektivitu při volání metod get...().

> {{page>courses:a4b99rph:internal:cviceni:tyden11#cars}}

====== Programovací testík ======

[[courses:a4b99rph:internal:kratke_testiky:tyden_10|Zadání]] na interních stránkách.


====== Hadanka ======


> {{page>courses:a4b99rph:internal:cviceni:tyden11#hadanka}}