Obsah
Třída (také poněkud nepřesně zvaná objektový typ) představuje skupinu objektů, které nesou stejné vlastnosti
"stejné" je myšleno kvalitativně, nikoli kvantitativně, tj.
Objekt je jeden konkrétní jedinec (reprezentant, entita) příslušné třídy
pro konkrétní objekt nabývají vlastnosti deklarované třídou konkrétních hodnot
Objekt
panProfesor
typu
Person má vlastnost name s
hodnotou "Václav Klaus".
Vlastnosti objektů - proměnné i metody - je třeba deklarovat.
viz Sun Java Tutorial / Trail: Learning the Java Language: Lesson: Classes and Inheritance
deklarujme třídu objektů - lidí
public class Person { private String name; private int age; public Person(String n, int a) { name = n; age = a; } public void writeInfo() { System.out.println("Person:"); System.out.println("Name "+name); System.out.println("Age "+age); } }Použijme ji v programu -
vytvořme instanci - objekt - typu
Personvypišme informace o něm
Mějme deklarovánu třídu Person
Metoda main v následujícím programu
Demo:
deklaruje dvě lokální proměnné typu Person - budou obsahovat odkazy na následně vytvořené objekty - lidi
vytvoří tyto dva lidi (pomocí new Person)
zavolá jejich metody
public class Demo { public static void main(String[] args) { Person ales = new Person("Ales Necas", 38); Person beata = new Person("Beata Novakova", 36); ales.writeInfo(); beata.writeInfo(); } }
Tedy: vypíší se informace o obou vytvořených objektech - lidech.
Ve výše uvedeném programu znamenalo na řádku:
Person ales = new Person("Ales Necas", 38); Person ales: pouze deklarace (tj. určení typu)
proměnné ales - bude typu
Person.
ales = new Person ("Ales Necas", 38): vytvoření
objektu Person se jménem Ales
Necas.
Lze napsat zvlášť do dvou řádků nebo (tak jak jsme to udělali) na řádek jeden.
Každý příkaz i samostatně stojící deklaraci ukončujeme středníkem.
Ve výše uvedených příkladech jsme objekty vytvářeli voláními
new Person(...) bezděčně jsme tak použili
jsou instance "své" třídy
vytváříme je operátorem new
- voláním
konstruktoruvytvořené objekty ukládáme do proměnné stejného typu (nebo typu předka či implementovaného rozhraní - o tom až později)
Položky name a age v
předchozím příkladu jsou proměnné
objektu Person.
Jsou deklarovány v těle deklarace třídy Person.
Deklarace proměnné objektu má tvar:
Výše uvedená proměnná rokNarozeni měla datový
typ int (32bitové celé číslo). Tedy:
proměnná takového typu nese jednu hodnotu typu celé číslo (v rozsahu -2^31.. 2^31-1);
nese-li jednu hodnotu, pak se jedná o tzv. primitivní datový typ.
Kromě celých čísel int nabízí Java celou řadu dalších primitivních datových typů. Primitivní typy jsou dané napevno, programátor je jen používá, nedefinuje.
Tam, kde nestačí diskrétní hodnoty (tj. primitivní typy), musíme použít typy složené, objektové.
Na jméno (identifikátor) proměnné sice Java neklade žádná speciální omezení (tedy mimo omezení platná pro jakýkoli identifikátor), ale přesto bývá velmi dobrým zvykem dodržovat při pojmenovávání následující pravidla (blíže viz podrobný rozbor na http://java.sun.com/docs/codeconv/):
jména začínají malým písmenem
nepoužíváme diakritiku (problémy s editory, přenositelností a kódováním znaků) - a to přesto, že Java ji i v identifikátorech povoluje
(raději ani český jazyk, angličtině rozumí "každý")
je-li to složenina více slov, pak je nespojujeme podtržítkem, ale další začne velkým písmenem (tzv. "CamelCase")
je identifikátor se správně (vhodně) utvořeným jménem, zatímco:
není vhodný identifikátor proměnné (začíná velkým písmenem)
Dodržování těchto jmenných konvencí je základem psaní srozumitelných programů a bude vyžadováno, sledováno a hodnoceno v odevzdávaných úlohách i písemkách.
Proměnné objektu odkazujeme pomocí "tečkové notace":
public class Demo2 {
public static void main(String[] args) {
...
Person ales = new Person("Ales Necas", 38); // vytvoření objektu ...
System.out.println(ales.name); // přístup k (čtení) jeho proměnné ...
ales.name = "Aleš Novák"; // modifikace (zápis do) jeho proměnné
}
} Přístup k proměnným (i metodám) může být řízen uvedením tzv. modifikátorů před deklaraci prvku, viz výše:
// private = přístup pouze z této třídy: private String name;
Modifikátorů je více typů, nejběžnější jsou právě zmíněné modifikátory přístupu (přístupových práv)
Objektů (tzv. instancí) stejného typu (tj. stejné třídy) si můžeme postupně vytvořit více:
public class Demo3 {
public static void main(String[] args) {
...
Person ales = new Person("Ales Necas", 38); // vytvoření prvniho objektu
Person petr = new Person("Petr Svoboda", 36); // vytvoření druheho objektu ...
System.out.println(ales.name); // přístup k (čtení) proměnné - prvnímu objektu
System.out.println(petr.name); // přístup k (čtení) proměnné - druhému objektu
}
} Existují tady dva objekty, každý má své (obecně různé) hodnoty proměnných - např. jsou různá jména obou lidí.
Nad existujícími (vytvořenými) objekty můžeme volat jejich metody. Metoda je:
![[Poznámka]](http://www.fi.muni.cz/~tomp/slides/images/note.png)
Výše uvedená třída Person měla metodu na
výpis informací o daném objektu/člověku:
public class Person {
private String name;
private int age;
public Person(String n, int a) {
name = n;
age = a;
}
public void writeInfo() {
System.out.println("Person:");
System.out.println("Name "+name);
System.out.println("Age "+age);
}
} Samotnou deklarací (napsáním kódu) metody se žádný kód neprovede.
Chceme-li vykonat kód metody, musíme ji zavolat.
Volání se realizuje (tak jako u proměnných) "tečkovou notací", viz dále.
Volání lze provést, jen je-li metoda z místa volání přístupná - "viditelná". Přístupnost regulují pdobně jako u proměnných modifikátory přístupu.
Vracíme se k prvnímu příkladu: vytvoříme dva lidi a zavoláme postupně jejich metodu writeInfo.
public class TestLidi {
public static void main(String[] args) {
Person ales = new Person("Ales Necas", 38);
Person beata = new Person("Beata Novakova", 36);
ales.writeInfo(); // volání metody objektu ales
beata.writeInfo(); // volání metody objektu beata
}
} Vytvoří se dva objekty Person a vypíší se
informace o nich.
V deklaraci metody uvádíme v její hlavičce tzv. formální parametry.
modifikatorytypVraceneHodnotynazevMetody(seznamFormalnichParametru) { tělo (výkonný kód) metody }
seznamFormalnichParametru je tvaru: typParametru
nazevFormalnihoParametru, ...
Podobně jako v jiných jazycích parametr představuje v rámci metody lokální proměnnou.
Při volání metody jsou f. p. nahrazeny skutečnými parametry.
Hodnoty primitivních typů - čísla, logické hodnoty, znaky
Hodnoty objektových typů - všechny ostatní (tj. vč. všech uživatelem definovaných typů)
se předávají odkazem, tj. do lokální proměnné metody se nakopíruje odkaz na objekt - skutečný parametr
Pozn: ve skutečnosti se tedy parametry vždy předávají hodnotou, protože v případě objektových parametrů se předává hodnota odkazu na objekt - skutečný parametr.
V Javě tedy nemáme jako programátoři moc na výběr, jak parametry předávat
Rozšiřme definici třídy Person o metodu scream s parametry:
...
public void scream(int kolikrat) {
System.out.println("Kricim " + kolikrat + "krat UAAAA!");
}
... ... scream(10); ...
Kricim 10krat UAAAA!
Následující třída Account modeluje jednoduchý
bankovní účet s možnostmi:
public class Account {
// stav (zustatek) penez uctu
private double balance;
public void add(double amount) {
balance += amount;
}
public void writeBalance() {
System.out.println(balance);
}
public void transferTo(Account whereTo, double amount) {
balance -= amount;
whereTo.add(amount);
}
} Metoda transferTo pracovat nejen se svým "mateřským" objektem, ale i s objektem whereTo předaným do metody... opět přes tečkovou notaci.
Příklad použití třídy Account:
...
public static void main(String[] args) {
Account petrsAccount = new Account();
Account ivansAccount = new Account();
petrsAccount.add(100);
ivansAccount.add(220);
petrsAccount.transferTo(ivansAccount, 50);
petrsAccount.writeBalance();
ivansAccount.writeBalance();
} Kód metody skončí, tj. předá řízení zpět volající metodě (nebo
systému - v případě startovní metody main),
jakmile
dokončí poslední příkaz v těle metody nebo
dospěje k příkazu
return
Metoda může při návratu vrátit hodnotu - tj. chovat se jako funkce (ve pascalském smyslu):
Pozn.: I když metoda něco vrátí, my to nemusíme použít, ale je to trochu divné...
Co a k čemu jsou konstruktory?
Konstruktury jsou speciální metody volané při vytváření nových instancí dané třídy.
Typicky se v konstruktoru naplní (inicializují) proměnné objektu.
Konstruktory lze volat jen ve spojení s operátorem
new k vytvoření nové instance třídy - nového
objektu, evt. volat z jiného konstruktoru
public class Person {
private String name;
private int age;
// konstruktor se dvěma parametry
// - inicializuje hodnoty proměnných ve vytvořeném objektu
public Person(String n, int a) {
name = n;
age = a;
}
...
} Příklad využití tohoto konstruktoru:
...
Person pepa = new Person("Pepa z Hongkongu", 105);
... Jak je psát a co s nimi lze dělat?
nemají návratový typ (ani
void -
to už vůbec ne!!!)mohou mít parametry
mohou volat konstruktor rodičovské třídy - ale jen jako svůj první příkaz
Ve třídě Ucet přetížíme metodu
prevedNa.
public void transferTo(Account whereTo) {
whereTo.add(balance);
balance = 0;
} koexistují dvě různé metody se stejným názvem, ale jinými parametry.
Pozn: I když jsou to teoreticky dvě úplně různé metody, pak když už se jmenují stejně, měly by dělat něco podobného.
Často přetížená metoda volá jinou "verzi" metody se stejným názvem:
public void transferTo(Account whereTo) { transferTo(whereTo, balance); }Toto je jednodušší, přehlednější, udělá se tam potenciálně méně chyb.
Lze doporučit. Je to přesně postup divide-et-impera, rozděl a panuj, dělba práce mezi metodami!
Je ale otázka, zdali převod celého zůstatku raději nenapsat jako nepřetíženou, samostatnou metodu, např.:
public void transferAllMoneyTo(Account whereTo) { transferTo(whereTo, balance); }Je to o něco instruktivnější, ale přibude další identifikátor - název metody - k zapamatování.
Což může být výhoda (je to výstižné) i nevýhoda (musíme si pamatovat další).
Deklarace proměnné objektového typu ještě žádný objekt nevytváří.
To se děje až příkazem - operátorem -
new.
V následující ukázce vytvoříme dva účty.
Odkazy na ně budou primárně v proměnných petruvUcet a ivanuvUcet.
V proměnné u nebude primárně odkaz na žádný účet.
Pak do ní přiřadíme (u = petruvUcet;
) odkaz
na objekt skrývající se pod odkazem
petruvUcet.Od této chvíle můžeme s účtem petruvUcet manipulovat přes odkaz (proměnnou) u.
Což se také děje: u.prevedNa(ivanuvUcet, 50);
...
public static void main(String[] args) {
Account petruvUcet = new Account();
Account ivanuvUcet = new Account();
Account u;
petruvUcet.add(100);
ivanuvUcet.add(220);
u = petruvUcet;
u.transferTo(ivanuvUcet, 50); // odečte se z Petrova účtu
petruvUcet.writeBalance(); // vypíše 50
ivanuvUcet.writeBalance();
} Metoda může vracet odkaz na objekt, nad nímž je volána pomocí
Příklad - upravený Account s metodou
transferTo vracející odkaz na sebe
public class Account {
private double balance;
public void add(double amt) {
balance += amt;
}
public void writeBalance() {
System.out.println(balance);
}
public Account transferTo(Account whereTo, double a) {
add(-a);
u.add(a);
return this;
}
} Vracení odkazu na sebe (tj. na objekt, na němž se metoda volala) lze s výhodou využít k "řetězení" volání:
...
public static void main(String[] args) {
Account petruvUcet = new Account();
Account ivanuvUcet = new Account();
Account igoruvUcet = new Account();
petruvUcet.add(100);
ivanuvUcet.add(100);
igoruvUcet.add(100);
// budeme řetězit volání:
petruvUcet.transferTo(ivanuvUcet, 50).transferTo(igoruvUcet, 20);
petruvUcet.writeBalance(); // vypíše 30
ivanuvUcet.writeBalance(); // vypíše 150
igoruvUcet.writeBalance(); // vypíše 120
}
Dosud jsme zmiňovali proměnné a metody (tj. souhrnně prvky - members) objektu.
Lze deklarovat také metody a proměnné patřící celé třídě, tj. skupině všech objektů daného typu - statická proměnná existuje pro jednu třídu jen jednou!
Takové metody a proměnné nazýváme statické a označujeme v deklaraci modifikátorem
static
Představme si, že si budeme pamatovat, kolik lidí se nám během chodu programu vytvořilo a vypisovat tento počet.
Budeme tedy potřebovat do třídy Person doplnit:
jednu proměnnou
peopleCountspolečnou pro celou tříduPerson- každý člověk ji při svém vzniku zvýší o jedna.jednu metodu
howManyPeople, která vrátí počet dosud vytvořených lidí.
public class Person {
private String name;
private int age;
private static int peopleCount = 0;
public Person(String n, int a) {
name = n;
age = a;
peopleCount++;
}
...
public static int howManyPeople() {
return peopleCount;
}
...
} Pozn: Všimněte si v obou případech modifikátoru/klíčového slova static.