Let's Have an Agreement

Krok 1: Lather, Rinse, Repeat

Určite ste už zaregistrovali, že na overenie správnosti postupu pri riešení misií potrebujete opakovať čím ďalej tým viac operácií po spustení aplikácie: povytvárať potrebné objekty a prepojenia medzi nimi, kontrolovať správanie po volaní metód. Okrem zdĺhavosti celého postupu hrozí aj to, že v reálnom svete bez inšpektora sa budete orientovať s problémami. S cieľom vyhnúť sa tejto situácií teraz predstavíme spôsob, ako scenáre pre testovanie misie vytvárať priamo v kóde.

V ďalších úlohách budete v rámci tejto metódy vkladať do scény ďalších aktérov a plánovať akcie, ktoré budú vykonávať. To znamená, že budete písať scenár.

Pre pridanie nového aktéra do scény potrebujete vytvoriť (alebo už mať k dispozícii) inštanciu daného aktéra a pridať ho do scény na nejakú pozíciu (t.j. definovať umiestnenie ľavého dolného rohu animácie aktéra voči ľavému dolnému rohu mapy scény).

Pridanie a zapnutie reaktora teda môže byť zapísané takto:

Reactor reactor = new Reactor();  // vytvorenie instancie reaktora
scene.addActor(reactor, 64, 64);  // pridanie reaktora do sceny na poziciu [x=64, y=64]
reactor.turnOn();

Implementáciu si overte spustením aplikácie. Reaktor by mal byť hneď po štarte umiestnený na danej pozícií a mal by byť zapnutý.

Akciu Invoke, ktorou je možné docieliť zapnutie chladiča, už poznáte z minulého cvičenia. V knižnici je dostupná aj akcia Wait, ktorá v konštruktore akceptuje dĺžku trvania čakania (v sekundách). So znalosťou týchto dvoch akcií by sme mohli chcieť riešiť túto úlohu nasledovne:

new Wait<>(5).scheduleFor(cooler);
new Invoke<>(cooler::turnOn).scheduleFor(cooler);

Ako sa však budú správať takto naplánované akcie? Scéna bude volať metódu execute() všetkých naplánovaných akcií pred každým vykreslením nového snímku. To znamená, že naplánované akcie sa vykonávajú súbežne. V tomto prípade teda nedocielime to, že sa chladič zapne až po ukončení akcie Wait (ktorá tu bude trvať 5 sekúnd). Namiesto toho bude chladič zapnutý hneď po spustení aplikácie.

Pre riešenie úlohy potrebujeme zapezpečiť spustenie akcie zapnutia chladiča až po ukončení akcie čakania. Za účelom zreťazenia vykonávania viacerých akcií vieme použiť ďalšiu akciu z knižnice - ActionSequence, ktorá v konštruktore akceptuje variabilný počet iných akcií, pre ktoré zabezpečí sekvenčné vykonávanie. Na scéne potom naplánujeme len túto sekvenčnú akciu:

new ActionSequence<>(
    new Wait<>(5),
    new Invoke<>(cooler::turnOn)
).scheduleFor(cooler);

Pri riešení tejto úlohy je potrebné akciou zavolať metódu repairWith(Hammer hammer) na reaktore. Táto metóda očakáva jeden argument - kladivo. To nám umožňuje predstaviť ďalší spôsob, ako je možné zapisovať akcie: pomocou anonymných tried, alebo skrátene pomocou lambda výrazov.

Doteraz ste konštruktor akcie Invoke používali s referenciou na bezparametrickú metódu. Signatúra tohto konštruktora je v knižnici zapísaná takto:

public Invoke(Runnable action)

Runnable je štandardné Java rozhranie, ktoré predpisuje jednu metódu so signatúrou void run(). V kombinácii s možnosťou vytvárať anonymné triedy - triedy zapísané napr. priamo v kóde metódy, kde sa z takejto triedy hneď aj vytvorí jedna inštancia - by sme mohli zapísať akciu pre opravu reaktora kladivom takto:

new Invoke<>(new Runnable() {  // zapiseme priamo implementaciu rozhrania
    public void run() {
        reactor.repairWith(hammer);
    }
});

Týmto zápisom dosiahneme vytvorenie objektu typu Runnable s konkrétnou implementáciou metódy run(). Tento objekt je odovzdaný do konštruktora akcie Invoke a táto akcia je implementovaná tak, že vo svojej execute() metóde zavolá run() metódu na tomto objekte.

