Java (II) - 1. lekcia

Obsah prvej lekcie:

• Základy objektovo orientovaného programovania
• Komentáre
• Primitívne dátové typy
• Zoznam vyhradených kľúčových slov (keywords) pre Javu
• Úloha č. 1

Základy objektovo orientovaného programovania

Základy OOP rozdelím na jednotlivé časti, ktoré stručne popíšem tak, ako to uvádza Sun. Túto časť je nutné veľmi dobre pochopiť, lebo od nej sa budú odvíjať ďalšie časti tohoto kurzu. Podrobnejšiu vysvetlím samotnú stavbu a použitie kódu v uvedených príkladoch v ďalšej lekcii. Taktiež napr. polymorfizmus a rozhrania nechám na neskôr.

Objekty

Objekt (object) je základným stavebným kameňom vývoja aplikácii a každý program napísaný v jazyku Java obsahuje minimálne jeden. Je to softwarový zväzok premenných (premenná je pomenovaný kúsok pamäte, ktorá je použitá k uloženiu nejakej informácie alebo dátovej položky) a príbuzných metód (metóda je funkcia definovaná v triede).

Softwarové objekty si môžeme predstaviť ako skutočné objekty z nášho života. Všetko, čo tieto objekty vedia (stav) alebo čo môžu robiť (správanie), je vyjadrené premennými a metódami. Na nižšie uvedenom obrázku je znázornený objekt, kde metódy obklopujú a skrývajú jeho jadro s premennými pred inými objektami. Takéto združovanie premenných do stredu objektu sa nazýva enkapsulácia – zapúzdrenie (encapsulation).

Ako objekt si môžeme predstaviť napr. auto. Tento príklad je len na pochopenie princípu premenných a metód. Stavbu (syntax) kódu si vysvetlíme neskôr.

Príklad č. 1

public class Auto {
    /*
     *  premenne pre ulozenie udajov o aute
     */
    private int rychlost;
    private int pocetNajazdenychKilometrov;

    /*
     *  metoda na zistenie rychlosti auta
     */
    public void zistiRychlost() {
        return rychlost;
    }

    /*
     *  metoda na nastavenie rychlosti auta
     */
    public void nastavRychlost(int novaRychlost) {
        rychlost = novaRychlost;
    }

    /*
     *  metoda, ktora vyvola poruchu auta, ked sa pocet najazdenych km rovna 1000
     */
    public boolean porucha() {
        if(pocetNajazdenychKilometrov == 1000)
            return true;
        else
            return false;     
    }
}

Vo vyššie uvedenom príklade sme použili premenné rychlost a pocetNajazdenychKilometrov. Metódy zistiRychlost, nastavRychlost a porucha predstavujú vlastnosti alebo správanie objektu. Metódy často využívajú premenné k tomu, aby mohly ovplyvniť alebo zmeniť správanie a vlastnosti objektu.

Správy

Objekty vzájomne pôsobia a komunikujú (interakcia – interaction) medzi sebou pomocou správ (messages). Na obrázku dole je uvedená interakcia dvoch objektov pomocou správy. Objekt A môže predstavovať napr. auto a objekt B človeka v aute. Človek chce znížiť rýchlosť auta, a tak pribrzdí, čím pošle správu autu o potrebe zníženia rýchlosti. Inak si interkaciu objektov môžeme vysvetliť ako využitie princípu architektúry klient-server. Klient poslaním správy žiada server o nejakú službu.

Jediný objekt nieje sám o sebe veľmi užitočný. Zvyčajne vystupuje ako komponent väčšieho programu alebo aplikácie, ktorá pozostáva s viacerých objektov. Programátori prostredníctvom interakcie objektov dosiahnu vysokú funkčnosť a viacej úrovňové komplexné správanie.

Triedy

Príklad č. 2 (trieda a objekty)

public class Auto {
	/*
	 *  premenne pre ulozenie udajov o aute
	 */
	private String typAuta;
	private int serioveCislo;
	private int maxRychlost;
	
	/*
	 *  metoda na zistenie typu auta
	 */
	public String zistiTypAuta() {
		return typAuta;
	}
	
	/*
	 *  metoda na zistenie serioveho cisla
	 */
	public int zistiSerioveCislo() {
		return serioveCislo;
	}
	
	/*
	 *  metoda na zistenie maximalnej rychlosti
	 */
	public int zistiMaxRychlost() {
		return maxRychlost;
	}
	
