WEBVTT

00:00:01.006 --> 00:00:03.482
Wracamy do programu
tworzącego Winstonów.

00:00:03.582 --> 00:00:06.335
Dodałam nowy typ obiektu: Hopper,

00:00:06.435 --> 00:00:08.637
bo Hopper czuła się pominięta.

00:00:08.737 --> 00:00:11.977
Definiuję ją tak samo jak Winstona.

00:00:12.077 --> 00:00:14.210
Zaczynam od konstruktora,

00:00:14.310 --> 00:00:16.927
potem są właściwości,
rysowanie i mówienie...

00:00:17.027 --> 00:00:20.828
Dodałam też metodę „Hura!”,

00:00:20.928 --> 00:00:25.216
bo Hopper bardzo lubi świętować.
A Winston - wcale.

00:00:25.316 --> 00:00:29.785
U dołu funkcji stworzyłam
dwa nowe obiekty „Hopper”:

00:00:29.885 --> 00:00:32.972
Dużą i Małą. Narysowałam je.

00:00:33.072 --> 00:00:36.540
Jednej przypisałam funkcję
mówienia, drugiej - „Hura”.

00:00:36.640 --> 00:00:40.081
I dobrze. Patrząc
w ten fragment programu,

00:00:40.181 --> 00:00:42.504
możecie zauważyć coś ciekawego.

00:00:42.604 --> 00:00:47.162
Program dla Hopper
jest podobny do tego dla Winstona.

00:00:47.262 --> 00:00:49.133
Zwróćcie uwagę na konstruktora.

00:00:49.233 --> 00:00:54.822
Może pamiętacie... To dokładnie
ten sam program, co u Winstona.

00:00:54.922 --> 00:01:00.186
I funkcja „talk” jest identyczna
jak u niego.

00:01:01.045 --> 00:01:04.311
Jedno i drugie ma funkcję „draw”.

00:01:04.411 --> 00:01:07.175
Te dwa typy obiektów wiele łączy!

00:01:07.275 --> 00:01:12.817
To ma sens, bo Hopper i Winston
są podobnymi typami w naszym świecie.

00:01:12.917 --> 00:01:17.067
Zresztą w prawdziwym świecie,
poza komputerem,

00:01:17.879 --> 00:01:20.717
wiele typów obiektów
przypomina inne.

00:01:20.817 --> 00:01:22.732
Np. w królestwie zwierząt.

00:01:22.832 --> 00:01:25.310
Wszystkie zwierzęta
są do siebie podobne.

00:01:25.410 --> 00:01:29.065
Ale są różne typy zwierząt,
np. ludzie.

00:01:29.165 --> 00:01:34.365
Ludzie są podobni do zwierząt,
a także do siebie nawzajem.

00:01:34.465 --> 00:01:37.918
Możemy więc powiedzieć,
że „zwierzę” to typ obiektu,

00:01:38.018 --> 00:01:41.680
od którego typ obiektu „człowiek”
dziedziczy funkcjonalność.

00:01:41.780 --> 00:01:43.560
Nie zaczynamy się z niczego;

00:01:43.660 --> 00:01:46.718
dodajemy cechy do tych,
które mamy jako zwierzęta.

00:01:46.818 --> 00:01:48.922
Wszystkie zwierzęta wydają odgłosy,

00:01:49.022 --> 00:01:50.944
a ludzie dodatkowo mówią.

00:01:51.823 --> 00:01:56.331
Pojęcie dziedziczenia obiektów
przydaje się też w programowaniu.

00:01:56.431 --> 00:02:00.650
W JavaScript możemy stworzyć
łańcuch dziedziczenia obiektów.

00:02:00.750 --> 00:02:04.830
Zastanówmy się, co łączy
nasze typy obiektów.

00:02:04.930 --> 00:02:06.641
I wymyślmy nazwę.

00:02:06.741 --> 00:02:10.542
Stworzymy nowy typ obiektu,
reprezentujący obiekt bazowy.

00:02:10.642 --> 00:02:13.561
Dajmy nazwę: „Creatures”
(istoty). Bo nimi są.

00:02:13.661 --> 00:02:16.092
Piszemy: „var creature =”...

00:02:16.192 --> 00:02:17.980
Potrzebujemy konstruktora.

