Java - abstraktné triedy

Základy informatiky - jazyk Java

---

---

Platforma Java - prehľad

Úvod do programovania v jazyku Java

Java - objektovo orientovaný prístup

>Java - konštruktory
>Java - prístupové metódy
>Java - dedičnosť
>Java - preťažovanie metód
>Java - polymorfizmus
>Java - abstraktné triedy
>Java - rozhrania

Vzorové príklady:

Prvé programy v Jave

Vzorové triedy v Jave

Java applety

Java - desktopové aplikácie

Java - implementácia numerických algoritmov

Java - triedy geometrických tvarov

Pokročilé témy:

Základy práce s NetBeans IDE a vývoj modulov

Abstraktné triedy sa využívajú na definovanie spoločných charakterových rysov podtried. Z abstraktnej triedy sa nedá vytvoriť inštancia (objekt). Môže použiť len ako generická trieda pre ostatné triedy, ktoré ju budú rozširovať.

Definícia abstrakcie

Abstraktná trieda sa deklaruje pomocou kľúčového slova abstract Abstraktrné triedy sa využívajú ako šablóny pre konkrétne podtriedy. Tak ako Každá iná trieda, aj abstraktrná trieda môže obsahovať vlastnosti a metódy, ktoré definujú správanie triedy.

Abstraktná trieda môže taktiež obsahovať metódy bez implementácie. Takéto metódy sa nazývajú abstraktné metódy. Deklarácia abstraktnej metódy musí začínať kľúčovým slovom abstract a za názvom funkcie (a parametrami) nesmie byť telo, ale musí tam byť bodkočiarka.

Ak trieda obsahuje nejaké abstraktné metódy, buď deklarované v aktuálnej triede, alebo zdedené, musí byť deklarovaná ako abstraktná. Abstrakné metódy poskytujú určitú šablónu pre triedy, ktoré sú z pôvodnej (abstraktnej) triedy odvodené.

Z abstraktných tried sa nedajú vytvárať objekty. Abstaktné triedy musia byť použité ako triedy rodičov. Triedy, ktoré sú potomkami abstraktnej triedy buď musia abstraktné metódy implementovať, alebo ich zdedia ako abstatkné a samotná trieda potomka sa stáva abstraktnou.

Príklad abstraktnej triedy:

abstract class GraphicObject {
    int x, y;
    ...
    void moveTo(int newX, int newY) {
        ...
    }
    abstract void draw();
    abstract void resize();
}

Vysvetlenie k predchádzajúcemu zdrojovému kódu:

• Trieda GraphicsObject je abstrakná
• Obsahuje 2 abstraktné metódy: draw a resize
• Metóda moveTo nie je abstraktná (má svoju implementáciu)

Príklad abstraktnej triedy

Zoberme si už preberaný príklad so živočíšnymi druhmi: Zviera-Cicavec-Mačka-Plaz-Vtak. Keďže nemá zmysel vytvárať obejekt typu Zviera, triedu zviera budeme definovať ako abstraktnú:

public abstract class Zviera {
    public String nazov;
    public int vaha;
 
    public Zviera()
    {
        this("Zviera",0);
    }
    public Zviera(String nazov, int vaha) {
        this.nazov = nazov;
        this.vaha = vaha;
    }
    // abstaktné metódy
    public abstract void pohniSa(int k);
    public abstract void prijmiPotravu(int mnozstvo);
    public abstract void rozmnozujSa();
}

Teraz je trieda Zviera abstraktná a už nie je možné vytvárať objekt typu Zviera (Zviera z= new Zviera() ). Ale je možné použiť odkaz ma obejkt typu Zviera pri použití polymorfizmu ( Zviera p= new Plaz() ). Na to, aby celý náš zverinec fungoval treba doplniť triedy Cicavec, Pes, Plaz a Vtak o všetky abstraktné metódy, ktoré zdedili. Toto ilustruje nasledujúci obrázok:

Požiadavka na implementovanie všetkých zdedených abstraktným metód

Trieda Cicavec po doplnení vyzerá nasledovne:

public class Cicavec extends Zviera{
    public int dlzka_gravidity;
    public String typ_srsti;

    public Cicavec() {
        super("Cicavec",1);
        this.dlzka_gravidity = 7;
        this.typ_srsti = "";
    }
    // ostatné metódy sú nezmenené

    @Override
    public void prijmiPotravu(int mnozstvo) {
         System.out.println("Cicavec zozral "+mnozstvo+" kg potravy");
    }

    @Override
    public void rozmnozujSa() {
        System.out.println("Cicavec sa rozmnožuje");
    }
}

Podobne triedy Vtak a Plaz budú vyzerať nasledovne:

public class Vtak extends Zviera {
    public float rozpatie_kridel;
    public int pocet_vajec;

    public Vtak()
    {
        super("Vtak",3);
        this.rozpatie_kridel = 0;
        this.pocet_vajec = 8;
    }
    // ostatné metódy sú nezmenené

    @Override
    public void prijmiPotravu(int mnozstvo) {
         System.out.println("Vtak vyzobal "+mnozstvo+" kg zrna");
    }

    @Override
    public void rozmnozujSa() {
        System.out.println("Vtak sa rozmnožuje kladenim vajec");
    }
}

public class Plaz extends Zviera {

    public float dlzka;
    public String typ;

    public Plaz(String nazov, int vaha, float dlzka, String typ) {
        super(nazov, vaha);
        this.dlzka = dlzka;
        this.typ = typ;
    }
    // ostatné metódy sú nezmenené

    @Override
    public void prijmiPotravu(int mnozstvo) {
         System.out.println("Plaz prehltol "+mnozstvo+" cicavcov");
    }

    @Override
    public void rozmnozujSa() {
        System.out.println("Plaz sa rozmnožuje");
    }
}

Poznámka: Anotácia @Override označuje, že metóda je preťažená. Ak je metóda označená ako @Override a nepreťažuje žiadnu metódu v nadtriede, kompilátor vygeneruje chybu. Ak anotácia @Override pri preťaženej metóde chýba, kompilátor vygeneruje varovanie.

Použite takto upravenej hierarchie tried je podobné ako pri polymorfizme:

public class testZOO {
    public static void main(String[] args) {

        //Zviera z=new Zviera();  CHYBA!!!
        Zviera c = new Cicavec();
        Zviera v = new Vtak();
        Zviera p = new Plaz();

        c.pohniSa(1);
        v.pohniSa(2);
        p.pohniSa(3);

        c.prijmiPotravu(2);
        v.prijmiPotravu(4);
        p.prijmiPotravu(5);

        c.rozmnozujSa();
        v.rozmnozujSa();
        p.rozmnozujSa();
    }
}

Výstup programu je nasledovný:

bežím 1 metrov
letim 2 metrov
plazím sa 3 metrov
Cicavec zozral 2 kg potravy
Vtak vyzobal 4 kg zrna
Plaz prehltol 5 cicavcov
Cicavec sa rozmnožuje
Vtak sa rozmnožuje kladenim vajec
Plaz sa rozmnožuje