1
00:00:00,000 --> 00:00:11,420

2
00:00:11,420 --> 00:00:13,590
>> 天宇劉：哎，怎麼是
它會大家？

3
00:00:13,590 --> 00:00:20,250
這是iOS應用
對目標C研討會編程。

4
00:00:20,250 --> 00:00:21,520
我的名字是劉天宇。

5
00:00:21,520 --> 00:00:26,114
我是一名大三洛厄爾現在，
集中在計算機科學。

6
00:00:26,114 --> 00:00:28,030
因此，在這個研討會上，我
要教你們

7
00:00:28,030 --> 00:00:30,770
如何使一個應用程序，一點點。

8
00:00:30,770 --> 00:00:33,030
耶，興奮吧。

9
00:00:33,030 --> 00:00:36,790
>> 所以，之前，我們甚至開始跳水
到實際編程方面，

10
00:00:36,790 --> 00:00:41,840
讓我們真的非常快說說
你為什麼會想建立一個iOS應用程序？

11
00:00:41,840 --> 00:00:43,940
為什麼如此的iOS真棒？

12
00:00:43,940 --> 00:00:47,250
因此，第一個問題，在第一
事情是相當真棒對我們來說，

13
00:00:47,250 --> 00:00:51,190
尤其是作為CS50
學生，是的iOS

14
00:00:51,190 --> 00:00:55,860
使用目的C.嗯，有
一種新的語言叫做雨燕，

15
00:00:55,860 --> 00:00:58,260
但我們不打算
使用，在本次研討會。

16
00:00:58,260 --> 00:01:01,540
如果你有興趣斯威夫特，有
是一個關於獨立的研討會。

17
00:01:01,540 --> 00:01:05,590
但目標C基本上
C.含義的一個超集

18
00:01:05,590 --> 00:01:10,230
在C使用一切可以
翻譯成目標C

19
00:01:10,230 --> 00:01:11,630
很容易。

20
00:01:11,630 --> 00:01:15,730
>> 正如你可能會看到後，確實
有一些非常基本的語法，是

21
00:01:15,730 --> 00:01:19,790
基本上完全一樣，
C和Objective C。所以，

22
00:01:19,790 --> 00:01:22,860
既然你已經採取CS50
了這一步，你已經

23
00:01:22,860 --> 00:01:26,500
知道目標C，至少40％。

24
00:01:26,500 --> 00:01:30,720
此外，蘋果公司有一個非常
強大的API為iOS。

25
00:01:30,720 --> 00:01:33,750
有很多很瘋狂的
東西，你可以用它做。

26
00:01:33,750 --> 00:01:36,760
其中之一是有人
實際上創造了一個iOS應用

27
00:01:36,760 --> 00:01:40,600
用於控制汽車，其中
是非常有趣的。

28
00:01:40,600 --> 00:01:42,610
可能是直升機更精彩。

29
00:01:42,610 --> 00:01:47,020
但是，這是多麼強大
iOS的API即可。

30
00:01:47,020 --> 00:01:49,340
>> 正如你可能有
想通了，現在，

31
00:01:49,340 --> 00:01:53,000
堆棧溢出大概是一
最重要的在線資源

32
00:01:53,000 --> 00:01:54,250
提供給您。

33
00:01:54,250 --> 00:01:58,090
而好消息，對於每一個
單一的問題，你都不可能

34
00:01:58,090 --> 00:02:01,840
想同時建立你的
在目標C最終的項目，

35
00:02:01,840 --> 00:02:05,910
有可能是一個堆棧溢出的答案。

36
00:02:05,910 --> 00:02:07,420
這只是真棒。

37
00:02:07,420 --> 00:02:12,780
除此之外，
iOS的是一個真正的平台

38
00:02:12,780 --> 00:02:16,260
在這裡你可以達到一個巨大的
觀眾毫不費力。

39
00:02:16,260 --> 00:02:20,170
它不喜歡的Andr​​oid，在那裡
一切都非常零散。

40
00:02:20,170 --> 00:02:22,540
>> 一切的iOS是統一的。

41
00:02:22,540 --> 00:02:25,920
只要您創建
對於iPhone的應用程序，

42
00:02:25,920 --> 00:02:31,260
你可以很容易端口到iPad，
iPad的迷你型，或不同的iPhone尺寸。

43
00:02:31,260 --> 00:02:33,050
這些都是真的很方便。

44
00:02:33,050 --> 00:02:36,430
它只是真的好
為打動你的朋友。

45
00:02:36,430 --> 00:02:38,920
你可以只持有iPhone
告訴你的朋友嘿嘿，

46
00:02:38,920 --> 00:02:40,250
這是應用程序，我做。

47
00:02:40,250 --> 00:02:43,860
你可以這樣做，對於任何
桌面應用程序，這是很好的。

48
00:02:43,860 --> 00:02:48,870
>> 好了，現在讓我們真正得到
成目標語言C.

49
00:02:48,870 --> 00:02:52,910
那麼，我們為什麼不先從
一些非常基本的語法。

50
00:02:52,910 --> 00:02:57,410
正如我之前提到的目標
C時的C的基本上是一個超集

51
00:02:57,410 --> 00:03:01,860
所以很多基本的語法都
實際上完全相同。

52
00:03:01,860 --> 00:03:06,150
聲明一個變量，
加上兩個變量在一​​起

53
00:03:06,150 --> 00:03:09,440
正是因為我們的馬里奧已經完成。

54
00:03:09,440 --> 00:03:11,140
什麼是新來的。

55
00:03:11,140 --> 00:03:17,370
>> 同樣，房客for循環
和條件也是相同的。

56
00:03:17,370 --> 00:03:22,370
你可以做一個循環，你
已經做了馬里奧[聽不清]。

57
00:03:22,370 --> 00:03:26,280
你可以做條件
正如你

58
00:03:26,280 --> 00:03:29,240
一直在做以前的P組。

59
00:03:29,240 --> 00:03:33,400
然而，目標C
不完全是C，

60
00:03:33,400 --> 00:03:36,640
並有東西，
是種奇怪的了。

61
00:03:36,640 --> 00:03:42,340
>> 第一種是，當你
做C語言編程，你通常打電話

62
00:03:42,340 --> 00:03:46,310
包括，然後一個庫名。

63
00:03:46,310 --> 00:03:49,860
但在目標C調用的進口。

64
00:03:49,860 --> 00:03:53,100
基本上說的功能，
只是叫法不同。

65
00:03:53,100 --> 00:03:55,940
和字符串
實際上有點怪異。

66
00:03:55,940 --> 00:03:58,250
你可以看到，第一
這是種奇怪的事情

67
00:03:58,250 --> 00:04:04,190
是，你有一個漂亮的weird--
sorry--你有一個非常奇怪的NS

68
00:04:04,190 --> 00:04:04,960
簽在這裡。

69
00:04:04,960 --> 00:04:07,452

70
00:04:07,452 --> 00:04:09,160
第二件事
這是一種奇怪的

71
00:04:09,160 --> 00:04:14,090
在你之前有一個at符號
實際上宣告字符串。

72
00:04:14,090 --> 00:04:19,209
因此，在標誌的基本意義
一個字符串不僅是字符串，

73
00:04:19,209 --> 00:04:20,880
它實際上是一個對象。

74
00:04:20,880 --> 00:04:22,780
我們要解釋
後來所以不要

75
00:04:22,780 --> 00:04:25,800
恐慌，如果你不這樣做
明白這意味著什麼。

76
00:04:25,800 --> 00:04:29,980
並打印到控制台是一點點
因為不同的C語言，我們調用printf，

77
00:04:29,980 --> 00:04:33,350
但在目標C，我們稱之為[聽不清]。

78
00:04:33,350 --> 00:04:35,640
>> 你可能想知道那是什麼。

79
00:04:35,640 --> 00:04:38,070
這基本上是printf的，
只是不同的語言。

80
00:04:38,070 --> 00:04:41,370
完全相同的用法，
完全相同的功能。

81
00:04:41,370 --> 00:04:44,060
好吧，事實證明
Objective C的實際

82
00:04:44,060 --> 00:04:50,040
有NS前綴幾乎
的一切，每一個基本數據類型，

83
00:04:50,040 --> 00:04:52,690
的NSString，NSArray的，NSDictionary的。

84
00:04:52,690 --> 00:04:56,340
的原因是納秒
實際上代表下一步，

85
00:04:56,340 --> 00:04:59,980
這是一個公司，
史蒂夫·喬布斯已經成立，

86
00:04:59,980 --> 00:05:03,960
這是一個公司，其中
語言Objective C的誕生。

87
00:05:03,960 --> 00:05:06,140
因此，這基本上是傳統。

88
00:05:06,140 --> 00:05:09,010
我知道這是一個有點
怪異，但它是蘋果。

89
00:05:09,010 --> 00:05:16,840
>> 所以，一些甚至怪異
比是一個函數聲明。

90
00:05:16,840 --> 00:05:22,600
這與我們非常不同的
看到C，因為在這裡它實際上

91
00:05:22,600 --> 00:05:25,190
看起來並不像C了。

92
00:05:25,190 --> 00:05:28,810
你有什麼這裡 - 由
這樣，這不是一個小點，

93
00:05:28,810 --> 00:05:30,690
這是一個負號。

94
00:05:30,690 --> 00:05:36,440
你有一個減號括號
無效，那麼函數名。

95
00:05:36,440 --> 00:05:38,450
遠的不說，如果我們
有你好世界，那麼

96
00:05:38,450 --> 00:05:42,820
返回類型是無效
因為我們沒有什麼回報。

97
00:05:42,820 --> 00:05:44,680
>> 什麼才真不可思議
就是當你

98
00:05:44,680 --> 00:05:49,580
具有一個以上的參數
通入一個相同的功能

99
00:05:49,580 --> 00:05:53,870
將是很奇怪的，如下圖所示。

100
00:05:53,870 --> 00:05:58,230
我們有一個方法名，
所謂addInt為[聽不清]

101
00:05:58,230 --> 00:06:00,370
我們正在傳遞一個參數。

102
00:06:00,370 --> 00:06:05,170
但在那之後，我們有
更多的方法名與調用。

103
00:06:05,170 --> 00:06:08,500
經與我們傳遞
第二個參數。

104
00:06:08,500 --> 00:06:11,940
這實際上是一個有點怪異，
但所有這些函數聲明

105
00:06:11,940 --> 00:06:14,770
遵循相同的模式，因為這。

106
00:06:14,770 --> 00:06:17,450
>> 我們有一個減號開始。

107
00:06:17,450 --> 00:06:21,550
減號可能是一個加號
有時是基於什麼樣的方法

108
00:06:21,550 --> 00:06:22,340
就是它了。

109
00:06:22,340 --> 00:06:25,000
方法基本上
另一名功能。

110
00:06:25,000 --> 00:06:26,760
我們要去
解釋說，以後當

111
00:06:26,760 --> 00:06:30,580
我們談論的對象
面向對象編程。

112
00:06:30,580 --> 00:06:34,300
您首先確定回歸
鍵入括號內，

113
00:06:34,300 --> 00:06:37,450
之後出現的方法名。

114
00:06:37,450 --> 00:06:40,310
你傳遞一個參數。

115
00:06:40,310 --> 00:06:44,750
如果你有多個參數
需要延長的方法名稱

116
00:06:44,750 --> 00:06:46,770
基本上寫更多的東西在這裡。

117
00:06:46,770 --> 00:06:48,090
>> 它可以是任何你想要的。

118
00:06:48,090 --> 00:06:50,140
在我們的情況下，它是用。

119
00:06:50,140 --> 00:06:56,160
但你可以說結束，或或或
ABC完整的酒吧，任何你想要的。

120
00:06:56,160 --> 00:06:59,500
然後你之後
傳遞參數b。

121
00:06:59,500 --> 00:07:01,750
這是一個很奇怪
會展但我們

122
00:07:01,750 --> 00:07:05,800
要明白為什麼蘋果要
要做到這一點非常快。

123
00:07:05,800 --> 00:07:10,530
那麼，你如何調用函數？

124
00:07:10,530 --> 00:07:15,520
調用目標函數
C也從不同C.

125
00:07:15,520 --> 00:07:18,170
>> 事實上，調用
在Objective C函數

126
00:07:18,170 --> 00:07:21,030
更像是你與人交談。

127
00:07:21,030 --> 00:07:27,030
在這裡，我們有自我，這
被稱作一個對象。

128
00:07:27,030 --> 00:07:33,830
你基本上說的是
反對自我說的“Hello World！”

129
00:07:33,830 --> 00:07:36,830
這是如何調用該函數。

130
00:07:36,830 --> 00:07:41,690
對象和方法名
彼此結合。

131
00:07:41,690 --> 00:07:49,600
這是怪異的擴展，其中
為方法名真正的用武之地。

132
00:07:49,600 --> 00:07:52,150
>> 讓我們來看看第二個例子。

133
00:07:52,150 --> 00:07:56,780
我們只是定義了一個名為方法
addInt用等等等等等等。

134
00:07:56,780 --> 00:08:00,066
因此，在這種情況下，當你調用
具體[？消息？]這是怎麼回事

135
00:08:00,066 --> 00:08:02,035
看起來像自我addInt：用10：2。

136
00:08:02,035 --> 00:08:05,410

137
00:08:05,410 --> 00:08:08,070
這聽起來像英語。

138
00:08:08,070 --> 00:08:11,980
雖然功能
函數的聲明是怪異，

139
00:08:11,980 --> 00:08:15,600
對目標C的點
方法聲明的模式，

140
00:08:15,600 --> 00:08:18,830
是，當你在呼喚
的函數或方法

141
00:08:18,830 --> 00:08:21,980
它聽起來像實際英語。

142
00:08:21,980 --> 00:08:25,270
所以這是非常直觀的
一旦你進入它。

143
00:08:25,270 --> 00:08:28,740
>> 特別是在這種情況下，
在那裡你可以基本上

144
00:08:28,740 --> 00:08:33,010
看到函數名
排序記錄本身。

145
00:08:33,010 --> 00:08:35,390
你不需要任何
更多的解釋，看看

146
00:08:35,390 --> 00:08:42,770
究竟發生了什麼
只有一個參數做。

147
00:08:42,770 --> 00:08:48,470
超越，讓我們談一點
關於面向對象的編程位。

148
00:08:48,470 --> 00:08:52,160
面向對象編程
基本程序之一

149
00:08:52,160 --> 00:08:57,110
技術或模式，是
使用目標C.目標C

150
00:08:57,110 --> 00:09:03,110
被稱為目標C，不是
C，一個很好的理由。

151
00:09:03,110 --> 00:09:07,560
>> 所以，在我們進入
Objective C的語法，

152
00:09:07,560 --> 00:09:11,670
讓我們真的很快看看
究竟是什麼物體。

153
00:09:11,670 --> 00:09:15,480
我們可能已經做了一些事情
像之前的對象，這

154
00:09:15,480 --> 00:09:19,780
被稱為當你的結構
實施樹或鍊錶

155
00:09:19,780 --> 00:09:25,730
或[？試試。 ？]所以，這是
基本上像一個結構，

156
00:09:25,730 --> 00:09:28,560
但比這更強大。

157
00:09:28,560 --> 00:09:33,150
對象具有的方法和屬性。

158
00:09:33,150 --> 00:09:35,310
方法基本上函數。

159
00:09:35,310 --> 00:09:39,480
基本功能，一個
特定於某個特定的對象。

160
00:09:39,480 --> 00:09:45,440
>> 和屬性基本上是
現場您在結構中指定。

161
00:09:45,440 --> 00:09:48,500
因此，對於每一個對象
我們有一些財產

162
00:09:48,500 --> 00:09:53,160
有一些變量，
特定於對象。

163
00:09:53,160 --> 00:09:57,170
我們有一些職能
也特定於對象。

164
00:09:57,170 --> 00:10:01,180
和功能被調用的方法
和變量被稱為屬性。

165
00:10:01,180 --> 00:10:03,190
它只是一個花哨的名字。

166
00:10:03,190 --> 00:10:10,440
當你事實上，每一個單一的視圖
你看，當您打開一個iOS應用程序，

167
00:10:10,440 --> 00:10:17,720
讓我們只說Twitter或Facebook，
你看到的每一個觀點是一種對象。

168
00:10:17,720 --> 00:10:22,110
乃至整個應用程序是
開始與一個對象。

169
00:10:22,110 --> 00:10:25,340
非常有趣的概念。

170
00:10:25,340 --> 00:10:28,480
>> 為什麼我們要的對象
面向對象編程？

171
00:10:28,480 --> 00:10:33,530
所以你可以想像，當你
程序也變得相當複雜。

172
00:10:33,530 --> 00:10:36,400
遠的不說，當你
實施棋盤，

173
00:10:36,400 --> 00:10:40,020
邏輯將要
可以非常複雜。

174
00:10:40,020 --> 00:10:43,280
你有36種不同的
件，所以，如果

175
00:10:43,280 --> 00:10:48,370
想寫邏輯所有
36個不同的國際象棋，

176
00:10:48,370 --> 00:10:52,150
那將是一個很大的
不同的函數和變量。

177
00:10:52,150 --> 00:10:54,070
這是一個很大的麻煩。

178
00:10:54,070 --> 00:10:58,980
大概你會寫
不同的方法或不同的功能

179
00:10:58,980 --> 00:11:03,950
對每個片的至
精確控制他們做什麼。

180
00:11:03,950 --> 00:11:08,830
>> 但是，如果你做的面向對象
編程，所有的這些作品

181
00:11:08,830 --> 00:11:12,440
可以抽象成
一個單獨的對象。

182
00:11:12,440 --> 00:11:16,111
與該對象將具有一些共同
性能，喜歡什麼樣件

183
00:11:16,111 --> 00:11:16,610
是什麼呢？

184
00:11:16,610 --> 00:11:17,740
它是什麼顏色？

185
00:11:17,740 --> 00:11:19,480
它如何移動？

186
00:11:19,480 --> 00:11:24,660
並以這種方式有很大的
簡化了它的邏輯。

187
00:11:24,660 --> 00:11:28,480
所以它只是一個非常好的辦法
作複雜的程序，

188
00:11:28,480 --> 00:11:33,700
和層次關係
在程序中，很簡單的。

189
00:11:33,700 --> 00:11:36,800
正如我們將看到
為什麼非常快的時候

190
00:11:36,800 --> 00:11:39,660
我們實際上在做
programming--當我們真正

191
00:11:39,660 --> 00:11:42,830
做一個S碼
以後的編程會話。

192
00:11:42,830 --> 00:11:48,120
>> 井除此之外，
面向對象編程

193
00:11:48,120 --> 00:11:50,030
僅僅是一個很大的樂趣。

194
00:11:50,030 --> 00:11:51,990
你必須設計自己的對象。

195
00:11:51,990 --> 00:11:56,080
你一定要設計什麼呢
它看起來像自己。

196
00:11:56,080 --> 00:11:58,250
沒有正確的答案。

197
00:11:58,250 --> 00:12:02,940
它是完全有趣。

198
00:12:02,940 --> 00:12:07,270
所以在面向對象的編程，
兩個基本概念

199
00:12:07,270 --> 00:12:10,130
將類和實例。

