OOP po lopate - Triedy

09/11/2018 #how-to #po-lopate #oop

Minule sme si povedali niečo málo o koncepte a využití OOP, dnes sa pozrieme na príklady tried. 

class Dog
{
    public $name;
    protected $barkType;

    public function __construct($name, $barkType)
    {
      $this->name = $name;
      $this->barkType = $barkType;
    }

    public function rename($newName = '')
    {
      $this->name = $newName;
    }

    public function getName()
    {
      return $this->name;
    }

    public function bark($to = '')
    {
      echo `{$this->name}: {$this->barkType} -> {$to}`;
    }
}

$dunco = new Dog('Dunčo');
echo $dunco->getName();
$dunco->bark();

$anotherDog = new Dog('Hafo', 'buff');
echo $anotherDog->getName();
$anotherDog->bark('Dano');
class Dog(object):

  def __init__(self, name, bark_type):
    self.name = name
    self.bark_type = bark_type

  def get_name(self):
    return self.name

  def rename(self, new_name = ''):
    self.name = new_name

  def bark(self, to = ''):
    print('{}: {} -> {}'.format(self.name, bark_type, to))

dunco = Dog('Dunčo')
print(dunco.get_name)
dunco.bark()

another_dog = Dog('Hafo', 'buff')
print(another_dog.get_name)
another_dog.bark('Dano')
class Dog {
    constructor(name, barkType) {
      this.name = name;
      this.barkType = barkType;
    }

    rename(newName = '') {
      this.name = newName;
    }

    getName() {
      return this.name;
    }

    bark(to = '') {
      echo `{this.name}: {this.barkType} -> {to}`;
    }
}

let dunco = new Dog('Dunčo');
echo dunco.getName();
dunco.bark();

let anotherDog = new Dog('Hafo', 'buff');
echo anotherDog.getName();
anotherDog.bark('Dano');
public class Dog {

    private String name;
    private String barkType;

    public Dog(String name, String barkType) {
        this.name = name;
        this.barkType = barkType;
    }

    public void rename(String newName) {
        this.name = newName;
    }

    public String getName() {
        return this.name;
    }

    public void bark(String to) {
        System.out.println(this.name  + ": " + this.barkType + " -> " + to);
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        Dog dunco = new Dog("Dunčo", "baff");
        System.out.println(dunco.getName());
        dunco.bark("");

        Dog anotherDog = new Dog("Hafo", "buff");
        System.out.println(anotherDog.getName());
        anotherDog.bark("Dano");
    }
}

Poďme si to teda postupne rozobrať:

  1. Definícia triedy

    Ako si môžeme všimnúť v oboch jazykoch je podobná značína klúčovým slovom class následne ide jej meno. Mená tried začínajú s veľkým písmenom a píšu sa CamelCase.

    Python má jedno špecifikum, niekedy uvidíte prepis class Dog(object): alebo class Dog: obe sú správne a vyjadrujú to isté. Ich vysvetleniu sa dočkáme v dalšom článku.

  2. Konštruktor / Init

    Táto verejná metóda určuje s akými parametrami sa pri vytvorení Triedy bude pracovať. Zaujímavé je v nej slovičko self alebo $this, ide o kontext samotného objektu. Ako si môžeme všimnúť priradujeme hodnoty, ktoré sme definovali pri vytvorení na danú inštanciu, vytvorený objekt.

  3. Premenné = atribúty

    Následne keď vieme, čo za premenné budeme používať v triede vytvoríme si jej atribúty. O ich videteľnosť sa zatiaľ starať nebudeme, v prípade PHP. Stačí nám zatiaľ vedieť, že tieto premenné, teda atribúty budú dostupné cez self alebo $this v prípade PHP.

  4. Metódy

    Táto časť už obsahuje len metódy, všimnime si rozdiel PHP a Pythonu, pri pythone je nutné definovať self pre prístup k atribútom objektu/inštancie. Tieto metódy fungujú ako klasické funkcie, ale majú navyše prístup k samotnej inštancií Triedy.

  5. Vytvorenie inštancie

    V PHP sa používa klúčové slovo new, ktoré vytvára novú inštanciu danej triedy. V Pythone postačí spustiť Triedu s danými parametrami. Následne sa tieto parametre prenesú na inštanciu, nie na triedu!. A zvyšok hovorí za seba. Máme vytvorených dvoch psíkov, ktorý vedia rôzne hafkať, môžeme ich aj premenovať a vieme si aj zisiť ich mená.

Slovníček pojmov