1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Seminário] [iOS: Escrevendo Aplicativos Like a Boss]

2
00:00:02,000 --> 00:00:04,000
[Tommy MacWilliam] [Harvard University]

3
00:00:04,000 --> 00:00:08,000
[Esta é CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Tudo bem, todos, bem-vindos para iOS: Escrevendo Aplicativos como um chefe.

5
00:00:12,000 --> 00:00:16,000
Este seminário vai se concentrar em escrever aplicativos para o iPhone

6
00:00:16,000 --> 00:00:19,000
e por sua vez a escrever aplicativos para o iPad, e por isso estamos basicamente vai percorrer

7
00:00:19,000 --> 00:00:23,000
alguns exemplos diferentes de como fazer um aplicativo, um jogo simples como Tic Tac Toe,

8
00:00:23,000 --> 00:00:26,000
ou se você está mais interessado em fazer um aplicativo como uma espécie de leitor de notícias

9
00:00:26,000 --> 00:00:30,000
ou algo que interage com a Internet vou falar sobre isso também.

10
00:00:30,000 --> 00:00:32,000
Aqui está a nossa agenda breve.

11
00:00:32,000 --> 00:00:36,000
>> Aplicativos do IOS são escritos em uma linguagem chamada Objective-C,

12
00:00:36,000 --> 00:00:39,000
e por isso este é um pouco semelhante a C, mas não realmente em tudo,

13
00:00:39,000 --> 00:00:41,000
por isso vamos estar falando um pouco sobre a própria linguagem

14
00:00:41,000 --> 00:00:45,000
e como construir aplicativos para o iPhone usando este programa aplicativo chamado XCode,

15
00:00:45,000 --> 00:00:48,000
que se você não tiver baixado ainda sinta-se livre para iniciar o download agora.

16
00:00:48,000 --> 00:00:50,000
É vários gigabytes.

17
00:00:50,000 --> 00:00:54,000
Ele deve ser livre na App Store, por isso você precisa ter um Mac

18
00:00:54,000 --> 00:00:57,000
idealmente rodando a última versão do OS X.

19
00:00:57,000 --> 00:00:59,000
Se você não for, não há problema.

20
00:00:59,000 --> 00:01:02,000
Temos Macs no Centro de Ciências disponíveis para seu uso

21
00:01:02,000 --> 00:01:05,000
com o XCode instalado, e tão à vontade para usar aqueles para o desenvolvimento.

22
00:01:05,000 --> 00:01:07,000
Se você quiser fazer um app, mas não tem um Mac, não se preocupe.

23
00:01:07,000 --> 00:01:09,000
Há uma abundância de recursos do campus para isso.

24
00:01:09,000 --> 00:01:15,000
E então nós estamos indo para cobrir 2 exemplos maiores de aplicativos diferentes que você pode fazer.

25
00:01:15,000 --> 00:01:19,000
Objective-C é tecnicamente o que é chamado um super set de C.

26
00:01:19,000 --> 00:01:24,000
Isso significa que qualquer código C é também o código Objective-C válido.

27
00:01:24,000 --> 00:01:29,000
Isso significa que nós tipo de conduto gravadas em algumas características adicionais para C.

28
00:01:29,000 --> 00:01:33,000
Algumas destas características incluem não ter que escrever sempre malloc novamente, graças a Deus,

29
00:01:33,000 --> 00:01:36,000
sem ter que se preocupar com os ponteiros estúpidas e libertando-os e todas as coisas que

30
00:01:36,000 --> 00:01:40,000
você odiava sobre C, e é uma espécie de desaparecido em Objective-C.

31
00:01:40,000 --> 00:01:43,000
>> Agora, Objective-C também tem uma biblioteca padrão muito maior,

32
00:01:43,000 --> 00:01:47,000
por isso há uma funcionalidade muito mais você começa para dentro livre de Objective-C.

33
00:01:47,000 --> 00:01:50,000
Lembre-se de quando estávamos escrevendo PHP notamos que passou de

34
00:01:50,000 --> 00:01:54,000
este menor linguagem para a biblioteca gigante de todas essas coisas malucas que você pode fazer.

35
00:01:54,000 --> 00:01:56,000
A mesma coisa acontece no iOS.

36
00:01:56,000 --> 00:01:59,000
Há objetos para coisas como o calendário budista, e realmente nada

37
00:01:59,000 --> 00:02:05,000
você pode pensar de, provavelmente, já existe na implementação Objective-C.

38
00:02:05,000 --> 00:02:08,000
A parte objetiva da Objective-C é referência algo

39
00:02:08,000 --> 00:02:11,000
chamado de Programação Orientada a Objetos.

40
00:02:11,000 --> 00:02:14,000
Este é o tipo de um conceito novo, mas temos, na verdade a maioria aprendeu

41
00:02:14,000 --> 00:02:17,000
muitos desses conceitos já.

42
00:02:17,000 --> 00:02:19,000
A idéia por trás Programação Orientada a Objetos é que você está indo para estruturar

43
00:02:19,000 --> 00:02:23,000
um monte de seu código em torno dessas coisas chamadas de classes,

44
00:02:23,000 --> 00:02:26,000
e essas aulas são realmente glorificado estruturas.

45
00:02:26,000 --> 00:02:30,000
Dentro de uma estrutura que basicamente disse aqui é uma coisa,

46
00:02:30,000 --> 00:02:32,000
e esta coisa pode ter membros.

47
00:02:32,000 --> 00:02:35,000
Por exemplo, um nó de uma lista ligada pode ter outras coisas

48
00:02:35,000 --> 00:02:38,000
como um valor, um ponteiro para o próximo nó na lista,

49
00:02:38,000 --> 00:02:44,000
e, juntos, esse ponteiro e esse valor compôs esta instância de uma struct.

50
00:02:44,000 --> 00:02:47,000
As aulas são muito semelhantes, exceto

51
00:02:47,000 --> 00:02:50,000
classes também podem ter funções dentro deles.

52
00:02:50,000 --> 00:02:54,000
Quando declaramos uma estrutura, podemos apenas dizer n int ou * próximo nó.

53
00:02:54,000 --> 00:02:57,000
>> Agora, com o Objective-C, podemos realmente colocar funções

54
00:02:57,000 --> 00:02:59,000
dentro dessas coisas.

55
00:02:59,000 --> 00:03:03,000
Outra coisa que as classes podem fazer é que eles podem herdar dados de outras classes.

56
00:03:03,000 --> 00:03:07,000
Por exemplo, vamos estar a olhar para um monte de built-in classes Objective-C.

57
00:03:07,000 --> 00:03:11,000
Um deles poderia ser a classe que representa o ponto de vista de uma tela,

58
00:03:11,000 --> 00:03:14,000
e assim por dizer eu quero implementar meu próprio ponto de vista

59
00:03:14,000 --> 00:03:18,000
nós basicamente dizer alguém na Apple, as pessoas provavelmente muito legais,

60
00:03:18,000 --> 00:03:21,000
escreveu esta classe para mim, e ele lida com as coisas como mostrar botões

61
00:03:21,000 --> 00:03:25,000
ou tornando a tela, e seria muito triste

62
00:03:25,000 --> 00:03:28,000
para implementar todas as funcionalidades que nós mesmos, e assim, simplesmente

63
00:03:28,000 --> 00:03:31,000
herdar dados, podemos dizer que tudo o que fez na classe

64
00:03:31,000 --> 00:03:34,000
Eu também quero dentro da minha classe, e então eu vou fazer algumas outras coisas,

65
00:03:34,000 --> 00:03:37,000
ou seja, implementar um aplicativo.

66
00:03:37,000 --> 00:03:40,000
Isso é o que a herança palavra significa. Vamos ver um exemplo mais concreto.

67
00:03:40,000 --> 00:03:42,000
>> E, finalmente, a chave com programação orientada a objeto é que

68
00:03:42,000 --> 00:03:45,000
ela conduz a encapsulação de dados.

69
00:03:45,000 --> 00:03:48,000
Em alguns dos nosso problema define poderíamos ter estes grandes, variáveis ​​globais

70
00:03:48,000 --> 00:03:51,000
e globais em toda parte, e é assim que nós manter o controle de estado.

71
00:03:51,000 --> 00:03:55,000
Com aulas podemos começar encapsular informações dentro de um objeto.

72
00:03:55,000 --> 00:03:58,000
Se temos uma tela em nosso app, nós realmente não precisa ter todos os dados de

73
00:03:58,000 --> 00:04:01,000
outra tela em nosso interior app de que,

74
00:04:01,000 --> 00:04:04,000
e assim por encapsular as coisas dentro de classes isso realmente leva

75
00:04:04,000 --> 00:04:08,000
ao projeto do código muito melhor, e isso é possível com alguns dos recursos adicionais

76
00:04:08,000 --> 00:04:11,000
de Objective-C.

77
00:04:11,000 --> 00:04:15,000
Aviso prévio, a sintaxe para Objective-C é bananas.

78
00:04:15,000 --> 00:04:19,000
É como nada que já vimos antes,

79
00:04:19,000 --> 00:04:22,000
por isso é um pouco de uma curva de aprendizado para se acostumar

80
00:04:22,000 --> 00:04:24,000
o que diabos isso significa?

81
00:04:24,000 --> 00:04:27,000
Mas uma vez que você passar por essa curva de aprendizado inicial é realmente, realmente bom

82
00:04:27,000 --> 00:04:29,000
para começar a escrever aplicativos.

83
00:04:29,000 --> 00:04:33,000
>> Para declarar uma classe, a dizer aqui é a minha classe, ele existe,

84
00:04:33,000 --> 00:04:35,000
e, talvez, aqui estão algumas coisas que eu estou indo para definir posteriormente,

85
00:04:35,000 --> 00:04:38,000
Eu vou dizer @ interface.

86
00:04:38,000 --> 00:04:41,000
Eu vou dizer @ interface. Eu vou dar a minha aula de um nome.

87
00:04:41,000 --> 00:04:43,000
E, mais tarde, em outro lugar que eu vou dizer @ final,

88
00:04:43,000 --> 00:04:46,000
e tudo entre a interface eo @ @ end

89
00:04:46,000 --> 00:04:48,000
vai ser minha classe.

90
00:04:48,000 --> 00:04:51,000
Isso vai ser o que está dentro de nossos arquivos. H.

91
00:04:51,000 --> 00:04:55,000
Assim como em C nossos arquivos. H basicamente disse, aqui estão algumas coisas que existem.

92
00:04:55,000 --> 00:04:57,000
Eu não estou necessariamente dizendo o que eles fazem, no entanto,

93
00:04:57,000 --> 00:04:59,000
mas o compilador precisa saber que eles existem.

94
00:04:59,000 --> 00:05:04,000
Mais tarde, dentro da nossa m. Arquivos, porque m para Objective-C

95
00:05:04,000 --> 00:05:08,000
é para onde estamos indo realmente para definir o que essas classes fazem.

96
00:05:08,000 --> 00:05:11,000
Muito parecido com nossos arquivos. C, fornecemos uma implementação para funções.

97
00:05:11,000 --> 00:05:15,000
Dentro do nosso arquivo. M vamos dizer aqui é que todas as funções

98
00:05:15,000 --> 00:05:18,000
dentro da minha classe o que todos fazem.

99
00:05:18,000 --> 00:05:22,000
E, finalmente, dentro de uma estrutura poderíamos dizer dentro dessas chaves

100
00:05:22,000 --> 00:05:25,000
int, ou nó n * próxima

101
00:05:25,000 --> 00:05:28,000
e em Objective-C, vamos usar a palavra-chave @ property

102
00:05:28,000 --> 00:05:31,000
e isto é o que vai definir as propriedades,

103
00:05:31,000 --> 00:05:36,000
ou as funções não-que são uma parte de minhas aulas.

104
00:05:36,000 --> 00:05:40,000
>> Chamando funções em Objective-C é também bananas.

105
00:05:40,000 --> 00:05:43,000
Quando declarou funções em C que disse algo como int foo

106
00:05:43,000 --> 00:05:46,000
e aberto parêntese e depois deu-lhe uma lista de argumentos.

107
00:05:46,000 --> 00:05:51,000
Isto é o que declarar métodos ou funções parece em Objective-C.

108
00:05:51,000 --> 00:05:54,000
Se eu quiser declarar uma função ou um método

109
00:05:54,000 --> 00:05:58,000
onde eu estou dizendo método é realmente apenas uma função que é membro de uma classe,

110
00:05:58,000 --> 00:06:01,000
tão tipo de intercambiáveis, mas não realmente,

111
00:06:01,000 --> 00:06:03,000
tão dentro do meu método eu quero criar um novo método.

112
00:06:03,000 --> 00:06:06,000
Vai retornar nada, por isso vai ser do tipo void.

113
00:06:06,000 --> 00:06:08,000
Este é o tipo de retorno da minha função.

114
00:06:08,000 --> 00:06:11,000
Agora temos parênteses aqui porque, eu não sei.

115
00:06:11,000 --> 00:06:14,000
Em seguida vai ser o nome da minha função,

116
00:06:14,000 --> 00:06:17,000
e, finalmente, temos um ponto e vírgula como tivemos em C.

117
00:06:17,000 --> 00:06:19,000
O que é novo aqui é esse cara aqui.

118
00:06:19,000 --> 00:06:22,000
Este hífen é realmente necessário, eo que isso diz é que

119
00:06:22,000 --> 00:06:26,000
este método aqui deve ser chamado em uma instância de uma classe.

120
00:06:26,000 --> 00:06:29,000
>> Depois que declarou nossas estruturas que provavelmente disse algo como

121
00:06:29,000 --> 00:06:32,000
n nó struct, e que criou

122
00:06:32,000 --> 00:06:35,000
ou instanciado uma dessas estruturas para que eu pudesse realmente começar a trabalhar

123
00:06:35,000 --> 00:06:38,000
com o que está dentro dele, de modo que este traço significa que nós temos que

124
00:06:38,000 --> 00:06:41,000
instanciar a classe assim como nós instanciado que struct

125
00:06:41,000 --> 00:06:43,000
antes de nós pode chamar esse método nele.

126
00:06:43,000 --> 00:06:46,000
Se eu quiser começar a adicionar argumentos para os meus métodos

127
00:06:46,000 --> 00:06:48,000
torna-se ainda mais bananas.

128
00:06:48,000 --> 00:06:50,000
Aqui é o meu nome do método.

129
00:06:50,000 --> 00:06:53,000
Então eu vou ter dois pontos, e após este cólon diz aqui vem alguns argumentos.

130
00:06:53,000 --> 00:06:56,000
Este método tem um argumento.

131
00:06:56,000 --> 00:06:59,000
O tipo do argumento é um int, eo nome do que o argumento

132
00:06:59,000 --> 00:07:03,000
ou a variável que eu vou começar a usar dentro do método é chamado de i.

133
00:07:03,000 --> 00:07:05,000
Novamente, este é o método. Ela tem um argumento.

134
00:07:05,000 --> 00:07:10,000
>> Se você quer começar a adicionar mais argumentos fica mais bananas

135
00:07:10,000 --> 00:07:13,000
em que temos esta cólon que diz aqui vem a minha lista de argumentos.

136
00:07:13,000 --> 00:07:15,000
Este primeiro argumento é um inteiro.

137
00:07:15,000 --> 00:07:17,000
Agora, este segundo argumento é interessante.

138
00:07:17,000 --> 00:07:20,000
A variável que eu vou estar usando dentro da minha função

139
00:07:20,000 --> 00:07:23,000
é chamado de f, para dentro da minha função eu poderia dizer

140
00:07:23,000 --> 00:07:25,000
f + = 1 ou algo assim.

141
00:07:25,000 --> 00:07:30,000
Isso aqui é basicamente uma chave para que o argumento ou parâmetro.

142
00:07:30,000 --> 00:07:34,000
Assim como tivemos pares de valores-chave e algo como JSON ou arrays associativos

143
00:07:34,000 --> 00:07:37,000
Objective-C tomou a decisão de dizer, ok, só para que fique bem claro

144
00:07:37,000 --> 00:07:39,000
quando você chamar um método que todos estes parâmetros são

145
00:07:39,000 --> 00:07:41,000
Eu estou indo realmente para nomeá-los todos.

146
00:07:41,000 --> 00:07:45,000
Quando você chama um método, você vai realmente dizer andFloat,

147
00:07:45,000 --> 00:07:47,000
e então você vai passá-lo dentro

148
00:07:47,000 --> 00:07:50,000
>> Curiosamente, este não é nomeado, mas todos os outros parâmetros são,

149
00:07:50,000 --> 00:07:53,000
por isso, se tivéssemos um argumento 3 que eu poderia dizer andFloat

150
00:07:53,000 --> 00:07:56,000
e uma outra bóia e assim por diante.

151
00:07:56,000 --> 00:08:01,000
Quando eu chamar esses métodos é de bananas do curso,

152
00:08:01,000 --> 00:08:04,000
Então, se eu tenho um objeto, e eu definido um método chamado foo,

153
00:08:04,000 --> 00:08:09,000
e quero chamá-lo, em vez de dizer foo aberto / parens próximos

154
00:08:09,000 --> 00:08:11,000
Eu vou abrir um parêntese.

155
00:08:11,000 --> 00:08:13,000
Aqui está o nome do meu método.

156
00:08:13,000 --> 00:08:17,000
Eu vou fechar o suporte, e esse é o objeto que eu estou chamando-o.

157
00:08:17,000 --> 00:08:20,000
Lembre-se, todos estes métodos existem dentro de classes

158
00:08:20,000 --> 00:08:23,000
porque as classes podem ter métodos definidos dentro deles.

159
00:08:23,000 --> 00:08:26,000
>> Aqui eu arbitrariamente criado um objeto de alguma classe,

160
00:08:26,000 --> 00:08:28,000
e esta é a sintaxe para fazer isso.

161
00:08:28,000 --> 00:08:31,000
Há dois passos para a criação de um objeto.

162
00:08:31,000 --> 00:08:34,000
O primeiro passo é dizer que eu quero alocar espaço.

163
00:08:34,000 --> 00:08:37,000
Isto é o equivalente de um malloc. Não temos a dizer malloc mais.

164
00:08:37,000 --> 00:08:42,000
Nós derrubamos o m, fez alloc, e substituiu o c. Com. M.

165
00:08:42,000 --> 00:08:47,000
Depois que algo alloc que precisa então para o inicializar.

166
00:08:47,000 --> 00:08:49,000
Basicamente, quando você cria objetos que você pode querer ter alguma lógica

167
00:08:49,000 --> 00:08:53,000
que é executado quando eles são criados, assim você pode passar em alguns valores padrão

168
00:08:53,000 --> 00:08:57,000
ou algo assim, e por isso este método init é o que realmente cria o objeto.

169
00:08:57,000 --> 00:08:59,000
Nós primeiro alocar espaço, assim como fizemos em C,

170
00:08:59,000 --> 00:09:04,000
e, então, inicializar, o que pode ou não pode fazer muita coisa.

171
00:09:04,000 --> 00:09:07,000
Então, nós estamos retornando essa coisa em um o objeto.

172
00:09:07,000 --> 00:09:09,000
Há uma estrela aqui porque este é, tecnicamente, um ponteiro,

173
00:09:09,000 --> 00:09:12,000
mas não se preocupe, os ponteiros não são grande coisa em Objective-C mais.

174
00:09:12,000 --> 00:09:15,000
>> Agora nós instanciado esta classe chamada NSObject,

175
00:09:15,000 --> 00:09:19,000
e esta é apenas uma classe aleatória que a Apple tem.

176
00:09:19,000 --> 00:09:22,000
Nós instanciado isso, e agora eu tenho uma instância da classe

177
00:09:22,000 --> 00:09:25,000
neste o objeto, o que significa que se eu definido

178
00:09:25,000 --> 00:09:29,000
estes métodos que eu poderia chamá-los assim.

179
00:09:29,000 --> 00:09:31,000
Da mesma forma, se eu quisesse chamar um método com um argumento,

180
00:09:31,000 --> 00:09:34,000
por isso este é o método de bar, que tem um argumento,

181
00:09:34,000 --> 00:09:38,000
e aqui é o baz: método qux, então isso leva 2 argumentos.

182
00:09:38,000 --> 00:09:44,000
Isso está chamando uma função nesta o objeto.

183
00:09:44,000 --> 00:09:46,000
Faz sentido?

184
00:09:46,000 --> 00:09:50,000
A sintaxe deve fazer sentido, mas você meio que se acostumar com isso.

185
00:09:50,000 --> 00:09:54,000
>> Ok, vamos falar sobre algumas coisas que são construídos em Objective-C

186
00:09:54,000 --> 00:09:56,000
que não foram necessariamente construído em C.

187
00:09:56,000 --> 00:09:59,000
Em que tipo de C teve de lidar com as seqüências como essas matrizes de caráter estúpidas,

188
00:09:59,000 --> 00:10:01,000
e ele ficou realmente irritante.

189
00:10:01,000 --> 00:10:04,000
Objective-C tem todos aqueles construído em para nós, e é construído em

190
00:10:04,000 --> 00:10:06,000
usando esta classe chamada NSString.

191
00:10:06,000 --> 00:10:10,000
Quando eu quero criar um NSString temos sintaxe mais misterioso.

192
00:10:10,000 --> 00:10:15,000
Ao invés de dizer "CS50", dizemos @ "CS50"

193
00:10:15,000 --> 00:10:17,000
e esta é apenas a sintaxe para declarar strings em Objective-C.

194
00:10:17,000 --> 00:10:21,000
Isso é extremamente fácil de esquecer, por isso não.

195
00:10:21,000 --> 00:10:24,000
Agora, uma vez que tenho isso, isso é uma seqüência, mas observe

196
00:10:24,000 --> 00:10:26,000
é realmente apenas um objeto.

197
00:10:26,000 --> 00:10:30,000
Eu disse NSString, o que significa que a classe instanciada

198
00:10:30,000 --> 00:10:32,000
chamada NSString, que alguém escreveu para mim,

199
00:10:32,000 --> 00:10:35,000
e eles foram muito agradável sobre ele, e por isso agora

200
00:10:35,000 --> 00:10:37,000
Eu posso começar a chamar métodos nele.

201
00:10:37,000 --> 00:10:40,000
Se eu chamar o comprimento método nesta s objeto

202
00:10:40,000 --> 00:10:43,000
ele vai voltar para mim o comprimento da corda.

203
00:10:43,000 --> 00:10:45,000
Este é apenas como strlen em C.

204
00:10:45,000 --> 00:10:47,000
Este voltaria 4.

205
00:10:47,000 --> 00:10:51,000
>> Da mesma forma, um outro método que eu poderia querer se preocupar com isso é characterAtIndex.

206
00:10:51,000 --> 00:10:54,000
Este é um método que diz sobre este string s

207
00:10:54,000 --> 00:10:57,000
Eu quero você para obter o caractere 0,

208
00:10:57,000 --> 00:10:59,000
e assim que este voltaria para mim o caractere c,

209
00:10:59,000 --> 00:11:02,000
e há um monte mais desses métodos que você pode Google realmente fácil.

210
00:11:02,000 --> 00:11:07,000
Documentação da Apple é grande, e nós vamos dar uma olhada no que a pouco.

211
00:11:07,000 --> 00:11:09,000
Essas são cordas.

212
00:11:09,000 --> 00:11:11,000
Temos também matrizes de tamanho variável construído dentro

213
00:11:11,000 --> 00:11:13,000
Lembre-se no C quando declaramos uma matriz

214
00:11:13,000 --> 00:11:16,000
nós tivemos que dizer que você tem 5 elementos, fim da história.

215
00:11:16,000 --> 00:11:18,000
Quando chegamos ao JavaScript e PHP poderíamos começar

216
00:11:18,000 --> 00:11:20,000
fazer as coisas como a adição de elementos ou movendo elementos.

217
00:11:20,000 --> 00:11:22,000
Nós podemos fazer o mesmo em Objective-C.

218
00:11:22,000 --> 00:11:26,000
Em vez de criar uma matriz no caminho C normal

219
00:11:26,000 --> 00:11:30,000
temos novamente uma outra classe chamada NSMutableArray.

220
00:11:30,000 --> 00:11:33,000
Há também NSArray,

221
00:11:33,000 --> 00:11:35,000
e isso vai basicamente encapsular alguns matriz.

222
00:11:35,000 --> 00:11:38,000
Este diz que a primeira coisa que eu quero fazer é que eu quero para alocar

223
00:11:38,000 --> 00:11:41,000
espaço para uma nova matriz, e depois que eu atribuí-lo

224
00:11:41,000 --> 00:11:43,000
Eu, então, precisa inicializá-lo.

225
00:11:43,000 --> 00:11:45,000
Novamente, basta chamar esses dois métodos.

226
00:11:45,000 --> 00:11:48,000
Agora, isso significa que dentro deste objeto de um

227
00:11:48,000 --> 00:11:50,000
Eu tenho uma matriz vazia sentado lá.

228
00:11:50,000 --> 00:11:54,000
Se eu quiser adicionar algo a essa matriz, eu posso chamar o método addObject.

229
00:11:54,000 --> 00:11:59,000
Eu quero adicionar um objeto para a matriz, e eu quero adicionar a string CS50.

230
00:11:59,000 --> 00:12:02,000
Se eu quisesse remover inversamente que eu posso dizer que eu quero

231
00:12:02,000 --> 00:12:09,000
remover o objeto em primeiro lugar na matriz ou um objeto.

232
00:12:09,000 --> 00:12:11,000
>> Faz sentido?

233
00:12:11,000 --> 00:12:14,000
Ok, você meio que se acostumar com essa coisa colchete.

234
00:12:14,000 --> 00:12:18,000
A propósito, dentro de um monte de bibliotecas da Apple você verá este NS.

235
00:12:18,000 --> 00:12:21,000
O NS está realmente para próxima etapa, que foi uma das empresas de Steve Jobs primeira,

236
00:12:21,000 --> 00:12:24,000
e é aí que ele realmente começou a escrever um monte de código

237
00:12:24,000 --> 00:12:27,000
como uma espécie de base para o Mac OS X e todas as outras coisas,

238
00:12:27,000 --> 00:12:32,000
e por isso este tipo de NS é esse legado bom gritar para uma das empresas mais antigas

239
00:12:32,000 --> 00:12:34,000
volta, quando a Apple foi a primeira partida.

240
00:12:34,000 --> 00:12:36,000
Está em toda parte.

241
00:12:36,000 --> 00:12:41,000
Vamos dar uma olhada em um exemplo mais holística Objective-C.

242
00:12:41,000 --> 00:12:44,000
Aqui eu estou dentro de XCode.

243
00:12:44,000 --> 00:12:47,000
Para chegar até aqui, eu primeiro baixado XCode da App Store,

244
00:12:47,000 --> 00:12:50,000
abriu-se, e então eu fui até aqui para arquivo,

245
00:12:50,000 --> 00:12:54,000
cá para novo projeto, e então.

246
00:12:54,000 --> 00:12:57,000
Depois de eu fazer isso eu tenho todas essas opções do que eu quero para criar,

247
00:12:57,000 --> 00:12:59,000
e assim vamos dar uma olhada nessas opções mais tarde,

248
00:12:59,000 --> 00:13:03,000
mas apenas para este exemplo, porque não estamos realmente vai ter um aplicativo, no entanto,

249
00:13:03,000 --> 00:13:06,000
Eu vim aqui, e eu disse ferramenta de linha de comando,

250
00:13:06,000 --> 00:13:09,000
e este é um aplicativo que eu poderia correr na linha de comando

251
00:13:09,000 --> 00:13:12,000
como temos vindo a execução de C.

252
00:13:12,000 --> 00:13:16,000
É assim que eu criei este projeto, e agora eu estou aqui,

253
00:13:16,000 --> 00:13:20,000
então vamos primeiro olhar para este arquivo, e isso deve olhar muito familiar.

254
00:13:20,000 --> 00:13:24,000
Eu tenho um nome int. Não é o meu argc amigo, meu outro amigo argv.

255
00:13:24,000 --> 00:13:30,000
E assim podemos ver que este é o ponto de entrada para a minha candidatura Objective-C primeiro.

256
00:13:30,000 --> 00:13:32,000
Aqui podemos ignorar isso por enquanto.

257
00:13:32,000 --> 00:13:35,000
Este é basicamente algumas coisas gerenciamento de memória que você não vai realmente

258
00:13:35,000 --> 00:13:37,000
sempre tem que se preocupar.

259
00:13:37,000 --> 00:13:39,000
>> Vamos olhar para este primeiro bloco aqui.

260
00:13:39,000 --> 00:13:46,000
Esta primeira linha, se eu disser Estudante * alice = [[alloc Estudante] init] o que é que está fazendo?

261
00:13:46,000 --> 00:13:50,000
Este primeiro aluno aqui, esta é provavelmente uma classe.

262
00:13:50,000 --> 00:13:54,000
Esta não é uma classe que a Apple escreveu, mas é uma classe que eu escrevi.

263
00:13:54,000 --> 00:13:57,000
A primeira coisa que quero fazer é que eu quero alocar espaço para um novo aluno,

264
00:13:57,000 --> 00:14:00,000
e então eu quero para inicializar, então isso me dá de volta

265
00:14:00,000 --> 00:14:05,000
este objeto novo aluno, e eu sou armazenar isso em uma variável chamada Alice.

266
00:14:05,000 --> 00:14:07,000
Onde foi que a classe vem?

267
00:14:07,000 --> 00:14:12,000
Bem, aqui do lado esquerdo são todos os arquivos diferentes dentro do meu projeto.

268
00:14:12,000 --> 00:14:16,000
Podemos ver aqui eu tenho um Student.h e um Student.m.

269
00:14:16,000 --> 00:14:20,000
O. Arquivo h, lembre-se, é onde eu declaro todas as coisas

270
00:14:20,000 --> 00:14:22,000
que existirá dentro da classe.

271
00:14:22,000 --> 00:14:25,000
>> Vamos dar uma olhada nisso.

272
00:14:25,000 --> 00:14:29,000
Tudo bem, aqui temos esta interface @, e este diz que aqui vem

273
00:14:29,000 --> 00:14:33,000
as declarações de tudo o que vai existir dentro de minha classe.

274
00:14:33,000 --> 00:14:36,000
Então eu tenho dois pontos. Então eu tenho essa coisa NSObject.

275
00:14:36,000 --> 00:14:40,000
Isso significa que pouco cólon herança estávamos discutindo um pouco mais cedo.

276
00:14:40,000 --> 00:14:43,000
Isto diz tudo o que um pode fazer NSObject

277
00:14:43,000 --> 00:14:46,000
onde NSObject é esta classe escrito por outra pessoa,

278
00:14:46,000 --> 00:14:50,000
tudo o que este pode fazer NSObject Eu quero ser capaz de fazer isso.

279
00:14:50,000 --> 00:14:54,000
Ao dizer: NSObject que significa que eu, basicamente,

280
00:14:54,000 --> 00:14:58,000
herdado toda a funcionalidade de uma outra classe.

281
00:14:58,000 --> 00:15:02,000
Isso realmente me deu um monte de diferentes métodos e propriedades que eu possa usar.

282
00:15:02,000 --> 00:15:05,000
Aqui embaixo eu estou criando duas propriedades.

283
00:15:05,000 --> 00:15:08,000
Isso significa que o meu aluno, se este fosse uma estrutura, estes seriam os 2 coisas

284
00:15:08,000 --> 00:15:11,000
dentro da minha estrutura, de modo que cada aluno tem um nome

285
00:15:11,000 --> 00:15:14,000
que é uma string, e um estudante também tem um grau,

286
00:15:14,000 --> 00:15:17,000
que é um int.

287
00:15:17,000 --> 00:15:23,000
>> Finalmente, aqui eu vou criar um método para meu aluno.

288
00:15:23,000 --> 00:15:26,000
Liguei para o meu método, initWithName, e leva um argumento,

289
00:15:26,000 --> 00:15:31,000
e esse argumento é uma string, e eu chamei ele nomear.

290
00:15:31,000 --> 00:15:35,000
Agora vamos olhar como nós realmente implementado nesta classe.

291
00:15:35,000 --> 00:15:38,000
Aqui, agora eu estou dentro do meu arquivo m.,

292
00:15:38,000 --> 00:15:40,000
m para a implementação, eu acho.

293
00:15:40,000 --> 00:15:44,000
Eu tenho a minha aplicação, o meu fim, e aqui é onde eu estou, na verdade, a definição de

294
00:15:44,000 --> 00:15:47,000
o que faz initWithName.

295
00:15:47,000 --> 00:15:50,000
Tenho initWithName, o nome do meu parâmetro, e então esta

296
00:15:50,000 --> 00:15:53,000
é onde eu estou, na verdade, a criação de um estudante,

297
00:15:53,000 --> 00:15:56,000
e por isso este é um pouco enigmático, mas este é o tipo de clichê

298
00:15:56,000 --> 00:15:58,000
que você deseja incluir em seus construtores.

299
00:15:58,000 --> 00:16:02,000
Esta função de inicialização aqui, initWithName, é um tipo de construtor.

300
00:16:02,000 --> 00:16:05,000
Você está basicamente a construção de um objeto novo aluno

301
00:16:05,000 --> 00:16:07,000
e talvez o envio de alguns dados dentro dela.

302
00:16:07,000 --> 00:16:11,000
A primeira coisa que quero fazer é que eu quero chamar o init nesta coisa super.

303
00:16:11,000 --> 00:16:15,000
>> Lembre-se que quando eu disse aqui no arquivo h.

304
00:16:15,000 --> 00:16:21,000
que tudo um NSObject tem um estudante também tem.

305
00:16:21,000 --> 00:16:24,000
Isso significa que quando eu crio um estudante que eu também preciso fazer é

306
00:16:24,000 --> 00:16:28,000
certifique-se de que o NSObject que estou herdando todos os dados a partir de

307
00:16:28,000 --> 00:16:32,000
É também inicializado adequadamente.

308
00:16:32,000 --> 00:16:36,000
O que eu preciso dizer é o super é realmente indo para referir-se a classe pai

309
00:16:36,000 --> 00:16:39,000
que eu estou herdando, assim que eu quero me certificar de que inicializar

310
00:16:39,000 --> 00:16:43,000
tudo o que eu estou dependendo antes de eu começar a tentar usá-lo.

311
00:16:43,000 --> 00:16:46,000
Então, se isso inicializado corretamente este é apenas como dizer se malloc

312
00:16:46,000 --> 00:16:50,000
não retornar nulo, então eu posso começar a definir algumas propriedades.

313
00:16:50,000 --> 00:16:54,000
>> Em JavaScript e PHP tínhamos esta palavra-chave chamada isso,

314
00:16:54,000 --> 00:16:58,000
e isso se refere à instância atual de uma classe.

315
00:16:58,000 --> 00:17:00,000
Em Objective-C chamamos isso de si mesmo.

316
00:17:00,000 --> 00:17:04,000
Quando eu digo self.name, o que significa que o objeto

317
00:17:04,000 --> 00:17:07,000
Acabei de criar quando disse alloc estudante init,

318
00:17:07,000 --> 00:17:09,000
que vai me dar de volta um objeto.

319
00:17:09,000 --> 00:17:12,000
Isso significa que eu quero para definir o nome do objeto

320
00:17:12,000 --> 00:17:15,000
para o que eu apenas passado dentro

321
00:17:15,000 --> 00:17:18,000
Assim como em C, temos acesso a membros com este ponto,

322
00:17:18,000 --> 00:17:21,000
assim self.name diz o nome do objeto de estudante

323
00:17:21,000 --> 00:17:24,000
agora vai ser o que você acabou de passar dentro

324
00:17:24,000 --> 00:17:28,000
E assim, finalmente, eu posso devolvê-lo assim que eu realmente voltar algo.

325
00:17:28,000 --> 00:17:30,000
>> Perguntas?

326
00:17:30,000 --> 00:17:34,000
Ok, então essa auto = super-init,

327
00:17:34,000 --> 00:17:37,000
se você não compreender totalmente o material herança não se preocupe.

328
00:17:37,000 --> 00:17:40,000
Só sei que se você quiser fazer o seu próprio método de inicialização apenas

329
00:17:40,000 --> 00:17:42,000
fazer isso, e você vai ser bom para ir.

330
00:17:42,000 --> 00:17:44,000
Sim. >> [Estudante] O que se auto média?

331
00:17:44,000 --> 00:17:49,000
Isto significa que quando nós malloc algo que sempre verificado se ele era igual a nulo,

332
00:17:49,000 --> 00:17:51,000
e se era nulo, então saímos.

333
00:17:51,000 --> 00:17:55,000
Esta é a mesma coisa, porque se este retorna nulo, então nós provavelmente vamos culpa seg

334
00:17:55,000 --> 00:17:57,000
se começar a tentar manipulá-lo.

335
00:17:57,000 --> 00:18:01,000
Essa é a nossa classe estudantil.

336
00:18:01,000 --> 00:18:03,000
Isso significa que podemos iniciar nossos alunos em uma de duas maneiras.

337
00:18:03,000 --> 00:18:08,000
Se eu disser que o init alloc estudante eu não estou usando esse método que eu escrevi,

338
00:18:08,000 --> 00:18:11,000
e em vez disso eu posso simplesmente dizer alice.name,

339
00:18:11,000 --> 00:18:14,000
e agora eu estou indo para definir que o nome da propriedade.

340
00:18:14,000 --> 00:18:17,000
>> Da mesma forma, se eu quiser usar esse método initWithName

341
00:18:17,000 --> 00:18:20,000
Eu posso simplesmente dizer alloc, e depois ao invés de dizer o init

342
00:18:20,000 --> 00:18:24,000
Eu vou chamar esse método que acabei de criar, e eu vou passar em Bob.

343
00:18:24,000 --> 00:18:30,000
Neste ponto, o Bob objeto tem um nome igual ao Bob.

344
00:18:30,000 --> 00:18:35,000
Ok, aqui eu estou usando o que NSMutableArray que vimos anteriormente.

345
00:18:35,000 --> 00:18:38,000
Estou alocando space.Then estou inicializando uma nova matriz.

346
00:18:38,000 --> 00:18:40,000
Eu estou indo para adicionar 2 coisas a ele.

347
00:18:40,000 --> 00:18:43,000
Esta matriz agora detém objetos estudantes.

348
00:18:43,000 --> 00:18:46,000
Repare que em nenhum lugar que eu tenho que dizer que este é um conjunto de alunos.

349
00:18:46,000 --> 00:18:48,000
Eu disse que é uma matriz, período.

350
00:18:48,000 --> 00:18:50,000
Então eu posso colocar o que dentro dele que eu quero.

351
00:18:50,000 --> 00:18:52,000
Aqui eu tenho dois objetos.

352
00:18:52,000 --> 00:18:56,000
>> Finalmente, tenho um outro objeto aqui, este TF.

353
00:18:56,000 --> 00:18:59,000
Aqui em TF.h basicamente a mesma coisa.

354
00:18:59,000 --> 00:19:01,000
Estou herdando de NSObject, e, a propósito,

355
00:19:01,000 --> 00:19:03,000
quando você criar classes de tudo isto é feito para você,

356
00:19:03,000 --> 00:19:06,000
esse tipo de clichê interface.

357
00:19:06,000 --> 00:19:08,000
Ele tem uma propriedade de estudantes.

358
00:19:08,000 --> 00:19:15,000
Eu tenho um par de métodos aqui que realmente não fazer muito,

359
00:19:15,000 --> 00:19:18,000
e então isso significa que depois de eu criar esse objeto TF

360
00:19:18,000 --> 00:19:23,000
Eu posso chamar esse método em série assim.

361
00:19:23,000 --> 00:19:26,000
Qualquer dúvida sobre Objective-C sintaxe antes de começar a se mover em um pouco mais de

362
00:19:26,000 --> 00:19:30,000
coisas desenvolvimento interessante aplicativos?

363
00:19:30,000 --> 00:19:34,000
>> Ok, então vamos realmente fazer um aplicativo para iPhone.

364
00:19:34,000 --> 00:19:39,000
As aulas do núcleo que você vai usar dentro de seu aplicativo para iPhone são chamados de controladores de vista,

365
00:19:39,000 --> 00:19:42,000
e um controlador de vista representa basicamente uma única tela

366
00:19:42,000 --> 00:19:46,000
dentro do seu aplicativo, então se eu estou no aplicativo de música, por exemplo,

367
00:19:46,000 --> 00:19:50,000
um controlador de vista pode representar o ponto de vista em que eu ver todas as músicas no meu iPhone.

368
00:19:50,000 --> 00:19:53,000
Outro controlador de vista poderia ser quando eu clico em uma música e começar a jogar

369
00:19:53,000 --> 00:19:55,000
ou como eu estou perfuração para baixo em artistas.

370
00:19:55,000 --> 00:19:59,000
Cada uma dessas telas diferentes podem ser representadas como um controlador de ponto de vista diferente,

371
00:19:59,000 --> 00:20:04,000
e um controlador de vista é realmente apenas uma classe que diz como esta tela funciona.

372
00:20:04,000 --> 00:20:07,000
Coisas dentro de um controlador de vista, nós vamos ter propriedades,

373
00:20:07,000 --> 00:20:10,000
para coisas como um botão que vai ser uma propriedade de nosso controlador de vista.

374
00:20:10,000 --> 00:20:13,000
>> Nós também vamos ter métodos, e estas são, basicamente, manipuladores de eventos.

375
00:20:13,000 --> 00:20:16,000
Este método diz quando você pressionar este botão

376
00:20:16,000 --> 00:20:19,000
Eu quero fazer alguma coisa, e, finalmente, de novo,

377
00:20:19,000 --> 00:20:24,000
vamos estar usando esta palavra-chave auto para acessar a instância atual.

378
00:20:24,000 --> 00:20:29,000
Para construir interfaces no iOS é realmente muito, muito fácil.

379
00:20:29,000 --> 00:20:32,000
Eles têm essa resistência agradável e interface queda chamada Interface Builder,

380
00:20:32,000 --> 00:20:37,000
e os dois conceitos fundamentais que o fio de seu Objective-C para Interface Builder

381
00:20:37,000 --> 00:20:40,000
são IBOutlet e IBAction.

382
00:20:40,000 --> 00:20:44,000
Um IBOutlet simplesmente diz que se você declarar uma propriedade que é um botão,

383
00:20:44,000 --> 00:20:47,000
e você quer ligar-se a algo em sua interface real,

384
00:20:47,000 --> 00:20:49,000
você vai dizer que é uma saída.

385
00:20:49,000 --> 00:20:51,000
Da mesma forma, se você quiser representar um manipulador de eventos

386
00:20:51,000 --> 00:20:54,000
então você vai dizer que é uma ação.

387
00:20:54,000 --> 00:20:57,000
>> Para realmente conectar esta representação gráfica

388
00:20:57,000 --> 00:21:00,000
e seu código é realmente, realmente simples.

389
00:21:00,000 --> 00:21:03,000
Se você deseja anexar um IBOutlet, tudo que você tem a fazer é você controlar clique,

390
00:21:03,000 --> 00:21:05,000
e vamos ver um exemplo disso realmente rápido.

391
00:21:05,000 --> 00:21:07,000
Você controla clique onde diz View Controller.

392
00:21:07,000 --> 00:21:09,000
Você vai arrastar para a interface, ou, inversamente,

393
00:21:09,000 --> 00:21:13,000
se você quiser ligar um manipulador de eventos que vai arrastar a partir da interface

394
00:21:13,000 --> 00:21:15,000
na outra direção.

395
00:21:15,000 --> 00:21:20,000
Vamos dar uma olhada em um exemplo iOS realmente simples.

396
00:21:20,000 --> 00:21:23,000
>> Vamos criar um novo projeto.

397
00:21:23,000 --> 00:21:25,000
Eu vou vir aqui para aplicativo,

398
00:21:25,000 --> 00:21:28,000
e eu vou clique em Aplicativo de visualização simples.

399
00:21:28,000 --> 00:21:31,000
Vou clique em Avançar. Eu vou dar o meu projeto de um nome.

400
00:21:31,000 --> 00:21:33,000
Eu vou chamá-lo Olá.

401
00:21:33,000 --> 00:21:36,000
Curiosamente, a Apple assume que você está criando um produto

402
00:21:36,000 --> 00:21:38,000
de modo que você pode vendê-lo e eles podem fazer dinheiro.

403
00:21:38,000 --> 00:21:41,000
Aqui embaixo vou dizer que este é um aplicativo para iPhone.

404
00:21:41,000 --> 00:21:44,000
Você pode criar um aplicativo para iPad, ou se você quiser criar um desses aplicativos

405
00:21:44,000 --> 00:21:47,000
que suporta ambos os dispositivos que você pode fazer isso também.

406
00:21:47,000 --> 00:21:49,000
Estes são o que você quer que seus checkmarks a aparência.

407
00:21:49,000 --> 00:21:51,000
>> Você quer usar storyboards, que vamos ver mais tarde,

408
00:21:51,000 --> 00:21:54,000
e você definitivamente quer usar a contagem de referência automática,

409
00:21:54,000 --> 00:21:58,000
o que é um bom recurso que impede que você tenha a dizer malloc e free.

410
00:21:58,000 --> 00:22:03,000
A menos que você quiser chamar malloc e free, eu deixaria o marcado.

411
00:22:03,000 --> 00:22:07,000
Eu vou clique em Avançar e, finalmente, isso vai me perguntar onde eu quero salvá-lo.

412
00:22:07,000 --> 00:22:14,000
Eu vou bater criar, e aqui vamos nós.

413
00:22:14,000 --> 00:22:16,000
Eu criei um novo projeto.

414
00:22:16,000 --> 00:22:19,000
Aqui do lado esquerdo são todos os arquivos que estão dentro do meu projeto,

415
00:22:19,000 --> 00:22:22,000
e perceber que eu tenho um monte, e eu não fiz nada.

416
00:22:22,000 --> 00:22:24,000
IOS é grande.

417
00:22:24,000 --> 00:22:27,000
>> Por exemplo, aqui ViewController.h isso,

418
00:22:27,000 --> 00:22:30,000
isso vai representar o meu controlador de primeira vista,

419
00:22:30,000 --> 00:22:32,000
para a primeira tela dentro do meu aplicativo.

420
00:22:32,000 --> 00:22:34,000
Agora sabemos o que isso está dizendo.

421
00:22:34,000 --> 00:22:36,000
Nós estamos dizendo que eu estou chamando este ViewController classe,

422
00:22:36,000 --> 00:22:40,000
e um ViewController faz tudo o que um UIViewController faz,

423
00:22:40,000 --> 00:22:43,000
e isso, novamente, é uma classe que a Apple escreveu que faz um monte de coisa útil para nós

424
00:22:43,000 --> 00:22:46,000
como exibir a tela.

425
00:22:46,000 --> 00:22:50,000
Aqui é onde eu posso realmente começar a definir o que o meu controlador de vista faz,

426
00:22:50,000 --> 00:22:52,000
e acontece que eu realmente não precisa de nada disso.

427
00:22:52,000 --> 00:22:55,000
Este é o código clichê de que a Apple me dá de graça.

428
00:22:55,000 --> 00:22:59,000
Eu fiz precisa que a primeira linha, ou eu não tenho uma classe,

429
00:22:59,000 --> 00:23:02,000
assim podemos nos livrar disso e se livrar dessa.

430
00:23:02,000 --> 00:23:05,000
Ok, então esta é a minha tela vazia.

431
00:23:05,000 --> 00:23:08,000
>> Agora vamos clicar neste MainStoryboard.storyboard,

432
00:23:08,000 --> 00:23:11,000
e é aí que ele começa a ficar interessante.

433
00:23:11,000 --> 00:23:14,000
Isto representa a primeira tela do meu aplicativo.

434
00:23:14,000 --> 00:23:17,000
Se eu quiser adicionar um botão, em HTML, eu tive que criar uma marca de botão.

435
00:23:17,000 --> 00:23:20,000
No Android você tem que criar uma tag botão,

436
00:23:20,000 --> 00:23:23,000
mas no iOS se eu vir aqui para a parte inferior direita

437
00:23:23,000 --> 00:23:27,000
e se eu clicar em um presente 3 aqui onde diz Objetos,

438
00:23:27,000 --> 00:23:31,000
e eu posso deslocar para baixo, ou eu posso começar a procurar por botão.

439
00:23:31,000 --> 00:23:35,000
E olha, um botão, então se eu realmente arrastar e soltar esse direito lá,

440
00:23:35,000 --> 00:23:38,000
Eu apenas acrescentou um botão para esta tela no meu app.

441
00:23:38,000 --> 00:23:41,000
Se eu quiser mudar o texto, eu posso clicar duas vezes nele,

442
00:23:41,000 --> 00:23:47,000
dizer algo atraentes como "Prima-me."

443
00:23:47,000 --> 00:23:51,000
Ok, agora se eu executar este aplicativo, de modo que compilá-lo,

444
00:23:51,000 --> 00:23:54,000
para executá-lo eu clicar no botão play no canto superior esquerdo, e há o meu aplicativo.

445
00:23:54,000 --> 00:23:58,000
Eu não fiz nada, e eu tenho um aplicativo para iPhone doce olhar.

446
00:23:58,000 --> 00:24:01,000
Se eu quiser parar, você pode clicar no botão de parada

447
00:24:01,000 --> 00:24:03,000
porque é mais divertido.

448
00:24:03,000 --> 00:24:07,000
>> Vamos dizer que eu realmente quer que algo aconteça quando eu pressionar este botão.

449
00:24:07,000 --> 00:24:09,000
Para fazer que o que eu preciso fazer é que eu preciso para criar

450
00:24:09,000 --> 00:24:13,000
um manipulador novo evento ou uma ação.

451
00:24:13,000 --> 00:24:16,000
Isso significa que eu preciso criar algum método que eu quero ser chamado

452
00:24:16,000 --> 00:24:18,000
quando eu aperto o botão, então vamos criar um novo método.

453
00:24:18,000 --> 00:24:20,000
Eu estou dentro de ViewController.h.

454
00:24:20,000 --> 00:24:22,000
Eu preciso dizer que um método existe.

455
00:24:22,000 --> 00:24:26,000
Eu preciso de um primeiro hífen, porque eu vou estar chamando isso no controlador de vista.

456
00:24:26,000 --> 00:24:28,000
Eu preciso dar um presente tipo.

457
00:24:28,000 --> 00:24:31,000
O tipo de isso vai ser aquela coisa IBAction que vimos anteriormente.

458
00:24:31,000 --> 00:24:35,000
Este é um manipulador de eventos, por isso vai retornar um IBAction,

459
00:24:35,000 --> 00:24:38,000
e esta é uma dica para o XCode para dizer que

460
00:24:38,000 --> 00:24:40,000
isso é algo que eu quero ligar algo a.

461
00:24:40,000 --> 00:24:45,000
Posso dar-lhe um nome, como vírgula, buttonPressed.

462
00:24:45,000 --> 00:24:48,000
>> Agora eu tenho declarado um novo método dentro da minha classe.

463
00:24:48,000 --> 00:24:50,000
Eu já disse, este método tem de existir.

464
00:24:50,000 --> 00:24:53,000
Agora vamos entrar em ViewController.m,

465
00:24:53,000 --> 00:24:56,000
e vamos dizer o que este método pode fazer.

466
00:24:56,000 --> 00:25:03,000
Se eu começar a digitar, por exemplo, (void) buttonPressed

467
00:25:03,000 --> 00:25:06,000
aviso XCode é muito bom e autocompletes para mim.

468
00:25:06,000 --> 00:25:09,000
Isso é realmente maravilhoso.

469
00:25:09,000 --> 00:25:12,000
Note-se aqui que dentro do arquivo. M Eu também posso dizer nula,

470
00:25:12,000 --> 00:25:15,000
e isso é porque que IBAction não é realmente um tipo.

471
00:25:15,000 --> 00:25:19,000
É realmente hashtag definido em algum lugar para ser um vazio,

472
00:25:19,000 --> 00:25:22,000
e, novamente, esta é apenas uma dica para XCode que diz

473
00:25:22,000 --> 00:25:25,000
Eu quero que este seja um manipulador de eventos, e vamos ver por que, em apenas um segundo.

474
00:25:25,000 --> 00:25:28,000
Quando este botão é pressionado eu vou fazer algo chato

475
00:25:28,000 --> 00:25:30,000
gosto mostrar uma pop-up.

476
00:25:30,000 --> 00:25:35,000
>> Para fazer que eu posso criar uma nova instância desta classe chamada UIAlertView,

477
00:25:35,000 --> 00:25:39,000
e esta é uma classe que a Apple escreveu que vai exibir pop-ups irritantes.

478
00:25:39,000 --> 00:25:43,000
Vamos chamar este alerta pop-up, e eu tenho dois passos, lembre-se, para criar este objeto.

479
00:25:43,000 --> 00:25:46,000
A primeira coisa que precisa fazer é alocar espaço.

480
00:25:46,000 --> 00:25:48,000
Eu quero um UIAlertView.

481
00:25:48,000 --> 00:25:51,000
Quero alocar espaço. Esse é o meu primeiro método.

482
00:25:51,000 --> 00:25:53,000
Meu próximo método é que eu quero inicializar ele,

483
00:25:53,000 --> 00:25:58,000
e por isso tenho este método, grande e longo chamado initWithTitle.

484
00:25:58,000 --> 00:26:01,000
Isso é basicamente o que vai controlar esse pop-up diz.

485
00:26:01,000 --> 00:26:04,000
O título do meu pop-up pode ser Olá.

486
00:26:04,000 --> 00:26:08,000
A mensagem deste pop-up pode ser "Este é o iOS."

487
00:26:08,000 --> 00:26:10,000
Delegado coisa, eu não sei o que é.

488
00:26:10,000 --> 00:26:13,000
Vamos dizer que não é nada.

489
00:26:13,000 --> 00:26:18,000
Agora, o botão que vai aparecer pode dizer algo como "Com certeza é",

490
00:26:18,000 --> 00:26:24,000
e eu realmente não quero quaisquer outros botões, então vamos excluir esse e fechar o suporte.

491
00:26:24,000 --> 00:26:27,000
>> Ok, eu criei um extra. Lá vamos nós.

492
00:26:27,000 --> 00:26:30,000
Isto é como eu posso criar um pop-up nova.

493
00:26:30,000 --> 00:26:35,000
Se eu quiser realmente mostrar o pop-up que eu quero chamar o método show.

494
00:26:35,000 --> 00:26:38,000
Para fazer o que posso dizer alerta e show,

495
00:26:38,000 --> 00:26:40,000
e, novamente, autocomplete foi super agradável.

496
00:26:40,000 --> 00:26:42,000
Se eu esqueci o que era, se eu digitei em s,

497
00:26:42,000 --> 00:26:45,000
Eu posso rolar por aqui para descobrir o que era,

498
00:26:45,000 --> 00:26:48,000
e ele filtra bem.

499
00:26:48,000 --> 00:26:52,000
Agora eu criei esse pop-up nova.

500
00:26:52,000 --> 00:26:55,000
Nós vamos voltar ao que significa delegado depois,

501
00:26:55,000 --> 00:26:58,000
e agora eu quero dizer que eu quero que este método a ser demitido

502
00:26:58,000 --> 00:27:01,000
quando eu aperto o botão, então eu vou voltar para o meu storyboard,

503
00:27:01,000 --> 00:27:04,000
e eu quero agora anexar esse IBAction.

504
00:27:04,000 --> 00:27:06,000
A primeira coisa que você quer fazer é clicar no botão.

505
00:27:06,000 --> 00:27:08,000
Ao pressionar este botão eu quero que algo aconteça.

506
00:27:08,000 --> 00:27:10,000
Eu não vou segurar para baixo controle.

507
00:27:10,000 --> 00:27:13,000
Eu estou indo para clicar e arrastar a partir do botão

508
00:27:13,000 --> 00:27:15,000
para aqui onde diz View Controller.

509
00:27:15,000 --> 00:27:17,000
Podemos ver que ele bem se acende.

510
00:27:17,000 --> 00:27:22,000
>> Se eu deixar de ir com o meu mouse agora tenho esse pop-up aqui onde eu tenho algumas opções.

511
00:27:22,000 --> 00:27:24,000
Uma delas são os eventos que eu possa registrar.

512
00:27:24,000 --> 00:27:28,000
Estes são todos os métodos eu declarados no meu arquivo h como IBActions.

513
00:27:28,000 --> 00:27:31,000
Isto é como XCode sabe o que deve aparecer nesta lista pequena,

514
00:27:31,000 --> 00:27:33,000
de modo que é apenas uma sugestão.

515
00:27:33,000 --> 00:27:37,000
Se eu clicar no botão pressionado, eu agora registrou o manipulador de eventos.

516
00:27:37,000 --> 00:27:41,000
Em JavaScript que tínhamos a dizer que eu tenho um código que registrou o manipulador de eventos.

517
00:27:41,000 --> 00:27:43,000
Em Objective-C foi realmente assim tão fácil.

518
00:27:43,000 --> 00:27:46,000
Se eu executar este novo

519
00:27:46,000 --> 00:27:49,000
agora quando eu aperto o botão meu manipulador evento vai ao fogo,

520
00:27:49,000 --> 00:27:51,000
e eu vou pegar esse pop-up.

521
00:27:51,000 --> 00:27:54,000
Super, super simples lá.

522
00:27:54,000 --> 00:27:57,000
>> Se você quiser ver todos os eventos que acontecem a ser registrado

523
00:27:57,000 --> 00:28:00,000
em um componente se eu clicar neste botão

524
00:28:00,000 --> 00:28:02,000
e eu vim aqui para o lado direito

525
00:28:02,000 --> 00:28:05,000
primeiro você pode ver aqui o que posso fazer coisas como o tipo de botão,

526
00:28:05,000 --> 00:28:08,000
então se você quiser um desses, eu ou o botão Adicionar contato

527
00:28:08,000 --> 00:28:10,000
ou o que quer.

528
00:28:10,000 --> 00:28:13,000
Se eu quiser ver todos os eventos que estão neste botão

529
00:28:13,000 --> 00:28:16,000
se eu vir até aqui para o lado direito

530
00:28:16,000 --> 00:28:19,000
podemos ver aqui os eventos que eu tenho todos esses eventos diferentes.

531
00:28:19,000 --> 00:28:23,000
Eu posso pressionar o botão, quando eu deixar de ir ao botão, quando eu dobro da torneira ou o que seja,

532
00:28:23,000 --> 00:28:26,000
e aquele que eu apenas registrado é este evento chamado Touch Up Inside,

533
00:28:26,000 --> 00:28:29,000
e este diz que, assim como meu dedo sai o botão

534
00:28:29,000 --> 00:28:32,000
que o evento vai para o fogo, e é exatamente isso o que aconteceu.

535
00:28:32,000 --> 00:28:36,000
Este é o tipo de evento de botão padrão pressionado.

536
00:28:36,000 --> 00:28:39,000
>> Todas as perguntas até agora?

537
00:28:39,000 --> 00:28:43,000
Ok, é assim que podemos começar a conectar as coisas no nosso código

538
00:28:43,000 --> 00:28:46,000
em coisas dentro da nossa interface.

539
00:28:46,000 --> 00:28:49,000
Lembre-se, a primeira coisa que tínhamos que fazer era encontrar o código,

540
00:28:49,000 --> 00:28:54,000
e, então, com fio a interface com o código,

541
00:28:54,000 --> 00:28:57,000
e não é o nosso primeiro aplicativo.

542
00:28:57,000 --> 00:29:00,000
Ok, isso foi muito legal, e criamos este botão.

543
00:29:00,000 --> 00:29:03,000
O que não se quer ter para criar um grupo de propriedades

544
00:29:03,000 --> 00:29:05,000
representando estes botões?

545
00:29:05,000 --> 00:29:08,000
Por exemplo, no Tic Tac Toe tenho 9 botões,

546
00:29:08,000 --> 00:29:11,000
e que seria super, super chato ter que arrastar e soltar 9 vezes

547
00:29:11,000 --> 00:29:14,000
ou se eu tivesse que fazer Tic Tac Toe com 81 em vez de 9

548
00:29:14,000 --> 00:29:17,000
e eu tive que arrastar e soltar 81 vezes, e isso é ridículo.

549
00:29:17,000 --> 00:29:20,000
O que podemos fazer é em vez muito como um HTML

550
00:29:20,000 --> 00:29:23,000
quando tivemos coisas como IDs e nomes e podemos procurar por coisas

551
00:29:23,000 --> 00:29:27,000
por sua identificação, há uma noção similar no iOS chamados de tags.

552
00:29:27,000 --> 00:29:31,000
>> Uma marcação é simplesmente um identificador numérico único para um componente.

553
00:29:31,000 --> 00:29:34,000
Se eu disser que este tem uma marca de 0, por exemplo,

554
00:29:34,000 --> 00:29:38,000
se eu criar um botão e dar-lhe uma marca de 0, e vamos ver como fazer isso em apenas um segundo,

555
00:29:38,000 --> 00:29:41,000
se eu quiser obter esse botão eu posso simplesmente dizer que eu quero chamar

556
00:29:41,000 --> 00:29:45,000
o, viewWithTag método no objeto aqui

557
00:29:45,000 --> 00:29:48,000
o self.view, que representa a tela atual, por exemplo.

558
00:29:48,000 --> 00:29:53,000
Se eu chamar esse método viewWithTag, eu vou puxar o botão com tag 0.

559
00:29:53,000 --> 00:29:58,000
Vamos dar uma olhada neste edifício por Tic Tac Toe.

560
00:29:58,000 --> 00:30:01,000
Em primeiro lugar, este é o meu storyboard.

561
00:30:01,000 --> 00:30:05,000
Eu criei estes 10 botões da interface do usuário.

562
00:30:05,000 --> 00:30:07,000
Observe que eles são todos do mesmo tamanho.

563
00:30:07,000 --> 00:30:11,000
Se eu clicar em um desses e eu volto aqui deste lado direito

564
00:30:11,000 --> 00:30:15,000
você vai ver que eu ajustada a fonte aqui, então eu fiz a fonte um pouco maior,

565
00:30:15,000 --> 00:30:19,000
mas o que eu também fiz foi definir essa tag.

566
00:30:19,000 --> 00:30:23,000
Eu disse que isso tem uma marca de 1, e essa é a parte superior esquerda.

567
00:30:23,000 --> 00:30:26,000
>> Agora, se eu clicar em outro botão, como este segundo aqui,

568
00:30:26,000 --> 00:30:29,000
agora você vai ver que a minha marca é 2.

569
00:30:29,000 --> 00:30:32,000
Cada uma destas teclas só tem uma marca única,

570
00:30:32,000 --> 00:30:35,000
e por isso este é mais tarde como eu vou começar a interagir

571
00:30:35,000 --> 00:30:38,000
com meu aplicativo.

572
00:30:38,000 --> 00:30:40,000
Isso tudo é dentro de um controlador de vista,

573
00:30:40,000 --> 00:30:42,000
mas aqui é o que temos.

574
00:30:42,000 --> 00:30:44,000
Temos três propriedades aqui.

575
00:30:44,000 --> 00:30:49,000
O primeiro e último vão representar o estado do meu conselho.

576
00:30:49,000 --> 00:30:53,000
Basicamente, este primeiro é uma matriz que representa, onde os Xs e Os são.

577
00:30:53,000 --> 00:30:57,000
Este outro aqui diz-nos quem é a vez.

578
00:30:57,000 --> 00:31:01,000
Você vai perceber que eu também tenho essas coisas aqui.

579
00:31:01,000 --> 00:31:05,000
Antes, quando declarou propriedades que lhes deu um nome e um tipo.

580
00:31:05,000 --> 00:31:08,000
Podemos também dar-lhes algumas informações adicionais aqui.

581
00:31:08,000 --> 00:31:11,000
Este primeiro diz não atômica, eo que isso diz

582
00:31:11,000 --> 00:31:16,000
é basicamente a única coisa que nunca vai ser tentando acessar este variável de cada vez.

583
00:31:16,000 --> 00:31:19,000
Você poderia fazer aplicações mais complexas que são multi-threaded,

584
00:31:19,000 --> 00:31:22,000
e assim volta em Scratch tivemos tópicos diferentes,

585
00:31:22,000 --> 00:31:25,000
e sprites diferentes poderia fazer coisas diferentes ao mesmo tempo.

586
00:31:25,000 --> 00:31:29,000
>> Se esse não é o caso, que não é em qualquer coisa que nós vamos estar olhando,

587
00:31:29,000 --> 00:31:33,000
se dizemos que não atômica que realmente vai tornar as coisas um pouco mais rápido.

588
00:31:33,000 --> 00:31:37,000
Nós também temos essa coisa chamada assign, forte ou fraco.

589
00:31:37,000 --> 00:31:40,000
Esta atribuir apenas diz que este é um tipo de padrão.

590
00:31:40,000 --> 00:31:43,000
Este não é um objeto ou um ponteiro porque este é apenas um bool,

591
00:31:43,000 --> 00:31:46,000
para bool é construído em Objective-C.

592
00:31:46,000 --> 00:31:49,000
Este diz que não tentar fazer algo extravagante com ponteiros aqui.

593
00:31:49,000 --> 00:31:51,000
É um scaler idade regular.

594
00:31:51,000 --> 00:31:54,000
Fortes e fracos, este fraco diz que, na verdade,

595
00:31:54,000 --> 00:31:57,000
Eu quero que isso seja apontando para algo no controlador de vista.

596
00:31:57,000 --> 00:32:00,000
Eu não estou indo para realmente alocar ou init isso mesmo.

597
00:32:00,000 --> 00:32:04,000
O construtor de interface, quando eu executar o aplicativo, vai lidar com toda a inicialização isso.

598
00:32:04,000 --> 00:32:07,000
Se eu digo fraco, que diz que alguém vai estar criando isso.

599
00:32:07,000 --> 00:32:09,000
Se eu disser forte, este diz que eu vou ser o único

600
00:32:09,000 --> 00:32:12,000
que está criando esse objeto bordo,

601
00:32:12,000 --> 00:32:14,000
e por isso aqui eu tenho métodos mais alguns aqui,

602
00:32:14,000 --> 00:32:18,000
por exemplo, uma acção para que o botão é pressionado novo jogo,

603
00:32:18,000 --> 00:32:20,000
uma ação para quando qualquer um dos outros botões são pressionados,

604
00:32:20,000 --> 00:32:23,000
e et cetera.

605
00:32:23,000 --> 00:32:26,000
>> Nós não vamos entrar muito da lógica de Tic Tac Toe,

606
00:32:26,000 --> 00:32:30,000
embora seja muito emocionante, mas vamos dar uma olhada

607
00:32:30,000 --> 00:32:33,000
algumas das coisas que podemos fazer dentro do iOS.

608
00:32:33,000 --> 00:32:35,000
Este método novo jogo vai ser demitido

609
00:32:35,000 --> 00:32:37,000
sempre que eu pressione o botão novo jogo.

610
00:32:37,000 --> 00:32:41,000
Para conectar-se de que eu simplesmente vir ao meu storyboard.

611
00:32:41,000 --> 00:32:43,000
Eu cliquei no novo jogo.

612
00:32:43,000 --> 00:32:47,000
Se eu vir aqui para a direita eu posso ver que

613
00:32:47,000 --> 00:32:50,000
Toque Up Inside é ligado ao método NewGame.

614
00:32:50,000 --> 00:32:53,000
É por isso que este vai ser demitido.

615
00:32:53,000 --> 00:32:56,000
O método NewGame vai fazer alguma configuração.

616
00:32:56,000 --> 00:32:59,000
Vai dizer que eu quero que você limpar o estado da placa.

617
00:32:59,000 --> 00:33:01,000
Este é um método agradável em mutáveis ​​matrizes.

618
00:33:01,000 --> 00:33:03,000
Isso vai dizer que é agora a vez de X,

619
00:33:03,000 --> 00:33:07,000
e agora eu vou aproveitar essa coisa viewWithTag.

620
00:33:07,000 --> 00:33:11,000
>> Eu sei que os meus botões têm as marcas 1-9,

621
00:33:11,000 --> 00:33:13,000
e isso é algo que eu arbitrariamente escolhido.

622
00:33:13,000 --> 00:33:15,000
Se eu quiser definir o texto de cada botão para estar vazio

623
00:33:15,000 --> 00:33:17,000
porque eu comecei um novo jogo e eu não quero nenhum

624
00:33:17,000 --> 00:33:20,000
Xs ou Os para sobrar eu posso fazer isso.

625
00:33:20,000 --> 00:33:24,000
Eu posso dizer que eu quero a vista com a tag, 1, 2, 3, 4 et cetera.

626
00:33:24,000 --> 00:33:27,000
Isso vai puxar um botão diferente a cada vez.

627
00:33:27,000 --> 00:33:30,000
Aqui eu vou lançá-lo aos UIButton.

628
00:33:30,000 --> 00:33:33,000
Assim como nós poderíamos lançar ints para carros alegóricos e vice-versa

629
00:33:33,000 --> 00:33:37,000
este diz que eu quero lançar a um UIButton.

630
00:33:37,000 --> 00:33:40,000
Isso significa que o tipo de esta será a * UIButton

631
00:33:40,000 --> 00:33:43,000
porque de ponteiros, mas não se preocupe, eles não são assustadores mais.

632
00:33:43,000 --> 00:33:47,000
>> Uma vez que eu tenho esse botão que eu vou chamar um método nele.

633
00:33:47,000 --> 00:33:50,000
Este método é chamado setTitle forState, e por isso este diz

634
00:33:50,000 --> 00:33:53,000
Eu quero definir o texto do botão para ser a cadeia vazia,

635
00:33:53,000 --> 00:33:57,000
e eu quero que seja a cadeia vazia quando não está pressionado.

636
00:33:57,000 --> 00:34:01,000
Se eu estou usando esse método, eu posso mudar o texto do botão

637
00:34:01,000 --> 00:34:04,000
assim que alguém chega, mas queremos dizer quando o botão é apenas sentado ali

638
00:34:04,000 --> 00:34:07,000
Eu quero que o texto em branco.

639
00:34:07,000 --> 00:34:10,000
Finalmente, vamos inicializar o meu conselho,

640
00:34:10,000 --> 00:34:12,000
e vou dizer que tudo é atualmente a 0,

641
00:34:12,000 --> 00:34:15,000
de modo que este membros do conselho imutável é uma matriz mutável,

642
00:34:15,000 --> 00:34:21,000
o que significa que eu posso chamar o método addObject e apenas dentro de um 0 dele.

643
00:34:21,000 --> 00:34:23,000
Isso é o que acontece quando eu criar um novo jogo.

644
00:34:23,000 --> 00:34:25,000
>> Vamos dar uma olhada em outro.

645
00:34:25,000 --> 00:34:28,000
Este método aqui é o IBAction que vai ser pressionado

646
00:34:28,000 --> 00:34:31,000
cada vez que um dos quadrados é pressionado.

647
00:34:31,000 --> 00:34:33,000
Agora temos uma lógica Tic Tac Toe aqui.

648
00:34:33,000 --> 00:34:36,000
Nós descobrir quem é a vez,

649
00:34:36,000 --> 00:34:39,000
e com base em que seja definido um X ou um O,

650
00:34:39,000 --> 00:34:43,000
mas percebemos que estamos reutilizar este mesmo manipulador de eventos

651
00:34:43,000 --> 00:34:45,000
para cada um desses botões.

652
00:34:45,000 --> 00:34:49,000
Isso significa que eu não tenho um método para o botão superior esquerdo,

653
00:34:49,000 --> 00:34:52,000
um método diferente para o botão inferior direito, apesar de que eu poderia ter feito isso.

654
00:34:52,000 --> 00:34:54,000
Isso não seria realmente um bom design.

655
00:34:54,000 --> 00:34:57,000
O que eu estou fazendo aqui é que eu estou indo realmente para determinar

656
00:34:57,000 --> 00:35:00,000
o que a etiqueta do botão que foi pressionado é.

657
00:35:00,000 --> 00:35:04,000
Você percebe que este método de reprodução tem um argumento.

658
00:35:04,000 --> 00:35:07,000
É chamado de remetente, eo que é remetente é remetente vai

659
00:35:07,000 --> 00:35:10,000
representam exatamente o que foi tomado medidas em cima.

660
00:35:10,000 --> 00:35:15,000
Se eu apertar um botão, este remetente vai ser que UIButton

661
00:35:15,000 --> 00:35:18,000
I, na verdade, que pressionado, o que significa que esta UIButton

662
00:35:18,000 --> 00:35:20,000
tem uma marca porque eu criei uma tag.

663
00:35:20,000 --> 00:35:23,000
>> Se eu quiser chegar à marca que eu posso simplesmente dizer

664
00:35:23,000 --> 00:35:26,000
Eu quero a tag do remetente,

665
00:35:26,000 --> 00:35:28,000
e de novo, eu só fundido a um UIButton.

666
00:35:28,000 --> 00:35:32,000
Acontece que eu sei que o remetente será um UIButton.

667
00:35:32,000 --> 00:35:34,000
Nem sempre tem que ser um UIButton.

668
00:35:34,000 --> 00:35:36,000
Eu poderia, por exemplo, registrar o mesmo manipulador de eventos

669
00:35:36,000 --> 00:35:38,000
 para um para um botão, uma por uma barra.

670
00:35:38,000 --> 00:35:40,000
Neste caso, eu sei que eles estão todos os botões, então eu vou dizer

671
00:35:40,000 --> 00:35:43,000
Eu quero que este seja um botão, e então eu posso obter a marca,

672
00:35:43,000 --> 00:35:48,000
e da marca agora eu sei onde eu estou dentro do conselho.

673
00:35:48,000 --> 00:35:51,000
Então eu posso simplesmente definir X ou o O, pode virar o turno,

674
00:35:51,000 --> 00:35:54,000
verificar quem ganhou, et cetera.

675
00:35:54,000 --> 00:35:59,000
>> Qualquer dúvida sobre isso até agora?

676
00:35:59,000 --> 00:36:02,000
Ok, todo o código que postou online-não quero entrar muito

677
00:36:02,000 --> 00:36:06,000
da lógica de Tic Tac Toe, mas agora você pode ver que realmente

678
00:36:06,000 --> 00:36:09,000
tudo o que estamos fazendo é que estamos looping sobre essa matriz,

679
00:36:09,000 --> 00:36:13,000
por isso temos um par de loops aqui, e nós estamos apenas comparando para ver

680
00:36:13,000 --> 00:36:18,000
temos um jogo em todas as linhas, um jogo em uma coluna ou qualquer coisa assim.

681
00:36:18,000 --> 00:36:21,000
Para realmente executar este aplicativo, se eu tocar em um dos botões

682
00:36:21,000 --> 00:36:24,000
que o método de jogo foi demitido, o que significa que apenas definir

683
00:36:24,000 --> 00:36:31,000
o botão para ser um X, então agora este botão será um O, e assim por diante,

684
00:36:31,000 --> 00:36:35,000
e é assim que estamos começando a interagir com este aplicativo única página.

685
00:36:35,000 --> 00:36:38,000
>> Vamos postar o código, então sinta-se livre para examinar que,

686
00:36:38,000 --> 00:36:43,000
mas vamos agora falar sobre alguns aplicativos que são mais do que apenas uma página.

687
00:36:43,000 --> 00:36:47,000
Tão emocionante como Tic Tac Toe foi, um monte de aplicativos dentro do iOS

688
00:36:47,000 --> 00:36:50,000
são estes tipo de detalhamento coisas com múltiplas telas.

689
00:36:50,000 --> 00:36:54,000
O primeiro conceito que vamos precisar de falar são protocolos,

690
00:36:54,000 --> 00:36:57,000
e um protocolo é simplesmente um conjunto de métodos

691
00:36:57,000 --> 00:36:59,000
que você pode prometer para definir.

692
00:36:59,000 --> 00:37:02,000
Se eu criar este novo protocolo com dois métodos, este primeiro,

693
00:37:02,000 --> 00:37:05,000
se o tipo de retorno é void, eu o chamei foo.

694
00:37:05,000 --> 00:37:07,000
Ele não tem argumentos. Eu tenho um outro método.

695
00:37:07,000 --> 00:37:11,000
Ele retorna um int. Chamei-bar, e ele tem um argumento.

696
00:37:11,000 --> 00:37:14,000
Todos protocolo isto é que se chama SomeProtocol-se aqui,

697
00:37:14,000 --> 00:37:19,000
este é um conjunto de coisas que alguém pode implementar.

698
00:37:19,000 --> 00:37:22,000
Eu não dentro deste protocolo, disse que foo faz.

699
00:37:22,000 --> 00:37:26,000
Em vez disso, eu só estou dizendo que você poderia definir foo se você quiser.

700
00:37:26,000 --> 00:37:30,000
Se eu estou criando um controlador de vista ou a criação de uma classe

701
00:37:30,000 --> 00:37:33,000
Eu posso dentro dessa promessa classe para implementar

702
00:37:33,000 --> 00:37:40,000
alguns desses métodos, assim, por exemplo, se dizer <SomeProtocol>

703
00:37:40,000 --> 00:37:43,000
isso agora diz que eu estou fazendo uma promessa a você que dentro

704
00:37:43,000 --> 00:37:50,000
desta classe controlador de vista eu vou ter definições para ambos foo e bar.

705
00:37:50,000 --> 00:37:52,000
>> Por que isso é útil?

706
00:37:52,000 --> 00:37:55,000
Um monte de componentes dentro do iOS aproveitar essa

707
00:37:55,000 --> 00:37:58,000
padrão de projeto chamado de delegação, e que diz delegação

708
00:37:58,000 --> 00:38:01,000
é que, por exemplo, se eu tenho uma caixa de texto

709
00:38:01,000 --> 00:38:04,000
e existem alguns eventos que poderiam ser registrados dentro da minha caixa de texto,

710
00:38:04,000 --> 00:38:07,000
em vez de criar eventos separados que eu posso fazer é o que posso dizer

711
00:38:07,000 --> 00:38:10,000
o delegado da caixa de texto será algum objeto.

712
00:38:10,000 --> 00:38:13,000
Quando eu digo que este é um delegado agora que significa que

713
00:38:13,000 --> 00:38:16,000
sempre que algum evento teria sido demitido na caixa de texto

714
00:38:16,000 --> 00:38:18,000
ao invés de ter que registrá-lo ou algo assim

715
00:38:18,000 --> 00:38:21,000
ele só vai chamar um método no delegado.

716
00:38:21,000 --> 00:38:24,000
Por exemplo, dentro da minha caixa de texto Eu tenho um método para quando eu pressione

717
00:38:24,000 --> 00:38:27,000
que fez botão no canto inferior direito,

718
00:38:27,000 --> 00:38:30,000
e assim, em vez de registrar manipulador de eventos o que eu posso dizer é

719
00:38:30,000 --> 00:38:34,000
caixa de texto, aqui é um objeto que eu quero que você chamar um método em

720
00:38:34,000 --> 00:38:37,000
cada vez que alguém pressiona o botão Done,

721
00:38:37,000 --> 00:38:40,000
e isso significa que esse objeto tem que implementar algum protocolo

722
00:38:40,000 --> 00:38:45,000
que diz que eu prometo para definir que ação do botão feito,

723
00:38:45,000 --> 00:38:47,000
porque se ele não define esse método e que prima Concluir

724
00:38:47,000 --> 00:38:49,000
em seguida, ele vai ser confuso.

725
00:38:49,000 --> 00:38:55,000
>> Vamos dar uma olhada em um exemplo.

726
00:38:55,000 --> 00:38:58,000
Aqui eu simplesmente tem uma caixa de texto,

727
00:38:58,000 --> 00:39:04,000
e uma das propriedades desta caixa de texto por aqui deste lado direito é o delegado.

728
00:39:04,000 --> 00:39:06,000
Esta é uma propriedade da classe.

729
00:39:06,000 --> 00:39:09,000
O que eu fiz aqui é que eu controlar clicado, e eu arrastei a partir deste ponto aqui

730
00:39:09,000 --> 00:39:13,000
ao controlador do ponto de vista, e que agora diz o delegado da caixa de texto

731
00:39:13,000 --> 00:39:18,000
vai ser o controlador de vista.

732
00:39:18,000 --> 00:39:20,000
Isso significa que, quando algumas acções acontecer, em vez de registar

733
00:39:20,000 --> 00:39:25,000
manipuladores de eventos separados que eu quero que você envie para o delegado.

734
00:39:25,000 --> 00:39:28,000
Agora vamos dar uma olhada no meu controlador de vista.

735
00:39:28,000 --> 00:39:32,000
Dentro do arquivo h. Fiz uma promessa.

736
00:39:32,000 --> 00:39:36,000
Eu prometi para implementar alguns métodos dentro deste protocolo

737
00:39:36,000 --> 00:39:38,000
chamado UITextFieldDelegate, e novamente,

738
00:39:38,000 --> 00:39:42,000
esta é apenas uma lista de algumas coisas que eu posso escolher para implementar.

739
00:39:42,000 --> 00:39:46,000
>> Se eu vir aqui no meu arquivo. M, eu implementei um tal método.

740
00:39:46,000 --> 00:39:49,000
Eu chamei ele textFieldShouldReturn

741
00:39:49,000 --> 00:39:52,000
porque é isso que ele foi chamado dentro do protocolo.

742
00:39:52,000 --> 00:39:57,000
E agora sempre que eu pressione o botão feito dentro do campo de texto

743
00:39:57,000 --> 00:40:00,000
isso é o que vai pagar, então eu não registrar um manipulador de evento.

744
00:40:00,000 --> 00:40:03,000
Liguei o delegado e sempre que esse evento é disparado

745
00:40:03,000 --> 00:40:08,000
este é o método que será chamado, então se eu vir aqui ao meu storyboard e execute-o-

746
00:40:08,000 --> 00:40:11,000
enquanto que a está carregando podemos ver que isso faz.

747
00:40:11,000 --> 00:40:13,000
Na minha tela eu tenho 2 coisas.

748
00:40:13,000 --> 00:40:16,000
Eu tenho esse campo de texto, e eu tenho este rótulo.

749
00:40:16,000 --> 00:40:19,000
Estou simplesmente dizendo que deseja que o texto deste rótulo

750
00:40:19,000 --> 00:40:23,000
ser igual a qualquer que seja o utilizador digitado no interior do campo de texto.

751
00:40:23,000 --> 00:40:26,000
Essa linha aqui é simplesmente um método que eu estou chamando

752
00:40:26,000 --> 00:40:29,000
no campo de texto que diz que eu quero que você esconder o teclado.

753
00:40:29,000 --> 00:40:33,000
Este é apenas o método arbitrário que a Apple escolheu.

754
00:40:33,000 --> 00:40:38,000
>> Mais uma vez, antes de eu fazer qualquer coisa que eu tinha que ligar tudo, então eu cheguei aqui.

755
00:40:38,000 --> 00:40:42,000
Do controlador de vista eu arrastar até a caixa de texto.

756
00:40:42,000 --> 00:40:46,000
Eu deixar de ir, e eu posso ver aqui que eu posso fazer isso a propriedade de campo de texto

757
00:40:46,000 --> 00:40:49,000
desde aqui no controlador de vista eu defini uma propriedade

758
00:40:49,000 --> 00:40:52,000
que é um IBOutlet de um campo de texto.

759
00:40:52,000 --> 00:40:55,000
Este diz que eu posso ligar esta propriedade se

760
00:40:55,000 --> 00:40:59,000
a um campo de texto no meu UI.

761
00:40:59,000 --> 00:41:03,000
Agora, quando eu clico isso eu posso começar a digitar.

762
00:41:03,000 --> 00:41:06,000
Agora, se eu clicar no botão feito isso vai disparar

763
00:41:06,000 --> 00:41:08,000
um evento que agora posso responder.

764
00:41:08,000 --> 00:41:10,000
Não manipuladores de eventos.

765
00:41:10,000 --> 00:41:13,000
É assim que eu só respondeu a esse botão feito.

766
00:41:13,000 --> 00:41:15,000
Faz sentido?

767
00:41:15,000 --> 00:41:20,000
>> Este não é um padrão de design que-você não pode nunca encontrar-se

768
00:41:20,000 --> 00:41:23,000
criar o seu próprio protocolo, mas só sei que alguns

769
00:41:23,000 --> 00:41:27,000
diferentes componentes iOS registrar eventos de diferentes maneiras.

770
00:41:27,000 --> 00:41:29,000
Botões, por exemplo, usar essas IBActions.

771
00:41:29,000 --> 00:41:32,000
Campos de texto, por outro lado, vão usar delegados.

772
00:41:32,000 --> 00:41:36,000
Podemos ver e você pode olhar tudo isso dentro se da documentação.

773
00:41:36,000 --> 00:41:41,000
A propósito, há realmente uma tonelada de coisas UI construído no iOS para você,

774
00:41:41,000 --> 00:41:46,000
assim, por exemplo, a maneira que eu fiz que dizem feito na parte inferior direita

775
00:41:46,000 --> 00:41:48,000
é Selecionei este campo de texto.

776
00:41:48,000 --> 00:41:50,000
Eu vim para cá.

777
00:41:50,000 --> 00:41:53,000
Eu rolada para baixo um pouco para retornar chave,

778
00:41:53,000 --> 00:41:56,000
e eu posso realmente fazer isso um monte de coisas, como se eu quero que dizer

779
00:41:56,000 --> 00:42:00,000
chamada de emergência vez eu posso fazer isso, que é totalmente aleatória,

780
00:42:00,000 --> 00:42:02,000
e eu não sei por que não há um built-in botão de chamada de emergência,

781
00:42:02,000 --> 00:42:06,000
mas lá, ele diz que chamada de emergência em letras muito pequenas.

782
00:42:06,000 --> 00:42:08,000
Lá você vai.

783
00:42:08,000 --> 00:42:12,000
>> Definitivamente explorar todos esses diferentes opções no iOS.

784
00:42:12,000 --> 00:42:14,000
Qualquer dúvida sobre os delegados?

785
00:42:14,000 --> 00:42:18,000
Mais uma vez, apenas um padrão de design interessante que você deve estar ciente.

786
00:42:18,000 --> 00:42:22,000
Ok, vamos dar uma olhada junto com a vista da tabela.

787
00:42:22,000 --> 00:42:26,000
A vista de tabela é basicamente que a lista de itens que está em todo o lugar no iOS.

788
00:42:26,000 --> 00:42:29,000
Quando você está folheando todos os seus contatos, você está olhando

789
00:42:29,000 --> 00:42:34,000
a página de configuração, e esse tipo de lista de coisas é chamado de exibição de tabela.

790
00:42:34,000 --> 00:42:37,000
Implementação de uma exibição de tabela no iOS é bem simples.

791
00:42:37,000 --> 00:42:41,000
Em vez de fazer uma classe que desce do que UIViewController

792
00:42:41,000 --> 00:42:44,000
como já fizemos antes, nós simplesmente precisamos dizer, em vez de

793
00:42:44,000 --> 00:42:46,000
tudo o que um UIViewController não quero fazer,

794
00:42:46,000 --> 00:42:50,000
Eu digo tudo o que um UITableViewController não quero fazer,

795
00:42:50,000 --> 00:42:54,000
de modo que simplesmente adiciona algumas coisas adicionais que são totalmente feito por nós.

796
00:42:54,000 --> 00:42:58,000
Precisamos fazer muito pouco para, basicamente, preencher os espaços em branco dentro da tabela.

797
00:42:58,000 --> 00:43:02,000
>> A fim de apresentar uma tabela que eu preciso responder algumas perguntas.

798
00:43:02,000 --> 00:43:06,000
A primeira pergunta que eu preciso responder é quantos pontos estão em cima da mesa?

799
00:43:06,000 --> 00:43:08,000
Quando você está folheando o seu aplicativo de contatos você vai perceber que é uma espécie de

800
00:43:08,000 --> 00:43:12,000
organizado pelo Como, então você tem o Bs, e você tem que cabeçalho pouco sub.

801
00:43:12,000 --> 00:43:14,000
Cada um destes é chamado de uma secção.

802
00:43:14,000 --> 00:43:16,000
Você pode ou não necessitar destes.

803
00:43:16,000 --> 00:43:19,000
A primeira coisa que você precisa fazer é implementar um método

804
00:43:19,000 --> 00:43:22,000
chamado tableView: numberOfSectionsInTableView.

805
00:43:22,000 --> 00:43:25,000
Que simplesmente retorna quantas seções que você tem,

806
00:43:25,000 --> 00:43:29,000
de modo que este pudesse dizer retornar um, se você tem uma vista de tabela grande.

807
00:43:29,000 --> 00:43:33,000
A próxima pergunta que o iOS precisa saber é quantas linhas você tem?

808
00:43:33,000 --> 00:43:36,000
Por exemplo, você está folheando uma exibição de tabela.

809
00:43:36,000 --> 00:43:39,000
Você tem um número fixo de músicas que você está olhando ou um número fixo de contatos.

810
00:43:39,000 --> 00:43:41,000
Se você é eu, é claro, não é muito,

811
00:43:41,000 --> 00:43:44,000
e é assim que o iOS sabe quantas células para exibir.

812
00:43:44,000 --> 00:43:46,000
>> Mais uma vez, isso poderia dizer algo como retorno 3.

813
00:43:46,000 --> 00:43:49,000
Minha visão tabela tem três linhas.

814
00:43:49,000 --> 00:43:52,000
Finalmente, o iOS precisa saber o que cada célula parece,

815
00:43:52,000 --> 00:43:54,000
Então, o que ele realmente vai fazer é chamar esse método aqui,

816
00:43:54,000 --> 00:43:57,000
este tableView: cellForRowAtIndexPath.

817
00:43:57,000 --> 00:44:01,000
Vai chamar esse método em cada célula dentro de sua tabela.

818
00:44:01,000 --> 00:44:03,000
Como ele sabe quantas vezes a chamá-lo?

819
00:44:03,000 --> 00:44:06,000
Bem, você disse que dentro do número de linhas em seção.

820
00:44:06,000 --> 00:44:08,000
Vamos chamar isso em cada uma de nossas células,

821
00:44:08,000 --> 00:44:11,000
e dentro deste é onde você pode realmente fazer coisas como

822
00:44:11,000 --> 00:44:16,000
definir o texto ou dizer-lhe o que isso pequeno botão azul no lado direito faz.

823
00:44:16,000 --> 00:44:19,000
O padrão para a obtenção dessas células, vamos usar este método

824
00:44:19,000 --> 00:44:22,000
chamado dequeueReusableCellWithIdentifier.

825
00:44:22,000 --> 00:44:29,000
>> Objective-C é realmente muito conhecido para a duração ridícula de seus nomes de método,

826
00:44:29,000 --> 00:44:32,000
e este é realmente um caso agradável no exemplo ponto.

827
00:44:32,000 --> 00:44:37,000
O que este método faz é este apenas diz que eu quero que você me dê uma célula.

828
00:44:37,000 --> 00:44:39,000
Apenas uma coisa iOS.

829
00:44:39,000 --> 00:44:41,000
Se você tem algo como 100 mil músicas em seu iPod

830
00:44:41,000 --> 00:44:45,000
o iOS não quer fazer é alocar 100.000 células,

831
00:44:45,000 --> 00:44:48,000
porque se você está no topo da sua lista, você realmente precisa para alocar memória

832
00:44:48,000 --> 00:44:51,000
para a célula que é 99.000 linhas para baixo?

833
00:44:51,000 --> 00:44:55,000
Não, porque como você está rolando você pode tipo de alocar como você vá junto.

834
00:44:55,000 --> 00:44:57,000
Isto é feito para você.

835
00:44:57,000 --> 00:44:59,000
Você não tem que se preocupar com todo o material de desempenho que estúpido.

836
00:44:59,000 --> 00:45:02,000
Tudo o que você diz é você chamar este método dequeueReusableCellWithIdentifier,

837
00:45:02,000 --> 00:45:06,000
e este diz, tudo bem, se você precisar eu vou criar uma nova célula para você.

838
00:45:06,000 --> 00:45:09,000
>> Mas se você está no fundo da tabela e você já alocados algumas células

839
00:45:09,000 --> 00:45:12,000
no topo da tabela que você realmente não vai precisar tão cedo

840
00:45:12,000 --> 00:45:15,000
Eu vou dar-lhe um daqueles de volta em vez de alocar um novo,

841
00:45:15,000 --> 00:45:17,000
e por isso esta é uma preocupação desempenho agradável.

842
00:45:17,000 --> 00:45:21,000
Você não tem que alocar as células-se.

843
00:45:21,000 --> 00:45:23,000
Isso vai lhe dar de volta uma célula.

844
00:45:23,000 --> 00:45:25,000
Ele vai voltar para você um objeto de célula.

845
00:45:25,000 --> 00:45:28,000
Depois de ter o objeto de célula que você pode fazer coisas para ele.

846
00:45:28,000 --> 00:45:32,000
Você pode definir o texto da célula com essa propriedade chamada rótulo de texto.

847
00:45:32,000 --> 00:45:36,000
Você pode adicionar a seta à direita ou algumas outras coisas aleatórias

848
00:45:36,000 --> 00:45:41,000
com esta outra propriedade chamada accessoryType, e assim por diante e assim por diante.

849
00:45:41,000 --> 00:45:46,000
>> Vamos dar uma olhada em realmente implementar uma exibição de tabela agora.

850
00:45:46,000 --> 00:45:49,000
Quando eu criei este projeto

851
00:45:49,000 --> 00:45:53,000
ao invés de dizer aplicação única visão que eu realmente vim aqui

852
00:45:53,000 --> 00:45:57,000
a mestre-detalhe de aplicação, e por isso, basicamente o que corresponde ao aplicativo de email

853
00:45:57,000 --> 00:46:01,000
no iPad com a exibição de tabela à esquerda e, em seguida, o conteúdo à direita.

854
00:46:01,000 --> 00:46:07,000
No iPod ou iPhone isso vai corresponder a uma visão única tabela.

855
00:46:07,000 --> 00:46:10,000
É onde eu tenho o meu código inicial.

856
00:46:10,000 --> 00:46:13,000
>> Vamos primeiro dar uma olhada no storyboard.

857
00:46:13,000 --> 00:46:15,000
Tudo isso foi feito por mim, basicamente criado.

858
00:46:15,000 --> 00:46:18,000
Esta barra de navegação me mostrou o que uma célula exemplo pode parecer,

859
00:46:18,000 --> 00:46:22,000
e eu pode clicar duas vezes isso, alterar o título.

860
00:46:22,000 --> 00:46:25,000
Quaisquer preocupações UI outros eu posso lidar lá.

861
00:46:25,000 --> 00:46:27,000
O arquivo de cabeçalho parece muito simples.

862
00:46:27,000 --> 00:46:30,000
Ao invés de dizer isso é UIViewController agora estamos dizendo que este é um

863
00:46:30,000 --> 00:46:35,000
TableViewController, por isso sabemos que queremos chamar todos os métodos da tabela.

864
00:46:35,000 --> 00:46:38,000
Próxima Eu quero criar uma propriedade que vai representar

865
00:46:38,000 --> 00:46:40,000
as coisas dentro da minha mesa.

866
00:46:40,000 --> 00:46:43,000
Esta tabela vai exibir arbitrariamente

867
00:46:43,000 --> 00:46:46,000
uma lista de frutas, e então eu preciso criar alguma matriz

868
00:46:46,000 --> 00:46:49,000
em que eu possa inserir frutas.

869
00:46:49,000 --> 00:46:52,000
Dentro do meu arquivo de implementação, a primeira coisa que eu quero fazer

870
00:46:52,000 --> 00:46:55,000
é que eu quero ter certeza que eu inicializar esta matriz.

871
00:46:55,000 --> 00:46:58,000
>> Eu disse alloc init, criei a minha matriz de frutas,

872
00:46:58,000 --> 00:47:03,000
e eu estou adicionando 4 coisas para ele, um dos quais é muito mais controverso do que os outros 3.

873
00:47:03,000 --> 00:47:06,000
E agora eu tenho uma matriz de tamanho 4.

874
00:47:06,000 --> 00:47:08,000
Estamos agitando-se no CS50.

875
00:47:08,000 --> 00:47:11,000
Agora tenho uma matriz de tamanho 4.

876
00:47:11,000 --> 00:47:13,000
Agora eu vou começar a responder a estas questões, e na verdade,

877
00:47:13,000 --> 00:47:16,000
quando eu criei este aplicativo tudo isso já foi feito por mim.

878
00:47:16,000 --> 00:47:19,000
Eu não tenho que digitar o número de seções em vista de tabela.

879
00:47:19,000 --> 00:47:22,000
Ele já estava lá, e eu estou preenchendo os espaços em branco.

880
00:47:22,000 --> 00:47:24,000
Quantas seções que eu tenho?

881
00:47:24,000 --> 00:47:26,000
Um. Tudo feito.

882
00:47:26,000 --> 00:47:28,000
Quantas linhas que eu tenho?

883
00:47:28,000 --> 00:47:31,000
Bem, eu tenho uma linha para cada fruta, para esta contagem

884
00:47:31,000 --> 00:47:34,000
é uma propriedade de qualquer matriz que diz o quão grande é isso?

885
00:47:34,000 --> 00:47:36,000
Esse é o número de linhas que eu tenho.

886
00:47:36,000 --> 00:47:42,000
Finalmente, eu preciso dizer o que é que cada célula se parece?

887
00:47:42,000 --> 00:47:46,000
Eu vou dizer dequeueReusableCellWithIdentifier.

888
00:47:46,000 --> 00:47:48,000
>> Novamente, isso já estava escrito para mim.

889
00:47:48,000 --> 00:47:51,000
Eu não tenho que fazer isso mesmo, e eu quero voltar

890
00:47:51,000 --> 00:47:54,000
esta célula neste local.

891
00:47:54,000 --> 00:47:57,000
Lembre-se que estamos chamando este mesmo método em todas as células,

892
00:47:57,000 --> 00:48:01,000
e este argumento aqui, esse argumento indexPath,

893
00:48:01,000 --> 00:48:03,000
diz o que eu estou dentro da linha

894
00:48:03,000 --> 00:48:05,000
Se eu disser indexPath.row aqui

895
00:48:05,000 --> 00:48:09,000
isto irá ser 0, então ele irá ser 1, então ele irá ser 2, e este é então sei

896
00:48:09,000 --> 00:48:11,000
o que eu estou célula que está exibindo.

897
00:48:11,000 --> 00:48:15,000
Eu quero definir o texto da célula usando esta propriedade TextLabel

898
00:48:15,000 --> 00:48:19,000
para ir dentro da minha matriz frutas e obter

899
00:48:19,000 --> 00:48:21,000
o objeto correspondente a cada linha.

900
00:48:21,000 --> 00:48:24,000
Se esta é uma seqüência, agora estou definindo

901
00:48:24,000 --> 00:48:28,000
a propriedade de texto para uma string.

902
00:48:28,000 --> 00:48:30,000
Eu posso fazer outra coisa.

903
00:48:30,000 --> 00:48:32,000
I também pode registar-se um processador de eventos em cada uma das células,

904
00:48:32,000 --> 00:48:35,000
então quando eu tocar cada uma dessas células

905
00:48:35,000 --> 00:48:39,000
este didSelectRowAtIndexPath, isso vai ser chamado para mim,

906
00:48:39,000 --> 00:48:42,000
tão simplesmente definindo isso eu agora pode lidar com o que acontece

907
00:48:42,000 --> 00:48:46,000
quando você toca em uma célula, e, novamente, estamos passando em qual célula foi aproveitado

908
00:48:46,000 --> 00:48:50,000
para que possamos reutilizar esse mesmo manipulador de eventos para todas as nossas células.

909
00:48:50,000 --> 00:48:53,000
>> Mais uma vez, isso é algo que o iOS está fazendo por mim.

910
00:48:53,000 --> 00:48:55,000
Vamos mostrar um outro pop-up irritantes

911
00:48:55,000 --> 00:48:59,000
que simplesmente diz que você pegou algo em algo que

912
00:48:59,000 --> 00:49:04,000
vai ser o objeto de linha.

913
00:49:04,000 --> 00:49:10,000
Quando eu executo isso, eu vou ter essa visão boa mesa

914
00:49:10,000 --> 00:49:14,000
com uma linha para cada um desses frutos, e se eu tocar um

915
00:49:14,000 --> 00:49:16,000
diz-me o que aconteceu.

916
00:49:16,000 --> 00:49:21,000
Faz sentido?

917
00:49:21,000 --> 00:49:24,000
Vamos construir um pouco mais complexa de um aplicativo,

918
00:49:24,000 --> 00:49:28,000
tanto quanto você escolheu clicando tomate é.

919
00:49:28,000 --> 00:49:31,000
A parte agradável sobre o storyboard

920
00:49:31,000 --> 00:49:35,000
é que não só vai ajudar-nos a projetar telas individualmente,

921
00:49:35,000 --> 00:49:38,000
também vai nos ajudar a unir a nossa aplicação inteira

922
00:49:38,000 --> 00:49:42,000
de modo que o aplicativo final que vai ser este edifício é agradável esportes leitor de notícias,

923
00:49:42,000 --> 00:49:45,000
e assim vai ter várias telas, e para que eu possa realmente representar

924
00:49:45,000 --> 00:49:48,000
cada uma dessas telas múltiplas no storyboard,

925
00:49:48,000 --> 00:49:52,000
e eu posso diminuir o zoom e ver meu aplicativo a partir de um nível elevado.

926
00:49:52,000 --> 00:49:55,000
>> A fim de criar um novo elemento dentro do meu storyboard

927
00:49:55,000 --> 00:49:59,000
é realmente simples dentro de Interface Builder.

928
00:49:59,000 --> 00:50:01,000
Se eu quiser adicionar outra tela para isso, por exemplo,

929
00:50:01,000 --> 00:50:06,000
Eu posso primeiro zoom com o zoom pitada de que a Apple tanto ama,

930
00:50:06,000 --> 00:50:09,000
e aqui antes de eu procurar por um botão

931
00:50:09,000 --> 00:50:12,000
e eu arrastar e soltar um botão

932
00:50:12,000 --> 00:50:15,000
se eu quiser criar uma nova tela que eu possa realmente basta arrastar e soltar

933
00:50:15,000 --> 00:50:19,000
um controlador de vista inteira, então se eu pegar isso, puxe-aqui,

934
00:50:19,000 --> 00:50:23,000
hey, há uma outra tela, e agora usando esse arquivo storyboard mesmo

935
00:50:23,000 --> 00:50:26,000
Eu posso ter todas as telas dentro do meu aplicativo, e eu posso diminuir o zoom

936
00:50:26,000 --> 00:50:28,000
e ver como eles interagem.

937
00:50:28,000 --> 00:50:32,000
Estes não vão interagir ainda.

938
00:50:32,000 --> 00:50:36,000
A maneira em que estas duas telas interagem é definir relacionamentos.

939
00:50:36,000 --> 00:50:39,000
Basicamente você pode dizer que esta tela, ao pressionar este botão,

940
00:50:39,000 --> 00:50:42,000
Eu quero que você deslize para esta nova tela.

941
00:50:42,000 --> 00:50:44,000
Isso significa que não há este tipo de relação entre

942
00:50:44,000 --> 00:50:46,000
 a primeira tela e na segunda tela.

943
00:50:46,000 --> 00:50:49,000
Você tem basicamente uma flecha que o botão para a segunda tela

944
00:50:49,000 --> 00:50:53,000
dizendo que quando você pressionar este botão que é onde eu quero ir.

945
00:50:53,000 --> 00:50:57,000
Assim como nós controlamos clicado e arrastado para definir esses estabelecimentos

946
00:50:57,000 --> 00:51:01,000
vamos fazer a mesma coisa para definir esses segues.

947
00:51:01,000 --> 00:51:05,000
>> Vamos ver um exemplo para que, e antes que a transição de fato

948
00:51:05,000 --> 00:51:08,000
a partir de uma tela para outra iOS é bom o suficiente para chamar esse método

949
00:51:08,000 --> 00:51:11,000
prepareForSegue chamado, e é aí que podemos começar

950
00:51:11,000 --> 00:51:14,000
o envio de dados a partir de um aplicativo para outro.

951
00:51:14,000 --> 00:51:17,000
No exemplo que estamos prestes a olhar para ele, basicamente, permitir-nos-

952
00:51:17,000 --> 00:51:20,000
para filtrar times de beisebol pelas ligas e divisões.

953
00:51:20,000 --> 00:51:23,000
Quando eu selecionar uma liga, por exemplo, eu quero fazer a transição

954
00:51:23,000 --> 00:51:25,000
a minha próxima tela onde eu possa mostrar todas as divisões

955
00:51:25,000 --> 00:51:27,000
nessa liga ou todas as equipes diferentes.

956
00:51:27,000 --> 00:51:31,000
Eu preciso enviar para a tela o que as equipes que você deve exibir.

957
00:51:31,000 --> 00:51:35,000
Para fazer isso eu vou aproveitar este método aqui.

958
00:51:35,000 --> 00:51:39,000
>> Por fim, apenas um ponto aleatório no iOS.

959
00:51:39,000 --> 00:51:41,000
Se você deseja armazenar dados há essa coisa chamada de dados básicos,

960
00:51:41,000 --> 00:51:44,000
que na verdade é meio complicado de se trabalhar.

961
00:51:44,000 --> 00:51:47,000
Você também pode usar SQL para armazenar dados,

962
00:51:47,000 --> 00:51:51,000
que, novamente, é bom, mas o tipo de no lado mais complicado de se trabalhar,

963
00:51:51,000 --> 00:51:55,000
mas iOS também suporta essas coisas muito legal chamado listas de propriedades,

964
00:51:55,000 --> 00:52:00,000
e uma lista de propriedades é apenas um arquivo que representa pares de valores-chave.

965
00:52:00,000 --> 00:52:03,000
Você define uma lista de chaves, e você diz esta chave vai ser um array.

966
00:52:03,000 --> 00:52:06,000
Esta chave vai ser uma string, e basicamente qualquer coisa que você pode fazer

967
00:52:06,000 --> 00:52:10,000
em JSON que você pode fazer dentro de uma lista de propriedades,

968
00:52:10,000 --> 00:52:14,000
e por isso esta realmente muito bem nos permite trabalhar com alguns dados.

969
00:52:14,000 --> 00:52:18,000
Por exemplo, eu tenho essa Teams.plist que eu criei.

970
00:52:18,000 --> 00:52:22,000
Eu criei um arquivo plist novo, e eu posso detalhar.

971
00:52:22,000 --> 00:52:26,000
Trata-se de um dicionário, este é um dicionário, são cadeias de caracteres,

972
00:52:26,000 --> 00:52:30,000
e por isso esta é uma boa representação gráfica de um documento JSON

973
00:52:30,000 --> 00:52:33,000
ou apenas um conjunto de pares de valores-chave,

974
00:52:33,000 --> 00:52:37,000
e por isso este é o dado que eu vou estar trabalhando com o interior do meu aplicativo.

975
00:52:37,000 --> 00:52:40,000
>> Vamos primeiro a chegar aqui. Temos arquivos muito mais agora.

976
00:52:40,000 --> 00:52:44,000
Mas primeiro vamos vir aqui para o storyboard.

977
00:52:44,000 --> 00:52:48,000
O storyboard aqui, se eu posso afastar-

978
00:52:48,000 --> 00:52:51,000
agora podemos ver que este é o fluxo do meu aplicativo.

979
00:52:51,000 --> 00:52:53,000
Estou indo primeiro para começar nesta tela.

980
00:52:53,000 --> 00:52:55,000
Vou detalhar a este ecrã,

981
00:52:55,000 --> 00:52:58,000
e eu estou indo para detalhar a esta tela, e podemos ver aqui que se eu tipo de

982
00:52:58,000 --> 00:53:04,000
mover um deles em torno de nós essas setas vai daqui até aqui,

983
00:53:04,000 --> 00:53:08,000
e do jeito que eu definir a seta era se eu ampliar um pouco,

984
00:53:08,000 --> 00:53:12,000
e se eu vir para este controlador de vista,

985
00:53:12,000 --> 00:53:16,000
e aqui está uma célula, e eu quero dizer que quando você toque em uma célula

986
00:53:16,000 --> 00:53:18,000
Eu quero que você deslizar sobre a outra tela.

987
00:53:18,000 --> 00:53:21,000
Eu posso simplesmente segure o controle,

988
00:53:21,000 --> 00:53:26,000
rolar mais um pouco, mantenha o controle, arrastar esta célula mais e deixar ir.

989
00:53:26,000 --> 00:53:30,000
>> E aqui podemos dizer que é a transição que você quer usar?

990
00:53:30,000 --> 00:53:32,000
Você quer usar essa coisa slide que é chamado de impulso?

991
00:53:32,000 --> 00:53:34,000
Você quer deslizar para cima a partir do fundo?

992
00:53:34,000 --> 00:53:36,000
Isso é chamado de modal.

993
00:53:36,000 --> 00:53:40,000
E uma vez que eu clicar em um deles, ele vai tirar essa flecha para mim,

994
00:53:40,000 --> 00:53:44,000
e isso significa que eu realmente tratado o que acontece quando eu pressionar este botão graficamente.

995
00:53:44,000 --> 00:53:48,000
Eu não escrever qualquer código para realmente deslizar de uma tela para a próxima.

996
00:53:48,000 --> 00:53:51,000
Eu defini isso visualmente dentro de Interface Builder.

997
00:53:51,000 --> 00:53:55,000
Se eu clicar nesta seta, podemos ver que eu dei essa coisa de um nome.

998
00:53:55,000 --> 00:53:59,000
Chamei-showDivisions, e isso é para que eu possa saber

999
00:53:59,000 --> 00:54:03,000
que a transição está prestes a ocorrer, e vamos ver por que, em apenas um segundo.

1000
00:54:03,000 --> 00:54:06,000
É assim que eu tenho com fio até as diferentes telas em meu aplicativo.

1001
00:54:06,000 --> 00:54:09,000
Se este fosse um botão, por exemplo, em vez de uma vista de tabela,

1002
00:54:09,000 --> 00:54:11,000
Eu poderia controlar clique no botão, arraste até a próxima tela,

1003
00:54:11,000 --> 00:54:16,000
e é assim que eu possa fazer caminho de navegação que.

1004
00:54:16,000 --> 00:54:19,000
>> Muito rapidamente, se nós entrarmos na MasterViewController,

1005
00:54:19,000 --> 00:54:22,000
novamente, nós estamos indo simplesmente para definir uma lista de coisas

1006
00:54:22,000 --> 00:54:26,000
que será exibido na exibição de tabela.

1007
00:54:26,000 --> 00:54:29,000
Aqui eu estou dizendo que eu quero que você pegue esse arquivo plist,

1008
00:54:29,000 --> 00:54:32,000
e eu quero que você coloque-o em um dicionário,

1009
00:54:32,000 --> 00:54:35,000
e uma vez que você tem que dicionário, eu vou responder a essas mesmas perguntas novamente.

1010
00:54:35,000 --> 00:54:37,000
Aqui é o número de seções.

1011
00:54:37,000 --> 00:54:41,000
Um, há uma linha para cada liga, eo texto de cada célula

1012
00:54:41,000 --> 00:54:46,000
ou deveria ser a primeira, a primeira liga, a segunda liga, e assim por diante.

1013
00:54:46,000 --> 00:54:51,000
Finalmente, eu vou usar este método que acabamos de ver chamado prepareForSegue,

1014
00:54:51,000 --> 00:54:54,000
e este é o método que vai ser acionado quando eu clico

1015
00:54:54,000 --> 00:54:57,000
em uma dessas linhas e, portanto, ativando essa transição

1016
00:54:57,000 --> 00:54:59,000
que eu criar com as setas.

1017
00:54:59,000 --> 00:55:02,000
Isto está dizendo que eu posso ter vários

1018
00:55:02,000 --> 00:55:05,000
relações de uma tela para outra.

1019
00:55:05,000 --> 00:55:08,000
Se eu tiver dois botões e cada botão leva você para uma tela diferente

1020
00:55:08,000 --> 00:55:10,000
Eu vou ter dois segues, um para cada botão.

1021
00:55:10,000 --> 00:55:14,000
Mas esta prepareForSegue é, de novo, vai ser reutilizada

1022
00:55:14,000 --> 00:55:17,000
para cada uma das diferentes relações, o que significa que precisam de uma maneira

1023
00:55:17,000 --> 00:55:21,000
de identificar se você pressionar o botão primeiro ou você pressionar o segundo botão.

1024
00:55:21,000 --> 00:55:25,000
>> Lembre-se de que quando eu dei Segue um nome, este showDivisions,

1025
00:55:25,000 --> 00:55:29,000
é assim que eu agora sei que este é o Segue que foi ativado.

1026
00:55:29,000 --> 00:55:32,000
Tudo o que eu quero fazer é que eu quero dizer

1027
00:55:32,000 --> 00:55:35,000
Eu quero descobrir o que eu bater,

1028
00:55:35,000 --> 00:55:38,000
e assim conseguir isso, eu posso dizer que eu quero o indexPath para a linha selecionada,

1029
00:55:38,000 --> 00:55:42,000
lembrar o indexPath apenas diz onde eu cliquei,

1030
00:55:42,000 --> 00:55:47,000
e então eu quero dizer que eu quero descobrir para onde estou indo.

1031
00:55:47,000 --> 00:55:50,000
Este destinationViewController, que é uma propriedade do Segue.

1032
00:55:50,000 --> 00:55:53,000
Essa é a tela que eu vou,

1033
00:55:53,000 --> 00:55:56,000
então eu sei que a tela eu vou é chamado DivisionsViewController

1034
00:55:56,000 --> 00:55:59,000
porque eu criei essa classe,

1035
00:55:59,000 --> 00:56:02,000
e agora se eu disser d.divisions

1036
00:56:02,000 --> 00:56:06,000
Estou agora a definição de uma propriedade do controlador de vista que estou prestes a ir.

1037
00:56:06,000 --> 00:56:10,000
Isto é como eu estou enviando dados de uma tela para outra tela.

1038
00:56:10,000 --> 00:56:13,000
>> Basta olhar para esta DivisionsViewController

1039
00:56:13,000 --> 00:56:16,000
você pode ver aqui que no arquivo h.

1040
00:56:16,000 --> 00:56:20,000
há que as divisões de propriedade, e é isso que eu estou basicamente preencher,

1041
00:56:20,000 --> 00:56:25,000
então é assim que eu sei que eu estou mostrando as divisões que correspondem a

1042
00:56:25,000 --> 00:56:28,000
a liga que eu cliquei, e novamente,

1043
00:56:28,000 --> 00:56:31,000
o ponto de vista da tabela atual parece praticamente o mesmo, apenas respondendo aos

1044
00:56:31,000 --> 00:56:34,000
3 perguntas simples, bem como a identificação

1045
00:56:34,000 --> 00:56:37,000
o que acontece quando você se mover para a próxima tela.

1046
00:56:37,000 --> 00:56:40,000
Apenas um par de outras coisas aqui.

1047
00:56:40,000 --> 00:56:43,000
Você percebe no topo aqui que em vez de dizer # include

1048
00:56:43,000 --> 00:56:45,000
Estou dizendo agora # importar.

1049
00:56:45,000 --> 00:56:47,000
Esta é apenas uma coisa Objective-C.

1050
00:56:47,000 --> 00:56:52,000
A importação é basicamente uma versão mais agradável de inclusão,

1051
00:56:52,000 --> 00:56:57,000
e, por exemplo, precisamos saber o que esta classe é,

1052
00:56:57,000 --> 00:57:00,000
por isso não posso apenas dizer DivisionsViewController.

1053
00:57:00,000 --> 00:57:05,000
Se não hashtag dentro standardio.c do nosso arquivo c.

1054
00:57:05,000 --> 00:57:07,000
o compilador não tinha idéia do que era printf.

1055
00:57:07,000 --> 00:57:12,000
Da mesma forma, se eu não me importar o DivisionsViewController

1056
00:57:12,000 --> 00:57:16,000
o compilador realmente não tem idéia do que é um DivisionsViewController.

1057
00:57:16,000 --> 00:57:19,000
Apenas certifique-se que dentro de seus arquivos diferentes. M que garantir a importação

1058
00:57:19,000 --> 00:57:25,000
os arquivos correspondentes. h para que o compilador sabe o que está acontecendo.

1059
00:57:25,000 --> 00:57:31,000
>> Finalmente, o que a Apple finalmente faz é apresentar alguns dados usando uma visão web,

1060
00:57:31,000 --> 00:57:35,000
e assim uma visão da Web é um objeto no qual você pode inserir

1061
00:57:35,000 --> 00:57:37,000
um navegador pouco dentro de sua aplicação.

1062
00:57:37,000 --> 00:57:40,000
Tudo que você precisa fazer é fornecer uma URL para seu navegador,

1063
00:57:40,000 --> 00:57:43,000
então eu quero ir para a mlb.mlb.com,

1064
00:57:43,000 --> 00:57:46,000
e é assim que eu posso acessar a página inicial de cada equipe,

1065
00:57:46,000 --> 00:57:49,000
e então pela passagem neste URL

1066
00:57:49,000 --> 00:57:52,000
a exibição da web pode exibir isso para mim, e eu posso navegar ao redor,

1067
00:57:52,000 --> 00:58:01,000
e simulador está em uso por aquele.

1068
00:58:01,000 --> 00:58:03,000
Agora, isso veio da minha plist.

1069
00:58:03,000 --> 00:58:07,000
Se eu clicar nesse presente também veio do meu plist, e este deslizamento foi tratado

1070
00:58:07,000 --> 00:58:09,000
definindo os segues.

1071
00:58:09,000 --> 00:58:12,000
Clico isso e mais um,

1072
00:58:12,000 --> 00:58:15,000
e agora aqui está a minha UIWebView, assim como que

1073
00:58:15,000 --> 00:58:19,000
aqui está o site para a URL que eu apenas incorporado,

1074
00:58:19,000 --> 00:58:21,000
e eu não ter de lidar com qualquer coisa louca.

1075
00:58:21,000 --> 00:58:24,000
Esta é a forma de mostrar uma página web.

1076
00:58:24,000 --> 00:58:27,000
Coisas como este botão volta aqui também são dadas para mim

1077
00:58:27,000 --> 00:58:33,000
totalmente de graça, porque eu já definiu essas relações usando segues.

1078
00:58:33,000 --> 00:58:37,000
>> Alguma pergunta? Sim.

1079
00:58:37,000 --> 00:58:40,000
[Estudante] Então, quando você usar alloc, você nunca tem a nada livre?

1080
00:58:40,000 --> 00:58:43,000
Exatamente, quando você chamar alloc e init você não tem para libertá-la.

1081
00:58:43,000 --> 00:58:46,000
IOS vai lidar com tudo isso para você.

1082
00:58:46,000 --> 00:58:51,000
É maravilhoso, e você não está quebrando nenhuma regra. Sim.

1083
00:58:51,000 --> 00:58:54,000
[Estudante] Se você fosse para incluir mais times que poderiam caber na tela,

1084
00:58:54,000 --> 00:58:58,000
seria automaticamente tem uma opção de deslocamento, ou é algo que você precisa adicionar?

1085
00:58:58,000 --> 00:59:01,000
Exatamente, se eu tivesse mais equipes, por exemplo, seria tratar automaticamente

1086
00:59:01,000 --> 00:59:04,000
a rolagem para mim, e todos os problemas de desempenho

1087
00:59:04,000 --> 00:59:08,000
com a enorme mesa também são feitos totalmente por mim.

1088
00:59:08,000 --> 00:59:11,000
>> Outras perguntas?

1089
00:59:11,000 --> 00:59:13,000
Todo esse código vai ser postado.

1090
00:59:13,000 --> 00:59:16,000
Nós meio que encoberto um pouco dos detalhes mais pequenos,

1091
00:59:16,000 --> 00:59:19,000
mas coisas como definir algumas propriedades para a exibição da web

1092
00:59:19,000 --> 00:59:22,000
são apenas coisas que você pode obter através de seu navegador de documentação da Apple,

1093
00:59:22,000 --> 00:59:24,000
o que é realmente, realmente muito bem definidos.

1094
00:59:24,000 --> 00:59:27,000
Eles têm um monte de aplicativos de amostra e exemplo usos

1095
00:59:27,000 --> 00:59:34,000
de APIs diferente, então definitivamente ler os se puder.

1096
00:59:34,000 --> 00:59:36,000
Apenas alguns links úteis que você pode querer dar uma olhada.

1097
00:59:36,000 --> 00:59:38,000
Estas são algumas guias de documentação à mão.

1098
00:59:38,000 --> 00:59:41,000
As URLs são enormes, por isso eles são encurtados.

1099
00:59:41,000 --> 00:59:44,000
Este primeiro é toda a biblioteca de documentação.

1100
00:59:44,000 --> 00:59:46,000
Há barras de pesquisa pequenos, então se você começar a digitar o botão

1101
00:59:46,000 --> 00:59:50,000
ele vai começar a dar-lhe todas as informações sobre todas as coisas que você pode fazer com um botão.

1102
00:59:50,000 --> 00:59:53,000
Eu também incluiu a Tabela de guia de programação View.

1103
00:59:53,000 --> 00:59:56,000
Ele lida com vistas de tabela em muito mais detalhe,

1104
00:59:56,000 --> 01:00:00,000
como fazer as coisas como adicionar dinamicamente ou células editar ou remover.

1105
01:00:00,000 --> 01:00:02,000
>> Há muitos aplicativos de amostra da Apple que vai mostrar como fazer isso,

1106
01:00:02,000 --> 01:00:05,000
e, finalmente, este último é o Human Interface Guidelines,

1107
01:00:05,000 --> 01:00:09,000
e isso é basicamente uma discussão de componentes de interface do usuário,

1108
01:00:09,000 --> 01:00:12,000
coisas como não fazer um botão que é 4 pixels por 4 pixels.

1109
01:00:12,000 --> 01:00:15,000
Isso é uma má idéia, e outras coisas que a Apple quer que você faça

1110
01:00:15,000 --> 01:00:18,000
encorajar a boa concepção.

1111
01:00:18,000 --> 01:00:23,000
>> Qualquer dúvida últimas antes de terminar?

1112
01:00:23,000 --> 01:00:27,000
Tudo bem, sinta-se livre definitivamente para-nós estamos indo ter rótulos especiais para discutir.

1113
01:00:27,000 --> 01:00:30,000
Nós vamos ter um iOS um, para definitivamente se sentir livre para utilizar isso.

1114
01:00:30,000 --> 01:00:34,000
Se você quiser trabalhar com seus colegas de classe em projetos

1115
01:00:34,000 --> 01:00:37,000
ou ajudar a descobrir algumas coisas iOS aleatória

1116
01:00:37,000 --> 01:00:40,000
sinta-se livre para me e-mail, e, definitivamente, ler tudo online o código porque

1117
01:00:40,000 --> 01:00:43,000
apenas no interesse de tempo que tipo de encoberto a mais

1118
01:00:43,000 --> 01:00:45,000
detalhes mais finos grãos de coisas.

1119
01:00:45,000 --> 01:00:47,000
Mas se não, então boa sorte em seus projetos de iOS, e espero que tenhamos

1120
01:00:47,000 --> 01:00:53,000
um grande fluxo de aplicativos na App Store.

1121
01:00:53,000 --> 01:00:56,000
[CS50.TV]