5. diel - Hracia kocka v Jave druhýkrát - Prekrývanie metód a random

V minulej lekcii, Hracia kocka v Jave - Zapuzdrenie a konštruktor, sme začali vytvárať prvý poriadny objekt, bola ním hracia kocka.

V tomto tutoriáli objektovo orientovaného programovania v Jave budeme pokračovať v tvorbe našej objektovej hracej kocky. Začneme s metódou pre hod. Vysvetlíme si na nej prácu s náhodnými číslami a potom preskúmame princípy prekrývania metód.

Náhodné čísla

V Jave máme pre generovanie náhodných čísel k dispozícii triedu Random. Aby sme ju mohli používať, musíme si triedu java.util.Random v súbore RollingDie.java najprv naimportovať. Import napíšeme hore, ako sme zvyknutí z používania importu pre Scanner. Následne pridáme triede RollingDie privátny atribút random typu Random, kde bude náhodný generátor čísel:

import java.util.Random;

/**
 * Class representing a die for a board game
 */
public class RollingDie {
    /**
     * Random number generator
     */
    private Random random;
    /**
     * Number of sides that the die has
     */
    private int sidesCount;

Ďalej v konštruktoroch vytvoríme inštanciu triedy Random. Upravené konštruktory budú vyzerať nasledovne:

/**
 * Creates an instance of a new rolling die
 */
public RollingDie() {
    sidesCount = 6;
    random = new Random();
}

/**
 * Creates an instance of a new rolling die
 *
 * @param sidesCount Number of sides the die has
 */
public RollingDie(int sidesCount) {
    this.sidesCount = sidesCount;
    random = new Random();
}

Hod kockou

Teraz môžeme v triede RollingDie definovať ďalšiu metódu. Nazveme ju roll():

/**
 * Rolls a die
 *
 * @return A number from 1 to sides count
 */
public int roll() {
    return random.nextInt(sidesCount) + 1;
}

Metóda nám vráti náhodné číslo od jednej do počtu strán, bude public (bude ju možné volať zvonku triedy) a nebude mať žiaden parameter. Návratová hodnota bude typu int. Náhodné číslo získame tak, že na generátore random zavoláme metódu nextInt(). Tá má dve preťaženia:

• nextInt() – Varianta bez parametra vracia náhodné číslo v celom rozsahu dátového typu int, konkrétne teda od -2147483648 do 2147483647.
• nextInt(do) – Vracia nezáporné čísla menšie než hranica do. Napríklad random.nextInt(100) teda vráti číslo od 0 do 99.

Pre naše účely sa najlepšie hodí druhé preťaženie. Dajte si pozor, aby ste netvorili generátor náhodných čísel v metóde, ktorá má náhodné číslo vracať, teda že by sa pre každé náhodné číslo vytvoril nový generátor. Výsledné čísla potom nie sú takmer náhodné alebo dokonca vôbec. Vždy si vytvorte jednu zdieľanú inštanciu generátora (napr. do privátneho atribútu pomocou konštruktora) a na tej potom metódu nextInt() volajte.

Prekrývanie metódy toString()

Kocka je takmer hotová, ukážme si ešte jednu užitočnú metódu, ktorú jej pridáme a ktorú budeme hojne používať aj vo väčšine našich ďalších objektov. Reč je o metóde toString(), o ktorej sme sa už zmienili a ktorú obsahuje každý objekt, teda aj naša kocka. Metóda je určená na to, aby vrátila tzv. textovú reprezentáciu inštancie. Hodí sa vo všetkých prípadoch, keď si inštanciu potrebujeme vypísať alebo s ňou pracovať ako s textom. Tieto metódy majú napr. aj čísla. Už vieme, že v Jave funguje implicitná konverzia – akonáhle teda budeme chcieť do konzoly vypísať objekt, Java na ňom zavolá metódu toString() a vypíše jej výstup. Ak si robíme vlastnú triedu, mali by sme zvážiť, či sa nám takáto metóda nehodí. Nikdy by sme si nemali robiť vlastnú metódu, napr. niečo ako print(), keď máme v Jave pripravenú cestu, ako to riešiť. U kocky nemá metóda toString() vyšší zmysel, ale u bojovníka bude určite vracať jeho meno. My si ju ku kocke aj tak pridáme – bude vypisovať, že ide o kocku a vráti aj počet stien. Najprv si skúsme vypísať do konzoly našu inštanciu kocky:

{JAVA_OOP}
{JAVA_MAIN_BLOCK}

