[Powered by Google Translate] [Seminário] [iOS: Escrevendo Aplicativos Like a Boss]
[Tommy MacWilliam] [Harvard University]
[Esta é CS50.] [CS50.TV]
>> Tudo bem, todos, bem-vindos para iOS: Escrevendo Aplicativos como um chefe.
Este seminário vai se concentrar em escrever aplicativos para o iPhone
e por sua vez a escrever aplicativos para o iPad, e por isso estamos basicamente vai percorrer
alguns exemplos diferentes de como fazer um aplicativo, um jogo simples como Tic Tac Toe,
ou se você está mais interessado em fazer um aplicativo como uma espécie de leitor de notícias
ou algo que interage com a Internet vou falar sobre isso também.
Aqui está a nossa agenda breve.
>> Aplicativos do IOS são escritos em uma linguagem chamada Objective-C,
e por isso este é um pouco semelhante a C, mas não realmente em tudo,
por isso vamos estar falando um pouco sobre a própria linguagem
e como construir aplicativos para o iPhone usando este programa aplicativo chamado XCode,
que se você não tiver baixado ainda sinta-se livre para iniciar o download agora.
É vários gigabytes.
Ele deve ser livre na App Store, por isso você precisa ter um Mac
idealmente rodando a última versão do OS X.
Se você não for, não há problema.
Temos Macs no Centro de Ciências disponíveis para seu uso
com o XCode instalado, e tão à vontade para usar aqueles para o desenvolvimento.
Se você quiser fazer um app, mas não tem um Mac, não se preocupe.
Há uma abundância de recursos do campus para isso.
E então nós estamos indo para cobrir 2 exemplos maiores de aplicativos diferentes que você pode fazer.
Objective-C é tecnicamente o que é chamado um super set de C.
Isso significa que qualquer código C é também o código Objective-C válido.
Isso significa que nós tipo de conduto gravadas em algumas características adicionais para C.
Algumas destas características incluem não ter que escrever sempre malloc novamente, graças a Deus,
sem ter que se preocupar com os ponteiros estúpidas e libertando-os e todas as coisas que
você odiava sobre C, e é uma espécie de desaparecido em Objective-C.
>> Agora, Objective-C também tem uma biblioteca padrão muito maior,
por isso há uma funcionalidade muito mais você começa para dentro livre de Objective-C.
Lembre-se de quando estávamos escrevendo PHP notamos que passou de
este menor linguagem para a biblioteca gigante de todas essas coisas malucas que você pode fazer.
A mesma coisa acontece no iOS.
Há objetos para coisas como o calendário budista, e realmente nada
você pode pensar de, provavelmente, já existe na implementação Objective-C.
A parte objetiva da Objective-C é referência algo
chamado de Programação Orientada a Objetos.
Este é o tipo de um conceito novo, mas temos, na verdade a maioria aprendeu
muitos desses conceitos já.
A idéia por trás Programação Orientada a Objetos é que você está indo para estruturar
um monte de seu código em torno dessas coisas chamadas de classes,
e essas aulas são realmente glorificado estruturas.
Dentro de uma estrutura que basicamente disse aqui é uma coisa,
e esta coisa pode ter membros.
Por exemplo, um nó de uma lista ligada pode ter outras coisas
como um valor, um ponteiro para o próximo nó na lista,
e, juntos, esse ponteiro e esse valor compôs esta instância de uma struct.
As aulas são muito semelhantes, exceto
classes também podem ter funções dentro deles.
Quando declaramos uma estrutura, podemos apenas dizer n int ou * próximo nó.
>> Agora, com o Objective-C, podemos realmente colocar funções
dentro dessas coisas.
Outra coisa que as classes podem fazer é que eles podem herdar dados de outras classes.
Por exemplo, vamos estar a olhar para um monte de built-in classes Objective-C.
Um deles poderia ser a classe que representa o ponto de vista de uma tela,
e assim por dizer eu quero implementar meu próprio ponto de vista
nós basicamente dizer alguém na Apple, as pessoas provavelmente muito legais,
escreveu esta classe para mim, e ele lida com as coisas como mostrar botões
ou tornando a tela, e seria muito triste
para implementar todas as funcionalidades que nós mesmos, e assim, simplesmente
herdar dados, podemos dizer que tudo o que fez na classe
Eu também quero dentro da minha classe, e então eu vou fazer algumas outras coisas,
ou seja, implementar um aplicativo.
Isso é o que a herança palavra significa. Vamos ver um exemplo mais concreto.
>> E, finalmente, a chave com programação orientada a objeto é que
ela conduz a encapsulação de dados.
Em alguns dos nosso problema define poderíamos ter estes grandes, variáveis ​​globais
e globais em toda parte, e é assim que nós manter o controle de estado.
Com aulas podemos começar encapsular informações dentro de um objeto.
Se temos uma tela em nosso app, nós realmente não precisa ter todos os dados de
outra tela em nosso interior app de que,
e assim por encapsular as coisas dentro de classes isso realmente leva
ao projeto do código muito melhor, e isso é possível com alguns dos recursos adicionais
de Objective-C.
Aviso prévio, a sintaxe para Objective-C é bananas.
É como nada que já vimos antes,
por isso é um pouco de uma curva de aprendizado para se acostumar
o que diabos isso significa?
Mas uma vez que você passar por essa curva de aprendizado inicial é realmente, realmente bom
para começar a escrever aplicativos.
>> Para declarar uma classe, a dizer aqui é a minha classe, ele existe,
e, talvez, aqui estão algumas coisas que eu estou indo para definir posteriormente,
Eu vou dizer @ interface.
Eu vou dizer @ interface. Eu vou dar a minha aula de um nome.
E, mais tarde, em outro lugar que eu vou dizer @ final,
e tudo entre a interface eo @ @ end
vai ser minha classe.
Isso vai ser o que está dentro de nossos arquivos. H.
Assim como em C nossos arquivos. H basicamente disse, aqui estão algumas coisas que existem.
Eu não estou necessariamente dizendo o que eles fazem, no entanto,
mas o compilador precisa saber que eles existem.
Mais tarde, dentro da nossa m. Arquivos, porque m para Objective-C
é para onde estamos indo realmente para definir o que essas classes fazem.
Muito parecido com nossos arquivos. C, fornecemos uma implementação para funções.
Dentro do nosso arquivo. M vamos dizer aqui é que todas as funções
dentro da minha classe o que todos fazem.
E, finalmente, dentro de uma estrutura poderíamos dizer dentro dessas chaves
int, ou nó n * próxima
e em Objective-C, vamos usar a palavra-chave @ property
e isto é o que vai definir as propriedades,
ou as funções não-que são uma parte de minhas aulas.
>> Chamando funções em Objective-C é também bananas.
Quando declarou funções em C que disse algo como int foo
e aberto parêntese e depois deu-lhe uma lista de argumentos.
Isto é o que declarar métodos ou funções parece em Objective-C.
Se eu quiser declarar uma função ou um método
onde eu estou dizendo método é realmente apenas uma função que é membro de uma classe,
tão tipo de intercambiáveis, mas não realmente,
tão dentro do meu método eu quero criar um novo método.
Vai retornar nada, por isso vai ser do tipo void.
Este é o tipo de retorno da minha função.
Agora temos parênteses aqui porque, eu não sei.
Em seguida vai ser o nome da minha função,
e, finalmente, temos um ponto e vírgula como tivemos em C.
O que é novo aqui é esse cara aqui.
Este hífen é realmente necessário, eo que isso diz é que
este método aqui deve ser chamado em uma instância de uma classe.
>> Depois que declarou nossas estruturas que provavelmente disse algo como
n nó struct, e que criou
ou instanciado uma dessas estruturas para que eu pudesse realmente começar a trabalhar
com o que está dentro dele, de modo que este traço significa que nós temos que
instanciar a classe assim como nós instanciado que struct
antes de nós pode chamar esse método nele.
Se eu quiser começar a adicionar argumentos para os meus métodos
torna-se ainda mais bananas.
Aqui é o meu nome do método.
Então eu vou ter dois pontos, e após este cólon diz aqui vem alguns argumentos.
Este método tem um argumento.
O tipo do argumento é um int, eo nome do que o argumento
ou a variável que eu vou começar a usar dentro do método é chamado de i.
Novamente, este é o método. Ela tem um argumento.
>> Se você quer começar a adicionar mais argumentos fica mais bananas
em que temos esta cólon que diz aqui vem a minha lista de argumentos.
Este primeiro argumento é um inteiro.
Agora, este segundo argumento é interessante.
A variável que eu vou estar usando dentro da minha função
é chamado de f, para dentro da minha função eu poderia dizer
f + = 1 ou algo assim.
Isso aqui é basicamente uma chave para que o argumento ou parâmetro.
Assim como tivemos pares de valores-chave e algo como JSON ou arrays associativos
Objective-C tomou a decisão de dizer, ok, só para que fique bem claro
quando você chamar um método que todos estes parâmetros são
Eu estou indo realmente para nomeá-los todos.
Quando você chama um método, você vai realmente dizer andFloat,
e então você vai passá-lo dentro
>> Curiosamente, este não é nomeado, mas todos os outros parâmetros são,
por isso, se tivéssemos um argumento 3 que eu poderia dizer andFloat
e uma outra bóia e assim por diante.
Quando eu chamar esses métodos é de bananas do curso,
Então, se eu tenho um objeto, e eu definido um método chamado foo,
e quero chamá-lo, em vez de dizer foo aberto / parens próximos
Eu vou abrir um parêntese.
Aqui está o nome do meu método.
Eu vou fechar o suporte, e esse é o objeto que eu estou chamando-o.
Lembre-se, todos estes métodos existem dentro de classes
porque as classes podem ter métodos definidos dentro deles.
>> Aqui eu arbitrariamente criado um objeto de alguma classe,
e esta é a sintaxe para fazer isso.
Há dois passos para a criação de um objeto.
O primeiro passo é dizer que eu quero alocar espaço.
Isto é o equivalente de um malloc. Não temos a dizer malloc mais.
Nós derrubamos o m, fez alloc, e substituiu o c. Com. M.
Depois que algo alloc que precisa então para o inicializar.
Basicamente, quando você cria objetos que você pode querer ter alguma lógica
que é executado quando eles são criados, assim você pode passar em alguns valores padrão
ou algo assim, e por isso este método init é o que realmente cria o objeto.
Nós primeiro alocar espaço, assim como fizemos em C,
e, então, inicializar, o que pode ou não pode fazer muita coisa.
Então, nós estamos retornando essa coisa em um o objeto.
Há uma estrela aqui porque este é, tecnicamente, um ponteiro,
mas não se preocupe, os ponteiros não são grande coisa em Objective-C mais.
>> Agora nós instanciado esta classe chamada NSObject,
e esta é apenas uma classe aleatória que a Apple tem.
Nós instanciado isso, e agora eu tenho uma instância da classe
neste o objeto, o que significa que se eu definido
estes métodos que eu poderia chamá-los assim.
Da mesma forma, se eu quisesse chamar um método com um argumento,
por isso este é o método de bar, que tem um argumento,
e aqui é o baz: método qux, então isso leva 2 argumentos.
Isso está chamando uma função nesta o objeto.
Faz sentido?
A sintaxe deve fazer sentido, mas você meio que se acostumar com isso.
>> Ok, vamos falar sobre algumas coisas que são construídos em Objective-C
que não foram necessariamente construído em C.
Em que tipo de C teve de lidar com as seqüências como essas matrizes de caráter estúpidas,
e ele ficou realmente irritante.
Objective-C tem todos aqueles construído em para nós, e é construído em
usando esta classe chamada NSString.
Quando eu quero criar um NSString temos sintaxe mais misterioso.
Ao invés de dizer "CS50", dizemos @ "CS50"
e esta é apenas a sintaxe para declarar strings em Objective-C.
Isso é extremamente fácil de esquecer, por isso não.
Agora, uma vez que tenho isso, isso é uma seqüência, mas observe
é realmente apenas um objeto.
Eu disse NSString, o que significa que a classe instanciada
chamada NSString, que alguém escreveu para mim,
e eles foram muito agradável sobre ele, e por isso agora
Eu posso começar a chamar métodos nele.
Se eu chamar o comprimento método nesta s objeto
ele vai voltar para mim o comprimento da corda.
Este é apenas como strlen em C.
Este voltaria 4.
>> Da mesma forma, um outro método que eu poderia querer se preocupar com isso é characterAtIndex.
Este é um método que diz sobre este string s
Eu quero você para obter o caractere 0,
e assim que este voltaria para mim o caractere c,
e há um monte mais desses métodos que você pode Google realmente fácil.
Documentação da Apple é grande, e nós vamos dar uma olhada no que a pouco.
Essas são cordas.
Temos também matrizes de tamanho variável construído dentro
Lembre-se no C quando declaramos uma matriz
nós tivemos que dizer que você tem 5 elementos, fim da história.
Quando chegamos ao JavaScript e PHP poderíamos começar
fazer as coisas como a adição de elementos ou movendo elementos.
Nós podemos fazer o mesmo em Objective-C.
Em vez de criar uma matriz no caminho C normal
temos novamente uma outra classe chamada NSMutableArray.
Há também NSArray,
e isso vai basicamente encapsular alguns matriz.
Este diz que a primeira coisa que eu quero fazer é que eu quero para alocar
espaço para uma nova matriz, e depois que eu atribuí-lo
Eu, então, precisa inicializá-lo.
Novamente, basta chamar esses dois métodos.
Agora, isso significa que dentro deste objeto de um
Eu tenho uma matriz vazia sentado lá.
Se eu quiser adicionar algo a essa matriz, eu posso chamar o método addObject.
Eu quero adicionar um objeto para a matriz, e eu quero adicionar a string CS50.
Se eu quisesse remover inversamente que eu posso dizer que eu quero
remover o objeto em primeiro lugar na matriz ou um objeto.
>> Faz sentido?
Ok, você meio que se acostumar com essa coisa colchete.
A propósito, dentro de um monte de bibliotecas da Apple você verá este NS.
O NS está realmente para próxima etapa, que foi uma das empresas de Steve Jobs primeira,
e é aí que ele realmente começou a escrever um monte de código
como uma espécie de base para o Mac OS X e todas as outras coisas,
e por isso este tipo de NS é esse legado bom gritar para uma das empresas mais antigas
volta, quando a Apple foi a primeira partida.
Está em toda parte.
Vamos dar uma olhada em um exemplo mais holística Objective-C.
Aqui eu estou dentro de XCode.
Para chegar até aqui, eu primeiro baixado XCode da App Store,
abriu-se, e então eu fui até aqui para arquivo,
cá para novo projeto, e então.
Depois de eu fazer isso eu tenho todas essas opções do que eu quero para criar,
e assim vamos dar uma olhada nessas opções mais tarde,
mas apenas para este exemplo, porque não estamos realmente vai ter um aplicativo, no entanto,
Eu vim aqui, e eu disse ferramenta de linha de comando,
e este é um aplicativo que eu poderia correr na linha de comando
como temos vindo a execução de C.
É assim que eu criei este projeto, e agora eu estou aqui,
então vamos primeiro olhar para este arquivo, e isso deve olhar muito familiar.
Eu tenho um nome int. Não é o meu argc amigo, meu outro amigo argv.
E assim podemos ver que este é o ponto de entrada para a minha candidatura Objective-C primeiro.
Aqui podemos ignorar isso por enquanto.
Este é basicamente algumas coisas gerenciamento de memória que você não vai realmente
sempre tem que se preocupar.
>> Vamos olhar para este primeiro bloco aqui.
Esta primeira linha, se eu disser Estudante * alice = [[alloc Estudante] init] o que é que está fazendo?
Este primeiro aluno aqui, esta é provavelmente uma classe.
Esta não é uma classe que a Apple escreveu, mas é uma classe que eu escrevi.
A primeira coisa que quero fazer é que eu quero alocar espaço para um novo aluno,
e então eu quero para inicializar, então isso me dá de volta
este objeto novo aluno, e eu sou armazenar isso em uma variável chamada Alice.
Onde foi que a classe vem?
Bem, aqui do lado esquerdo são todos os arquivos diferentes dentro do meu projeto.
Podemos ver aqui eu tenho um Student.h e um Student.m.
O. Arquivo h, lembre-se, é onde eu declaro todas as coisas
que existirá dentro da classe.
>> Vamos dar uma olhada nisso.
Tudo bem, aqui temos esta interface @, e este diz que aqui vem
as declarações de tudo o que vai existir dentro de minha classe.
Então eu tenho dois pontos. Então eu tenho essa coisa NSObject.
Isso significa que pouco cólon herança estávamos discutindo um pouco mais cedo.
Isto diz tudo o que um pode fazer NSObject
onde NSObject é esta classe escrito por outra pessoa,
tudo o que este pode fazer NSObject Eu quero ser capaz de fazer isso.
Ao dizer: NSObject que significa que eu, basicamente,
herdado toda a funcionalidade de uma outra classe.
Isso realmente me deu um monte de diferentes métodos e propriedades que eu possa usar.
Aqui embaixo eu estou criando duas propriedades.
Isso significa que o meu aluno, se este fosse uma estrutura, estes seriam os 2 coisas
dentro da minha estrutura, de modo que cada aluno tem um nome
que é uma string, e um estudante também tem um grau,
que é um int.
>> Finalmente, aqui eu vou criar um método para meu aluno.
Liguei para o meu método, initWithName, e leva um argumento,
e esse argumento é uma string, e eu chamei ele nomear.
Agora vamos olhar como nós realmente implementado nesta classe.
Aqui, agora eu estou dentro do meu arquivo m.,
m para a implementação, eu acho.
Eu tenho a minha aplicação, o meu fim, e aqui é onde eu estou, na verdade, a definição de
o que faz initWithName.
Tenho initWithName, o nome do meu parâmetro, e então esta
é onde eu estou, na verdade, a criação de um estudante,
e por isso este é um pouco enigmático, mas este é o tipo de clichê
que você deseja incluir em seus construtores.
Esta função de inicialização aqui, initWithName, é um tipo de construtor.
Você está basicamente a construção de um objeto novo aluno
e talvez o envio de alguns dados dentro dela.
A primeira coisa que quero fazer é que eu quero chamar o init nesta coisa super.
>> Lembre-se que quando eu disse aqui no arquivo h.
que tudo um NSObject tem um estudante também tem.
Isso significa que quando eu crio um estudante que eu também preciso fazer é
certifique-se de que o NSObject que estou herdando todos os dados a partir de
É também inicializado adequadamente.
O que eu preciso dizer é o super é realmente indo para referir-se a classe pai
que eu estou herdando, assim que eu quero me certificar de que inicializar
tudo o que eu estou dependendo antes de eu começar a tentar usá-lo.
Então, se isso inicializado corretamente este é apenas como dizer se malloc
não retornar nulo, então eu posso começar a definir algumas propriedades.
>> Em JavaScript e PHP tínhamos esta palavra-chave chamada isso,
e isso se refere à instância atual de uma classe.
Em Objective-C chamamos isso de si mesmo.
Quando eu digo self.name, o que significa que o objeto
Acabei de criar quando disse alloc estudante init,
que vai me dar de volta um objeto.
Isso significa que eu quero para definir o nome do objeto
para o que eu apenas passado dentro
Assim como em C, temos acesso a membros com este ponto,
assim self.name diz o nome do objeto de estudante
agora vai ser o que você acabou de passar dentro
E assim, finalmente, eu posso devolvê-lo assim que eu realmente voltar algo.
>> Perguntas?
Ok, então essa auto = super-init,
se você não compreender totalmente o material herança não se preocupe.
Só sei que se você quiser fazer o seu próprio método de inicialização apenas
fazer isso, e você vai ser bom para ir.
Sim. >> [Estudante] O que se auto média?
Isto significa que quando nós malloc algo que sempre verificado se ele era igual a nulo,
e se era nulo, então saímos.
Esta é a mesma coisa, porque se este retorna nulo, então nós provavelmente vamos culpa seg
se começar a tentar manipulá-lo.
Essa é a nossa classe estudantil.
Isso significa que podemos iniciar nossos alunos em uma de duas maneiras.
Se eu disser que o init alloc estudante eu não estou usando esse método que eu escrevi,
e em vez disso eu posso simplesmente dizer alice.name,
e agora eu estou indo para definir que o nome da propriedade.
>> Da mesma forma, se eu quiser usar esse método initWithName
Eu posso simplesmente dizer alloc, e depois ao invés de dizer o init
Eu vou chamar esse método que acabei de criar, e eu vou passar em Bob.
Neste ponto, o Bob objeto tem um nome igual ao Bob.
Ok, aqui eu estou usando o que NSMutableArray que vimos anteriormente.
Estou alocando space.Then estou inicializando uma nova matriz.
Eu estou indo para adicionar 2 coisas a ele.
Esta matriz agora detém objetos estudantes.
Repare que em nenhum lugar que eu tenho que dizer que este é um conjunto de alunos.
Eu disse que é uma matriz, período.
Então eu posso colocar o que dentro dele que eu quero.
Aqui eu tenho dois objetos.
>> Finalmente, tenho um outro objeto aqui, este TF.
Aqui em TF.h basicamente a mesma coisa.
Estou herdando de NSObject, e, a propósito,
quando você criar classes de tudo isto é feito para você,
esse tipo de clichê interface.
Ele tem uma propriedade de estudantes.
Eu tenho um par de métodos aqui que realmente não fazer muito,
e então isso significa que depois de eu criar esse objeto TF
Eu posso chamar esse método em série assim.
Qualquer dúvida sobre Objective-C sintaxe antes de começar a se mover em um pouco mais de
coisas desenvolvimento interessante aplicativos?
>> Ok, então vamos realmente fazer um aplicativo para iPhone.
As aulas do núcleo que você vai usar dentro de seu aplicativo para iPhone são chamados de controladores de vista,
e um controlador de vista representa basicamente uma única tela
dentro do seu aplicativo, então se eu estou no aplicativo de música, por exemplo,
um controlador de vista pode representar o ponto de vista em que eu ver todas as músicas no meu iPhone.
Outro controlador de vista poderia ser quando eu clico em uma música e começar a jogar
ou como eu estou perfuração para baixo em artistas.
Cada uma dessas telas diferentes podem ser representadas como um controlador de ponto de vista diferente,
e um controlador de vista é realmente apenas uma classe que diz como esta tela funciona.
Coisas dentro de um controlador de vista, nós vamos ter propriedades,
para coisas como um botão que vai ser uma propriedade de nosso controlador de vista.
>> Nós também vamos ter métodos, e estas são, basicamente, manipuladores de eventos.
Este método diz quando você pressionar este botão
Eu quero fazer alguma coisa, e, finalmente, de novo,
vamos estar usando esta palavra-chave auto para acessar a instância atual.
Para construir interfaces no iOS é realmente muito, muito fácil.
Eles têm essa resistência agradável e interface queda chamada Interface Builder,
e os dois conceitos fundamentais que o fio de seu Objective-C para Interface Builder
são IBOutlet e IBAction.
Um IBOutlet simplesmente diz que se você declarar uma propriedade que é um botão,
e você quer ligar-se a algo em sua interface real,
você vai dizer que é uma saída.
Da mesma forma, se você quiser representar um manipulador de eventos
então você vai dizer que é uma ação.
>> Para realmente conectar esta representação gráfica
e seu código é realmente, realmente simples.
Se você deseja anexar um IBOutlet, tudo que você tem a fazer é você controlar clique,
e vamos ver um exemplo disso realmente rápido.
Você controla clique onde diz View Controller.
Você vai arrastar para a interface, ou, inversamente,
se você quiser ligar um manipulador de eventos que vai arrastar a partir da interface
na outra direção.
Vamos dar uma olhada em um exemplo iOS realmente simples.
>> Vamos criar um novo projeto.
Eu vou vir aqui para aplicativo,
e eu vou clique em Aplicativo de visualização simples.
Vou clique em Avançar. Eu vou dar o meu projeto de um nome.
Eu vou chamá-lo Olá.
Curiosamente, a Apple assume que você está criando um produto
de modo que você pode vendê-lo e eles podem fazer dinheiro.
Aqui embaixo vou dizer que este é um aplicativo para iPhone.
Você pode criar um aplicativo para iPad, ou se você quiser criar um desses aplicativos
que suporta ambos os dispositivos que você pode fazer isso também.
Estes são o que você quer que seus checkmarks a aparência.
>> Você quer usar storyboards, que vamos ver mais tarde,
e você definitivamente quer usar a contagem de referência automática,
o que é um bom recurso que impede que você tenha a dizer malloc e free.
A menos que você quiser chamar malloc e free, eu deixaria o marcado.
Eu vou clique em Avançar e, finalmente, isso vai me perguntar onde eu quero salvá-lo.
Eu vou bater criar, e aqui vamos nós.
Eu criei um novo projeto.
Aqui do lado esquerdo são todos os arquivos que estão dentro do meu projeto,
e perceber que eu tenho um monte, e eu não fiz nada.
IOS é grande.
>> Por exemplo, aqui ViewController.h isso,
isso vai representar o meu controlador de primeira vista,
para a primeira tela dentro do meu aplicativo.
Agora sabemos o que isso está dizendo.
Nós estamos dizendo que eu estou chamando este ViewController classe,
e um ViewController faz tudo o que um UIViewController faz,
e isso, novamente, é uma classe que a Apple escreveu que faz um monte de coisa útil para nós
como exibir a tela.
Aqui é onde eu posso realmente começar a definir o que o meu controlador de vista faz,
e acontece que eu realmente não precisa de nada disso.
Este é o código clichê de que a Apple me dá de graça.
Eu fiz precisa que a primeira linha, ou eu não tenho uma classe,
assim podemos nos livrar disso e se livrar dessa.
Ok, então esta é a minha tela vazia.
>> Agora vamos clicar neste MainStoryboard.storyboard,
e é aí que ele começa a ficar interessante.
Isto representa a primeira tela do meu aplicativo.
Se eu quiser adicionar um botão, em HTML, eu tive que criar uma marca de botão.
No Android você tem que criar uma tag botão,
mas no iOS se eu vir aqui para a parte inferior direita
e se eu clicar em um presente 3 aqui onde diz Objetos,
e eu posso deslocar para baixo, ou eu posso começar a procurar por botão.
E olha, um botão, então se eu realmente arrastar e soltar esse direito lá,
Eu apenas acrescentou um botão para esta tela no meu app.
Se eu quiser mudar o texto, eu posso clicar duas vezes nele,
dizer algo atraentes como "Prima-me."
Ok, agora se eu executar este aplicativo, de modo que compilá-lo,
para executá-lo eu clicar no botão play no canto superior esquerdo, e há o meu aplicativo.
Eu não fiz nada, e eu tenho um aplicativo para iPhone doce olhar.
Se eu quiser parar, você pode clicar no botão de parada
porque é mais divertido.
>> Vamos dizer que eu realmente quer que algo aconteça quando eu pressionar este botão.
Para fazer que o que eu preciso fazer é que eu preciso para criar
um manipulador novo evento ou uma ação.
Isso significa que eu preciso criar algum método que eu quero ser chamado
quando eu aperto o botão, então vamos criar um novo método.
Eu estou dentro de ViewController.h.
Eu preciso dizer que um método existe.
Eu preciso de um primeiro hífen, porque eu vou estar chamando isso no controlador de vista.
Eu preciso dar um presente tipo.
O tipo de isso vai ser aquela coisa IBAction que vimos anteriormente.
Este é um manipulador de eventos, por isso vai retornar um IBAction,
e esta é uma dica para o XCode para dizer que
isso é algo que eu quero ligar algo a.
Posso dar-lhe um nome, como vírgula, buttonPressed.
>> Agora eu tenho declarado um novo método dentro da minha classe.
Eu já disse, este método tem de existir.
Agora vamos entrar em ViewController.m,
e vamos dizer o que este método pode fazer.
Se eu começar a digitar, por exemplo, (void) buttonPressed
aviso XCode é muito bom e autocompletes para mim.
Isso é realmente maravilhoso.
Note-se aqui que dentro do arquivo. M Eu também posso dizer nula,
e isso é porque que IBAction não é realmente um tipo.
É realmente hashtag definido em algum lugar para ser um vazio,
e, novamente, esta é apenas uma dica para XCode que diz
Eu quero que este seja um manipulador de eventos, e vamos ver por que, em apenas um segundo.
Quando este botão é pressionado eu vou fazer algo chato
gosto mostrar uma pop-up.
>> Para fazer que eu posso criar uma nova instância desta classe chamada UIAlertView,
e esta é uma classe que a Apple escreveu que vai exibir pop-ups irritantes.
Vamos chamar este alerta pop-up, e eu tenho dois passos, lembre-se, para criar este objeto.
A primeira coisa que precisa fazer é alocar espaço.
Eu quero um UIAlertView.
Quero alocar espaço. Esse é o meu primeiro método.
Meu próximo método é que eu quero inicializar ele,
e por isso tenho este método, grande e longo chamado initWithTitle.
Isso é basicamente o que vai controlar esse pop-up diz.
O título do meu pop-up pode ser Olá.
A mensagem deste pop-up pode ser "Este é o iOS."
Delegado coisa, eu não sei o que é.
Vamos dizer que não é nada.
Agora, o botão que vai aparecer pode dizer algo como "Com certeza é",
e eu realmente não quero quaisquer outros botões, então vamos excluir esse e fechar o suporte.
>> Ok, eu criei um extra. Lá vamos nós.
Isto é como eu posso criar um pop-up nova.
Se eu quiser realmente mostrar o pop-up que eu quero chamar o método show.
Para fazer o que posso dizer alerta e show,
e, novamente, autocomplete foi super agradável.
Se eu esqueci o que era, se eu digitei em s,
Eu posso rolar por aqui para descobrir o que era,
e ele filtra bem.
Agora eu criei esse pop-up nova.
Nós vamos voltar ao que significa delegado depois,
e agora eu quero dizer que eu quero que este método a ser demitido
quando eu aperto o botão, então eu vou voltar para o meu storyboard,
e eu quero agora anexar esse IBAction.
A primeira coisa que você quer fazer é clicar no botão.
Ao pressionar este botão eu quero que algo aconteça.
Eu não vou segurar para baixo controle.
Eu estou indo para clicar e arrastar a partir do botão
para aqui onde diz View Controller.
Podemos ver que ele bem se acende.
>> Se eu deixar de ir com o meu mouse agora tenho esse pop-up aqui onde eu tenho algumas opções.
Uma delas são os eventos que eu possa registrar.
Estes são todos os métodos eu declarados no meu arquivo h como IBActions.
Isto é como XCode sabe o que deve aparecer nesta lista pequena,
de modo que é apenas uma sugestão.
Se eu clicar no botão pressionado, eu agora registrou o manipulador de eventos.
Em JavaScript que tínhamos a dizer que eu tenho um código que registrou o manipulador de eventos.
Em Objective-C foi realmente assim tão fácil.
Se eu executar este novo
agora quando eu aperto o botão meu manipulador evento vai ao fogo,
e eu vou pegar esse pop-up.
Super, super simples lá.
>> Se você quiser ver todos os eventos que acontecem a ser registrado
em um componente se eu clicar neste botão
e eu vim aqui para o lado direito
primeiro você pode ver aqui o que posso fazer coisas como o tipo de botão,
então se você quiser um desses, eu ou o botão Adicionar contato
ou o que quer.
Se eu quiser ver todos os eventos que estão neste botão
se eu vir até aqui para o lado direito
podemos ver aqui os eventos que eu tenho todos esses eventos diferentes.
Eu posso pressionar o botão, quando eu deixar de ir ao botão, quando eu dobro da torneira ou o que seja,
e aquele que eu apenas registrado é este evento chamado Touch Up Inside,
e este diz que, assim como meu dedo sai o botão
que o evento vai para o fogo, e é exatamente isso o que aconteceu.
Este é o tipo de evento de botão padrão pressionado.
>> Todas as perguntas até agora?
Ok, é assim que podemos começar a conectar as coisas no nosso código
em coisas dentro da nossa interface.
Lembre-se, a primeira coisa que tínhamos que fazer era encontrar o código,
e, então, com fio a interface com o código,
e não é o nosso primeiro aplicativo.
Ok, isso foi muito legal, e criamos este botão.
O que não se quer ter para criar um grupo de propriedades
representando estes botões?
Por exemplo, no Tic Tac Toe tenho 9 botões,
e que seria super, super chato ter que arrastar e soltar 9 vezes
ou se eu tivesse que fazer Tic Tac Toe com 81 em vez de 9
e eu tive que arrastar e soltar 81 vezes, e isso é ridículo.
O que podemos fazer é em vez muito como um HTML
quando tivemos coisas como IDs e nomes e podemos procurar por coisas
por sua identificação, há uma noção similar no iOS chamados de tags.
>> Uma marcação é simplesmente um identificador numérico único para um componente.
Se eu disser que este tem uma marca de 0, por exemplo,
se eu criar um botão e dar-lhe uma marca de 0, e vamos ver como fazer isso em apenas um segundo,
se eu quiser obter esse botão eu posso simplesmente dizer que eu quero chamar
o, viewWithTag método no objeto aqui
o self.view, que representa a tela atual, por exemplo.
Se eu chamar esse método viewWithTag, eu vou puxar o botão com tag 0.
Vamos dar uma olhada neste edifício por Tic Tac Toe.
Em primeiro lugar, este é o meu storyboard.
Eu criei estes 10 botões da interface do usuário.
Observe que eles são todos do mesmo tamanho.
Se eu clicar em um desses e eu volto aqui deste lado direito
você vai ver que eu ajustada a fonte aqui, então eu fiz a fonte um pouco maior,
mas o que eu também fiz foi definir essa tag.
Eu disse que isso tem uma marca de 1, e essa é a parte superior esquerda.
>> Agora, se eu clicar em outro botão, como este segundo aqui,
agora você vai ver que a minha marca é 2.
Cada uma destas teclas só tem uma marca única,
e por isso este é mais tarde como eu vou começar a interagir
com meu aplicativo.
Isso tudo é dentro de um controlador de vista,
mas aqui é o que temos.
Temos três propriedades aqui.
O primeiro e último vão representar o estado do meu conselho.
Basicamente, este primeiro é uma matriz que representa, onde os Xs e Os são.
Este outro aqui diz-nos quem é a vez.
Você vai perceber que eu também tenho essas coisas aqui.
Antes, quando declarou propriedades que lhes deu um nome e um tipo.
Podemos também dar-lhes algumas informações adicionais aqui.
Este primeiro diz não atômica, eo que isso diz
é basicamente a única coisa que nunca vai ser tentando acessar este variável de cada vez.
Você poderia fazer aplicações mais complexas que são multi-threaded,
e assim volta em Scratch tivemos tópicos diferentes,
e sprites diferentes poderia fazer coisas diferentes ao mesmo tempo.
>> Se esse não é o caso, que não é em qualquer coisa que nós vamos estar olhando,
se dizemos que não atômica que realmente vai tornar as coisas um pouco mais rápido.
Nós também temos essa coisa chamada assign, forte ou fraco.
Esta atribuir apenas diz que este é um tipo de padrão.
Este não é um objeto ou um ponteiro porque este é apenas um bool,
para bool é construído em Objective-C.
Este diz que não tentar fazer algo extravagante com ponteiros aqui.
É um scaler idade regular.
Fortes e fracos, este fraco diz que, na verdade,
Eu quero que isso seja apontando para algo no controlador de vista.
Eu não estou indo para realmente alocar ou init isso mesmo.
O construtor de interface, quando eu executar o aplicativo, vai lidar com toda a inicialização isso.
Se eu digo fraco, que diz que alguém vai estar criando isso.
Se eu disser forte, este diz que eu vou ser o único
que está criando esse objeto bordo,
e por isso aqui eu tenho métodos mais alguns aqui,
por exemplo, uma acção para que o botão é pressionado novo jogo,
uma ação para quando qualquer um dos outros botões são pressionados,
e et cetera.
>> Nós não vamos entrar muito da lógica de Tic Tac Toe,
embora seja muito emocionante, mas vamos dar uma olhada
algumas das coisas que podemos fazer dentro do iOS.
Este método novo jogo vai ser demitido
sempre que eu pressione o botão novo jogo.
Para conectar-se de que eu simplesmente vir ao meu storyboard.
Eu cliquei no novo jogo.
Se eu vir aqui para a direita eu posso ver que
Toque Up Inside é ligado ao método NewGame.
É por isso que este vai ser demitido.
O método NewGame vai fazer alguma configuração.
Vai dizer que eu quero que você limpar o estado da placa.
Este é um método agradável em mutáveis ​​matrizes.
Isso vai dizer que é agora a vez de X,
e agora eu vou aproveitar essa coisa viewWithTag.
>> Eu sei que os meus botões têm as marcas 1-9,
e isso é algo que eu arbitrariamente escolhido.
Se eu quiser definir o texto de cada botão para estar vazio
porque eu comecei um novo jogo e eu não quero nenhum
Xs ou Os para sobrar eu posso fazer isso.
Eu posso dizer que eu quero a vista com a tag, 1, 2, 3, 4 et cetera.
Isso vai puxar um botão diferente a cada vez.
Aqui eu vou lançá-lo aos UIButton.
Assim como nós poderíamos lançar ints para carros alegóricos e vice-versa
este diz que eu quero lançar a um UIButton.
Isso significa que o tipo de esta será a * UIButton
porque de ponteiros, mas não se preocupe, eles não são assustadores mais.
>> Uma vez que eu tenho esse botão que eu vou chamar um método nele.
Este método é chamado setTitle forState, e por isso este diz
Eu quero definir o texto do botão para ser a cadeia vazia,
e eu quero que seja a cadeia vazia quando não está pressionado.
Se eu estou usando esse método, eu posso mudar o texto do botão
assim que alguém chega, mas queremos dizer quando o botão é apenas sentado ali
Eu quero que o texto em branco.
Finalmente, vamos inicializar o meu conselho,
e vou dizer que tudo é atualmente a 0,
de modo que este membros do conselho imutável é uma matriz mutável,
o que significa que eu posso chamar o método addObject e apenas dentro de um 0 dele.
Isso é o que acontece quando eu criar um novo jogo.
>> Vamos dar uma olhada em outro.
Este método aqui é o IBAction que vai ser pressionado
cada vez que um dos quadrados é pressionado.
Agora temos uma lógica Tic Tac Toe aqui.
Nós descobrir quem é a vez,
e com base em que seja definido um X ou um O,
mas percebemos que estamos reutilizar este mesmo manipulador de eventos
para cada um desses botões.
Isso significa que eu não tenho um método para o botão superior esquerdo,
um método diferente para o botão inferior direito, apesar de que eu poderia ter feito isso.
Isso não seria realmente um bom design.
O que eu estou fazendo aqui é que eu estou indo realmente para determinar
o que a etiqueta do botão que foi pressionado é.
Você percebe que este método de reprodução tem um argumento.
É chamado de remetente, eo que é remetente é remetente vai
representam exatamente o que foi tomado medidas em cima.
Se eu apertar um botão, este remetente vai ser que UIButton
I, na verdade, que pressionado, o que significa que esta UIButton
tem uma marca porque eu criei uma tag.
>> Se eu quiser chegar à marca que eu posso simplesmente dizer
Eu quero a tag do remetente,
e de novo, eu só fundido a um UIButton.
Acontece que eu sei que o remetente será um UIButton.
Nem sempre tem que ser um UIButton.
Eu poderia, por exemplo, registrar o mesmo manipulador de eventos
para um para um botão, uma por uma barra.
Neste caso, eu sei que eles estão todos os botões, então eu vou dizer
Eu quero que este seja um botão, e então eu posso obter a marca,
e da marca agora eu sei onde eu estou dentro do conselho.
Então eu posso simplesmente definir X ou o O, pode virar o turno,
verificar quem ganhou, et cetera.
>> Qualquer dúvida sobre isso até agora?
Ok, todo o código que postou online-não quero entrar muito
da lógica de Tic Tac Toe, mas agora você pode ver que realmente
tudo o que estamos fazendo é que estamos looping sobre essa matriz,
por isso temos um par de loops aqui, e nós estamos apenas comparando para ver
temos um jogo em todas as linhas, um jogo em uma coluna ou qualquer coisa assim.
Para realmente executar este aplicativo, se eu tocar em um dos botões
que o método de jogo foi demitido, o que significa que apenas definir
o botão para ser um X, então agora este botão será um O, e assim por diante,
e é assim que estamos começando a interagir com este aplicativo única página.
>> Vamos postar o código, então sinta-se livre para examinar que,
mas vamos agora falar sobre alguns aplicativos que são mais do que apenas uma página.
Tão emocionante como Tic Tac Toe foi, um monte de aplicativos dentro do iOS
são estes tipo de detalhamento coisas com múltiplas telas.
O primeiro conceito que vamos precisar de falar são protocolos,
e um protocolo é simplesmente um conjunto de métodos
que você pode prometer para definir.
Se eu criar este novo protocolo com dois métodos, este primeiro,
se o tipo de retorno é void, eu o chamei foo.
Ele não tem argumentos. Eu tenho um outro método.
Ele retorna um int. Chamei-bar, e ele tem um argumento.
Todos protocolo isto é que se chama SomeProtocol-se aqui,
este é um conjunto de coisas que alguém pode implementar.
Eu não dentro deste protocolo, disse que foo faz.
Em vez disso, eu só estou dizendo que você poderia definir foo se você quiser.
Se eu estou criando um controlador de vista ou a criação de uma classe
Eu posso dentro dessa promessa classe para implementar
alguns desses métodos, assim, por exemplo, se dizer
isso agora diz que eu estou fazendo uma promessa a você que dentro
desta classe controlador de vista eu vou ter definições para ambos foo e bar.
>> Por que isso é útil?
Um monte de componentes dentro do iOS aproveitar essa
padrão de projeto chamado de delegação, e que diz delegação
é que, por exemplo, se eu tenho uma caixa de texto
e existem alguns eventos que poderiam ser registrados dentro da minha caixa de texto,
em vez de criar eventos separados que eu posso fazer é o que posso dizer
o delegado da caixa de texto será algum objeto.
Quando eu digo que este é um delegado agora que significa que
sempre que algum evento teria sido demitido na caixa de texto
ao invés de ter que registrá-lo ou algo assim
ele só vai chamar um método no delegado.
Por exemplo, dentro da minha caixa de texto Eu tenho um método para quando eu pressione
que fez botão no canto inferior direito,
e assim, em vez de registrar manipulador de eventos o que eu posso dizer é
caixa de texto, aqui é um objeto que eu quero que você chamar um método em
cada vez que alguém pressiona o botão Done,
e isso significa que esse objeto tem que implementar algum protocolo
que diz que eu prometo para definir que ação do botão feito,
porque se ele não define esse método e que prima Concluir
em seguida, ele vai ser confuso.
>> Vamos dar uma olhada em um exemplo.
Aqui eu simplesmente tem uma caixa de texto,
e uma das propriedades desta caixa de texto por aqui deste lado direito é o delegado.
Esta é uma propriedade da classe.
O que eu fiz aqui é que eu controlar clicado, e eu arrastei a partir deste ponto aqui
ao controlador do ponto de vista, e que agora diz o delegado da caixa de texto
vai ser o controlador de vista.
Isso significa que, quando algumas acções acontecer, em vez de registar
manipuladores de eventos separados que eu quero que você envie para o delegado.
Agora vamos dar uma olhada no meu controlador de vista.
Dentro do arquivo h. Fiz uma promessa.
Eu prometi para implementar alguns métodos dentro deste protocolo
chamado UITextFieldDelegate, e novamente,
esta é apenas uma lista de algumas coisas que eu posso escolher para implementar.
>> Se eu vir aqui no meu arquivo. M, eu implementei um tal método.
Eu chamei ele textFieldShouldReturn
porque é isso que ele foi chamado dentro do protocolo.
E agora sempre que eu pressione o botão feito dentro do campo de texto
isso é o que vai pagar, então eu não registrar um manipulador de evento.
Liguei o delegado e sempre que esse evento é disparado
este é o método que será chamado, então se eu vir aqui ao meu storyboard e execute-o-
enquanto que a está carregando podemos ver que isso faz.
Na minha tela eu tenho 2 coisas.
Eu tenho esse campo de texto, e eu tenho este rótulo.
Estou simplesmente dizendo que deseja que o texto deste rótulo
ser igual a qualquer que seja o utilizador digitado no interior do campo de texto.
Essa linha aqui é simplesmente um método que eu estou chamando
no campo de texto que diz que eu quero que você esconder o teclado.
Este é apenas o método arbitrário que a Apple escolheu.
>> Mais uma vez, antes de eu fazer qualquer coisa que eu tinha que ligar tudo, então eu cheguei aqui.
Do controlador de vista eu arrastar até a caixa de texto.
Eu deixar de ir, e eu posso ver aqui que eu posso fazer isso a propriedade de campo de texto
desde aqui no controlador de vista eu defini uma propriedade
que é um IBOutlet de um campo de texto.
Este diz que eu posso ligar esta propriedade se
a um campo de texto no meu UI.
Agora, quando eu clico isso eu posso começar a digitar.
Agora, se eu clicar no botão feito isso vai disparar
um evento que agora posso responder.
Não manipuladores de eventos.
É assim que eu só respondeu a esse botão feito.
Faz sentido?
>> Este não é um padrão de design que-você não pode nunca encontrar-se
criar o seu próprio protocolo, mas só sei que alguns
diferentes componentes iOS registrar eventos de diferentes maneiras.
Botões, por exemplo, usar essas IBActions.
Campos de texto, por outro lado, vão usar delegados.
Podemos ver e você pode olhar tudo isso dentro se da documentação.
A propósito, há realmente uma tonelada de coisas UI construído no iOS para você,
assim, por exemplo, a maneira que eu fiz que dizem feito na parte inferior direita
é Selecionei este campo de texto.
Eu vim para cá.
Eu rolada para baixo um pouco para retornar chave,
e eu posso realmente fazer isso um monte de coisas, como se eu quero que dizer
chamada de emergência vez eu posso fazer isso, que é totalmente aleatória,
e eu não sei por que não há um built-in botão de chamada de emergência,
mas lá, ele diz que chamada de emergência em letras muito pequenas.
Lá você vai.
>> Definitivamente explorar todos esses diferentes opções no iOS.
Qualquer dúvida sobre os delegados?
Mais uma vez, apenas um padrão de design interessante que você deve estar ciente.
Ok, vamos dar uma olhada junto com a vista da tabela.
A vista de tabela é basicamente que a lista de itens que está em todo o lugar no iOS.
Quando você está folheando todos os seus contatos, você está olhando
a página de configuração, e esse tipo de lista de coisas é chamado de exibição de tabela.
Implementação de uma exibição de tabela no iOS é bem simples.
Em vez de fazer uma classe que desce do que UIViewController
como já fizemos antes, nós simplesmente precisamos dizer, em vez de
tudo o que um UIViewController não quero fazer,
Eu digo tudo o que um UITableViewController não quero fazer,
de modo que simplesmente adiciona algumas coisas adicionais que são totalmente feito por nós.
Precisamos fazer muito pouco para, basicamente, preencher os espaços em branco dentro da tabela.
>> A fim de apresentar uma tabela que eu preciso responder algumas perguntas.
A primeira pergunta que eu preciso responder é quantos pontos estão em cima da mesa?
Quando você está folheando o seu aplicativo de contatos você vai perceber que é uma espécie de
organizado pelo Como, então você tem o Bs, e você tem que cabeçalho pouco sub.
Cada um destes é chamado de uma secção.
Você pode ou não necessitar destes.
A primeira coisa que você precisa fazer é implementar um método
chamado tableView: numberOfSectionsInTableView.
Que simplesmente retorna quantas seções que você tem,
de modo que este pudesse dizer retornar um, se você tem uma vista de tabela grande.
A próxima pergunta que o iOS precisa saber é quantas linhas você tem?
Por exemplo, você está folheando uma exibição de tabela.
Você tem um número fixo de músicas que você está olhando ou um número fixo de contatos.
Se você é eu, é claro, não é muito,
e é assim que o iOS sabe quantas células para exibir.
>> Mais uma vez, isso poderia dizer algo como retorno 3.
Minha visão tabela tem três linhas.
Finalmente, o iOS precisa saber o que cada célula parece,
Então, o que ele realmente vai fazer é chamar esse método aqui,
este tableView: cellForRowAtIndexPath.
Vai chamar esse método em cada célula dentro de sua tabela.
Como ele sabe quantas vezes a chamá-lo?
Bem, você disse que dentro do número de linhas em seção.
Vamos chamar isso em cada uma de nossas células,
e dentro deste é onde você pode realmente fazer coisas como
definir o texto ou dizer-lhe o que isso pequeno botão azul no lado direito faz.
O padrão para a obtenção dessas células, vamos usar este método
chamado dequeueReusableCellWithIdentifier.
>> Objective-C é realmente muito conhecido para a duração ridícula de seus nomes de método,
e este é realmente um caso agradável no exemplo ponto.
O que este método faz é este apenas diz que eu quero que você me dê uma célula.
Apenas uma coisa iOS.
Se você tem algo como 100 mil músicas em seu iPod
o iOS não quer fazer é alocar 100.000 células,
porque se você está no topo da sua lista, você realmente precisa para alocar memória
para a célula que é 99.000 linhas para baixo?
Não, porque como você está rolando você pode tipo de alocar como você vá junto.
Isto é feito para você.
Você não tem que se preocupar com todo o material de desempenho que estúpido.
Tudo o que você diz é você chamar este método dequeueReusableCellWithIdentifier,
e este diz, tudo bem, se você precisar eu vou criar uma nova célula para você.
>> Mas se você está no fundo da tabela e você já alocados algumas células
no topo da tabela que você realmente não vai precisar tão cedo
Eu vou dar-lhe um daqueles de volta em vez de alocar um novo,
e por isso esta é uma preocupação desempenho agradável.
Você não tem que alocar as células-se.
Isso vai lhe dar de volta uma célula.
Ele vai voltar para você um objeto de célula.
Depois de ter o objeto de célula que você pode fazer coisas para ele.
Você pode definir o texto da célula com essa propriedade chamada rótulo de texto.
Você pode adicionar a seta à direita ou algumas outras coisas aleatórias
com esta outra propriedade chamada accessoryType, e assim por diante e assim por diante.
>> Vamos dar uma olhada em realmente implementar uma exibição de tabela agora.
Quando eu criei este projeto
ao invés de dizer aplicação única visão que eu realmente vim aqui
a mestre-detalhe de aplicação, e por isso, basicamente o que corresponde ao aplicativo de email
no iPad com a exibição de tabela à esquerda e, em seguida, o conteúdo à direita.
No iPod ou iPhone isso vai corresponder a uma visão única tabela.
É onde eu tenho o meu código inicial.
>> Vamos primeiro dar uma olhada no storyboard.
Tudo isso foi feito por mim, basicamente criado.
Esta barra de navegação me mostrou o que uma célula exemplo pode parecer,
e eu pode clicar duas vezes isso, alterar o título.
Quaisquer preocupações UI outros eu posso lidar lá.
O arquivo de cabeçalho parece muito simples.
Ao invés de dizer isso é UIViewController agora estamos dizendo que este é um
TableViewController, por isso sabemos que queremos chamar todos os métodos da tabela.
Próxima Eu quero criar uma propriedade que vai representar
as coisas dentro da minha mesa.
Esta tabela vai exibir arbitrariamente
uma lista de frutas, e então eu preciso criar alguma matriz
em que eu possa inserir frutas.
Dentro do meu arquivo de implementação, a primeira coisa que eu quero fazer
é que eu quero ter certeza que eu inicializar esta matriz.
>> Eu disse alloc init, criei a minha matriz de frutas,
e eu estou adicionando 4 coisas para ele, um dos quais é muito mais controverso do que os outros 3.
E agora eu tenho uma matriz de tamanho 4.
Estamos agitando-se no CS50.
Agora tenho uma matriz de tamanho 4.
Agora eu vou começar a responder a estas questões, e na verdade,
quando eu criei este aplicativo tudo isso já foi feito por mim.
Eu não tenho que digitar o número de seções em vista de tabela.
Ele já estava lá, e eu estou preenchendo os espaços em branco.
Quantas seções que eu tenho?
Um. Tudo feito.
Quantas linhas que eu tenho?
Bem, eu tenho uma linha para cada fruta, para esta contagem
é uma propriedade de qualquer matriz que diz o quão grande é isso?
Esse é o número de linhas que eu tenho.
Finalmente, eu preciso dizer o que é que cada célula se parece?
Eu vou dizer dequeueReusableCellWithIdentifier.
>> Novamente, isso já estava escrito para mim.
Eu não tenho que fazer isso mesmo, e eu quero voltar
esta célula neste local.
Lembre-se que estamos chamando este mesmo método em todas as células,
e este argumento aqui, esse argumento indexPath,
diz o que eu estou dentro da linha
Se eu disser indexPath.row aqui
isto irá ser 0, então ele irá ser 1, então ele irá ser 2, e este é então sei
o que eu estou célula que está exibindo.
Eu quero definir o texto da célula usando esta propriedade TextLabel
para ir dentro da minha matriz frutas e obter
o objeto correspondente a cada linha.
Se esta é uma seqüência, agora estou definindo
a propriedade de texto para uma string.
Eu posso fazer outra coisa.
I também pode registar-se um processador de eventos em cada uma das células,
então quando eu tocar cada uma dessas células
este didSelectRowAtIndexPath, isso vai ser chamado para mim,
tão simplesmente definindo isso eu agora pode lidar com o que acontece
quando você toca em uma célula, e, novamente, estamos passando em qual célula foi aproveitado
para que possamos reutilizar esse mesmo manipulador de eventos para todas as nossas células.
>> Mais uma vez, isso é algo que o iOS está fazendo por mim.
Vamos mostrar um outro pop-up irritantes
que simplesmente diz que você pegou algo em algo que
vai ser o objeto de linha.
Quando eu executo isso, eu vou ter essa visão boa mesa
com uma linha para cada um desses frutos, e se eu tocar um
diz-me o que aconteceu.
Faz sentido?
Vamos construir um pouco mais complexa de um aplicativo,
tanto quanto você escolheu clicando tomate é.
A parte agradável sobre o storyboard
é que não só vai ajudar-nos a projetar telas individualmente,
também vai nos ajudar a unir a nossa aplicação inteira
de modo que o aplicativo final que vai ser este edifício é agradável esportes leitor de notícias,
e assim vai ter várias telas, e para que eu possa realmente representar
cada uma dessas telas múltiplas no storyboard,
e eu posso diminuir o zoom e ver meu aplicativo a partir de um nível elevado.
>> A fim de criar um novo elemento dentro do meu storyboard
é realmente simples dentro de Interface Builder.
Se eu quiser adicionar outra tela para isso, por exemplo,
Eu posso primeiro zoom com o zoom pitada de que a Apple tanto ama,
e aqui antes de eu procurar por um botão
e eu arrastar e soltar um botão
se eu quiser criar uma nova tela que eu possa realmente basta arrastar e soltar
um controlador de vista inteira, então se eu pegar isso, puxe-aqui,
hey, há uma outra tela, e agora usando esse arquivo storyboard mesmo
Eu posso ter todas as telas dentro do meu aplicativo, e eu posso diminuir o zoom
e ver como eles interagem.
Estes não vão interagir ainda.
A maneira em que estas duas telas interagem é definir relacionamentos.
Basicamente você pode dizer que esta tela, ao pressionar este botão,
Eu quero que você deslize para esta nova tela.
Isso significa que não há este tipo de relação entre
a primeira tela e na segunda tela.
Você tem basicamente uma flecha que o botão para a segunda tela
dizendo que quando você pressionar este botão que é onde eu quero ir.
Assim como nós controlamos clicado e arrastado para definir esses estabelecimentos
vamos fazer a mesma coisa para definir esses segues.
>> Vamos ver um exemplo para que, e antes que a transição de fato
a partir de uma tela para outra iOS é bom o suficiente para chamar esse método
prepareForSegue chamado, e é aí que podemos começar
o envio de dados a partir de um aplicativo para outro.
No exemplo que estamos prestes a olhar para ele, basicamente, permitir-nos-
para filtrar times de beisebol pelas ligas e divisões.
Quando eu selecionar uma liga, por exemplo, eu quero fazer a transição
a minha próxima tela onde eu possa mostrar todas as divisões
nessa liga ou todas as equipes diferentes.
Eu preciso enviar para a tela o que as equipes que você deve exibir.
Para fazer isso eu vou aproveitar este método aqui.
>> Por fim, apenas um ponto aleatório no iOS.
Se você deseja armazenar dados há essa coisa chamada de dados básicos,
que na verdade é meio complicado de se trabalhar.
Você também pode usar SQL para armazenar dados,
que, novamente, é bom, mas o tipo de no lado mais complicado de se trabalhar,
mas iOS também suporta essas coisas muito legal chamado listas de propriedades,
e uma lista de propriedades é apenas um arquivo que representa pares de valores-chave.
Você define uma lista de chaves, e você diz esta chave vai ser um array.
Esta chave vai ser uma string, e basicamente qualquer coisa que você pode fazer
em JSON que você pode fazer dentro de uma lista de propriedades,
e por isso esta realmente muito bem nos permite trabalhar com alguns dados.
Por exemplo, eu tenho essa Teams.plist que eu criei.
Eu criei um arquivo plist novo, e eu posso detalhar.
Trata-se de um dicionário, este é um dicionário, são cadeias de caracteres,
e por isso esta é uma boa representação gráfica de um documento JSON
ou apenas um conjunto de pares de valores-chave,
e por isso este é o dado que eu vou estar trabalhando com o interior do meu aplicativo.
>> Vamos primeiro a chegar aqui. Temos arquivos muito mais agora.
Mas primeiro vamos vir aqui para o storyboard.
O storyboard aqui, se eu posso afastar-
agora podemos ver que este é o fluxo do meu aplicativo.
Estou indo primeiro para começar nesta tela.
Vou detalhar a este ecrã,
e eu estou indo para detalhar a esta tela, e podemos ver aqui que se eu tipo de
mover um deles em torno de nós essas setas vai daqui até aqui,
e do jeito que eu definir a seta era se eu ampliar um pouco,
e se eu vir para este controlador de vista,
e aqui está uma célula, e eu quero dizer que quando você toque em uma célula
Eu quero que você deslizar sobre a outra tela.
Eu posso simplesmente segure o controle,
rolar mais um pouco, mantenha o controle, arrastar esta célula mais e deixar ir.
>> E aqui podemos dizer que é a transição que você quer usar?
Você quer usar essa coisa slide que é chamado de impulso?
Você quer deslizar para cima a partir do fundo?
Isso é chamado de modal.
E uma vez que eu clicar em um deles, ele vai tirar essa flecha para mim,
e isso significa que eu realmente tratado o que acontece quando eu pressionar este botão graficamente.
Eu não escrever qualquer código para realmente deslizar de uma tela para a próxima.
Eu defini isso visualmente dentro de Interface Builder.
Se eu clicar nesta seta, podemos ver que eu dei essa coisa de um nome.
Chamei-showDivisions, e isso é para que eu possa saber
que a transição está prestes a ocorrer, e vamos ver por que, em apenas um segundo.
É assim que eu tenho com fio até as diferentes telas em meu aplicativo.
Se este fosse um botão, por exemplo, em vez de uma vista de tabela,
Eu poderia controlar clique no botão, arraste até a próxima tela,
e é assim que eu possa fazer caminho de navegação que.
>> Muito rapidamente, se nós entrarmos na MasterViewController,
novamente, nós estamos indo simplesmente para definir uma lista de coisas
que será exibido na exibição de tabela.
Aqui eu estou dizendo que eu quero que você pegue esse arquivo plist,
e eu quero que você coloque-o em um dicionário,
e uma vez que você tem que dicionário, eu vou responder a essas mesmas perguntas novamente.
Aqui é o número de seções.
Um, há uma linha para cada liga, eo texto de cada célula
ou deveria ser a primeira, a primeira liga, a segunda liga, e assim por diante.
Finalmente, eu vou usar este método que acabamos de ver chamado prepareForSegue,
e este é o método que vai ser acionado quando eu clico
em uma dessas linhas e, portanto, ativando essa transição
que eu criar com as setas.
Isto está dizendo que eu posso ter vários
relações de uma tela para outra.
Se eu tiver dois botões e cada botão leva você para uma tela diferente
Eu vou ter dois segues, um para cada botão.
Mas esta prepareForSegue é, de novo, vai ser reutilizada
para cada uma das diferentes relações, o que significa que precisam de uma maneira
de identificar se você pressionar o botão primeiro ou você pressionar o segundo botão.
>> Lembre-se de que quando eu dei Segue um nome, este showDivisions,
é assim que eu agora sei que este é o Segue que foi ativado.
Tudo o que eu quero fazer é que eu quero dizer
Eu quero descobrir o que eu bater,
e assim conseguir isso, eu posso dizer que eu quero o indexPath para a linha selecionada,
lembrar o indexPath apenas diz onde eu cliquei,
e então eu quero dizer que eu quero descobrir para onde estou indo.
Este destinationViewController, que é uma propriedade do Segue.
Essa é a tela que eu vou,
então eu sei que a tela eu vou é chamado DivisionsViewController
porque eu criei essa classe,
e agora se eu disser d.divisions
Estou agora a definição de uma propriedade do controlador de vista que estou prestes a ir.
Isto é como eu estou enviando dados de uma tela para outra tela.
>> Basta olhar para esta DivisionsViewController
você pode ver aqui que no arquivo h.
há que as divisões de propriedade, e é isso que eu estou basicamente preencher,
então é assim que eu sei que eu estou mostrando as divisões que correspondem a
a liga que eu cliquei, e novamente,
o ponto de vista da tabela atual parece praticamente o mesmo, apenas respondendo aos
3 perguntas simples, bem como a identificação
o que acontece quando você se mover para a próxima tela.
Apenas um par de outras coisas aqui.
Você percebe no topo aqui que em vez de dizer # include
Estou dizendo agora # importar.
Esta é apenas uma coisa Objective-C.
A importação é basicamente uma versão mais agradável de inclusão,
e, por exemplo, precisamos saber o que esta classe é,
por isso não posso apenas dizer DivisionsViewController.
Se não hashtag dentro standardio.c do nosso arquivo c.
o compilador não tinha idéia do que era printf.
Da mesma forma, se eu não me importar o DivisionsViewController
o compilador realmente não tem idéia do que é um DivisionsViewController.
Apenas certifique-se que dentro de seus arquivos diferentes. M que garantir a importação
os arquivos correspondentes. h para que o compilador sabe o que está acontecendo.
>> Finalmente, o que a Apple finalmente faz é apresentar alguns dados usando uma visão web,
e assim uma visão da Web é um objeto no qual você pode inserir
um navegador pouco dentro de sua aplicação.
Tudo que você precisa fazer é fornecer uma URL para seu navegador,
então eu quero ir para a mlb.mlb.com,
e é assim que eu posso acessar a página inicial de cada equipe,
e então pela passagem neste URL
a exibição da web pode exibir isso para mim, e eu posso navegar ao redor,
e simulador está em uso por aquele.
Agora, isso veio da minha plist.
Se eu clicar nesse presente também veio do meu plist, e este deslizamento foi tratado
definindo os segues.
Clico isso e mais um,
e agora aqui está a minha UIWebView, assim como que
aqui está o site para a URL que eu apenas incorporado,
e eu não ter de lidar com qualquer coisa louca.
Esta é a forma de mostrar uma página web.
Coisas como este botão volta aqui também são dadas para mim
totalmente de graça, porque eu já definiu essas relações usando segues.
>> Alguma pergunta? Sim.
[Estudante] Então, quando você usar alloc, você nunca tem a nada livre?
Exatamente, quando você chamar alloc e init você não tem para libertá-la.
IOS vai lidar com tudo isso para você.
É maravilhoso, e você não está quebrando nenhuma regra. Sim.
[Estudante] Se você fosse para incluir mais times que poderiam caber na tela,
seria automaticamente tem uma opção de deslocamento, ou é algo que você precisa adicionar?
Exatamente, se eu tivesse mais equipes, por exemplo, seria tratar automaticamente
a rolagem para mim, e todos os problemas de desempenho
com a enorme mesa também são feitos totalmente por mim.
>> Outras perguntas?
Todo esse código vai ser postado.
Nós meio que encoberto um pouco dos detalhes mais pequenos,
mas coisas como definir algumas propriedades para a exibição da web
são apenas coisas que você pode obter através de seu navegador de documentação da Apple,
o que é realmente, realmente muito bem definidos.
Eles têm um monte de aplicativos de amostra e exemplo usos
de APIs diferente, então definitivamente ler os se puder.
Apenas alguns links úteis que você pode querer dar uma olhada.
Estas são algumas guias de documentação à mão.
As URLs são enormes, por isso eles são encurtados.
Este primeiro é toda a biblioteca de documentação.
Há barras de pesquisa pequenos, então se você começar a digitar o botão
ele vai começar a dar-lhe todas as informações sobre todas as coisas que você pode fazer com um botão.
Eu também incluiu a Tabela de guia de programação View.
Ele lida com vistas de tabela em muito mais detalhe,
como fazer as coisas como adicionar dinamicamente ou células editar ou remover.
>> Há muitos aplicativos de amostra da Apple que vai mostrar como fazer isso,
e, finalmente, este último é o Human Interface Guidelines,
e isso é basicamente uma discussão de componentes de interface do usuário,
coisas como não fazer um botão que é 4 pixels por 4 pixels.
Isso é uma má idéia, e outras coisas que a Apple quer que você faça
encorajar a boa concepção.
>> Qualquer dúvida últimas antes de terminar?
Tudo bem, sinta-se livre definitivamente para-nós estamos indo ter rótulos especiais para discutir.
Nós vamos ter um iOS um, para definitivamente se sentir livre para utilizar isso.
Se você quiser trabalhar com seus colegas de classe em projetos
ou ajudar a descobrir algumas coisas iOS aleatória
sinta-se livre para me e-mail, e, definitivamente, ler tudo online o código porque
apenas no interesse de tempo que tipo de encoberto a mais
detalhes mais finos grãos de coisas.
Mas se não, então boa sorte em seus projetos de iOS, e espero que tenhamos
um grande fluxo de aplicativos na App Store.
[CS50.TV]