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

Příklad:

Vlastnostmi objektů jsou:

Vlastnosti objektů - proměnné i metody - je třeba deklarovat.

viz Sun Java Tutorial / Trail: Learning the Java Language: Lesson: Classes and Inheritance

Proměnné

Metody

Mějme deklarovánu třídu Clovek

Metoda main v následujícím programu:

Tedy: vypíší se informace o obou vytvořených objektech - lidech.

Nyní podrobněji k proměnným objektů.

Ve výše uvedeném programu znamenalo na řádku:

Clovek ales = new Clovek("Ales Necas", 1966); 

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

ales = new Clovek ("Ales Necas", 1966): vytvoření objektu Clovek 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 deklaraci ukončujeme středníkem.

Ve výše uvedených příkladech jsme objekty vytvářeli voláními new Clovek(...) bezděčně jsme tak použili

Objekty:

Položky jmeno a rokNarozeni v předchozím příkladu jsou proměnné objektu Clovek.

Jsou deklarovány v těle deklarace třídy Clovek.

Deklarace proměnné objektu má tvar:

modifikátory Typ jméno;

např.:

protected int rokNarozeni;

Výše uvedená proměnná rokNarozeni měla datový typ int (32bitové celé číslo). Tedy:

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 FIXME):

např.:

protected int rokNarozeni;

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

protected int RokNarozeni;

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 TestLidi2 { 
   public static void main(String[] args) { 
      ... 
      Clovek ales = new Clovek("Ales Necas", 1966); // vytvoření objektu ...
      System.out.println(ales.jmeno); // přístup k (čtení) jeho proměnné ...
      ales.jmeno = "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:

// protected = přístup pouze z třídy ve stejném balíku nebo z podtřídy: 
protected String jmeno;

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 TestLidi3 {
    public static void main(String[] args) { 
       ... 
       Clovek ales = new Clovek("Ales Necas", 1966); // vytvoření prvniho objektu 
       Clovek petr = new Clovek("Petr Svoboda", 1968); // vytvoření druheho objektu ...
       System.out.println(ales.jmeno); // přístup k (čtení) proměnné - prvnímu objektu
       System.out.println(petr.jmeno); // 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:

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

V Javě neexistují metody deklarované mimo třídy (tj. Java nezná žádné "globální" metody).

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

public class Clovek { 
   protected String jmeno; 
   protected int rokNarozeni; 

   public Clovek(String j, int rN) { 
      jmeno = j; 
      rokNarozeni = rN; 
   } 
   // Metoda vypisInfo() na výpis informací o člověku: 
   public void vypisInfo() {
      System.out.println("Clovek:"); 
      System.out.println("Jmeno="+jmeno);
      System.out.println("Rok narozeni="+rokNarozeni); 
   }
}   

Vracíme se k prvnímu příkladu: vytvoříme dva lidi a zavoláme postupně jejich metodu

vypisInfo

.

public class TestLidi { 
   public static void main(String[] args) { 
      Clovek ales = new Clovek("Ales Necas", 1966); 
      Clovek beata = new Clovek("Beata Novakova", 1970); 
      ales.vypisInfo(); // volání metody objektu ales 
      beata.vypisInfo(); // volání metody objektu beata 
   }
}   

Vytvoří se dva objekty Clovek a vypíší se informace o nich.

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 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ů)

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

Clovek

o metodu

zakric

s parametry:

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

Při zavolání:

... 
zakric(10); 
... 

tato metoda vypíše

Kricim 10krat UAAAA!

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

public class Ucet { 
    // stav (zustatek) penez uctu 
    protected double zustatek; 

    public void pridej(double castka) { 
        zustatek += castka; 
    }

    public void vypisZustatek() {
        System.out.println(zustatek);
    }

    public void prevedNa(Ucet kam, double castka) { 
        zustatek -= castka; 
        kam.pridej(castka); 
    }
} 

Metoda prevedNa pracovat nejen se svým "mateřským" objektem, ale i s objektem kam předaným do metody... opět přes tečkovou notaci.

Příklad použití třídy

Ucet

:

...
public static void main(String[] args) { 
   Ucet petruvUcet = new Ucet();
   Ucet ivanuvUcet = new Ucet(); 
   petruvUcet.pridej(100);
   ivanuvUcet.pridej(220); 
   petruvUcet.prevedNa(ivanuvUcet, 50);
   petruvUcet.vypisZustatek(); 
   ivanuvUcet.vypisZustatek(); 
}   

Kód metody skončí, tj. předá řízení zpět volající metodě (nebo systému - v případě startovní metody main), jakmile

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?

Syntaxe (viz výše):

public class Clovek { 
   protected String jmeno;
   protected int rokNarozeni; 
   // konstruktor se dvěma parametry 
   // - inicializuje hodnoty proměnných ve vytvořeném objektu 
   public Clovek(String j, int rN) { 
      jmeno = j;
      rokNarozeni = rn;
   }
   ...
} 

Příklad využití tohoto konstruktoru:

...
Clovek pepa = new Clovek("Pepa z Hongkongu", 1899); 
... 

Toto volání vytvoří objekt pepa a naplní ho jménem a rokem narození.

Jak je psát a co s nimi lze dělat?

Jedna třída může mít:

Ve třídě Ucet přetížíme metodu prevedNa.

public void prevedNa(Ucet u) { 
   u.pridej(zustatek); 
   zustatek = 0;
} 

Ve třídě

Ucet

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.

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.

 ... 
   public static void main(String[] args) { 
      Ucet petruvUcet = new Ucet(); 
      Ucet ivanuvUcet = new Ucet(); 
      Ucet u; 
      petruvUcet.pridej(100);
      ivanuvUcet.pridej(220);
      u = petruvUcet; 
      u.prevedNa(ivanuvUcet, 50); //  odečte se z Petrova účtu 
      petruvUcet.vypisZustatek(); // vypíše 50
      ivanuvUcet.vypisZustatek(); 
   } 

Metoda může vracet odkaz na objekt, nad nímž je volána pomocí

return this;

Příklad - upravený Ucet s metodou prevedNa vracející odkaz na sebe

public class Ucet { 
   float zustatek; 

   public void pridej(float castka) { 
      zustatek += castka; 
   }

   public void vypisZustatek() { 
      System.out.println(zustatek); 
   } 

   public Ucet prevedNa(Ucet u, float castka) { 
      zustatek -= castka; // nebo také vhodné je: pridej(-castka); 
      u.pridej(castka); 
      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) { 
      Ucet petruvUcet = new Ucet(); 
      Ucet ivanuvUcet = new Ucet(); 
      Ucet igoruvUcet = new Ucet(); 
      petruvUcet.pridej(100);
      ivanuvUcet.pridej(100); 
      igoruvUcet.pridej(100); 
// budeme řetězit volání:
      petruvUcet.prevedNa(ivanuvUcet, 50).prevedNa(igoruvUcet, 20);
      petruvUcet.vypisZustatek(); // vypíše 30 
      ivanuvUcet.vypisZustatek(); // vypíše 150 
      igoruvUcet.vypisZustatek(); // 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. 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 Clovek doplnit:

public class Clovek { 

   protected String jmeno; 
   protected int rokNarozeni; 
   protected static int pocetLidi = 0; 

   public Clovek(String j, int rN) { 
      jmeno = j; 
      rokNarozeni = rn;
      pocetLidi++;
   } 
   ... 
   public static int kolikMamLidi() { 
      return pocetLidi; 
   }
   ... 
} 

Pozn: Všimněte si v obou případech modifikátoru/klíčového slova static.