1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Seminarium] [iOS: Pisanie Aplikacji Like a Boss]

2
00:00:02,000 --> 00:00:04,000
[Tommy MacWilliam] [Harvard University]

3
00:00:04,000 --> 00:00:08,000
[To jest CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Dobra, wszyscy, zapraszamy do iOS: Pisanie Aplikacji jak Boss.

5
00:00:12,000 --> 00:00:16,000
To seminarium ma zamiar skupić się na pisaniu aplikacji dla iPhone

6
00:00:16,000 --> 00:00:19,000
az kolei pisanie aplikacji dla iPad, a więc jesteśmy w zasadzie zamiar przejść przez

7
00:00:19,000 --> 00:00:23,000
kilka różnych przykładów jak zrobić aplikację, prosta gra jak Tic Tac Toe,

8
00:00:23,000 --> 00:00:26,000
lub jeśli jesteś bardziej zainteresowany w tworzeniu app jak jakiś czytnik wiadomości

9
00:00:26,000 --> 00:00:30,000
lub coś, co współgra z Internetu będę mówić o tym również.

10
00:00:30,000 --> 00:00:32,000
Oto nasz krótki program.

11
00:00:32,000 --> 00:00:36,000
>> Aplikacje IOS są napisane w języku zwanym Objective-C,

12
00:00:36,000 --> 00:00:39,000
i tak to jest trochę podobny do C, ale naprawdę nie jest w ogóle,

13
00:00:39,000 --> 00:00:41,000
więc będziemy rozmawiać trochę o samym języku

14
00:00:41,000 --> 00:00:45,000
, a następnie, jak zbudować iPhone apps za pomocą tego programu Aplikacja o nazwie Xcode,

15
00:00:45,000 --> 00:00:48,000
które, jeśli nie pobrało go jeszcze tutaj, aby rozpocząć pobieranie teraz.

16
00:00:48,000 --> 00:00:50,000
Jest kilka gigabajtów.

17
00:00:50,000 --> 00:00:54,000
Powinno być za darmo na App Store, więc musisz mieć Mac

18
00:00:54,000 --> 00:00:57,000
doskonale działa z najnowszej wersji OS X.

19
00:00:57,000 --> 00:00:59,000
Jeśli nie jesteś, nie ma problemu.

20
00:00:59,000 --> 00:01:02,000
Mamy komputery Mac w centrum nauki do dyspozycji

21
00:01:02,000 --> 00:01:05,000
z XCode zainstalowany, a więc zachęcamy do korzystania z tych, dla rozwoju.

22
00:01:05,000 --> 00:01:07,000
Jeśli chcesz złożyć aplikację, ale nie masz Maca, nie martw się.

23
00:01:07,000 --> 00:01:09,000
Istnieje mnóstwo zasobów kampusu za to.

24
00:01:09,000 --> 00:01:15,000
I tak potem idziemy na pokrycie 2 większych przykładów różnych aplikacji można dokonać.

25
00:01:15,000 --> 00:01:19,000
Objective-C jest technicznie, co nazywa się super zestaw C

26
00:01:19,000 --> 00:01:24,000
To oznacza, że ​​każdy kod C obowiązuje również kod Objective-C.

27
00:01:24,000 --> 00:01:29,000
To oznacza, że ​​rodzaj kanału kręcony dodatkowe funkcje do C.

28
00:01:29,000 --> 00:01:33,000
Niektóre z tych funkcji są nie konieczności kiedykolwiek napisać malloc ponownie, dzięki Bogu,

29
00:01:33,000 --> 00:01:36,000
nie martwiąc się o tych głupich wskaźników i uwolnienie ich i wszystkie rzeczy

30
00:01:36,000 --> 00:01:40,000
nienawidzisz o C, a to trochę już w Objective-C.

31
00:01:40,000 --> 00:01:43,000
>> Teraz, celem C również większe biblioteki standardowej,

32
00:01:43,000 --> 00:01:47,000
więc nie ma dużo więcej funkcji można uzyskać za darmo wewnątrz Objective-C.

33
00:01:47,000 --> 00:01:50,000
Pamiętaj, gdy pisaliśmy PHP zauważyliśmy, że poszliśmy z

34
00:01:50,000 --> 00:01:54,000
to najmniejszy język giganta biblioteki tych wszystkich rzeczy szalonych możesz zrobić.

35
00:01:54,000 --> 00:01:56,000
To samo dzieje się w iOS.

36
00:01:56,000 --> 00:01:59,000
Jest obiekty dla rzeczy jak kalendarz buddyjski, i naprawdę nic

37
00:01:59,000 --> 00:02:05,000
można ewentualnie pomyśleć prawdopodobnie istnieje już w realizacji celu C w.

38
00:02:05,000 --> 00:02:08,000
Celem części Objective-C jest odwołanie coś

39
00:02:08,000 --> 00:02:11,000
nazywany Object-Oriented Programming.

40
00:02:11,000 --> 00:02:14,000
Jest to rodzaj nowej koncepcji, ale my rzeczywiście w większości dowiedziałem

41
00:02:14,000 --> 00:02:17,000
Wiele z tych pojęć już.

42
00:02:17,000 --> 00:02:19,000
Ideą programowania obiektowego jest, że idziesz do struktury

43
00:02:19,000 --> 00:02:23,000
Dużo kodu wokół tych rzeczy nazywane klas,

44
00:02:23,000 --> 00:02:26,000
a te zajęcia są naprawdę uwielbiony przypisać struktury.

45
00:02:26,000 --> 00:02:30,000
Wewnątrz struct my w zasadzie powiedział tutaj jest rzeczą,

46
00:02:30,000 --> 00:02:32,000
i to coś może mieć członków.

47
00:02:32,000 --> 00:02:35,000
Na przykład, węzeł połączonej liście może mieć inne rzeczy

48
00:02:35,000 --> 00:02:38,000
jak wartości, wskaźnik do następnego węzła na liście

49
00:02:38,000 --> 00:02:44,000
i razem, że wskaźnik i ta wartość składa tę jedną instancję struktury.

50
00:02:44,000 --> 00:02:47,000
Zajęcia są bardzo podobne, z wyjątkiem

51
00:02:47,000 --> 00:02:50,000
Zajęcia mogą mieć także funkcje wewnątrz nich.

52
00:02:50,000 --> 00:02:54,000
Kiedy oświadczył struct, możemy tylko powiedzieć, int n lub * węzła następnego.

53
00:02:54,000 --> 00:02:57,000
>> Teraz z Objective-C faktycznie możemy umieścić funkcje

54
00:02:57,000 --> 00:02:59,000
wewnątrz z tych rzeczy.

55
00:02:59,000 --> 00:03:03,000
Inną rzeczą, którą możemy zrobić, to zajęcia mogą dziedziczyć dane z innych klas.

56
00:03:03,000 --> 00:03:07,000
Na przykład, będziemy patrzeć na kilka wbudowanych w Objective-C klasy.

57
00:03:07,000 --> 00:03:11,000
Jedna z nich może być klasa, która reprezentuje widok dla ekranu

58
00:03:11,000 --> 00:03:14,000
a więc, mówiąc, że chcą wprowadzić własne poglądy

59
00:03:14,000 --> 00:03:18,000
my w zasadzie powiedzieć, kogoś na Apple, prawdopodobnie naprawdę mili ludzie,

60
00:03:18,000 --> 00:03:21,000
napisał tę klasę dla mnie, i obsługuje on takie rzeczy jak wyświetlanie przycisków

61
00:03:21,000 --> 00:03:25,000
lub uczynienie ekranu, i będziemy bardzo zasmucony

62
00:03:25,000 --> 00:03:28,000
do wdrożenia wszystkich tych funkcji sami, i tak po prostu

63
00:03:28,000 --> 00:03:31,000
dziedziczenie danych można powiedzieć, że zrobiłeś wszystko, co w tej klasie

64
00:03:31,000 --> 00:03:34,000
Chcę również wewnątrz mojej klasie, a potem zamierzam zrobić kilka innych rzeczy,

65
00:03:34,000 --> 00:03:37,000
mianowicie wdrożenie aplikacji.

66
00:03:37,000 --> 00:03:40,000
To właśnie, że dziedziczenie słowo oznacza. Zobaczymy bardziej konkretny przykład.

67
00:03:40,000 --> 00:03:42,000
>> I wreszcie, klucz z programowania obiektowego jest

68
00:03:42,000 --> 00:03:45,000
prowadzi do kapsułkowania danych.

69
00:03:45,000 --> 00:03:48,000
W niektórych z naszego problemu ustawia może mamy te duże, zmienne globalne

70
00:03:48,000 --> 00:03:51,000
i globals wszędzie, i to jak chcielibyśmy śledzić stanu.

71
00:03:51,000 --> 00:03:55,000
Z klas możemy zacząć enkapsulacji informacji wewnątrz obiektu.

72
00:03:55,000 --> 00:03:58,000
Jeśli mamy jeden ekran na naszej aplikacji, tak naprawdę nie trzeba mieć żadnych danych z

73
00:03:58,000 --> 00:04:01,000
kolejny ekran w naszej wewnętrznej aplikacji tego,

74
00:04:01,000 --> 00:04:04,000
i tak przez umieszczenie rzeczy w klasach to rzeczywiście prowadzi

75
00:04:04,000 --> 00:04:08,000
znacznie lepszego projektowania kodu, to jest możliwe, a niektóre z funkcji dodatkowych

76
00:04:08,000 --> 00:04:11,000
z Objective-C.

77
00:04:11,000 --> 00:04:15,000
Ostrzegawcza, składnia Objective-C to banany.

78
00:04:15,000 --> 00:04:19,000
To jest jak nic widzieliśmy wcześniej,

79
00:04:19,000 --> 00:04:22,000
tak to jest trochę krzywa uczenia się przyzwyczaić

80
00:04:22,000 --> 00:04:24,000
Co do cholery to znaczy?

81
00:04:24,000 --> 00:04:27,000
Ale po przeszłości, że początkowy krzywej uczenia się jest to bardzo, bardzo gładka

82
00:04:27,000 --> 00:04:29,000
zacząć pisać aplikacje.

83
00:04:29,000 --> 00:04:33,000
>> Aby zadeklarować klasę, tu powiedzieć to moja klasa, istnieje,

84
00:04:33,000 --> 00:04:35,000
a może są tu pewne rzeczy, które mam zamiar określić później,

85
00:04:35,000 --> 00:04:38,000
Zamierzam powiedzieć interfejs @.

86
00:04:38,000 --> 00:04:41,000
Zamierzam powiedzieć interfejs @. Mam zamiar dać mojej klasie nazwę.

87
00:04:41,000 --> 00:04:43,000
A potem gdzieś idę powiedzieć @ end,

88
00:04:43,000 --> 00:04:46,000
i wszystko, co w między @ interface i koniec @

89
00:04:46,000 --> 00:04:48,000
będzie moja klasa.

90
00:04:48,000 --> 00:04:51,000
Że będzie to, co jest wewnątrz naszych plików. Godz.

91
00:04:51,000 --> 00:04:55,000
Podobnie jak w C nasze pliki. H zasadzie powiedział, oto kilka rzeczy, które istnieją.

92
00:04:55,000 --> 00:04:57,000
Ja nie zawsze mówi ci to, co robią jeszcze,

93
00:04:57,000 --> 00:04:59,000
ale kompilator musi wiedzieć, że one istnieją.

94
00:04:59,000 --> 00:05:04,000
Później w środku naszego. M files-bo m dla Objective-C

95
00:05:04,000 --> 00:05:08,000
jest, dokąd faktycznie się określić, co te zajęcia zrobić.

96
00:05:08,000 --> 00:05:11,000
Podobnie jak w naszych plików. C, zapewniliśmy implementację dla funkcji.

97
00:05:11,000 --> 00:05:15,000
Wewnątrz naszego. M pliku będziemy tu powiedzieć to, co wszystkie funkcje

98
00:05:15,000 --> 00:05:18,000
wewnątrz moja klasa-co oni wszyscy.

99
00:05:18,000 --> 00:05:22,000
I w końcu, wewnątrz struktury moglibyśmy powiedzieć wewnątrz tych nawiasów klamrowych

100
00:05:22,000 --> 00:05:25,000
int n lub węzeł * next,

101
00:05:25,000 --> 00:05:28,000
w Objective-C mamy zamiar użyć słowa kluczowego właściwość @,

102
00:05:28,000 --> 00:05:31,000
i to, co się określa właściwości

103
00:05:31,000 --> 00:05:36,000
lub braku funkcji, które są częścią moich zajęć.

104
00:05:36,000 --> 00:05:40,000
>> Wywołanie funkcji w Objective-C jest również banany.

105
00:05:40,000 --> 00:05:43,000
Kiedy zadeklarowanych funkcji w C powiedzieliśmy coś int foo

106
00:05:43,000 --> 00:05:46,000
i otwarty nawias, a następnie dał mu listę argumentów.

107
00:05:46,000 --> 00:05:51,000
To właśnie stwierdzenie metody lub funkcji wygląda w Objective-C.

108
00:05:51,000 --> 00:05:54,000
Jeśli chcę zadeklarować funkcji lub metody

109
00:05:54,000 --> 00:05:58,000
gdy mówię metody jest tak naprawdę funkcja jest członkiem klasy,

110
00:05:58,000 --> 00:06:01,000
więc rodzaj wymienne, ale nie bardzo,

111
00:06:01,000 --> 00:06:03,000
tak wewnątrz mojej metody chcę utworzyć nową metodę.

112
00:06:03,000 --> 00:06:06,000
To będzie powrót nic, więc to będzie typu void.

113
00:06:06,000 --> 00:06:08,000
Jest to rodzaj powrotu mojej funkcji.

114
00:06:08,000 --> 00:06:11,000
Teraz mamy nawiasy tutaj, bo-nie wiem.

115
00:06:11,000 --> 00:06:14,000
Następna będzie nazwa mojej funkcji,

116
00:06:14,000 --> 00:06:17,000
i wreszcie mamy średnik tak jak mieliśmy w C.

117
00:06:17,000 --> 00:06:19,000
Nowością jest ten facet tutaj.

118
00:06:19,000 --> 00:06:22,000
Ten łącznik jest rzeczywiście konieczne, i co to mówi, że

119
00:06:22,000 --> 00:06:26,000
metoda ta musi tu być nazywany w instancji klasy.

120
00:06:26,000 --> 00:06:29,000
>> Po zadeklarowaliśmy nasze przypisać struktury zapewne powiedział coś

121
00:06:29,000 --> 00:06:32,000
struct n węzłów, i że faktycznie stworzył

122
00:06:32,000 --> 00:06:35,000
lub wystąpienia jednego z tych strukturach, abym mógł zacząć pracę

123
00:06:35,000 --> 00:06:38,000
z tym, co znajduje się w jej środku, więc ta kreska oznacza, że ​​mamy do

124
00:06:38,000 --> 00:06:41,000
instancji klasy, tak jak my, że instancja struct

125
00:06:41,000 --> 00:06:43,000
przed możemy wywołać tę metodę na nim.

126
00:06:43,000 --> 00:06:46,000
Jeśli chcę, aby rozpocząć dodawanie argumenty do moich metod

127
00:06:46,000 --> 00:06:48,000
będzie jeszcze więcej bananów.

128
00:06:48,000 --> 00:06:50,000
Oto moja nazwa metody.

129
00:06:50,000 --> 00:06:53,000
Wtedy będę mieć dwukropek, a po tym dwukropku jest napisane tutaj jest kilka argumentów.

130
00:06:53,000 --> 00:06:56,000
Ta metoda przyjmuje jeden argument.

131
00:06:56,000 --> 00:06:59,000
Typ jego argumentu jest int, a nazwa tego argumentu

132
00:06:59,000 --> 00:07:03,000
lub zmienna, której mam zamiar zacząć używać wewnątrz metody jest nazywany i.

133
00:07:03,000 --> 00:07:05,000
Ponownie, jest to sposób. Ona jeden argument.

134
00:07:05,000 --> 00:07:10,000
>> Jeśli chcesz, aby rozpocząć dodawanie więcej argumentów robi więcej bananów

135
00:07:10,000 --> 00:07:13,000
na tym, że mamy ten dwukropek, że mówi tu przychodzi moja lista argumentów.

136
00:07:13,000 --> 00:07:15,000
Ten pierwszy argument jest liczbą całkowitą.

137
00:07:15,000 --> 00:07:17,000
Teraz ten drugi argument jest ciekawy.

138
00:07:17,000 --> 00:07:20,000
Zmienna, że ​​mam zamiar używać wewnątrz mojej funkcji

139
00:07:20,000 --> 00:07:23,000
nazywa f, tak wewnątrz mojej funkcji można powiedzieć

140
00:07:23,000 --> 00:07:25,000
f + = 1 czy coś.

141
00:07:25,000 --> 00:07:30,000
To coś tu jest w zasadzie kluczem do tego argumentu lub parametru.

142
00:07:30,000 --> 00:07:34,000
Tak jak mieliśmy kluczowych par wartości i coś jak JSON lub tablice asocjacyjne

143
00:07:34,000 --> 00:07:37,000
Objective-C podjął decyzję, aby powiedzieć, w porządku, po prostu tak, że to jest naprawdę jasne

144
00:07:37,000 --> 00:07:39,000
podczas wywołania metody, co wszystkie te parametry są

145
00:07:39,000 --> 00:07:41,000
Jestem rzeczywiście będzie je wszystkie wymienić.

146
00:07:41,000 --> 00:07:45,000
Podczas wywoływania metody, będziesz faktycznie powiedzieć andFloat,

147
00:07:45,000 --> 00:07:47,000
a potem zdać go w.

148
00:07:47,000 --> 00:07:50,000
>> Interesujące jest to nie pochodzi, ale z innymi parametrami, są

149
00:07:50,000 --> 00:07:53,000
więc jeśli mieliśmy 3-szy argumentu mogę powiedzieć andFloat

150
00:07:53,000 --> 00:07:56,000
i innego przepływu i tak dalej.

151
00:07:56,000 --> 00:08:01,000
Kiedy dzwonię do tych metod jest bananów kursu,

152
00:08:01,000 --> 00:08:04,000
więc jeśli mam obiektu, i określono metodę o nazwie foo,

153
00:08:04,000 --> 00:08:09,000
i chcę to nazwać, zamiast mówić foo otworzyć / zamknąć nawiasy

154
00:08:09,000 --> 00:08:11,000
Zamierzam otworzyć uchwyt.

155
00:08:11,000 --> 00:08:13,000
Tutaj jest nazwa mojej metody.

156
00:08:13,000 --> 00:08:17,000
Mam zamiar zamknąć uchwyt, a to obiekt Wołam ją.

157
00:08:17,000 --> 00:08:20,000
Pamiętaj, że wszystkie te metody istnieją w klasach

158
00:08:20,000 --> 00:08:23,000
ponieważ klasy mogą mieć metody zdefiniowane wewnątrz nich.

159
00:08:23,000 --> 00:08:26,000
>> Tutaj mam arbitralnie tworzone obiekt jakiejś klasy,

160
00:08:26,000 --> 00:08:28,000
i to jest składnia to robić.

161
00:08:28,000 --> 00:08:31,000
Istnieją 2 kroki tworzenia obiektu.

162
00:08:31,000 --> 00:08:34,000
Pierwszym krokiem jest, że chcę przeznaczyć przestrzeń.

163
00:08:34,000 --> 00:08:37,000
Jest to równoważne z malloc. Nie mamy do powiedzenia malloc anymore.

164
00:08:37,000 --> 00:08:42,000
Wpadliśmy na m, dotarł Alloc, i zastąpił. C z. Metrów.

165
00:08:42,000 --> 00:08:47,000
Po czymś alloc my wtedy trzeba go zainicjować.

166
00:08:47,000 --> 00:08:49,000
Zasadniczo podczas tworzenia obiektów może chcesz mieć trochę logiki

167
00:08:49,000 --> 00:08:53,000
, który wykonuje, gdy są one tworzone, więc można przekazać w niektórych wartości domyślnych

168
00:08:53,000 --> 00:08:57,000
lub coś w tym stylu, i tak ta metoda init jest to, co w rzeczywistości tworzy obiekt.

169
00:08:57,000 --> 00:08:59,000
Najpierw alokacji przestrzeni, tak jak robiliśmy to w C,

170
00:08:59,000 --> 00:09:04,000
a potem zainicjować, które mogą, ale nie do dużo.

171
00:09:04,000 --> 00:09:07,000
Potem wracasz to coś w obiekt o.

172
00:09:07,000 --> 00:09:09,000
Jest tu, bo gwiazda jest to technicznie wskaźnik,

173
00:09:09,000 --> 00:09:12,000
ale nie martw się, wskaźniki nie są tak wielkie rzeczy w Objective-C więcej.

174
00:09:12,000 --> 00:09:15,000
>> Teraz mamy instancja tej klasy o nazwie NSObject,

175
00:09:15,000 --> 00:09:19,000
i jest to tylko random class, że Apple ma.

176
00:09:19,000 --> 00:09:22,000
Mamy instancja tego, a teraz mam wystąpienie tej klasy

177
00:09:22,000 --> 00:09:25,000
w obiekt O, więc oznacza to, że jeżeli określone

178
00:09:25,000 --> 00:09:29,000
Metody te można nazwać je tak.

179
00:09:29,000 --> 00:09:31,000
Podobnie, jeśli chcę wywołać metodę z jednym argumentem,

180
00:09:31,000 --> 00:09:34,000
jest to więc metoda bar, które ma jeden argument,

181
00:09:34,000 --> 00:09:38,000
i tutaj jest baz: Metoda qux, więc zajmuje to 2 argumenty.

182
00:09:38,000 --> 00:09:44,000
To jest wywołanie jednej funkcji na tym obiekcie o.

183
00:09:44,000 --> 00:09:46,000
Ma sens?

184
00:09:46,000 --> 00:09:50,000
Składnia powinna mieć sens, ale trochę się do niego przyzwyczaić.

185
00:09:50,000 --> 00:09:54,000
>> Dobrze, porozmawiajmy o kilku rzeczach, które są wbudowane w Objective-C

186
00:09:54,000 --> 00:09:56,000
, które niekoniecznie muszą być wbudowane w C.

187
00:09:56,000 --> 00:09:59,000
W języku C mamy rodzaj miał do czynienia z tekstem, jak te głupie tablic znakowych

188
00:09:59,000 --> 00:10:01,000
i zrobiło się naprawdę denerwujące.

189
00:10:01,000 --> 00:10:04,000
Objective-C posiada te wszystkie zbudowane w dla nas, i jest zbudowany w

190
00:10:04,000 --> 00:10:06,000
korzystania z tej klasy o nazwie NSString.

191
00:10:06,000 --> 00:10:10,000
Kiedy chcę utworzyć NSString mamy bardziej złożoną składnię.

192
00:10:10,000 --> 00:10:15,000
Zamiast mówić "CS50" Mówimy @ "CS50"

193
00:10:15,000 --> 00:10:17,000
i jest to tylko składnia deklarowania ciągów w Objective-C.

194
00:10:17,000 --> 00:10:21,000
Jest to bardzo łatwo zapomnieć, więc nie.

195
00:10:21,000 --> 00:10:24,000
Teraz, kiedy mam to, to jest ciąg, ale zauważ

196
00:10:24,000 --> 00:10:26,000
to naprawdę tylko przedmiot.

197
00:10:26,000 --> 00:10:30,000
Powiedziałem NSString, co oznacza, że ​​instancja klasy

198
00:10:30,000 --> 00:10:32,000
nazywa NSString, które ktoś inny napisał o mnie,

199
00:10:32,000 --> 00:10:35,000
i byli bardzo mili o tym, i tak teraz

200
00:10:35,000 --> 00:10:37,000
Mogę zacząć wywołanie metod na jej temat.

201
00:10:37,000 --> 00:10:40,000
Jeśli zadzwonię długość metody na tym obiekcie s

202
00:10:40,000 --> 00:10:43,000
to wróci do mnie na długość łańcucha.

203
00:10:43,000 --> 00:10:45,000
To jest jak strlen w C.

204
00:10:45,000 --> 00:10:47,000
To wróci 4.

205
00:10:47,000 --> 00:10:51,000
>> Podobnie inna metoda może chcę się martwić o to characterAtIndex.

206
00:10:51,000 --> 00:10:54,000
Jest to metoda, która mówi o tym string s

207
00:10:54,000 --> 00:10:57,000
Chcę, aby uzyskać 0-szy charakter

208
00:10:57,000 --> 00:10:59,000
i tak to wróci do mnie znak c,

209
00:10:59,000 --> 00:11:02,000
i jest tam cała masa z tych metod, które można google naprawdę łatwo.

210
00:11:02,000 --> 00:11:07,000
Dokumentacja Apple jest super, a my zapraszamy do obejrzenia, że ​​w nieco.

211
00:11:07,000 --> 00:11:09,000
Są to ciągi.

212
00:11:09,000 --> 00:11:11,000
Posiadamy również tablice zmiennych rozmiar wbudowane

213
00:11:11,000 --> 00:11:13,000
Zapamiętaj w C kiedy zadeklarowaliśmy tablicę

214
00:11:13,000 --> 00:11:16,000
mieliśmy, że masz 5 elementów, koniec historii.

215
00:11:16,000 --> 00:11:18,000
Kiedy dotarliśmy do JavaScript i PHP możemy zacząć

216
00:11:18,000 --> 00:11:20,000
robić rzeczy, jak dodanie elementów lub ruchomych elementów.

217
00:11:20,000 --> 00:11:22,000
Możemy zrobić to samo w Objective-C.

218
00:11:22,000 --> 00:11:26,000
Zamiast tworzenia tablicy w sposób normalny C

219
00:11:26,000 --> 00:11:30,000
mamy ponownie inną klasę o nazwie NSMutableArray.

220
00:11:30,000 --> 00:11:33,000
Jest też NSArray,

221
00:11:33,000 --> 00:11:35,000
i to będzie w zasadzie enkapsulacji jakąś tablicę.

222
00:11:35,000 --> 00:11:38,000
Ten mówi, pierwszą rzeczą, którą chcesz zrobić, to chcę, aby przydzielić

223
00:11:38,000 --> 00:11:41,000
przestrzeń dla nowej tablicy, a po I przeznaczyć go

224
00:11:41,000 --> 00:11:43,000
I wtedy trzeba go zainicjować.

225
00:11:43,000 --> 00:11:45,000
Ponownie, po prostu nazywanie tych 2 metod.

226
00:11:45,000 --> 00:11:48,000
Teraz oznacza to, że wnętrze tego obiektu jest

227
00:11:48,000 --> 00:11:50,000
I pusta tablica siedzi.

228
00:11:50,000 --> 00:11:54,000
Jeśli chcę coś dodać do tej tablicy, mogę zadzwonić do addObject metody.

229
00:11:54,000 --> 00:11:59,000
Chcę dodać obiekt do tablicy A i chcę dodać ciąg CS50.

230
00:11:59,000 --> 00:12:02,000
Jeśli chciałem odwrotnie usunąć to mogę powiedzieć, że chcą

231
00:12:02,000 --> 00:12:09,000
usunąć obiekt na pierwszym miejscu na tablicy lub obiektu.

232
00:12:09,000 --> 00:12:11,000
>> Ma sens?

233
00:12:11,000 --> 00:12:14,000
Dobra, trochę przyzwyczaić się do tego kwadratowy rzeczy wspornika.

234
00:12:14,000 --> 00:12:18,000
Nawiasem mówiąc, w środku wielu bibliotek Apple zobaczysz tę NS.

235
00:12:18,000 --> 00:12:21,000
NS naprawdę oznacza kolejnego etapu, który był jedną z firm, Steve Jobs po pierwsze,

236
00:12:21,000 --> 00:12:24,000
i to, gdzie tak naprawdę zacząłem pisać dużo kodu

237
00:12:24,000 --> 00:12:27,000
jako swego rodzaju podstawę do systemu Mac OS X i wszystkich innych rzeczy,

238
00:12:27,000 --> 00:12:32,000
i tak to NS jest rodzaj tej miłej spuścizny krzyczeć do jednego z wcześniejszych spółek

239
00:12:32,000 --> 00:12:34,000
z powrotem, gdy Apple po raz pierwszy zaczynają.

240
00:12:34,000 --> 00:12:36,000
Jest wszędzie.

241
00:12:36,000 --> 00:12:41,000
Rzućmy okiem na bardziej holistyczne Objective-C przykład.

242
00:12:41,000 --> 00:12:44,000
Oto jestem wewnątrz XCode.

243
00:12:44,000 --> 00:12:47,000
Aby się tu dostać, najpierw pobrać XCode z App Store,

244
00:12:47,000 --> 00:12:50,000
otworzył ją, a następnie udałem się tutaj do pliku,

245
00:12:50,000 --> 00:12:54,000
tutaj do nowego projektu, a następnie.

246
00:12:54,000 --> 00:12:57,000
Po zrobić, że mam te wszystkie opcje, co chcę stworzyć,

247
00:12:57,000 --> 00:12:59,000
i tak będziemy spojrzeć na te opcje później

248
00:12:59,000 --> 00:13:03,000
ale tylko na tym przykładzie, bo nie jesteśmy rzeczywiście będzie app jeszcze,

249
00:13:03,000 --> 00:13:06,000
Przyszłam tu, a ja powiedziałem Narzędzie linii poleceń,

250
00:13:06,000 --> 00:13:09,000
i jest to aplikacja, która można uruchomić z wiersza poleceń

251
00:13:09,000 --> 00:13:12,000
tak jak my został uruchomiony z C.

252
00:13:12,000 --> 00:13:16,000
Tak właśnie stworzył ten projekt, a więc teraz jestem tu,

253
00:13:16,000 --> 00:13:20,000
Więc pierwsze spojrzenie na tym pliku, i to powinno wyglądać dość znajomo.

254
00:13:20,000 --> 00:13:24,000
Mam int nazwę. To mój przyjaciel argc, mój inny kolega argv.

255
00:13:24,000 --> 00:13:30,000
I tak widzimy, że jest to punkt wyjścia dla mojej pierwszej Objective-C wniosku.

256
00:13:30,000 --> 00:13:32,000
Tutaj możemy ignorować tego teraz.

257
00:13:32,000 --> 00:13:35,000
Jest to po prostu niektóre rzeczy zarządzania pamięcią, które nie będziesz naprawdę

258
00:13:35,000 --> 00:13:37,000
kiedykolwiek się martwić.

259
00:13:37,000 --> 00:13:39,000
>> Przyjrzyjmy się tym pierwszym bloku tutaj.

260
00:13:39,000 --> 00:13:46,000
Ta pierwsza linia, jeśli powiem, Student * alice = [[alloc Student] init] co to robisz?

261
00:13:46,000 --> 00:13:50,000
Ten pierwszy uczeń tutaj, to prawdopodobnie klasy.

262
00:13:50,000 --> 00:13:54,000
To nie klasa, że ​​Apple to napisał, ale jest to klasa, która napisałem.

263
00:13:54,000 --> 00:13:57,000
Pierwszą rzeczą, którą chcesz zrobić, to chcę, aby przydzielić miejsca dla nowego ucznia,

264
00:13:57,000 --> 00:14:00,000
a następnie chcę, aby zainicjować go, więc to daje mnie

265
00:14:00,000 --> 00:14:05,000
Ten nowy obiekt student, a ja jestem w tym przechowywania w zmiennej o nazwie Alice.

266
00:14:05,000 --> 00:14:07,000
Skąd to klasa pochodzi?

267
00:14:07,000 --> 00:14:12,000
Cóż, tutaj z lewej strony to wszystko z różnych plików wewnątrz mojego projektu.

268
00:14:12,000 --> 00:14:16,000
Widzimy tutaj mam Student.h i Student.m.

269
00:14:16,000 --> 00:14:20,000
Plik. H, pamiętaj, gdzie jest Oświadczam wszystkie rzeczy

270
00:14:20,000 --> 00:14:22,000
która istnieje w klasie.

271
00:14:22,000 --> 00:14:25,000
>> Rzućmy okiem na to.

272
00:14:25,000 --> 00:14:29,000
Dobra, mamy to @ interface, a ten mówi, że nadchodzi

273
00:14:29,000 --> 00:14:33,000
deklaracje wszystkiego, co będzie istnieć w mojej klasie.

274
00:14:33,000 --> 00:14:36,000
Następnie mam dwukropek. Wtedy mam ten NSObject rzeczy.

275
00:14:36,000 --> 00:14:40,000
To oznacza, że ​​dwukropek trochę spadków Rozmawialiśmy trochę wcześniej.

276
00:14:40,000 --> 00:14:43,000
To mówi wszystko NSObject może zrobić

277
00:14:43,000 --> 00:14:46,000
gdzie NSObject jest ta klasa napisana przez kogoś innego,

278
00:14:46,000 --> 00:14:50,000
wszystko to NSObject może zrobić chcę być w stanie to zrobić.

279
00:14:50,000 --> 00:14:54,000
Mówiąc: NSObject to oznacza, że ​​ja w zasadzie

280
00:14:54,000 --> 00:14:58,000
dziedziczone wszystkich funkcji innej klasy.

281
00:14:58,000 --> 00:15:02,000
To naprawdę dał mi całą masę różnych metod i właściwości, które można wykorzystać.

282
00:15:02,000 --> 00:15:05,000
Tu tworzę 2 właściwości.

283
00:15:05,000 --> 00:15:08,000
To oznacza, że ​​mój uczeń, gdyby to było struct, byłyby to 2 rzeczy

284
00:15:08,000 --> 00:15:11,000
wewnątrz mojej struktury, więc każdy uczeń ma imię

285
00:15:11,000 --> 00:15:14,000
to jest ciąg znaków, a uczeń ma również klasy,

286
00:15:14,000 --> 00:15:17,000
który jest int.

287
00:15:17,000 --> 00:15:23,000
>> Wreszcie tu zamierzam stworzyć metodę dla mojego ucznia.

288
00:15:23,000 --> 00:15:26,000
Zadzwoniłem moja metoda, initWithName i trwa jeden argument,

289
00:15:26,000 --> 00:15:31,000
i ten argument jest ciągiem, i nazwał go nazwać.

290
00:15:31,000 --> 00:15:35,000
Teraz przyjrzyjmy się, jak w rzeczywistości realizowane tej klasy.

291
00:15:35,000 --> 00:15:38,000
Tutaj, teraz jestem w środku mojego pliku. M,

292
00:15:38,000 --> 00:15:40,000
m do realizacji, chyba.

293
00:15:40,000 --> 00:15:44,000
Mam wykonania, mój koniec, a tu, gdzie jestem naprawdę definiowania

294
00:15:44,000 --> 00:15:47,000
co initWithName robi.

295
00:15:47,000 --> 00:15:50,000
Mam initWithName, nazwę mojego parametru, a następnie ten

296
00:15:50,000 --> 00:15:53,000
jest, gdy jestem naprawdę tworząc studenta

297
00:15:53,000 --> 00:15:56,000
a więc jest to trochę tajemnicze, ale jest to rodzaj boilerplate

298
00:15:56,000 --> 00:15:58,000
, które chcesz umieścić w swoich konstruktorów.

299
00:15:58,000 --> 00:16:02,000
Ta funkcja inicjalizacji tutaj initWithName, jest rodzajem konstruktora.

300
00:16:02,000 --> 00:16:05,000
Jesteś w zasadzie budowę nowego obiektu studentów

301
00:16:05,000 --> 00:16:07,000
i może wysyłać niektóre dane znajdujące się wewnątrz niej.

302
00:16:07,000 --> 00:16:11,000
Pierwszą rzeczą, którą chcesz zrobić, to chcę zadzwonić init, na tej super rzeczy.

303
00:16:11,000 --> 00:16:15,000
>> Pamiętaj, że kiedy powiedziałem tu w pliku. H

304
00:16:15,000 --> 00:16:21,000
że wszystko NSObject ma uczeń posiada.

305
00:16:21,000 --> 00:16:24,000
Oznacza to, że podczas tworzenia studenta, co również trzeba zrobić, to

306
00:16:24,000 --> 00:16:28,000
upewnić się, że NSObject że jestem dziedziczenie wszystkich tych danych z

307
00:16:28,000 --> 00:16:32,000
jest poprawnie zainicjowany.

308
00:16:32,000 --> 00:16:36,000
Co muszę powiedzieć, to to super faktycznie się odnoszą się do klasy nadrzędnej

309
00:16:36,000 --> 00:16:39,000
że jestem dziedziczenie z, więc chcę się upewnić, zainicjować

310
00:16:39,000 --> 00:16:43,000
wszystko to, co mam w zależności od zanim zacznę próbować go użyć.

311
00:16:43,000 --> 00:16:46,000
Następnie jeśli zainicjalizowany poprawnie to jest tak jak mówią, jeśli malloc

312
00:16:46,000 --> 00:16:50,000
nie zwróci wartość null, wówczas można rozpocząć ustawienie niektórych właściwości.

313
00:16:50,000 --> 00:16:54,000
>> W JavaScripcie i PHP mieliśmy ten parametr nazywa to

314
00:16:54,000 --> 00:16:58,000
i ten odniósł się do bieżącej instancji klasy.

315
00:16:58,000 --> 00:17:00,000
W Objective-C nazywamy to ja.

316
00:17:00,000 --> 00:17:04,000
Kiedy mówię self.name, co oznacza, że ​​obiekt

317
00:17:04,000 --> 00:17:07,000
I właśnie utworzony, kiedy powiedziałem alloc uczeń init

318
00:17:07,000 --> 00:17:09,000
że zamierza mi zwrócić obiekt.

319
00:17:09,000 --> 00:17:12,000
To znaczy, że chcę, aby ustawić nazwę tego obiektu

320
00:17:12,000 --> 00:17:15,000
do tego, co właśnie przeszedł w.

321
00:17:15,000 --> 00:17:18,000
Podobnie jak w C, mamy dostęp użytkowników z tej kropki,

322
00:17:18,000 --> 00:17:21,000
tak self.name mówi nazwa obiektu studenckiej

323
00:17:21,000 --> 00:17:24,000
teraz będzie cokolwiek właśnie przeszedł w.

324
00:17:24,000 --> 00:17:28,000
I tak w końcu, mogę go zwrócić, więc rzeczywiście wrócić coś.

325
00:17:28,000 --> 00:17:30,000
>> Pytania?

326
00:17:30,000 --> 00:17:34,000
Okay, więc to samo = Super init

327
00:17:34,000 --> 00:17:37,000
jeśli nie całkowicie rozumiem rzeczy dziedziczenia nie martw się.

328
00:17:37,000 --> 00:17:40,000
Wystarczy wiedzieć, że jeśli kiedykolwiek chcesz zrobić własny metoda init tylko

329
00:17:40,000 --> 00:17:42,000
zrobić, a będziesz dobrze iść.

330
00:17:42,000 --> 00:17:44,000
Tak. >> [Student] Co oznacza, jeśli średnią siebie?

331
00:17:44,000 --> 00:17:49,000
Oznacza to, że gdy malloc coś zawsze sprawdzany, jeśli była równa null,

332
00:17:49,000 --> 00:17:51,000
i czy to null, potem odszedł.

333
00:17:51,000 --> 00:17:55,000
To jest to samo, bo jeśli ta zwraca null, to pewnie będzie seg winy

334
00:17:55,000 --> 00:17:57,000
jeśli zaczniemy próbuje manipulować.

335
00:17:57,000 --> 00:18:01,000
To jest nasza klasa student.

336
00:18:01,000 --> 00:18:03,000
To oznacza, że ​​możemy zainicjować naszych uczniów w jeden z dwóch sposobów.

337
00:18:03,000 --> 00:18:08,000
Jeśli powiem alloc uczeń init, nie używam tej metody, że po prostu napisał,

338
00:18:08,000 --> 00:18:11,000
a zamiast tego można po prostu powiedzieć, alice.name,

339
00:18:11,000 --> 00:18:14,000
i teraz mam zamiar ustawić tę nazwę właściwości.

340
00:18:14,000 --> 00:18:17,000
>> Podobnie, jeśli chcę użyć tej metody initWithName

341
00:18:17,000 --> 00:18:20,000
Mogę po prostu powiedzieć, Alloc, a następnie zamiast mówić startowych

342
00:18:20,000 --> 00:18:24,000
Mam zamiar zadzwonić tę metodę, że po prostu stworzone, i mam zamiar przejść w Boba.

343
00:18:24,000 --> 00:18:30,000
W tym momencie, obiekt Bob nazwę równą Boba.

344
00:18:30,000 --> 00:18:35,000
Dobra, tu używam tego NSMutableArray że przyjrzeliśmy wcześniej.

345
00:18:35,000 --> 00:18:38,000
Jestem przydzielania space.Then Jestem inicjowanie nową tablicę.

346
00:18:38,000 --> 00:18:40,000
Mam zamiar dodać 2 rzeczy do niego.

347
00:18:40,000 --> 00:18:43,000
Tablica ta posiada obecnie obiektów studenckich.

348
00:18:43,000 --> 00:18:46,000
Zauważ, że nigdzie nie muszę powiedzieć, że jest to tablica studentów.

349
00:18:46,000 --> 00:18:48,000
I powiedział, że to array, period.

350
00:18:48,000 --> 00:18:50,000
Następnie można umieścić cokolwiek wewnątrz niego, że chcę.

351
00:18:50,000 --> 00:18:52,000
Tutaj mam 2 obiekty.

352
00:18:52,000 --> 00:18:56,000
>> Wreszcie, mam inny obiekt tutaj, to TF.

353
00:18:56,000 --> 00:18:59,000
Tutaj w zasadzie TF.h samo.

354
00:18:59,000 --> 00:19:01,000
Jestem dziedziczy z NSObject, a przy okazji,

355
00:19:01,000 --> 00:19:03,000
podczas tworzenia klas jest to wszystko zrobić dla ciebie,

356
00:19:03,000 --> 00:19:06,000
ten rodzaj boilerplate interfejsu.

357
00:19:06,000 --> 00:19:08,000
Ma właściwości uczniów.

358
00:19:08,000 --> 00:19:15,000
Mam Metody para tutaj nie naprawdę dużo,

359
00:19:15,000 --> 00:19:18,000
i tak, że oznacza po utworzeniu tego obiektu TF

360
00:19:18,000 --> 00:19:23,000
Mogę nazwać ten gatunek metody na to w ten sposób.

361
00:19:23,000 --> 00:19:26,000
Wszelkie pytania dotyczące składni Objective-C, zanim zacznie się na kilka

362
00:19:26,000 --> 00:19:30,000
interesujący rozwój aplikacje rzeczy?

363
00:19:30,000 --> 00:19:34,000
>> Ok, więc niech rzeczywiście zrobić app iPhone.

364
00:19:34,000 --> 00:19:39,000
Klas podstawowych, które będziesz używać wewnątrz Twojego iPhone app nazywane są kontrolery widok,

365
00:19:39,000 --> 00:19:42,000
i kontroler widoku zasadniczo reprezentuje pojedynczy ekran

366
00:19:42,000 --> 00:19:46,000
wewnątrz swojej aplikacji, więc jeśli jestem na aplikacji muzycznej, na przykład,

367
00:19:46,000 --> 00:19:50,000
jeden widok kontroler może reprezentować pogląd, w którym zobaczyć wszystkie utwory na moim iPhone.

368
00:19:50,000 --> 00:19:53,000
Kolejny kontroler widoku może być po kliknięciu utwór i rozpocząć odtwarzanie

369
00:19:53,000 --> 00:19:55,000
lub jak jestem drążenia do artystów.

370
00:19:55,000 --> 00:19:59,000
Każdy z tych innych ekranów mogą być reprezentowane innego sterownika widoku

371
00:19:59,000 --> 00:20:04,000
i kontroler widoku jest naprawdę tylko klasy, który mówi, jak ten ekran działa.

372
00:20:04,000 --> 00:20:07,000
Rzeczy wewnątrz kontrolera widoku, będziemy mieć właściwości

373
00:20:07,000 --> 00:20:10,000
więc takie rzeczy jak przycisk będzie własnością naszego kontrolera widoku.

374
00:20:10,000 --> 00:20:13,000
>> Mamy również zamiar mają metody, a te są w zasadzie obsługi zdarzeń.

375
00:20:13,000 --> 00:20:16,000
Ta metoda mówi, po naciśnięciu tego przycisku

376
00:20:16,000 --> 00:20:19,000
Chcę coś zrobić, a na końcu znowu

377
00:20:19,000 --> 00:20:24,000
będziemy używać tego samo słowo kluczowe, aby uzyskać dostęp do bieżącej instancji.

378
00:20:24,000 --> 00:20:29,000
Do tworzenia interfejsów w iOS jest rzeczywiście bardzo, bardzo proste.

379
00:20:29,000 --> 00:20:32,000
Mają ten miły interfejs przeciągnij i upuść nazwie Interface Builder,

380
00:20:32,000 --> 00:20:37,000
i 2 podstawowych pojęć, że drut swojej Objective-C do Interface Builder

381
00:20:37,000 --> 00:20:40,000
są IBOutlet i IBAction.

382
00:20:40,000 --> 00:20:44,000
IBOutlet mówi po prostu, że jeśli zadeklarować właściwość, że znajduje się przycisk,

383
00:20:44,000 --> 00:20:47,000
i chcesz podłączyć go do czegoś w aktualnej UI,

384
00:20:47,000 --> 00:20:49,000
masz zamiar powiedzieć, że to gniazdo.

385
00:20:49,000 --> 00:20:51,000
Podobnie, jeśli chcesz reprezentować obsługi zdarzeń

386
00:20:51,000 --> 00:20:54,000
następnie masz zamiar powiedzieć, że jest to działanie.

387
00:20:54,000 --> 00:20:57,000
>> Aby faktycznie drut aż ten graficzną reprezentację

388
00:20:57,000 --> 00:21:00,000
a kod to jest naprawdę proste.

389
00:21:00,000 --> 00:21:03,000
Jeśli chcesz dołączyć IBOutlet, wszystko co musisz zrobić, to kontrolować kliknięcia

390
00:21:03,000 --> 00:21:05,000
i zobaczymy przykład to naprawdę szybko.

391
00:21:05,000 --> 00:21:07,000
Możesz kontrolować kliknij gdzie mówi Controller View.

392
00:21:07,000 --> 00:21:09,000
Masz zamiar przeciągnąć do interfejsu, lub odwrotnie,

393
00:21:09,000 --> 00:21:13,000
jeśli chcesz podłączyć moduł obsługi zdarzeń będziesz przeciągać z interfejsu

394
00:21:13,000 --> 00:21:15,000
w drugim kierunku.

395
00:21:15,000 --> 00:21:20,000
Rzućmy okiem na bardzo prostym przykładzie iOS.

396
00:21:20,000 --> 00:21:23,000
>> Stwórzmy nowy projekt.

397
00:21:23,000 --> 00:21:25,000
Mam zamiar przyjechać tu do stosowania,

398
00:21:25,000 --> 00:21:28,000
i mam zamiar kliknąć pojedynczej aplikacji Widok.

399
00:21:28,000 --> 00:21:31,000
Idę do kliknij next. Podam mój projekt nazwę.

400
00:21:31,000 --> 00:21:33,000
Nazwijmy go Hello.

401
00:21:33,000 --> 00:21:36,000
Co ciekawe, Apple zakłada, że ​​tworzysz produkt

402
00:21:36,000 --> 00:21:38,000
tak, że można go sprzedać i mogą zarabiać pieniądze.

403
00:21:38,000 --> 00:21:41,000
Tu mam zamiar powiedzieć, że jest to aplikacja na iPhone.

404
00:21:41,000 --> 00:21:44,000
Można utworzyć aplikację iPad, lub jeśli chcesz stworzyć jedną z tych aplikacji,

405
00:21:44,000 --> 00:21:47,000
który obsługuje zarówno urządzenia, które możesz zrobić, że zbyt.

406
00:21:47,000 --> 00:21:49,000
Są to, co chcesz, aby Twoje znacznikami wyboru wyglądać.

407
00:21:49,000 --> 00:21:51,000
>> Chcesz korzystać storyboardy, które zobaczymy później,

408
00:21:51,000 --> 00:21:54,000
i na pewno chcemy korzystać z automatycznego liczenia odniesienia,

409
00:21:54,000 --> 00:21:58,000
co jest dobrą cechą, która eliminuje konieczność powiedzieć malloc i free.

410
00:21:58,000 --> 00:22:03,000
Chyba, że ​​chcesz wywołać malloc i wolne, chciałbym pozostawić to sprawdzone.

411
00:22:03,000 --> 00:22:07,000
Będę kliknij obok, i wreszcie, to będzie o mnie, gdzie chcę, aby go zapisać.

412
00:22:07,000 --> 00:22:14,000
Uderzę tworzyć i jedziemy.

413
00:22:14,000 --> 00:22:16,000
Stworzyłem nowy projekt.

414
00:22:16,000 --> 00:22:19,000
Tutaj po lewej stronie są wszystkie pliki, które znajdują się wewnątrz mojego projektu,

415
00:22:19,000 --> 00:22:22,000
i zauważ, że mam całą masę, a ja nawet nie robić nic.

416
00:22:22,000 --> 00:22:24,000
IOS jest świetny.

417
00:22:24,000 --> 00:22:27,000
>> Na przykład, tutaj to ViewController.h,

418
00:22:27,000 --> 00:22:30,000
to będzie reprezentować swój pierwszy kontroler widoku,

419
00:22:30,000 --> 00:22:32,000
więc pierwszym ekranie wewnątrz mojej aplikacji.

420
00:22:32,000 --> 00:22:34,000
Teraz już wiemy, co to mówi.

421
00:22:34,000 --> 00:22:36,000
Mówimy dzwonię ten ViewController klasy,

422
00:22:36,000 --> 00:22:40,000
i robi wszystko, aby ViewController UIViewController robi,

423
00:22:40,000 --> 00:22:43,000
i to znowu jest jakaś klasa, że ​​Apple napisał robi wiele rzeczy dla nas wygodny

424
00:22:43,000 --> 00:22:46,000
jak wyświetlić ekran.

425
00:22:46,000 --> 00:22:50,000
Tutaj jest miejsce gdzie mogę zacząć definiowanie co mój kontroler widoku robi,

426
00:22:50,000 --> 00:22:52,000
i okazuje się, że tak naprawdę nie potrzebuję tego.

427
00:22:52,000 --> 00:22:55,000
To jest kod boilerplate że Apple daje mi za darmo.

428
00:22:55,000 --> 00:22:59,000
Ja potrzebuję tej pierwszej linii, albo nie mam klasy,

429
00:22:59,000 --> 00:23:02,000
więc możemy pozbyć się tego i pozbyć się tego.

430
00:23:02,000 --> 00:23:05,000
Ok, więc to jest mój pusty ekran.

431
00:23:05,000 --> 00:23:08,000
>> Teraz kliknij na ten MainStoryboard.storyboard,

432
00:23:08,000 --> 00:23:11,000
i to, gdy zaczyna się interesujące.

433
00:23:11,000 --> 00:23:14,000
Jest to pierwszy ekran na moim app.

434
00:23:14,000 --> 00:23:17,000
Jeśli chcę dodać przycisk w HTML musiałem utworzyć tag przycisk.

435
00:23:17,000 --> 00:23:20,000
W Android musisz utworzyć tag przycisku,

436
00:23:20,000 --> 00:23:23,000
ale w iOS jeśli tylko przyjść tutaj w prawym dolnym rogu

437
00:23:23,000 --> 00:23:27,000
i jeśli mogę kliknąć na ten 3-ta jeden tu, gdzie mówi obiekty,

438
00:23:27,000 --> 00:23:31,000
i można przewijać, czy mogę zacząć szukać przycisku.

439
00:23:31,000 --> 00:23:35,000
I patrzeć, przycisk, więc jeśli rzeczywiście przeciągnąć to prawo tam,

440
00:23:35,000 --> 00:23:38,000
Właśnie dodałem przycisk do tego ekranu na mojej aplikacji.

441
00:23:38,000 --> 00:23:41,000
Jeśli chcę zmienić tekst, mogę kliknij go dwukrotnie,

442
00:23:41,000 --> 00:23:47,000
powiedzieć coś kuszące jak "Naciśnij mnie".

443
00:23:47,000 --> 00:23:51,000
Dobra, a teraz jeśli uruchomić tę aplikację, więc go skompilować,

444
00:23:51,000 --> 00:23:54,000
tak, aby go uruchomić i kliknąć przycisk odtwarzania w lewym górnym rogu, a tam moja aplikacja.

445
00:23:54,000 --> 00:23:58,000
Ja nic nie zrobiłem, i mam słodki szuka app iPhone.

446
00:23:58,000 --> 00:24:01,000
Jeśli chcę go zatrzymać, możesz kliknąć przycisk stop

447
00:24:01,000 --> 00:24:03,000
ponieważ jest więcej zabawy.

448
00:24:03,000 --> 00:24:07,000
>> Powiedzmy, że faktycznie chcę coś się stało po naciśnięciu tego przycisku.

449
00:24:07,000 --> 00:24:09,000
Aby to zrobić, co trzeba zrobić, to trzeba utworzyć

450
00:24:09,000 --> 00:24:13,000
nowy uchwyt zdarzenia lub działania.

451
00:24:13,000 --> 00:24:16,000
To oznacza, że ​​trzeba stworzyć pewne metody, które chcę być nazywany

452
00:24:16,000 --> 00:24:18,000
po naciśnięciu przycisku, więc stwórzmy nową metodę.

453
00:24:18,000 --> 00:24:20,000
Jestem wewnątrz ViewController.h.

454
00:24:20,000 --> 00:24:22,000
Muszę powiedzieć, że metoda istnieje.

455
00:24:22,000 --> 00:24:26,000
Muszę myślnik pierwszy, ponieważ mam zamiar być wywołanie to na kontrolerze widoku.

456
00:24:26,000 --> 00:24:28,000
Muszę dać ten typ.

457
00:24:28,000 --> 00:24:31,000
Typ to będzie to coś IBAction które widzieliśmy wcześniej.

458
00:24:31,000 --> 00:24:35,000
To jest zdarzenie, tak to się zwróci IBAction,

459
00:24:35,000 --> 00:24:38,000
i jest to aluzja do XCode powiedzieć, że

460
00:24:38,000 --> 00:24:40,000
to jest coś, co chcę podłączyć coś.

461
00:24:40,000 --> 00:24:45,000
Mogę dać mu nazwę, jak buttonPressed, średnikiem.

462
00:24:45,000 --> 00:24:48,000
>> Teraz już ogłosił nową metodę wewnątrz z mojej klasy.

463
00:24:48,000 --> 00:24:50,000
Powiedziałem, metoda ta ma istnieć.

464
00:24:50,000 --> 00:24:53,000
Teraz wchodzą ViewController.m,

465
00:24:53,000 --> 00:24:56,000
i powiedzmy, że to, co ta metoda może zrobić.

466
00:24:56,000 --> 00:25:03,000
Jeśli zacznę pisać, na przykład, (void) buttonPressed

467
00:25:03,000 --> 00:25:06,000
Anons XCode jest naprawdę ładne i autocompletes dla mnie.

468
00:25:06,000 --> 00:25:09,000
To naprawdę wspaniałe.

469
00:25:09,000 --> 00:25:12,000
Zauważcie, że wewnątrz. M pliku można również powiedzieć, nieważne,

470
00:25:12,000 --> 00:25:15,000
a to dlatego, że w rzeczywistości nie jest IBAction typu.

471
00:25:15,000 --> 00:25:19,000
To faktycznie hashtag zdefiniowane gdzieś być unieważnione,

472
00:25:19,000 --> 00:25:22,000
i znowu, to tylko wskazówka do XCode, który mówi

473
00:25:22,000 --> 00:25:25,000
Chcę to być zdarzenie, a my zobaczymy, dlaczego w ciągu sekundy.

474
00:25:25,000 --> 00:25:28,000
Po naciśnięciu tego przycisku mam zamiar zrobić coś, przykry

475
00:25:28,000 --> 00:25:30,000
jak wyświetlić okienko.

476
00:25:30,000 --> 00:25:35,000
>> W tym celu można utworzyć nową instancję tej klasy o nazwie UIAlertView,

477
00:25:35,000 --> 00:25:39,000
i jest to klasa, która napisała, że ​​firmy Apple zamierza wyświetlać denerwujących pop-upów.

478
00:25:39,000 --> 00:25:43,000
Nazwijmy to okienko alert, a ja mam 2 kroki, pamiętaj, do tworzenia tego obiektu.

479
00:25:43,000 --> 00:25:46,000
Pierwszą rzeczą, którą musisz zrobić, to przydzielić miejsca.

480
00:25:46,000 --> 00:25:48,000
Chcę UIAlertView.

481
00:25:48,000 --> 00:25:51,000
Chcę przeznaczyć przestrzeń. To moja pierwsza metoda.

482
00:25:51,000 --> 00:25:53,000
Moja kolejna metoda to chcę go zainicjować,

483
00:25:53,000 --> 00:25:58,000
i tak mam ten duży, długi metodę zwaną initWithTitle.

484
00:25:58,000 --> 00:26:01,000
To w zasadzie będzie kontrolować, co to okienko mówi.

485
00:26:01,000 --> 00:26:04,000
Tytuł mojego popup może być hello.

486
00:26:04,000 --> 00:26:08,000
Przesłanie to okienko może być "to iOS."

487
00:26:08,000 --> 00:26:10,000
Delegat rzeczą, ja nie wiem, co to jest.

488
00:26:10,000 --> 00:26:13,000
Powiedzmy, że to nic.

489
00:26:13,000 --> 00:26:18,000
Teraz przycisk, który będzie pojawiać się może powiedzieć coś takiego: "To na pewno jest"

490
00:26:18,000 --> 00:26:24,000
a ja nie chcę żadnych innych przycisków, więc niech ją usunąć i zamknąć uchwyt.

491
00:26:24,000 --> 00:26:27,000
>> Okay, I stworzył dodatkowy jeden. Proszę bardzo.

492
00:26:27,000 --> 00:26:30,000
W ten sposób można utworzyć nowy popup.

493
00:26:30,000 --> 00:26:35,000
Jeśli chcę, aby rzeczywiście zobaczyć okienko chcę wywołać metodę show.

494
00:26:35,000 --> 00:26:38,000
Aby to zrobić, że mogę powiedzieć, alarm i pokazanie,

495
00:26:38,000 --> 00:26:40,000
i znowu, autouzupełnianie był super miły.

496
00:26:40,000 --> 00:26:42,000
Jeśli nie pamiętam, co to było, gdybym po prostu wpisane w s,

497
00:26:42,000 --> 00:26:45,000
Można przewijać, żeby dowiedzieć się, co to było,

498
00:26:45,000 --> 00:26:48,000
i filtruje ładnie.

499
00:26:48,000 --> 00:26:52,000
Teraz stworzyliśmy nowy popup.

500
00:26:52,000 --> 00:26:55,000
Wrócimy do tego, co oznacza, delegat później

501
00:26:55,000 --> 00:26:58,000
i teraz chcę powiedzieć, że metoda ta ma być zwolniony

502
00:26:58,000 --> 00:27:01,000
po naciśnięciu przycisku, więc mam zamiar wrócić do mojej serii ujęć

503
00:27:01,000 --> 00:27:04,000
i chcę teraz dołączyć to IBAction.

504
00:27:04,000 --> 00:27:06,000
Pierwszą rzeczą, którą chcesz zrobić, to kliknąć przycisk.

505
00:27:06,000 --> 00:27:08,000
Po naciśnięciu tego przycisku, chcę coś się wydarzy.

506
00:27:08,000 --> 00:27:10,000
I nie zamierzam się przytrzymać kontrolę.

507
00:27:10,000 --> 00:27:13,000
Idę do kliknij i przeciągnij z przycisku

508
00:27:13,000 --> 00:27:15,000
się tu, gdzie mówi kontroler widoku.

509
00:27:15,000 --> 00:27:17,000
Możemy zobaczyć, że ładnie się świecą.

510
00:27:17,000 --> 00:27:22,000
>> Jeśli mam odejść z mojej myszki teraz mam to okienko tu gdzie mam kilka opcji.

511
00:27:22,000 --> 00:27:24,000
Jedna z nich to wydarzenia, które można zarejestrować.

512
00:27:24,000 --> 00:27:28,000
Są to wszystkie z tych metod i zadeklarowane w moim pliku h jako IBActions.

513
00:27:28,000 --> 00:27:31,000
To jest jak XCode wie co powinien pojawić się w tej małej listy,

514
00:27:31,000 --> 00:27:33,000
więc to tylko wskazówka.

515
00:27:33,000 --> 00:27:37,000
Jeśli I kliknij na wciśniętym przycisku, już teraz zarejestrowała obsługi zdarzeń.

516
00:27:37,000 --> 00:27:41,000
W JavaScript mamy powiedzieć, że niektóre kod, który zarejestrował obsługi zdarzeń.

517
00:27:41,000 --> 00:27:43,000
W Objective-C to naprawdę takie proste.

518
00:27:43,000 --> 00:27:46,000
Jeśli to uruchomić ponownie

519
00:27:46,000 --> 00:27:49,000
teraz po naciśnięciu przycisku mój obsługi zdarzeń będzie ogień,

520
00:27:49,000 --> 00:27:51,000
i mam zamiar uzyskać to okienko.

521
00:27:51,000 --> 00:27:54,000
Super, super proste tam.

522
00:27:54,000 --> 00:27:57,000
>> Jeśli kiedykolwiek chcesz zobaczyć wszystkie wydarzenia, które mają być rejestrowane

523
00:27:57,000 --> 00:28:00,000
na części, jeśli klikniesz na ten przycisk

524
00:28:00,000 --> 00:28:02,000
i przyjść tutaj po prawej stronie

525
00:28:02,000 --> 00:28:05,000
początku możesz zobaczyć tu można zrobić takie rzeczy jak rodzaj przycisku,

526
00:28:05,000 --> 00:28:08,000
więc jeśli chcesz, aby jeden z tych, męskie lub przycisk Dodaj Kontakt

527
00:28:08,000 --> 00:28:10,000
lub cokolwiek.

528
00:28:10,000 --> 00:28:13,000
Jeśli chcesz zobaczyć wszystkie zdarzenia, które są na tym przycisku

529
00:28:13,000 --> 00:28:16,000
gdybym przychodziła tu z prawej strony

530
00:28:16,000 --> 00:28:19,000
Widzimy tutaj, w wydarzeniach, jakie mają wszystkie z tych różnych wydarzeń.

531
00:28:19,000 --> 00:28:23,000
Można nacisnąć przycisk, kiedy puścić przycisk, kiedy dwukrotnie dotknij lub cokolwiek,

532
00:28:23,000 --> 00:28:26,000
i jeden I tylko zarejestrowane jest to wydarzenie o nazwie Touch Up Inside,

533
00:28:26,000 --> 00:28:29,000
a ten mówi, że jak tylko mój palec schodzi przycisk

534
00:28:29,000 --> 00:28:32,000
że zdarzenie będzie ognia, a to jest dokładnie to, co się właśnie stało.

535
00:28:32,000 --> 00:28:36,000
Jest to rodzaj domyślny przycisk przypadku prasowanego.

536
00:28:36,000 --> 00:28:39,000
>> Wszelkie pytania do tej pory?

537
00:28:39,000 --> 00:28:43,000
Dobra, to jak możemy zacząć podłączać się rzeczy w naszym kodzie

538
00:28:43,000 --> 00:28:46,000
do rzeczy wewnątrz naszego interfejsu.

539
00:28:46,000 --> 00:28:49,000
Pamiętaj, pierwszą rzeczą, jaką musiałem zrobić, aby znaleźć kod,

540
00:28:49,000 --> 00:28:54,000
a potem okablowany interfejs do kodu,

541
00:28:54,000 --> 00:28:57,000
i jest to nasz pierwszy app.

542
00:28:57,000 --> 00:29:00,000
Ok, to było naprawdę fajne, i stworzyliśmy ten przycisk.

543
00:29:00,000 --> 00:29:03,000
Co zrobić jeżeli nie chcemy, aby stworzyć kilka właściwości

544
00:29:03,000 --> 00:29:05,000
reprezentujących te przyciski?

545
00:29:05,000 --> 00:29:08,000
Na przykład, w Tic Tac Toe mam 9 przycisków,

546
00:29:08,000 --> 00:29:11,000
i byłoby super, super denerwujące przeciągnij i upuść 9 razy

547
00:29:11,000 --> 00:29:14,000
lub jeśli miałem do Tic Tac Toe z 81 zamiast 9

548
00:29:14,000 --> 00:29:17,000
i musiałem przeciągnąć 81 razy, i to jest żałosne.

549
00:29:17,000 --> 00:29:20,000
Co możemy zrobić, a nie jest tak jak HTML

550
00:29:20,000 --> 00:29:23,000
kiedy mieliśmy takie rzeczy identyfikatorów i nazw i możemy szukać rzeczy

551
00:29:23,000 --> 00:29:27,000
według ich ID, jest podobny pogląd w iOS nazwie tags.

552
00:29:27,000 --> 00:29:31,000
>> Tag jest po prostu niepowtarzalny numeryczny identyfikator dla składnika.

553
00:29:31,000 --> 00:29:34,000
To znaczy, jeśli znacznik jest 0, na przykład

554
00:29:34,000 --> 00:29:38,000
jeśli utworzyć przycisk i dać mu znak 0, a my zobaczymy, jak to zrobić w ciągu zaledwie sekundy,

555
00:29:38,000 --> 00:29:41,000
jeśli chcę dostać ten przycisk można po prostu powiedzieć, że chcesz się połączyć

556
00:29:41,000 --> 00:29:45,000
viewWithTag metodę na obiekcie tutaj,

557
00:29:45,000 --> 00:29:48,000
self.view, który reprezentuje bieżący ekran, na przykład.

558
00:29:48,000 --> 00:29:53,000
Jeśli zgłoszę tę metodę viewWithTag, zamierzam się wycofać przycisk ze znacznikiem 0.

559
00:29:53,000 --> 00:29:58,000
Rzućmy okiem na to, budując Tac Toe Tic.

560
00:29:58,000 --> 00:30:01,000
Po pierwsze, jest to mój storyboard.

561
00:30:01,000 --> 00:30:05,000
Stworzyłem te 10 przycisków interfejsu użytkownika.

562
00:30:05,000 --> 00:30:07,000
Zauważ, wszystkie są tej samej wielkości.

563
00:30:07,000 --> 00:30:11,000
Jeśli I kliknij jedną z nich i wrócę tu na tej prawej stronie

564
00:30:11,000 --> 00:30:15,000
zobaczysz I dostosować czcionkę tu, więc zrobiłem czcionki trochę większe,

565
00:30:15,000 --> 00:30:19,000
ale to, co również nie było ustawić ten tag.

566
00:30:19,000 --> 00:30:23,000
Powiedziałem, że to ma tag 1, i to jest w lewym górnym rogu.

567
00:30:23,000 --> 00:30:26,000
>> Teraz, gdy klikam przycisk innego, jak ten drugi tutaj,

568
00:30:26,000 --> 00:30:29,000
teraz widać, że mój tag jest 2.

569
00:30:29,000 --> 00:30:32,000
Każdy z tych przycisków po prostu ma niepowtarzalny tag,

570
00:30:32,000 --> 00:30:35,000
i tak to później, jak mam zamiar rozpocząć interakcję

571
00:30:35,000 --> 00:30:38,000
z mojej aplikacji.

572
00:30:38,000 --> 00:30:40,000
Wszystko to jest wewnątrz jeden widok regulatora

573
00:30:40,000 --> 00:30:42,000
ale o to, co mamy.

574
00:30:42,000 --> 00:30:44,000
Mamy 3 właściwości tutaj.

575
00:30:44,000 --> 00:30:49,000
Pierwsza i ostatnia będą przedstawiają stan mojej płyty.

576
00:30:49,000 --> 00:30:53,000
Zasadniczo pierwszy jest tablica reprezentująca gdzie Xs i Os są.

577
00:30:53,000 --> 00:30:57,000
Ta druga tu mówi nam, którego jest tura.

578
00:30:57,000 --> 00:31:01,000
Zauważysz, że ja też mam te rzeczy tutaj.

579
00:31:01,000 --> 00:31:05,000
Wcześniej, kiedy oświadczył właściwości daliśmy im nazwę i typ.

580
00:31:05,000 --> 00:31:08,000
Możemy także dać im kilka dodatkowych informacji tutaj.

581
00:31:08,000 --> 00:31:11,000
Ten pierwszy mówi nonatomic i co to mówi

582
00:31:11,000 --> 00:31:16,000
jest w zasadzie tylko jedna rzecz nigdy nie będzie próbował uzyskać dostęp do tej zmiennej w czasie.

583
00:31:16,000 --> 00:31:19,000
Można zrobić bardziej złożonych aplikacji, które są wielowątkowe,

584
00:31:19,000 --> 00:31:22,000
i tak z powrotem w Scratch mieliśmy różne wątki,

585
00:31:22,000 --> 00:31:25,000
i mogą być różne duszki robi różne rzeczy w tym samym czasie.

586
00:31:25,000 --> 00:31:29,000
>> Jeśli tak nie jest, co nie jest w nic, że będziemy patrzeć na to,

587
00:31:29,000 --> 00:31:33,000
jeśli mówimy nonatomic to faktycznie zrobi wszystko trochę szybciej.

588
00:31:33,000 --> 00:31:37,000
Mamy też to coś o nazwie przywiąż, silny lub słaby.

589
00:31:37,000 --> 00:31:40,000
Ten przypisać po prostu mówi, że jest to standardowy typ.

590
00:31:40,000 --> 00:31:43,000
To nie jest obiekt lub wskaźnik jest, bo to jest tylko bool,

591
00:31:43,000 --> 00:31:46,000
tak bool jest wbudowany w Objective-C.

592
00:31:46,000 --> 00:31:49,000
Ten mówi, nie próbuj niczego ozdobnego z wskaźniki tutaj.

593
00:31:49,000 --> 00:31:51,000
Jest regularny stary skalowania.

594
00:31:51,000 --> 00:31:54,000
Silne i słabe, to mówi, że faktycznie słaby

595
00:31:54,000 --> 00:31:57,000
Chcę, aby było to wskazuje na coś w kontrolerze widoku.

596
00:31:57,000 --> 00:32:00,000
I nie zamierzam faktycznie przeznaczyć albo w init to samodzielnie.

597
00:32:00,000 --> 00:32:04,000
Budowniczy interfejs, kiedy uruchomić aplikację, będzie obsługiwać wszystkie te inicjalizacji.

598
00:32:04,000 --> 00:32:07,000
Jeśli powiem, że słaby, że mówi ktoś inny ma być stworzenie tego.

599
00:32:07,000 --> 00:32:09,000
Jeśli powiem, że silny, to mówi, że mam zamiar być tym

600
00:32:09,000 --> 00:32:12,000
który jest tworzenie tego obiektu pokładzie,

601
00:32:12,000 --> 00:32:14,000
a więc mam trochę więcej metod tutaj

602
00:32:14,000 --> 00:32:18,000
np. skarga o kiedy nowa gra przycisk jest wciśnięty,

603
00:32:18,000 --> 00:32:20,000
działanie, gdy którykolwiek z pozostałych przycisków zostanie naciśnięty,

604
00:32:20,000 --> 00:32:23,000
i et cetera.

605
00:32:23,000 --> 00:32:26,000
>> Nie dostanie się zbyt dużo logiki Tic Tac Toe,

606
00:32:26,000 --> 00:32:30,000
chociaż jest to bardzo ekscytujące, ale rzućmy okiem na

607
00:32:30,000 --> 00:32:33,000
niektóre z rzeczy, które możemy zrobić wewnątrz iOS.

608
00:32:33,000 --> 00:32:35,000
Ta nowa metoda gry zostanie zwolniony

609
00:32:35,000 --> 00:32:37,000
ilekroć nacisnąć nowy przycisk gry.

610
00:32:37,000 --> 00:32:41,000
Spinanie, że aż po prostu przyjść do mnie ujęć.

611
00:32:41,000 --> 00:32:43,000
Kliknąłem na nowej grze.

612
00:32:43,000 --> 00:32:47,000
Jeśli przyjdę tu na prawo widzę, że

613
00:32:47,000 --> 00:32:50,000
Touch Up Inside jest podłączony do newGame metody.

614
00:32:50,000 --> 00:32:53,000
Dlatego to będzie się strzały.

615
00:32:53,000 --> 00:32:56,000
Metoda newGame zrobi jakąś strukturę.

616
00:32:56,000 --> 00:32:59,000
Zapowiada się, że chcę, aby wyczyścić stan płyty.

617
00:32:59,000 --> 00:33:01,000
Jest to miły sposób na zmienne tablic.

618
00:33:01,000 --> 00:33:03,000
To powie to teraz kolej na X,

619
00:33:03,000 --> 00:33:07,000
i teraz mam zamiar skorzystać z tej viewWithTag rzeczy.

620
00:33:07,000 --> 00:33:11,000
>> Wiem, że moje przyciski posiadają tagi 1-9,

621
00:33:11,000 --> 00:33:13,000
i to jest coś, co arbitralnie zrywane.

622
00:33:13,000 --> 00:33:15,000
Jeśli chcę, aby tekst każdego przycisku być pusty

623
00:33:15,000 --> 00:33:17,000
bo właśnie zacząłem nową grę, a ja nie chcę

624
00:33:17,000 --> 00:33:20,000
Xs lub Os należy pozostawić ponad mogę tego zrobić.

625
00:33:20,000 --> 00:33:24,000
Mogę powiedzieć, że chcę widoku z tagu, 1, 2, 3, 4 et cetera.

626
00:33:24,000 --> 00:33:27,000
Będzie to ciągnąć inny przycisk za każdym razem.

627
00:33:27,000 --> 00:33:30,000
Tutaj mam zamiar oddać go do UIButton.

628
00:33:30,000 --> 00:33:33,000
Tak jak mogliśmy oddać Ints do pływaków i odwrotnie

629
00:33:33,000 --> 00:33:37,000
to mówi, że chcę oddać to do UIButton.

630
00:33:37,000 --> 00:33:40,000
Oznacza to, że typ będzie * UIButton

631
00:33:40,000 --> 00:33:43,000
z powodu wskaźników, ale nie martw się, że nie są już straszne.

632
00:33:43,000 --> 00:33:47,000
>> Kiedy mam ten przycisk, mam zamiar wywołać metodę na nim.

633
00:33:47,000 --> 00:33:50,000
Metoda ta nazywana jest setTitle forState, a więc to mówi

634
00:33:50,000 --> 00:33:53,000
Chcę ustawić tekst przycisku jest pusty ciąg znaków,

635
00:33:53,000 --> 00:33:57,000
i ma to być ciąg pusty, gdy nie jest wciśnięty.

636
00:33:57,000 --> 00:34:01,000
Jeśli używam tej metody, można zmienić tekst przycisku

637
00:34:01,000 --> 00:34:04,000
tak szybko, jak ktoś uderzy, ale chcemy powiedzieć, gdy przycisk jest po prostu siedzi tam

638
00:34:04,000 --> 00:34:07,000
Chcę tekst być puste.

639
00:34:07,000 --> 00:34:10,000
Wreszcie, mamy zamiar zainicjować deskę,

640
00:34:10,000 --> 00:34:12,000
i mam zamiar powiedzieć, że wszystko, co jest obecnie na 0,

641
00:34:12,000 --> 00:34:15,000
więc to zarząd niezmienna jest zmienny array,

642
00:34:15,000 --> 00:34:21,000
co oznacza, że ​​można wywołać addObject metodę i tylko 0 jej wnętrzu.

643
00:34:21,000 --> 00:34:23,000
To, co się dzieje, gdy tworzę nową grę.

644
00:34:23,000 --> 00:34:25,000
>> Rzućmy okiem na inny.

645
00:34:25,000 --> 00:34:28,000
Ta metoda jest tu IBAction że zamierza być wciśnięty

646
00:34:28,000 --> 00:34:31,000
za każdym razem jeden z tych pól jest wciśnięty.

647
00:34:31,000 --> 00:34:33,000
Teraz mamy kilka Tic Tac Toe logika tutaj.

648
00:34:33,000 --> 00:34:36,000
Dowiemy się, którego jest tura,

649
00:34:36,000 --> 00:34:39,000
i na podstawie, że albo ustawić X lub O,

650
00:34:39,000 --> 00:34:43,000
ale widzimy, że mamy do ponownego użycia tego samego obsługi zdarzeń

651
00:34:43,000 --> 00:34:45,000
na każdym z tych przycisków.

652
00:34:45,000 --> 00:34:49,000
Oznacza to, że nie ma sposobu górę lewego,

653
00:34:49,000 --> 00:34:52,000
innej metody przycisku prawym dolnym rogu, chociaż mogłem zrobić.

654
00:34:52,000 --> 00:34:54,000
To nie będzie naprawdę dobry projekt.

655
00:34:54,000 --> 00:34:57,000
Co ja tutaj robię to ja faktycznie się określić

656
00:34:57,000 --> 00:35:00,000
co znacznika, że ​​przycisk został wciśnięty jest.

657
00:35:00,000 --> 00:35:04,000
Można zauważyć, że metoda ta gra ma jeden argument.

658
00:35:04,000 --> 00:35:07,000
To się nazywa nadawca, a co nadawca jest nadawca będzie

659
00:35:07,000 --> 00:35:10,000
reprezentuje dokładnie to, co zostało zrobione na akcję.

660
00:35:10,000 --> 00:35:15,000
Jeśli naciśniesz przycisk, to nadawca będzie że UIButton

661
00:35:15,000 --> 00:35:18,000
I rzeczywiście, że przycisk, więc oznacza to, że UIButton

662
00:35:18,000 --> 00:35:20,000
ma identyfikator, bo stworzył tag.

663
00:35:20,000 --> 00:35:23,000
>> Jeśli chcę uzyskać w tagu można po prostu powiedzieć,

664
00:35:23,000 --> 00:35:26,000
Chcę tag z nadawcy,

665
00:35:26,000 --> 00:35:28,000
i znowu, właśnie oddano go do UIButton.

666
00:35:28,000 --> 00:35:32,000
I stało się, że nadawca będzie UIButton.

667
00:35:32,000 --> 00:35:34,000
To nie zawsze musi być UIButton.

668
00:35:34,000 --> 00:35:36,000
Mógłbym na przykład zarejestrować tę samą procedurę obsługi zdarzenia

669
00:35:36,000 --> 00:35:38,000
 jednego dla przycisku, po jednym dla suwaka.

670
00:35:38,000 --> 00:35:40,000
W tym przypadku, wiem, że są wszystkie przyciski, więc powiem

671
00:35:40,000 --> 00:35:43,000
Chcę to być przycisk, a następnie można uzyskać tagu

672
00:35:43,000 --> 00:35:48,000
i od słowa teraz wiem, gdzie jestem w środku planszy.

673
00:35:48,000 --> 00:35:51,000
Następnie można po prostu ustawić X lub O, może odwrócić kolej,

674
00:35:51,000 --> 00:35:54,000
sprawdzić, kto wygrał, et cetera.

675
00:35:54,000 --> 00:35:59,000
>> Wszelkie pytania na ten temat do tej pory?

676
00:35:59,000 --> 00:36:02,000
Ok, kod wysłaliśmy online-nie chcemy dostać się do zbyt

677
00:36:02,000 --> 00:36:06,000
logiki Tic Tac Toe, ale teraz widać, że naprawdę

678
00:36:06,000 --> 00:36:09,000
wszyscy robimy to jesteśmy w pętli na tej tablicy

679
00:36:09,000 --> 00:36:13,000
więc mamy kilka pętli tutaj, a my po prostu, aby zobaczyć porównanie

680
00:36:13,000 --> 00:36:18,000
mamy mecz we wszystkich rzędach, meczu w kolumnie lub coś w tym rodzaju.

681
00:36:18,000 --> 00:36:21,000
Aby rzeczywiście uruchomić tę aplikację, jeśli dotknąć jednego z tych przycisków

682
00:36:21,000 --> 00:36:24,000
metoda zabaw został zwolniony, więc to oznacza, że ​​wystarczy ustawić

683
00:36:24,000 --> 00:36:31,000
Przycisk jest X, teraz ten przycisk będzie O, i tak dalej,

684
00:36:31,000 --> 00:36:35,000
i tak to jest, jak zaczynamy wchodzić w interakcje z tym jednym app strony.

685
00:36:35,000 --> 00:36:38,000
>> Będziemy pisać kod, tak więc zapraszamy do zapoznania się, że

686
00:36:38,000 --> 00:36:43,000
ale niech się teraz mówić o niektórych aplikacji, które są czymś więcej niż tylko jednej stronie.

687
00:36:43,000 --> 00:36:47,000
Tak ekscytujące jak Tic Tac Toe było wiele aplikacji wewnątrz iOS

688
00:36:47,000 --> 00:36:50,000
są rodzajem tych drążyć rzeczy z wielu ekranach.

689
00:36:50,000 --> 00:36:54,000
Pierwsza koncepcja, że ​​musimy porozmawiać o to protokoły,

690
00:36:54,000 --> 00:36:57,000
oraz protokół prostu zestaw metod

691
00:36:57,000 --> 00:36:59,000
Obiecuję, że można zdefiniować.

692
00:36:59,000 --> 00:37:02,000
Jeśli utworzyć ten nowy protokół z 2 metod, ten pierwszy,

693
00:37:02,000 --> 00:37:05,000
jeśli typ zwracany jest nieważna, nazwałem to foo.

694
00:37:05,000 --> 00:37:07,000
To nie potrzebuje żadnych argumentów. Mam inną metodę.

695
00:37:07,000 --> 00:37:11,000
Zwraca int. Nazwałem ją zablokować, a to trwa jeden argument.

696
00:37:11,000 --> 00:37:14,000
Wszystko to jest protokół, który jest nazywany SomeProtocol tu,

697
00:37:14,000 --> 00:37:19,000
jest to zbiór rzeczy, które ktoś może wdrożyć.

698
00:37:19,000 --> 00:37:22,000
I nie wewnątrz tego protokołu powiedział, co foo robi.

699
00:37:22,000 --> 00:37:26,000
Zamiast tego, tylko mówię można zdefiniować foo, jeśli chcesz.

700
00:37:26,000 --> 00:37:30,000
Jeśli tworzę kontroler widoku lub tworząc klasę

701
00:37:30,000 --> 00:37:33,000
Mogę wewnątrz tej obietnicy klasy do wdrożenia

702
00:37:33,000 --> 00:37:40,000
Niektóre z tych metod, tak na przykład, gdy mówi <SomeProtocol>

703
00:37:40,000 --> 00:37:43,000
to teraz mówi, że robię ci obietnicę, że wewnątrz

704
00:37:43,000 --> 00:37:50,000
tej klasy kontrolera widoku będę mieć definicje obu foo i bar.

705
00:37:50,000 --> 00:37:52,000
>> Dlaczego jest to przydatne?

706
00:37:52,000 --> 00:37:55,000
Wiele elementów wewnątrz iOS to wykorzystać

707
00:37:55,000 --> 00:37:58,000
wzorzec projektowy zwany delegację, i co mówi, delegacja

708
00:37:58,000 --> 00:38:01,000
jest to, że, na przykład, jeśli mają pole tekstowe

709
00:38:01,000 --> 00:38:04,000
i jest kilka wydarzeń, które mogą być rejestrowane wewnątrz mojego pola tekstowego,

710
00:38:04,000 --> 00:38:07,000
zamiast tworzyć osobne wydarzenia, co mogę zrobić, to mogę powiedzieć,

711
00:38:07,000 --> 00:38:10,000
delegat tym polu będzie kilka obiektów.

712
00:38:10,000 --> 00:38:13,000
Kiedy mówię, że jest to delegat to oznacza, że ​​teraz

713
00:38:13,000 --> 00:38:16,000
ilekroć pewne zdarzenia zostałby zwolniony w polu tekstowym

714
00:38:16,000 --> 00:38:18,000
zamiast go zarejestrować, czy coś w tym stylu

715
00:38:18,000 --> 00:38:21,000
to po prostu się do wywołania metody na delegata.

716
00:38:21,000 --> 00:38:24,000
Na przykład, we wnętrzu moim polu tekstowym mam metodę po naciśnięciu

717
00:38:24,000 --> 00:38:27,000
tego zrobić przycisk w prawym dolnym rogu,

718
00:38:27,000 --> 00:38:30,000
i tak zamiast rejestracji obsługi zdarzeń, co mogę powiedzieć to to,

719
00:38:30,000 --> 00:38:34,000
pole tekstowe, tutaj jest obiekt, który chcę Ci do wywołania metody na

720
00:38:34,000 --> 00:38:37,000
za każdym razem ktoś naciśnie przycisk Gotowe,

721
00:38:37,000 --> 00:38:40,000
a to oznacza, że ​​obiekt musi zaimplementować protokół

722
00:38:40,000 --> 00:38:45,000
mówi, że obiecuję definiuje tego zrobić akcję przycisku,

723
00:38:45,000 --> 00:38:47,000
bo jeśli nie definiuje tę metodę i naciśnij Gotowe,

724
00:38:47,000 --> 00:38:49,000
wtedy będzie to mylące.

725
00:38:49,000 --> 00:38:55,000
>> Rzućmy okiem na przykład.

726
00:38:55,000 --> 00:38:58,000
Tu po prostu jednego pola tekstowego,

727
00:38:58,000 --> 00:39:04,000
i jedną z właściwości tego pola tekstowego, tu na tej prawej stronie jest delegatem.

728
00:39:04,000 --> 00:39:06,000
To właściwości klasy.

729
00:39:06,000 --> 00:39:09,000
Co ja o to kontrolować kliknięciu i przeciągnąłem z tego miejsca tutaj

730
00:39:09,000 --> 00:39:13,000
do kontrolera widok, i mówi, że teraz delegata tym polu tekstowym

731
00:39:13,000 --> 00:39:18,000
będzie kontroler widoku.

732
00:39:18,000 --> 00:39:20,000
Oznacza to, że gdy niektóre działania się zamiast rejestracji

733
00:39:20,000 --> 00:39:25,000
oddzielne obsługi zdarzeń chcę Ci wysłać je do delegata.

734
00:39:25,000 --> 00:39:28,000
Teraz rzućmy okiem na moje kontrolera widoku.

735
00:39:28,000 --> 00:39:32,000
Wewnątrz pliku. H. Zrobiłem obietnicy.

736
00:39:32,000 --> 00:39:36,000
Obiecałem wdrożyć niektóre metody wewnątrz tego protokołu

737
00:39:36,000 --> 00:39:38,000
nazywa UITextFieldDelegate, i znowu,

738
00:39:38,000 --> 00:39:42,000
to tylko niektóre lista niektórych rzeczy, które mogę wybrać do wdrożenia.

739
00:39:42,000 --> 00:39:46,000
>> Gdybym tu w moim. M pliku, I wprowadziły jedną taką metodę.

740
00:39:46,000 --> 00:39:49,000
Zadzwoniłam to textFieldShouldReturn

741
00:39:49,000 --> 00:39:52,000
bo to jest to, co nazwano wewnątrz protokołu.

742
00:39:52,000 --> 00:39:57,000
A teraz, gdy naciskam przycisk wykonane wewnątrz tego pola tekstowego

743
00:39:57,000 --> 00:40:00,000
jest to, co się się nazywa, więc nie zarejestrować obsługi zdarzeń.

744
00:40:00,000 --> 00:40:03,000
I podłączony delegata, a gdy to zdarzenie jest opalane

745
00:40:03,000 --> 00:40:08,000
jest to metoda, która zostanie wywołana, więc jeśli tu przyjść do mojego ujęć i uruchomić go-

746
00:40:08,000 --> 00:40:11,000
podczas gdy jest ładowanie możemy zobaczyć co to robi.

747
00:40:11,000 --> 00:40:13,000
Na moim ekranie mam 2 rzeczy.

748
00:40:13,000 --> 00:40:16,000
Mam to pole tekstowe, i mam tę etykietę.

749
00:40:16,000 --> 00:40:19,000
Mówię po prostu, chcę tekst tej etykiety

750
00:40:19,000 --> 00:40:23,000
równa co użytkownik wpisze w wewnątrz pola tekstowego.

751
00:40:23,000 --> 00:40:26,000
To następna linia to po prostu metoda Dzwonię

752
00:40:26,000 --> 00:40:29,000
w polu tekstowym, które mówi, że chce, aby ukryć klawiaturę.

753
00:40:29,000 --> 00:40:33,000
To jest po prostu arbitralne metody, które Apple wybrał.

754
00:40:33,000 --> 00:40:38,000
>> Ponownie, zanim zrobiłem coś musiałem podłączyć wszystko, tak więc po raz pierwszy przyjechałem tutaj.

755
00:40:38,000 --> 00:40:42,000
Od kontrolera widoku I przeciągnij do pola tekstowego.

756
00:40:42,000 --> 00:40:46,000
Odpuścić, i widzę tutaj, że mogę zrobić to właściwość pola tekstowego

757
00:40:46,000 --> 00:40:49,000
ponieważ tutaj w kontrolerze widoku I zostały zdefiniowane właściwości

758
00:40:49,000 --> 00:40:52,000
to IBOutlet pola tekstowego.

759
00:40:52,000 --> 00:40:55,000
To mówi, że można podłączyć ten obiekt się

760
00:40:55,000 --> 00:40:59,000
do pola tekstowego w moim UI.

761
00:40:59,000 --> 00:41:03,000
Teraz gdy klikam to mogę zacząć pisać.

762
00:41:03,000 --> 00:41:06,000
Teraz, gdy klikam przycisk done to będzie ogień

763
00:41:06,000 --> 00:41:08,000
wydarzenie, które teraz mogę odpowiedzieć.

764
00:41:08,000 --> 00:41:10,000
Brak obsługi zdarzeń.

765
00:41:10,000 --> 00:41:13,000
Tak się po prostu odpowiedziała na ten przycisk Gotowe.

766
00:41:13,000 --> 00:41:15,000
Ma sens?

767
00:41:15,000 --> 00:41:20,000
>> To nie jest to, że wzorzec projektowy-nie może kiedykolwiek znaleźć się

768
00:41:20,000 --> 00:41:23,000
tworząc swój własny protokół, ale po prostu wiem, że niektóre

769
00:41:23,000 --> 00:41:27,000
różne składniki iOS zarejestrować wydarzenia na różne sposoby.

770
00:41:27,000 --> 00:41:29,000
Przyciski, na przykład, wykorzystać te IBActions.

771
00:41:29,000 --> 00:41:32,000
Pola tekstowe, z drugiej strony, będzie używany delegatów.

772
00:41:32,000 --> 00:41:36,000
Widzimy i można sprawdzić wszystkie tego wewnątrz dokumentacji.

773
00:41:36,000 --> 00:41:41,000
Nawiasem mówiąc, jest rzeczywiście mnóstwo rzeczy UI wbudowany iOS dla Ciebie,

774
00:41:41,000 --> 00:41:46,000
tak na przykład sposób, w jaki odbywa się to mówi w prawym dolnym

775
00:41:46,000 --> 00:41:48,000
Wybrałem się pole tekstowe.

776
00:41:48,000 --> 00:41:50,000
Przyjechałem tutaj.

777
00:41:50,000 --> 00:41:53,000
I przewijane w dół trochę wrócić klucz

778
00:41:53,000 --> 00:41:56,000
i mogę rzeczywiście zrobić to cała masa rzeczy, jak, jeśli chcę powiedzieć, że

779
00:41:56,000 --> 00:42:00,000
awaryjne zadzwonić zamiast mogę to zrobić, co jest całkowicie losowy,

780
00:42:00,000 --> 00:42:02,000
i nie wiem, dlaczego jest wbudowany przycisk alarmowy,

781
00:42:02,000 --> 00:42:06,000
ale nie, to mówi alarmowy literami naprawdę małe.

782
00:42:06,000 --> 00:42:08,000
Proszę bardzo.

783
00:42:08,000 --> 00:42:12,000
>> Zdecydowanie zbadania wszystkich tych różnych opcji w iOS.

784
00:42:12,000 --> 00:42:14,000
Wszelkie pytania dotyczące delegatów?

785
00:42:14,000 --> 00:42:18,000
Ponownie, po prostu ciekawy wzorzec projektowy, który powinien być świadomy.

786
00:42:18,000 --> 00:42:22,000
Dobra, następny spojrzeć na widoki tabeli.

787
00:42:22,000 --> 00:42:26,000
Widok tabeli jest w zasadzie, że lista elementów, które jest w każdym miejscu, w iOS.

788
00:42:26,000 --> 00:42:29,000
Kiedy przeglądasz wszystkie kontakty, szukasz na

789
00:42:29,000 --> 00:42:34,000
ustawienie strony, i tego rodzaju listy rzeczy nazywany jest widok tabeli.

790
00:42:34,000 --> 00:42:37,000
Implementacja widoku tabeli w iOS jest dość prosta.

791
00:42:37,000 --> 00:42:41,000
Zamiast klasy, która zstępuje z tego UIViewController

792
00:42:41,000 --> 00:42:44,000
jak zrobiliśmy wcześniej po prostu trzeba powiedzieć, a nie

793
00:42:44,000 --> 00:42:46,000
wszystko UIViewController nie chcę zrobić,

794
00:42:46,000 --> 00:42:50,000
I powiedzieć wszystko UITableViewController nie chcę zrobić,

795
00:42:50,000 --> 00:42:54,000
tak, że po prostu dodaje kilka dodatkowych rzeczy, które są całkowicie dla nas uczynił.

796
00:42:54,000 --> 00:42:58,000
Musimy zrobić bardzo niewiele, aby właściwie wypełnić puste wewnątrz tabeli.

797
00:42:58,000 --> 00:43:02,000
>> Aby wyświetlić tabelę muszę odpowiedzieć na kilka pytań.

798
00:43:02,000 --> 00:43:06,000
Pierwsze pytanie trzeba odpowiedzieć, to ile sekcje są w tabeli?

799
00:43:06,000 --> 00:43:08,000
Kiedy przeglądasz Twojej aplikacji Kontakty można zauważyć, że jest to swego rodzaju

800
00:43:08,000 --> 00:43:12,000
zorganizowane przez As, następnie masz BS, a masz ten mały sub nagłówek.

801
00:43:12,000 --> 00:43:14,000
Każda z tych części jest nazywane.

802
00:43:14,000 --> 00:43:16,000
Państwo może, ale nie trzeba tych.

803
00:43:16,000 --> 00:43:19,000
Pierwszą rzeczą, którą musisz zrobić, to wdrożyć metodę

804
00:43:19,000 --> 00:43:22,000
nazywa tableView: numberOfSectionsInTableView.

805
00:43:22,000 --> 00:43:25,000
Że po prostu zwraca ile sekcje masz,

806
00:43:25,000 --> 00:43:29,000
tak więc można powiedzieć, zwrócić jeden, jeśli masz jeden wielki widok tabeli.

807
00:43:29,000 --> 00:43:33,000
Kolejne pytanie, które iOS musi wiedzieć, ile wierszy masz?

808
00:43:33,000 --> 00:43:36,000
Na przykład, jesteś przeglądając widoku tabeli.

809
00:43:36,000 --> 00:43:39,000
Masz stałą liczbę utworów ty patrzysz na lub stałą liczbę kontaktów.

810
00:43:39,000 --> 00:43:41,000
Jeśli ja, oczywiście, nie, że wielu,

811
00:43:41,000 --> 00:43:44,000
i tak to jest, jak iOS wie, ile komórek do wyświetlenia.

812
00:43:44,000 --> 00:43:46,000
>> Ponownie, to może powiedzieć coś w stylu powrotu 3.

813
00:43:46,000 --> 00:43:49,000
Mój pogląd tabela zawiera 3 wiersze.

814
00:43:49,000 --> 00:43:52,000
Wreszcie, iOS musi wiedzieć, co każda komórka wygląda,

815
00:43:52,000 --> 00:43:54,000
więc co to faktycznie zrobić to wywołanie tej metody, tu,

816
00:43:54,000 --> 00:43:57,000
ta tableView: cellForRowAtIndexPath.

817
00:43:57,000 --> 00:44:01,000
To będzie wywołać tę metodę na każdej pojedynczej komórki wewnątrz tabeli.

818
00:44:01,000 --> 00:44:03,000
Jak to jest wiedzieć, ile razy to nazwać?

819
00:44:03,000 --> 00:44:06,000
Cóż, powiedział to w środku liczby wierszy w sekcji.

820
00:44:06,000 --> 00:44:08,000
Będziemy nazywają to na każdej z naszych komórek,

821
00:44:08,000 --> 00:44:11,000
i wewnątrz jest to, gdzie rzeczywiście można robić takie rzeczy jak

822
00:44:11,000 --> 00:44:16,000
ustaw tekst lub powiedzieć, co ten mały niebieski przycisk z prawej strony robi.

823
00:44:16,000 --> 00:44:19,000
Wzór do uzyskania tych komórek, będziemy korzystać z tej metody

824
00:44:19,000 --> 00:44:22,000
nazywa dequeueReusableCellWithIdentifier.

825
00:44:22,000 --> 00:44:29,000
>> Objective-C jest rzeczywiście bardzo dobrze znana na śmiesznej długości ich nazw metod,

826
00:44:29,000 --> 00:44:32,000
i to jest naprawdę miłe miejsce w przykładzie pkt.

827
00:44:32,000 --> 00:44:37,000
Co ta metoda nie jest to po prostu mówi: Chcę, żebyś mi komórkę.

828
00:44:37,000 --> 00:44:39,000
Podobnie rzecz iOS.

829
00:44:39,000 --> 00:44:41,000
Jeśli masz coś 100.000 piosenek na iPodzie

830
00:44:41,000 --> 00:44:45,000
co iOS nie chce zrobić, to przeznaczyć 100.000 komórek,

831
00:44:45,000 --> 00:44:48,000
bo jeśli jesteś na górze listy, czy naprawdę trzeba przydzielić pamięci

832
00:44:48,000 --> 00:44:51,000
do komórki, która znajduje się 99.000 wierszy w dół?

833
00:44:51,000 --> 00:44:55,000
Nie, bo jak jesteś przewijania można rodzaj przeznaczenia, jak iść.

834
00:44:55,000 --> 00:44:57,000
Odbywa się to za Ciebie.

835
00:44:57,000 --> 00:44:59,000
Nie musisz martwić się o tym wszystkim głupim wydajności.

836
00:44:59,000 --> 00:45:02,000
Wszystko co mówisz jest nazywać to dequeueReusableCellWithIdentifier metody,

837
00:45:02,000 --> 00:45:06,000
i to mówi, dobrze, jeśli trzeba Zamierzam utworzyć nową komórkę dla Ciebie.

838
00:45:06,000 --> 00:45:09,000
>> Ale jeśli jesteś na dole tabeli, a już przydzielone niektóre komórki

839
00:45:09,000 --> 00:45:12,000
w górnej części tabeli, która naprawdę nie będzie potrzebował w najbliższym czasie

840
00:45:12,000 --> 00:45:15,000
Mam zamiar dać ci jeden z nich z powrotem zamiast przydzielania nowego,

841
00:45:15,000 --> 00:45:17,000
i tak jest to miły dotyczą wydajności.

842
00:45:17,000 --> 00:45:21,000
Nie musisz przeznaczyć Komórki siebie.

843
00:45:21,000 --> 00:45:23,000
Że zamierza oddać komórkę.

844
00:45:23,000 --> 00:45:25,000
To będzie powrót do ciebie obiekt komórek.

845
00:45:25,000 --> 00:45:28,000
Kiedy już masz obiekt komórek można zrobić rzeczy do niego.

846
00:45:28,000 --> 00:45:32,000
Można ustawić tekst komórki z tego obiektu o nazwie label text.

847
00:45:32,000 --> 00:45:36,000
Można dodać, że strzałka na prawej lub innej rzeczy przypadkowej

848
00:45:36,000 --> 00:45:41,000
z tym inne własności zwanej accessoryType i tak dalej, i tak dalej.

849
00:45:41,000 --> 00:45:46,000
>> Rzućmy okiem na faktycznie wdraża widok tabeli teraz.

850
00:45:46,000 --> 00:45:49,000
Po utworzeniu tego projektu

851
00:45:49,000 --> 00:45:53,000
zamiast mówić jeden wniosek widok I rzeczywiście przyszedł tutaj

852
00:45:53,000 --> 00:45:57,000
do master-detail aplikacji, a więc w zasadzie odpowiada to aplikacji poczty

853
00:45:57,000 --> 00:46:01,000
na iPad z widoku tabeli po lewej stronie, a następnie zawartość po prawej stronie.

854
00:46:01,000 --> 00:46:07,000
Na iPod lub iPhone to będzie odpowiadać jednej widoku tabeli.

855
00:46:07,000 --> 00:46:10,000
To miejsce, gdzie dostałem kodu startowego.

856
00:46:10,000 --> 00:46:13,000
>> Niech najpierw przyjrzeć się serii ujęć.

857
00:46:13,000 --> 00:46:15,000
Wszystko to było dla mnie zrobił, zasadniczo tworzony.

858
00:46:15,000 --> 00:46:18,000
Ten pasek nawigacji pokazał mi, co komórka przykład mógłby wyglądać,

859
00:46:18,000 --> 00:46:22,000
i mogę kliknąć dwukrotnie, zmień tytuł.

860
00:46:22,000 --> 00:46:25,000
Wszelkie inne kwestie UI Poradzę tam.

861
00:46:25,000 --> 00:46:27,000
Plik nagłówkowy wygląda naprawdę proste.

862
00:46:27,000 --> 00:46:30,000
Zamiast mówić to UIViewController jesteśmy teraz mówiąc jest to

863
00:46:30,000 --> 00:46:35,000
TableViewController, więc wiemy, że chcemy, aby wywołać wszystkie te metody w tabeli.

864
00:46:35,000 --> 00:46:38,000
Dalej chcę utworzyć właściwość, która się dzieje do reprezentowania

865
00:46:38,000 --> 00:46:40,000
rzeczy wewnątrz moim stole.

866
00:46:40,000 --> 00:46:43,000
Ta tabela będzie arbitralnie wyświetlić

867
00:46:43,000 --> 00:46:46,000
Lista owoców, a więc trzeba stworzyć jakiś tablicę

868
00:46:46,000 --> 00:46:49,000
w którym można wstawić owoce.

869
00:46:49,000 --> 00:46:52,000
Wewnątrz mojego pliku wdrażania pierwszą rzeczą chcę zrobić

870
00:46:52,000 --> 00:46:55,000
to chcę się upewnić, zainicjować tę tablicę.

871
00:46:55,000 --> 00:46:58,000
>> Powiedziałem alloc init, stworzyłem tablicę owoców,

872
00:46:58,000 --> 00:47:03,000
i dodaję 4 rzeczy do niego, z których jeden jest o wiele bardziej kontrowersyjne niż w innych 3.

873
00:47:03,000 --> 00:47:06,000
I teraz mam tablicę o rozmiarze 4.

874
00:47:06,000 --> 00:47:08,000
Jesteśmy kręcąc go w CS50.

875
00:47:08,000 --> 00:47:11,000
Mam teraz tablicę wielkości 4.

876
00:47:11,000 --> 00:47:13,000
Teraz mam zamiar zacząć odpowiedzi na te pytania, a właściwie,

877
00:47:13,000 --> 00:47:16,000
kiedy stworzył tę aplikację to wszystko było już dla mnie zrobił.

878
00:47:16,000 --> 00:47:19,000
Nie trzeba wpisywać się liczbę sekcji w widoku tabeli.

879
00:47:19,000 --> 00:47:22,000
To było już tam, a ja wypełniając formularz.

880
00:47:22,000 --> 00:47:24,000
Ile sekcji mam?

881
00:47:24,000 --> 00:47:26,000
One. Wszystko zrobione.

882
00:47:26,000 --> 00:47:28,000
Ile wierszy mam?

883
00:47:28,000 --> 00:47:31,000
Cóż, mam jeden wiersz dla każdego owocu, więc ta liczba

884
00:47:31,000 --> 00:47:34,000
jest własnością wszystkich tablic, które mówi, jak duże to jest?

885
00:47:34,000 --> 00:47:36,000
To, ile wierszy mam.

886
00:47:36,000 --> 00:47:42,000
Wreszcie, muszę powiedzieć, co ma każda komórka wygląda?

887
00:47:42,000 --> 00:47:46,000
Zamierzam powiedzieć dequeueReusableCellWithIdentifier.

888
00:47:46,000 --> 00:47:48,000
>> Ponownie, to już było napisane dla mnie.

889
00:47:48,000 --> 00:47:51,000
Nie musisz tego robić sam, i chcę wrócić

890
00:47:51,000 --> 00:47:54,000
komórka w tym miejscu.

891
00:47:54,000 --> 00:47:57,000
Pamiętaj, że mamy wywołanie tej samej metody na każdej komórki,

892
00:47:57,000 --> 00:48:01,000
i ten argument tutaj, ten argument indexPath,

893
00:48:01,000 --> 00:48:03,000
mówi to, co rząd jestem w.

894
00:48:03,000 --> 00:48:05,000
Jeśli powiem indexPath.row tu

895
00:48:05,000 --> 00:48:09,000
to jest 0, to jest 1, to będzie 2, i jest to tak, znam

896
00:48:09,000 --> 00:48:11,000
co komórka Jestem aktualnie wyświetlane.

897
00:48:11,000 --> 00:48:15,000
Chcę ustawić tekst w komórce za pomocą tej właściwości TextLabel

898
00:48:15,000 --> 00:48:19,000
, aby przejść w mojej tablicy owoców i uzyskać

899
00:48:19,000 --> 00:48:21,000
object do każdego wiersza.

900
00:48:21,000 --> 00:48:24,000
Jeśli jest to ciąg, jestem teraz ustawienie

901
00:48:24,000 --> 00:48:28,000
Właściwość text na ciąg.

902
00:48:28,000 --> 00:48:30,000
Można zrobić jedną rzecz.

903
00:48:30,000 --> 00:48:32,000
Mogę również zarejestrować obsługi zdarzeń w każdej z komórek,

904
00:48:32,000 --> 00:48:35,000
więc kiedy dotknąć każdego z tych komórek

905
00:48:35,000 --> 00:48:39,000
ta didSelectRowAtIndexPath, to będzie się nazywać dla mnie,

906
00:48:39,000 --> 00:48:42,000
tak po prostu przez określenie to mogę obsłużyć, co się dzieje

907
00:48:42,000 --> 00:48:46,000
po dotknięciu komórkę, i znowu, jesteśmy przechodząc w którym komórka był na podsłuchu

908
00:48:46,000 --> 00:48:50,000
tak, że możemy wykorzystać ten sam obsługi zdarzeń dla wszystkich naszych komórek.

909
00:48:50,000 --> 00:48:53,000
>> Ponownie, jest to coś, iOS robi dla mnie.

910
00:48:53,000 --> 00:48:55,000
Miejmy wyświetlić inny przykry popup

911
00:48:55,000 --> 00:48:59,000
który po prostu mówi, że wziął coś, gdzie, że coś

912
00:48:59,000 --> 00:49:04,000
będzie obiekt wiersz.

913
00:49:04,000 --> 00:49:10,000
Gdy uruchomię to będę mieć ten miły widok tabeli

914
00:49:10,000 --> 00:49:14,000
jednym wierszu dla każdego z tych owoców, a jeśli ja dotknij jednego

915
00:49:14,000 --> 00:49:16,000
mówi mi, co się stało.

916
00:49:16,000 --> 00:49:21,000
Ma sens?

917
00:49:21,000 --> 00:49:24,000
Zbudujmy nieco bardziej skomplikowane z app,

918
00:49:24,000 --> 00:49:28,000
jak kliknięcie wybrałeś pomidora jest.

919
00:49:28,000 --> 00:49:31,000
Miły część o storyboardów

920
00:49:31,000 --> 00:49:35,000
jest to nie tylko pomoże nam ekrany projekt indywidualnie,

921
00:49:35,000 --> 00:49:38,000
to też pomoże nam powiązać całą naszą aplikację,

922
00:49:38,000 --> 00:49:42,000
więc końcowy app będziemy budynek jest ten miły sport czytnik wiadomości,

923
00:49:42,000 --> 00:49:45,000
i tak będzie musiał kilka ekranów, a więc faktycznie mogę reprezentować

924
00:49:45,000 --> 00:49:48,000
każda z tych wielu ekranach w serii ujęć

925
00:49:48,000 --> 00:49:52,000
i mogę pomniejszyć i widzieć moją app z wysokim poziomie.

926
00:49:52,000 --> 00:49:55,000
>> W celu stworzenia nowego wnętrza elementem mojej serii ujęć

927
00:49:55,000 --> 00:49:59,000
to naprawdę proste wewnątrz konstruktorze Interface.

928
00:49:59,000 --> 00:50:01,000
Jeśli chcesz dodać kolejny ekran do tego, na przykład,

929
00:50:01,000 --> 00:50:06,000
Dostanie najpierw pomniejszyć z pinch zoom, że Apple kocha tak bardzo,

930
00:50:06,000 --> 00:50:09,000
a tu przed I szukać przycisku

931
00:50:09,000 --> 00:50:12,000
i przeciągnąć przycisk

932
00:50:12,000 --> 00:50:15,000
jeśli chcę, aby utworzyć nowy ekran faktycznie mogę po prostu przeciągnij i upuść

933
00:50:15,000 --> 00:50:19,000
cały regulator zewnętrzny, więc jeśli mogę odebrać to, wyciągnij go tu,

934
00:50:19,000 --> 00:50:23,000
hej, jest jeszcze jeden ekran, a więc teraz przy użyciu tego samego pliku storyboard

935
00:50:23,000 --> 00:50:26,000
Mogę mieć wszystkich ekranach wewnątrz z mojej aplikacji, i mogę pomniejszyć

936
00:50:26,000 --> 00:50:28,000
i zobaczyć, jak one oddziałują.

937
00:50:28,000 --> 00:50:32,000
To nie będzie oddziaływać jeszcze.

938
00:50:32,000 --> 00:50:36,000
Sposób, w jaki te 2 ekrany interakcji jest zdefiniowanie relacji.

939
00:50:36,000 --> 00:50:39,000
Można w zasadzie powiedzieć, z tego ekranu, po naciśnięciu tego przycisku

940
00:50:39,000 --> 00:50:42,000
Chcę, abyś ślizgać się do tego nowego ekranu.

941
00:50:42,000 --> 00:50:44,000
To oznacza, że ​​jest to rodzaj relacji między

942
00:50:44,000 --> 00:50:46,000
 Pierwszy ekran, a drugi ekran.

943
00:50:46,000 --> 00:50:49,000
Będziesz musiał w zasadzie strzałę z tego przycisku do drugiego ekranu

944
00:50:49,000 --> 00:50:53,000
mówiąc, że po naciśnięciu tego przycisku, który znajduje się tam, gdzie chcę iść.

945
00:50:53,000 --> 00:50:57,000
Tak jak możemy kontrolować kliknął i zaciągnął do określenia tych punktów

946
00:50:57,000 --> 00:51:01,000
mamy zamiar zrobić to samo określenie tych segues.

947
00:51:01,000 --> 00:51:05,000
>> Zobaczymy na przykład, że i zanim faktycznie przejście

948
00:51:05,000 --> 00:51:08,000
z jednego ekranu na drugi iOS jest na tyle miły, aby wywołać tę metodę

949
00:51:08,000 --> 00:51:11,000
nazywa prepareForSegue, i to, gdzie możemy zacząć

950
00:51:11,000 --> 00:51:14,000
wysyłanie danych z jednej aplikacji do drugiej.

951
00:51:14,000 --> 00:51:17,000
W przykładzie mamy zamiar spojrzeć na to będzie w zasadzie pozwala nam

952
00:51:17,000 --> 00:51:20,000
filtrować drużyn baseballowych przez ligi i podziałów.

953
00:51:20,000 --> 00:51:23,000
Kiedy wybieram ligę, na przykład, chcę przejście

954
00:51:23,000 --> 00:51:25,000
do mojego kolejnego ekranu, na którym można wyświetlić wszystkich działów

955
00:51:25,000 --> 00:51:27,000
w tej lidze, czy wszystkie zespoły różnych.

956
00:51:27,000 --> 00:51:31,000
Muszę wysłać do tego ekranu, co zespoły należy wyświetlić.

957
00:51:31,000 --> 00:51:35,000
Aby to zrobić, że mam zamiar skorzystać z tej metody tutaj.

958
00:51:35,000 --> 00:51:39,000
>> Wreszcie, po prostu przypadkowy punkt na iOS.

959
00:51:39,000 --> 00:51:41,000
Jeśli chcesz przechowywać dane jest jeszcze to, co nazywa się podstawowe dane,

960
00:51:41,000 --> 00:51:44,000
która jest faktycznie trochę skomplikowane w użyciu.

961
00:51:44,000 --> 00:51:47,000
Można również użyć SQL do przechowywania danych,

962
00:51:47,000 --> 00:51:51,000
które ponownie, jest ładny, ale trochę z boku bardziej skomplikowane do pracy,

963
00:51:51,000 --> 00:51:55,000
ale iOS również wspiera te naprawdę fajne rzeczy nazywane wykazy nieruchomości,

964
00:51:55,000 --> 00:52:00,000
oraz wykaz nieruchomości jest tylko plik, który reprezentuje najważniejsze par wartości.

965
00:52:00,000 --> 00:52:03,000
Zdefiniować listę kluczy, i powiedzieć, że to klucz będzie tablica.

966
00:52:03,000 --> 00:52:06,000
Klucz ten będzie łańcuch, iw zasadzie wszystko, co można zrobić

967
00:52:06,000 --> 00:52:10,000
w JSON można zrobić wewnątrz wykazu nieruchomości,

968
00:52:10,000 --> 00:52:14,000
i tak to bardzo ładnie pozwala nam pracować z niektórych danych.

969
00:52:14,000 --> 00:52:18,000
Na przykład, mam ten Teams.plist że utworzony.

970
00:52:18,000 --> 00:52:22,000
I stworzył nowy plik plist i mogę drążyć.

971
00:52:22,000 --> 00:52:26,000
To jest słownik, to słownik, są smyczki,

972
00:52:26,000 --> 00:52:30,000
i tak jest to miły graficzne przedstawienie dokumentu JSON

973
00:52:30,000 --> 00:52:33,000
lub po prostu zbiór podstawowych par wartości,

974
00:52:33,000 --> 00:52:37,000
a więc jest to dane, że będę pracować z wnętrza mojej aplikacji.

975
00:52:37,000 --> 00:52:40,000
>> Niech najpierw przyjść tutaj. Mamy o wiele więcej teraz pliki.

976
00:52:40,000 --> 00:52:44,000
Ale niech najpierw dojść tu do serii ujęć.

977
00:52:44,000 --> 00:52:48,000
Storyboard tu czy mogę pomniejszyć-

978
00:52:48,000 --> 00:52:51,000
teraz możemy zobaczyć, że to jest przepływ mojej aplikacji.

979
00:52:51,000 --> 00:52:53,000
Jestem 1-ty ruszy na tym ekranie.

980
00:52:53,000 --> 00:52:55,000
Będę drążyć do tego ekranu,

981
00:52:55,000 --> 00:52:58,000
i będę drążyć do tego ekranu, i widzimy tutaj, że jeśli rodzaj

982
00:52:58,000 --> 00:53:04,000
przenieść jeden z nich wokół nas te strzałki dzieje stąd dotąd,

983
00:53:04,000 --> 00:53:08,000
i sposób, w jaki definiuje tego strzałkę było gdybym powiększyć trochę,

984
00:53:08,000 --> 00:53:12,000
i gdybym przyszedł do tego kontrolera widoku

985
00:53:12,000 --> 00:53:16,000
i tu jest komórka, i chcę powiedzieć, że po dotknięciu komórkę

986
00:53:16,000 --> 00:53:18,000
Chcę byś przesunąć do innego ekranu.

987
00:53:18,000 --> 00:53:21,000
Mogę po prostu przytrzymaj kontrolę,

988
00:53:21,000 --> 00:53:26,000
przejdź na trochę, przytrzymaj kontrolę, przeciągnij komórkę nad i puścić.

989
00:53:26,000 --> 00:53:30,000
>> A tutaj mówimy, co jest przejście, które chcesz użyć?

990
00:53:30,000 --> 00:53:32,000
Czy chcesz korzystać z tej rzeczy slajdów, który jest zwany Push?

991
00:53:32,000 --> 00:53:34,000
Chcesz przesunąć od dołu?

992
00:53:34,000 --> 00:53:36,000
To się nazywa modalne.

993
00:53:36,000 --> 00:53:40,000
I raz kliknąć jeden z nich, to będzie narysować tę strzałkę, dla mnie,

994
00:53:40,000 --> 00:53:44,000
a to oznacza, że ​​mam faktycznie obchodzić, co się dzieje po naciśnięciu tego przycisku, w formie graficznej.

995
00:53:44,000 --> 00:53:48,000
Nie napisałem żadnego kodu faktycznie slajdów z jednego ekranu do następnego.

996
00:53:48,000 --> 00:53:51,000
I określono to wizualnie wnętrze konstruktorze Interface.

997
00:53:51,000 --> 00:53:55,000
Jeśli kliknij na strzałkę, możemy zobaczyć, że dałem to coś nazwę.

998
00:53:55,000 --> 00:53:59,000
Nazwałem to showDivisions, i to jest tak, że mogę wiedzieć

999
00:53:59,000 --> 00:54:03,000
co przejście ma się pojawić, a my zobaczymy, dlaczego w ciągu zaledwie sekundy.

1000
00:54:03,000 --> 00:54:06,000
To jak mam podłączane różne ekrany w mojej aplikacji.

1001
00:54:06,000 --> 00:54:09,000
Gdyby tak było, gwarantujące przykład zamiast widoku tabeli

1002
00:54:09,000 --> 00:54:11,000
Mogłem kontrolować kliknij na przycisk, przeciągnij do następnego ekranu,

1003
00:54:11,000 --> 00:54:16,000
i to jak można zrobić w ten sposób nawigacji.

1004
00:54:16,000 --> 00:54:19,000
>> Bardzo szybko, jeśli dojdziemy do MasterViewController,

1005
00:54:19,000 --> 00:54:22,000
ponownie, jesteśmy po prostu będzie zdefiniować listę rzeczy

1006
00:54:22,000 --> 00:54:26,000
, które będą wyświetlane w widoku tabeli.

1007
00:54:26,000 --> 00:54:29,000
Tutaj mówię chcę żebyś to plist,

1008
00:54:29,000 --> 00:54:32,000
i chcę, załadowanie go do słownika,

1009
00:54:32,000 --> 00:54:35,000
i raz masz ten słownik, mam zamiar odpowiedzieć na te same pytania ponownie.

1010
00:54:35,000 --> 00:54:37,000
Tutaj jest liczba sekcji.

1011
00:54:37,000 --> 00:54:41,000
One, jest jeden wiersz dla każdej ligi, a tekst z każdej komórki

1012
00:54:41,000 --> 00:54:46,000
powinna być pierwsza, Lig, League drugi, i tak dalej.

1013
00:54:46,000 --> 00:54:51,000
Wreszcie, mam zamiar skorzystać z tej metody, że właśnie widział nazwie prepareForSegue,

1014
00:54:51,000 --> 00:54:54,000
i jest to metoda, która zamierza zostać zwolniony po kliknięciu

1015
00:54:54,000 --> 00:54:57,000
w jednym z tych rzędów, a w związku z tym, że przejście aktywacji

1016
00:54:57,000 --> 00:54:59,000
że mogę ustawić za pomocą strzałek.

1017
00:54:59,000 --> 00:55:02,000
To mówi, że można mieć wiele

1018
00:55:02,000 --> 00:55:05,000
relacje z jednego ekranu do drugiego.

1019
00:55:05,000 --> 00:55:08,000
Jeśli mam 2 przyciski, a każdy przycisk przeniesie Cię do innego ekranu

1020
00:55:08,000 --> 00:55:10,000
Mam zamiar mieć 2 segues, 1 dla każdego przycisku.

1021
00:55:10,000 --> 00:55:14,000
Jednak jest to prepareForSegue znowu będzie ponownie

1022
00:55:14,000 --> 00:55:17,000
dla każdego z różnych związków, więc oznacza to, że potrzebny jest sposób i

1023
00:55:17,000 --> 00:55:21,000
identyfikacji, jeśli pierwszy przycisk lub naciśnij drugi przycisk.

1024
00:55:21,000 --> 00:55:25,000
>> Pamiętaj, że kiedy dałem Segue nazwę, to showDivisions,

1025
00:55:25,000 --> 00:55:29,000
to jak teraz wiem, że to jest Segue że zostało aktywowane.

1026
00:55:29,000 --> 00:55:32,000
Wszystko co chcę zrobić, to chcę powiedzieć,

1027
00:55:32,000 --> 00:55:35,000
Chcę dowiedzieć się, co po prostu hit,

1028
00:55:35,000 --> 00:55:38,000
i tak się to dostać, mogę powiedzieć, chcę indexPath dla wybranego wiersza,

1029
00:55:38,000 --> 00:55:42,000
Pamiętam indexPath tylko mówi, gdzie po prostu kliknąć,

1030
00:55:42,000 --> 00:55:47,000
i chcę powiedzieć, chcę dowiedzieć się, gdzie idę.

1031
00:55:47,000 --> 00:55:50,000
Ten destinationViewController, to własność Segue.

1032
00:55:50,000 --> 00:55:53,000
To ekran będę,

1033
00:55:53,000 --> 00:55:56,000
tak wiem, że ekran będę nazywa DivisionsViewController

1034
00:55:56,000 --> 00:55:59,000
bo stworzył tę klasę,

1035
00:55:59,000 --> 00:56:02,000
więc teraz, jeśli powiem d.divisions

1036
00:56:02,000 --> 00:56:06,000
Jestem teraz ustawienie właściwości kontrolera widoku mam zamiar przejść.

1037
00:56:06,000 --> 00:56:10,000
To jak mam wysyłać dane z jednego ekranu do innego ekranu.

1038
00:56:10,000 --> 00:56:13,000
>> Po prostu patrząc na to DivisionsViewController

1039
00:56:13,000 --> 00:56:16,000
widać tutaj, że w pliku. h

1040
00:56:16,000 --> 00:56:20,000
istnieją podziały nieruchomości, a to, co mam w zasadzie wypełniania,

1041
00:56:20,000 --> 00:56:25,000
tak to wiem, że jestem wyświetlania podziałów odpowiadających

1042
00:56:25,000 --> 00:56:28,000
liga, że ​​kliknąłem, i znowu,

1043
00:56:28,000 --> 00:56:31,000
rzeczywisty widok tabeli wygląda niemal tak samo, po prostu odpowiadając na te

1044
00:56:31,000 --> 00:56:34,000
3 proste pytania, jak również identyfikujące

1045
00:56:34,000 --> 00:56:37,000
co się dzieje, kiedy przejść do następnego ekranu.

1046
00:56:37,000 --> 00:56:40,000
Wystarczy kilka innych rzeczy.

1047
00:56:40,000 --> 00:56:43,000
Można zauważyć na górze tutaj zamiast mówić # include

1048
00:56:43,000 --> 00:56:45,000
Jestem teraz mówią # import.

1049
00:56:45,000 --> 00:56:47,000
To jest po prostu rzeczą Objective-C.

1050
00:56:47,000 --> 00:56:52,000
Import jest w zasadzie ładniejsza wersja obejmują,

1051
00:56:52,000 --> 00:56:57,000
i na przykład, musimy wiedzieć, co to jest klasa,

1052
00:56:57,000 --> 00:57:00,000
, więc nie można po prostu powiedzieć DivisionsViewController.

1053
00:57:00,000 --> 00:57:05,000
Gdybyśmy nie hashtag standardio.c wnętrze naszego pliku. C

1054
00:57:05,000 --> 00:57:07,000
kompilator nie miał pojęcia, co printf był.

1055
00:57:07,000 --> 00:57:12,000
Podobnie, jeśli nie importować DivisionsViewController

1056
00:57:12,000 --> 00:57:16,000
kompilator naprawdę nie ma pojęcia co DivisionsViewController jest.

1057
00:57:16,000 --> 00:57:19,000
Wystarczy upewnić się, że w środku swoich różnych. Pliki m upewnić zaimportować

1058
00:57:19,000 --> 00:57:25,000
odpowiednie pliki. h tak, że kompilator nie wie, co się dzieje.

1059
00:57:25,000 --> 00:57:31,000
>> Wreszcie, co Apple ostatecznie zgadza się wyświetlać niektórych danych przy użyciu widoku sieciowego,

1060
00:57:31,000 --> 00:57:35,000
i tak widok internetowych jest obiekt, w którym można osadzić

1061
00:57:35,000 --> 00:57:37,000
mała przeglądarka wewnątrz Twojej aplikacji.

1062
00:57:37,000 --> 00:57:40,000
Wszystko, co musisz zrobić, to dostarczyć adres URL do przeglądarki internetowej,

1063
00:57:40,000 --> 00:57:43,000
więc chcę iść do mlb.mlb.com,

1064
00:57:43,000 --> 00:57:46,000
i jest to w jaki sposób można uzyskać dostęp do strony startowej dla każdego zespołu,

1065
00:57:46,000 --> 00:57:49,000
i tak przez przekazanie tego adresu URL

1066
00:57:49,000 --> 00:57:52,000
zobacz internetowa może wyświetlać to dla mnie, a ja mogę zajrzeć,

1067
00:57:52,000 --> 00:58:01,000
i symulator jest używany przez tego.

1068
00:58:01,000 --> 00:58:03,000
Teraz przyszedł z mojego plist.

1069
00:58:03,000 --> 00:58:07,000
Jeśli I kliknij ten to również pochodzi z mojego plist, i to było obsługiwane przesuwne

1070
00:58:07,000 --> 00:58:09,000
definiując te segues.

1071
00:58:09,000 --> 00:58:12,000
Klikam to i jeszcze jeden,

1072
00:58:12,000 --> 00:58:15,000
i teraz tu jest mój UIWebView, więc tak po prostu

1073
00:58:15,000 --> 00:58:19,000
tutaj jest strona internetowa o adresie URL, które po prostu osadzony,

1074
00:58:19,000 --> 00:58:21,000
i nie ma potrzeby obsługi nic szalonego.

1075
00:58:21,000 --> 00:58:24,000
To jest, jak wyświetlić stronę internetową.

1076
00:58:24,000 --> 00:58:27,000
Rzeczy takie jak tego przycisku Wstecz tutaj są podane także do mnie

1077
00:58:27,000 --> 00:58:33,000
całkowicie za darmo, bo już zdefiniowane te relacje za pomocą segues.

1078
00:58:33,000 --> 00:58:37,000
>> Masz pytanie? Tak.

1079
00:58:37,000 --> 00:58:40,000
[Student] Więc po użyciu alloc, nie musisz do swobodnego cokolwiek?

1080
00:58:40,000 --> 00:58:43,000
Dokładnie, kiedy zadzwonić alloc i init nie masz, aby uwolnić ją.

1081
00:58:43,000 --> 00:58:46,000
IOS będzie obsługiwać to wszystko dla Ciebie.

1082
00:58:46,000 --> 00:58:51,000
To wspaniałe, i nie łamiesz żadnych zasad. Tak.

1083
00:58:51,000 --> 00:58:54,000
[Student] Jeśli było to więcej zespołów, które zmieści się na ekranie,

1084
00:58:54,000 --> 00:58:58,000
to automatycznie posiada opcję przewijania, czy jest to coś trzeba dodawać?

1085
00:58:58,000 --> 00:59:01,000
Dokładnie, gdybym miał więcej drużyn, na przykład, to automatycznie obsłużyć

1086
00:59:01,000 --> 00:59:04,000
przewijanie do mnie, a wszystkie obawy wydajność

1087
00:59:04,000 --> 00:59:08,000
z ogromnym stole są również obsługiwane całkowicie dla mnie.

1088
00:59:08,000 --> 00:59:11,000
>> Inne pytania?

1089
00:59:11,000 --> 00:59:13,000
Cały ten kod ma być wysłana.

1090
00:59:13,000 --> 00:59:16,000
Mamy rodzaju tabu trochę szczegółów więcej drobnych,

1091
00:59:16,000 --> 00:59:19,000
ale takie rzeczy jak ustawienie niektóre właściwości do widoku internetowej

1092
00:59:19,000 --> 00:59:22,000
są po prostu rzeczy, które można uzyskać, przeglądając dokumentację Apple,

1093
00:59:22,000 --> 00:59:24,000
który jest naprawdę ładnie rozplanowany.

1094
00:59:24,000 --> 00:59:27,000
Mają wiele przykładowych aplikacji i przykład zwyczajów

1095
00:59:27,000 --> 00:59:34,000
różnych API, więc na pewno czytać tych, jeśli możesz.

1096
00:59:34,000 --> 00:59:36,000
Tylko niektóre pomocne linki warto przyjrzeć.

1097
00:59:36,000 --> 00:59:38,000
Oto kilka przydatnych przewodników dokumentacji.

1098
00:59:38,000 --> 00:59:41,000
Adresy URL są ogromne, więc są one skrócone.

1099
00:59:41,000 --> 00:59:44,000
Ten pierwszy jest cała biblioteka dokumentacji.

1100
00:59:44,000 --> 00:59:46,000
Jest małe bary wyszukiwania, więc jeśli przycisk start pisania

1101
00:59:46,000 --> 00:59:50,000
rozpocznie podając wszystkie informacje o wszystkich rzeczy można zrobić za pomocą przycisku.

1102
00:59:50,000 --> 00:59:53,000
Mam również widoku tabeli Programming Guide.

1103
00:59:53,000 --> 00:59:56,000
Zajmuje widoki tabeli bardziej szczegółowo,

1104
00:59:56,000 --> 01:00:00,000
jak robić rzeczy, jak dynamicznie dodawać komórki lub edytować komórki lub ich usunięcia.

1105
01:00:00,000 --> 01:00:02,000
>> Jest wiele aplikacji, próbka z Apple, który pokaże Ci, jak to zrobić,

1106
01:00:02,000 --> 01:00:05,000
i wreszcie, ta ostatnia jest ludzki Wytyczne Interface,

1107
01:00:05,000 --> 01:00:09,000
i to jest w zasadzie pewne omówienie elementów interfejsu użytkownika,

1108
01:00:09,000 --> 01:00:12,000
rzeczy, jak nie zrobić przycisk, który znajduje się w 4 pikseli na 4 piksele.

1109
01:00:12,000 --> 01:00:15,000
To zły pomysł, i inne rzeczy, że Apple chce, aby zrobić

1110
01:00:15,000 --> 01:00:18,000
zachęcić dobrego wzornictwa.

1111
01:00:18,000 --> 01:00:23,000
>> Jakieś ostatnie pytania zanim skończę?

1112
01:00:23,000 --> 01:00:27,000
W porządku, na pewno tutaj, ale jesteśmy będzie mieć specjalne etykiety na dyskutować.

1113
01:00:27,000 --> 01:00:30,000
Będziemy mieć iOS jeden, więc na pewno tutaj wykorzystuje to.

1114
01:00:30,000 --> 01:00:34,000
Jeśli chcesz pracować z kolegami na temat projektów

1115
01:00:34,000 --> 01:00:37,000
lub pomóc wymyślić jakiś random stuff iOS

1116
01:00:37,000 --> 01:00:40,000
krępuj się napisz do mnie, a na pewno czytać cały kod online ponieważ

1117
01:00:40,000 --> 01:00:43,000
tylko w interesie raz rodzaj tabu więcej

1118
01:00:43,000 --> 01:00:45,000
drobnoziarnista szczegóły rzeczy.

1119
01:00:45,000 --> 01:00:47,000
Ale jeśli nie, to powodzenia na projekty iOS i mam nadzieję, że mamy

1120
01:00:47,000 --> 01:00:53,000
duży napływ aplikacji w App Store.

1121
01:00:53,000 --> 01:00:56,000
[CS50.TV]