	/*
	 *  metoda na nastavenie typu auta
	 */
	public void nastavTypAuta(String novyTypAuta) {
		typAuta = novyTypAuta;
	}
	
	/*
	 *  metoda na nastavenie serioveho cisla
	 */
	public void nastavSerioveCislo(int noveSerioveCislo) {
		serioveCislo = noveSerioveCislo;
	}
	
	/*
	 *  metoda na nastavenie maximalnej rychlosti
	 */
	public void nastavMaxRychlost(int novaMaxRychlost) {
		maxRychlost = novaMaxRychlost;
	}
	
	/*
	 *  hlavna metoda, ktora je spustena hned po spusteni aplikacie
	 */
	public static void main(String[] args) {
		
		/*
		 *  vytvorenie prveho auta a nastavenie jeho udajov
		 */
		Auto Ferrari = new Auto();
		Ferrari.nastavTypAuta("Ferrari Enzo");
		Ferrari.nastavSerioveCislo(12345);
		Ferrari.nastavMaxRychlost(300);
		
		/*
		 *  vypis udajov prveho auta
		 */
		System.out.println("Typ prveho auta: " + Ferrari.zistiTypAuta());
		System.out.println("Seriove cislo prveho auta: " + Ferrari.zistiSerioveCislo());
		System.out.println("Max. rychlost prveho auta: " + Ferrari.zistiMaxRychlost());
		
		System.out.println();
		
		/*
		 *  vytvorenie druheho auta a nastavenie jeho udajov
		 */
		Auto Porsche = new Auto();
		Porsche.nastavTypAuta("Porsche 911");
		Porsche.nastavSerioveCislo(54321);
		Porsche.nastavMaxRychlost(280);
		
		/*
		 *  vypis udajov druheho auta
		 */
		System.out.println("Typ druheho auta: " + Porsche.zistiTypAuta());
		System.out.println("Seriove cislo druheho auta: " + Porsche.zistiSerioveCislo());
		System.out.println("Max. rychlost druheho auta: " + Porsche.zistiMaxRychlost());
	}

}

Vo vyššie uvedenom príklade je jednoduchá demonštrácia vytvorenia dvoch objektov na základe jednej triedy. Použili sme tri premenné na uloženie údajov o type, sériovom čísle a maximálnej rýchlosti auta. Na nastavenie a zistenie týchto údajov boli použité metódy, tzv. nastavovače (setters od angl. slova set – nastav) a zisťovače (getters od angl. slova get – získaj).

Dedičnosť

Triedy dedia (alebo odvodzujú, angl. inherit) stav a správanie zo svojej základnej triedy (alebo rodičovskej triedy, predka, angl. superclass). Dedením vzniká nová trieda (alebo odvodená trieda, priama podtrieda, priamy potomok, angl. subclass).

Triedy Ferrari, Porsche aj BMW dedia zo základnej triedy Auto stav vo forme premenných (každé auto, či už je to Ferrari, Porsche alebo BMW, má napr. svoje sériové číslo) a správanie vo forme metód (napr. všetky autá dokážu meniť smer jazdy volantom).

Príklad č. 3 (dedičnosť)

Trieda Auto

public class Auto {
	/*
	 *  premenna pre ulozenie serioveho cisla
	 */
	private int serioveCislo;
	
	/*
	 *  metoda na zistenie serioveho cisla
	 */
	public int zistiSerioveCislo() {
		return serioveCislo;
	}
	
	/*
	 *  metoda na nastavenie serioveho cisla
	 */
	public void nastavSerioveCislo(int noveSerioveCislo) {
		serioveCislo = noveSerioveCislo;
	}
}

Trieda Ferrari

public class Ferrari extends Auto {
	/*
	 * premenna pre ulozenie farby nasho Ferrati
	 */
	private String farbaFerrari;
	
	/*
	 *  metoda na zistenie serioveho cisla
	 */
	public String zistiFarbuFerrari() {
		return farbaFerrari;
	}
	
	/*
	 *  metoda na nastavenie serioveho cisla
	 */
	public void nastavFarbuFerrari(String novaFarbaFerari) {
		farbaFerrari = novaFarbaFerari;
	}
}

Trieda Porsche

public class Porsche extends Auto {
	/*
	 * premenna pre ulozenie poctu dveri nasho Porsche
	 */
	private int pocetDveriPorsche;
	
