1
00:00:01,006 --> 00:00:03,482
Wracamy do programu
tworzącego Winstonów.

2
00:00:03,582 --> 00:00:06,335
Dodałam nowy typ obiektu: Hopper,

3
00:00:06,435 --> 00:00:08,637
bo Hopper czuła się pominięta.

4
00:00:08,737 --> 00:00:11,977
Definiuję ją tak samo jak Winstona.

5
00:00:12,077 --> 00:00:14,210
Zaczynam od konstruktora,

6
00:00:14,310 --> 00:00:16,927
potem są właściwości,
rysowanie i mówienie...

7
00:00:17,027 --> 00:00:20,828
Dodałam też metodę „Hura!”,

8
00:00:20,928 --> 00:00:25,216
bo Hopper bardzo lubi świętować.
A Winston - wcale.

9
00:00:25,316 --> 00:00:29,785
U dołu funkcji stworzyłam
dwa nowe obiekty „Hopper”:

10
00:00:29,885 --> 00:00:32,972
Dużą i Małą. Narysowałam je.

11
00:00:33,072 --> 00:00:36,540
Jednej przypisałam funkcję
mówienia, drugiej - „Hura”.

12
00:00:36,640 --> 00:00:40,081
I dobrze. Patrząc
w ten fragment programu,

13
00:00:40,181 --> 00:00:42,504
możecie zauważyć coś ciekawego.

14
00:00:42,604 --> 00:00:47,162
Program dla Hopper
jest podobny do tego dla Winstona.

15
00:00:47,262 --> 00:00:49,133
Zwróćcie uwagę na konstruktora.

16
00:00:49,233 --> 00:00:54,822
Może pamiętacie... To dokładnie
ten sam program, co u Winstona.

17
00:00:54,922 --> 00:01:00,186
I funkcja „talk” jest identyczna
jak u niego.

18
00:01:01,045 --> 00:01:04,311
Jedno i drugie ma funkcję „draw”.

19
00:01:04,411 --> 00:01:07,175
Te dwa typy obiektów wiele łączy!

20
00:01:07,275 --> 00:01:12,817
To ma sens, bo Hopper i Winston
są podobnymi typami w naszym świecie.

21
00:01:12,917 --> 00:01:17,067
Zresztą w prawdziwym świecie,
poza komputerem,

22
00:01:17,879 --> 00:01:20,717
wiele typów obiektów
przypomina inne.

23
00:01:20,817 --> 00:01:22,732
Np. w królestwie zwierząt.

24
00:01:22,832 --> 00:01:25,310
Wszystkie zwierzęta
są do siebie podobne.

25
00:01:25,410 --> 00:01:29,065
Ale są różne typy zwierząt,
np. ludzie.

26
00:01:29,165 --> 00:01:34,365
Ludzie są podobni do zwierząt,
a także do siebie nawzajem.

27
00:01:34,465 --> 00:01:37,918
Możemy więc powiedzieć,
że „zwierzę” to typ obiektu,

28
00:01:38,018 --> 00:01:41,680
od którego typ obiektu „człowiek”
dziedziczy funkcjonalność.

29
00:01:41,780 --> 00:01:43,560
Nie zaczynamy się z niczego;

30
00:01:43,660 --> 00:01:46,718
dodajemy cechy do tych,
które mamy jako zwierzęta.

31
00:01:46,818 --> 00:01:48,922
Wszystkie zwierzęta wydają odgłosy,

32
00:01:49,022 --> 00:01:50,944
a ludzie dodatkowo mówią.

33
00:01:51,823 --> 00:01:56,331
Pojęcie dziedziczenia obiektów
przydaje się też w programowaniu.

34
00:01:56,431 --> 00:02:00,650
W JavaScript możemy stworzyć
łańcuch dziedziczenia obiektów.

35
00:02:00,750 --> 00:02:04,830
Zastanówmy się, co łączy
nasze typy obiektów.

36
00:02:04,930 --> 00:02:06,641
I wymyślmy nazwę.

37
00:02:06,741 --> 00:02:10,542
Stworzymy nowy typ obiektu,
reprezentujący obiekt bazowy.

38
00:02:10,642 --> 00:02:13,561
Dajmy nazwę: „Creatures”
(istoty). Bo nimi są.

39
00:02:13,661 --> 00:02:16,092
Piszemy: „var creature =”...

40
00:02:16,192 --> 00:02:17,980
Potrzebujemy konstruktora.

