0:00:01.180,0:00:03.578
Znacie podstawy języka JavaScript.

0:00:03.679,0:00:05.735
Pokażę wam fajne zastosowanie.

0:00:05.835,0:00:08.765
Tzw. programowanie obiektowe.

0:00:09.485,0:00:12.392
Zacznijmy od tego,[br]czemu to jest przydatne.

0:00:12.492,0:00:17.322
Mam program, który ulepszymy[br]za pomocą obiektów.

0:00:17.422,0:00:19.502
Teraz też jest niezły!

0:00:19.602,0:00:24.094
Dwie zmienne, u góry,[br]przechowują literały.

0:00:25.087,0:00:28.305
Literał to obiekt, który już znamy:

0:00:28.405,0:00:33.111
w klamrach wpisujemy nazwy[br]właściwości oraz wartości.

0:00:34.292,0:00:38.999
Tu mamy dwie zmienne z literałami,[br]a tu - funkcję „drawWinston”,

0:00:39.099,0:00:41.006
przyjmującą jeden argument.

0:00:41.106,0:00:45.836
Funkcja rysuje obraz[br]z uwzględnieniem „x” i „y”

0:00:45.936,0:00:47.647
oraz właściwości obiektu;

0:00:47.747,0:00:52.103
wyświetla też podpis[br]z przydomkiem i wiekiem.

0:00:52.918,0:00:57.864
U dołu mamy funkcję „drawWinston”[br]dla wieku nastoletniego i dorosłego.

0:00:57.964,0:01:00.905
Dlatego pokazuje się obraz.

0:01:01.005,0:01:05.991
Super! Przyglądając się literałom,

0:01:06.091,0:01:11.116
zauważymy ich podobieństwo.

0:01:11.216,0:01:13.909
Mają te same właściwości

0:01:14.009,0:01:17.601
i w obu może działać[br]ta sama funkcja „drawWinston”.

0:01:17.701,0:01:21.631
Zastanówmy się:[br]każdy literał opisuje

0:01:21.731,0:01:23.429
jakiś rodzaj Winstona.

0:01:23.529,0:01:28.514
Jakby na świecie istniał[br]abstrakcyjny typ Winstona,

0:01:28.614,0:01:31.579
zatem każdy Winston[br]miałby te same właściwości

0:01:31.679,0:01:35.828
(przydomek, wiek,[br]współrzędne „x” i „y”)...

0:01:36.386,0:01:41.889
A my tu stworzyliśmy[br]tylko dwie instancje Winstona,

0:01:41.989,0:01:44.990
by opisać go[br]w szczególnej sytuacji.

0:01:45.090,0:01:48.065
Ten jest nastolatkiem,[br]a ten - dorosłym.

0:01:48.165,0:01:51.455
Są podobni do siebie.

0:01:51.555,0:01:54.660
Bardzo wiele ich łączy.

0:01:54.760,0:01:57.453
Tak zresztą działa świat.

0:01:57.553,0:02:01.066
Istnieją abstrakcyjne[br]typy danych, np. ludzie,

0:02:01.166,0:02:05.626
a każdy z nas jest instancją,[br]z własnymi cechami.

0:02:05.726,0:02:10.078
W JavaScript możemy używać[br]technik obiektowych,

0:02:10.178,0:02:14.606
żeby te zmienne z Winstonem

0:02:14.706,0:02:17.751
były instancjami obiektu „Winston”,

0:02:17.851,0:02:21.664
i wiedziały,[br]że mają wspólne cechy.

0:02:21.764,0:02:24.073
Aby tak było, musimy...

0:02:24.173,0:02:27.818
opisać ten abstrakcyjny[br]typ danych - „Winstona”.

0:02:27.918,0:02:32.578
W tym celu określimy zmienną,[br]by przechowywać w niej dane.

0:02:32.678,0:02:35.759
Piszę więc: „var Winston”,[br]przez wielkie „W”

0:02:35.859,0:02:38.743
(nazwy obiektów[br]zaczynamy od wielkiej litery).

0:02:38.843,0:02:41.030
I piszemy, że jest to równe funkcji.

0:02:42.115,0:02:46.649
To funkcja specjalna,[br]zwana konstruktorem.

0:02:46.763,0:02:49.702
Zostanie przywołana zawsze,[br]gdy będziemy chcieli

0:02:49.802,0:02:51.821
stworzyć nową instancję Winstona.

0:02:51.921,0:02:54.288
Chcąc stworzyć Winstona[br]nastoletniego

0:02:54.388,0:02:57.737
albo dorosłego,[br]przywołamy tę funkcję.

0:02:57.837,0:03:00.767
Będzie ona przyjmować

0:03:00.867,0:03:03.623
argumenty, których potrzebuje,

0:03:03.723,0:03:06.200
by stworzyć pełnego Winstona.

0:03:06.300,0:03:10.171
W tym przypadku to przydomek,[br]wiek, „x” i „y”.

0:03:11.233,0:03:15.024
Skoro przyjęliśmy te argumenty,[br]musimy coś z nimi zrobić.

0:03:15.124,0:03:17.787
Trzeba przypisać

0:03:17.887,0:03:21.200
te informacje do obiektu „Winston”.

0:03:21.434,0:03:24.776
Użyjemy nowego specjalnego[br]hasła, zwanego „this” (to).

0:03:25.536,0:03:28.406
Będzie się odnosić[br]do bieżącej instancji obiektu.

0:03:28.506,0:03:30.813
Napiszemy: „this.nickname”,

0:03:30.913,0:03:34.714
co będzie znaczyć, że właściwość[br]przydomka obiektu jest równa...

