WEBVTT

00:00:00.977 --> 00:00:03.623
Jsme zpět u našeho programu,
který vytváří Winstony.

00:00:03.623 --> 00:00:06.339
Ale přidala jsem nový 
typ objektu a to Hoppera.

00:00:06.339 --> 00:00:08.739
Protože Hopper se cítil
trochu opomenutý.

00:00:08.739 --> 00:00:11.924
Teď definuji Hoppera stejným 
způsobem, jakým definuji Winstona.

00:00:11.924 --> 00:00:15.394
Počínaje funkcí konstruktoru
a stejnými vlastnostmi.

00:00:15.394 --> 00:00:16.963
Máme zde draw a talk...

00:00:16.963 --> 00:00:20.933
A pak jsem také přidala 
další metodu zvanou Horray.

00:00:20.933 --> 00:00:25.328
Protože Hoppeři opravdu rádi
slaví a Winstoni zase ne.

00:00:25.328 --> 00:00:29.924
Ve spodní části funkce jsem 
vytvořila dva nové objekty Hoppera:

00:00:29.924 --> 00:00:31.524
Little Hoppera a Big Hoppera.

00:00:31.524 --> 00:00:36.507
Nakreslila jsem je a na jednoho
zavolala "talk" a na druhého "hooray".

00:00:36.507 --> 00:00:37.676
Je to celkem povedené.

00:00:37.676 --> 00:00:42.648
Když se ale podíváte na horní část kódu,
možná si všimnete něčeho zajímavého.

00:00:42.648 --> 00:00:47.314
Kód pro Hoppera je velmi podobný
kódu pro Winstona.

00:00:47.314 --> 00:00:49.464
Obzvláště se podívejte 
na tento konstruktor.

00:00:49.464 --> 00:00:50.844
Nevím, jestli si vzpomínáte,

00:00:50.844 --> 00:00:54.864
ale tento kód vypadá úplně stejně
jako kód pro konstruktor Winstona.

00:00:54.864 --> 00:00:58.493
Tato funkce talk je taky
definována úplně stejným kódem,

00:00:58.493 --> 00:01:00.507
jako funkce talk u Winstona.

00:01:02.002 --> 00:01:03.897
Oba mají také funkci draw.

00:01:03.897 --> 00:01:07.382
Tyto dva typy objektů mají
tedy hodně společného.

00:01:07.382 --> 00:01:08.841
A dává to smysl,

00:01:08.841 --> 00:01:13.299
protože Hopper a Winston jsou v našem
světě dva velmi podobné typy objektů.

00:01:13.299 --> 00:01:17.879
A pokud uvažujete o skutečném světě,
o tom mimo počítač,

00:01:17.879 --> 00:01:20.809
většina typů objektů sdílí podobné rysy
s jinými typy objektů.

00:01:20.809 --> 00:01:22.453
Například zvířecí říše.

00:01:22.453 --> 00:01:25.543
Všechna zvířata jsou 
v některých ohledech podobná.

00:01:25.543 --> 00:01:29.762
A pak máme různé typy
zvířat, jako například lidi.

00:01:29.762 --> 00:01:34.298
Lidé hodně podobností sdílejí, ale také
mají své vlastní jedinečné podobnosti.

00:01:34.298 --> 00:01:38.100
Takže bychom mohli říct, 
že zvíře je typ objektu,

00:01:38.100 --> 00:01:41.627
od kterého typ lidského objektu
zdědil určitou funkčnost.

00:01:41.627 --> 00:01:43.634
Nezačíname úplně od nuly.

00:01:43.634 --> 00:01:46.894
Přidáváme k funkcionalitě,
kterou máme jako zvíře.

00:01:46.894 --> 00:01:51.796
Stejně jako všechna zvířata 
vydávají zvuky, tak lidé mají řeč.

00:01:51.796 --> 00:01:56.363
Koncept dědičnosti objektu
je opravdu užitečný při programování.

00:01:56.363 --> 00:02:00.715
Můžeme dokonce vytvořit řetězec
dědičnosti objektů v našem Javascriptu.

00:02:00.715 --> 00:02:05.039
Abychom to provedli, musíme zjistit,
co naše typy objektů spolu sdílejí.

00:02:05.039 --> 00:02:06.875
A musíme pro to 
vymyslet nějaký název.

00:02:06.875 --> 00:02:09.055
Protože se chystáme vytvořit
nový typ objektu,

00:02:09.055 --> 00:02:11.089
který představuje základní objekt.

00:02:11.089 --> 00:02:12.645
Nazvěme je creatures (tvorové).

