1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Семинар] [IOS: Написание приложений, таких как Boss]

2
00:00:02,000 --> 00:00:04,000
[Tommy MacWilliam] [Гарвардский университет]

3
00:00:04,000 --> 00:00:08,000
[Это CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Ладно, все, добро пожаловать в IOS: Написание приложений, таких как Boss.

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
несколько различных примеров того, как сделать приложение, простой игре, как Tic Tac Toe,

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, так что вам необходимо иметь Mac

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
Если вы хотите, чтобы приложение, но не имеют Mac, не волнуйтесь.

23
00:01:07,000 --> 00:01:09,000
Там есть много кампуса ресурсов для этого.

24
00:01:09,000 --> 00:01:15,000
И тогда мы собираемся охватить 2 больших примеры различных приложений, которые вы можете сделать.

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
Некоторые из этих функций включают в себя не того, чтобы когда-нибудь написать таНос раз, слава Богу,

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
Когда мы объявили структуру, мы можем только сказать, Int 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
мы в основном говорят, что кто-то более на Apple, вероятно, действительно хорошие люди,

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
Это будет то, что внутри нашего. Файлов час.

91
00:04:51,000 --> 00:04:55,000
Так же, как в С нашим. Ч файлы в основном сказали, вот некоторые вещи, которые будут существовать.

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
Позже внутри нашего. М. файлы, потому что м для 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
Внутри нашей. М. файл, который мы собираемся сказать вот то, что все функции

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
Когда мы объявили функций в C мы сказали что-то вроде Int Foo

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
Он собирается вернуться ничего, так что это будет типа недействительными.

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
п структуры узла, и что на самом деле созданы

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
Это эквивалентно таНос. Мы не должны говорить таНос больше.

164
00:08:37,000 --> 00:08:42,000
Мы бросили м, сделали его идентификатор, и заменил. С с. Метров.

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
или что-то вроде этого, и поэтому этот метод инициализации является то, что на самом деле создает объект.

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
Затем мы возвращаем эту вещь в объект, о.

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
В этом объект О, так это значит, что, если я определил

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 метод, так что это занимает от 2 аргументов.

182
00:09:38,000 --> 00:09:44,000
Это вызов одной функции на этом объекте °.

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
Если я называю методом Длина этого объекта с

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
Это метод, который говорит на эту строку с

207
00:10:54,000 --> 00:10:57,000
Я хочу, чтобы вы нулевом характер,

208
00:10:57,000 --> 00:10:59,000
и так это было бы вернуться ко мне с характером,

209
00:10:59,000 --> 00:11:02,000
и есть целая куча более из этих методов, которые вы можете Google очень легко.

210
00:11:02,000 --> 00:11:07,000
Документации Apple, является большим, и мы взглянем на этом немного позже.

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
Опять же, просто называя эти 2 способа.

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
Я хочу добавить объект в массив, и я хочу, чтобы добавить строку 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
Кстати, внутри много библиотек Apple, вы увидите, что это 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
назад, когда Apple, впервые начинающих.

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
Чтобы попасть сюда, я сначала скачал XCode из App Store,

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.

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
Это первая линия, если я скажу, студенческая * Алиса = [[Студенческие идентификатор] Init] Что это делаешь?

261
00:13:46,000 --> 00:13:50,000
Это первый студент здесь, это, вероятно, класса.

262
00:13:50,000 --> 00:13:54,000
Это не класс, Apple, пишет, но это класс, который я написал.

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
. Ч файла, помню, где я заявляю, все вещи,

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
Это означает, что мой студент, если бы это была структура, это будут 2 вещи

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
Вот, теперь я внутри моего. Файл м,

292
00:15:38,000 --> 00:15:40,000
м для реализации, я думаю.

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
Первое, что я хочу сделать, это я хочу обратить инициализации на это супер вещь.

303
00:16:11,000 --> 00:16:15,000
>> Помните, что, когда я сказал назад здесь, в. Файл ч

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
Тогда, если это правильно инициализирован это, как говорят, если таНос

312
00:16:46,000 --> 00:16:50,000
не вернуть нулевой, то я могу начать установку некоторых свойств.

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 Init,

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
Ладно, так это само = супер INIT,

327
00:17:34,000 --> 00:17:37,000
если вы не совсем понимаете наследства вещи не волнуйтесь.

328
00:17:37,000 --> 00:17:40,000
Просто знайте, что если вы хотите сделать свой собственный метод инициализации просто

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
Это означает, что, когда мы таНос то, что мы всегда проверяется, если она была равна нулю,

332
00:17:49,000 --> 00:17:51,000
и если она была нулевой, то мы вышли.

333
00:17:51,000 --> 00:17:55,000
Это то же самое, потому что, если это возвращает нуль, то мы, вероятно, будет сегменте вина

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
Если я скажу, студент идентификатор инициализации я не использую этот способ, что я только что написал,

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
Я могу просто сказать, идентификатор, а затем вместо того, чтобы говорить инициализации

342
00:18:20,000 --> 00:18:24,000
Я буду называть это метод, который я только что создали, и я собираюсь пройти в Боб.

343
00:18:24,000 --> 00:18:30,000
На данный момент, этот объект Боб имеет имя, совпадающее с Бобом.

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
Вот у меня есть 2 объекта.

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 в Interface Builder

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
Вы управляете щелкните там, где он говорит View Controller.

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
и я собираюсь нажать Одна заявка View.

399
00:21:28,000 --> 00:21:31,000
Я собираюсь нажмите кнопку Далее. Я дам моему проекту имя.

400
00:21:31,000 --> 00:21:33,000
Я буду называть его Hello.

401
00:21:33,000 --> 00:21:36,000
Интересно, Apple предполагает, что вы создаете продукт

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
, который является приятной особенностью, которая предотвращает Вас от необходимости говорить таНос и бесплатно.

410
00:21:58,000 --> 00:22:03,000
Если вы хотите позвонить таНос и свободно, я хотел бы оставить это проверено.

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
и это, опять же, некоторым классом, который писал, что Apple, делает много полезных вещей для нас

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
Это шаблонный код, который Apple, дает мне бесплатно.

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
сказать что-то заманчиво, как "Press Me".

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 действительно хорош и autocompletes для меня.

468
00:25:06,000 --> 00:25:09,000
Это действительно замечательно.

469
00:25:09,000 --> 00:25:12,000
Заметьте, что внутри. М. файла я могу также сказать, пустота,

470
00:25:12,000 --> 00:25:15,000
и это потому, что IBAction на самом деле не тип.

471
00:25:15,000 --> 00:25:19,000
Это на самом деле хэштэг определена где-то быть пустота,

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
и это класс, который Apple, писал, что собирается показывать назойливые всплывающие окна.

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
Если я хочу на самом деле показать всплывающее окно я хочу назвать шоу методом.

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
Если я забыл, что это такое, если я только что ввели в с,

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
более здесь, где он говорит View Controller.

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
Это все те методы, которые я объявил в моем ч файла 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
и тот, который я только что зарегистрировался это событие называется Touch Up Inside,

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
Например, в Tic Tac Toe у меня есть 9 кнопок,

546
00:29:08,000 --> 00:29:11,000
и было бы супер, супер раздражает нужно перетащить 9 раз

547
00:29:11,000 --> 00:29:14,000
или если я должен был сделать Tic Tac Toe с 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
когда у нас были такие вещи, как идентификаторы и имена, и мы можем искать вещи

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
Давайте взглянем на это, здание Tic Tac Toe.

560
00:29:58,000 --> 00:30:01,000
Во-первых, это мои раскадровки.

561
00:30:01,000 --> 00:30:05,000
Я создал эти 10 кнопок интерфейса.

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
В основном это Первый массив, представляющий где Xs и ОС.

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
и так еще в Царапины у нас были разные темы,

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
Я не собираюсь на самом деле выделить или инициализации этого сам.

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
>> Мы не будем вдаваться слишком много логики Tic Tac Toe,

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
Touch Up Inside подключен к 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
Так же, как мы могли бы бросить на целые поплавки и наоборот

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
Теперь у нас есть Tic Tac Toe логика.

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
из логики Toe Tic Tac, но теперь вы можете видеть, что на самом деле

678
00:36:06,000 --> 00:36:09,000
все, что мы делаем, мы цикл по этому массиву,

679
00:36:09,000 --> 00:36:13,000
поэтому мы имеем пару циклов здесь, и мы просто сравнение, чтобы увидеть

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
Столь же захватывающий, как Tic Tac Toe было, много приложений внутри 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
если возвращаемый тип является ничтожным, я назвал его 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 и бар.

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
Внутри. Файл ч я дал обещание.

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
>> Если бы я приехал сюда в моей. М. файла, я реализовал один из таких методов.

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
На моем экране у меня есть 2 вещи.

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
Это всего лишь произвольные метод, который Apple, выбрал.

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 для вас,

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
Следующий вопрос, который IOS должен знать, сколько строк у вас есть?

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
Если у вас есть что-то вроде 100000 композиций на ставку

830
00:44:41,000 --> 00:44:45,000
IOS, что не хотите сделать, это выделить 100000 клеток,

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
На ставку или 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
Любые другие проблемы пользовательского интерфейса я могу справиться там.

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
>> Я сказал идентификатор инициализации, создал свой плод массива,

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
One. Все сделано.

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
Текст собственности в строку.

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
это действительно просто внутри Interface Builder.

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
Я определил это визуально внутри Interface Builder.

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
>> Помните, когда я дал, что переход название, это showDivisions,

1025
00:55:25,000 --> 00:55:29,000
Вот как я теперь знаю, что это переход, который был активирован.

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, это свойство переходить.

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
Вы можете видеть здесь, что в файле. ч

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
Вы заметили, в верхней здесь, что вместо того, чтобы говорить # включить

1048
00:56:43,000 --> 00:56:45,000
Я сейчас говорю # импортировать.

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
Если бы мы не хэштэг standardio.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
Просто убедитесь, что в Вашем разные. Файлов м вы убедитесь, что импорт

1058
00:57:19,000 --> 00:57:25,000
соответствующая. ч. файлы, так что компилятор не знает, что происходит.

1059
00:57:25,000 --> 00:57:31,000
>> Наконец, то, что Apple, в конечном счете, делает это показать некоторые данные с помощью веб-просмотра,

1060
00:57:31,000 --> 00:57:35,000
и т.д. Ваш взгляд объекта, в котором Вы можете вставлять

1061
00:57:35,000 --> 00:57:37,000
немного веб-браузер внутри вашего приложения.

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
Ваш может отображаться это для меня, и я могу просматривать вокруг,

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
Это, как отображать веб-страницы.

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
[Студент] Итак, когда вы используете идентификатор, вам никогда не придется ничего бесплатно?

1080
00:58:40,000 --> 00:58:43,000
Именно, когда вы звоните идентификатор инициализации и вам не придется освободить его.

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
но вещи, как установить некоторые свойства для веб-просмотра

1092
00:59:19,000 --> 00:59:22,000
просто вещи, которые вы можете получить, перейдя по ссылке документации Apple,

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
URL-адреса, массивные, так что они сокращены.

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
Я также включил программирования Table View Guide.

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
>> Там много образцов приложений от Apple, которая покажет вам, как это сделать,

1106
01:00:02,000 --> 01:00:05,000
И, наконец, эта последняя является Основные принципы учета человеческого интерфейса,

1107
01:00:05,000 --> 01:00:09,000
и это в основном некоторого обсуждения компонентов пользовательского интерфейса,

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]