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
如果我们不包括hashtag 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]