Třídy a objekty

Třídu deklarujeme pomocí klíčového slova class. Za ním následuje jméno třídy. Jméno třídy obvykle začíná velkým písmenem. Pokud se skládá z více slov, oddělujeme slova tak, že první písmeno každého slova je velké (např. BarevnyObrazek). Není zvykem používat podtržítka. Třída může obsahovat deklarace proměnných a metod. Proměnné i metody mohou být buď třídní (statické) nebo instanční. Instančním proměnným říkáme instanční atributy nebo zkráceně atributy (angl. instance attributes nebo fields). Třídní (statické) metody již známe. Deklarují se pomocí klíčového slova static. Dále si ukážeme, jak deklarovat a používat instanční metody (angl. instance methods). Instanční metody se deklarují podobně jako statické. Na rozdíl od statických metod však jejich hlavičky neobsahují klíčové slovo static. Instanční metody často pracují s instančními atributy.

  class Moje {
     int x;  // instanční atribut
     void vypisX() {  // instanční metoda
        System.out.println( x );
     }
  } 

  Moje p; 

  p = new Moje(); 

  p.x = 1;
  p.vypisX(); 

  Moje p2 = new Moje();
  p2.x = 2;
  p2.vypisX(); 

  class Moje {
     int x;
     void zvysX() {
        x++;
     }
  } 

  class Moje {
     int x;
     // pričte dx k x a vrátí novou hodnotu x
     int posunX( int dx ) {
        x += dx;
        return x;
     }
  } 

  class Box {
     double d;
     Box() {  // konstruktor
        d = Math.random() * 100;
     }
  } 

  class Box {
     double d;
     Box( double dd ) {  // konstruktor s parametrem
        d = dd;
     }
  } 

  Box p = new Box( 3.5 ); 

  class Cislo {
     int x = 1;  // inicializátor
  } 

V jedné třídě je možné deklarovat více konstruktorů, pokud se liší seznamem parametrů. Má-li třída alespoň dva konstruktory, říkáme o konstruktoru, že je přetížený (angl. overloaded).

  class Cislo {
     int x;
     Cislo() {
        x = 1;
     }
     Cislo( int px ) {
        x = px;
     }
  } 

  Cislo p1 = new Cislo();  // volání konstruktoru bez parametrů
  Cislo p2 = new Cislo( 97 );  // volání konstruktoru s parametrem 

1. přidělení (alokace) paměti
2. inicializace na nulu
3. provedení inicializátorů
4. zavolání konstruktoru

Při provádění konstruktoru tedy atributy mají definovanou hodnotu. Buď mají nulové hodnoty nebo hodnoty, které jsme jim přiřadili pomocí inicializátorů.

Dále si ukážeme třídu Bod, která popisuje bod v rovině:

  class Bod {
     int x, y;
     // konstruktory
     Bod( int px, int py ) {
        x = px;
        y = py;
     }
     Bod( Bod b ) {
        x = b.x;
        y = b.y;
     }
     // posune bod o dx a dy
     void posun( int dx, int dy ) {
        x += dx;
        y += dy;
     }
     // vytiskne souřadnice bodu
     void vytiskni() {
        System.out.printf( "[%d,%d]", x, y );
     }
     // spočte vzdálenost bodu od počátku
     double spoctiVzdalenostOdPocatku() {
        return Math.sqrt( x * x + y * y );
     }
  } 

  Bod b1 = new Bod( 1, 2 );
  Bod b2 = b1;  // odkaz uložený v b1 se zkopíruje do b2
  b2.vytiskni();  // vytiskne [1,2]
  b1.posun( 1, 1 );  // posune bod na [2,3]
  b2.vytiskni();  // vytiskne [2,3] 

Referenční typy lze použít i pro parametry metod. Při volání metody se pak předává hodnota reference, tj. odkaz na objekt. Stejně jako u parametrů primitivního typu jde o předávání hodnotou.

  static void m1( Bod b ) {
     b.posun( 1, 1 );
  }
  public static void main( String[] args ) {
     Bod p = new Bod( 1, 2 );
     m1( p );
     p.vytiskni();  // vytiskne [2,3]
  } 

Pokud v deklaraci třídy neuvedeme konstruktor, překladač do třídy automaticky vloží tzv. implicitní konstruktor (angl. default constructor). Implicitní konstruktor nemá žádné parametry a má prázdné tělo.

  class Bod {
     int x, y;
     // pokud nedeklarujeme konstruktor, překladač vloží
     // implicitní konstruktor:
     // Bod() { }
  } 

Úloha 1

Doplňte metodu spoctiObsah(), která vrátí obsah obdélníka. start

Úloha 2

Doplňte konstruktor, který bude mít tři parametry. Parametry použijte pro inicializaci atributů. start

Úloha 3

Do třídy Datum doplňte deklaraci atributů den, mesic a rok a deklaraci konstruktoru se třemi parametry. start

Úloha 4

Do třídy RacionalniCislo doplňte dva konstruktory. První konstruktor bude mít dva parametry typu int a druhý konstruktor bude mít jeden parametr typu RacionalniCislo. start

Úloha 5

Určete, co bude výstupem následujícího kódu. start

Úloha 6

Doplňte věty. start

Úloha 7

Napište ve správném pořadí. start

Otázky a odpovědi

  class Bod {
     int x = 1;  // toto se provede první
     Bod() {
        x = y = 3;  // toto třetí
     }
     int y = 2;  // toto druhé
  } 

  class Souradnice {
     double x = Math.random() * 100;
     double y = x;
  } 

  class Souradnice {
     double x, y;
     Souradnice() {
        x = y = Math.random() * 100;
     }
  } 

  class Box {
     Box( int x, double y ) {
        System.out.println( "Box( int x, double y )" );
     }
     Box( double y, int x ) {
        System.out.println( "Box( double y, int x )" );
     }
  } 

  Box b1 = new Box( 1, 2.5 );  // parametry int a double
  Box b2 = new Box( 2.5, 1 );  // parametry double a int 

  Box b1 = new Box( 1, 2 );    // toto se nepřeloží
  Box b2 = new Box( 1, 2.0 );  // takto vybereme první konstruktor
  Box b3 = new Box( 1.0, 2 );  // a takto druhý