Objekty, atributy, metody

Pojmy třída, objekt

Deklarace a definice tříd, jejich vlastnosti (proměnné, metody)

Vytváření objektů, proměnné odkazující na objekt

Jmenné konvence — jak tvořit jména tříd, proměnných, metod

Použití objektů, volání metod, přístupy k proměnným

Modifikátory viditelnosti (public, private…)

Konstruktory (dotvoří/naplní prázdný objekt)

Přetěžování metod (dvě metody se stejným názvem a jinými parametry)

Třída (také poněkud nepřesně zvaná objektový typ) představuje skupinu objektů, které nesou stejné vlastnosti,

"Stejné" je myšleno kvalitativně, typově, nikoli ve smyslu konkrétních hodnot — ty jsou pro různé objekty téže třídy různé.

Např. všechny objekty třídy Person mají vlastnost name,

tato vlastnost má však obecně pro různé lidi různé hodnoty — lidi mají různá jména.

Objekt je jeden konkrétní jedinec (instance, reprezentant či entita) příslušné třídy.

Pro konkrétní objekt nabývají vlastnosti deklarované třídou konkrétních hodnot.

Třída Person má vlastnost name

Objekt panProfesor typu Person má vlastnost name s hodnotou Václav Klaus .

proměnné neboli atributy

metody

Vlastnosti objektů — proměnné/atributy i metody — je třeba deklarovat.

viz Oracle The Java™ Tutorials Lesson: Classes and Inheritance

deklarujme třídu objektů — lidí:

public class Person {
   private String name;
   private int age;
   public Person(String name, int age) {
      // pomocí this odlišíme proměnnou objektu od parametru!
      this.name = name;
      this.age = age;
   }
   public void writeInfo() {
      System.out.println("Person:");
      System.out.println("Name " + name);
      System.out.println("Age " + age);
   }
}

Ve výše uvedeném programu znamenalo na řádku: Person ales = new Person("Ales Necas", 38);

Person ales je pouze deklarace (tj. určení typu) proměnné ales - bude typu Person.

Až ales = new Person ("Ales Necas", 38) je samotným vytvořením objektu osoby (Person) se jménem Ales Necas a přiřazení odkazu na něj do proměnné ales.

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ím new Person(…) a bezděčně jsme tak použili:

operátor new , který vytvoří prázdný objekt typu Person a vzápětí sám provede

volání konstruktoru , který prázdný objekt naplní počátečními údaji (daty).

Objekty:

Terminologie: pro data zapouzdřená do objektů budeme používat záměnným způsobem označení atributy či proměnné. Je to totéž.

Atribut je jednoznačnější, jde vždy o datovou položku objektu či třídy, zatímco proměnné mohou být i lokální ("pomocné") uvnitř metody.

Položky name a age v předchozím příkladu jsou atributy/proměnné objektu Person. Jsou deklarovány v těle deklarace třídy Person.

Deklarace atributu/proměnné objektu má tvar: modifikátory TypProměnné jménoProměnné;

např. private int age;

Výše uvedený atribut/proměnná age měl/a datový typ int (32bitové celé číslo).

Tedy: proměnná takového typu nese jednu hodnotu typu celé číslo

Kromě celých čísel int nabízí Java celou řadu dalších primitivních datových typů (pro celá i necelá čísla, logické hodnoty, znaky).

Primitivní (základní, dále nedělitelné) typy jsou Javou dané napevno, programátor je nedefinuje ani nemodifikuje (na rozdíl např. od C/C++), nýbrž jen používá.

V Javě tedy neexistuje (na rozdíl od C/C+) možnost typy modifikovat (např. +unsigned int).

Tam, kde nestačí jednoduché hodnoty (tj. primitivní typy), musíme použít typy složené , objektové.

Objektovými typy v Javě jsou třídy (class) a rozhraní (interface) i pole. Třídy už jsme viděli na příkladu Person.

Existují třídy definované přímo v Javě, v knihovně Java Core API.

Nenajdeme-li třídu, kterou potřebujeme, v Java Core API ani v nám dostupných a použitelných knihovnách, můžeme si ji nadefinovat sami.

Konvencemi rozumíme zaužívaná doporučení, která především:

Usnadňují čtení cizího (i vlastního) kódu.

Eliminují tím chybovost.

Zvyšují produktivitu, šetří čas vlastní i ostatních.

Dodržování konvencí nehlídá překladač: i kód nedodržující konvence může být přeložitelný a funkční.

Hlídáme si to sami tím, že to dle konvencí vědomě píšeme a můžeme použít specializované nástroje pro kontrolu.

Doporučení přímo od Sun/Oracle Code Conventions for the Java Programming Language

Konvence užívané knize Cay Horstmann: Big Java popsané v kompaktní formě na 99 % shodné s naším pohledem na věc.

Do námi užívaného prostředí BlueJ je možné doinstalovat rozšíření pro hlídání stylu kódování BlueJ Checkstyle Extension, které hlídá dvě výše uvedené skupiny konvencí.