00:02:18.080 --> 00:02:22.802
Ma go Hopper.
Taki sam jest u Winstona.

00:02:22.902 --> 00:02:25.171
W porządku? I teraz...

00:02:25.271 --> 00:02:28.445
Zobaczmy... Teraz chcemy...

00:02:28.545 --> 00:02:33.251
Co dalej? Może dodamy
funkcję „talk”?

00:02:33.351 --> 00:02:35.829
Zabierzemy ją.

00:02:35.929 --> 00:02:39.822
Musi być w prototypie „creature”.

00:02:39.922 --> 00:02:41.216
W porządku.

00:02:41.316 --> 00:02:45.209
Mamy już typ obiektu „creature”.

00:02:45.309 --> 00:02:48.205
Ale Hopper musi się dowiedzieć,

00:02:48.305 --> 00:02:52.524
że ma na opierać swoje działanie
na „creature”.

00:02:52.624 --> 00:02:55.589
Załatwimy to, pisząc ten wiersz.

00:02:55.689 --> 00:02:58.863
Piszemy: „Hopper.prototype”

00:02:58.963 --> 00:03:02.485
równa się „object.create”

00:03:02.585 --> 00:03:04.839
„creature.prototype”.

00:03:04.939 --> 00:03:07.996
Ten wiersz każe językowi JavaScript

00:03:08.096 --> 00:03:12.121
oprzeć prototyp,
czyli funkcjonalność Hopper,

00:03:12.221 --> 00:03:14.908
na prototypie „creature”.

00:03:15.008 --> 00:03:19.970
Zawsze, gdy program szuka
funkcji u Hopper,

00:03:20.070 --> 00:03:22.965
najpierw spojrzy na prototyp.

00:03:23.065 --> 00:03:26.657
A jeśli tam nie znajdzie,
to spojrzy na prototyp „creature”.

00:03:26.757 --> 00:03:28.956
To nazywamy łańcuchem prototypów.

00:03:29.652 --> 00:03:31.464
Po zrobieniu tego

00:03:31.564 --> 00:03:35.156
powinno być możliwe skasowanie
funkcji „talk” u Hopper.

00:03:35.256 --> 00:03:37.454
Bo jest już w „creature”.

00:03:37.554 --> 00:03:39.793
Wyżej w łańcuchu prototypów.
Spróbujmy!

00:03:39.893 --> 00:03:42.841
Gotowi? Udało się!

00:03:42.941 --> 00:03:47.648
Bo program znalazł funkcję
w prototypie „creature”.

00:03:48.762 --> 00:03:51.479
Spróbujmy skasować
tę funkcję u Winstona.

00:03:53.221 --> 00:03:57.958
Nie udało się. Obiekt nie ma
metody „talk”.

00:03:58.058 --> 00:03:59.513
A dlaczego?

00:03:59.613 --> 00:04:02.787
Są konstruktor i „draw”,
a „talk” usunęliśmy.

00:04:02.887 --> 00:04:06.583
Zapomnieliśmy powiedzieć
prototypowi Winstona,

00:04:06.683 --> 00:04:10.109
że ma się opierać na prototypie
„creature”. Ważny wiersz:

00:04:10.209 --> 00:04:15.489
„Winston.prototype=object.create
creature.portotype”.

00:04:17.995 --> 00:04:21.038
Już! Zauważcie coś istotnego:

00:04:21.137 --> 00:04:23.682
Ten wiersz jest po konstruktorze,

00:04:23.782 --> 00:04:27.135
ale wpisuję go, zanim dodam coś
do prototypu Winstona.

00:04:27.235 --> 00:04:29.792
Zazwyczaj chcemy powiedzieć,

00:04:29.892 --> 00:04:34.181
że na tym będzie się opierać
początkowy prototyp.

00:04:34.281 --> 00:04:37.106
Możemy dodawać do prototypu
kolejne elementy.

00:04:37.206 --> 00:04:40.775
Winston i Hopper mogą mieć
charakterystyczne cechy,

00:04:40.875 --> 00:04:45.210
których nie ma w „creatures”.
Super, że można je zdefiniować!

00:04:46.557 --> 00:04:49.901
No dobrze. Widzimy
powtarzające się fragmenty.

00:04:50.001 --> 00:04:51.334
To konstruktor.