00:02:12.645 --> 00:02:13.984
Oba jsou totiž tvory.

00:02:13.984 --> 00:02:16.111
Takže napíšeme: 
var creature se rovná.

00:02:16.111 --> 00:02:18.081
A nyní potřebujeme náš konstruktor.

00:02:18.081 --> 00:02:19.641
Pojďme ho tedy ukrást Hopperovi,

00:02:19.641 --> 00:02:23.412
protože je to to samé,
co má Winston.

00:02:26.542 --> 00:02:29.392
Co chceme dělat dál?

00:02:29.392 --> 00:02:32.986
Možná chceme přidat
funkci "talk".

00:02:32.986 --> 00:02:36.123
Funkci talk bychom mohli
ukrást Hoppperovi.

00:02:36.123 --> 00:02:39.693
Ale samozřejmě to musíme mít
v prototypu Creature.

00:02:41.213 --> 00:02:45.540
Takže teď máme tento 
typ objektu Creature.

00:02:45.540 --> 00:02:48.000
Ale ještě musíme Hopperovi říct,

00:02:48.000 --> 00:02:52.391
že Hopper by vlastně měl zakládat 
svou funkčnost na základě Creature.

00:02:52.391 --> 00:02:55.901
Můžeme to udělat napsáním
tohoto řádku zde.

00:02:55.901 --> 00:03:04.750
Napíšeme: Hopper.prototype rovná 
se object.create(creature.prototype);

00:03:04.750 --> 00:03:09.567
Tento řádek říká, aby Javascript 
založil Hopperův prototyp,

00:03:09.567 --> 00:03:15.357
čili všechny jeho funkce,
na základě prototypu Creature.

00:03:15.357 --> 00:03:19.857
To znamená, že pokaždé, 
když hledá funkci pro Hoppera,

00:03:19.857 --> 00:03:23.777
podívá se nejprve na Hopperův 
prototyp a pokud ho nenajde,

00:03:23.777 --> 00:03:26.619
podívá se, zda je součástí
prototypu Creature.

00:03:26.619 --> 00:03:29.496
A to je to, čemu říkáme
prototypový řetězec.

00:03:29.496 --> 00:03:31.442
Jakmile máme toto hotovo,

00:03:31.442 --> 00:03:35.592
měli bychom být schopni smazat 
funkci talk pro Hoppera,

00:03:35.592 --> 00:03:37.602
protože ta již existuje
v rámci Creatura.

00:03:37.602 --> 00:03:40.300
Je už v prototypovém řetězci, 
tak to zkusíme.

00:03:42.202 --> 00:03:47.701
Funguje to a to kvůli tomu,
že talk najdeme u prototypu Creature.

00:03:48.574 --> 00:03:52.634
Zkusme to smazat 
také u Winstona.

00:03:53.574 --> 00:03:55.620
Nefungovalo to.

00:03:55.620 --> 00:03:58.170
Máme hlášení, že objekt 
nemá žádnou metodu talk.

00:03:58.170 --> 00:03:59.430
Ale proč to tak je?

00:03:59.430 --> 00:04:02.993
Máme náš konstruktor Winstona i
funkci draw a jenom jsme odebrali talk.

00:04:02.993 --> 00:04:06.297
Všimnete si, že jsme zapomněli
říci prototopu Winstona,

00:04:06.297 --> 00:04:08.601
že má být založen na základě 
prototypu Creature.

00:04:08.601 --> 00:04:10.741
Potřebujeme tedy přidat 
velmi důležitý řádek:

00:04:10.741 --> 00:04:15.961
Winston.prototype rovná se
Object.create(Creature.prototype);

00:04:19.156 --> 00:04:20.636
Všimněte si něčeho důležitého.

00:04:20.636 --> 00:04:23.526
Tento řádek máme až po
funkci konstruktoru,

00:04:23.526 --> 00:04:27.038
ale předtím, než k prototypu Winstona
přidáme cokoli jiného.

00:04:27.038 --> 00:04:29.053
Obvykle to chcete udělat tak,

00:04:29.053 --> 00:04:33.950
že si nejdříve určíte,
jaký prototyp bude výchozí.

00:04:33.950 --> 00:04:36.974
Poté k prototypu
přidáváte další věci.

00:04:36.974 --> 00:04:38.923
Protože by mohly 
existovat nějaké věci,

00:04:38.923 --> 00:04:41.851
které jsou jedinečné pro Winstony 
nebo jedinečné pro Hoppery.

00:04:41.851 --> 00:04:43.159
Nejsou závislé na Creature.

