« 1 2 3 »
Autor Zpráva
smiesek
Profil
Trochu jsem si chtěla nastudovat používání Tříd v php, ale ani po více jak týdnu se nějak nedokážu hnout a ani pochopit, k čemu mi to tak může být a jak je používat - snad jen to, že se to blíží OOP???
Neumím používat ani základní příkazy a tak hold se budu ptát od úplných začátků, protože když dám vyhledat v prohlížeči "Třídy v php" nebo další skomoleniny, nic mi nepomáhá a nerozumím tomu, stejně tak jako když jsem na YT shlédla české video a pak i nějaké anglické, jsem jen koukala, co se dělá a jaké existují případy a použití (datový typ, metoda, modifikátor přístupu, dědění...) ale už to neumím pochopit a vyzkoušet.
Pokud máte i nějaký typ na vysvětlení a používání tříd česky, budu ráda za doporučení.

Nyní tedy k mému prvnímu dotazu/případu.
Proč nemohu vypsat všechna data a vypíše se mi pouze jméno instance?

// deklarace třídy
class Hokejista {

    //deklarace členských proměnných s přiřazením modifikátoru přístupu
    public $jmeno;
    public $prijmeni;
    public $vek;

    // deklarace metody resp. funkce
    public function Ukaz() {
        return $this->jmeno;
        return $this->prijmeni;
        return $this->vek;
    }
}

// vytvoření instance
$h1 = new Hokejista();

// přirazení hodnot členským proměnným
$h1->jmeno = 'Petr';
$h1->prijmeni = 'Leška';
$h1->vek = 39;

// volání funkce pro výpis
echo $h1->Ukaz();