0:03:34.814,0:03:38.244
temu, co poda[br]funkcja konstruktor. OK?

0:03:38.344,0:03:41.259
A „this.age” jest równe[br]wprowadzonemu wiekowi;

0:03:41.359,0:03:44.676
„this.x” równa się[br]wprowadzonemu „x”, a „y”...

0:03:45.807,0:03:48.252
równa się wprowadzonemu „y”.

0:03:48.352,0:03:52.948
Mamy abstrakcyjny typ danych,[br]który nazwaliśmy Winstonem,

0:03:53.048,0:03:56.634
a z pomocą konstruktora[br]możemy stworzyć nowego Winstona.

0:03:57.497,0:04:00.187
Spróbujmy z tego skorzystać.

0:04:00.287,0:04:05.063
Znów robimy nastoletniego Winstona.[br]Powiemy, że jest on równy...

0:04:05.163,0:04:07.153
Zamiast wstawiać klamry,

0:04:07.253,0:04:10.141
powiemy, że jest równy[br]nowemu Winstonowi.

0:04:10.241,0:04:13.770
Czyli staramy się stworzyć[br]nową instancję Winstona.

0:04:13.870,0:04:17.300
Wprowadzamy potrzebne informacje:[br]„winstonTeen”,

0:04:17.399,0:04:21.293
15, 20, 50. W porządku?

0:04:22.276,0:04:25.752
Stary fragment możemy skasować.[br]Jest już niepotrzebny.

0:04:27.284,0:04:30.786
Stworzyliśmy nowego Winstona.

0:04:30.886,0:04:34.970
Powiemy, że Dorosły Winston[br]równa się Nowemu Winstonowi.

0:04:35.070,0:04:37.617
Nazywa się Pan Wygrany,

0:04:37.717,0:04:39.127
ładnie!

0:04:39.227,0:04:43.237
Ma 30 lat i znajduje się[br]na 229 i 50.

0:04:43.933,0:04:47.207
Możemy skasować literał.

0:04:47.307,0:04:50.063
Hura! Nasz program działa!

0:04:50.729,0:04:54.243
Powiedzieliśmy tutaj:

0:04:54.343,0:04:57.656
mamy abstrakcyjny[br]typ danych, Winstona,

0:04:57.756,0:05:00.403
i możemy tworzyć nowe instancje

0:05:00.503,0:05:04.251
z wyjątkowymi właściwościami.

0:05:04.351,0:05:08.639
Przypomnijmy sobie[br]właściwości w nich zawarte.

0:05:08.739,0:05:10.613
Trzeba o nich pamiętać.

0:05:10.713,0:05:14.130
Mamy tu „this.nickname”[br]i „this.age”.

0:05:14.230,0:05:17.596
Gdyby nie było „this.age”,

0:05:17.696,0:05:19.970
spójrzcie: wyskakuje „nieokreślone”.

0:05:20.070,0:05:22.780
Bo tutaj, wewnątrz[br]funkcji „drawWinston”,

0:05:22.880,0:05:28.005
każdy wprowadzony obiekt[br]powinien mieć właściwość wieku.

0:05:28.105,0:05:30.512
Gdybyśmy nie powiedzieli[br]„this.age”,

0:05:30.612,0:05:32.486
nie byłoby właściwości wieku.

0:05:32.586,0:05:35.481
Wpisaliśmy to do konstruktora[br]i nic nie zrobiliśmy.

0:05:35.581,0:05:39.359
Musimy przypisać wiek do obiektu[br]używając hasła „this”.

0:05:39.459,0:05:41.170
Dodajmy to z powrotem.

0:05:41.270,0:05:46.255
Pomyślicie: „Jasne, twój program[br]śmiga, robisz niezłe rzeczy...

0:05:46.355,0:05:50.505
ale to wszystko dałoby się[br]osiągnąć starymi metodami”.

0:05:50.605,0:05:52.386
Teraz będzie fajnie.

0:05:52.486,0:05:55.770
Każdy Winston przechodzi[br]przez tego samego konstruktora.

0:05:55.870,0:06:00.814
Gdybyśmy chcieli, możemy zmienić[br]to i owo o Winstonie.

0:06:00.914,0:06:03.043
O wszystkich Winstonach tutaj.

0:06:03.143,0:06:05.830
Przy wieku napiszemy „ile lat”.

0:06:05.930,0:06:07.618
Umieszczamy to tu

0:06:07.718,0:06:12.424
i każdy Winston mówi:[br]„15 lat”, „30 lat” itd.

0:06:12.524,0:06:14.866
To jego specyfika,

0:06:14.966,0:06:17.231
ale instancje mają też[br]cechy wspólne.

0:06:17.331,0:06:20.764
Świetne w programowaniu[br]obiektowym jest to...

0:06:20.864,0:06:22.757
że istnieją rodzaje obiektów,

0:06:22.857,0:06:26.287
a my możemy tworzyć[br]ich instancje.

0:06:26.387,0:06:29.700
Czasami są podobne,[br]np. mają te same własciwości,

0:06:29.800,0:06:34.739
ale są też różnice, np. „ta właściwość[br]przybiera inną wartość niż ta druga”.

0:06:35.528,0:06:38.992
Możemy jednak zrobić to samo,

0:06:39.092,0:06:43.168
przywołać te same funkcje[br]i użyć ich w podobny sposób.

0:06:43.268,0:06:45.908
To są zalety[br]programowania obiektowego,

0:06:46.008,0:06:48.485
ale zobaczycie: można więcej!

0:06:48.585,0:06:50.017
Oglądajcie dalej!