Takýto zápis nám poskytuje väčšiu flexibilitu ako používanie referencie na metódu, no zároveň je aj dosť zdĺhavý. Keďže je rozhranie Runnable funkcionálnym rozhraním, t.j., predpisuje práve jednu abstraktnú metódu, môžeme zápis skrátiť použitím lambda výrazu, kde zapíšeme namiesto celej triedy len implementáciu tej jednej abstraktnej metódy. Pre náš príklad bude prepis vyššie uvedenej anonymnej triedy vyzerať takto:

new Invoke<>(() -> {
    reactor.repairWith(hammer);
});

Výsledkom je, rovnako ako v predošlom príklade, vytvorenie objektu typu Runnable (na základe signatúry konštruktora akcie Invoke), ktorý má metódu run() s nami definovanou implementáciou.

Pre riešenie druhej časti úlohy (detekcia momentu, kedy teplota reaktora dosiahne danú teplotu) môžeme zas využiť existujúcu akciu When. Prvým argumentom konštruktora akcie When je jednoduchý predikát. Je to objekt typu Supplier<Boolean> s jednou abstraktnou metódou boolean get(), alebo jemu ekvivalentný lambda výraz. Predikát sa testuje neustále od momentu naplánovania akcie When. V momente, keď prvýkrát vráti true, akcia definovaná v druhom argumente konštruktora akcie When bude vykonaná.

Zápis akcie When v kontexte, kde máme k dispozícií objekty reaktora reactor a kladiva hammer, môže vyzerať nasledovne:

new When<>(
    () -> {
        return reactor.getTemperature() >= 3000;
    },
    new Invoke<>(() -> {
        reactor.repairWith(hammer);
    })
).scheduleFor(reactor);

A keďže telá oboch metód zapísaných v lambdách pozostávajú len z jedného výrazu, Java nám umožňuje zápis skrátiť do nasledovnej ekvivalentnej podoby:

new When<>(
    () -> reactor.getTemperature() >= 3000,
    new Invoke<>(() -> reactor.repairWith(hammer))
).scheduleFor(reactor);

Zápisom rôznych prípadov použitia existujúcich aktérov sa snažte minimalizovať použitie inšpektora.

Krok 2: Switchable

Doteraz sme vedeli ovládať vypínačom len jeden typ zariadení (objektov). Tentokrát sa však pokúsite "prehovoriť" a "dohodnúť" aj s ďalšími objektami, aby sa dali ovládať. Všetko je len otázkou, akú dohodu vo forme rozhrania im ponúknete.

Signatúry metód v tomto rozhraní a ich význam je nasledovný:

• void turnOn() - metóda zapne ovládané zariadenie
• void turnOff() - metóda vypne ovládané zariadenie
• boolean isOn() - metóda vráti hodnotu, ktorá reprezentuje stav zariadenia (true - zariadenie je zapnuté, false - zariadenie je vypnuté)

Metódy, ktoré majú byť súčasťou rozhrania, už v triede máte. Správanie metódy isOn() máte ale implementované metódou isRunning(). Použite možnosti refaktorizácie vo vývojovom prostredí na premenovanie tejto metódy.

Upravte implementáciu triedy PowerSwitch tak, aby mala nasledovné verejné metódy:

• getDevice() - poskytuje referenciu na pripojené zariadenie
• switchOn() - zapína pripojené zariadenie
• switchOff() - vypína pripojené zariadenie

getAnimation().setTint(Color.GRAY);

Pokiaľ tieto triedy už majú implementované požadované metódy, pridajte im anotáciu @Override. Ak majú funkcionalitou podobné metódy, len ich premenujte. Ak však tieto metódy vôbec neexistujú, vytvorte ich.

Správnosť overíte tak, že vytvoríte inštancie uvedených tried a pre každú inštanciu vytvoríte aj príslušný vypínač, pomocou ktorého ho budete vedieť ovládať.

Krok 3: Producer/consumer

Reaktor dokáže v súčasnosti napájať len zariadenia, ktoré sú inštancie triedy Light. Vašou úlohou je pripraviť vhodný "štandard" pre napájanie ľubovoľných zariadení (navrhnúť vzájomne kompatibilné "zásuvky" a "zástrčky").