41
00:02:18,080 --> 00:02:22,802
Ma go Hopper.
Taki sam jest u Winstona.

42
00:02:22,902 --> 00:02:25,171
W porządku? I teraz...

43
00:02:25,271 --> 00:02:28,445
Zobaczmy... Teraz chcemy...

44
00:02:28,545 --> 00:02:33,251
Co dalej? Może dodamy
funkcję „talk”?

45
00:02:33,351 --> 00:02:35,829
Zabierzemy ją.

46
00:02:35,929 --> 00:02:39,822
Musi być w prototypie „creature”.

47
00:02:39,922 --> 00:02:41,216
W porządku.

48
00:02:41,316 --> 00:02:45,209
Mamy już typ obiektu „creature”.

49
00:02:45,309 --> 00:02:48,205
Ale Hopper musi się dowiedzieć,

50
00:02:48,305 --> 00:02:52,524
że ma na opierać swoje działanie
na „creature”.

51
00:02:52,624 --> 00:02:55,589
Załatwimy to, pisząc ten wiersz.

52
00:02:55,689 --> 00:02:58,863
Piszemy: „Hopper.prototype”

53
00:02:58,963 --> 00:03:02,485
równa się „object.create”

54
00:03:02,585 --> 00:03:04,839
„creature.prototype”.

55
00:03:04,939 --> 00:03:07,996
Ten wiersz każe językowi JavaScript

56
00:03:08,096 --> 00:03:12,121
oprzeć prototyp,
czyli funkcjonalność Hopper,

57
00:03:12,221 --> 00:03:14,908
na prototypie „creature”.

58
00:03:15,008 --> 00:03:19,970
Zawsze, gdy program szuka
funkcji u Hopper,

59
00:03:20,070 --> 00:03:22,965
najpierw spojrzy na prototyp.

60
00:03:23,065 --> 00:03:26,657
A jeśli tam nie znajdzie,
to spojrzy na prototyp „creature”.

61
00:03:26,757 --> 00:03:28,956
To nazywamy łańcuchem prototypów.

62
00:03:29,652 --> 00:03:31,464
Po zrobieniu tego

63
00:03:31,564 --> 00:03:35,156
powinno być możliwe skasowanie
funkcji „talk” u Hopper.

64
00:03:35,256 --> 00:03:37,454
Bo jest już w „creature”.

65
00:03:37,554 --> 00:03:39,793
Wyżej w łańcuchu prototypów.
Spróbujmy!

66
00:03:39,893 --> 00:03:42,841
Gotowi? Udało się!

67
00:03:42,941 --> 00:03:47,648
Bo program znalazł funkcję
w prototypie „creature”.

68
00:03:48,762 --> 00:03:51,479
Spróbujmy skasować
tę funkcję u Winstona.

69
00:03:53,221 --> 00:03:57,958
Nie udało się. Obiekt nie ma
metody „talk”.

70
00:03:58,058 --> 00:03:59,513
A dlaczego?

71
00:03:59,613 --> 00:04:02,787
Są konstruktor i „draw”,
a „talk” usunęliśmy.

72
00:04:02,887 --> 00:04:06,583
Zapomnieliśmy powiedzieć
prototypowi Winstona,

73
00:04:06,683 --> 00:04:10,109
że ma się opierać na prototypie
„creature”. Ważny wiersz:

74
00:04:10,209 --> 00:04:15,489
„Winston.prototype=object.create
creature.portotype”.

75
00:04:17,995 --> 00:04:21,038
Już! Zauważcie coś istotnego:

76
00:04:21,137 --> 00:04:23,682
Ten wiersz jest po konstruktorze,

77
00:04:23,782 --> 00:04:27,135
ale wpisuję go, zanim dodam coś
do prototypu Winstona.

78
00:04:27,235 --> 00:04:29,792
Zazwyczaj chcemy powiedzieć,

79
00:04:29,892 --> 00:04:34,181
że na tym będzie się opierać
początkowy prototyp.

80
00:04:34,281 --> 00:04:37,106
Możemy dodawać do prototypu
kolejne elementy.

81
00:04:37,206 --> 00:04:40,775
Winston i Hopper mogą mieć
charakterystyczne cechy,

82
00:04:40,875 --> 00:04:45,210
których nie ma w „creatures”.
Super, że można je zdefiniować!

83
00:04:46,557 --> 00:04:49,901
No dobrze. Widzimy
powtarzające się fragmenty.

84
00:04:50,001 --> 00:04:51,334
To konstruktor.