200
00:12:10,130 --> 00:12:13,570
一類是基本
一個模板為對象。

201
00:12:13,570 --> 00:12:18,070
和一個實例是基本上
一個特定對象。

202
00:12:18,070 --> 00:12:21,090
>> 遠的不說，你正在做一個cookie。

203
00:12:21,090 --> 00:12:24,800
在這種情況下，每單
餅乾，你居然落得

204
00:12:24,800 --> 00:12:27,310
將是一個對象。

205
00:12:27,310 --> 00:12:35,830
但餅乾板用來烤
所有的餅乾將是一個類。

206
00:12:35,830 --> 00:12:37,880
一類是基本的模板。

207
00:12:37,880 --> 00:12:46,170
和實例將是一個具體的
對象創建出一流的。

208
00:12:46,170 --> 00:12:49,970
>> 和實例將被創建
基於類的聲明，

209
00:12:49,970 --> 00:12:56,760
我們將在以後的幻燈片中看到。

210
00:12:56,760 --> 00:13:00,010
因此，讓我們實際上做一個真正
簡單的例子[聽不清]。

211
00:13:00,010 --> 00:13:04,280
比方說，我們正在申報
對象為一隻貓。

212
00:13:04,280 --> 00:13:07,930
對象應have--
如若貓類

213
00:13:07,930 --> 00:13:11,260
有一些屬性和方法。

214
00:13:11,260 --> 00:13:17,300
什麼樣的屬性應該在的
類have--應該貓有哪些？

215
00:13:17,300 --> 00:13:20,580
>> 例如，顏色，
年齡和品種，這些

216
00:13:20,580 --> 00:13:24,440
將變量
特定於每個貓。

217
00:13:24,440 --> 00:13:27,790
而這些都是一些事情
我們用來形容一隻貓。

218
00:13:27,790 --> 00:13:31,880
什麼樣的方法，
或者有什麼可以一隻貓嗎？

219
00:13:31,880 --> 00:13:37,160
一些簡單的例子就追
鼠標，吃魚或只是喵。

220
00:13:37,160 --> 00:13:40,900
這是一個非常快
例如貓類。

221
00:13:40,900 --> 00:13:46,920
而一個真正的特定
貓物體將是一個貓

222
00:13:46,920 --> 00:13:50,930
在這裡我們指定
顏色，年齡和品種。

223
00:13:50,930 --> 00:13:53,790
>> 在這種情況下，我們的目的是
不再是一個類了。

224
00:13:53,790 --> 00:14:00,010
我們複製的模板從類和
我們指定每個具體信息

225
00:14:00,010 --> 00:14:04,510
到該特定對象
使其獨立。

226
00:14:04,510 --> 00:14:09,350
而當你在呼喚
對象內的方法，

227
00:14:09,350 --> 00:14:16,640
你只需要調用喵的對象，
這是您剛才創建的貓。

228
00:14:16,640 --> 00:14:19,020
>> 也許你會打印出
類似的“Hello World！

229
00:14:19,020 --> 00:14:20,000
喵。“

230
00:14:20,000 --> 00:14:22,110
漂亮可愛。

231
00:14:22,110 --> 00:14:24,500
好吧，讓我們只
進入一些細節

232
00:14:24,500 --> 00:14:30,650
看看究竟是什麼
翻譯應運而生的iOS編程。

233
00:14:30,650 --> 00:14:36,500
因此，在iOS的編程每一個
類將在兩個文件中予以實施。

234
00:14:36,500 --> 00:14:41,420
一個文件是在這裡，這
被稱為接口。

235
00:14:41,420 --> 00:14:45,300
另一個文件是在這裡，這
被稱為實施。

236
00:14:45,300 --> 00:14:48,890
>> 通常情況下，接口
將有extension.h

237
00:14:48,890 --> 00:14:51,740
正如我們所看到的C庫。

238
00:14:51,740 --> 00:14:56,340
和實現文件
將有extension.n。

239
00:14:56,340 --> 00:14:57,260
這是一種奇怪的。

240
00:14:57,260 --> 00:15:01,270
但是.N指實際的.c，沒有
那些之間的根本區別

241
00:15:01,270 --> 00:15:02,100
2。

242
00:15:02,100 --> 00:15:06,650
所以在這種情況下，我們可以看到，我們是
聲明接口，貓：對象。

243
00:15:06,650 --> 00:15:10,660

244
00:15:10,660 --> 00:15:13,760
這就是所謂的繼承。

245
00:15:13,760 --> 00:15:19,170
我們基本上繼承
從Object類貓類。

246
00:15:19,170 --> 00:15:24,790
所以，每一個屬性和方法，這是
先前在該對象類中定義

247
00:15:24,790 --> 00:15:28,560
將被自動定義
在貓類也是如此。

248
00:15:28,560 --> 00:15:35,900
>> 除此之外，我們定義顏色，
品種和年齡，三個變量。

249
00:15:35,900 --> 00:15:39,360
實際上看起來像
一些你以前做過。

250
00:15:39,360 --> 00:15:41,770
它看起來像結構。

251
00:15:41,770 --> 00:15:44,950
即基本上語法
對結構聲明，

252
00:15:44,950 --> 00:15:47,710
那是完全正確的。

253
00:15:47,710 --> 00:15:51,825
因為我之前提到的，
區別一個struct

254
00:15:51,825 --> 00:15:53,960
和一個對象，所述一個
根本分歧

255
00:15:53,960 --> 00:15:59,080
是，一個對象具有的方法，
而結構只有變量。

256
00:15:59,080 --> 00:16:03,450
因此除了屬性或
我們已經為對象創建的變量，

257
00:16:03,450 --> 00:16:05,700
我們指定的一些方法。

258
00:16:05,700 --> 00:16:09,720
>> 遠的不說，我們在這裡有
兩種方法，一種是喵，

259
00:16:09,720 --> 00:16:12,460
另一個是追逐鼠標。

260
00:16:12,460 --> 00:16:18,600
我們可能要被傳遞
基於我們以前的方法參數

261
00:16:18,600 --> 00:16:20,440
聲明格局。

262
00:16:20,440 --> 00:16:22,160
你可能想傳遞一個鼠標。

263
00:16:22,160 --> 00:16:25,180
你可能會想
返回一個布爾表意

264
00:16:25,180 --> 00:16:30,010
如果你的貓已經成功
捉住了老鼠與否。

265
00:16:30,010 --> 00:16:33,170
>> 這是接口，但我們可以
看到實際的接口

266
00:16:33,170 --> 00:16:35,150
沒有做任何事情。

267
00:16:35,150 --> 00:16:40,800
它只是講述了一個什麼樣的程序exists--
在貓類的東西存在。

268
00:16:40,800 --> 00:16:43,640
所以，為了使
計劃做一些事情，

269
00:16:43,640 --> 00:16:46,680
我們需要有執行文件。

270
00:16:46,680 --> 00:16:51,940
所以在這裡，我們做的第一件事就是
很明顯，我們導入的接口。

271
00:16:51,940 --> 00:16:56,470
當我們導入接口，
我們定義該方法。

272
00:16:56,470 --> 00:17:00,150
>> 遠的不說這裡喵
將剛剛打印出來

273
00:17:00,150 --> 00:17:01,740
“你好世界！”到控制台。

274
00:17:01,740 --> 00:17:04,319

275
00:17:04,319 --> 00:17:08,460
並實施後，
文件中，我們幾乎完成。

276
00:17:08,460 --> 00:17:14,530
這基本上是一個類
聲明一個類。

277
00:17:14,530 --> 00:17:19,970
所以，現在的問題是，
你如何聲明一個變量？

278
00:17:19,970 --> 00:17:26,880
該方法使用一個類來創建
在Objective C的對象是寫在這裡。

279
00:17:26,880 --> 00:17:30,730
>> 你先指定
這是一隻貓的指針，

280
00:17:30,730 --> 00:17:38,700
因為在目標C中的每個對象
最終實現為指針。

281
00:17:38,700 --> 00:17:46,210
你調用類，給他們打電話
作為ALLOC，這基本上是malloc的，

282
00:17:46,210 --> 00:17:51,220
告訴操作系統您
需要這個對象的一些內存空間。

283
00:17:51,220 --> 00:17:55,780
之後，你有一個對象
已經和你只是初始化。

284
00:17:55,780 --> 00:17:56,780
這僅僅是慣例。

285
00:17:56,780 --> 00:17:59,390

286
00:17:59,390 --> 00:18:04,410
我知道這是一個有點怪異，但
這是蘋果公司實際上是怎麼做的東西。

287
00:18:04,410 --> 00:18:07,130
>> 分配的屬性是
其實很簡單。

288
00:18:07,130 --> 00:18:09,250
這是非常相似
你在做什麼時，

289
00:18:09,250 --> 00:18:13,780
你分配一些特定的
場結構內。

290
00:18:13,780 --> 00:18:16,830
你只需變量
名，屬性名，

291
00:18:16,830 --> 00:18:20,140
並指定一個特定值到它。

292
00:18:20,140 --> 00:18:24,120
和調用方法非常相似。

293
00:18:24,120 --> 00:18:29,080
調用的方法是
基本上是我談談

294
00:18:29,080 --> 00:18:32,390
調用的目標C.任何方法

295
00:18:32,390 --> 00:18:36,660
>> 你傳遞一個對象，在
這種情況下，將是myCat，

296
00:18:36,660 --> 00:18:42,490
而你傳遞的方法名。

297
00:18:42,490 --> 00:18:47,130
因為如果你在談論的對象，
myCat，你應該喵。

298
00:18:47,130 --> 00:18:48,570
這是很有趣的。

299
00:18:48,570 --> 00:18:52,010

300
00:18:52,010 --> 00:18:55,680
在這之後，有一
更重要的設計模式

301
00:18:55,680 --> 00:18:59,940
我們需要談談
之前獲得實際的S碼。

302
00:18:59,940 --> 00:19:03,300
該設計圖案被稱為
事件驅動編程。

303
00:19:03,300 --> 00:19:09,660
這也是最大概1
基本思想在iOS的編程。

304
00:19:09,660 --> 00:19:14,410
>> 所以，你可能不知道究竟是什麼
是事件驅動編程，

305
00:19:14,410 --> 00:19:16,990
但它不是真的那麼可怕。

306
00:19:16,990 --> 00:19:20,400
其實嘛，你有
已經做之前。

307
00:19:20,400 --> 00:19:24,894
這是你可能的線路之一
已經寫在最後[聽不清]

308
00:19:24,894 --> 00:19:26,810
CS50的，
google.maps.event.addListener（標記，

309
00:19:26,810 --> 00:19:27,810
“點擊”功能（）{}）:.

310
00:19:27,810 --> 00:19:32,410

311
00:19:32,410 --> 00:19:37,620
通過調用這一行你
實質上就是告訴計算機

312
00:19:37,620 --> 00:19:42,650
每當事件被稱為
“點擊”發生在標記，

313
00:19:42,650 --> 00:19:43,630
使用該功能。

314
00:19:43,630 --> 00:19:46,910

315
00:19:46,910 --> 00:19:50,950
>> 這是非常不同
你在做mario.c。

316
00:19:50,950 --> 00:19:56,670
在mario.c你只要運行該程序
一次，它給你的輸出，

317
00:19:56,670 --> 00:19:58,590
就大功告成了。

318
00:19:58,590 --> 00:20:02,590
這些都是有點像
一桿的方案。

319
00:20:02,590 --> 00:20:05,830
事件驅動程序
是非常，非常不同。

320
00:20:05,830 --> 00:20:10,230
讓我們想像一下，如果Facebook是一個
拍攝計劃它不是真正的好。

321
00:20:10,230 --> 00:20:13,750
你只要去到Facebook
一次，它的完成。

322
00:20:13,750 --> 00:20:16,700
它給你一些輸出
你從來沒有回來。

323
00:20:16,700 --> 00:20:19,380
你從來沒有得到任何東西。

324
00:20:19,380 --> 00:20:23,880
>> 所以在這裡，特別是
我們使用模式是

325
00:20:23,880 --> 00:20:26,940
事件驅動的，從而使
每一個功能都會

326
00:20:26,940 --> 00:20:31,480
根據被抓什麼
事件已經發生了。

327
00:20:31,480 --> 00:20:34,670
例如，如果我們有
一個按鈕，我們指定

328
00:20:34,670 --> 00:20:39,870
只要單擊該按鈕，
調用調用的函數的“Hello World！”

329
00:20:39,870 --> 00:20:47,810
這樣，我們才能真正
管理功能邏輯

330
00:20:47,810 --> 00:20:50,560
流在一個高度靈活的方式。

331
00:20:50,560 --> 00:20:55,840
用戶可以做或調用一個函數
已被調用。

332
00:20:55,840 --> 00:20:59,900
它完全基於哪些用戶做。

333
00:20:59,900 --> 00:21:04,080
>> 所以我們可以看到，這是
比mario.c實際上要好得多。

334
00:21:04,080 --> 00:21:07,190
而好消息是，它的
其實並不是一個新的概念。

335
00:21:07,190 --> 00:21:12,140
你們已經做了
在最後一個問題集。

336
00:21:12,140 --> 00:21:16,640
因此，在目標C有
三種不同的圖

337
00:21:16,640 --> 00:21:19,030
事件驅動編程。

338
00:21:19,030 --> 00:21:21,970
第一個圖是
所謂目標的行動，

339
00:21:21,970 --> 00:21:26,990
在那裡你綁定按鈕
記者與一些功能。

340
00:21:26,990 --> 00:21:31,590
遠的不說，只要你點擊
一些按鈕，你調用一些功能。

341
00:21:31,590 --> 00:21:33,620
這是非常簡單的目標採取行動。

342
00:21:33,620 --> 00:21:35,580
>> 第二個是
實際上最難的之一，

343
00:21:35,580 --> 00:21:38,450
這就是所謂的協議，代表團一行。

344
00:21:38,450 --> 00:21:41,800
我們要解釋
在偉大的詳細版本。

345
00:21:41,800 --> 00:21:44,420
而第三種方式是通知。

346
00:21:44,420 --> 00:21:46,770
這實際上是不
非常重要的，因為遠

347
00:21:46,770 --> 00:21:50,920
作為我們來講，因為機會
你要使用的通知

348
00:21:50,920 --> 00:21:53,310
在最終的項目是相當低的。

349
00:21:53,310 --> 00:21:56,440
所以我們要跳過這一部分。

350
00:21:56,440 --> 00:21:59,460
>> 我們要去潛水
插入協議的代表團。

351
00:21:59,460 --> 00:22:02,380

352
00:22:02,380 --> 00:22:04,470
那麼究竟什麼是協議？

353
00:22:04,470 --> 00:22:06,450
或者，究竟是代表團？

354
00:22:06,450 --> 00:22:09,670
讓我們來談談協議開始。

355
00:22:09,670 --> 00:22:13,360
協議是什麼，但事件。

356
00:22:13,360 --> 00:22:19,230
但是，這些事件被提供給
您可以通過蘋果開始。

357
00:22:19,230 --> 00:22:22,640
舉例來說，我不是
完全確定你們有多少人

358
00:22:22,640 --> 00:22:27,930
人使用蘋果的原
應用程序的郵件或聯繫人，

359
00:22:27,930 --> 00:22:32,180
但每次滾動
表，並按特定細胞

360
00:22:32,180 --> 00:22:36,130
在桌子上，也就是一個事件。

361
00:22:36,130 --> 00:22:38,330
>> 如果你想要做的
該事件自己，

362
00:22:38,330 --> 00:22:40,410
它實際上是一個有點硬。

363
00:22:40,410 --> 00:22:44,880
因此，蘋果已經考慮到甚至你
讓你可以直接使用

364
00:22:44,880 --> 00:22:49,610
事件做一些你自己的。

365
00:22:49,610 --> 00:22:52,980
協議實際上是
真的，真的很廣泛的應用

366
00:22:52,980 --> 00:22:58,320
在Objective C.井
事實上，每一個單一的應用程序

367
00:22:58,320 --> 00:23:00,870
有東西抓住了應用程序委託。

368
00:23:00,870 --> 00:23:06,330
裡面的細膩是一切的
協議用於裝載應用程序。

369
00:23:06,330 --> 00:23:12,470
>> 遠的不說，有
事件的應用程序做負載。

370
00:23:12,470 --> 00:23:18,200
所以會發生什麼你已經經過
創建一個應用程序，打開應用程序後，

371
00:23:18,200 --> 00:23:22,630
關閉應用程序，或在後
你把iPhone睡覺。

372
00:23:22,630 --> 00:23:27,480
這些是具有所有事件
已給你。

373
00:23:27,480 --> 00:23:34,730
這些顆粒原本裡面
就沒有實現。

374
00:23:34,730 --> 00:23:39,750
蘋果只是告訴你，這個功能
當一些事件發生的會發生，

375
00:23:39,750 --> 00:23:44,380
但你做了什麼與
功能是完全取決於你。

376
00:23:44,380 --> 00:23:49,290
>> 代表團基本上是
告訴類

377
00:23:49,290 --> 00:23:53,060
你應該處理這些協議。

378
00:23:53,060 --> 00:23:55,340
這是一個有點
混亂，但是這將是

379
00:23:55,340 --> 00:23:59,380
當我們做更清晰
在S碼的行動。

380
00:23:59,380 --> 00:24:04,760
代表團的協議實際上是一個
非常穩健的機制在這個意義上

381
00:24:04,760 --> 00:24:08,160
如果我們做的代表團
到一個特定的類，

382
00:24:08,160 --> 00:24:12,400
我們基本上可以處理
各類賽事

383
00:24:12,400 --> 00:24:17,040
使用任何類，我們有，
非常方便的工具。

384
00:24:17,040 --> 00:24:21,530
>> 因此一個簡單的例子為
在協議授權

385
00:24:21,530 --> 00:24:24,120
將是我剛才講的。

386
00:24:24,120 --> 00:24:26,720

387
00:24:26,720 --> 00:24:30,890
該協議明確被稱為
的tableview [聽不清]選擇角色

388
00:24:30,890 --> 00:24:35,480
在[？指數？] [？過去的。 ？]所以這一個
事件會被抓住，當你

389
00:24:35,480 --> 00:24:39,710
實際上點擊一個特定的
細胞在你的tableview，

390
00:24:39,710 --> 00:24:43,570
我們只能說在您的郵件
或者在您的聯繫人應用程序。

391
00:24:43,570 --> 00:24:48,180
>> 裡面的功能有
本來無所事事。

392
00:24:48,180 --> 00:24:51,950
該功能不
做默認情況下任何東西。

393
00:24:51,950 --> 00:24:55,540
但是，你可以指定
功能做什麼，

394
00:24:55,540 --> 00:24:59,610
給你想要你的應用程序中。

395
00:24:59,610 --> 00:25:01,610
非常方便的工具。

396
00:25:01,610 --> 00:25:06,840
並與所有的
雖這麼說，我基本上

397
00:25:06,840 --> 00:25:11,430
包括一些非常基本的語法和
對目標C基本概念

398
00:25:11,430 --> 00:25:15,860
編程，我們可以做一些S碼。

399
00:25:15,860 --> 00:25:17,980
更令人興奮。

400
00:25:17,980 --> 00:25:21,070
因此S碼實際上是為
有點勢不可擋

401
00:25:21,070 --> 00:25:23,330
當你打開它的第一次。

402
00:25:23,330 --> 00:25:26,640
>> 一個快速的注意，因此，如果您
想要做iOS開發，

403
00:25:26,640 --> 00:25:29,630
我強烈建議你有一個蘋果。

404
00:25:29,630 --> 00:25:33,930
因為這樣做iOS開發上
Windows是真的，真的很難。

405
00:25:33,930 --> 00:25:37,560
這是可行的，但它真的很難。

406
00:25:37,560 --> 00:25:40,610
你肯定做
不想用G編輯。

407
00:25:40,610 --> 00:25:47,950
因此，在S碼我們
幾個不同的區域。

408
00:25:47,950 --> 00:25:53,050
當你第​​一次打開S碼
你會看到一個導航區域，

409
00:25:53,050 --> 00:25:57,470
這基本上說明你一切
文件是當前項目。

410
00:25:57,470 --> 00:26:03,590
>> 你有一個工具欄區域，
基本上是管理的意見，

411
00:26:03,590 --> 00:26:08,570
或者一些小快
關於S碼本身的工具。

412
00:26:08,570 --> 00:26:11,140
而這是實際的編輯器區域。

413
00:26:11,140 --> 00:26:15,900
這個地區是非常相似克編輯，
但遠比克編輯好。

414
00:26:15,900 --> 00:26:21,150
在這方面的權利，是
所謂的實用面積。

415
00:26:21,150 --> 00:26:27,170
該地區變得非常方便時，
你創建的界面或指定

416
00:26:27,170 --> 00:26:30,070
一些快速設置為您的應用程序。

417
00:26:30,070 --> 00:26:34,570
>> 和最終面積的調試。

418
00:26:34,570 --> 00:26:37,970
此區域包含控制台。

419
00:26:37,970 --> 00:26:43,170
所以每當你說的printf，
或者NSLog的在我們的情況下，

420
00:26:43,170 --> 00:26:47,330
所有的結果
將要在這裡進行打印。

421
00:26:47,330 --> 00:26:48,260
行？

422
00:26:48,260 --> 00:26:52,090
我想我們真的可以做到迅速
一個例子為iOS編程。

423
00:26:52,090 --> 00:26:54,220
讓我們實際打開了S碼。

424
00:26:54,220 --> 00:26:57,210

425
00:26:57,210 --> 00:27:01,346
所以每次你打開S碼的時候，它的
將出現類似的東西。

426
00:27:01,346 --> 00:27:03,220
它會問你
你想讓我做什麼？

427
00:27:03,220 --> 00:27:06,830
你想啟動的東西
隨機的，操場，基本上你

428
00:27:06,830 --> 00:27:11,250
可以測試代碼，而無需
實際上犯任何應用程序。

429
00:27:11,250 --> 00:27:13,020
>> 你想創建一個新的項目？

430
00:27:13,020 --> 00:27:16,660
或者你想繼續
工作在現有的項目？

431
00:27:16,660 --> 00:27:20,270
在我們的例子中，我們要去
創建一個新的項目。

432
00:27:20,270 --> 00:27:22,980
所以這是非常好的，S
代碼實際上早已

433
00:27:22,980 --> 00:27:26,820
給你一些模板
創建對象。

434
00:27:26,820 --> 00:27:32,680
如果你想要做一個遊戲，S碼
實際上有一個遊戲的模板給你，

435
00:27:32,680 --> 00:27:36,890
有一個基於網頁的應用程序，
標籤的應用程序。

436
00:27:36,890 --> 00:27:39,280
在這種情況下，我們要
做的東西很簡單，

437
00:27:39,280 --> 00:27:43,230
而我們將使用
單一視圖的應用程序。

438
00:27:43,230 --> 00:27:48,270
>> 之後，只是你想叫什麼
您的產品，你叫什麼名字，

439
00:27:48,270 --> 00:27:52,760
什麼是你的標識，
你用什麼樣的語言。

440
00:27:52,760 --> 00:27:57,060
在這裡，我們不希望
檢查使用核心數據。

441
00:27:57,060 --> 00:28:00,170
核心數據基本上是建庫的iOS。

442
00:28:00,170 --> 00:28:05,360
如果你做的核心數據，S
代碼是要限定

443
00:28:05,360 --> 00:28:07,710
很多更複雜的類為您服務。

444
00:28:07,710 --> 00:28:12,740
所以把一切都簡單，我們
剛準備做沒有核心數據

445
00:28:12,740 --> 00:28:15,290
現在。

446
00:28:15,290 --> 00:28:18,030
>> 我們將是問題
使用是that--問題

447
00:28:18,030 --> 00:28:23,770
我們將要建立的是，我們
基本上想從C導入馬里奧

448
00:28:23,770 --> 00:28:25,437
一個iOS應用。

449
00:28:25,437 --> 00:28:26,645
因此，讓我們稱之為馬里奧的iOS。

450
00:28:26,645 --> 00:28:31,230

451
00:28:31,230 --> 00:28:34,880
當然你指定你
想要把你的項目。

452
00:28:34,880 --> 00:28:37,870
還有，我們走了。

453
00:28:37,870 --> 00:28:41,390
>> 所以這是一個有點
鋪天蓋地，但其實這是

454
00:28:41,390 --> 00:28:43,540
我們剛才看到的幻燈片。

455
00:28:43,540 --> 00:28:49,710
和第一方面，我們看到現在
基本上是項目配置。

456
00:28:49,710 --> 00:28:53,390
所以一切你想做的事
項目，什麼樣的設備，

457
00:28:53,390 --> 00:28:58,810
讓我們只說什麼樣的設備
你想你的應用程序出現在？

458
00:28:58,810 --> 00:29:01,280
它是iPhone，iPad還是通用？

459
00:29:01,280 --> 00:29:04,660
所以設備的方向，這一切的東西。

460
00:29:04,660 --> 00:29:08,490
不是很重要，
但也可以是，但這種

461
00:29:08,490 --> 00:29:11,050
就是你設置了一個地方
你的項目，如果你真的

462
00:29:11,050 --> 00:29:15,180
要部署到蘋果專賣店。

463
00:29:15,180 --> 00:29:20,420
>> 好吧，讓我們來看看
東西是我們的代碼中。

464
00:29:20,420 --> 00:29:22,360
讓我們通過文件導航。

465
00:29:22,360 --> 00:29:30,140
而這些所有的文件已經
附帶的模板，非常漂亮。

466
00:29:30,140 --> 00:29:35,980
所以，當我們點擊其中一個
這是什麼樣子。

467
00:29:35,980 --> 00:29:38,530
非常相似克編輯。

468
00:29:38,530 --> 00:29:41,340
但是你可以看到，
語法高亮可能

469
00:29:41,340 --> 00:29:42,780
一點點更好。

470
00:29:42,780 --> 00:29:45,610
它實際上更
強大的比克編輯。

471
00:29:45,610 --> 00:29:49,970
並且可以自動完成
很多東西你，

472
00:29:49,970 --> 00:29:52,370
正如我們所看到的非常快。

473
00:29:52,370 --> 00:29:54,100
>> 讓我們打開調試方面也是如此。

474
00:29:54,100 --> 00:30:02,790

475
00:30:02,790 --> 00:30:07,000
好吧，我們可以看到，
控制台就在這裡。

476
00:30:07,000 --> 00:30:13,840
這是你將成為怎樣看哪裡
你在printf的或nsloging東西。

477
00:30:13,840 --> 00:30:17,155
因此，事不宜遲，讓我們真正
編譯應用程序，看看會發生什麼。

478
00:30:17,155 --> 00:30:20,000

479
00:30:20,000 --> 00:30:23,410
對於一個基本特徵
S碼，是S碼

480
00:30:23,410 --> 00:30:25,850
配備了一個iPhone模擬器。

481
00:30:25,850 --> 00:30:29,820
所以，你不需要有一個
iPhone試試你的項目，

482
00:30:29,820 --> 00:30:34,440
S碼可以模擬，對於
你，我們可以看到現在。

483
00:30:34,440 --> 00:30:36,406
>> 這是相當不錯的。

484
00:30:36,406 --> 00:30:38,640
它採取了一些
時間位編譯

485
00:30:38,640 --> 00:30:43,040
基本上我們有
一個空的應用程序，

486
00:30:43,040 --> 00:30:44,640
這實際上什麼都不做。

487
00:30:44,640 --> 00:30:46,175
但它編譯。

488
00:30:46,175 --> 00:30:47,380
這是相當真棒。

489
00:30:47,380 --> 00:30:50,200
這比C好得多，是吧？

490
00:30:50,200 --> 00:30:52,130
好了，接下來就讓我們
嘗試添加一些東西。

491
00:30:52,130 --> 00:30:56,050

492
00:30:56,050 --> 00:31:02,650
一個文件，該文件是一點點
奇怪的是這裡所謂的故事情節。

493
00:31:02,650 --> 00:31:08,020
這實際上是一個偉大的，
真棒功能的S碼。

494
00:31:08,020 --> 00:31:14,170
因為在S碼的，你其實可以拖動
拖放元素到接口

495
00:31:14,170 --> 00:31:17,430
它會直接顯示出來。

496
00:31:17,430 --> 00:31:18,055
讓我們來試試。

497
00:31:18,055 --> 00:31:21,230

498
00:31:21,230 --> 00:31:27,236
>> 我們放棄一個標籤在這裡的“Hello World！”

499
00:31:27,236 --> 00:31:29,740
我們可以說為中心。

500
00:31:29,740 --> 00:31:30,970
很酷。

501
00:31:30,970 --> 00:31:33,915
現在讓我們來運行這個停止模擬。

502
00:31:33,915 --> 00:31:36,940

503
00:31:36,940 --> 00:31:38,700
在這裡，我們的“Hello World！”

504
00:31:38,700 --> 00:31:40,810
我們甚至沒有做任何編碼呢。

505
00:31:40,810 --> 00:31:42,750
你到底是怎麼回事？

506
00:31:42,750 --> 00:31:45,880
這是多麼強大
Interface Builder中即可。

507
00:31:45,880 --> 00:31:48,030
有人甚至說，
你可能只

508
00:31:48,030 --> 00:31:52,800
完成無需編寫一個應用程序
大概一千行代碼

509
00:31:52,800 --> 00:31:54,820
只是使用界面生成器。

510
00:31:54,820 --> 00:31:59,680
但它可能不是
最好的辦法做到這一點。

511
00:31:59,680 --> 00:32:01,670
>> 現在，讓我們真正坐下來編碼。

512
00:32:01,670 --> 00:32:04,860

513
00:32:04,860 --> 00:32:08,330
這樣的結構的文件
其實真的很有趣

514
00:32:08,330 --> 00:32:15,610
因為，你可能會看到，有
沒有主要功能的任何地方。

515
00:32:15,610 --> 00:32:17,466
看到了嗎？

516
00:32:17,466 --> 00:32:19,340
正如我們之前所提到的，
你可以看到這

517
00:32:19,340 --> 00:32:22,830
是一個實現文件
對於一個特定的類。

518
00:32:22,830 --> 00:32:25,690
但是沒有任何地方為主。

519
00:32:25,690 --> 00:32:27,490
那麼，是主要的？

520
00:32:27,490 --> 00:32:31,970
實際上，有一個主，但
主實際上是從你隱藏。

521
00:32:31,970 --> 00:32:34,560
主要是在這裡。

522
00:32:34,560 --> 00:32:37,120
這看起來很熟悉。

523
00:32:37,120 --> 00:32:41,000
>> 所以基本上什麼的iOS
正在做內部的主

524
00:32:41,000 --> 00:32:43,540
是，每當主要是
叫，這基本上是

525
00:32:43,540 --> 00:32:49,000
每當應用程序被執行，它
創建一個名為的AppDelegate對象。

526
00:32:49,000 --> 00:32:52,980

527
00:32:52,980 --> 00:32:57,350
正如我前面提到的，整個
應用程序實際上是一個對象本身。

528
00:32:57,350 --> 00:33:02,270
因此，在這種方式，基本上
iOS應用程序是在告訴編譯器

529
00:33:02,270 --> 00:33:05,540
那好吧，我要創建
一個名為AppDelegate中的產品，

530
00:33:05,540 --> 00:33:07,620
那將是我的應用程序。

531
00:33:07,620 --> 00:33:09,640
所以，你需要去
通過的AppDelegate

532
00:33:09,640 --> 00:33:12,040
，看看那傢伙在做什麼。

533
00:33:12,040 --> 00:33:14,850
我的工作是為我做的。

534
00:33:14,850 --> 00:33:22,070
>> 而在AppDelegate中可以看到，
也有一些很奇怪的功能，

535
00:33:22,070 --> 00:33:25,290
其實好方法，即
蘋果已經給了你。

536
00:33:25,290 --> 00:33:27,464
這些是什麼？

537
00:33:27,464 --> 00:33:31,010
這些實際上只是協議
我在說什麼。

538
00:33:31,010 --> 00:33:35,670
因此，這些都是事件，蘋果
給你下手。

539
00:33:35,670 --> 00:33:38,050
有沒有在一些
現在的功能，

540
00:33:38,050 --> 00:33:40,820
但如果我們想初始化
東西給我們的應用程序

541
00:33:40,820 --> 00:33:46,140
進入前顯示
任何看法，我們在這裡。

542
00:33:46,140 --> 00:33:51,150
>> 你可以閱讀的名字，我猜
事件實際上是真正清楚。

543
00:33:51,150 --> 00:33:54,160

544
00:33:54,160 --> 00:33:58,350
所以，現在的主要創造
的對象的AppDelegate。

545
00:33:58,350 --> 00:34:05,220
什麼的AppDelegate是要幹什麼
居然還藏著你。

546
00:34:05,220 --> 00:34:09,250
在AppDelegate中即將開始
加載的ViewController股票。

547
00:34:09,250 --> 00:34:13,170
因此，它基本上將開始
加載了所有你有意見

548
00:34:13,170 --> 00:34:17,500
，只是渲染視圖
基於層次上。

549
00:34:17,500 --> 00:34:21,280
>> 因此，在這種情況下，我們只有
一種觀點認為，這是在這裡。

550
00:34:21,280 --> 00:34:25,060
所以這是唯一的視圖
那將被調用。

551
00:34:25,060 --> 00:34:28,159
該邏輯的ViewController是在這裡。

552
00:34:28,159 --> 00:34:32,159
這是代碼實際上是
控制我們剛才看到的視圖。

553
00:34:32,159 --> 00:34:33,679
好吧，讓我們做的東西在這裡。

554
00:34:33,679 --> 00:34:44,030

555
00:34:44,030 --> 00:34:50,560
所以viewDidLoad中聽起來像一個事件，
而事實上，這也是一個委託，

556
00:34:50,560 --> 00:34:52,500
這也是一個協議。

557
00:34:52,500 --> 00:34:56,350
>> 所以，無論視圖被加載，
一切都在函數內部

558
00:34:56,350 --> 00:34:57,920
將被調用。

559
00:34:57,920 --> 00:35:02,840
在這種情況下，我們應該看到“Hello
天宇！“如果我們運行程序。

560
00:35:02,840 --> 00:35:09,820

561
00:35:09,820 --> 00:35:12,842
它變得有點慢
編譯故事板文件。

562
00:35:12,842 --> 00:35:15,440

563
00:35:15,440 --> 00:35:18,190
確實很好，我們確實看到了它的輸出。

564
00:35:18,190 --> 00:35:20,720
這實在是太酷了。

565
00:35:20,720 --> 00:35:22,000
現在，讓我們真正做到馬里奧。

566
00:35:22,000 --> 00:35:25,400

567
00:35:25,400 --> 00:35:27,625
我要去定義
傳播非常快。

568
00:35:27,625 --> 00:35:31,510

569
00:35:31,510 --> 00:35:54,245
marioWithLevels：（INT）水平的結果。

570
00:35:54,245 --> 00:36:01,120

571
00:36:01,120 --> 00:36:06,410
>> 好吧，這其實是真棒
第代碼自動完成功能。

572
00:36:06,410 --> 00:36:10,680
所以，當你寫，然後鍵入回車，
它已經放棄了模板

573
00:36:10,680 --> 00:36:12,325
對你來說，這是很酷。

574
00:36:12,325 --> 00:36:50,480

575
00:36:50,480 --> 00:36:52,850
這應該是真的
熟悉你們。

576
00:36:52,850 --> 00:36:55,940

577
00:36:55,940 --> 00:36:59,680
對不起，這是我的錯。

578
00:36:59,680 --> 00:37:15,790

579
00:37:15,790 --> 00:37:18,120
好吧，冷靜。

580
00:37:18,120 --> 00:37:22,710
這個邏輯看起來真的很熟悉
到你們，特別是剛馬里奧。

581
00:37:22,710 --> 00:37:26,140
>> 但我們現在將打印出來
控制台每一次，

582
00:37:26,140 --> 00:37:29,280
因為我們希望以某種方式繼續
賽道是我們打印的。

583
00:37:29,280 --> 00:37:31,810
我們將使用
結果後來不知何故，

584
00:37:31,810 --> 00:37:35,010
顯示打印
出結果給用戶。

585
00:37:35,010 --> 00:37:37,730
因此，而不是我們只是
nslogging一切，

586
00:37:37,730 --> 00:37:42,410
這是我們要存儲的一切
成一個函數調用的結果，

587
00:37:42,410 --> 00:37:44,070
但邏輯是完全一樣的。

588
00:37:44,070 --> 00:37:48,030

589
00:37:48,030 --> 00:37:51,800
當我們完成它，我們
只是打印我們的結果。

590
00:37:51,800 --> 00:37:59,330

591
00:37:59,330 --> 00:38:04,970
>> 在這裡，而不是打印出我的
名，我們將調用一個函數。

592
00:38:04,970 --> 00:38:15,340

593
00:38:15,340 --> 00:38:18,090
讓我們看看會發生什麼。

594
00:38:18,090 --> 00:38:21,240
哎呀，很明顯。

595
00:38:21,240 --> 00:38:24,320
我們有一個很好的
小金字塔在這裡。

596
00:38:24,320 --> 00:38:28,370
這基本上是C，我們只是
操縱在那裡你調用一個函數

597
00:38:28,370 --> 00:38:30,010
而如何做一個功能是什麼樣子。

598
00:38:30,010 --> 00:38:31,560
沒有什麼不同。

599
00:38:31,560 --> 00:38:34,040
但其實這是
不是很令人興奮的在這裡，

600
00:38:34,040 --> 00:38:37,500
因為我們沒有看到
任何從iPhone應用程序。

601
00:38:37,500 --> 00:38:42,120
>> 所以，如果你真的有一個iPhone app--
如果你確實有馬里奧的iOS權

602
00:38:42,120 --> 00:38:45,080
現在，你不會
看到什麼，

603
00:38:45,080 --> 00:38:49,450
有什麼關係，因為馬里奧
所有輸出到一個控制台

604
00:38:49,450 --> 00:38:51,620
從用戶是隱藏的。

605
00:38:51,620 --> 00:38:53,850
這就是你所看到的，
這就是的“Hello World！”

