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