1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [講座] [IOS：編寫應用程序像老闆]

2
00:00:02,000 --> 00:00:04,000
[和湯米MacWilliam] [哈佛大學]

3
00:00:04,000 --> 00:00:08,000
這是CS50。[CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> 好吧，大家好，歡迎到iOS：編寫應用程序，像老闆。

5
00:00:12,000 --> 00:00:16,000
本次研討會將重點上寫的iPhone應用程序

6
00:00:16,000 --> 00:00:19,000
，從而編寫應用程序的iPad，所以我們基本上要穿行

7
00:00:19,000 --> 00:00:23,000
一對夫婦不同的例子，如何使一個應用程序，一個簡單的遊戲，如井字，

8
00:00:23,000 --> 00:00:26,000
或者，如果你更感興趣的是一個應用程序，如某種形式的新聞閱讀器

9
00:00:26,000 --> 00:00:30,000
的東西，我會談談，以及與互聯網交互。

10
00:00:30,000 --> 00:00:32,000
這裡我們簡要的議程。

11
00:00:32,000 --> 00:00:36,000
>> IOS應用程序是用的語言叫Objective-C的，

12
00:00:36,000 --> 00:00:39,000
所以這是有點類似C，但沒有真正的所有，

13
00:00:39,000 --> 00:00:41,000
因此，我們會說一點點關於語言本身

14
00:00:41,000 --> 00:00:45,000
那麼如何來構建iPhone應用程序使用名為Xcode這個應用程序，

15
00:00:45,000 --> 00:00:48,000
如果你還沒有下載，還覺得現在開始下載。

16
00:00:48,000 --> 00:00:50,000
這是幾千兆字節。

17
00:00:50,000 --> 00:00:54,000
在App Store上應該是免費的，所以你需要有一個蘋果

18
00:00:54,000 --> 00:00:57,000
理想情況下運行最新版本的OS X。

19
00:00:57,000 --> 00:00:59,000
如果你沒有，沒有問題。

20
00:00:59,000 --> 00:01:02,000
我們有在科學中心提供的Mac電腦供您使用

21
00:01:02,000 --> 00:01:05,000
安裝了XCode，所以隨意使用這些發展。

22
00:01:05,000 --> 00:01:07,000
如果你想使一個應用程序，但不會有一個蘋果，不用擔心。

23
00:01:07,000 --> 00:01:09,000
有大量的校內資源，為。

24
00:01:09,000 --> 00:01:15,000
這樣的話，我們要去不同的應用程序，你可以覆蓋更大的例子。

25
00:01:15,000 --> 00:01:19,000
Objective-C是技術上被稱為C的一個超集

26
00:01:19,000 --> 00:01:24,000
這意味著，任何C代碼是有效的Objective-C代碼。

27
00:01:24,000 --> 00:01:29,000
這意味著，我們種管上一些額外的功能，C.錄音

28
00:01:29,000 --> 00:01:33,000
這些功能包括一些沒有寫的malloc再次，感謝上帝，

29
00:01:33,000 --> 00:01:36,000
不必擔心那些愚蠢的指針，並釋放他們和所有的東西

30
00:01:36,000 --> 00:01:40,000
你恨C，和它的種了，在Objective-C。

31
00:01:40,000 --> 00:01:43,000
>> 現在，Objective-C的標準庫有一個更大的，

32
00:01:43,000 --> 00:01:47,000
所以你的Objective-C的免費內了更多的功能。

33
00:01:47,000 --> 00:01:50,000
記住，當我們在寫PHP，我們注意到，我們就從

34
00:01:50,000 --> 00:01:54,000
這個最小的語言，所有這些瘋狂的事情你可以做的巨大的圖書館。

35
00:01:54,000 --> 00:01:56,000
同樣的事情發生在iOS。

36
00:01:56,000 --> 00:01:59,000
有對象的東西，如佛歷，真的什麼

37
00:01:59,000 --> 00:02:05,000
你可能認為在Objective-C的實現可能已經存在。

38
00:02:05,000 --> 00:02:08,000
Objective-C的目標的一部分，被引用的東西

39
00:02:08,000 --> 00:02:11,000
所謂的面向對象編程。

40
00:02:11,000 --> 00:02:14,000
這是一個新的概念，但我們實際上大多學會

41
00:02:14,000 --> 00:02:17,000
這些概念已經有很多。

42
00:02:17,000 --> 00:02:19,000
面向對象編程背後的想法是，你要構建

43
00:02:19,000 --> 00:02:23,000
您的代碼周圍有很多這些東西稱為類，

44
00:02:23,000 --> 00:02:26,000
這些類的真正榮耀的結構。

45
00:02:26,000 --> 00:02:30,000
內部的結構，我們基本上可以說這裡是一個東西，

46
00:02:30,000 --> 00:02:32,000
這個東西可以有成員。

47
00:02:32,000 --> 00:02:35,000
例如，一個鏈接的列表中的一個節點可以有其他的事情

48
00:02:35,000 --> 00:02:38,000
像的值，在列表中的下一個節點的指針，

49
00:02:38,000 --> 00:02:44,000
在一起的指針，該值由一個結構的一個實例。

50
00:02:44,000 --> 00:02:47,000
類是非常相似的，除了

51
00:02:47,000 --> 00:02:50,000
類也有他們內部的功能。

52
00:02:50,000 --> 00:02:54,000
當我們宣布一個結構，我們只能說整數n或節點*未來。

53
00:02:54,000 --> 00:02:57,000
>> 現在用的Objective-C實際上，我們可以把功能

54
00:02:57,000 --> 00:02:59,000
裡面的那些東西。

55
00:02:59,000 --> 00:03:03,000
類可以做的另一件事是，他們可以從其他類繼承的數據。

56
00:03:03,000 --> 00:03:07,000
例如，我們將著眼於一堆內置的Objective-C類。

57
00:03:07,000 --> 00:03:11,000
其中一個可能的類，它代表一個屏幕的視圖，

58
00:03:11,000 --> 00:03:14,000
，所以說，我要實現我自己的看法

59
00:03:14,000 --> 00:03:18,000
我們基本上說對在蘋果的人，可能是非常好的人，

60
00:03:18,000 --> 00:03:21,000
為我寫了這個類，它處理的事情，比如顯示按鈕

61
00:03:21,000 --> 00:03:25,000
或呈現在屏幕上，我們將是非常痛苦的

62
00:03:25,000 --> 00:03:28,000
實現所有的功能我們自己，所以通過簡單的

63
00:03:28,000 --> 00:03:31,000
繼承的數據，我們可以說，你沒有在這個類中的一切

64
00:03:31,000 --> 00:03:34,000
我也希望我的類的內部，然後我會做一些其他的東西，

65
00:03:34,000 --> 00:03:37,000
即實​​現一個應用程序。

66
00:03:37,000 --> 00:03:40,000
這是什麼字繼承的意思。我們會看到一個更具體的例子。

67
00:03:40,000 --> 00:03:42,000
>> 最後，與面向對象編程的關鍵是，

68
00:03:42,000 --> 00:03:45,000
它會導致數據的封裝。

69
00:03:45,000 --> 00:03:48,000
我們在一些問題設置，我們可以有這些大的，全局變量

70
00:03:48,000 --> 00:03:51,000
和全局無處不在，這就是我們會保持跟踪狀態。

71
00:03:51,000 --> 00:03:55,000
帶類，我們就可以開始封裝內的對象的信息。

72
00:03:55,000 --> 00:03:58,000
如果我們有我們的應用程序的一個屏幕上，我們並不真正需要的任何數據從

73
00:03:58,000 --> 00:04:01,000
在我們的應用程序內的，另一個屏幕，

74
00:04:01,000 --> 00:04:04,000
等封裝在類的東西，這實際上導致

75
00:04:04,000 --> 00:04:08,000
到更好的代碼設計，這是可能的，與一些附加功能。

76
00:04:08,000 --> 00:04:11,000
Objective-C的。

77
00:04:11,000 --> 00:04:15,000
預警，為Objective-C的語法是香蕉。

78
00:04:15,000 --> 00:04:19,000
這是什麼之前，我們已經看到，

79
00:04:19,000 --> 00:04:22,000
所以它是一點點的學習曲線已經習慣了

80
00:04:22,000 --> 00:04:24,000
這到底是什麼意思呢？

81
00:04:24,000 --> 00:04:27,000
但是，一旦你過去，最初的學習曲線，這是真的，真的很光滑

82
00:04:27,000 --> 00:04:29,000
開始編寫應用程序。

83
00:04:29,000 --> 00:04:33,000
>> 要聲明一個類，這裡要說的是我的課，它的存在，

84
00:04:33,000 --> 00:04:35,000
也許這裡有一些事情，我要定義後，

85
00:04:35,000 --> 00:04:38,000
我會說接口。

86
00:04:38,000 --> 00:04:41,000
我會說接口。我想給我的類的名稱。

87
00:04:41,000 --> 00:04:43,000
再後來又在其他地方，我會說結束，

88
00:04:43,000 --> 00:04:46,000
一切都在@接口和@結束的之間的

89
00:04:46,000 --> 00:04:48,000
將是我的課。

90
00:04:48,000 --> 00:04:51,000
這將是我們的。h文件裡面有什麼。

91
00:04:51,000 --> 00:04:55,000
就像在C h文件，從根本上說，這裡有一些事情，會存在。

92
00:04:55,000 --> 00:04:57,000
我不一定告訴你他們還做什麼，

93
00:04:57,000 --> 00:04:59,000
但編譯器需要知道它們的存在。

94
00:04:59,000 --> 00:05:04,000
後來我們。米內的文件，因為m的Objective-C的

95
00:05:04,000 --> 00:05:08,000
我們要定義這些類的。

96
00:05:08,000 --> 00:05:11,000
就像我們的文件，我們提供功能的實現。

97
00:05:11,000 --> 00:05:15,000
在我們的m文件，我們要在這裡說的是什麼的全部功能

98
00:05:15,000 --> 00:05:18,000
裡面的我的課，他們都做。

99
00:05:18,000 --> 00:05:22,000
最後，內​​部的結構，我們可以說，這些花括號內

100
00:05:22,000 --> 00:05:25,000
INT n或節點*下，

101
00:05:25,000 --> 00:05:28,000
在Objective-C，我們要使用關鍵字@財產，

102
00:05:28,000 --> 00:05:31,000
這是怎麼回事定義屬性，

103
00:05:31,000 --> 00:05:36,000
非功能的一部分，我的課。

104
00:05:36,000 --> 00:05:40,000
>> Objective-C中調用函數是香蕉。

105
00:05:40,000 --> 00:05:43,000
當我們宣布我們說了些什麼，如int foo的功能在C

106
00:05:43,000 --> 00:05:46,000
和開放的括號，然後把它的參數列表。

107
00:05:46,000 --> 00:05:51,000
這是聲明的方法或函數看起來像在Objective-C的。

108
00:05:51,000 --> 00:05:54,000
如果我要聲明一個函數或方法

109
00:05:54,000 --> 00:05:58,000
我說的方法實際上是一個函數，這是一個類的成員，

110
00:05:58,000 --> 00:06:01,000
因此種可互換的，但不是真的，

111
00:06:01,000 --> 00:06:03,000
裡面有我的方法，我想創建一個新的方法。

112
00:06:03,000 --> 00:06:06,000
這將返回任何結果，所以這將是void類型。

113
00:06:06,000 --> 00:06:08,000
這是我的函數的返回類型。

114
00:06:08,000 --> 00:06:11,000
現在，我們有括號括住在這裡，因為我不知道。

115
00:06:11,000 --> 00:06:14,000
下一步將是我的函數的名稱，

116
00:06:14,000 --> 00:06:17,000
最後，我們有一個分號，就像我們在C.

117
00:06:17,000 --> 00:06:19,000
什麼是新來的，是這傢伙在這裡。

118
00:06:19,000 --> 00:06:22,000
這連字符實際上是必要的，這說的是，

119
00:06:22,000 --> 00:06:26,000
這種方法必須調用類的一個實例。

120
00:06:26,000 --> 00:06:29,000
>> 當我們宣布我們的結構，我們可能是這樣說：

121
00:06:29,000 --> 00:06:32,000
結構節點n，和實際創建

122
00:06:32,000 --> 00:06:35,000
或實例化這些結構，這樣我就可以真正開始工作

123
00:06:35,000 --> 00:06:38,000
它裡面是什麼，所以這個破折號意味著我們必須

124
00:06:38,000 --> 00:06:41,000
實例化的類，就像我們實例化結構

125
00:06:41,000 --> 00:06:43,000
之前，我們可以調用這個方法就可以了。

126
00:06:43,000 --> 00:06:46,000
如果我要開始我的方法添加參數

127
00:06:46,000 --> 00:06:48,000
它變得更加香蕉。

128
00:06:48,000 --> 00:06:50,000
這裡是我的方法的名稱。

129
00:06:50,000 --> 00:06:53,000
然後我有一個冒號，這個冒號後，這裡說的幾個參數。

130
00:06:53,000 --> 00:06:56,000
這種方法需要一個參數。

131
00:06:56,000 --> 00:06:59,000
其參數的類型是int，這樣的說法和名稱

132
00:06:59,000 --> 00:07:03,000
，我要開始使用裡面的方法或變量叫我。

133
00:07:03,000 --> 00:07:05,000
再次，這是方法。它接受一個參數。

134
00:07:05,000 --> 00:07:10,000
>> 如果你想開始添加更多的參數，得到更多的香蕉

135
00:07:10,000 --> 00:07:13,000
中，我們有這個冒號在這裡說來我的參數列表。

136
00:07:13,000 --> 00:07:15,000
第一個參數是一個整數。

137
00:07:15,000 --> 00:07:17,000
現在，這個說法很有趣。

138
00:07:17,000 --> 00:07:20,000
我的變量，將使用在我的功能

139
00:07:20,000 --> 00:07:23,000
被稱為F，所以在我的功能，我可以說

140
00:07:23,000 --> 00:07:25,000
F + = 1或東西。

141
00:07:25,000 --> 00:07:30,000
這件事情在這裡基本上是一個關鍵，參數或參數。

142
00:07:30,000 --> 00:07:34,000
就像我們的鍵值對的東西，如JSON或關聯數組

143
00:07:34,000 --> 00:07:37,000
Objective-C的說，沒關係，只要它確實是明確的決定

144
00:07:37,000 --> 00:07:39,000
當你調用一個方法，所有這些參數是什麼

145
00:07:39,000 --> 00:07:41,000
實際上，我到他們的名字。

146
00:07:41,000 --> 00:07:45,000
當你調用一個方法，你實際上會說andFloat的，

147
00:07:45,000 --> 00:07:47,000
然後你會通過它。

148
00:07:47,000 --> 00:07:50,000
>> 有趣的是，這個人是沒有被命名，但所有的其他參數，

149
00:07:50,000 --> 00:07:53,000
因此，如果我們有一個第三個參數我可以說andFloat的

150
00:07:53,000 --> 00:07:56,000
和另一個浮動等。

151
00:07:56,000 --> 00:08:01,000
當我把這些方法當然香蕉，

152
00:08:01,000 --> 00:08:04,000
所以，如果我有一個對象，我定義了一個名為foo的方法，

153
00:08:04,000 --> 00:08:09,000
我想打電話給它，而不是說foo的打開/關閉括號

154
00:08:09,000 --> 00:08:11,000
我要打開一個支架。

155
00:08:11,000 --> 00:08:13,000
下面是我的方法的名稱。

156
00:08:13,000 --> 00:08:17,000
我要關閉支架，這是我調用它的對象。

157
00:08:17,000 --> 00:08:20,000
請記住，所有這些方法都存在於類

158
00:08:20,000 --> 00:08:23,000
因為類可以有定義的方法內的。

159
00:08:23,000 --> 00:08:26,000
>> 在這裡，我隨意創建某個類的一個對象，

160
00:08:26,000 --> 00:08:28,000
這是這樣做的語法。

161
00:08:28,000 --> 00:08:31,000
有2個步驟創建一個對象。

162
00:08:31,000 --> 00:08:34,000
第一步是說，我要分配空間。

163
00:08:34,000 --> 00:08:37,000
這相當於一個malloc。我們沒有說的malloc了。

164
00:08:37,000 --> 00:08:42,000
我們放棄了米，它的alloc，取代的。c。米。

165
00:08:42,000 --> 00:08:47,000
後，我們的alloc東西的，我們就需要對其進行初始化。

166
00:08:47,000 --> 00:08:49,000
基本上，當你創建對象，你可能想有一些邏輯

167
00:08:49,000 --> 00:08:53,000
執行時，他們創建的，所以你可以通過一些默認值

168
00:08:53,000 --> 00:08:57,000
或類似的東西，所以這個init（）方法實際上是創建對象。

169
00:08:57,000 --> 00:08:59,000
我們第一次分配空間，就像我們在C，

170
00:08:59,000 --> 00:09:04,000
然後我們將它初始化，可能會或可能不會做很多。

171
00:09:04,000 --> 00:09:07,000
然後，我們回到這件事情的對象o。

172
00:09:07,000 --> 00:09:09,000
這裡有一個明星，因為從技術上講，這是一個指針，

173
00:09:09,000 --> 00:09:12,000
不過不用擔心，指針是不是什麼大不了的事在Objective-C了。

174
00:09:12,000 --> 00:09:15,000
>> 現在，我們已經實例化這個類NSObject的，

175
00:09:15,000 --> 00:09:19,000
而這僅僅是一個隨機的類，蘋果。

176
00:09:19,000 --> 00:09:22,000
我們已經實例化了，現在我有這個類的一個實例

177
00:09:22,000 --> 00:09:25,000
在這個對象o，所以這意味著，如果我定義

178
00:09:25,000 --> 00:09:29,000
這些方法，我可以打電話給他們這個樣子。

179
00:09:29,000 --> 00:09:31,000
同樣，如果我想用一個參數來調用一個方法，

180
00:09:31,000 --> 00:09:34,000
所以這是酒吧的方法，它有一個參數，

181
00:09:34,000 --> 00:09:38,000
這裡是巴茲：QUX方法，所以這需要兩個參數。

182
00:09:38,000 --> 00:09:44,000
這是調用這個對象o上的一個功能。

183
00:09:44,000 --> 00:09:46,000
有意義嗎？

184
00:09:46,000 --> 00:09:50,000
它的語法意義，但你種習慣。

185
00:09:50,000 --> 00:09:54,000
>> 好吧，讓我們來談談幾件事情中內置的Objective-C的

186
00:09:54,000 --> 00:09:56,000
不一定C建成。

187
00:09:56,000 --> 00:09:59,000
在C語言中，我們種的，因為這些愚蠢的字符數組與字符串處理，

188
00:09:59,000 --> 00:10:01,000
真的很討厭。

189
00:10:01,000 --> 00:10:04,000
Objective-C的全部建成，對我們來說，它是建立在

190
00:10:04,000 --> 00:10:06,000
使用這個類稱為NSString的。

191
00:10:06,000 --> 00:10:10,000
當我想創建一個NSString我們有更艱澀難懂的語法。

192
00:10:10,000 --> 00:10:15,000
而不是說：“CS50”我們說：“CS50”

193
00:10:15,000 --> 00:10:17,000
而這僅僅是聲明字符串中的Objective-C的語法。

194
00:10:17,000 --> 00:10:21,000
這是非常容易忘記，所以不要。

195
00:10:21,000 --> 00:10:24,000
現在，一旦我有這個，這是一個字符串，但要注意

196
00:10:24,000 --> 00:10:26,000
它實際上是一個對象。

197
00:10:26,000 --> 00:10:30,000
我說的NSString，這意味著我實例化的類

198
00:10:30,000 --> 00:10:32,000
所謂的NSString，別人寫的我，

199
00:10:32,000 --> 00:10:35,000
和他們是很不錯的了，所以現在

200
00:10:35,000 --> 00:10:37,000
我可以調用它的方法。

201
00:10:37,000 --> 00:10:40,000
如果我調用該方法的對象s的長度

202
00:10:40,000 --> 00:10:43,000
它會回到我這裡來的字符串的長度。

203
00:10:43,000 --> 00:10:45,000
這是一樣的strlen C.

204
00:10:45,000 --> 00:10:47,000
這將返回4。

205
00:10:47,000 --> 00:10:51,000
>> 同樣，我可能要關心的是另一種方法這個characterAtIndex。

206
00:10:51,000 --> 00:10:54,000
這是一個方法，說這個字符串s

207
00:10:54,000 --> 00:10:57,000
我希望你能得到零級人物，

208
00:10:57,000 --> 00:10:59,000
，所以這將返回到我的字符c，

209
00:10:59,000 --> 00:11:02,000
有一大堆以上的這些方法，你可以在Google真的很容易。

210
00:11:02,000 --> 00:11:07,000
蘋果的文檔是偉大的，我們就來看看，在一個位。

211
00:11:07,000 --> 00:11:09,000
這些都是字符串。

212
00:11:09,000 --> 00:11:11,000
我們也有內置的可變大小的數組

213
00:11:11,000 --> 00:11:13,000
請記住，在C時，我們聲明數組

214
00:11:13,000 --> 00:11:16,000
我們不得不說，你有5個元素，故事的結尾。

215
00:11:16,000 --> 00:11:18,000
當我們到了JavaScript和PHP，我們可以開始

216
00:11:18,000 --> 00:11:20,000
做的事情，如添加元素或移動元素。

217
00:11:20,000 --> 00:11:22,000
我們可以做同樣的Objective-C中。

218
00:11:22,000 --> 00:11:26,000
在正常的C方式，而不是創建一個數組

219
00:11:26,000 --> 00:11:30,000
我們再次調用另一個類的NSMutableArray。

220
00:11:30,000 --> 00:11:33,000
還有的NSArray，

221
00:11:33,000 --> 00:11:35,000
這是怎麼回事，基本上封裝了一些陣列。

222
00:11:35,000 --> 00:11:38,000
這是說我想要做的第一件事情是我想分配

223
00:11:38,000 --> 00:11:41,000
為新陣列的空間，並在我分配

224
00:11:41,000 --> 00:11:43,000
然後，我需要對其進行初始化。

225
00:11:43,000 --> 00:11:45,000
同樣，調用這些方法。

226
00:11:45,000 --> 00:11:48,000
現在，這意味著這個對象內部的一個

227
00:11:48,000 --> 00:11:50,000
我有一個空數組坐在那裡。

228
00:11:50,000 --> 00:11:54,000
如果我要添加到這個數組中的東西，我可以調用AddObject方法。

229
00:11:54,000 --> 00:11:59,000
我想補充一個對象數組a，我想補充的字符串CS50。

230
00:11:59,000 --> 00:12:02,000
如果我想反過來刪除，我可以說，我要

231
00:12:02,000 --> 00:12:09,000
刪除對象在陣列上的第一個地方或物件。

232
00:12:09,000 --> 00:12:11,000
>> 有意義嗎？

233
00:12:11,000 --> 00:12:14,000
好了，你種習慣了這方括號內的事情。

234
00:12:14,000 --> 00:12:18,000
順便說一下，裡面有很多蘋果的圖書館，你會看到這個NS。

235
00:12:18,000 --> 00:12:21,000
NS實際上代表的下一個步驟，這是史蒂夫·喬布斯最早的公司之一，

236
00:12:21,000 --> 00:12:24,000
而這也正是他真的開始寫了很多的代碼

237
00:12:24,000 --> 00:12:27,000
作為一種適用於Mac OS X和所有其他的東西的基礎，

238
00:12:27,000 --> 00:12:32,000
所以這NS是這個漂亮遺留下來的一種喊出來較早的公​​司之一

239
00:12:32,000 --> 00:12:34,000
回來時，蘋果公司第一次開始了。

240
00:12:34,000 --> 00:12:36,000
它無處不在。

241
00:12:36,000 --> 00:12:41,000
讓我們來看看一個更全面的Objective-C的例子。

242
00:12:41,000 --> 00:12:44,000
在這裡，我在裡面的Xcode。

243
00:12:44,000 --> 00:12:47,000
到這裡，我第一次從App Store下載的XCode，

244
00:12:47,000 --> 00:12:50,000
打開它，然後我去到文件，

245
00:12:50,000 --> 00:12:54,000
在這裡，新的，然後項目。

246
00:12:54,000 --> 00:12:57,000
當我這樣做，我有所有這些選項是什麼，我想創建，

247
00:12:57,000 --> 00:12:59,000
所以我們就來看看這些選項後，

248
00:12:59,000 --> 00:13:03,000
但在這個例子中，因為我們實際上沒有去有一個應用程序，

249
00:13:03,000 --> 00:13:06,000
我來到這裡，和我說的命令行工具，

250
00:13:06,000 --> 00:13:09,000
這是一個應用程序，我可以在命令行中運行

251
00:13:09,000 --> 00:13:12,000
就像我們已經從C

252
00:13:12,000 --> 00:13:16,000
這就是我創造了這個項目，所以現在我在這裡，

253
00:13:16,000 --> 00:13:20,000
讓我們先來看看這個文件，這應該很熟悉。

254
00:13:20,000 --> 00:13:24,000
我有一個int的名稱。還有我的朋友，我的其他哥們ARGV的argc。

255
00:13:24,000 --> 00:13:30,000
因此，我們可以看到，這是我的第一個Objective-C的應用程序的入口點。

256
00:13:30,000 --> 00:13:32,000
在這裡，我們可以忽略這個現在。

257
00:13:32,000 --> 00:13:35,000
這基本上是一些內存管理的東西，你不會真的

258
00:13:35,000 --> 00:13:37,000
以往任何時候都不必擔心。

259
00:13:37,000 --> 00:13:39,000
>> 讓我們來看看這首塊。

260
00:13:39,000 --> 00:13:46,000
這第一行，如果我說學生愛麗絲= [[學生的alloc]初始化]那是什麼做的？

261
00:13:46,000 --> 00:13:50,000
這首先這裡的學生，這可能是一個類。

262
00:13:50,000 --> 00:13:54,000
這是不是一個類，蘋果寫的，但它是一個類，我寫的。

263
00:13:54,000 --> 00:13:57,000
我想要做的第一件事情是，我想新的學生分配空間，

264
00:13:57,000 --> 00:14:00,000
然後我想將它初始化，所以這讓我回

265
00:14:00,000 --> 00:14:05,000
這個新的學生對象，我存儲在一個叫愛麗絲的變量。

266
00:14:05,000 --> 00:14:07,000
那類從何而來？

267
00:14:07,000 --> 00:14:12,000
那麼，在這裡的左側，這些都是我的項目裡面的不同的文件。

268
00:14:12,000 --> 00:14:16,000
我們可以看到，在這裡我有一個Student.h和Student.m。

269
00:14:16,000 --> 00:14:20,000
h文件，記住，是我宣布所有的事情

270
00:14:20,000 --> 00:14:22,000
將存在於類。

271
00:14:22,000 --> 00:14:25,000
>> 讓我們來看看在那。

272
00:14:25,000 --> 00:14:29,000
好了，在這裡，我們有這樣的@接口，這說來

273
00:14:29,000 --> 00:14:33,000
一切都將存在於我的課的聲明。

274
00:14:33,000 --> 00:14:36,000
然後，我有一個冒號。然後，我有這樣的NSObject的事情。

275
00:14:36,000 --> 00:14:40,000
這的結腸表示，繼承位，我們的討論早一點。

276
00:14:40,000 --> 00:14:43,000
這是說一NSObject可以做的一切

277
00:14:43,000 --> 00:14:46,000
NSObject的是別人寫的這個類，

278
00:14:46,000 --> 00:14:50,000
這的NSObject的可以做的一切，我想是能夠做到這一點。

279
00:14:50,000 --> 00:14:54,000
他說：NSObject的，這意味著我基本上

280
00:14:54,000 --> 00:14:58,000
繼承另一個類的所有的功能。

281
00:14:58,000 --> 00:15:02,000
這真的給了我一大堆，我可以用不同的方法和屬性。

282
00:15:02,000 --> 00:15:05,000
在這裡我創建2個屬性。

283
00:15:05,000 --> 00:15:08,000
這意味著我的學生，如果這是一個結構，這將是兩件事情

284
00:15:08,000 --> 00:15:11,000
我的結構內，使每一個學生都有一個名字

285
00:15:11,000 --> 00:15:14,000
這是一個字符串，和學生也有一個檔次，

286
00:15:14,000 --> 00:15:17,000
這是一個int。

287
00:15:17,000 --> 00:15:23,000
>> 最後，在這裡我要為我的學生創建一個方法。

288
00:15:23,000 --> 00:15:26,000
我打電話給我的方法，initWithName，它需要一個參數，

289
00:15:26,000 --> 00:15:31,000
該參數是一個字符串，我把它叫做命名。

290
00:15:31,000 --> 00:15:35,000
現在，讓我們來看看我們如何實現這個類。

291
00:15:35,000 --> 00:15:38,000
在這裡，我現在是我的m文件裡面，

292
00:15:38,000 --> 00:15:40,000
m的實施，我猜。

293
00:15:40,000 --> 00:15:44,000
我有我的實現，我的目的，這裡是什麼地方，我實際上是在定義

294
00:15:44,000 --> 00:15:47,000
什麼initWithName。

295
00:15:47,000 --> 00:15:50,000
我有initWithName，我的參數的名稱，然後將此

296
00:15:50,000 --> 00:15:53,000
實際上，我創建一個學生，

297
00:15:53,000 --> 00:15:56,000
所以這是一個有點神秘的，但是這是種樣板

298
00:15:56,000 --> 00:15:58,000
要包括在你的構造函數。

299
00:15:58,000 --> 00:16:02,000
在這裡，這個初始化函數initWithName，是一個類型的構造函數。

300
00:16:02,000 --> 00:16:05,000
你基本上是興建一座新的學生對象

301
00:16:05,000 --> 00:16:07,000
也許它內部的數據發送一些。

302
00:16:07,000 --> 00:16:11,000
我想要做的第一件事情是我要調用init這超級事情上。

303
00:16:11,000 --> 00:16:15,000
>> 請記住，當我回到這裡。h文件

304
00:16:15,000 --> 00:16:21,000
這一切的NSObject的學生也有。

305
00:16:21,000 --> 00:16:24,000
這意味著，當我創建了一個學生，我還需要做的是

306
00:16:24,000 --> 00:16:28,000
確保NSObject的，我繼承所有的數據

307
00:16:28,000 --> 00:16:32,000
正確初始化。

308
00:16:32,000 --> 00:16:36,000
我需要說的是，這個超級實際上是指父類

309
00:16:36,000 --> 00:16:39,000
我繼承的，所以我想確保我初始化

310
00:16:39,000 --> 00:16:43,000
一切，我根據之前，我開始嘗試使用它。

311
00:16:43,000 --> 00:16:46,000
然後，如果正確初始化這就像說如果malloc

312
00:16:46,000 --> 00:16:50,000
沒有返回null，然後我就可以開始設置一些屬性。

313
00:16:50,000 --> 00:16:54,000
>> 在JavaScript和PHP，我們有這個關鍵字叫這個，

314
00:16:54,000 --> 00:16:58,000
這是指一類的當前實例。

315
00:16:58,000 --> 00:17:00,000
在Objective-C中，我們稱這種自我。

316
00:17:00,000 --> 00:17:04,000
當我說self.name，這意味著該對象

317
00:17:04,000 --> 00:17:07,000
我剛剛創建時，我說，學生的alloc初始化，

318
00:17:07,000 --> 00:17:09,000
將會給我回一個對象。

319
00:17:09,000 --> 00:17:12,000
這意味著我要設置該對象的名稱

320
00:17:12,000 --> 00:17:15,000
無論我剛剛傳入

321
00:17:15,000 --> 00:17:18,000
就像在C中，我們訪問這個點，

322
00:17:18,000 --> 00:17:21,000
所以self.name說的學生對象的名稱

323
00:17:21,000 --> 00:17:24,000
現在不管你剛剛傳入

324
00:17:24,000 --> 00:17:28,000
所以最後，我可以返回它，所以我得到的東西回來。

325
00:17:28,000 --> 00:17:30,000
>> 有問題嗎？

326
00:17:30,000 --> 00:17:34,000
好了，所以這個自我=超初始化的，

327
00:17:34,000 --> 00:17:37,000
如果你不完全理解繼承的東西，不要擔心。

328
00:17:37,000 --> 00:17:40,000
只知道，如果你想使自己的init（）方法只是

329
00:17:40,000 --> 00:17:42,000
做到這一點，你會好到哪裡去。

330
00:17:42,000 --> 00:17:44,000
是啊。>> [學生]是什麼，如果自我平均？

331
00:17:44,000 --> 00:17:49,000
這意味著，當我們的malloc的東西，我們總是檢查，如果它等於空，

332
00:17:49,000 --> 00:17:51,000
如果它是空的，然後我們退出。

333
00:17:51,000 --> 00:17:55,000
這是同樣的事情，因為如果此方法返回null，那麼我們很可能要賽格故障

334
00:17:55,000 --> 00:17:57,000
如果我們開始試圖操縱它。

335
00:17:57,000 --> 00:18:01,000
這是我們的學生類。

336
00:18:01,000 --> 00:18:03,000
這意味著我們可以初始化我們的學生在以下兩種方法之一。

337
00:18:03,000 --> 00:18:08,000
如果我說學生的alloc初始化，我沒有使用這種方法，我只寫了，

338
00:18:08,000 --> 00:18:11,000
不是我可以簡單地說alice.name，

339
00:18:11,000 --> 00:18:14,000
現在我要設置該屬性的名稱。

340
00:18:14,000 --> 00:18:17,000
>> 同樣，如果我想使用，initWithName方法

341
00:18:17,000 --> 00:18:20,000
我可以簡單地說ALLOC，然後，而不是說的init

342
00:18:20,000 --> 00:18:24,000
我要調用該方法，我剛剛創建的，我要通過在鮑勃。

343
00:18:24,000 --> 00:18:30,000
在這一點上，此對象鮑勃具有名稱等於給Bob。

344
00:18:30,000 --> 00:18:35,000
好了，在這裡我使用NSMutableArray裡，我們前面介紹過。

345
00:18:35,000 --> 00:18:38,000
我我分配space.Then的我一個新的數組初始化。

346
00:18:38,000 --> 00:18:40,000
我要的東西給它加2。

347
00:18:40,000 --> 00:18:43,000
現在，此數組保存學生對象。

348
00:18:43,000 --> 00:18:46,000
請注意，沒有在哪個地方，我不得不說這是一個數組的學生。

349
00:18:46,000 --> 00:18:48,000
我說，它是一個數組期。

350
00:18:48,000 --> 00:18:50,000
然後，我可以把任何在它裡面，我想。

351
00:18:50,000 --> 00:18:52,000
在這裡，我有兩個對象。

352
00:18:52,000 --> 00:18:56,000
>> 最後，我有另一個對象，這個TF。

353
00:18:56,000 --> 00:18:59,000
在TF.h在這裡基本上是同樣的事情。

354
00:18:59,000 --> 00:19:01,000
我從NSObject繼承的方式，

355
00:19:01,000 --> 00:19:03,000
創建類時，這一切都為你做，

356
00:19:03,000 --> 00:19:06,000
這種接口的樣板。

357
00:19:06,000 --> 00:19:08,000
它有一個屬性的學生。

358
00:19:08,000 --> 00:19:15,000
我有一對夫婦的方法在這裡並不真正做了一大堆，

359
00:19:15,000 --> 00:19:18,000
因此，這意味著創建這個TF對象後，

360
00:19:18,000 --> 00:19:23,000
我可以調用此方法的檔次上是這樣的。

361
00:19:23,000 --> 00:19:26,000
Objective-C語法上的任何問題，然後才開始遷入一些更

362
00:19:26,000 --> 00:19:30,000
有趣的應用程序開發的東西嗎？

363
00:19:30,000 --> 00:19:34,000
>> 好吧，讓我們的實際上是一個iPhone應用程序。

364
00:19:34,000 --> 00:19:39,000
核心類，你會在你的iPhone應用程序使用被稱為視圖控制器，

365
00:19:39,000 --> 00:19:42,000
一個視圖控制器基本上是一個單一的屏幕

366
00:19:42,000 --> 00:19:46,000
你的應用程序裡面，所以如果我的音樂應用程序，例如，

367
00:19:46,000 --> 00:19:50,000
一個視圖控制器可以代表我的視圖中查看所有歌曲在我的iPhone。

368
00:19:50,000 --> 00:19:53,000
另一種觀點控制器可以當我點擊一首歌曲，開始播放

369
00:19:53,000 --> 00:19:55,000
我深入到藝術家。

370
00:19:55,000 --> 00:19:59,000
這些不同的畫面中的每一個都可以表示為一個不同的視圖控制器，

371
00:19:59,000 --> 00:20:04,000
一個視圖控制器類實際上只是一個說，這個屏幕是如何工作的。

372
00:20:04,000 --> 00:20:07,000
裡面的東西的一個視圖控制器，我們要的屬性，

373
00:20:07,000 --> 00:20:10,000
這樣的事情像一個按鈕，將是我們的視圖控制器的屬性。

374
00:20:10,000 --> 00:20:13,000
>> 我們也有方法，這些都是基本的事件處理程序。

375
00:20:13,000 --> 00:20:16,000
這種方法說，當你按下這個按鈕時，

376
00:20:16,000 --> 00:20:19,000
我想要做的事情，最後，再次，

377
00:20:19,000 --> 00:20:24,000
我們將使用這種自我關鍵字來訪問當前實例。

378
00:20:24,000 --> 00:20:29,000
要建立在iOS界面實際上是真的，真的很容易。

379
00:20:29,000 --> 00:20:32,000
他們有這個漂亮的叫Interface Builder中的拖放界面，

380
00:20:32,000 --> 00:20:37,000
和2線的核心概念，你的Objective-C的界面生成器

381
00:20:37,000 --> 00:20:40,000
IBOutlet和IBAction。

382
00:20:40,000 --> 00:20:44,000
一個IBOutlet簡單地說，如果你聲明一個屬性，這是一個按鈕，

383
00:20:44,000 --> 00:20:47,000
你想要把它掛在您的實際UI的東西，

384
00:20:47,000 --> 00:20:49,000
你會說，這是一個出口。

385
00:20:49,000 --> 00:20:51,000
同樣，如果你​​想表示一個事件處理程序

386
00:20:51,000 --> 00:20:54,000
那麼你會說​​這是一個行動。

387
00:20:54,000 --> 00:20:57,000
>> 要真正連接的圖形表示

388
00:20:57,000 --> 00:21:00,000
你的代碼是真的，真的很簡單。

389
00:21:00,000 --> 00:21:03,000
如果你想附加一個IBOutlet，所有你所要做的是控制點擊，

390
00:21:03,000 --> 00:21:05,000
我們會看到一個例子，這是真的快。

391
00:21:05,000 --> 00:21:07,000
您可以控制​​點擊它說 - 視圖 - 控制器。

392
00:21:07,000 --> 00:21:09,000
你要拖動到界面，或者相反，

393
00:21:09,000 --> 00:21:13,000
如果你想連接的事件處理程序，你要拖動的界面

394
00:21:13,000 --> 00:21:15,000
在另一個方向上。

395
00:21:15,000 --> 00:21:20,000
讓我們來看看在一個非常簡單的iOS的例子。

396
00:21:20,000 --> 00:21:23,000
>> 讓我們創建一個新的項目。

397
00:21:23,000 --> 00:21:25,000
我要來這裡申請，

398
00:21:25,000 --> 00:21:28,000
我要“的單一視圖應用程序。

399
00:21:28,000 --> 00:21:31,000
我要點擊下一步。我會給你我的項目的名稱。

400
00:21:31,000 --> 00:21:33,000
我會打電話給它餵。

401
00:21:33,000 --> 00:21:36,000
有趣的是，蘋果公司不承擔您要創建一個產品

402
00:21:36,000 --> 00:21:38,000
這樣就可以賣它，他們就可以賺錢。

403
00:21:38,000 --> 00:21:41,000
在這裡我會說，這是一個iPhone應用程序。

404
00:21:41,000 --> 00:21:44,000
您可以創建一個iPad應用程序，或者如果您想創建這些應用程序之一

405
00:21:44,000 --> 00:21:47,000
支持這兩種設備可以做到這一點。

406
00:21:47,000 --> 00:21:49,000
這是你想要看起來像你的复選標記。

407
00:21:49,000 --> 00:21:51,000
>> 您要使用的故事板，我們將在後​​面看到，

408
00:21:51,000 --> 00:21:54,000
你一定要使用自動的引用計數，

409
00:21:54,000 --> 00:21:58,000
這是一個很好的功能，可以防止你說malloc和free。

410
00:21:58,000 --> 00:22:03,000
除非你想調用malloc和free，我將離開這個托運。

411
00:22:03,000 --> 00:22:07,000
我會單擊“下一步”，最後，這是怎麼回事，問我在哪裡，我想將它保存。

412
00:22:07,000 --> 00:22:14,000
我會打造成“，在這裡，我們去。

413
00:22:14,000 --> 00:22:16,000
我創建了一個新的項目。

414
00:22:16,000 --> 00:22:19,000
在這裡的左邊是我的項目內的所有文件，

415
00:22:19,000 --> 00:22:22,000
請注意，我得到了一大堆，我什至沒有做任何事情。

416
00:22:22,000 --> 00:22:24,000
IOS是很大的。

417
00:22:24,000 --> 00:22:27,000
>> 例如，在這裡ViewController.h，

418
00:22:27,000 --> 00:22:30,000
這將是我的第一個視圖控制器，

419
00:22:30,000 --> 00:22:32,000
所以我的應用程序的第一個屏幕內。

420
00:22:32,000 --> 00:22:34,000
現在我們知道這是什麼話說。

421
00:22:34,000 --> 00:22:36,000
我們說，我調用這個類的ViewController，

422
00:22:36,000 --> 00:22:40,000
一個ViewController的一切，一個UIViewController，

423
00:22:40,000 --> 00:22:43,000
而這，又是一些類，蘋果寫道，我們做了很多方便的東西

424
00:22:43,000 --> 00:22:46,000
我想顯示在屏幕上。

425
00:22:46,000 --> 00:22:50,000
在這裡我可以真正開始界定什麼是我的視圖控制器，

426
00:22:50,000 --> 00:22:52,000
事實證明，我真的不需要任何。

427
00:22:52,000 --> 00:22:55,000
這是蘋果給我免費的樣板代碼。

428
00:22:55,000 --> 00:22:59,000
我確實需要，第一行，我沒有一類，

429
00:22:59,000 --> 00:23:02,000
這樣我們就可以擺脫，擺脫這一點。

430
00:23:02,000 --> 00:23:05,000
好了，所以這是我空白的屏幕。

431
00:23:05,000 --> 00:23:08,000
>> 現在，讓我們的點擊這MainStoryboard.storyboard，

432
00:23:08,000 --> 00:23:11,000
這是它開始變得有趣的地方。

433
00:23:11,000 --> 00:23:14,000
這代表我的應用程序的第一個屏幕。

434
00:23:14,000 --> 00:23:17,000
如果我想在HTML中添加一個按鈕，我不得不創建一個按鈕，標籤。

435
00:23:17,000 --> 00:23:20,000
在Android中，你必須創建一個按鈕，標籤，

436
00:23:20,000 --> 00:23:23,000
但在iOS中，如果我只是來這裡的右下角

437
00:23:23,000 --> 00:23:27,000
，如果我點擊，第3個在這裡說的對象，

438
00:23:27,000 --> 00:23:31,000
我可以向下滾動，或者我就可以開始搜索按鈕。

439
00:23:31,000 --> 00:23:35,000
你看，一個按鈕，所以如果我拖動和下降這一權利，

440
00:23:35,000 --> 00:23:38,000
我只是增加了一個按鈕，此畫面在我的應用程序。

441
00:23:38,000 --> 00:23:41,000
如果我想改變的文字，我可以雙擊它，

442
00:23:41,000 --> 00:23:47,000
說誘人，如“按我的東西。”

443
00:23:47,000 --> 00:23:51,000
好了，現在如果我運行這個程序，所以我們編譯它，

444
00:23:51,000 --> 00:23:54,000
運行，我點擊播放按鈕在左上角，有我的應用程序。

445
00:23:54,000 --> 00:23:58,000
我沒有做任何事情，我有一個甜美的期待的iPhone應用程序。

446
00:23:58,000 --> 00:24:01,000
如果我要阻止它，你可以單擊“停止”按鈕

447
00:24:01,000 --> 00:24:03,000
因為它更有趣。

448
00:24:03,000 --> 00:24:07,000
>> 比方說，我真正想要的東西發生時，我按下這個按鈕。

449
00:24:07,000 --> 00:24:09,000
要做到這一點，我需要做的是，我需要創建

450
00:24:09,000 --> 00:24:13,000
一個新的事件處理程序或行動。

451
00:24:13,000 --> 00:24:16,000
這意味著，我需要創建一些方法，我希望被稱為

452
00:24:16,000 --> 00:24:18,000
當我按下按鈕，讓我們創建一個新的方法。

453
00:24:18,000 --> 00:24:20,000
我裡面的ViewController.h。

454
00:24:20,000 --> 00:24:22,000
我需要說的方法存在。

455
00:24:22,000 --> 00:24:26,000
我需要一個連字符，因為我將要調用此視圖控制器。

456
00:24:26,000 --> 00:24:28,000
我需要給這個類型。

457
00:24:28,000 --> 00:24:31,000
“這是怎麼回事，IBAction的事情，我們在前面看到的。

458
00:24:31,000 --> 00:24:35,000
這是一個事件處理程序，所以它會返回一個IBAction，

459
00:24:35,000 --> 00:24:38,000
這是一個暗示說，到XCode

460
00:24:38,000 --> 00:24:40,000
這是我想要的東西線的東西。

461
00:24:40,000 --> 00:24:45,000
我可以給它一個名字，如buttonPressed，分號。

462
00:24:45,000 --> 00:24:48,000
>> 現在，我宣布我的班級內部的一種新方法。

463
00:24:48,000 --> 00:24:50,000
我說的這個方法存在。

464
00:24:50,000 --> 00:24:53,000
現在，讓我們的進入ViewController.m，

465
00:24:53,000 --> 00:24:56,000
讓我們說，這種方法可以做什麼。

466
00:24:56,000 --> 00:25:03,000
例如，如果我開始打字，（空）buttonPressed

467
00:25:03,000 --> 00:25:06,000
通知XCode是非常好的，對我來說自動完成。

468
00:25:06,000 --> 00:25:09,000
這真是太棒了。

469
00:25:09,000 --> 00:25:12,000
請注意這裡面的m文件，我也可以說無效，

470
00:25:12,000 --> 00:25:15,000
這是，因為這，IBAction是不實際的類型。

471
00:25:15,000 --> 00:25:19,000
它實際上包括hashtag定義的是一個空白的地方，

472
00:25:19,000 --> 00:25:22,000
再次，這只是一個提示Xcode中說：

473
00:25:22,000 --> 00:25:25,000
我想這是一個事件處理程序中，我們將看到為什麼在短短的一秒鐘。

474
00:25:25,000 --> 00:25:28,000
按下此按鈕時，我會做一些惱人的

475
00:25:28,000 --> 00:25:30,000
我想顯示一個彈出窗口。

476
00:25:30,000 --> 00:25:35,000
>> 要做到這一點，我可以創建一個新的類的實例稱為UIAlertView，

477
00:25:35,000 --> 00:25:39,000
這是一類，蘋果寫道，要顯示煩人的彈出窗口。

478
00:25:39,000 --> 00:25:43,000
我們稱這個彈出警報，我有2個步驟，記住，要創建此對象。

479
00:25:43,000 --> 00:25:46,000
我需要做的第一件事情是分配空間。

480
00:25:46,000 --> 00:25:48,000
我想的UIAlertView。

481
00:25:48,000 --> 00:25:51,000
我想分配空間。這是我的第一種方法。

482
00:25:51,000 --> 00:25:53,000
我的下一個方法是我想要初始化它，

483
00:25:53,000 --> 00:25:58,000
所以我有這個又大又長的方法，稱為initWithTitle。

484
00:25:58,000 --> 00:26:01,000
這基本上就是要控制這個彈出窗口說什麼。

485
00:26:01,000 --> 00:26:04,000
我的彈出窗口的標題可以招呼。

486
00:26:04,000 --> 00:26:08,000
這個彈出的消息是：“這是iOS的。”

487
00:26:08,000 --> 00:26:10,000
代表的事，我不知道那是什麼。

488
00:26:10,000 --> 00:26:13,000
比方說，沒什麼。

489
00:26:13,000 --> 00:26:18,000
現在的按鈕，會出現可以說是“肯定的是，”

490
00:26:18,000 --> 00:26:24,000
和我真的不希望任何其他的按鈕，讓我們刪除，並關閉支架。

491
00:26:24,000 --> 00:26:27,000
>> 好吧，我創建了一個額外的一個。我們走吧。

492
00:26:27,000 --> 00:26:30,000
這就是我如何可以創建一個新的彈出窗口。

493
00:26:30,000 --> 00:26:35,000
如果我要顯示的彈出窗口，我想調用Show方法。

494
00:26:35,000 --> 00:26:38,000
要做到這一點，我可以說警報，並顯示，

495
00:26:38,000 --> 00:26:40,000
再次，自動完成超好聽。

496
00:26:40,000 --> 00:26:42,000
如果我忘了那是什麼，如果我只輸入S，

497
00:26:42,000 --> 00:26:45,000
我在這裡可以通過滾動弄清楚它是什麼，

498
00:26:45,000 --> 00:26:48,000
過濾得很好。

499
00:26:48,000 --> 00:26:52,000
現在我創造了這個新的彈出窗口。

500
00:26:52,000 --> 00:26:55,000
我們會回來後，代表意味著什麼

501
00:26:55,000 --> 00:26:58,000
現在，我想說，我想這個方法被解僱

502
00:26:58,000 --> 00:27:01,000
當我按下按鈕，所以我要回來我的故事板，

503
00:27:01,000 --> 00:27:04,000
我想現在重視這個IBAction。

504
00:27:04,000 --> 00:27:06,000
你想要做的第一件事情就是按一下按鈕。

505
00:27:06,000 --> 00:27:08,000
當我按下這個按鈕，我想事情發生。

506
00:27:08,000 --> 00:27:10,000
我不會去，按住控制權。

507
00:27:10,000 --> 00:27:13,000
我要單擊並拖動按鈕

508
00:27:13,000 --> 00:27:15,000
在這裡，它說 - 視圖 - 控制器。

509
00:27:15,000 --> 00:27:17,000
我們可以看到，它很好地亮起來。

510
00:27:17,000 --> 00:27:22,000
>> 如果我讓我的鼠標，我現在有這個彈出，在這裡，我有一些選擇。

511
00:27:22,000 --> 00:27:24,000
其中之一是我可以註冊的事件。

512
00:27:24,000 --> 00:27:28,000
這些都是我宣布我的h文件IBActions這些方法。

513
00:27:28,000 --> 00:27:31,000
這是Xcode如何知道什麼應該出現在這個小名單，

514
00:27:31,000 --> 00:27:33,000
所以，這只是一個提示。

515
00:27:33,000 --> 00:27:37,000
如果我按下按鈕上按一下，我現在已經註冊的事件處理程序。

516
00:27:37,000 --> 00:27:41,000
在JavaScript中，我們不得不說，我有一些代碼，註冊事件處理程序。

517
00:27:41,000 --> 00:27:43,000
在Objective-C，它真的那麼容易。

518
00:27:43,000 --> 00:27:46,000
如果我運行一次

519
00:27:46,000 --> 00:27:49,000
現在當我按下按鈕時，要解僱我的事件處理程序，

520
00:27:49,000 --> 00:27:51,000
我要得到這個彈出。

521
00:27:51,000 --> 00:27:54,000
超級，超級簡單。

522
00:27:54,000 --> 00:27:57,000
>> 如果你想看到所有已經登記的事件

523
00:27:57,000 --> 00:28:00,000
上一個組成部分，如果我點擊此按鈕

524
00:28:00,000 --> 00:28:02,000
和我來這裡的右側

525
00:28:02,000 --> 00:28:05,000
第一次在這裡你可以看到我喜歡的類型的按鈕可以做的事情，

526
00:28:05,000 --> 00:28:08,000
所以如果你想那些我的“添加聯繫人”按鈕

527
00:28:08,000 --> 00:28:10,000
或什麼的。

528
00:28:10,000 --> 00:28:13,000
如果我想看到所有的事件，此按鈕

529
00:28:13,000 --> 00:28:16,000
如果我遠道而來，在這裡的右側

530
00:28:16,000 --> 00:28:19,000
在活動中，我有所有這些不同的事件，我們可以在這裡看到。

531
00:28:19,000 --> 00:28:23,000
我可以按按鈕，當我放手的按鈕，當我雙擊自來水或任何，

532
00:28:23,000 --> 00:28:26,000
我剛剛註冊的是這一事件被稱為觸摸裡面，

533
00:28:26,000 --> 00:28:29,000
說，一旦我的手指離開按鈕

534
00:28:29,000 --> 00:28:32,000
該事件要火了，這也正是剛剛發生了什麼。

535
00:28:32,000 --> 00:28:36,000
這是一種默認的按鈕被按下的事件。

536
00:28:36,000 --> 00:28:39,000
>> 有任何疑問，這麼遠嗎？

537
00:28:39,000 --> 00:28:43,000
好吧，這就是我們可以開始連接起來的東西在我們的代碼中

538
00:28:43,000 --> 00:28:46,000
進入裡面的東西，我們的接口。

539
00:28:46,000 --> 00:28:49,000
請記住我們必須做的第一件事是找到的代碼，

540
00:28:49,000 --> 00:28:54,000
然後我們有線接口的代碼，

541
00:28:54,000 --> 00:28:57,000
那是我們的第一個應用程序。

542
00:28:57,000 --> 00:29:00,000
好吧，這真是太酷了，我們創建此按鈕。

543
00:29:00,000 --> 00:29:03,000
如果我們不希望有創建一堆的屬性

544
00:29:03,000 --> 00:29:05,000
代表這些按鈕嗎？

545
00:29:05,000 --> 00:29:08,000
例如，在井字我有9個按鍵，

546
00:29:08,000 --> 00:29:11,000
它會是超級，超級討厭有拖放9倍

547
00:29:11,000 --> 00:29:14,000
或者如果我不得不做出打井81，而不是9

548
00:29:14,000 --> 00:29:17,000
，我不得不拖放81倍，這就是跛腳。

549
00:29:17,000 --> 00:29:20,000
我們能做些什麼，而不是很像一個HTML

550
00:29:20,000 --> 00:29:23,000
當我們有ID和名字一樣的東西，我們可以尋找的東西

551
00:29:23,000 --> 00:29:27,000
通過他們的ID，有一個類似的概念在iOS稱為標籤。

552
00:29:27,000 --> 00:29:31,000
>> 標記是一個唯一的數字標識符的組成部分。

553
00:29:31,000 --> 00:29:34,000
例如，如果我說這有一個標記為0，

554
00:29:34,000 --> 00:29:38,000
如果我創建一個按鈕，並給它一個標記為0，我們將看到如何做到這一點在短短的一秒鐘，

555
00:29:38,000 --> 00:29:41,000
如果我想要得到這個按鈕，我可以簡單地說，我要打電話

556
00:29:41,000 --> 00:29:45,000
viewWithTag對象上的方法，在這裡，

557
00:29:45,000 --> 00:29:48,000
self.view，它代表了當前的屏幕，例如。

558
00:29:48,000 --> 00:29:53,000
如果我打電話，viewWithTag的方法，我要拉回來的按鈕標記0。

559
00:29:53,000 --> 00:29:58,000
讓我們一起來看看這款大廈井字。

560
00:29:58,000 --> 00:30:01,000
首先，這是我的故事板。

561
00:30:01,000 --> 00:30:05,000
我已經創建了這10個UI按鈕。

562
00:30:05,000 --> 00:30:07,000
請注意，他們都是一樣的尺寸。

563
00:30:07,000 --> 00:30:11,000
如果我點擊了其中的一個，我在這裡在此右側回來

564
00:30:11,000 --> 00:30:15,000
你會看到我調整了字體在這裡，所以我做的字體有點大了，

565
00:30:15,000 --> 00:30:19,000
但我也做了我設置這個標籤。

566
00:30:19,000 --> 00:30:23,000
我說，這有一個標記為1，這是最佳的左側。

567
00:30:23,000 --> 00:30:26,000
>> 現在，如果我點擊另一個按鈕，這樣第二個，

568
00:30:26,000 --> 00:30:29,000
現在，你會看到我的標籤2。

569
00:30:29,000 --> 00:30:32,000
每個按鈕都有一個唯一的標籤，

570
00:30:32,000 --> 00:30:35,000
所以這是以後怎麼我要開始交互

571
00:30:35,000 --> 00:30:38,000
我的應用程序。

572
00:30:38,000 --> 00:30:40,000
這是所有裡面的一個視圖控制器，

573
00:30:40,000 --> 00:30:42,000
但這裡是我們所擁有的。

574
00:30:42,000 --> 00:30:44,000
我們這裡有3個屬性。

575
00:30:44,000 --> 00:30:49,000
第一個和最後一個要代表我的板子的狀態。

576
00:30:49,000 --> 00:30:53,000
基本上，這是一個數組，表示其中X和OS。

577
00:30:53,000 --> 00:30:57,000
這等人告訴我們該輪到誰了。

578
00:30:57,000 --> 00:31:01,000
你會發現，我也有這些東西在這裡。

579
00:31:01,000 --> 00:31:05,000
在此之前，當我們聲明的屬性，我們給了他們一個名字和一個類型。

580
00:31:05,000 --> 00:31:08,000
我們也可以給他們一些額外的信息。

581
00:31:08,000 --> 00:31:11,000
這第一個說非原子，這是什麼

582
00:31:11,000 --> 00:31:16,000
基本上只有一件事，永遠不會試圖訪問這個變量的時候。

583
00:31:16,000 --> 00:31:19,000
你可以做更複雜的應用程序都是多線程的，

584
00:31:19,000 --> 00:31:22,000
和做回，在Scratch我們有不同的線程，

585
00:31:22,000 --> 00:31:25,000
不同的精靈可以做不同的事情在同一時間。

586
00:31:25,000 --> 00:31:29,000
>> 如果是這樣的情況並非如此，它不是什麼，我們將著眼於，

587
00:31:29,000 --> 00:31:33,000
如果說非原子，它實際上使事情有點快。

588
00:31:33,000 --> 00:31:37,000
我們也有這樣的東西叫分配，強，或弱。

589
00:31:37,000 --> 00:31:40,000
這種分配，只是說，這是一個標準的類型。

590
00:31:40,000 --> 00:31:43,000
這是不是一個對象或者一個指針，因為這僅僅是一個布爾值，

591
00:31:43,000 --> 00:31:46,000
因此，BOOL是內置的Objective-C的。

592
00:31:46,000 --> 00:31:49,000
這是說，不要試圖做任何事情看中這裡的指針。

593
00:31:49,000 --> 00:31:51,000
這是一個普通的老定標器。

594
00:31:51,000 --> 00:31:54,000
強與弱，弱的說，其實

595
00:31:54,000 --> 00:31:57,000
我想這是被人指指點點的東西在視圖控制器。

596
00:31:57,000 --> 00:32:00,000
我不打算實際分配，或init這個我。

597
00:32:00,000 --> 00:32:04,000
Interface Builder的，當我運行的應用程序，要處理所有的初始化。

598
00:32:04,000 --> 00:32:07,000
如果我說弱者，另外一個人說將要創建此。

599
00:32:07,000 --> 00:32:09,000
如果我說強，說，我要一個

600
00:32:09,000 --> 00:32:12,000
創建此板對象，

601
00:32:12,000 --> 00:32:14,000
所以在這裡，我在這裡有更多的方法，

602
00:32:14,000 --> 00:32:18,000
例如，新的遊戲的按鈕被按下時，一個動作，

603
00:32:18,000 --> 00:32:20,000
當任何其他的按鈕被按下時，一個動作，

604
00:32:20,000 --> 00:32:23,000
等等。

605
00:32:23,000 --> 00:32:26,000
>> 我們不會得到到井字太多的邏輯，

606
00:32:26,000 --> 00:32:30,000
雖然這是非常令人興奮的，但是讓我們一起來看看

607
00:32:30,000 --> 00:32:33,000
一些我們可以做的事情，裡面的iOS。

608
00:32:33,000 --> 00:32:35,000
這種新的遊戲方法是將被解僱

609
00:32:35,000 --> 00:32:37,000
每當我按新的遊戲按鍵。

610
00:32:37,000 --> 00:32:41,000
要掛鉤，我只是過來我的故事板。

611
00:32:41,000 --> 00:32:43,000
我點擊了新的遊戲。

612
00:32:43,000 --> 00:32:47,000
如果我來這裡的右側，我可以看到，

613
00:32:47,000 --> 00:32:50,000
觸摸起來裡面是有線到的newGame的方法。

614
00:32:50,000 --> 00:32:53,000
這就是為什麼這會被解僱。

615
00:32:53,000 --> 00:32:56,000
newGame方法做一些設置。

616
00:32:56,000 --> 00:32:59,000
這是怎麼回事，說我要你清除板的狀態。

617
00:32:59,000 --> 00:33:01,000
這是一個很好的方法，可變數組。

618
00:33:01,000 --> 00:33:03,000
這是怎麼說的，現在輪到X的，

619
00:33:03,000 --> 00:33:07,000
現在，我將充分利用本viewWithTag的事情。

620
00:33:07,000 --> 00:33:11,000
>> 我知道，我的按鈕的標籤1-9，

621
00:33:11,000 --> 00:33:13,000
這是我隨意挑的東西。

622
00:33:13,000 --> 00:33:15,000
如果我要設置每個按鈕的文本是空的

623
00:33:15,000 --> 00:33:17,000
因為我剛剛開始一個新的遊戲，我不希望任何

624
00:33:17,000 --> 00:33:20,000
XS或操作系統被遺留下來的，我可以做到這一點。

625
00:33:20,000 --> 00:33:24,000
我可以說我想要的標籤，1，2，3，4等等。

626
00:33:24,000 --> 00:33:27,000
這將每次拉不同的按鈕。

627
00:33:27,000 --> 00:33:30,000
在這裡，我打算將它轉換為UIButton的。

628
00:33:30,000 --> 00:33:33,000
就像我們投int到彩車，反之亦然

629
00:33:33,000 --> 00:33:37,000
這說，我想投一個UIButton。

630
00:33:37,000 --> 00:33:40,000
這意味著此類型的將是一個UIButton *

631
00:33:40,000 --> 00:33:43,000
因為三分球，但不用擔心，他們不再害怕。

632
00:33:43,000 --> 00:33:47,000
>> 一旦我有這個按鈕，我要調用一個方法就可以了。

633
00:33:47,000 --> 00:33:50,000
這種方法被稱為setTitle forState，所以這說

634
00:33:50,000 --> 00:33:53,000
我想設置的按鈕的文本是空字符串，

635
00:33:53,000 --> 00:33:57,000
我希望它是空字符串時，它不是按。

636
00:33:57,000 --> 00:34:01,000
如果我用這個方法，我可以改變文字的按鈕

637
00:34:01,000 --> 00:34:04,000
只要有人點擊它，但我們想說的按鈕時，只是坐在那裡，

638
00:34:04,000 --> 00:34:07,000
我想是空白的文本。

639
00:34:07,000 --> 00:34:10,000
最後，我們要初始化我的板，

640
00:34:10,000 --> 00:34:12,000
我要去說，目前一切都在0，

641
00:34:12,000 --> 00:34:15,000
所以這個董事會的成員不變的是一個可變的數組，

642
00:34:15,000 --> 00:34:21,000
這意味著我可以調用AddObject方法，只是它裡面的0。

643
00:34:21,000 --> 00:34:23,000
這是發生了什麼，當我創建一個新的遊戲。

644
00:34:23,000 --> 00:34:25,000
>> 讓我們來看看另一個。

645
00:34:25,000 --> 00:34:28,000
這種方法在這裡是要被按壓的IBAction

646
00:34:28,000 --> 00:34:31,000
每次這些廣場之一被按下。

647
00:34:31,000 --> 00:34:33,000
現在我們這裡有一些井字邏輯。

648
00:34:33,000 --> 00:34:36,000
我們計算出該輪到誰了，

649
00:34:36,000 --> 00:34:39,000
此基礎上，我們要么設置一個X或O，

650
00:34:39,000 --> 00:34:43,000
但我們注意到，我們打算重用相同的事件處理程序

651
00:34:43,000 --> 00:34:45,000
每一個單一的其中一個按鈕。

652
00:34:45,000 --> 00:34:49,000
這意味著，我沒有的方法的最佳的左按鈕，

653
00:34:49,000 --> 00:34:52,000
不同的方法右下角的按鈕，但我可以做到這一點。

654
00:34:52,000 --> 00:34:54,000
這不會真的是不錯的設計。

655
00:34:54,000 --> 00:34:57,000
實際上，我要確定我在這裡做什麼

656
00:34:57,000 --> 00:35:00,000
被按下的按鈕的標記是什麼。

657
00:35:00,000 --> 00:35:04,000
您會注意到，這種打法方法接受一個參數。

658
00:35:04,000 --> 00:35:07,000
這就是所謂的發件人和發送者的發送者要

659
00:35:07,000 --> 00:35:10,000
究竟代表什麼時採取行動。

660
00:35:10,000 --> 00:35:15,000
如果我按下一個按鈕，發送者將是該UIButton的

661
00:35:15,000 --> 00:35:18,000
我按下，這樣就意味著，UIButton的

662
00:35:18,000 --> 00:35:20,000
有一個標記，因為我創建了一個標籤。

663
00:35:20,000 --> 00:35:23,000
>> 如果我想要得到的標籤，我可以簡單地說

664
00:35:23,000 --> 00:35:26,000
我想在標籤的發送者，

665
00:35:26,000 --> 00:35:28,000
，我剛剛鑄造一個UIButton。

666
00:35:28,000 --> 00:35:32,000
我碰巧知道發送者將是一個UIButton。

667
00:35:32,000 --> 00:35:34,000
它並不總是必須是一個UIButton。

668
00:35:34,000 --> 00:35:36,000
例如，我可以，我註冊了相同的事件處理程序

669
00:35:36,000 --> 00:35:38,000
 為一個用於一個按鈕，一個用於一個滑塊。

670
00:35:38,000 --> 00:35:40,000
在這種情況下，我知道他們所有的按鈕，所以我說

671
00:35:40,000 --> 00:35:43,000
我想這是一個按鈕，然後我就可以得到標籤，

672
00:35:43,000 --> 00:35:48,000
從標籤我現在知道我在裡面的電路板。

673
00:35:48,000 --> 00:35:51,000
然後，我可以簡單地設置X或O，可翻轉轉，

674
00:35:51,000 --> 00:35:54,000
檢查誰贏了，等等。

675
00:35:54,000 --> 00:35:59,000
>> 至今有任何疑問？

676
00:35:59,000 --> 00:36:02,000
好了，所有的代碼，我們在網上發布，我們不希望進入太多

677
00:36:02,000 --> 00:36:06,000
的的井字邏輯，但現在你可以看到，真正

678
00:36:06,000 --> 00:36:09,000
我們正在做的是，我們遍歷這個數組，

679
00:36:09,000 --> 00:36:13,000
因此，我們有一對夫婦的for循環在這裡，我們只是比較看

680
00:36:13,000 --> 00:36:18,000
我們有一個匹配的所有行，比賽在一列或類似的東西。

681
00:36:18,000 --> 00:36:21,000
要真正運行這個程序，如果我點擊其中一個按鈕

682
00:36:21,000 --> 00:36:24,000
玩的方法被解僱了，所以這意味著我只設置

683
00:36:24,000 --> 00:36:31,000
是X的按鈕，所以現在這個按鈕將是一個O，等等，

684
00:36:31,000 --> 00:36:35,000
所以這是我們如何開始這個單頁面應用程序進行交互。

685
00:36:35,000 --> 00:36:38,000
>> 我們將發布的代碼，可以隨意細讀，

686
00:36:38,000 --> 00:36:43,000
但現在，讓我們來談論一些應用程序，更多的不僅僅是一個頁面。

687
00:36:43,000 --> 00:36:47,000
井字令人興奮的是，大量的應用程序裡面的iOS

688
00:36:47,000 --> 00:36:50,000
這些鑽孔是一種具有多個屏幕下來的東西。

689
00:36:50,000 --> 00:36:54,000
第一個概念，我們需要談論的協議，

690
00:36:54,000 --> 00:36:57,000
協議就是一組方法

691
00:36:57,000 --> 00:36:59,000
你能答應來定義。

692
00:36:59,000 --> 00:37:02,000
如果我創建這個新的協議有2種方法，第一個，

693
00:37:02,000 --> 00:37:05,000
如果返回類型為void，我把它叫做foo的。

694
00:37:05,000 --> 00:37:07,000
它不帶任何參數。我有另一種方法。

695
00:37:07,000 --> 00:37:11,000
它返回一個int。我打電話給它吧，它需要一個參數。

696
00:37:11,000 --> 00:37:14,000
所有這一切協議，這就是所謂的SomeProtocol在這裡，

697
00:37:14,000 --> 00:37:19,000
這是一組的人可以實現的事情。

698
00:37:19,000 --> 00:37:22,000
我還沒有在本協議說什麼foo的。

699
00:37:22,000 --> 00:37:26,000
相反，我只是說如果你想，你可以foo定義。

700
00:37:26,000 --> 00:37:30,000
如果我創建一個視圖控制器或創建一個類

701
00:37:30,000 --> 00:37:33,000
我可以在這個類的承諾，以實現

702
00:37:33,000 --> 00:37:40,000
其中的一些方法，所以舉例來說，如果說<SomeProtocol>

703
00:37:40,000 --> 00:37:43,000
現在說我在做一個對您的承諾，這裡面

704
00:37:43,000 --> 00:37:50,000
這個視圖控制器類的，我會為foo和bar的定義。

705
00:37:50,000 --> 00:37:52,000
>> 這是為什麼有用嗎？

706
00:37:52,000 --> 00:37:55,000
很多內部組件的iOS利用

707
00:37:55,000 --> 00:37:58,000
設計模式叫做代表團，代表團說什麼

708
00:37:58,000 --> 00:38:01,000
是，舉例來說，如果我有一個文本框

709
00:38:01,000 --> 00:38:04,000
有我的文本框內部的一些事件，可以註冊，

710
00:38:04,000 --> 00:38:07,000
而不是創建單獨的事件，我能做些什麼，我可以說

711
00:38:07,000 --> 00:38:10,000
這個文本框的委託，將某些對象。

712
00:38:10,000 --> 00:38:13,000
當我說，這是一個代表現在這意味著，

713
00:38:13,000 --> 00:38:16,000
當有一些事件將會被解僱，在文本框中

714
00:38:16,000 --> 00:38:18,000
而不必註冊或類似的東西

715
00:38:18,000 --> 00:38:21,000
它只是要調用的方法的委託。

716
00:38:21,000 --> 00:38:24,000
例如，在裡面我有一個方法，當我按我的文本框

717
00:38:24,000 --> 00:38:27,000
完成後，在右下角的按鈕，

718
00:38:27,000 --> 00:38:30,000
等，而不是註冊的事件處理程序，我可以說是

719
00:38:30,000 --> 00:38:34,000
文本框，這裡是一個對象，我希望你調用一個方法

720
00:38:34,000 --> 00:38:37,000
每次有人按下“完成”按鈕，

721
00:38:37,000 --> 00:38:40,000
這意味著，對象必須實現某些協議

722
00:38:40,000 --> 00:38:45,000
說我答應做的按鈕操作定義，

723
00:38:45,000 --> 00:38:47,000
因為如果不定義該方法，你按了，

724
00:38:47,000 --> 00:38:49,000
那麼它會是混亂。

725
00:38:49,000 --> 00:38:55,000
>> 讓我們來看看一個例子。

726
00:38:55,000 --> 00:38:58,000
在這裡，我只是有一個文本框，

727
00:38:58,000 --> 00:39:04,000
在這裡在此右側的這個文本框的屬性之一是委託。

728
00:39:04,000 --> 00:39:06,000
這是一個屬性的類。

729
00:39:06,000 --> 00:39:09,000
我在這裡做的是我控制點擊，在這裡，我拖著這點

730
00:39:09,000 --> 00:39:13,000
到視圖控制器，並且說，現在這個文本框的委託，

731
00:39:13,000 --> 00:39:18,000
將是視圖控制器。

732
00:39:18,000 --> 00:39:20,000
這意味著，當發生某些行動，而不是登記

733
00:39:20,000 --> 00:39:25,000
我要你把它們發送到委託獨立的事件處理程序。

734
00:39:25,000 --> 00:39:28,000
現在，讓我們來看看在我的視圖控制器。

735
00:39:28,000 --> 00:39:32,000
裡面的。h文件中，我已經作出了承諾。

736
00:39:32,000 --> 00:39:36,000
我已經答應來實現本協議內的一些方法

737
00:39:36,000 --> 00:39:38,000
被稱為UITextFieldDelegate，並再次，

738
00:39:38,000 --> 00:39:42,000
這僅僅是一些列表的一些事情，我可以選擇執行。

739
00:39:42,000 --> 00:39:46,000
>> 如果我來到這裡，在我的m文件，我已經實現了這樣的一個方法。

740
00:39:46,000 --> 00:39:49,000
我把它稱為textFieldShouldReturn

741
00:39:49,000 --> 00:39:52,000
因為這是這是什麼所謂的協議內。

742
00:39:52,000 --> 00:39:57,000
現在每當我按下完成按鈕，該文本字段內

743
00:39:57,000 --> 00:40:00,000
這是發生了什麼事情被調用，所以我沒有註冊事件處理程序。

744
00:40:00,000 --> 00:40:03,000
我的委託，每次發生此事件被觸發

745
00:40:03,000 --> 00:40:08,000
這是將被調用的方法，所以，如果我來這裡我的故事板，並運行它

746
00:40:08,000 --> 00:40:11,000
而加載，我們可以看到，這是什麼做的。

747
00:40:11,000 --> 00:40:13,000
在我的屏幕上，我有兩件事情。

748
00:40:13,000 --> 00:40:16,000
我有這樣的文字欄位，我有這樣的標籤。

749
00:40:16,000 --> 00:40:19,000
我只是說，我想這個標籤的文本

750
00:40:19,000 --> 00:40:23,000
等於不管用戶鍵入的文本字段內。

751
00:40:23,000 --> 00:40:26,000
下面這一行，這裡是一個簡單的方法，我給你打電話

752
00:40:26,000 --> 00:40:29,000
在文本字段說，我希望你能隱藏鍵盤。

753
00:40:29,000 --> 00:40:33,000
這僅僅是蘋果選擇的任意方法。

754
00:40:33,000 --> 00:40:38,000
>> 同樣，在我做了什麼，我不得不將所有東西了，所以我第一次來到這裡。

755
00:40:38,000 --> 00:40:42,000
我的視圖控制器拖動到文本框中。

756
00:40:42,000 --> 00:40:46,000
我放手，我可以看到，在這裡，我可以使這個文本字段屬性

757
00:40:46,000 --> 00:40:49,000
因為在這裡的視圖控制器中，我定義了一個屬性

758
00:40:49,000 --> 00:40:52,000
這是一個IBOutlet的文本字段。

759
00:40:52,000 --> 00:40:55,000
這是說，我可以連接屬性

760
00:40:55,000 --> 00:40:59,000
我的用戶界面中的文本字段。

761
00:40:59,000 --> 00:41:03,000
現在，當我點擊這個，我可以開始輸入。

762
00:41:03,000 --> 00:41:06,000
現在，如果我點擊“完成”按鈕，這是怎麼回事火

763
00:41:06,000 --> 00:41:08,000
我現在可以響應的事件。

764
00:41:08,000 --> 00:41:10,000
事件處理程序。

765
00:41:10,000 --> 00:41:13,000
這就是我剛做的按鈕。

766
00:41:13,000 --> 00:41:15,000
有意義嗎？

767
00:41:15,000 --> 00:41:20,000
>> 這是一種設計模式，你可能會不會發現自己

768
00:41:20,000 --> 00:41:23,000
創建自己的協議，但我們知道，有些

769
00:41:23,000 --> 00:41:27,000
不同的iOS組件註冊事件以不同的方式。

770
00:41:27,000 --> 00:41:29,000
按鈕，例如，使用這些IBActions。

771
00:41:29,000 --> 00:41:32,000
文本字段，另一方面，要使用的代表。

772
00:41:32,000 --> 00:41:36,000
我們可以看到，你可以看看，裡面的所有的文件。

773
00:41:36,000 --> 00:41:41,000
順便說一下，其實有一噸重的為你的iOS內置的UI東西，

774
00:41:41,000 --> 00:41:46,000
例如，在我說在右下角

775
00:41:46,000 --> 00:41:48,000
我選擇這個文本字段。

776
00:41:48,000 --> 00:41:50,000
我這邊走了過來。

777
00:41:50,000 --> 00:41:53,000
我向下滾動了一下，返回鍵，

778
00:41:53,000 --> 00:41:56,000
我實際上可以使這一大堆的東西一樣，如果我想，說

779
00:41:56,000 --> 00:42:00,000
緊急呼叫，而不是我能做到這一點，這是完全隨機的，

780
00:42:00,000 --> 00:42:02,000
我不知道為什麼有一個內置的緊急呼叫按鈕，

781
00:42:02,000 --> 00:42:06,000
但也有，它說，在非常小的字母緊急呼叫。

782
00:42:06,000 --> 00:42:08,000
你去那裡。

783
00:42:08,000 --> 00:42:12,000
>> 絕對探討所有在iOS這些不同的選擇。

784
00:42:12,000 --> 00:42:14,000
代表任何疑問嗎？

785
00:42:14,000 --> 00:42:18,000
同樣，只是一個有趣的設計模式，你應該知道的。

786
00:42:18,000 --> 00:42:22,000
好吧，讓我們的下一代來看看在表視圖。

787
00:42:22,000 --> 00:42:26,000
表視圖是基本的項目清單，是所有的地方在iOS。

788
00:42:26,000 --> 00:42:29,000
當你翻閱您的所有聯繫人，你看

789
00:42:29,000 --> 00:42:34,000
設置頁面的事情的清單，而這種被稱為表視圖。

790
00:42:34,000 --> 00:42:37,000
在iOS上實現表視圖是非常簡單的。

791
00:42:37,000 --> 00:42:41,000
而不是下降，UIViewController的一類

792
00:42:41,000 --> 00:42:44,000
就像我們以前做之前，我們只需要簡單地說，而不是

793
00:42:44,000 --> 00:42:46,000
一個UIViewController沒有我想要做的一切，

794
00:42:46,000 --> 00:42:50,000
我說一個UITableViewController沒有我想要做的一切，

795
00:42:50,000 --> 00:42:54,000
所以，簡單地添加一些額外的東西，是完全為我們做了。

796
00:42:54,000 --> 00:42:58,000
我們需要做的很少，基本上填補空白的表內。

797
00:42:58,000 --> 00:43:02,000
>> 為了顯示一個表，我需要回答一些問題。

798
00:43:02,000 --> 00:43:06,000
我要回答的第一個問題是表中有多少段？

799
00:43:06,000 --> 00:43:08,000
當你翻閱您的聯繫人應用程序，你會發現它的種

800
00:43:08,000 --> 00:43:12,000
組織的作為，那麼你的家，你有那麼一點子標題。

801
00:43:12,000 --> 00:43:14,000
每個這些被稱為一節。

802
00:43:14,000 --> 00:43:16,000
您可能會或可能不需要這些。

803
00:43:16,000 --> 00:43:19,000
你需要做的第一件事是實現的方法

804
00:43:19,000 --> 00:43:22,000
所謂的tableView：numberOfSectionsInTableView。

805
00:43:22,000 --> 00:43:25,000
這只是簡單地返回你有多少段，

806
00:43:25,000 --> 00:43:29,000
因此，可以說，如果你有一個很大的表視圖，返回一個。

807
00:43:29,000 --> 00:43:33,000
接下來的問題是，內部監督辦公室需要知道的是你有多少行？

808
00:43:33,000 --> 00:43:36,000
例如，你正在翻閱一表視圖。

809
00:43:36,000 --> 00:43:39,000
你有一個固定數量的歌曲，你看或固定數量的接觸。

810
00:43:39,000 --> 00:43:41,000
如果你是我，當然，沒有那麼多，

811
00:43:41,000 --> 00:43:44,000
所以這是如何的iOS知道有多少細胞顯示。

812
00:43:44,000 --> 00:43:46,000
>> 同樣，這可以說是這樣回報3。

813
00:43:46,000 --> 00:43:49,000
我的表視圖中有3行。

814
00:43:49,000 --> 00:43:52,000
最後，IOS需要知道每一個細胞看起來像什麼，

815
00:43:52,000 --> 00:43:54,000
所以它實際上是做什麼的，是這裡調用此方法，

816
00:43:54,000 --> 00:43:57,000
的tableView：cellForRowAtIndexPath。

817
00:43:57,000 --> 00:44:01,000
這將調用此方法，你的表上的每一個細胞內。

818
00:44:01,000 --> 00:44:03,000
它是如何知道多少次調用它呢？

819
00:44:03,000 --> 00:44:06,000
好了，你告訴它裡面節中的行數。

820
00:44:06,000 --> 00:44:08,000
我們會打電話給我們的細胞，

821
00:44:08,000 --> 00:44:11,000
在這裡面，在這裡你可以真正喜歡做的事情

822
00:44:11,000 --> 00:44:16,000
設置文本，或者告訴你是什麼藍色的小按鈕，在右側。

823
00:44:16,000 --> 00:44:19,000
的模式，讓這些細胞，我們要使用此方法

824
00:44:19,000 --> 00:44:22,000
被稱為dequeueReusableCellWithIdentifier。

825
00:44:22,000 --> 00:44:29,000
>> Objective-C的實際上是非常有名的荒謬的長度它們的方法名稱，

826
00:44:29,000 --> 00:44:32,000
這確實是一個不錯的點的例子。

827
00:44:32,000 --> 00:44:37,000
這種方法確實是這樣的，只是說我要你給我一個細胞。

828
00:44:37,000 --> 00:44:39,000
只是iOS的事情。

829
00:44:39,000 --> 00:44:41,000
如果你有像10萬首歌曲，在你的iPod

830
00:44:41,000 --> 00:44:45,000
IOS不想要做的是分配100,000個細胞，

831
00:44:45,000 --> 00:44:48,000
因為如果你在列表頂端時，你是否真的需要分配內存

832
00:44:48,000 --> 00:44:51,000
下來是99000行的單元格？

833
00:44:51,000 --> 00:44:55,000
沒有，因為當你滾動，你可以種分配，當您去。

834
00:44:55,000 --> 00:44:57,000
這樣做是為了你。

835
00:44:57,000 --> 00:44:59,000
您不必擔心所有的愚蠢表現的東西。

836
00:44:59,000 --> 00:45:02,000
你說的是你調用這種方法dequeueReusableCellWithIdentifier，

837
00:45:02,000 --> 00:45:06,000
這說，沒關係，如果你需要，我會為你創建一個新的細胞。

838
00:45:06,000 --> 00:45:09,000
>> 但是，如果你在表的底部，你已經分配了一些細胞

839
00:45:09,000 --> 00:45:12,000
在表的頂部，你真的不會需要很快

840
00:45:12,000 --> 00:45:15,000
我給你一個，而不是分配一個新的，

841
00:45:15,000 --> 00:45:17,000
所以這是一個不錯的性能問題。

842
00:45:17,000 --> 00:45:21,000
您不必分配自己的細胞。

843
00:45:21,000 --> 00:45:23,000
這將會給你回一個細胞。

844
00:45:23,000 --> 00:45:25,000
這將返回給你一個單元格對象。

845
00:45:25,000 --> 00:45:28,000
一旦你有你可以做的東西給它的單元格對象。

846
00:45:28,000 --> 00:45:32,000
此屬性的文本標籤，您可以設置文本的單元格。

847
00:45:32,000 --> 00:45:36,000
您可以添加在右邊的箭頭或其他一些隨機的東西

848
00:45:36,000 --> 00:45:41,000
這個叫其他財產的accessoryType，等等等等。

849
00:45:41,000 --> 00:45:46,000
>> 讓我們來看看現在實際執行的表視圖。

850
00:45:46,000 --> 00:45:49,000
當我創造了這個項目

851
00:45:49,000 --> 00:45:53,000
而不是說單一視圖的應用程序其實，我這邊走了過來

852
00:45:53,000 --> 00:45:57,000
主詳細的應用程序，基本上是這樣的郵件應用程序

853
00:45:57,000 --> 00:46:01,000
在iPad上的表格視圖左側，然後在右邊的內容。

854
00:46:01,000 --> 00:46:07,000
在iPod或iPhone上，這是對應於一個單一的表視圖。

855
00:46:07,000 --> 00:46:10,000
這就是我得到了我的啟動代碼。

856
00:46:10,000 --> 00:46:13,000
>> 讓我們先來看看在情節串連圖板。

857
00:46:13,000 --> 00:46:15,000
所有這一切都為我所做的，基本上創建的。

858
00:46:15,000 --> 00:46:18,000
此導航欄給我看一個例子細胞可能看起來像，

859
00:46:18,000 --> 00:46:22,000
，我可以雙擊，更改標題。

860
00:46:22,000 --> 00:46:25,000
任何其他UI問題，我可以處理。

861
00:46:25,000 --> 00:46:27,000
頭文件看起來真的很簡單。

862
00:46:27,000 --> 00:46:30,000
與其說這是UIViewController的，我們現在說這是一個

863
00:46:30,000 --> 00:46:35,000
TableViewController，所以我們知道我們想要調用的所有表的方法。

864
00:46:35,000 --> 00:46:38,000
接下來，我想創建一個屬性的代表

865
00:46:38,000 --> 00:46:40,000
我的表裡面的東西。

866
00:46:40,000 --> 00:46:43,000
此表將任意顯示

867
00:46:43,000 --> 00:46:46,000
水果的列表，所以我需要創建一些數組

868
00:46:46,000 --> 00:46:49,000
我可以將水果。

869
00:46:49,000 --> 00:46:52,000
我的執行文件的第一件事情裡面，我想要做的

870
00:46:52,000 --> 00:46:55,000
我想確保我初始化數組。

871
00:46:55,000 --> 00:46:58,000
>> 我說的alloc初始化，創建我的果實陣列，

872
00:46:58,000 --> 00:47:03,000
，我加入到它的4件事，其中之一是更有爭議比其他3。

873
00:47:03,000 --> 00:47:06,000
而現在，我有一個數組大小為4。

874
00:47:06,000 --> 00:47:08,000
我們不停地搖晃，CS50。

875
00:47:08,000 --> 00:47:11,000
我現在有一個數組的大小為4。

876
00:47:11,000 --> 00:47:13,000
現在，我要開始回答這些問題，而實際上，

877
00:47:13,000 --> 00:47:16,000
當我創造了這個應用程序時，所有這一切都已經為我做的。

878
00:47:16,000 --> 00:47:19,000
我沒有在表視圖中輸入的節數。

879
00:47:19,000 --> 00:47:22,000
這是已經存在，而且我填補的空白。

880
00:47:22,000 --> 00:47:24,000
我有多少段？

881
00:47:24,000 --> 00:47:26,000
一。全部完成。

882
00:47:26,000 --> 00:47:28,000
我有多少行？

883
00:47:28,000 --> 00:47:31,000
嗯，我有一個行的每一個水果，所以這個數

884
00:47:31,000 --> 00:47:34,000
說有多大的數組的屬性是什麼？

885
00:47:34,000 --> 00:47:36,000
這是我有多少行。

886
00:47:36,000 --> 00:47:42,000
最後，我需要說的每一個細胞看起來像什麼？

887
00:47:42,000 --> 00:47:46,000
我要說dequeueReusableCellWithIdentifier。

888
00:47:46,000 --> 00:47:48,000
>> 同樣，這已經為我寫的。

889
00:47:48,000 --> 00:47:51,000
我沒有這樣做我自己，我要回去

890
00:47:51,000 --> 00:47:54,000
這種細胞在這個位置。

891
00:47:54,000 --> 00:47:57,000
請記住，我們可以將這個同樣的方法對每一個細胞，

892
00:47:57,000 --> 00:48:01,000
這種說法在這裡，這indexPath參數，

893
00:48:01,000 --> 00:48:03,000
說行我

894
00:48:03,000 --> 00:48:05,000
如果我說indexPath.row在這裡

895
00:48:05,000 --> 00:48:09,000
這將是0，那麼這將是1，那麼它會是2，這是，所以我知道

896
00:48:09,000 --> 00:48:11,000
我目前顯示什麼樣細胞。

897
00:48:11,000 --> 00:48:15,000
我想設置文本的單元格使用此為textLabel屬性

898
00:48:15,000 --> 00:48:19,000
裡面去我的果實陣列，並得到

899
00:48:19,000 --> 00:48:21,000
對應於每行的對象。

900
00:48:21,000 --> 00:48:24,000
如果這是一個字符串，我現在設置

901
00:48:24,000 --> 00:48:28,000
text屬性設置為一個字符串。

902
00:48:28,000 --> 00:48:30,000
我可以做的一件事。

903
00:48:30,000 --> 00:48:32,000
我也註冊了一個事件處理程序的每個細胞，

904
00:48:32,000 --> 00:48:35,000
所以，當我點擊每個單元格

905
00:48:35,000 --> 00:48:39,000
這didSelectRowAtIndexPath，這是怎麼回事打電話給我，

906
00:48:39,000 --> 00:48:42,000
通過簡單的定義，我現在可以處理發生了什麼

907
00:48:42,000 --> 00:48:46,000
當你點擊一個單元格，再一次，我們通過細胞被竊聽

908
00:48:46,000 --> 00:48:50,000
所以，我們可以重複使用相同的事件處理程序為我們所有的細胞。

909
00:48:50,000 --> 00:48:53,000
>> 再次，這是IOS是為我做的東西。

910
00:48:53,000 --> 00:48:55,000
讓我們顯示另一個惱人的彈出

911
00:48:55,000 --> 00:48:59,000
簡單地說，你挑的東西在那裡的東西

912
00:48:59,000 --> 00:49:04,000
將是該行的對象。

913
00:49:04,000 --> 00:49:10,000
當我運行這個，我要這個漂亮的表視圖

914
00:49:10,000 --> 00:49:14,000
一排這些水果，如果我點擊

915
00:49:14,000 --> 00:49:16,000
它告訴我發生了什麼事。

916
00:49:16,000 --> 00:49:21,000
有意義嗎？

917
00:49:21,000 --> 00:49:24,000
讓我們建立一個稍微複雜一點的應用程序，

918
00:49:24,000 --> 00:49:28,000
盡可能多的點擊你選擇了番茄。

919
00:49:28,000 --> 00:49:31,000
很好的情節串連圖板

920
00:49:31,000 --> 00:49:35,000
是它的不只是單獨來幫助我們設計屏幕，

921
00:49:35,000 --> 00:49:38,000
它也將幫助我們聯繫在一起，我們的整個應用程序，

922
00:49:38,000 --> 00:49:42,000
所以最終的應用程序，我們將建立新聞閱讀器這是很好的運動，

923
00:49:42,000 --> 00:49:45,000
等將有多個屏幕，這樣我就可以實際上代表

924
00:49:45,000 --> 00:49:48,000
這些多個屏幕的故事情節，

925
00:49:48,000 --> 00:49:52,000
我可以放大和我的應用程序從一個高的水平。

926
00:49:52,000 --> 00:49:55,000
>> 為了創建一個新的元素裡面我的故事板

927
00:49:55,000 --> 00:49:59,000
其實很簡單，裡面的界面生成器。

928
00:49:59,000 --> 00:50:01,000
如果我想添加另一個屏幕，例如，

929
00:50:01,000 --> 00:50:06,000
我可以先縮小與蘋果喜歡這麼多的雙指縮放，

930
00:50:06,000 --> 00:50:09,000
在這裡之前，我搜索一個按鈕

931
00:50:09,000 --> 00:50:12,000
我和拖放一個按鈕

932
00:50:12,000 --> 00:50:15,000
如果我要創建一個新的畫面，我可以實際上只是拖動和下降

933
00:50:15,000 --> 00:50:19,000
整個視圖控制器，所以如果我挑了這個，把它在這裡，

934
00:50:19,000 --> 00:50:23,000
嘿，還有另一個屏幕，所以現在使用同樣的故事板文件

935
00:50:23,000 --> 00:50:26,000
我可以有我的應用程序內的所有的畫面，我可以縮小

936
00:50:26,000 --> 00:50:28,000
看看它們如何相互作用。

937
00:50:28,000 --> 00:50:32,000
這些還沒有互動。

938
00:50:32,000 --> 00:50:36,000
這2個屏幕互動的方式，就是你定義的關係。

939
00:50:36,000 --> 00:50:39,000
基本上你可以說這屏幕，當您按下此按鈕時，

940
00:50:39,000 --> 00:50:42,000
我希望你能滑動到這個新的屏幕。

941
00:50:42,000 --> 00:50:44,000
這意味著有這種關係

942
00:50:44,000 --> 00:50:46,000
 第一屏和第二屏。

943
00:50:46,000 --> 00:50:49,000
你會基本上是一個箭頭，從該按鈕的第二個屏幕

944
00:50:49,000 --> 00:50:53,000
他說，當你按下這個按鈕時，這就是我想要去的地方。

945
00:50:53,000 --> 00:50:57,000
就像我們控制點擊和拖動來定義這些網點

946
00:50:57,000 --> 00:51:01,000
我們要到做同樣的事情，定義這些segues的。

947
00:51:01,000 --> 00:51:05,000
>> 我們將看到一個例子，在我們實際過渡

948
00:51:05,000 --> 00:51:08,000
從一個屏幕到另一個iOS是不夠好，調用此方法

949
00:51:08,000 --> 00:51:11,000
被稱為prepareForSegue，這是我們可以開始

950
00:51:11,000 --> 00:51:14,000
將數據從一個應用程序到另一個。

951
00:51:14,000 --> 00:51:17,000
在這個例子中，我們將要看看它基本上允許我們

952
00:51:17,000 --> 00:51:20,000
過濾棒球隊的聯賽和部門。

953
00:51:20,000 --> 00:51:23,000
例如，當我選擇一個聯賽，我想過渡

954
00:51:23,000 --> 00:51:25,000
我的下一個屏幕，在那裡我可以顯示所有的部門

955
00:51:25,000 --> 00:51:27,000
該聯盟或所有不同的團隊。

956
00:51:27,000 --> 00:51:31,000
我需要發送的隊伍，你應該顯示該屏幕。

957
00:51:31,000 --> 00:51:35,000
要做到這一點，我要採取這種方法的好處在這裡。

958
00:51:35,000 --> 00:51:39,000
>> 最後，只是一個隨機點在iOS上。

959
00:51:39,000 --> 00:51:41,000
如果你要存儲的數據是這東西叫做核心數據，

960
00:51:41,000 --> 00:51:44,000
這實際上是一種複雜的工作。

961
00:51:44,000 --> 00:51:47,000
您也可以使用SQL來存儲數據，

962
00:51:47,000 --> 00:51:51,000
再次，是好的，但一種更複雜的一面工作，

963
00:51:51,000 --> 00:51:55,000
但iOS也支持這些屬性列表非常酷的事情，

964
00:51:55,000 --> 00:52:00,000
和財產清單僅僅是一個文件，該文件表示鍵值對。

965
00:52:00,000 --> 00:52:03,000
您定義的鍵的列表，和你說，這個鍵是一個數組。

966
00:52:03,000 --> 00:52:06,000
此鍵是一個字符串，基本上什麼可以做，

967
00:52:06,000 --> 00:52:10,000
在JSON中，你可以做裡面的一個屬性列表，

968
00:52:10,000 --> 00:52:14,000
，所以這真的很好，讓我們能有一些數據。

969
00:52:14,000 --> 00:52:18,000
例如，我有這Teams.plist，我創建了。

970
00:52:18,000 --> 00:52:22,000
我創建了一個新的plist文件，我可以向下鑽取。

971
00:52:22,000 --> 00:52:26,000
這是一個字典，這是一個字典，這些都是字符串，

972
00:52:26,000 --> 00:52:30,000
所以這是一個很好的圖形表示的JSON文件

973
00:52:30,000 --> 00:52:33,000
或只是一組鍵值對，

974
00:52:33,000 --> 00:52:37,000
所以這是，我會與我的應用程序內的數據。

975
00:52:37,000 --> 00:52:40,000
>> 讓我們先來這裡。我們現在有更多的文件。

976
00:52:40,000 --> 00:52:44,000
不過，讓我們先來這裡的腳本。

977
00:52:44,000 --> 00:52:48,000
其實，故事情節在這裡，如果我能縮小

978
00:52:48,000 --> 00:52:51,000
現在我們可以看到，這是我的應用程序的流量。

979
00:52:51,000 --> 00:52:53,000
我首先要在此屏幕上開始。

980
00:52:53,000 --> 00:52:55,000
我要向下鑽取到這個屏幕，

981
00:52:55,000 --> 00:52:58,000
，我會深入到這個屏幕，我們可以在這裡看到的，如果我種

982
00:52:58,000 --> 00:53:04,000
移動這些後，我們可以從這裡到這裡的箭頭，

983
00:53:04,000 --> 00:53:08,000
我定義箭頭的方式，如果我在一點點放大，

984
00:53:08,000 --> 00:53:12,000
如果我過來到這個視圖控制器，

985
00:53:12,000 --> 00:53:16,000
這裡是一個細胞，我想說的是，當你點擊一個細胞

986
00:53:16,000 --> 00:53:18,000
我希望你能滑動到另一個屏幕。

987
00:53:18,000 --> 00:53:21,000
我可以簡單地按住控制，

988
00:53:21,000 --> 00:53:26,000
多一點點滾動，按住控制，拖動該單元格，並放手。

989
00:53:26,000 --> 00:53:30,000
>> 在這裡，我們說什麼的過渡要使用的呢？

990
00:53:30,000 --> 00:53:32,000
你想使用該幻燈片的事情，這就是所謂的推嗎？

991
00:53:32,000 --> 00:53:34,000
你想從下往上滑動嗎？

992
00:53:34,000 --> 00:53:36,000
這就是所謂的模式。

993
00:53:36,000 --> 00:53:40,000
當我點擊其中之一，它會為我作出這樣的箭頭，

994
00:53:40,000 --> 00:53:44,000
這意味著，其實我已經會發生什麼，當我按下這個按鈕，圖形化的處理。

995
00:53:44,000 --> 00:53:48,000
我沒有寫任何代碼就可以從一個屏幕上滑動到下一個。

996
00:53:48,000 --> 00:53:51,000
我定義的界面生成器，這在視覺上內。

997
00:53:51,000 --> 00:53:55,000
如果我點擊這個箭頭，我們可以看到，我給了這東西的名稱。

998
00:53:55,000 --> 00:53:59,000
我把它叫做的showDivisions，這是使我可以知道

999
00:53:59,000 --> 00:54:03,000
發生的轉變是什麼，我們就會明白為什麼在短短幾秒鐘之內。

1000
00:54:03,000 --> 00:54:06,000
這就是我在我的應用程序的不同屏幕有線。

1001
00:54:06,000 --> 00:54:09,000
如果這是一個按鈕，例如，而不是表視圖，

1002
00:54:09,000 --> 00:54:11,000
我可以控制的按鈕上單擊，拖動到下一個屏幕，

1003
00:54:11,000 --> 00:54:16,000
這就是我可以做導航的方式。

1004
00:54:16,000 --> 00:54:19,000
>> 真的很快，如果我們到MasterViewController來，

1005
00:54:19,000 --> 00:54:22,000
再次，我們只是要定義的東西的清單

1006
00:54:22,000 --> 00:54:26,000
將顯示在表視圖。

1007
00:54:26,000 --> 00:54:29,000
在這裡，我說我要你把那個plist文件，

1008
00:54:29,000 --> 00:54:32,000
我希望你能加載它到一個字典，

1009
00:54:32,000 --> 00:54:35,000
一旦你有字典，我會再回答這些同樣的問題。

1010
00:54:35,000 --> 00:54:37,000
這裡的節數。

1011
00:54:37,000 --> 00:54:41,000
其中，有一排為每一個聯盟，每個單元格中的文本

1012
00:54:41,000 --> 00:54:46,000
應該是第一個，第一個聯賽，聯賽第二，等等。

1013
00:54:46,000 --> 00:54:51,000
最後，我要使用這種方法，我們只是看到了被稱為prepareForSegue，

1014
00:54:51,000 --> 00:54:54,000
這是方法，將被解僱，當我點擊

1015
00:54:54,000 --> 00:54:57,000
在那些行之一，因此激活該過渡

1016
00:54:57,000 --> 00:54:59,000
我設立的箭頭。

1017
00:54:59,000 --> 00:55:02,000
這是說，我可以有多個

1018
00:55:02,000 --> 00:55:05,000
從一個到另一個屏幕的關係。

1019
00:55:05,000 --> 00:55:08,000
如果我有2個按鈕，每個按鈕帶你到不同的畫面

1020
00:55:08,000 --> 00:55:10,000
我要為每個按鈕有2 segues，1。

1021
00:55:10,000 --> 00:55:14,000
但此prepareForSegue是，再次，要被重用

1022
00:55:14,000 --> 00:55:17,000
對於每個不同的關係，因此，這意味著，我需要一種方法

1023
00:55:17,000 --> 00:55:21,000
確定，如果按下第一個按鈕或按下第二個按鈕。

1024
00:55:21,000 --> 00:55:25,000
>> 還記得當我給Segue公司的名稱，這showDivisions，

1025
00:55:25,000 --> 00:55:29,000
這就是我現在知道，這是SEGUE被激活。

1026
00:55:29,000 --> 00:55:32,000
我想要做的就是我想說的

1027
00:55:32,000 --> 00:55:35,000
我想弄清楚什麼我只是打，

1028
00:55:35,000 --> 00:55:38,000
等拿到，我可以說，我要為選定的行的indexPath，

1029
00:55:38,000 --> 00:55:42,000
記得indexPath只是說，我只是點擊，

1030
00:55:42,000 --> 00:55:47,000
然後我想說，我想弄清楚我要去的地方。

1031
00:55:47,000 --> 00:55:50,000
這的destinationViewController，這是一個財產的SEGUE。

1032
00:55:50,000 --> 00:55:53,000
這就是我要的畫面，

1033
00:55:53,000 --> 00:55:56,000
所以我知道我要的屏幕被稱為DivisionsViewController

1034
00:55:56,000 --> 00:55:59,000
因為我創造了這個類，

1035
00:55:59,000 --> 00:56:02,000
所以現在如果我說d.divisions

1036
00:56:02,000 --> 00:56:06,000
我現在設置的視圖控制器的屬性，我去。

1037
00:56:06,000 --> 00:56:10,000
這是我發送的數據從一個屏幕到另一個屏幕。

1038
00:56:10,000 --> 00:56:13,000
>> 只要看看這DivisionsViewController的

1039
00:56:13,000 --> 00:56:16,000
你可以在這裡看到。h文件

1040
00:56:16,000 --> 00:56:20,000
還有就是物業部門，這就是我基本上填充，

1041
00:56:20,000 --> 00:56:25,000
所以這就是我知道我顯示對應的部門

1042
00:56:25,000 --> 00:56:28,000
我點擊的同盟，並再次，

1043
00:56:28,000 --> 00:56:31,000
實際的表視圖看起來幾乎是一樣的，只是回答這些

1044
00:56:31,000 --> 00:56:34,000
3個簡單的問題，以及確定

1045
00:56:34,000 --> 00:56:37,000
會發生什麼，當你移動到下一個屏幕。

1046
00:56:37,000 --> 00:56:40,000
只是一對夫婦，其他的東西在這裡。

1047
00:56:40,000 --> 00:56:43,000
您會發現在頂部，而不是在這裡說的＃include

1048
00:56:43,000 --> 00:56:45,000
我現在說的＃import。

1049
00:56:45,000 --> 00:56:47,000
這僅僅是一個Objective-C的東西。

1050
00:56:47,000 --> 00:56:52,000
的進口基本上是一個更好的版本包括，

1051
00:56:52,000 --> 00:56:57,000
例如，我們需要知道這個類是什麼，

1052
00:56:57,000 --> 00:57:00,000
這樣我就可以不只是說DivisionsViewController的。

1053
00:57:00,000 --> 00:57:05,000
如果我們不包括h​​ashtag standardio.c內。c文件

1054
00:57:05,000 --> 00:57:07,000
編譯器不知道printf的是什麼。

1055
00:57:07,000 --> 00:57:12,000
同樣，如果我不導入DivisionsViewController

1056
00:57:12,000 --> 00:57:16,000
編譯器真的不知道什麼DivisionsViewController的。

1057
00:57:16,000 --> 00:57:19,000
只要確保這裡面不同的m文件，確保導入的

1058
00:57:19,000 --> 00:57:25,000
對應的。h文件，使編譯器知道這是怎麼回事。

1059
00:57:25,000 --> 00:57:31,000
>> 最後，什麼蘋果最終沒有被使用Web視圖顯示一些數據，

1060
00:57:31,000 --> 00:57:35,000
一個web視圖對象，在其中您可以嵌入

1061
00:57:35,000 --> 00:57:37,000
您的應用程序內部的一個小的web瀏覽器。

1062
00:57:37,000 --> 00:57:40,000
所有你需要做的是提供一個URL到您的網頁瀏覽器，

1063
00:57:40,000 --> 00:57:43,000
所以我想去mlb.mlb.com，

1064
00:57:43,000 --> 00:57:46,000
這是怎麼了，我可以訪問的主頁每個團隊，

1065
00:57:46,000 --> 00:57:49,000
通過此URL

1066
00:57:49,000 --> 00:57:52,000
的web視圖可以顯示這對我來說，我可以瀏覽周圍，

1067
00:57:52,000 --> 00:58:01,000
模擬器是在使用中的一個。

1068
00:58:01,000 --> 00:58:03,000
現在，這是從我的plist。

1069
00:58:03,000 --> 00:58:07,000
如果我點擊這個來自我的plist，滑動處理

1070
00:58:07,000 --> 00:58:09,000
定義這些segues。

1071
00:58:09,000 --> 00:58:12,000
我點擊一多，

1072
00:58:12,000 --> 00:58:15,000
現在這裡是我的UIWebView的，所以就像

1073
00:58:15,000 --> 00:58:19,000
這裡的網站，我只是嵌入式的URL，

1074
00:58:19,000 --> 00:58:21,000
我沒有處理什麼瘋狂的。

1075
00:58:21,000 --> 00:58:24,000
這是如何顯示的Web頁面。

1076
00:58:24,000 --> 00:58:27,000
之類的東西這回按鈕，在這裡也給我

1077
00:58:27,000 --> 00:58:33,000
完全免費的，因為我已​​經定義了這些關係segues。

1078
00:58:33,000 --> 00:58:37,000
>> 有什麼問題嗎？是啊。

1079
00:58:37,000 --> 00:58:40,000
[學生]因此，當你使用alloc，你永遠不會有免費的什麼？

1080
00:58:40,000 --> 00:58:43,000
沒錯，當你調用alloc和init，你沒有釋放它。

1081
00:58:43,000 --> 00:58:46,000
IOS會為你處理所有這一切。

1082
00:58:46,000 --> 00:58:51,000
這是美妙的，而你沒有違反任何規則。是啊。

1083
00:58:51,000 --> 00:58:54,000
[學生]：如果你有更多的球隊，可以在屏幕上顯示，

1084
00:58:54,000 --> 00:58:58,000
它會自動有一個滾動的選項，或者是，你需要添加的東西嗎？

1085
00:58:58,000 --> 00:59:01,000
沒錯，如果我有更多的球隊，例如，它會自動處理

1086
00:59:01,000 --> 00:59:04,000
對我來說，所有的性能問題的滾動

1087
00:59:04,000 --> 00:59:08,000
巨大的表也完全為我處理。

1088
00:59:08,000 --> 00:59:11,000
>> 其他問題嗎？

1089
00:59:11,000 --> 00:59:13,000
所有這些代碼將被發布。

1090
00:59:13,000 --> 00:59:16,000
我們種更微小的細節，掩蓋了一點點，

1091
00:59:16,000 --> 00:59:19,000
但諸如此類的web視圖設置一些屬性

1092
00:59:19,000 --> 00:59:22,000
只是事情，你可以通過瀏覽蘋果的文檔，

1093
00:59:22,000 --> 00:59:24,000
這是真的，真的很好的佈局。

1094
00:59:24,000 --> 00:59:27,000
他們有很多的示例應用程序和示例用法

1095
00:59:27,000 --> 00:59:34,000
不同的API，所以肯定細讀如果可以的話。

1096
00:59:34,000 --> 00:59:36,000
只是一些有用的鏈接，你可能想看一看。

1097
00:59:36,000 --> 00:59:38,000
這些都是一些有用的文檔指南。

1098
00:59:38,000 --> 00:59:41,000
網址是巨大的，所以他們縮短。

1099
00:59:41,000 --> 00:59:44,000
第一個是整個庫文件。

1100
00:59:44,000 --> 00:59:46,000
很少有搜索欄，所以如果你開始輸入按鈕

1101
00:59:46,000 --> 00:59:50,000
它會開始給你所有的信息，所有的事情，你可以用一個按鈕。

1102
00:59:50,000 --> 00:59:53,000
我還包含了表視圖編程指南“。

1103
00:59:53,000 --> 00:59:56,000
它可以處理更詳細的表視圖，

1104
00:59:56,000 --> 01:00:00,000
做這樣的事情如何動態地添加單元格或編輯單元格或刪除。

1105
01:00:00,000 --> 01:00:02,000
>> 有大量的示例應用程序從蘋果公司會告訴你如何做到這一點，

1106
01:00:02,000 --> 01:00:05,000
終於，這最後一個是人機界面指南，

1107
01:00:05,000 --> 01:00:09,000
這是基本的UI組件的一些討論，

1108
01:00:09,000 --> 01:00:12,000
這樣的話不使一個按鈕，4個像素，4個像素。

1109
01:00:12,000 --> 01:00:15,000
這是一個壞主意，和其他的東西，蘋果想要你做的事

1110
01:00:15,000 --> 01:00:18,000
鼓勵良好的設計。

1111
01:00:18,000 --> 01:00:23,000
>> 最後還有什麼問題之前，我們完成了嗎？

1112
01:00:23,000 --> 01:00:27,000
好了，肯定會覺得 - 我們有特殊的標籤上討論。

1113
01:00:27,000 --> 01:00:30,000
我們將有一個iOS之一，所以肯定會覺得自由利用這一點。

1114
01:00:30,000 --> 01:00:34,000
如果你想與你的同學對項目工作

1115
01:00:34,000 --> 01:00:37,000
或幫助找出一些隨機的iOS的東西

1116
01:00:37,000 --> 01:00:40,000
隨時給我發電子郵件，絕對仔細閱讀所有網上的代碼，因為

1117
01:00:40,000 --> 01:00:43,000
的利益的時候，我們只是在掩飾了一種更

1118
01:00:43,000 --> 01:00:45,000
細粒度細節的東西。

1119
01:00:45,000 --> 01:00:47,000
但是，如果沒有，那麼在您的iOS項目，好運氣，我希望我們能有

1120
01:00:47,000 --> 01:00:53,000
在App Store中的應用程序的大量湧入。

1121
01:00:53,000 --> 01:00:56,000
[CS50.TV]