606
00:38:53,850 --> 00:38:55,720
不好。

607
00:38:55,720 --> 00:39:03,090
現在，讓我們盡量讓用戶看
究竟我們要打印出來。

608
00:39:03,090 --> 00:39:06,000
因此，我們就不需要了標記。

609
00:39:06,000 --> 00:39:09,800
讓我們試著找出什麼
否則，可能是有用的。

610
00:39:09,800 --> 00:39:12,140
>> 其實是有1
被稱為元件

611
00:39:12,140 --> 00:39:16,460
文本字段，這可能
有很大的幫助我們。

612
00:39:16,460 --> 00:39:19,880
它主要顯示區域
文本的可編輯。

613
00:39:19,880 --> 00:39:22,320
所以，看起來真的很有幫助。

614
00:39:22,320 --> 00:39:23,810
現在，讓我們將其拖放它。

615
00:39:23,810 --> 00:39:26,880

616
00:39:26,880 --> 00:39:32,670
哇，我們有一個文本視圖
在我們看來，真正看中的。

617
00:39:32,670 --> 00:39:35,430
這是一個有點太大了。

618
00:39:35,430 --> 00:39:38,150
讓我們把它縮小。

619
00:39:38,150 --> 00:39:40,290
把它放到中心。

620
00:39:40,290 --> 00:39:43,760
使其更小為好。

621
00:39:43,760 --> 00:39:50,110
>> 現在我們有一個文本視圖，我們可以
被用於顯示我們的最終結果。

622
00:39:50,110 --> 00:39:52,860
但現在它的
絕對行不通的

623
00:39:52,860 --> 00:39:56,970
因為有no--的
我們的ViewController剛

624
00:39:56,970 --> 00:40:03,010
定義不知道
有一個文本視圖在那裡。

625
00:40:03,010 --> 00:40:06,550
因此，我們需要以某種方式
鏈接文本視圖，我們只是

626
00:40:06,550 --> 00:40:11,660
與類創建
已經和我們一起去。

627
00:40:11,660 --> 00:40:14,860
>> 我們這樣做的方式是
居然真的神奇。

628
00:40:14,860 --> 00:40:18,190
因此，開拓故事情節。

629
00:40:18,190 --> 00:40:22,220
有一個特殊的[聽不清]
所謂的[？助理？] [聽不清]。

630
00:40:22,220 --> 00:40:25,190
當您單擊的是，它的
要打開兩個文件。

631
00:40:25,190 --> 00:40:29,425
一個是一類，而另一個
為它的相應視圖。

632
00:40:29,425 --> 00:40:31,920
這是非常，非常有幫助。

633
00:40:31,920 --> 00:40:35,950
讓我們剛剛經歷.h文件。

634
00:40:35,950 --> 00:40:39,110
控制，這是[聽不清]邏輯。

635
00:40:39,110 --> 00:40:47,280
按Ctrl並拖動
文本視圖進入申報。

636
00:40:47,280 --> 00:40:48,780
我們將調用outputView。

637
00:40:48,780 --> 00:40:52,189

638
00:40:52,189 --> 00:40:53,670
連接。

639
00:40:53,670 --> 00:40:59,420
所以在這裡，我們已經宣布了新的
物業為我們的ViewController類。

640
00:40:59,420 --> 00:41:02,300
而新的物業
僅僅是文本視圖

641
00:41:02,300 --> 00:41:05,000
我們已經在界面的建設創造。

642
00:41:05,000 --> 00:41:07,990
因此，在這種方式我們可以
訪問所有數據

643
00:41:07,990 --> 00:41:13,630
和操縱一切，是裡面
輸出來看，這是真棒。

644
00:41:13,630 --> 00:41:19,260
>> 因此，在我們實際的代碼，
讓我們用它做什麼。

645
00:41:19,260 --> 00:41:23,810
所以這個時候，我們都喜歡印刷
從最終的結果馬里奧，

646
00:41:23,810 --> 00:41:28,020
我們在沒有任何記錄。

647
00:41:28,020 --> 00:41:30,080
我的意思是，我們能保持
記錄的聲明。

648
00:41:30,080 --> 00:41:41,490
除了這一點，我們
送讀出我們只是

649
00:41:41,490 --> 00:41:47,622
創建的，在輸出圖，其中
TextView的是我們剛剛創建的UI。

650
00:41:47,622 --> 00:41:48,746
現在，讓我們看看會發生什麼。

651
00:41:48,746 --> 00:41:54,470

652
00:41:54,470 --> 00:41:56,620
哇。

653
00:41:56,620 --> 00:41:59,130
我們在應用程序中的金字塔現在。

654
00:41:59,130 --> 00:42:06,720
>> 這樣用戶就可以看到我們的輸出，因為
我們複製我們的代碼的輸出

655
00:42:06,720 --> 00:42:08,045
我們的接口。

656
00:42:08,045 --> 00:42:10,950
這是相當不錯的。

657
00:42:10,950 --> 00:42:14,990
它實際上不是
令人興奮，因為我們can--

658
00:42:14,990 --> 00:42:18,250
所有的應用程序正在做的是
呈現出金字塔給你，

659
00:42:18,250 --> 00:42:20,520
還有就是你可以做些什麼。

660
00:42:20,520 --> 00:42:22,330
這不是特別令人興奮。

661
00:42:22,330 --> 00:42:27,840
所以，現在讓我們做一個按鈕
這將明確的意見。

662
00:42:27,840 --> 00:42:30,290
看來，一個按鈕會有所幫助。

663
00:42:30,290 --> 00:42:33,270
拖放。

664
00:42:33,270 --> 00:42:33,900
按鈕之一。

665
00:42:33,900 --> 00:42:36,730

666
00:42:36,730 --> 00:42:37,320
兩個按鈕。

667
00:42:37,320 --> 00:42:49,170

668
00:42:49,170 --> 00:42:52,052
>> 所以，當我們點擊左側
按鈕，在視圖應該清除。

669
00:42:52,052 --> 00:42:53,635
應該有什麼在屏幕上。

670
00:42:53,635 --> 00:42:56,970
當我們點擊
右邊的按鈕，馬里奧，

671
00:42:56,970 --> 00:42:59,740
認為會再次出現。

672
00:42:59,740 --> 00:43:05,510
所以這樣一來我們也做了
神奇的東西，控制和阻力

673
00:43:05,510 --> 00:43:08,740
在類的聲明
在助手director--

674
00:43:08,740 --> 00:43:11,600
在助手觀眾。

675
00:43:11,600 --> 00:43:18,620
在這種情況下，我們指定
這應該是一個動作。

676
00:43:18,620 --> 00:43:19,120
clearMario。

677
00:43:19,120 --> 00:43:21,650

678
00:43:21,650 --> 00:43:26,830
>> 所以在這裡，我們已經創建
所謂clearMario一個動作，

679
00:43:26,830 --> 00:43:34,210
這是將被調用的方法
當我們按下按鈕清晰。

680
00:43:34,210 --> 00:43:41,030
因此，在我們實際的代碼，我們只
把輸出文本和輸出視圖

681
00:43:41,030 --> 00:43:44,620
到一無所有，這樣
它會顯得清晰。

682
00:43:44,620 --> 00:43:47,500

683
00:43:47,500 --> 00:43:57,230
除此之外，讓我們創建
另一種方法叫runMario。

684
00:43:57,230 --> 00:44:00,140

685
00:44:00,140 --> 00:44:03,436
噢，對不起，這不應該是一個屬性。

686
00:44:03,436 --> 00:44:12,107

687
00:44:12,107 --> 00:44:13,940
好吧，這應該
成為一個動作為好。

688
00:44:13,940 --> 00:44:25,780

689
00:44:25,780 --> 00:44:34,740
>> 而當該功能是
所謂的，我們只需運行馬里奧10。

690
00:44:34,740 --> 00:44:37,620

691
00:44:37,620 --> 00:44:39,780
希望這將是罰款。

692
00:44:39,780 --> 00:44:41,120
它編譯？

693
00:44:41,120 --> 00:44:43,920
是。

694
00:44:43,920 --> 00:44:45,090
現在我們有一個觀點。

695
00:44:45,090 --> 00:44:46,560
我們有一個輸出。

696
00:44:46,560 --> 00:44:50,040
讓我們只看看會發生什麼。

697
00:44:50,040 --> 00:44:52,590
這走了。

698
00:44:52,590 --> 00:44:54,500
這是回來了。

699
00:44:54,500 --> 00:44:57,620
所以在這裡我們已經指定
什麼樣的功能

700
00:44:57,620 --> 00:45:00,400
將被調用時，
我們在什麼類型，

701
00:45:00,400 --> 00:45:03,160
當我們按下特定的按鈕。

702
00:45:03,160 --> 00:45:07,890
這基本上是
目標的行動計劃

703
00:45:07,890 --> 00:45:12,510
事件驅動
在Objective C.編程

704
00:45:12,510 --> 00:45:15,030
>> 除此之外，
這是不是很令人興奮

705
00:45:15,030 --> 00:45:19,810
因為我們無法真正改變
有多高的金字塔會，

706
00:45:19,810 --> 00:45:23,640
所以我們可能需要以某種方式
獲取來自用戶的輸入

707
00:45:23,640 --> 00:45:29,490
和改變的高度
金字塔的基礎上，他們的輸出。

708
00:45:29,490 --> 00:45:32,900
所以，我們要做到這一點。

709
00:45:32,900 --> 00:45:38,720
所以，當我們稱之為runMario這個時候，
我們不只是直接調用馬里奧。

710
00:45:38,720 --> 00:46:06,280

711
00:46:06,280 --> 00:46:07,000
這一次的冠軍。

712
00:46:07,000 --> 00:46:22,180