Děkuju za komentáře, už si nevím rady a budu si brzy trhat z toho vlasy a kopat kolem sebe :(
anonymníí
Profil *
smiesek:
S OOP ani třídami zběhlý nejsem, ale tvůj problém, proč je vrací jen jméno, je prostý. Funkce je ukončena prvním returnem, na který narazí, další řádky nezpracovává.

Řešením bude vytvořit třeba pole, které ta fce bude vracet.

public function Ukaz() {
    $out = array (
        'jmeno'     => $this->jmeno,
        'prijmeni'     => $this->prijmeni,
        'vek'        => $this->vek
    );

    return $out;
}
lionel messi
Profil
smiesek:
Proč nemohu vypsat všechna data a vypíše se mi pouze jméno instance?

Pretože metóda (podobne ako funkcia v procedurálnom programovaní) vráti návratovú hodnotu uvedenú prvým príkazom return a tým sa „ukončí“ (skúsenejší kolegovia vysvetlia lepšie).

Ak chcete vypísať všetky vlastnosti, naskladajte ich do jednej návratovej hodnoty:

public function Ukaz() {
        return $this->jmeno . " " . $this->prijmeni . " " . $this->vek;
    }

Výborná úprava je tiež tá od anonymníí.
juriad
Profil
smiesek:
Přikaz return na 11. řádce ukončí metodu a vratí jméno. Další příkazy se již nevykonají. To samé platilo i u obyčejných funkcí. Metoda jen navíc má přístup k proměnné [pre]$this, skoro nijak jinak se od funkce mimo třídu neliší.
Metoda Ukaz by mohla vypadat spíš takto:
    public function Ukaz() {
        return $this->jmeno . " " . $this->prijmeni . "(" . $this->vek . ")";
    }

Pak ti volání:
echo $h1->Ukaz();
Opravdu vypíše "Petr Leška (39)".

A ještě lepší by bylo pojmenovat tu metodu __toString (dvě podtržítka).
Pak bys ji ani nemusela volat (jednalo by se o magickou metodu, která se zavolá sama, kdykoli je potřeba string):
echo $h1;
Viz též php.net/manual/en/language.oop5.magic.php#object.tostring

Také není dobré nastavovat proměnné takto zvenku, ale je lepší vytvořit si konstruktor (metodu __construct), které všechny tři údaje předáš a ona je nastaví do proměnných.
Pak by vytváření hokejsty vypadalo:
$h1 = new Hokejista('Petr', 'Leška', 39);

anonymníí:
Ale pak nebude fungovat to echo; vypíše jen strohé "array" a smiesek bude ztracená i nadále.
smiesek
Profil
uf tak to nezvládnu - to je ztracený případ :(
I tak děkuju
lionel messi
Profil
smiesek:
se nějak nedokážu hnout a ani pochopit, k čemu mi to tak může být a jak je používat - snad jen to, že se to blíží OOP???

Správne použité objektovo orientované programovanie vám dovoľuje lepšiu a prehľadnejšiu organizáciu kódu, môžete napríklad dobre oddeliť vnútornú logiku aplikácie od výstupu a podobne.

K tzv. magickým metódam __toString a __construct: nie je nutné ich používať, ale výrazne uľahčia prácu. Bližšie informácie nájdete napríklad v článku: www.itnetwork.cz/php-tutorial-oop-atributy-magicke-metody (zrejme vás budú zaujímať aj predchádzajúce/nasledujúce diely odkázaného seriálu).
smiesek
Profil
lionel messi:
ano z toho dílu/resp. těch dílů jsem se snažila vycházet, ale prostě zatím nějak z toho nedokážu nic pochopit :(
Tak už nevím co dělám špatně že jak tak to vidím i v diskusích, mám jediný problém pouze já :(
anonymníí
Profil *
juriad:
Tak jasně, že to nebude reagovat na echo, když je to pole :-)

Ale z logiky věci si myslím, že než vracet ten string, mělo by to vracet (správně) pole. Jako kodérovi mi nepřijde vhodné, aby mi aplikace vracela cosi formátovaného, když se s tím má/může pracovat (i) jinak, v jiném formátu.

Oprav mě, pokud se pletu (na, řekněme, odbornější úrovni). Do začátku tazateli je pravda, že jsem měl volit (dle mého méně správné) echo.
smiesek
Profil
děkuju já se to snažím nějak pochytit a co jsem s poli zápasila, tak abych je mohla vypsat, bych je musela nechat projít např. pomocí foreachem a nebo vypsat pomocí print_r ale zase alespoň nyní do začátku tedy už nejsem alespoň ztracená v tom, proč to nemohlo vypisovat vše, jak jsem si myslela.
Alphard
Profil
anonymníí:
Ale z logiky věci si myslím, že než vracet ten string, mělo by to vracet (správně) pole.
Zapouzdřujícím objektem je třída samotná, lze se na ni dívat trochu jako na asociativní pole. Publikování (ideálně) private atributů tímto způsobem ven snad ani nepřináší žádné výhody. Jaký je pro vás jako pro kodéra rozdíl ve volání $pole['jmeno'] a $objekt->jmeno?

[#9] smiesek
Viz moje předchozí odpověď. __toString() je řekl bych specifická, dobrá na debugging, ale na výpis něčeho do šablony se určitě nehodí. Ideálně vytvořte pro každý z venku přístupný atribut getter a ten používejte přímo v šablonách.

Jméno: <b>{$instance->getJmeno()} {$instance->getPrijmeni()}</b>, věk: {$instance->getVek()}
PS: Ta složenina get a českého názvu vypadá hrozně :-)

Alternativně (buď pro začátek, nebo až se naučíte další magické metody) bez těch getterů
Jméno: <b>{$instance->jmeno} {$instance->prijmeni}</b>, věk: {$instance->vek}
anonymníí
Profil *
Alphard:
Jaký je pro vás jako pro kodéra rozdíl ve volání $pole['jmeno'] a $objekt->jmeno?
Pokud to vrací rovnou objekt, tedy $objekt->jmeno, tak pro mě pole nemá žádný význam (nevěděl jsem, že to vrací toto). Narážel jsem na návratovou hodnotu kolegů, kteří vraceli částečně formátovaný (ozávorkovaný) řetězec.

$objekt->jmeno $objekt->prijmeni ($objekt->vek) je za mě OK
$h1, jehož výstupem "Jméno Prijmeni (věk)" je nesmysl. Na to jsem narážel.
smiesek
Profil
Alphard:
já bych řekla, že tím to je jedno, nějak se snažím pochopit vůbec ten základ, což mi vůbec nejde.
Když se něco píše, příjde mi, že se to vysvětluje inteligentům a nikoliv pro osli jako jsem já.

Že jsou nějaké settery a gettery to jsem se nějak dočetla, stejně tak jako třeba proměnná $this, ale stejně to neumím použít a ani vysvětlit, kdy a kde tedy to jak použít. Hold jsem v tvrzení, raději to $this psát všude a kde to s tím nebude fungovat, tak to odmažu, ale to je pořád to co nechcu, zkoušet pokus-omyl bez logického uvažování a vysvětlení :( Ale v tom mi zase není pomoci.
Keeehi
Profil
anonymníí:
jehož výstupem "Jméno Prijmeni (věk)" je nesmysl. Na to jsem narážel.
Kdyby se ta metoda jmenovala Vrať, pak bych s tím souhlasil. Jenže ona se jmenuje Ukaz takže bych čekal, že spíš než aby mi něco vrátila, tak by to vypíše.

smiesek:
Je záhodno pojmenovávat metody malým písmenem na začátku. Velkým písmenem na začátku by měly začínat třídy.
smiesek
Profil
kluci to vůbec neřešte co a jak je pojmenováno a jakým způsobem to vrátit.

Já se snažím o pochopení vůbec nějakého principu a nebo základu, proto nepřemýšlím nad tím, jak to pojmenovat a nebo vracet, hlavně aby to splnilo ten účel :(
Alphard
Profil
smiesek:
stejně tak jako třeba proměnná $this
$this je v podstatě reference na aktuální instaci.
Když vyjdu z předpokladu, že budu každou členskou proměnnou (lépe atribut/vlastnost třídy) definovat na začátku třídy, tak se poté budu na tyhle proměnné a metody (a jenom na ně) odkazovat pomocí $this.
Jestlis četla o statických atributech, tak na ně teď zapomeň. Všechny ostatní proměnné budou normální lokální proměnné a budou se chovat jako v každé jiné funkci.
class Person {
  // atributy třídy, budu se na ně odkazovat pomocí $this
  private $name;
  private $bornYear;

  public function __construct($name, $bornYear) { // parametry metody, normální lokální proměnné
    $this->name = $name;
    $this->bornYear = $bornYear;
    // Tohle je konstruktor, z pohledu platnosti proměnných se chová jako normální funkce. Hodnoty předané do parametrů
    // budou po dokončení funkce smazány, proto si je kopíruji do atributů třídy, abych je mohl použít později.
  }

  // $this->name jsem definoval jako private, nejde k němu přistoupit z venku, takže mám metodu, která mi tu hodnotu vrátí
  public function getName() {
    return $this->name;
  }

  // Tohle je důvod, proč se používají gettery. Mohu provést nějaký výpočet.
  public function getAge() {
    return date('Y') - $this->bornYear;
  }
}

A pak to již zbývá jen použít:
$jagr = new Person('Jagr', 1972);
$vokoun = new Person('Vokoun', 1976);
// mám několik různých instancí jedné stejné třídy (interně se $this odkazuje vždy na tu správnou verzi)

// mohu si vytvořit funkci, které předám přímo instanci nějaké osoby
// tahle funkce mi simuluje šablonu, které bych předával data
function printPersonInfo(Person $person) {
  echo $person->getName(), '(vek: ', $person->getAge(), ')', PHP_EOL;
}

// a pak už jen vše vypsat
printPersonInfo($jagr);
printPersonInfo($vokoun);

Vypíše to
Jagr(vek: 43)
Vokoun(vek: 39)
smiesek
Profil
Alphard:
děkuju a projdu, ale prosím nedokážu pochopit slovní vyjádření, zmiňuješ jej i Ty a i v různých článcích to je "nejde přistoupit k proměnné z venku" - jak to poznám? co to znamená? Týká se to pouze předpokládám private a protected členských proměnných, tedy při public není nutné případně používat proměnnou $this? Nebo zase úplně plácám mimo? :/
Alphard
Profil
smiesek:
Týká se to pouze předpokládám private a protected členských proměnných
Ano. Je to ochrana interních interních atributů, aby je nebylo možné změnit.

tedy při public není nutné případně používat proměnnou $this?
To s tím vůbec nesouvisí. Když budou atributy veřejné, bude k nim možné (mimo jiné) přistoupit z venku, ale interně (uvnitř třídy) jsou přístupné úplně stejně přes $this.
Jiné řešení nedává smysl*. Když místo $this->name použiješ jen $name, odkazuješ se na lokální proměnnou (a ta buď v dané funkci neexistuje, nebo je to úplně jiná proměnná).

*Resp. by smysl dávat mohlo, ale v PHP to jinak nejde.
smiesek
Profil
Alphard:
a jak můžu udělat, abych mohla přistupovat z "nepřistoupit k proměnné z venku" k "přistoupit k proměnné z venku"?

proč pak i nemůže být následující modelový příklad, když funkce je protected, stejně tak jako proměnná $b ... $a chápu, $c taky, ale ne $b

<?php
class trida
{
  private $a = 1;
  protected $b = 2;
  public $c = 3;
 
  protected function metoda()
  {
    $this->a = 1; // v pořádku
    $this->b = 2; // v pořádku
    $this->c = 3; // v pořádku
  }
}
 
$objekt = new trida;
 
$objekt->a = 1; // nelze
$objekt->b = 2; // nelze
$objekt->c = 3; // v pořádku
 
$objekt->metoda(); // nelze
?> Více na: http://www.zive.cz/clanky/objekty-v-php-5---1-dil/sc-3-a-122728/default.aspx#utm_medium=selfpromo&utm_source=zive&utm_campaign=copylink

jak z toho pak tedy udělám, aby to bylo v pořádku $a a $b? Jen tím, že bych tomu dala public?

Ach jo, zase další úskalí co nikdy nepochopím a co není pro osli :( jen pro inteligenty

a to $this mám teda furt používat a nebo pouze pokud budu mít protected a private?

Stejně to je jedno, když nedokážu pochopit základy, tak je jasné, že to nebudu používat a nikde není návod pro osli, cokoliv dám vyhledat, se to vždy jinak píše a se to všude jen rozchází, nikde není originální návod ani popis, nic :( takže vždy zavřu prohlížeč a tím to končí cokoliv studovat, když tomu nerozumím - nepomůže ani svěcená voda a tlučko do hlavy
Tomáš123
Profil
smiesek:
Chápem tvoj prístup. Nikdy som veľmi nehľadal zdroje o OOP (tu na diskusii existuje akýsi súhrn), lebo som spočiatku nerozumel a po viacerých neúspešných pokusoch zavesil všetko na klinec (podobne ako ty nestojím o hrubé naštudovanie, ale dôkladné pochopenie).

Joker mi ale poradil nehľadať priamo OOP v PHP, ale snažiť sa pochopiť všeobecne princíp na niečom väčšom. Kúpil som si teda knihu Mistrovství v C++ a teraz ju po večeroch čítavam. Možno by si sa tiež mala vydať touto cestou. Podľa môjho názoru sú internetové zdroje príliš rozhádzané na to, aby z toho vedel vyjsť začiatočník/čka prípadne autor/i vytvoria seriál, ale nevedia, čo je začiatočníkovi nejasné a na čom stroskotá.

a to $this mám teda furt používat a nebo pouze pokud budu mít protected a private?
Pokiaľ som dobre pochopil základy, $this sa stále odvoláva výlučne na premenné v triede, ktoré sa používajú vo vnútri metódy. Jeho použitie nemá žiadny súvis s oborom. Skôr ide o to, čo potrebuješ urobiť.

Čo sa týka kódu [#18], asi rozumieš, prečo neprejdú riadky 18 a 19. Obory sú chránené proti prístupu zvonku a tak nemôžeš meniť hodnoty premenných/atribútov (neovládam terminológiu) priamo. Musíš použiť metódu.

Riadok 22, metóda má definovaný obor protected a opäť sa jedná o priamy prístup.

Pravdepodobne mám na vec príliš jednoduchý pohľad, takže to nemusí byť tak úplne pravda.
Moderátori: Ak píšem priveľa blbostí, pokojne ma odtiaľ zmažte. Nechcem vlákno poškodiť snahou ostatných uviesť všetko čo som napísal na pravú mieru. Ocením ale, keď mi napíšte čo bolo nesprávne.
tiso
Profil
smiesek: Tu sa pletie niekoľko vecí dokopy
Viditeľnosť premenných a metód:
public - dostupné odvšadial (zvonku, zvnútra)
private - dostupné iba zvnútra triedy
protected - dostupné zvnútra triedy a zvnútra potomkov triedy, nedostupné zvonku

Spôsoby prístupu k premenným:
čítanie zvonku priamo: $directAccess = $object->publicVar;//iba public premenne
čítanie zvonku nepriamo: $indirectAccess = $object->getVar();//vsetky typy premennych
zápis zvonku priamo: $object->publicVar = $value;//ako citanie
zápis zvonku nepriamo: $object->setVar($value);//ako citanie

čítanie zvnútra triedy priamo: $directAccess = $this->var;//vsetky typy
čítanie zvnútra triedy nepriamo: $indirectAccess = $this->getVar();//vsetky typy
zápis zvnútra triedy priamo: $this->var = $value;//ako citanie
zápis zvnútra triedy nepriamo: $this->setVar($value);//ako citanie

čítanie zvnútra potomka triedy priamo: $directAccess = $this->parentVar;//iba public a protected premenne
čítanie zvnútra potomka triedy nepriamo: $indirectAccess = $this->getParentVar();//zalezi kde je definovana metoda, ak v rodicovi, tak vsetky typy premennych, ak v potomkovi, tak len public a protected
zápis zvnútra potomka triedy priamo: $this->parentVar = $value;//ako citanie
zápis zvnútra potomka triedy nepriamo: $this->setParentVar($value);//ako citanie

Správnosť návrhu
- zvonku dostupné premenné a metódy definujú rozhranie triedy
- viditeľnosť treba nastaviť tak, aby sa objekt nemohol dostať do nekonzistentného stavu
- používanie public premenných nie je dobrý spôsob
- private a protected metódy sú pomocné, slúžia len vo vnútri triedy, používajú sa na sprehľadnenie a odstránenie duplicít
smiesek
Profil
tiso:
používanie public premenných nie je dobrý spôsob
takže všeobecně ve třídách, když se použíají public proměnné to je špatně? Proč to tedy se uvádí v modelových příkladech?
Jak se mám pak něco učit, když polovina z toho je blbě? Sice to funguje, ale nepoužívá se to?
To je to, čemu se chci vyhnout a nedokáže nikdo pochopit, pořád mě peskujou, ať si přečtu nějaké základy apod. ale když se to v praxi nepoužívá, k čemu mi to bude?

Ty přístupy k proměnným si zkusím nějak nastudovat, určitě dobrý výčet konečně někde takhle pospolu dohromady, jen si to budu muset přepsat do češtiny a udělat i s příklady. Takhle se to snažím pochytit fotografickou pamětí, což je blbě :(

Ještě tedy opět k terminologii:
a) přímo - to jsou proměnné public
b) nepřímo - to jsou proměnné protected a private

Nebo opět blbě a slova "přímo" a "nepřímo" mají jiné použití? Co to tedy znamená "přímo" a "nepřímo" a jak to poznám?

A ještě:
A) zvenku
B) zevnitř

Kdy poznám pro co se rozhodnout, kdy zapisovat "zvenku" a kdy "zevnitř"?
juriad
Profil
smiesek:
Návody začínají tím, že se modifikátor přístupu neuvádí nebo se uvádí automaticky public (to je ve výsledku to samé) proto, že chtějí, aby vše začátečníkům fungovalo. Na public, protected, private klidně můžeš zapomenout a představovat si, že všude je public. Důvod, proč se tyto modifikátory zavedly, je ten, že často chceš uživateli tvé knihovny tříd říct, co smí volat a co smí měnit. Jakmile je něco public a tvůj kód je široce používaný, změna modifikátoru znamená, že někomu něco přestane fungovat, protože vždy se najde někdo, kdo tvoji třídu používá jinak, než ty zamýšlíš. Když je něco public, musíš počítat s tím, že takovou metodu někdo může zavolat nebo takovou proměnnou změnit a tvůj kód s tím musí počítat, protože to tak přece inzeroval.
Pokud se jedná o malý projekt, který se nedostane do rukou (z hlediska zdrojového kódu) širší veřejnosti, na modifikátorech nezáleží.

Zapomeň na to přímo a nepřímo. To chápeš úplně špatně a tiso to také nevysvětlil dobře. Třída obsahuje proměnné (často se jim také říká atributy nebo vlastnosti/property) a metody. Může se ti stát, že chceš reprezentovat osobu, která já jakkoli dlouhé jméno. Může mít třeba dvě prostřední jména. J. R. R. Tolkien. Pak bys asi části jména uchovávala v poli, ale nechceš, aby uživatel měl přistup k tomu poli, protože by něco mohl rozvrtat, takže mu nabídneš metody, které mu budou vracet to, co mají.

class Osoba {
  private $jmena; # toto bude pole, například: ['Jean-Claude', 'Camille', 'François', 'Van Varenberg']
  public function __construct(array $jmena) {
    $this->jmena = $jmena;
  }
  public function getKrestniJmeno() { # jen první část
    return $this->jmena[0];
  }
  public function getKrestniJmena() { # vše kromě poslední části
    return implode(array_slice($this->jmena, 0, count($this->jmena - 1));
  }
  public function getPrijmeni() { # jen poslední část
    return $this->jmena[count($this->jmena) - 1];
  }
}

To, co tiso nazval nepřímým přístupem je postup, kdy se vytvoří dvojice metod, která slouží k přístupu a změně proměnné. Je to výhodné z důvodu, že je pak jedno, jak je informace uvnitř třídy uložena:
function getKrestniJmeno() {
  return $this->jmena[0];
}
function setKrestniJmeno($krestni) {
  $this->jmena[0] = $krestni;
}

Obvykle se ale nic zajímavého neděje a getter a setter (tak se ty metody nazývají) jsou primitivní:
function getVek() { # getter
  return $this->vek;
}
function setVek($vek) { # setter
  # if ($vek >= 0)
  $this->vek = $vek;
}
Ale už tady vidíš, že v setteru bys mohla kontrolovat, že věk je nezáporné číslo. A v připadě záporného bys změnu odmítla provést (naznačený if).

Kdybys měla proměnnou $vek public, nějaký uživatel by udělal toto a projde mu to. Nemáš šanci tomu zabránit.
$o = new Osoba(['Pepa', 'Novák']);
$o->vek = -4000;
Ale setter (pokud $vek není public) mu v tom zabrání:
$o->setVek(-4000);

To je důvod, proč je často proměnná private/protected a existují k ní getter a setter, přestože nedělají nic užitečného. Zatím. Až si někdo vzpomenne, že je třeba kontrolovat hodnotu, bylo by už pozdě měnit modifikátor a vytvářet metodu, to by všichni programátoři používající tvůj kód museli vše opravit.

Toto nazval tiso rozdílem mezi přímým a nepřímým přístupem k proměnné.
juriad
Profil
Zevnitř objektu: z metody té třídy (nebo jejích potomků).
To jsou všechny přístupy k proměnné $jmena v ukázkách, přistupy k $vek v getVek a setVek.
Ukázka volání zevnitř by byla třeba metoda (to znamená, že je definovaná uvnitř třídy Osoba):
function getFormatovaneJmeno() { # jen pro ilustraci; třída Osoba se nemá starat o formátování
  return $this->getKrestniJmena() . " <b>" . $this->getPrijmeni(); # metody jsou voláný zevnitř objektu
}

Zvenku objektu: jinak
To je v ukázce přístup na řádce: $o->vek = -4000;
To jsou všechna volání metod v ukázkách.

Výše uvedená metoda by šla implemtovat jako funkce, pak bude přístup k metodám getKrestniJmena a getPrijmeni zvenku objektu.
function getFormatovaneJmeno($osoba) { # teď by nebyla defininovaná uvnitř třídy Osoba, ale mimo, proto také nemá příštup k $this a osoba, se kterou bude pracovat se musí předat jako argument
  return $osoba->getKrestniJmena() . " <b>" . $osoba->getPrijmeni();
}

Asi sis všimla toho rozdílu: zevnitř - používáš $this; zvenku - používáš proměnnou, ve které je objekt, například tady je to $osoba.
smiesek
Profil
juriad:
já nějak z toho nic nechápu :(

Takže pokud je nepřímo = použití getteru a setteru?

Taky nechápu to s tím věkem, jak tomu setter zabrání? Jak veřejnou? Však nyní je veřejná ne?

:( to je v háji, jak mám něco používat, když to nikde není normálně napsané a hlavně vysvětlené?


juriad:
hm tak to taky nechápu, zase jen vidím $this = aha tak to asi bude zevnitř
juriad
Profil
smiesek:
Když budeš mít:
public $vek;
Tak ti tam uživatel může uložit cokoli. Ani to nemusí být číslo.

Když budeš mít:
private $vek;
Tak nemůže nic. Můžeš mu ale vytvořit metodu setVek, která bude kontrolovat, co chce uživatel uložit.
smiesek
Profil
juriad:
při public se to nedá kontrolovat?
Keeehi
Profil
smiesek:
při public se to nedá kontrolovat?
Ano.

Jen upřesním, že uživatel v tomto případě znamená jiný programátor, který používá tebou vytvořené třídy.
smiesek
Profil
Keeehi:
nechápu, dá nebo nedá?

To s tím programátorem už je pro mě úplně ztraceno
tiso
Profil
smiesek: ideš na to od lesa. Ja som ti tu dal dokopy čo znamenajú viditeľnosti public/protected/private, aj ako sa dá pristupovať k premenným v rôznych kontextoch. Keď to dáš dokopy, tak ti víde, ako sa dá pristupovať ku premenným z rôznou viditeľnosťou. Výsledkom je, že je viacero spôsobov ako to robiť. A to je to, čo potrebuješ pochopiť.

Zvyšok medzitým vysvetlil juriad.
smiesek
Profil
tiso:
jenže já prostě nevím jak se to mám naučit :(
však mi nic nejde, nepoužitelná sem :(
« 1 2 3 »

Vaše odpověď

Mohlo by se hodit


Prosím používejte diakritiku a interpunkci.

Ochrana proti spamu. Napište prosím číslo dvě-sta čtyřicet-sedm: