Lekce 2 - První objektová aplikace v Javě - Hello object world
Minulá lekce, Úvod do objektově orientovaného programování v Javě, nás uvedla do objektově orientovaného programování.
Již víme, že objekty mají atributy a metody. Také víme, že k vytvoření objektu vytvoříme nejprve třídu. Ta je vzorem, podle kterého následně tvoříme její instance.
Na začátku kurzu se základními strukturami jazyka Javy jsme si vytvořili program Hello world. Udělejme si nyní podobný program jako úvod do objektově orientovaného programování. Naprogramujme si aplikaci Hello object world!
Založme si novou Java aplikaci tak, jak jsme to dělali doposud.
-
V záložce Project klikneme pravým tlačítkem myši na na balík (package) našeho projektu a vybereme z menu položku New -> Java Class:
- V záložce Projects klikneme pravým tlačítkem myši na balík (package) našeho projektu a vybereme z menu položku New -> Java Class:
Vytvoříme třídu HelloObjects
, ve které obvyklým způsobem
vytvoříme hlavní metodu main()
.
Poté vytvoříme další třídu Zdravic
a potvrdíme. Název
třídy píšeme vždy notací PascalCase
, tedy bez mezer a na
rozdíl od proměnných (ty používají camelCase
) má
každé slovo velké první písmeno, tedy i první. Název je
samozřejmě také bez diakritiky, tu v programu používáme maximálně
uvnitř textových řetězců, nikoli v identifikátorech.
Podle této třídy později vytvoříme objekt zdravic
, který
nás bude umět pozdravit. Vidíme, že se na program již díváme úplně
jinak, za každou akci je zodpovědný nějaký objekt, nestačí pouze něco
"nabušit" do metody main()
. V našem případě vám to může
přijít zbytečné, u složitějších aplikací si to budete pochvalovat
V našem package přibude další soubor .java
a IDE
nám ho otevře. K původnímu souboru HelloObjects.java
s metodou
main()
se můžeme vrátit pomocí záložky nebo přes záložku
Projects.
Podívejme se, co nám IDE vygenerovalo a kód si popišme. Následně si do třídy přidáme vlastní metodu pro pozdravení.
package cz.itnetwork; public class Zdravic { }
Klíčové slovo package
nám označuje tzv. balíček. Stejně,
jako se metody sdružují do tříd, tak se třídy sdružují do balíčků.
Pokud chceme, aby byla naše třída viditelná i ve výchozí třídě, kde
máme metodu main()
, musíme ji mít ve stejném balíčku. To zde
platí, IDE samo novou třídu vloží do toho samého balíčku, vy místo
helloobjects
budete mít název své aplikace, pokud jste ji
nepojmenovali, bude tam pravděpodobně untitled1
.
V package je tedy umístěná samotná třída, která se deklaruje
klíčovým slovem class
. Třída se jmenuje Zdravic
a
je prázdná.
Všimněte si, že kód je téměř stejný, jako ten v
HelloObjects.java
, již tedy rozumíme tomu, co jsme předtím
ignorovali. Náš konzolový program byla vlastně třída umístěná v
package, která obsahovala jednu metodu main()
.
Vidíme, že v Javě se v podstatě neobjektově programovat ani nedá, což je
jen dobře
Nyní si do třídy Zdravic
přidáme metodu
pozdrav()
, bude veřejně viditelná a nebude mít žádnou
návratovou hodnotu ani atributy.
Deklarace metody v Javě je tedy následující:
[modifikátorPřístupu] [návratovýTyp] [názevMetody]([parametry])
Před metodou bude tzv. modifikátor přístupu, v našem případě
public
(veřejná). Metoda nebude vracet žádnou hodnotu, toho
docílíme klíčovým slovem void
. Dále bude následovat samotný
název metody. Metody píšeme stejně jako proměnné velbloudí notací s
malým počátečním písmenem. Závorka s parametry je povinná, my ji
necháme prázdnou, protože metoda žádné parametry mít nebude. Do těla
metody zapíšeme kód pro výpis na konzoli:
Naše třída bude nyní vypadat takto:
public class Zdravic { public void pozdrav() { System.out.println("Hello object world!"); } }
Zde jsme prozatím skončili, přejdeme do souboru
HelloObjects.java
.
Nyní si v těle metody main()
vytvoříme
instanci třídy Zdravic
. Bude to tedy ten objekt
zdravic
, se kterým budeme pracovat. Objekty se ukládají do
proměnných, název třídy slouží jako datový typ. Instance má zpravidla
název třídy, jen má první písmeno malé. Deklarujme si proměnnou a
následně v ní založme novou instanci třídy Zdravic
:
Zdravic zdravic;
zdravic = new Zdravic();
Tyto řádky říkají: "Chci proměnnou zdravic
, ve které bude
instance třídy Zdravic
.". S proměnnými jsme vlastně již takto
pracovali.
Na druhém řádku je klíčové slovo new
, které nám
vytvoří novou instanci třídy Zdravic
. Tuto
instanci přiřadíme do naší proměnné.
Při vytvoření nové instance se zavolá tzv. konstruktor. To je speciální metoda na třídě, proto při vytvoření instance píšeme ty prázdné závorky, jelikož voláme tuto "vytvářecí" metodu. Konstruktor zpravidla obsahuje nějakou inicializaci vnitřního stavu instance (např. dosadí výchozí hodnoty do proměnných). My jsme v kódu žádný konstruktor nedeklarovali, Java si proto vytvořila tzv. implicitní bezparametrický konstruktor. Vytvoření instance objektu je tedy podobné volání metody. Deklaraci můžeme samozřejmě zkrátit na:
Zdravic zdravic = new Zdravic();
Jelikož v proměnné nyní máme opravdu instanci třídy
Zdravic
, můžeme instanci nechat pozdravit. Zavoláme na ni metodu
pozdrav()
a to jako zdravic.pozdrav()
. Kód metody
main()
bude tedy nyní vypadat následovně:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Zdravic zdravic = new Zdravic(); zdravic.pozdrav(); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Zdravic { public void pozdrav() { System.out.println("Hello object world!"); } } {/JAVA_OOP}
Program spustíme a v konzoli se nám zobrazí:
Konzolová aplikace
Hello object world!
Máme tedy svou první objektovou aplikaci!
Dejme nyní naší metodě pozdrav()
parametr
jmeno
, aby dokázala pozdravit konkrétního uživatele. Přejdeme
do souboru Zdravic.java
:
public void pozdrav(String jmeno) { System.out.printf("Ahoj uživateli %s%n", jmeno); }
Vidíme, že syntaxe parametru metody je stejná, jako syntaxe proměnné.
Kdybychom chtěli parametrů více, oddělujeme je čárkou. Upravíme nyní
naši metodu main()
v souboru HelloObjects.java
:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Zdravic zdravic = new Zdravic(); zdravic.pozdrav("Karel"); zdravic.pozdrav("Petr"); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Zdravic { public void pozdrav(String jmeno) { System.out.printf("Ahoj uživateli %s%n", jmeno); } } {/JAVA_OOP}
Náš kód je nyní v metodě a my ho můžeme jednoduše pomocí parametrů volat znovu s různými parametry. Nemusíme 2x opisovat "Ahoj uživateli...". Kód budeme odteď dělit logicky do metod.
Konzolová aplikace
Ahoj uživateli Karel
Ahoj uživateli Petr
Třídě přidáme nějaký atribut, nabízí se atribut text
,
kde bude uložen text pozdravu. Atributy se definují stejně, jako proměnné.
Jako u metod platí, že před ně píšeme modifikátor přístupu. Pokud
modifikátor nenapíšeme, bude atribut přístupný v rámci daného balíčku
(package
), ale mimo něj už nikoliv. K čemu přesně
modifikátory přístupu slouží si řekneme dále v kurzu. Upravme naši
třídu Zdravic
:
public class Zdravic { public String text; public void pozdrav(String jmeno) { System.out.printf("%s %s%n", text, jmeno); } }
Text nyní musíme pochopitelně nastavit vytvořené instanci v
HelloObjects.java
:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Zdravic zdravic = new Zdravic(); zdravic.text = "Ahoj uživateli"; zdravic.pozdrav("Karel"); zdravic.pozdrav("Petr"); zdravic.text = "Vítám tě tu programátore"; zdravic.pozdrav("Richard"); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Zdravic { public String text; public void pozdrav(String jmeno) { System.out.printf("%s %s%n", text, jmeno); } } {/JAVA_OOP}
Výsledek:
Konzolová aplikace
Ahoj uživateli Karel
Ahoj uživateli Petr
Vítám tě tu programátore Richard
Vzhledem k objektovému návrhu není nejvhodnější, aby si každý objekt
ovlivňoval vstup a výstup, jak se mu zachce. Pochopitelně narážím na naše
vypisování do konzole. Každý objekt by měl mít určitou kompetenci a tu by
neměl překračovat. Pověřme náš objekt pouze sestavením pozdravu a jeho
výpis si zpracujeme již mimo, v našem případě v metodě
main()
. Výhodou takto navrženého objektu je vysoká
univerzálnost a znovupoužitelnost. Objekt doposud umí jen psát do konzole,
my ho však přizpůsobíme tak, aby daná metoda text pouze vracela a bylo na
jeho příjemci, jak s ním naloží. Takto můžeme pozdravy ukládat do
souborů, psát na webové stránky nebo dále zpracovávat.
Jelikož chceme, aby metoda vracela hodnotu String
, změníme
její dosavadní typ void
na String
. K návratu
hodnoty použijeme příkaz return
. Příkaz return
metodu ukončí a navrátí hodnotu. Jakýkoli kód v těle metody po příkazu
return
se již neprovede! Upravme obě třídy:
Metoda pozdrav()
v souboru Zdravic.java
:
public String pozdrav(String jmeno) { return String.format("%s %s", text, jmeno); }
Tělo metody main()
v souboru
HelloObjects.java
:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Zdravic zdravic = new Zdravic(); zdravic.text = "Ahoj uživateli"; System.out.println(zdravic.pozdrav("Karel")); System.out.println(zdravic.pozdrav("Petr")); zdravic.text = "Vítám tě tu programátore"; System.out.println(zdravic.pozdrav("Richard")); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Zdravic { public String text; public String pozdrav(String jmeno) { return String.format("%s %s", text, jmeno); } } {/JAVA_OOP}
Nyní je náš kód dle dobrých praktik. Ještě naši třídu okomentujme,
jak se sluší a patří. Komentáře budeme psát nad název třídy a nad
název každého atributu a metody. K jejich zápisu použijeme
/** Popisek */
. Vyplatí se nám to ve chvíli, když na
třídě používáme nějakou metodu, její popis se nám zobrazí v
našeptávači. Zdokumentovaná třída může vypadat např. takto:
/** * Třída reprezentuje zdravič, který slouží ke zdravení uživatelů */ public class Zdravic { /** * Text pozdravu */ public String text; /** * Pozdraví uživatele textem pozdravu a jeho jménem * @param jmeno Jméno uživatele * @return Text s pozdravem */ public String pozdrav(String jmeno) { return String.format("%s %s", text, jmeno); } }
Znaky /*
začíná víceřádkový komentář a končí
opačnými znaky */
, syntaxe popisků se nazývá
Javadoc.
-
Nad místem, kde chceme vytvořit dokumentaci (např. nad metodou/atributem) napíšeme
/**
a stiskneme klávesu Enter:Metodu, atribut či třídu tak jednoduše a rychle popíšeme. Alternativně můžeme kliknout například metodu
pozd|rav()
(|
značí kurzor v názvu metody) a stiskneme klávesy Alt a Enter.Klikneme kurzorem na metodu
pozdrav()
v metoděmain()
a IDE nám opravdu popisky zobrazí:Pokud budete své třídy dobře popisovat, programátorskou dokumentaci k aplikaci vytvoříte poté jediným kliknutím. Z Javadoc umí IntelliJ generovat dokumentaci i ve formátu HTML. Kliknete pravým na třídu v záložce Project a zvolíte z hlavního menu položku Tools -> Generate Javadoc....
-
NetBeans umí Javadoc sám přidat do vašeho kódu, stačí ho pak jen vyplnit. Kliknete pravým na třídu v záložce Project a zvolíte položku Tools -> Analyze Javadoc, zaškrtáte chybějící políčka a potvrdíte. Z Javadoc umí IDE NetBeans generovat dokumentaci i ve formátu HTML. Pokud budete své třídy dobře popisovat, programátorskou dokumentaci k aplikaci vytvoříte poté jediným kliknutím.
Klikneme kurzorem na metodu
pozdrav()
v metoděmain()
a IDE nám opravdu popisky zobrazí:
U metody pozdrav()
nám to vygenerovalo klíčové slovo
@param
, za ním hned název parametru jmeno
. To
značí, že následující popisek bude patřit parametru jmeno
(popisek může pokračovat i na dalším řádku pro větší přehlednost).
Metoda může mít totiž více parametrů a tím se zajistí, že bude mít
každý parametr vlastní popisek. Dále nám IDE vygenerovalo ještě
klíčové slovo @return
, to značí popisek toho, co nám metoda
vrátí.
A jsme u konce. Námi napsaný program má již nějakou úroveň, i když vlastně nic nedělá. Za úkol máte předělat si naši konzolovou kalkulačku do objektů.
V následujícím cvičení, Řešené úlohy k 2. lekci OOP v Javě, si procvičíme nabyté zkušenosti z předchozích lekcí.
Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.
Stáhnout
Stažením následujícího souboru souhlasíš s licenčními podmínkami
Staženo 1995x (11.25 kB)
Aplikace je včetně zdrojových kódů v jazyce Java