85
00:04:51,434 --> 00:04:53,918
Ten sam we wszystkich
trzech przypadkach.

86
00:04:54,018 --> 00:04:56,843
Czy możemy go skasować?

87
00:04:58,028 --> 00:04:59,189
Spróbujmy.

88
00:05:01,000 --> 00:05:03,577
Hmmm... Nie udało się.

89
00:05:03,677 --> 00:05:07,726
Hopper pokazuje się w lewym górnym
rogu. Nie pamięta nic o sobie.

90
00:05:07,826 --> 00:05:10,868
Bo JavaScript nie zakłada,

91
00:05:10,968 --> 00:05:15,118
że chcemy tego samego konstruktora,
nawet gdy ma być w prototypie.

92
00:05:15,218 --> 00:05:19,181
Pozwala nam zdefiniować
konstruktora dla tych obiektów.

93
00:05:19,281 --> 00:05:22,548
I daje łatwy sposób,
by przywołać

94
00:05:22,648 --> 00:05:26,031
tę funkcję z obiektu.

95
00:05:26,131 --> 00:05:29,003
Piszemy więc: „creature”...

96
00:05:29,103 --> 00:05:30,187
kropka, „call”,

97
00:05:30,954 --> 00:05:35,342
„this,nickname,age,x,y”.

98
00:05:35,738 --> 00:05:36,503
Dobrze.

99
00:05:36,603 --> 00:05:39,289
Program robi to
(zauważcie - zadziałało!)...

100
00:05:39,389 --> 00:05:44,607
przywołuje funkcję
„creature”, konstruktora.

101
00:05:44,707 --> 00:05:47,958
Przywołuje funkcję, ale mówi:

102
00:05:48,058 --> 00:05:53,268
„przywołaj tę funkcję tak
jak z obiektu Hopper,

103
00:05:54,065 --> 00:05:56,745
jak z tymi argumentami”.

104
00:05:56,845 --> 00:05:59,607
Tak została przywołana Hopper.

105
00:05:59,707 --> 00:06:03,810
Program zostanie wykonany tak,
jakby był tutaj.

106
00:06:03,910 --> 00:06:05,480
I o to właśnie nam chodzi.

107
00:06:05,582 --> 00:06:06,712
Udało się!

108
00:06:06,812 --> 00:06:09,917
Możemy skopiować ten wiersz

109
00:06:10,017 --> 00:06:13,678
także do konstruktora Winstona.

110
00:06:14,862 --> 00:06:16,883
To działa. Tak!

111
00:06:16,983 --> 00:06:19,019
Dobrze. Patrzcie:

112
00:06:19,119 --> 00:06:21,991
zamknęliśmy wspólne właściwości
i funkcjonalność

113
00:06:22,091 --> 00:06:24,661
w jednym typie obiektu bazowego,
„creature”,

114
00:06:24,761 --> 00:06:28,144
i na tej podstawie stworzyliśmy
dwa typy obiektów.

115
00:06:28,244 --> 00:06:31,737
Dziedziczą funkcjonalność,
ale dodają też własną.

116
00:06:31,837 --> 00:06:36,271
Wystarczy zmienić tę funkcjonalność
w jednym miejscu.

117
00:06:36,371 --> 00:06:40,869
Np. moglibyśmy zmienić wiek,
pisząc: „plus lata”.

118
00:06:40,969 --> 00:06:43,934
Teraz każdy ma na końcu „lata”.

119
00:06:44,034 --> 00:06:48,206
Możemy też zmienić
funkcje „talk”. „Super!”.

120
00:06:48,306 --> 00:06:52,107
Teraz każdy Winston
i Hopper mówią: „Super!”.

121
00:06:52,897 --> 00:06:56,589
Wiecie, jak tworzyć typy obiektów
i jak przebiega dziedziczenie.

122
00:06:56,689 --> 00:07:00,099
Pomyślcie, jak to wykorzystać
w rysowaniu, animacjach,

123
00:07:00,199 --> 00:07:01,422
symulacjach i grach.

124
00:07:01,522 --> 00:07:04,560
Np. macie grę
z wieloma postaciami...

125
00:07:04,660 --> 00:07:07,542
Wszystkie biegają,
ale tylko niektóre skaczą.

126
00:07:07,642 --> 00:07:11,589
Tu trzeba wykorzystać typy
obiektów i dziedziczenie!

127
00:07:11,689 --> 00:07:15,304
Na pewno wymyślicie też
mnóstwo własnych zastosowań.