00:04:43.159 --> 00:04:46.609
A to je naprosto v pohodě,
můžete je definovat.

00:04:46.609 --> 00:04:50.205
Teď, když se na to podíváme,
pořád se nám opakuje nějaký kód.

00:04:50.205 --> 00:04:51.274
Kód konstruktoru.

00:04:51.274 --> 00:04:54.630
Máme ho celkem třikrát.

00:04:54.630 --> 00:05:00.618
Co kdybychom ho smazali,
pojďme to zkusit.

00:05:00.618 --> 00:05:03.248
Dobře, vypadá to,
že to takhle nepůjde.

00:05:03.248 --> 00:05:05.369
Náš Hopper se objevil
v levém horním rohu.

00:05:05.369 --> 00:05:08.415
A všechno o sobě zapomněl.

00:05:08.415 --> 00:05:10.944
To se stalo kvůli tomu, 
že Javascript nepředpokládá,

00:05:10.944 --> 00:05:15.014
že chcete stejný konstruktor,
i když na něm chcete založit prototyp.

00:05:16.004 --> 00:05:19.109
To vám umožní definovat svůj vlastní
konstruktor pro tyto objekty.

00:05:19.109 --> 00:05:26.168
Ale také vám to ulehčuje
volání konstruktoru z podobjektu.

00:05:26.168 --> 00:05:28.426
Způsob, jakým to můžeme udělat,
je, že napíšeme:

00:05:28.426 --> 00:05:35.860
Creature.call(this, nickname, age, x, y);

00:05:36.620 --> 00:05:47.441
Dělá to to, že se zavolá funkce Creature,
konstrukční funkce, a řekne se:

00:05:47.441 --> 00:05:53.599
Zavolejme si konstruktor funkce,
tak jako u objektu Hoppera.

00:05:53.954 --> 00:05:56.778
A to přesně s těmi 
samými argumenty.

00:05:56.778 --> 00:05:59.177
To jsou argumenty,
které používáme u Hoppera.

00:05:59.177 --> 00:06:03.609
A tím se provede tento kód, 
jako by to bylo právě tady.

00:06:03.609 --> 00:06:05.557
A přesně to chceme.

00:06:05.557 --> 00:06:06.557
A fungovalo to.

00:06:06.557 --> 00:06:13.809
Můžeme pokračovat a zkopírovat
tento řádek i do konstruktoru Winstona.

00:06:14.665 --> 00:06:16.721
A funguje to.

00:06:17.824 --> 00:06:18.811
Podívejte na to.

00:06:18.811 --> 00:06:21.971
Shrnuli jsme všechny naše sdílené
vlastnosti a funkce o objektech,

00:06:21.971 --> 00:06:24.651
do tohoto jediného a základního 
typu objektu: Creature.

00:06:24.651 --> 00:06:28.657
A vytvořili jsme dva typy objektů, které
jsou rozšířením tohoto základního objektu.

00:06:28.657 --> 00:06:31.681
Zdědí nějakou funkčnost,
ale také přidávají své vlastní.

00:06:31.681 --> 00:06:33.059
A opravdu skvělé je to,

00:06:33.059 --> 00:06:36.239
že můžeme změnit sdílenou
funkčnost na jednom místě.

00:06:36.239 --> 00:06:40.769
Kdybychom chtěli změnit věk,
stačilo by napsat: "+ years old".

00:06:40.769 --> 00:06:43.938
Super, teď všichni mají
"years old" na konci.

00:06:43.938 --> 00:06:46.331
Nebo bychom mohli 
změnit funkci "talk".

00:06:49.231 --> 00:06:53.071
A nyní Winstoni i Hoppeři
říkají "sup".

00:06:53.071 --> 00:06:54.381
Takže teď jste viděli,

00:06:54.381 --> 00:06:56.768
jak vytvářet typy objektů
a jak typu objektu dědit.

00:06:56.768 --> 00:06:58.163
Můžete začít přemýšlet o tom,

00:06:58.163 --> 00:07:02.044
jak by to mohlo být užitečné ve vašich 
kresbách, animacích, simulacích a hrách.

00:07:02.044 --> 00:07:05.054
Můžete mít třeba hru, která
obsahuje mnoho typů postav.

00:07:05.054 --> 00:07:07.833
Všechny mohou běžet,
ale jen některé mohou skákat.

00:07:07.833 --> 00:07:11.870
To je perfektní místo pro použití
typů objektů a jejich dědičnosti.

00:07:11.870 --> 00:07:15.790
Vsadím se, že dokáže přijít
na hodně dalších příkladů.