	/*
	 *  metoda na zistenie poctu dveri
	 */
	public int zistiPocetDveriPorsche() {
		return pocetDveriPorsche;
	}
	
	/*
	 *  metoda na nastavenie poctu dveri
	 */
	public void nastavPocetDveriPorsche(int novyPocetDveri) {
		pocetDveriPorsche = novyPocetDveri;
	}
}

Trieda BMW

public class BMW extends Auto {
	/*
	 * premenna pre ulozenie ceny nasho BMW
	 */
	private long cenaBMW;
	
	/*
	 *  metoda na zistenie ceny
	 */
	public long zistiCenuBMW() {
		return cenaBMW;
	}
	
	/*
	 *  metoda na nastavenie ceny
	 */
	public void nastavCenuBMW(int novaCenaBMW) {
		cenaBMW = novaCenaBMW;
	}
}

Trieda TestAut

public class TestAut {
	public static void main(String[] args) {
		
		// vytvorenie objektu mojeFerrari zo subclassu Ferrari
		Ferrari mojeFerrari = new Ferrari();
		
		// nastavenie serioveho cisla cez metodu, ktora bola zdedena zo superclassu Auto
		mojeFerrari.nastavSerioveCislo(11111);
		
		// nastavenie farby cez metodu v subclasse
		mojeFerrari.nastavFarbuFerrari("cervena");
		
		// vypis serioveho cisla a farby
		System.out.println("Seriove cislo Ferrari: " + mojeFerrari.zistiSerioveCislo());
		System.out.println("Farba Ferrari: " + mojeFerrari.zistiFarbuFerrari());
	
		System.out.println();
		
		// vytvorenie objektu mojePorsche zo subclassu Porsche
		Porsche mojePorsche = new Porsche();
		
		// nastavenie serioveho cisla cez metodu, ktora bola zdedena zo superclassu Auto
		mojePorsche.nastavSerioveCislo(22222);
		
		// nastavenie poctu dveri cez metodu v subclasse
		mojePorsche.nastavPocetDveriPorsche(2);
		
		// vypis serioveho cisla a poctu dveri
		System.out.println("Seriove cislo Porsche: " + mojePorsche.zistiSerioveCislo());
		System.out.println("Pocet dveri Porsche: " + mojePorsche.zistiPocetDveriPorsche());
		
		System.out.println();
		
		// vytvorenie objektu mojeBMW zo subclassu BMW
		BMW mojeBMW = new BMW();
		
		// nastavenie serioveho cisla cez metodu, ktora bola zdedena zo superclassu Auto
		mojeBMW.nastavSerioveCislo(33333);
		
		// nastavenie ceny cez metodu v subclasse
		mojeBMW.nastavCenuBMW(1200000);
		
		// vypis serioveho cisla a ceny
		System.out.println("Seriove cislo BMW: " + mojeBMW.zistiSerioveCislo());
		System.out.println("Pocet dveri Porsche: " + mojeBMW.zistiCenuBMW());
	}
}

V tomto príklade je použitých päť zdrojových súborov, pričom každý z nich obsahuje jednu triedu. Príklad spustíme tak, že si v Eclipse vytvoríme projekt, do ktorého pridáme päť tried (5× „File-> New-> Class“), nazveme ich tak, ako to je uvedené v príklade, a vložíme do nich zdrojáky. Aplikáciu spustíme v „Package Exploreri“ cez súbor TestAut.java, ako je to znázornené na nižšie uvedenom obrázku.

Komentáre

Java podporuje tri druhy komentárov (komentáre sú poznámky programátora, ktoré bližšie objasňujú zdrojový kód). Prvé dva sú známe z jazykov C a C++:

// jednoriadkový komentár

/*
 * niekolko
 * riadkovy
 * komentar
 */

Tretím druhom je tzv. javadoc. Je to nástroj pre generovanie API dokumentácie do HTML formátu:

/**
 * javadoc - vsimnite si 
 * dve hviezdicky
 * na zaciatku komentara
 */

V predchádzajúcich príkladoch sme použili prvé dva druhy komentárov a pri nich aj zatiaľ ostaneme.

Primitívne dátové typy

Primitívne dátové typy sú typy hodnôt premenných. Keď deklarujeme premennú, do ktorej budeme ukladať nejaké čislo, musíme uviesť, akého dátového typu bude. Môže byť napr. celočíselného typu (int) alebo to môže byť typ s desatinnou čiarkou (float). Java používa tieto primitívne dátové typy:

* Dátové typy float a double nadobúdajú kladné a záporné hodnoty, kladné a záporné nuly, kladné a záporné nekonečná a NaN (Not-a-Number).

Príklad č. 4 (dátové typy)

public class DatoveTypy {
	// premenne
	private boolean odpovedNaOtazku;
	private byte octet;
	private short maleCislo;
	private int cislo;
	private long velkeCislo;
	private char znak;
	private float maleDesatinneCislo;
	private double velkeDesatinneCislo;
	
	public static void main(String[] args) {
		// vytvorenie objektu 
		// z triedy DatoveTypy
		DatoveTypy mojeDatoveTypy = new DatoveTypy();
		
		System.out.println("Vypis implicitne nastavenych (prednastavenych) hodnot datovych typov: \n");
		System.out.println(mojeDatoveTypy.odpovedNaOtazku);
		System.out.println(mojeDatoveTypy.octet);
		System.out.println(mojeDatoveTypy.maleCislo);
		System.out.println(mojeDatoveTypy.cislo);
		System.out.println(mojeDatoveTypy.velkeCislo);
		System.out.println(mojeDatoveTypy.znak);
		System.out.println(mojeDatoveTypy.maleDesatinneCislo);
		System.out.println(mojeDatoveTypy.velkeDesatinneCislo);
		
		System.out.println();
		
		/*
		 * teraz zmenime hodnoty premennych
		 * vsimnite si, ze pri premennych "velkeCislo"
		 * typu long a "maleDesatinneCislo" typu float
		 * musime na konci cisla uviest malym alebo
		 * velkym pismenom ci sa jedna o long alebo float
		 * 
		 * je to kvoli tomu aby sa dali cisla rozoznat od
		 * inych datovych typov, napr. cislo 3.14 moze byt 
		 * typu float aj typu double; zapisom 3.14F je nam
		 * aj kompilatoru jasne, ze sa jedna o premennu
		 * datoveho typu float
		 * 
		 * pri desatinnych cislach oddelujeme cisla pred
		 * a za desatinnou ciarkou bodkou ako je vidno
		 * pri cisle 3.14
		 */
		mojeDatoveTypy.odpovedNaOtazku = true;
		mojeDatoveTypy.octet = 12;
		mojeDatoveTypy.maleCislo = 10000;
		mojeDatoveTypy.cislo = 100000;
		mojeDatoveTypy.velkeCislo = 1000000000000L; // vsimnite si pismeno "L" na konci
		mojeDatoveTypy.znak = 'x';
		mojeDatoveTypy.maleDesatinneCislo = 3.14F; // vsimnite si pismeno "F" na konci
		mojeDatoveTypy.velkeDesatinneCislo = 3.1415926535897932384626433832795;
		
		System.out.println("Vypis explicitne (nami) nastavenych hodnot datovych typov: \n");
		System.out.println(mojeDatoveTypy.odpovedNaOtazku);
		System.out.println(mojeDatoveTypy.octet);
		System.out.println(mojeDatoveTypy.maleCislo);
		System.out.println(mojeDatoveTypy.cislo);
		System.out.println(mojeDatoveTypy.velkeCislo);
		System.out.println(mojeDatoveTypy.znak);
		System.out.println(mojeDatoveTypy.maleDesatinneCislo);
		System.out.println(mojeDatoveTypy.velkeDesatinneCislo);
	}
}

V tomto príklade sme pristupovali k pemenným priamo cez objekt. Je nutné podotknúť, že takýto spôsob prístupu sa nepoužíva a je nebezpečný, lebo sa ním priamo mení hodnota premennej. Na nastavenie a získanie hodnôt premenných sa používajú gettre a settre, ktoré som už spomínal a použil v predošlých príkladoch.

Implicitné hodnoty dátových členov

Primitívne dátové typy obsahujú východziu počiatočnú hodnotu pokiaľ niesú inicializované na inú hodnotu.

Zoznam vyhradených kľúčových slov (keywords) pre Javu

Zoznam slov, ktoré sú v Jave vyhradené na používanie vlastností tohto jazyka. Postupne sa s nimi oboznámime.

Úloha č. 1

Vyskúšajte všetky uvedené príklady a zoznámte sa s prostredím Eclipse, poprípade NetBeans. Všetky problémy a veci týkajúce sa Javy a tohto kurzu sa budú riešiť na fóre v kategórii Java.