týkají se jak lokálních proměnných v metodách, tak atributů

netýkají se statických atributů a hlavně ne konstant

jména proměnných 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ý/slovenský či jiný národní jazyk, angličtině rozumí více lidí

je-li to složenina více slov, pak je nespojujeme podtržítkem, ale další začne velkým písmenem (tzv. "CamelCase", v případě proměnných tedy přesněji "camelCase")

private int yearOfBirth; je identifikátor se správně (vhodně) utvořeným jménem, zatímco:

private int YearOfBirth; není vhodný identifikátor proměnné v Javě (začíná velkým písmenem)

private int rokNarozeni; rovněž není vhodný identifikátor proměnné v Javě (zahraniční kolegové nebudou bez dalšího komentáře rozumět, co v té proměnné je)

Dodržování 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.

Konvence se bohužel liší od zvyklostí v příbuzných jazycích.

V Javě se např. nepoužívá v názvech tříd znak podtržítka — je to teoreticky možné, ale skoro nikdo tak nečiní.

Poměrně málo často se v názvech tříd či proměnných používají číslice. Občas ano, ale nikoli na začátku a nejspíše tam, kde jde o zvláštní konkrétní význam daného čísla, např. Counter32bit.

Rovněž se v názvech proměnných nepoužívá tzv. "maďarská notace", kde se připojují předpony např. dle datového typu proměnné.

Atributy objektu odkazujeme pomocí "tečkové notace":

public class Demo2 {
   public static void main(String[] args) {
      // vytvoření objektu ...
      Person ales = new Person("Ales Necas", 38);
      // přístup k (čtení) jeho proměnné ...
      System.out.println(ales.name);
      // modifikace (zápis do) jeho proměnné
      ales.name = "Aleš Novák";
   }
}

Viditelnost, tzn. přímá přístupnost atributů (i metod) může být řízena uvedením tzv. modifikátorů před deklaraci prvku, viz výše:

Modifikátorů je více typů (ještě další dva), zdaleka nejběžnější jsou dva právě zmíněné: private a public.

Objektů (tzv. instancí ) stejného typu (tj. stejné třídy) si můžeme postupně vytvořit více:

// vytvoření prvniho objektu
Person ales = new Person("Ales Necas", 38);
// vytvoření druheho objektu ...
Person petr = new Person("Petr Svoboda", 36);
// přístup k (čtení) proměnné prvního objektu
System.out.println(ales.name);
// přístup k (čtení) proměnné druhého objektu
System.out.println(petr.name);

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 podprogram (v terminologii neobjektových jazyků — funkce, procedura), který primárně pracuje s proměnnými "mateřského" objektu,

může mít další parametry,

může ve svém kódu (těle) deklarovat lokální proměnné — v našem příkladu metoda main deklarovala proměnné ales, petr.

Pro výsledky a mezivýsledky výpočtů používáme na ukládání hodnot lokální proměnné nebo atributy objektů. Rozdíl mezi lokální proměnnou a atributem (proměnnou objektu) je značný:

Hodnota uložená v atribut objektu je "trvalá" ve smyslu, že přetrvává (až do přiřazení jiné) po celou dobu existence daného objektu.

U lokální proměnné v metodě platnost skončí (zruší se) tato proměnná ukončením dané metody.

Metoda může vracet hodnotu podobně jako v Pascalu funkce.

Každá metoda se musí ve své třídě deklarovat.

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 name, int age) {
      this.name = name;
      this.age = age;
   }
   //... zde jsou další metody
}

Výše uvedená třída Person měla metodu pro výpis informací o daném objektu/člověku:

public class Person {
   private String name;
   private int age;
   //... zde patří konstruktor
   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í viditelná (přístupná). Přístupnost regulují podobně jako u proměnných modifikátory.

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.

Kód metody skončí, tj. předá řízení zpět volající metodě (nebo operačnímu 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):

Vrácenou hodnotu musíme uvést za příkazem return. V tomto případě tedy nesmí return chybět!

Typ vrácené hodnoty musíme v hlavičce metody deklarovat .

Nevrací-li metoda nic, pak musíme namísto typu vracené hodnoty psát void.

Pozn.: I když metoda něco vrátí, my to nemusíme použít, ale je to trochu divné…

V deklaraci metody uvádíme v její hlavičce tzv. formální parametry. Syntaxe:

modifikatory typVraceneHodnoty nazevMetody(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 formální parametry nahrazeny skutečnými parametry .

Rozšiřme definici třídy Person o metodu scream s parametry:

...
public void scream(int howManyTimes) {
   System.out.println("Kricim " + howManyTimes + "krat UAAAA!");
}
...

Při zavolání: scream(10);

tato metoda vypíše Kricim 10krat UAAAA!

Následující třída Account modeluje jednoduchý bankovní účet s možnostmi:

přidávat na účet/odebírat z účtu

vypisovat zůstatek na něm

převádět na jiný účet

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();
}