00:04:51.434 --> 00:04:53.918
Ten sam we wszystkich
trzech przypadkach.

00:04:54.018 --> 00:04:56.843
Czy możemy go skasować?

00:04:58.028 --> 00:04:59.189
Spróbujmy.

00:05:01.000 --> 00:05:03.577
Hmmm... Nie udało się.

00:05:03.677 --> 00:05:07.726
Hopper pokazuje się w lewym górnym
rogu. Nie pamięta nic o sobie.

00:05:07.826 --> 00:05:10.868
Bo JavaScript nie zakłada,

00:05:10.968 --> 00:05:15.118
że chcemy tego samego konstruktora,
nawet gdy ma być w prototypie.

00:05:15.218 --> 00:05:19.181
Pozwala nam zdefiniować
konstruktora dla tych obiektów.

00:05:19.281 --> 00:05:22.548
I daje łatwy sposób,
by przywołać

00:05:22.648 --> 00:05:26.031
tę funkcję z obiektu.

00:05:26.131 --> 00:05:29.003
Piszemy więc: „creature”...

00:05:29.103 --> 00:05:30.187
kropka, „call”,

00:05:30.954 --> 00:05:35.342
„this,nickname,age,x,y”.

00:05:35.738 --> 00:05:36.503
Dobrze.

00:05:36.603 --> 00:05:39.289
Program robi to
(zauważcie - zadziałało!)...

00:05:39.389 --> 00:05:44.607
przywołuje funkcję
„creature”, konstruktora.

00:05:44.707 --> 00:05:47.958
Przywołuje funkcję, ale mówi:

00:05:48.058 --> 00:05:53.268
„przywołaj tę funkcję tak
jak z obiektu Hopper,

00:05:54.065 --> 00:05:56.745
jak z tymi argumentami”.

00:05:56.845 --> 00:05:59.607
Tak została przywołana Hopper.

00:05:59.707 --> 00:06:03.810
Program zostanie wykonany tak,
jakby był tutaj.

00:06:03.910 --> 00:06:05.480
I o to właśnie nam chodzi.

00:06:05.582 --> 00:06:06.712
Udało się!

00:06:06.812 --> 00:06:09.917
Możemy skopiować ten wiersz

00:06:10.017 --> 00:06:13.678
także do konstruktora Winstona.

00:06:14.862 --> 00:06:16.883
To działa. Tak!

00:06:16.983 --> 00:06:19.019
Dobrze. Patrzcie:

00:06:19.119 --> 00:06:21.991
zamknęliśmy wspólne właściwości
i funkcjonalność

00:06:22.091 --> 00:06:24.661
w jednym typie obiektu bazowego,
„creature”,

00:06:24.761 --> 00:06:28.144
i na tej podstawie stworzyliśmy
dwa typy obiektów.

00:06:28.244 --> 00:06:31.737
Dziedziczą funkcjonalność,
ale dodają też własną.

00:06:31.837 --> 00:06:36.271
Wystarczy zmienić tę funkcjonalność
w jednym miejscu.

00:06:36.371 --> 00:06:40.869
Np. moglibyśmy zmienić wiek,
pisząc: „plus lata”.

00:06:40.969 --> 00:06:43.934
Teraz każdy ma na końcu „lata”.

00:06:44.034 --> 00:06:48.206
Możemy też zmienić
funkcje „talk”. „Super!”.

00:06:48.306 --> 00:06:52.107
Teraz każdy Winston
i Hopper mówią: „Super!”.

00:06:52.897 --> 00:06:56.589
Wiecie, jak tworzyć typy obiektów
i jak przebiega dziedziczenie.

00:06:56.689 --> 00:07:00.099
Pomyślcie, jak to wykorzystać
w rysowaniu, animacjach,

00:07:00.199 --> 00:07:01.422
symulacjach i grach.

00:07:01.522 --> 00:07:04.560
Np. macie grę
z wieloma postaciami...

00:07:04.660 --> 00:07:07.542
Wszystkie biegają,
ale tylko niektóre skaczą.

00:07:07.642 --> 00:07:11.589
Tu trzeba wykorzystać typy
obiektów i dziedziczenie!

00:07:11.689 --> 00:07:15.304
Na pewno wymyślicie też
mnóstwo własnych zastosowań.