713
00:46:22,180 --> 00:46:23,700
>> 委託。

714
00:46:23,700 --> 00:46:25,160
這是很有趣的。

715
00:46:25,160 --> 00:46:26,720
什麼是代表？

716
00:46:26,720 --> 00:46:28,950
我打算把自這裡。

717
00:46:28,950 --> 00:46:31,038
我們將看到
什麼較晚。

718
00:46:31,038 --> 00:46:46,380

719
00:46:46,380 --> 00:46:51,120
所以在這裡我們已經基本建立了一個
具體的實例調用一個UI警報

720
00:46:51,120 --> 00:46:52,210
視圖。

721
00:46:52,210 --> 00:46:54,440
一個UI警報視圖是
基本上你會是什麼

722
00:46:54,440 --> 00:46:58,940
每次看到一些持久性有機污染物
並要求您輸入，

723
00:46:58,940 --> 00:47:03,080
就像當你想會發生什麼
購買的東西上的應用程序商店。

724
00:47:03,080 --> 00:47:14,250
>> 除此之外，在你
創建它，我們只是展示了警報。

725
00:47:14,250 --> 00:47:20,090

726
00:47:20,090 --> 00:47:22,568
好吧，就讓我們快
測試將這項工作與否。

727
00:47:22,568 --> 00:47:31,105

728
00:47:31,105 --> 00:47:32,140
這是非常酷的。

729
00:47:32,140 --> 00:47:55,370

730
00:47:55,370 --> 00:47:59,120
現在，讓我們實際創建
輸入字段的UI警報。

731
00:47:59,120 --> 00:48:01,170
這是我們如何做到這一點。

732
00:48:01,170 --> 00:48:07,490
我們應該有一個
為警報輸入視圖。

733
00:48:07,490 --> 00:48:09,020
非常酷。

734
00:48:09,020 --> 00:48:12,330
遠的不說，10。

735
00:48:12,330 --> 00:48:14,900
>> 它沒有做任何事情的權利
因為現在實際上是調用

736
00:48:14,900 --> 00:48:17,770
並沒有改變執行馬里奧。

737
00:48:17,770 --> 00:48:23,470
所以這已成為一個小
有點不可思議，因為每當

738
00:48:23,470 --> 00:48:30,790
我們按一個按鈕，每當我們
在警報視圖按下一個按鈕，

739
00:48:30,790 --> 00:48:35,560
事情應該發生，
但它並沒有發生。

740
00:48:35,560 --> 00:48:37,220
我們如何趕上？

741
00:48:37,220 --> 00:48:41,280
我們怎麼知道用戶
已經駁回了警報視圖

742
00:48:41,280 --> 00:48:45,630
並且已經進入了一個號碼，因為
現在什麼也沒有實際發生。

743
00:48:45,630 --> 00:48:50,450
>> 嗯，你可能已經猜到了
它的權利，代表團一行。

744
00:48:50,450 --> 00:48:55,440
因此，除了所有
這些聲明，

745
00:48:55,440 --> 00:49:03,190
我們需要添加一個新的代表團
它所謂的UI警報視圖委託。

746
00:49:03,190 --> 00:49:06,440
讓每一個
互動或事件

747
00:49:06,440 --> 00:49:10,190
那我們將有
與UI警報視圖

748
00:49:10,190 --> 00:49:14,100
將要被處理的
通過我們的類為好。

749
00:49:14,100 --> 00:49:26,297
>> 因此除了是，將
在索引警報視圖點擊按鈕。

750
00:49:26,297 --> 00:49:34,260

751
00:49:34,260 --> 00:49:37,730
此為止。

752
00:49:37,730 --> 00:49:42,020
因此，在這種情況下，我們有
already--所以我們有

753
00:49:42,020 --> 00:49:46,210
發現了一個協議，
將處理該事件時，

754
00:49:46,210 --> 00:49:51,320
我們點擊完成按鈕
在警報視圖。

755
00:49:51,320 --> 00:49:55,976
所以每次我們解散
警報看來，這應該發生。

756
00:49:55,976 --> 00:49:57,350
讓我很快測試。

757
00:49:57,350 --> 00:50:16,220

758
00:50:16,220 --> 00:50:19,300
好吧的確，我們在這裡達到了。

759
00:50:19,300 --> 00:50:22,210
>> 所以在這裡，我們將不會有什麼
實際上得到的是實際

760
00:50:22,210 --> 00:50:43,120
得到the--所以我們想出去
我們有以前的文字

761
00:50:43,120 --> 00:50:45,350
在警報視圖輸入。

762
00:50:45,350 --> 00:50:48,505
而基於文本，我們
要顯示馬里奧。

763
00:50:48,505 --> 00:50:52,336

764
00:50:52,336 --> 00:50:55,480
這很快證明
如果實際工作與否。

765
00:50:55,480 --> 00:50:59,476
因此，在這種情況下，如果我們的輸入，
比方說，10日，我們應該看到10。

766
00:50:59,476 --> 00:51:02,740

767
00:51:02,740 --> 00:51:05,210
>> 非常好，我們在這裡做的有很多。

768
00:51:05,210 --> 00:51:06,470
這是相當不錯的。

769
00:51:06,470 --> 00:51:16,840
現在的最後一步將be--所以
最後一步，我們需要做的事情

770
00:51:16,840 --> 00:51:21,100
只是一個叫馬里奧
級別基於輸入

771
00:51:21,100 --> 00:51:23,270
我們已經投入警報視圖。

772
00:51:23,270 --> 00:51:26,920
因此，我們需要轉換
這串入的iOS。

773
00:51:26,920 --> 00:51:33,820

774
00:51:33,820 --> 00:51:35,496
靜溢很真棒。

775
00:51:35,496 --> 00:51:44,930

776
00:51:44,930 --> 00:51:51,182
然後我們只需調用自
marioWithLevels值。

777
00:51:51,182 --> 00:51:54,550

778
00:51:54,550 --> 00:51:56,284
讓我們來看看這會
實際工作或沒有。

779
00:51:56,284 --> 00:51:59,070

780
00:51:59,070 --> 00:52:01,550
>> 我們已經給出一個金字塔。

781
00:52:01,550 --> 00:52:04,785
讓我們試著改變高度。

782
00:52:04,785 --> 00:52:06,530
實際工作。

783
00:52:06,530 --> 00:52:07,610
這實在是太酷了。

784
00:52:07,610 --> 00:52:10,420
所以，現在你可以
輸入你想要的任何值。

785
00:52:10,420 --> 00:52:12,440
遠的不說，四名。

786
00:52:12,440 --> 00:52:14,260
這是相當真棒。

787
00:52:14,260 --> 00:52:17,090
所以這基本上是
一個真正簡單的例子

788
00:52:17,090 --> 00:52:23,170
對於如何在S碼項目
而如何真正快速連線了

789
00:52:23,170 --> 00:52:26,220
一些很簡單的活動和功能。

790
00:52:26,220 --> 00:52:28,840
>> 因此源會
可後來在網上放。

791
00:52:28,840 --> 00:52:33,400
所以，如果你有興趣
在iOS的馬里奧是如何工作的，

792
00:52:33,400 --> 00:52:38,360
我打算把一模一樣的
項目到CS50網站後。

793
00:52:38,360 --> 00:52:41,260
我們基本上用做
夏天到了，才完成

794
00:52:41,260 --> 00:52:45,190
我只是想你點傢伙
一些真正真棒資源

795
00:52:45,190 --> 00:52:47,550
可在網上。

796
00:52:47,550 --> 00:52:52,270
>> 顯然，蘋果公司文檔
將是非常有益的。

797
00:52:52,270 --> 00:52:57,630
但除此之外，我特別
推薦四個來源，學校代碼，

798
00:52:57,630 --> 00:53:02,120
樹屋，AppCoda和WWDC視頻。

799
00:53:02,120 --> 00:53:07,270
代碼學校，樹屋是
兩個在線育人的網站，

800
00:53:07,270 --> 00:53:10,210
其中特別關注
軟件工程。

801
00:53:10,210 --> 00:53:16,930
特別是對學校的代碼，他們
對iOS的真正的好教程。

802
00:53:16,930 --> 00:53:19,550
>> 這是一個非常簡單的例子吧。

803
00:53:19,550 --> 00:53:22,980
他們實際上創造一個真正cute--
看看這個小可愛iPhone

804
00:53:22,980 --> 00:53:24,920
花花公子那邊，這是相當真棒。

805
00:53:24,920 --> 00:53:31,010
和他們的方式解釋目的
C語法是完全清楚的。

806
00:53:31,010 --> 00:53:32,230
樹屋是一樣的。

807
00:53:32,230 --> 00:53:34,660
和AppCoda是一個論壇。

808
00:53:34,660 --> 00:53:38,130
它實際上是運行一個博客
一個真正有經驗目標C

809
00:53:38,130 --> 00:53:39,120
程序員。

810
00:53:39,120 --> 00:53:43,950
而在AppCoda所有這些教程
很短，很容易實現，

811
00:53:43,950 --> 00:53:45,390
強烈推薦。

812
00:53:45,390 --> 00:53:47,700
>> 如果你是一名開發人員，
肯定是去檢查

813
00:53:47,700 --> 00:53:55,660
在那裡你可以如何WWDC視頻
了解最新的iOS編程

814
00:53:55,660 --> 00:53:58,250
技術，API和庫。

815
00:53:58,250 --> 00:54:02,850
所以這是一個很值得
它的研討會。

816
00:54:02,850 --> 00:54:03,820
太謝謝你了。

817
00:54:03,820 --> 00:54:08,040
我希望你玩得開心
創建自己的iOS應用。

818
00:54:08,040 --> 00:54:09,302