        RollingDie sixSided = new RollingDie();
        RollingDie tenSided = new RollingDie(10);

        System.out.println(sixSided);
{/JAVA_MAIN_BLOCK}
{/JAVA_OOP}
{JAVA_OOP}
import java.util.Random;

public class RollingDie {

    private Random random;
    private int sidesCount;

    public RollingDie() {
        sidesCount = 6;
        random = new Random();
    }

    public RollingDie(int sidesCount) {
        this.sidesCount = sidesCount;
        random = new Random();
    }

    public int getSidesCount() {
        return sidesCount;
    }

    public int roll() {
        return random.nextInt(sidesCount) + 1;
    }

}

{/JAVA_OOP}

Do konzoly sa vypíše iba cesta k našej triede, teda com.ictdemy.RollingDie, a tzv. hash kód objektu. V mojom prípade bol vypísaný tento reťazec:

Konzolová aplikácia
com.ictdemy.RollingDie@7c1c8c58

Metódu toString() už jednoducho nedefinujeme, ale pretože už existuje, musíme ju prepísať, resp. prekryť. Tým sa opäť nebudeme teraz podrobne zaoberať, no chcem, aby sme už teraz vedeli metódu toString() používať. Pre prehľadné prekrytie označíme metódu anotáciou @Override:

{JAVA_OOP}


import java.util.Random;
public class RollingDie {

    private Random random;
    private int sidesCount;

    public RollingDie() {
        sidesCount = 6;
        random = new Random();
    }

    public RollingDie(int sidesCount) {
        this.sidesCount = sidesCount;
        random = new Random();
    }

    public int getSidesCount() {
        return sidesCount;
    }

    public int roll() {
        return random.nextInt(sidesCount) + 1;
    }

    /**
     * Returns a textual representation of our die
     * @return Textual representation of the die
     */
    @Override
    public String toString() {
        return String.format("Rolling die with %s sides", sidesCount);
    }

}

{/JAVA_OOP}
{JAVA_OOP}
{JAVA_MAIN_BLOCK}

        RollingDie sixSided = new RollingDie();
        RollingDie tenSided = new RollingDie(10);
        System.out.println(sixSided);

{/JAVA_MAIN_BLOCK}
{/JAVA_OOP}

Teraz opäť skúsime do konzoly vypísať priamo inštanciu kocky.

Výstup:

Konzolová aplikácia
Rolling die with 6 sides

Ešte si naše kocky vyskúšame. Skúsme si v programe s našimi dvoma kockami v cykloch hádzať a pozrime sa, či fungujú tak, ako sa očakáva:

{JAVA_OOP}
{JAVA_MAIN_BLOCK}
        // Create instances
        RollingDie sixSided = new RollingDie();
        RollingDie tenSided = new RollingDie(10);

        // Rolls the 6-sided die
        System.out.println(sixSided);
        for (int i = 0; i < 10; i++) {
            System.out.print(sixSided.roll() + " ");
        }

        // Rolls the 10-sided die
        System.out.println("\n\n" + tenSided);
        for (int i = 0; i < 10; i++) {
            System.out.print(tenSided.roll() + " ");
        }
{/JAVA_MAIN_BLOCK}
{/JAVA_OOP}
{JAVA_OOP}

import java.util.Random;

public class RollingDie {
    private Random random;
    private int sidesCount;

    public RollingDie() {
        sidesCount = 6;
        random = new Random();
    }

    public RollingDie(int sidesCount) {
        this.sidesCount = sidesCount;
        random = new Random();
    }

    public int getSidesCount() {
        return sidesCount;
    }

    public int roll() {
        return random.nextInt(sidesCount) + 1;
    }

    @Override
    public String toString() {
        return String.format("Rolling die with %s sides", sidesCount);
    }
}

{/JAVA_OOP}

Výstup môže vyzerať nejako takto:

Konzolová aplikácia
Rolling die with 6 sides
3 6 6 1 6 3 6 2 6 3

Rolling die with 10 sides
5 9 9 2 10 4 9 3 10 5

Máme hotovú celkom peknú a nastaviteľnú triedu, ktorá reprezentuje hraciu kocku. Bude sa nám hodiť v našej aréne, ale môžete ju použiť aj kdekoľvek inde. Vidíme, ako OOP umožňuje znovupoužívať komponenty.

V nasledujúcom cvičení, Riešené úlohy k 4.-5. lekcii OOP v Jave, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.