Rozhranie EnergyConsumer bude mať len jednu metódu. Jej signatúra a význam je nasledovný:

• void setPowered(boolean) - pomocou tejto metódy bude výrobca energie oznamovať zariadeniam, že energia je, resp. nie je dodávaná.

Pokiaľ ste postupovali správne, výsledná funkcionalita sa výrazne nezmení - stále bude svetlo jediným spotrebičom, ktorý je možné pripojiť. Tentokrát ho však reaktor nebude vidieť ako objekt typu Light, ale ako objekt typu EnergyConsumer.

Počítač bude fungovať len v prípade, že je napájaný elektrinou. V opačnom prípade pracovať nebude (pozastaví prehrávanie animácie a výsledky všetkých operácií budú mať hodnotu 0).

Referencie na objekty týchto zariadení nech sa ukladajú do množiny. Využite pritom nasledovný kód na jej vytvorenie:

// deklaracia clenskej premennej pre mnozinu pripojenych zariadeni
private Set<EnergyConsumer> devices;

// vytvorenie instancie mnoziny v konstruktore
// (typovy parameter pre HashSet je odvodeny na zaklade typu premennej devices)
devices = new HashSet<>();

Patrične upravte metódy addDevice() a removeDevice() v triede Reactor. Pre pridanie zariadenia do množiny použite volanie metódy add() na objekte množiny. Metódu removeDevice() upravte na parametrickú, pričom parametrom nech je objekt typu EnergyConsumer. Pre odobratie zariadenia z množiny použite volanie metódy remove(), ktorej v parametri predáte konkrétny objekt, ktorý sa má z množiny odobrať.

Ak ste postupovali správne, budete vedieť k reaktoru tentokrát pripojiť nie len inštancie triedy Light, ale aj inštancie triedy Computer. Tu sa prejavuje polymorfizmus využitím rozhraní.

Krok 4: Useful generalization

V rámci prípravy na reálny svet je určite potrebné zamerať sa aj na "prečistenie" už implementovaného kódu a precvičenie refaktorizácie (zmena štruktúry už implemetovaného kódu pri zachovaní správania). V tomto prípade pôjde o zovšeobecnenie nástrojov na použiteľných aktérov a o otočenie vzťahu medzi iniciátorom použitia a používaným objektom. Rozhraním rozlíšime aj skupinu aktérov, ktoré je možné opraviť.

Rozhranie Usable bude používať typový parameter A, ktorý bude viazaný na podtypy rozhrania Actor:

interface Usable<A extends Actor> {
    // ...
}

V rozhraní potom definujte metódu so signatúrou void useWith(A actor). Aktér dodaný v parametri metódy useWith() bude slúžiť na dodefinovanie kontextu použitia Usable aktéra.

Metódu use() z pôvodnej implementácie BreakableTool upravte tak, aby prekrývala metódu useWith() z rozhrania Usable. Nezabudnite na anotáciu @Override.

Typovým parametrom pre BreakableTool špecifikujte typ aktéra, s ktorým môže daný nástroj pracovať (ktorý vie opraviť; napr. kladivo vie opraviť reaktor).

V jednotlivých nástrojoch prekryte implementáciu metódy useWith() a vykonajte príslušnú opravu.

Nezabudnite upraviť metódy opravy reaktora repairWith() a extinguishWith(), ktoré teraz premenujte na repair() a extinguish(), keďže opravu vyvolajú samotné nástroje kladivo, resp. hasiaci prístroj. Pri týchto upravených metódach využite návratovú hodnotu boolean na signalizáciu úspešnosti, resp. neúspešnosti použitia nástroja.

V rozhraní definujte metódu so signatúrou boolean repair(). Návratová hodnota bude vyjadrovať úspešnosť, resp. neúspešnosť opravy.

Oprava svetla (svetlo prestane blikať) však vydrží len 10 sekúnd a potom sa svetlo opäť pokazí.

Nech Wrench rozširuje triedu BreakableTool a má 2 použitia. Pre jeho grafickú reprezentáciu použite obrázok wrench.

Krok 5: Repository

Zdrojový kód nahrajte aj v prípade, ak ste nestihli dokončiť všetky úlohy. Rozpracované časti, ktoré by mohli spôsobiť kompilačné chyby, odporúčame zakomentovať.