2. diel - Prvá objektová aplikácia v Jave - Hello object world
Minulá lekcia, Úvod do objektovo orientovaného programovania v Jave, nás uviedla do objektovo orientovaného programovania.
Už vieme, že objekty majú atribúty a metódy. Tiež vieme, že na vytvorenie objektu vytvoríme najprv triedu. Tá je vzorom, podľa ktorého následne tvoríme jej inštancie.
Na začiatku kurzu so základnými štruktúrami jazyka Java sme si vytvorili program Hello world. Urobme si teraz podobný program ako úvod do objektovo orientovaného programovania. Naprogramujme si aplikáciu Hello object world!
Založme si novú Java aplikáciu tak, ako sme to robili doteraz.
V záložke Project klikneme pravým tlačidlom myši na balík (package) nášho projektu a vyberieme z menu položku New -> Java Class:
Vytvoríme triedu HelloObjects
, v ktorej obvyklým spôsobom
vytvoríme hlavnú metódu main()
.
Potom vytvoríme ďalšiu triedu Greeter
a potvrdíme. Názov
triedy píšeme vždy notáciou PascalCase
, teda bez medzier, a na
rozdiel od premenných (tie používajú camelCase
) má
každé slovo veľké prvé písmeno, teda aj to prvé. Názov
je samozrejme tiež bez diakritiky, tú v programe používame maximálne vo
vnútri textových reťazcov, nie v identifikátoroch:
Podľa tejto triedy neskôr vytvoríme objekt greeter
, ktorý
nás bude vedieť pozdraviť. Vidíme, že sa na program už pozeráme úplne
inak, za každú akciu je zodpovedný nejaký objekt, nestačí iba niečo
"nahádzať" do metódy main()
. V našom prípade vám to môže
prísť zbytočné, pri zložitejších aplikáciách si to budete pochvaľovať
V našom package pribudne ďalší súbor .java
a IDE
nám ho otvorí. K pôvodnému súboru HelloObjects.java
s metódou
main()
sa môžeme vrátiť pomocou záložky alebo cez záložku
Projects.
Pozrime sa, čo nám IDE vygenerovalo a kód si popíšme. Následne si do triedy pridáme vlastnú metódu na pozdravenie:
package com.ictdemy; public class Greeter { }
Kľúčové slovo package
nám označuje tzv. balíček. Rovnako
ako sa metódy združujú do tried, tak sa triedy združujú do balíčkov. Ak
chceme, aby bola naša trieda viditeľná aj vo východiskovej triede, kde máme
metódu main()
, musíme ju mať v rovnakom balíčku. To tu platí,
IDE samo novú triedu vloží do toho istého balíčka. Ak ste pri zakladaní
projektu nevyplnili GroupId
, budete mať v predvolenom nastavení
package org.example
namiesto package com.ictdemy
.
V package je teda umiestnená samotná trieda, ktorá sa deklaruje
kľúčovým slovom class
. Trieda sa volá Greeter
a
je prázdna.
Všimnite si, že kód je takmer rovnaký, ako ten v
HelloObjects.java
, už teda rozumieme tomu, čo sme predtým
ignorovali. Náš konzolový program bola vlastne trieda umiestnená v
package, ktorá obsahovala jednu metódu main()
.
Vidíme, že v Jave sa v podstate neobjektovo programovať ani nedá, čo je len
dobre
Teraz si do triedy Greeter
pridáme metódu
greet()
, bude verejne viditeľná a nebude mať žiadnu návratovú
hodnotu ani atribúty.
Deklarácia metódy v Jave je teda nasledujúca:
[accessModifier] [returnType] [methodName]([parameters])
Pred metódou bude tzv. modifikátor prístupu, v našom prípade
public
(verejná). Metóda nebude vracať žiadnu hodnotu, to
docielime kľúčovým slovom void
. Ďalej bude nasledovať
samotný názov metódy. Metódy píšeme rovnako ako premenné ťavou notáciou
s malým počiatočným písmenom. Zátvorka s parametrami je povinná, my ju
necháme prázdnu, pretože metóda nebude mať žiadne parametre. Do tela
metódy zapíšeme kód pre výpis na konzole:
Naša trieda bude teraz vyzerať takto:
public class Greeter { public void greet() { System.out.println("Hello object world!"); } }
Tu sme zatiaľ skončili, prejdeme do súboru
HelloObjects.java
.
Teraz si v tele metódy main()
vytvoríme
inštanciu triedy Greeter
. Bude to teda ten objekt
greeter
, s ktorým budeme pracovať. Objekty sa ukladajú do
premenných, názov triedy slúži ako dátový typ. Inštancia má spravidla
názov triedy, len má prvé písmeno malé. Deklarujme si premennú a následne
v nej založme novú inštanciu triedy Greeter
:
Greeter greeter;
greeter = new Greeter();
Tieto riadky hovoria: "Chcem premennú greeter
, v ktorej bude
inštancia triedy Greeter
.". S premennými sme vlastne už takto
pracovali.
Na druhom riadku je kľúčové slovo new
, ktoré nám
vytvorí novú inštanciu triedy Greeter
. Túto
inštanciu priradíme do našej premennej.
Pri vytvorení novej inštancie sa zavolá tzv. konštruktor. To je špeciálna metóda na triede, preto pri vytvorení inštancie píšeme tie prázdne zátvorky, pretože voláme túto "vytváraciu" metódu. Konštruktor spravidla obsahuje nejakú inicializáciu vnútorného stavu inštancie (napr. dosadí východiskové hodnoty do premenných). My sme v kóde žiadny konštruktor nedeklarovali, Java si preto vytvorila tzv. implicitný bezparametrický konštruktor. Vytvorenie inštancie objektu je teda podobné volaniu metódy. Deklaráciu môžeme samozrejme skrátiť na:
Greeter greeter = new Greeter();
Keďže v premennej teraz máme naozaj inštanciu triedy
Greeter
, môžeme inštanciu nechať pozdraviť. Zavoláme na ňu
metódu greet()
a to ako greeter.greet()
. Kód metódy
main()
bude teda teraz vyzerať nasledovne:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Greeter greeter = new Greeter(); greeter.greet(); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Greeter { public void greet() { System.out.println("Hello object world!"); } } {/JAVA_OOP}
Program spustíme a v konzole sa nám zobrazí:
Konzolová aplikácia
Hello object world!
Máme teda prvú objektovú aplikáciu!
Dajme teraz našej metóde greet()
parameter name
,
aby dokázala pozdraviť konkrétneho používateľa. Prejdeme do súboru
Greeter.java
:
public void greet(String name) { System.out.printf("Hi %s%n", name); }
Vidíme, že syntax parametra metódy je rovnaká ako syntax premennej. Keby
sme chceli parametrov viac, oddeľujeme ich čiarkou. Upravíme teraz našu
metódu main()
v súbore HelloObjects.java
:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Greeter greeter = new Greeter (); greeter.greet("Carl"); greeter.greet("Peter"); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Greeter { public void greet(String name) { System.out.printf("Hi %s%n", name); } } {/JAVA_OOP}
Náš kód je teraz v metóde a my ho môžeme pomocou parametrov jednoducho volať znova s rôznymi parametrami. Nemusíme 2x písať "Hi...". Kód budeme odteraz deliť logicky do metód.
Výstup v konzole:
Konzolová aplikácia
Hi Carl
Hi Peter
Triede pridáme nejaký atribút. Ponúka sa atribút text
, kde
bude uložený text pozdravu. Atribúty sa definujú rovnako ako premenné. Ako
pri metódach platí to, že pred nich píšeme modifikátor prístupu. Ak
modifikátor nenapíšeme, bude atribút prístupný v rámci daného balíčka
(package
), ale mimo neho už nie. Na čo presne modifikátory
prístupu slúžia, si povieme ďalej v kurze. Upravme našu triedu
Greeter
:
public class Greeter { public String text; public void greet(String name) { System.out.printf("%s %s%n", text, name); } }
Text teraz musíme pochopiteľne nastaviť vytvorenej inštancii v
HelloObjects.java
:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Greeter greeter = new Greeter(); greeter.text = "Hi"; greeter.greet("Carl"); greeter.greet("Peter"); greeter.text = "Hello programmer"; greeter.greet("Richard"); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Greeter { public String text; public void greet(String name) { System.out.printf("%s %s%n", text, name); } } {/JAVA_OOP}
Výsledok:
Konzolová aplikácia
Hi Carl
Hi Peter
Hello programmer Richard
Vzhľadom k objektovému návrhu nie je najvhodnejšie, aby si každý objekt
ovplyvňoval vstup a výstup, ako sa mu zachce. Pochopiteľne narážam na naše
vypisovanie do konzoly. Každý objekt by mal mať určitú kompetenciu a tú by
nemal prekračovať. Poverme náš objekt iba zostavením pozdravu a jeho výpis
si spracujeme už mimo, v našom prípade v metóde main()
.
Výhodou takto navrhnutého objektu je vysoká univerzálnosť a
znovupoužiteľnosť. Objekt zatiaľ vie len písať do konzoly, my ho však
prispôsobíme tak, aby daná metóda text iba vracala a bolo na jeho
príjemcovi, ako s ním naloží. Takto môžeme pozdravy ukladať do súborov,
písať na webové stránky alebo ďalej spracovávať.
Keďže chceme, aby metóda vracala hodnotu String
, zmeníme jej
doterajší typ void
na String
. Na návrat hodnoty
použijeme príkaz return
. Príkaz return
metódu
ukončí a vráti hodnotu. Akýkoľvek kód v tele metódy po príkaze
return
sa už nevykoná! Upravme obe triedy:
Metóda greet()
v súbore Greeter.java
:
public String greet(String name) { return String.format("%s %s", text, name); }
Telo metódy main()
v súbore
HelloObjects.java
:
{JAVA_OOP} {JAVA_MAIN_BLOCK} Greeter greeter = new Greeter(); greeter.text = "Hi"; System.out.println(greeter.greet("Carl")); System.out.println(greeter.greet("Peter")); greeter.text = "Hello programmer"; System.out.println(greeter.greet("Richard")); {/JAVA_MAIN_BLOCK} {/JAVA_OOP}
{JAVA_OOP} public class Greeter { public String text; public String greet(String name) { return String.format("%s %s", text, name); } } {/JAVA_OOP}
Teraz je náš kód v súlade s dobrými praktikami. Ešte našu triedu
okomentujme, ako sa patrí. Komentáre budeme písať nad názov triedy a nad
názov každého atribútu a metódy. Na ich zápis použijeme
/** Comments */
. Oplatí sa nám to vo chvíli, keď na
triede používame nejakú metódu, jej popis sa nám zobrazí v našepkávači.
Zdokumentovaná trieda môže vyzerať napr. takto:
/** * A class represents a greeter whose purpose is to greet the user */ public class Greeter { /** * Greeting text */ public String text; /** * Greets the user with the stored greeting and his/her name * @param name The user's name * @return The greeting text */ public String greet(String name) { return String.format("%s %s", text, name); } }
Znakmi /*
začína viacriadkový komentár a končí opačnými
znakmi */
, syntax popisov sa nazýva Javadoc.
Nad miestom, kde chceme vytvoriť dokumentáciu (napr. nad
metódou/atribútom), napíšeme /**
a stlačíme
Enter:
Metódu, atribút či triedu tak jednoducho a rýchlo popíšeme.
Alternatívne môžeme kliknúť napríklad na metódu gre|et()
(|
značí kurzor v názve metódy) a stlačíme klávesy
Ctrl a Q.
Klikneme kurzorom na metódu greet()
v metóde
main()
a IDE nám naozaj popisky zobrazí:
Ak budete svoje triedy dobre popisovať, programátorskú dokumentáciu k aplikácii potom vytvoríte jediným kliknutím. Z Javadoc vie IntelliJ generovať dokumentáciu aj vo formáte HTML. Kliknete pravým na triedu v záložke Project a zvolíte v hlavnom menu položku Tools -> Generate Javadoc....
Pri metóde greet()
nám to vygenerovalo kľúčové slovo
@param
, za ním hneď názov parametra name
. To
značí, že nasledujúci popis bude patriť parametru name
(popisok môže pokračovať aj na ďalšom riadku pre väčšiu prehľadnosť).
Metóda môže mať totiž viacero parametrov a tým sa zaistí, že bude mať
každý parameter vlastný popis. Ďalej nám IDE vygenerovalo ešte kľúčové
slovo @return
, to značí popis toho, čo nám metóda vráti.
A sme na konci. Nami napísaný program má už nejakú úroveň, aj keď vlastne nič nerobí. Za úlohu máte prerobiť si našu konzolovú kalkulačku na objekty.
V nasledujúcom cvičení, Riešené úlohy k 2. 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š.
Stiahnuť
Stiahnutím nasledujúceho súboru súhlasíš s licenčnými podmienkami
Stiahnuté 37x (3.04 kB)
Aplikácia je vrátane zdrojových kódov v jazyku Java