Portuguese Subtitles for Stanford University Developing iOS 7 Apps: Lecture 2 - Xcode 5



Subtitles / Closed Captions - Portuguese

>> Universidade de Stanford.

>> Paul Hegarty: Okay. Bem, bem-vindo a palestra número dois da CS 193P para a queda de 2013/2014 ano lectivo. E hoje nós vamos ter alguns slides no início, pouco mais de falar, e então eu vou ter bastante um grande demonstração que vai tentar

e espero sintetizar todas as coisas que eu tenho falado sobre as lâminas para as duas primeiras palestras, o que é que vamos começar a construir o nosso jogo de cartas. OK. Este jogo de correspondência cartão vai ser o nosso substrato para as duas primeiras semanas de aprender um pouco de Objective-C, aprendendo sobre Xcode, aprendendo sobre como iOS ganchos

o controlador, e a vista, e o modelo para fazer uma UI. Então, se você se lembra da última vez, fizemos essa coisa cartão que - fizemos o cartão inteiro. Era uma classe muito simples. Tem um par de propriedades - três propriedades lá - e um método.

E isso é muito bonito isso. E por isso hoje nós estamos indo para ir em frente e fazer uma outra classe, que é uma plataforma, está bem? O baralho de cartas. E lembre-se, esse cartão e deck são genéricos; eles não são específicos para cartas de jogar, certo?

Um cartão de jogo, como o ás de paus ou o rei dos corações - algo que tem tudo o que nele - isso é uma coisa do cartão de jogo. Estes são os cartões gerais e decks. Portanto, esta poderia ser uma plataforma de cartões de memória flash, um baralho de palavras em língua estrangeira que você está tentando

para aprender ou o que quer. Então, estamos tentando manter estes baralho e as classes de cartão de pouco genérico. Então aqui está o deck. Ele deve parecer familiar em termos de sua estrutura básica, certo? Estamos importando nossa estrutura superclasses lá,

e então, obviamente, a importação de nosso próprio arquivo de cabeçalho em nossa aplicação. E a interface para plataforma vai ter esses dois tipos de métodos fundamentais: Um acrescenta um cartão para o convés e uma tira uma carta aleatória fora do baralho. OK? E a adicionar um cartão para o convés é um pouco novo para você

porque você pode ver que tem dois argumentos. OK? Este é o primeiro método que você já viu que tem dois argumentos. Até agora só vi métodos sem argumentos ou um método com um argumento como esse - jogo - partida teve um argumento ou os setters,

eles também têm um argumento. Então, observe que quando você tem vários argumentos e objetivos, ver que eles estão tipo de intercaladas com os nomes dos métodos. OK? Assim, o nome do presente método, este método longa é adicionar cólon cartão no cólon superior.

Esse é o nome do método. OK? Assim, a parte de cima de é realmente parte do nome deste método. E os argumentos, como o cartão que você está indo para adicionar e na parte superior - que é um booleano se adicioná-lo no topo do convés ou na parte inferior do convés -

ok, esses argumentos são intercaladas. E vamos ver como você chamar esse método em um momento aqui. E depois tirar uma carta aleatória é como um, você sabe, semelhante a um getter em que ele retorna um valor e não tem argumentos. Mas este não é um getter porque não fazer deste um imóvel.

E é tipo de importante para entender que você poderia ter feito isso uma propriedade como uma propriedade só de leitura ou algo que lê-lo, mas desde que compre um card aleatório espécie de faz algo, ele tem tipo de um algoritmo para isso - um mecanismo - você normalmente não seria que uma propriedade fazer.

É uma espécie de um abuso de getter para fazer isso. Um getter é realmente apenas configurar e obter um valor. Ele pode ter efeitos secundários, como o ajuste pode atualizar a interface do usuário ou se pode ter certeza que é inicializado pela primeira vez - esse tipo de coisa. Você não vai - algo que faz algo

como desenhar um cartão não vai ser uma propriedade. Agora, se você quer ter, como, que pelo argumento de topo ser opcional, está bem, a única maneira fazer isso em Objective-C - obviamente, precisamos que o nosso arquivo de cabeçalho lá - a única maneira de fazer isso em Objective-C é

para declarar um novo método, adicione cólon cartão com nenhuma na parte superior do mesmo. Portanto, este é um método totalmente diferente, totalmente alheios para o outro método excepto que, na sua implementação deste outro método nós apenas estamos indo para chamar o outro, ok? Assim, em cartão add vamos dizer auto adicionar cartão no cólon superior,

o que quisermos o padrão a ser, que eu vou dizer é não. OK? Então, basta entender que, você sabe, em algumas línguas, como, alguns argumentos podem ser opcionais ou você pode tipo da sobrecarga de coisas para ter o mesmo nome do método tem argumentos diferentes.

Não. Em Objective-C cada método é completamente distinta e tem um nome distinto. E argumentos extras são intercaladas assim. OK? Assim, estes seriam dois métodos diferentes. Isso faz sentido? Tudo certo.

Então vamos falar sobre a nossa implementação do nosso deck. Portanto, a nossa plataforma está indo só para conter um monte de cartões. Nós precisamos de algum tipo de estrutura de dados interna para armazenar todas as nossas cartas na. E o que vamos fazer é que estamos indo para obter uma matriz mutável. Então, você já viu a matriz NS classe,

que é a matriz de classe fundação, que é uma matriz de objetos. Esses objetos, por sinal, na matriz pode ser de qualquer classe. Não há realmente nenhuma maneira de especificar que tipo de classe de objeto está em uma matriz. Algumas linguagens permitem que você faça isso.

Você pode especificar "Este é um array de strings ", e ele sabe disso. Mas, em Objective-C você não pode fazer isso. E vamos falar sobre como vamos lidar com isso. Isso é um pouco do oeste selvagem de Objective-C, mas existem maneiras de tipo de verificação

e ver o que os objetos estão se você quiser para ser realmente seguro sobre isso. Mas, neste caso, só temos essa matriz mutável. E meios mutáveis ​​que pode adicionar objetos à matriz. Normalmente uma série NS é imutável. OK? Uma vez que é criado, qualquer que seja objetos entrar,

que é os objetos que estão nela para sempre - você não pode tomar qualquer fora e você não pode colocar qualquer em. Portanto, se queremos matriz onde podemos adicionar coisas, temos que usar esta subclasse de NS matriz chamada matriz mutável NS. OK? Você pode ver que é uma propriedade.

Ele é forte, porque queremos que essa matriz para ficar na pilha enquanto nós estamos apontando para ele. E, claro, nós sempre colocar nonatomic lá. OK? Portanto, esta vai ser uma série de cartões. Agora que temos isso, poderíamos facilmente implementar adicionar cartão, por exemplo, apenas dizendo, "Se no topo, em seguida, inserir objeto"

o cartão, que é o argumento para este método - primeiro argumento - "adicionar índice zero." Então inserir objecto adicionar índice é um método em matriz mutável NS, não em matriz NS - apenas na matriz mutável NS porque isso seria mutação-lo - que insere o objeto no índice na matriz

e índice de zero, vai ser o topo que vamos definir. E, em seguida, caso contrário, se nós não estamos indo para colocá-lo no topo, nós estamos indo para colocá-lo na parte inferior, vamos usar um método de matriz mutável diferentes NS chamada adicionar objeto.

E isso só acrescenta algo no final da matriz. Por isso, todos bem com isso? Então eu na maior parte apenas colocar este método em aqui apenas para mostrar-lhe que há um par de métodos diferentes na matriz mutável e, você sabe, como podemos usar os argumentos. Não é grande coisa aqui; é apenas uma espécie de obter mais usado

para o que está acontecendo aqui. Tudo certo. Então, isso é adicionar cartão. Muito, muito simples. E há um problema, porém. Neste adicionar cartões, se acabamos de criar uma plataforma

e então chamou placa adicional, que não iria funcionar. OK? Ele não faria nada. Por que ele não fazer nada? Porque os cartões de propriedade, tudo bem - self.cards é como estamos acessando nossa propriedade - sua getter parece que, por padrão.

Se nós não damos um getter, é isso que o getter parece. Ele só vai voltar este cartões Underbar variável de instância. Bem, essa variável de cartões Underbar instância indo para começar em zero porque todas as variáveis ​​de instância

em um objeto Objective-C começar a zero. Todos eles. OK? Então, incluindo ponteiros. Então, esse ponteiro será zero, o que é que chamamos nil, o que significa que não aponta para qualquer coisa, o que significa que não há nenhuma matriz, ok?

Temos um ponteiro para uma matriz que não aponta a qualquer coisa agora. OK? Então, isso é um problema. Por isso, quando executar o código em cartões add como self.cards adicionar cartão de objeto, que está indo para não falhar mas não fazer nada, tampouco.

OK? Porque eu lhe disse que você pode enviar mensagens para nil, enviar mensagens para os ponteiros, a objetos em que ele não está apontando para um de cada vez, e não vai falhar. Se você enviar uma mensagem que retorna um valor, essa mensagem não vai executar qualquer código mas ele irá retornar zero.

OK? Então, um monte de zeros voando por aqui. OK? Então, como é que vamos corrigir isso? Como é que vamos fazer com que adicionar cartão funciona? Bem, nós poderíamos colocar algo no início do cartão add que diz: "Se self.cards é nulo, então vá alocar uma matriz na pilha e apontar para ele, e então vamos usá-lo. "

OK? Mas isso significaria cada vez temos usar self.cards teríamos de ir ao redor e verifique e certifique-se que não é nula. E isso seria muito chato. OK? Isso seria muito propenso a erros, erro-propenso, podemos esquecer de fazê-lo em algum lugar.

Todas essas coisas. Assim, um ótimo lugar para fazer isso pouco Se cheque está no getter, ok? Isso getter que temos ali para cartões - esse é o getter para os nossos cartões de propriedade privada - ao invés de apenas retornar as cartas, vamos colocar um direito linha

na frente que diz: "Se as cartas é nulo, em seguida, vamos alocar um na pilha e atribuí-lo para a variável de instância. " OK? Assim, a maneira que você alocar uma matriz na pilha é utilizar NS mutável matriz de alocação de init. Então, isso é duas chamadas mensagens aninhados um dentro do outro.

O alloc aloca o membro na pilha, e de inicialização inicializa a memória de modo que é um, você sabe, array sensata. E vamos ver como podemos construir o nosso próprio inicializador em um par desliza aqui. Então, dessa maneira cada vez que você chamar self.cards,

você pode ter certeza que não é nulo; é, pelo menos, vai ser uma matriz vazia. Será que todo mundo entender esse código? É importante compreender isso. Sim. [Inaudível]

>> Paul Hegarty: Okay. Então a questão é: em vez de ter o código de iniciação ser neste getter, por que não posso fazer um inicializador como um INIT para convés e colocar esta plataforma dentro? OK? E isso é uma outra opção.

E, novamente, vamos ver inicializador para jogar baralho de cartas, nós vamos fazer um inicializador. E nós poderíamos fazer isso. Mas ter a inicialização desse coisa estar mais perto para o real recebendo da propriedade é mais - faz sua inicialização menos cheio de um monte de lixo assim.

E isso é chamado de instanciação preguiçoso, pelo caminho, fazê-lo desta forma. Estamos esperando preguiçosamente ao último segundo, até que uma instância. Este padrão é algo que todos em Objective-C é usado para,

e você deve usá-lo definitivamente em vez de fazer as coisas em sua inicialização. Em init você quer, você sabe, definir as coisas, valores definidos que, você sabe, não pode ser facilmente cumprido assim. OK? Mas isso é uma pergunta muito boa. E vamos ver o init em um par de slides.

OK? Então, desta forma estamos self.cards garantido é Nunca nulo. Sim? >> [Inaudível] >> Paul Hegarty: Yeah. Então, o sublinhado é da última palestra.

Lembre-se que quando criamos uma propriedade, Objective-C automaticamente essa coisa, atribua sintetizar: Cartões igual underbar cartões. Portanto, em outras palavras, ele atribui uma variável de instância chamada nome underbar da propriedade para ser o espaço de armazenamento para essa propriedade.

Então é por isso cartões Underbar são criados automaticamente para nós, não nos bastidores. Isso arroba sintetiza um pop-up no nosso código, mas está lá nos bastidores. Essa é uma pergunta muito boa. Todas as outras perguntas sobre isso?

OK. Então, vamos recolher para baixo algumas dessas coisas e procurar a desenhar uma carta aleatória, ok? Então, compre um card aleatório, tudo o que quer fazer é obter um cartão aleatório fora desse self.cards, ok? Assim que o código é muito simples também. Então, nós apenas obter um número inteiro aleatório.

Isso é o que arc 4 aleatório faz se você não sabe. É apenas uma função de biblioteca C. Ela recebe um número inteiro aleatório. Então esse pequeno por cento depois que significa mod - bem, inteiro modulo - e então self.cards.count é o número de cartões em nossas self.cards.

OK? Então, nós apenas estamos indo para obter um índice aleatório em self.cards, em seguida, atribuir uma carta aleatória para ser self.cards quadrado índice de suportes, ok? Então, isso é que os mesmos colchetes para acessar um tipo matriz de sintaxe. E é interessante,

que suportes self.cards quadrado índice, na verdade, isso é um envio de mensagem, acredite ou não. Isso é mesmo que self.cards objeto no índice índice. OK? É apenas uma sintaxe especial e açúcar sintático para torná-lo de modo que você não tem ter muito tempo objeto de índice add.

Na verdade, é objeto no índice subscrita ou algo com um nome verdadeiro método de comprimento. Portanto, este é apenas um pequeno e belo sintaxe, simples. Mas isso é uma mensagem enviar para obter o cartão em que o índice para fora da matriz. E então nós também vamos remover esse cartão

fora da matriz porque este é desenhar uma carta aleatória, ok? É desenhar o cartão para fora do baralho. Portanto, não é no baralho mais, certo? Agora, há um problema com este código, bem como, que é: O que se o pavimento está vazio? OK? Se o deck estiver vazio, então esse índice não assinado vai

para ser zero, certo, porque ele vai para ser arco 4 aleatório de zero mod. Isso vai ser zero. E assim que você vai dizer, "Carta aleatória é igual self.card sub zero." Bem, isso vai travar o seu programa

porque se self.cards é uma matriz vazia, então não há nenhum objeto no índice zero e você vai para obter índice de matriz fora dos limites. OK? Portanto, tenha cuidado disso. O índice - você não pode obter o índice - Se uma matriz não tem um objeto

desse índice, você não pode obtê-lo. Então, isso é fácil de corrigir, embora. Nós apenas estamos indo para dizer: "Se contar self.cards" em outras palavras, se há coisas na matriz ", então vamos fazer isso. Caso contrário, nós apenas estamos indo para voltar carta aleatória, "

que eu felizmente inicializado a zero no início do meu método. E é por isso que eu meio que gosto dessa coisa de inicializá-lo para o valor padrão que você quer, em seguida, configurá-lo, e depois voltar. E dessa forma, se a configuração falhar por algum motivo como este - ele falhar porque não há nenhum cartão no baralho -

ele irá retornar o padrão razoável. Isso é apenas um tipo de coisa estilo de codificação. OK? Nós fizemos a mesma coisa com a pontuação e combinar. OK? Qualquer dúvida sobre isso? Sim? [Inaudível]

>> Paul Hegarty: Ótima pergunta. Então a questão é: Quando eu uso NS inteiro ou NSU inteiro versus o número int ou mesmo NS, que é um objecto que nós não falamos sobre isso ainda? E a resposta é que é uma questão de estilo. E vamos falar um pouco sobre esse estilo

e quando usar essas coisas. Aqui eu realmente não quiser usar um número NS, que é um objeto quando estou apenas usá-lo, você sabe, como um pequeno local coisa assim. Você nunca faria isso. Você está usando números NS basicamente

passá-los aos métodos. E mesmo assim, você poderia passar ints, você sabe, e carros alegóricos. Por isso vai ser tornar-se óbvio como eu falar sobre o número NS, que vamos fazer na próxima semana. OK. Então é isso para deck. Deck, classe muito simples também.

Então, vamos passar para outra classe, que está jogando cartas. OK? A razão que eu estou mostrando cartas de jogar, Eu só quero te mostrar o que parece fazer uma subclasse de outra classe que você escreveu. Então, cartão de jogo é uma subclasse de cartão. E este é o cartão específico, como rei dos corações,

três de ouros, esse tipo de cartão, ok? Agora, ele tem propriedades que são específicas para um cartão de jogo, que é o terno e rank. OK? A classificação que é como um três, quatro, um macaco, rei, certo? E o fato de ser corações, diamantes, clubes.

E eu vou representar o terno como um único caractere - os personagens corações, o personagem clubes. Lembre-se que eu digitei o personagem clubes Eu acho no cartão que poderia ter mostrado que. Eu não sei. Mas você pode digitar um único caractere.

Unicode tem um caráter de cada um dos quatro naipes. Então é isso que meu terno vai ser. E, em seguida, o posto vai ser um número entre zero e treze anos. É que o rei? Sim. Representando o rank.

Então é assim que eu vou representar na minha API pública. E aqui eu estou usando aviso NSU inteiro, em vez de int não assinado. Então NSU inteiro e unsigned int são quase exatamente o mesma coisa. A única coisa sobre NSU inteiro é que é typedef. Pode ser um pouco diferente em diferentes plataformas.

Por exemplo, os novos 5s Capas são processadores de 64-bit. Então NSU inteiro vai ser um 64-bit int, unsigned int em um iPhone 5. E pode apenas cerca de 32-bit uma volta em um iPhone 4 e antes. OK? Então, isso é um pouco diferente.

Assim, uma menor int. Nós provavelmente não estavam representando inteiros. Certamente aqui nós só vai zero a treze. Provavelmente não importa. Mas, você sabe, não estamos representando inteiros que são tão gigantesca que vamos estar usando o bit 33.

Então, observe que, em carta de baralho estamos cartão substituindo conteúdos método. OK? Nós herdamos conteúdo do nosso superclasse. E pelo conteúdo padrão retorna apenas o valor de tudo o que a propriedade conteúdo é. Mas aqui no cartão de jogo que vamos substituir conteúdos

para realmente calcular conteúdos apresentados, com base nessas outras duas propriedades. OK? Então, nós estamos substituindo o getter de conteúdos de modo que ele sempre retorna um string - o conteúdo desta carta de baralho - que é calculado a partir do terno e rank.

Você vê o que estamos fazendo aqui? Então, nós estamos tomando basicamente o armazenamento de conteúdos - conteúdos Underbar - do nosso superclasse e ignorá-lo porque estamos substituindo seu getter. OK? Portanto, esta é uma razão perfeitamente válida por que fazemos estes Propriedades assim porque podemos ter uma maneira melhor

para fazer as coisas que o armazenamento. Agora, aqui está uma forma poderíamos aplicá-lo: Nós podemos simplesmente retornar uma string, ok? cadeia NS, string com formato apenas como printf-ing uma corda. Não se preocupe com essa sintaxe muito. E eu estou printf-ing uma cadeia com cento e D por cento no sinal.

Então por cento D significa inteiro; por cento no sinal significa um objeto. OK? Uma representação de string de um objeto. E então eu estou usando apenas o valor e naipe. Portanto, esta seria uma maneira de fazer o meu conteúdo. Não é uma maneira muito boa porque, por exemplo, o valete de copas diria 11 corações, ok?

Não vai dizer J, pelo menos; queremos dizer J, e não 11. Portanto, esta não é uma maneira muito boa. Então, ao invés eu vou fazer uma matriz que tem todas as coisas certas como um A para um, e J para 11, e um Q de 12 e um K para 13, certo? Então, eu estou apenas fazendo essa matriz aqui.

No meio eu tive que cortar para ajustá-la, certo? E eu ainda fez a zero marca seja pergunta. Portanto, se a sua classificação é zero, ele vai ser, como, ponto de interrogação, como, desactivado. Você sabe, a sua classificação é basicamente não definido. E então eu retornar uma string, que está tomando o posto de

essa matriz e anexando para ele a pequena cadeia de terno, o coração, ou o clube, ou o diamante. Todo mundo entende isso? Eu sou o tipo de dando-lhe isso para que você pode ver como estamos misturando na notação matriz e envio de mensagem, e todo o tipo mistura de perfeitamente lá.

OK? Portanto, agora o conteúdo retorna corações J, ou 5 diamantes, ou o que quer. Observe que a nossa posição é muito bom porque se a nossa classificação é zero, que começa sendo quando dizemos novo cartão de jogo - todas as variáveis ​​de instância são zero para classificação seria zero -

ficamos com este ponto de interrogação agradável. Mas nossa ação começa como nula, e que seria bom se o processo também voltou ponto de interrogação Se foi dito, se era nula. Então aqui estou apenas substituindo o getter de terno para dizer, "Se retorno, se meu terno é nulo, em seguida, retornar o ponto de interrogação,

caso contrário, quando o meu terno não é nulo, em seguida, retornar o que o terno é. " OK? Então, eu estou apenas uma espécie de proteger a minha API ter certeza que eu sempre retornam ponto de interrogação quando o posto ou o terno não está definido. Sim.

>> [Inaudível] >> Paul Hegarty: Desculpe. Todos pouco de sinais - o vermelho no sinal, quer dizer? Sim. Acho que nós não chegar a isso em cartão. Mas nós poderíamos ter. Mas lembre-se que todas as cadeias que estamos indo para o trabalho

com nesta classe são objetos de cadeia, não const estrelas cuidado, certo? Eles são objetos string. E o compilador, se você colocar um sinal de arroba na frente de uma corda, ele vai fazer um objeto string para você, ok? Então é isso que as pessoas em sinais fazer,

eles fazem todas aquelas cordas ser objetos de cadeia porque não podemos colocar uma estrela cuidados const em uma matriz NS. matriz de NS é para objetos, por isso temos de colocar objetos lá como cordas NS. Esses são objetos. OK? Boa pergunta.

Sim? [Inaudível] >> Paul Hegarty: Sim. OK. Esta é uma boa pergunta. Se tivéssemos usado que getter é igual a notação que usamos para é escolhida e é correspondida para alterar o nome,

em seguida, quando substituir temos que usar o novo nome. Nós teríamos que é o que quer. Agora, este não é o caso aqui. Mas eu sei que você está dizendo, e sim, você teria que usar o novo nome. Ótima pergunta.

Todas as outras perguntas sobre isso? OK. Assim que ajuda o terno sempre retornam ponto de interrogação se o terno é nulo ou não definido. Vamos também proteger as pessoas que definem o terno a algo errado. OK? Vamos só permitem que as pessoas definir o terno usar essa propriedade,

o setter público da propriedade. Nós só vai deixar as pessoas definir o terno ser um dos quatro naipes. Então, eu só na mosca no meio há criado uma matriz dessas quatro naipes. E então eu usar esse método contém objeto;

que classe você acha que contém objeto é de que pouco? Alguém? [Inaudível] >> [Inaudível] >> Paul Hegarty: É um método de matriz NS, exatamente. Então contém objeto é um método de array NS. Estou enviando-o para a matriz que eu crio no lugar certo lá.

A matriz que tem corações, diamantes, espadas, e clubes na mesma. E eu só estou perguntando: Você contêm esta cadeia? E que contém objeto vai comparar o conteúdo desta cadeia em todos esses recursos usando um método é igual. Na verdade, ele vai dizer é igual a todos os quatro deles

com o terno como o argumento; não é igual a string - é igual. E na seqüência é igual é implementado por vocação é igual a cadeia se o argumento é uma string. Enfim, mais detalhes do que você precisa provavelmente lá. Mas esta é, obviamente, protegendo-a.

Então não há nenhuma maneira que nós podemos definir a nossa variável de armazenamento terno interna a qualquer coisa exceto para os quatro naipes. Sim? [Inaudível] >> Paul Hegarty: Ótima pergunta. Vocês são direito em cima dela.

Então, cada vez que eu usar o sinal abrir colchete - o azul - para criar uma matriz, Isso é realmente a criação de uma nova matriz de cada vez. OK? Porque eu lhe disse que que colchete arroba e todas essas coisas matriz é realmente apenas chamar métodos? Bem, isso está chamando um método como o init alloc com matriz

com objetos ou algo parecido. Certo? Por isso, é criá-lo. Por isso, seria bom para movê-lo para fora, e vamos fazer isso. Embora, mais uma vez, ter cuidado para não preoptimize. Provavelmente não faria nada diferente. Eu só estou indo para movê-lo para fora para fazer o meu código mais limpo;

Eu não estou indo para movê-lo para fora por qualquer motivo desempenho. Sim? >> [Inaudível] >> Paul Hegarty: Yeah. >> [Inaudível] >> Paul Hegarty: A pergunta é: Será que LLVM apenas cuidar

disso, otimizar isso para você? E isso provavelmente não, porque isso é um envio de mensagem; não é certo que pode haver efeitos colaterais do mesmo. Mas em qualquer caso, nós apenas estamos indo para fazê-lo apenas para tornar o nosso código mais limpo olhar. E o desempenho seria insignificante aqui.

Estamos falando de UI. Não é nem perto. Uma coisa a notar, porém, antes de fazer isso é uma vez que temos implementado tanto o setter e getter de terno, que agora são obrigados a fazer o pelo sintetizar sinal. OK? Em outras palavras, normalmente não temos

fazer isso em sintetizar sinal. Ele é feito para nós. Mas se implementar o setter eo getter, agora vamos fazer. É fácil de fazer porque é sempre dessa mesma forma exata. Mas nós temos que fazê-lo.

OK. Então aqui está - vamos fazer o que estávamos dizendo. Vamos dar esse pequeno conjunto de fatos que temos lá e colocá-lo em outro método. Agora, mais uma vez, eu não estou recebendo qualquer desempenho ao fazer isso, ok? Eu estou apenas começando a limpeza de código, fazendo isso porque eu ainda sou - cada vez que eu chamo ternos válidos,

ele vai criá-la novamente. Agora, eu poderia usar uma variável estática. Este é C. Eu poderia armazenar essa matriz. Começou por ser nulo. Se for nulo, configurá-lo para essa matriz, e então ele só criaria uma vez.

Mas tenha cuidado. Mais uma vez, a limpeza de código e compreensivelmente dez vezes mais importante que o desempenho como este. Então, se você estiver indo para chamar ternos válidos no laço interno milhares de vezes,

ele não está indo realmente importa. Mas uma vez que proponho que se em um método diferente, este tipo de método que eu me mudei para é um pouco diferente. Repare que tem um plus. Você vê um plus lá em vez de um sinal de menos de iniciá-lo? Além disso NS matriz ternos válido?

OK. Um método mais é um método de classe. OK? Isso significa que você enviá-lo para a classe, não para uma instância de um objeto. Tudo certo? Então, já que você não está enviando-o para uma instância, você não pode usar quaisquer variáveis ​​de instância ou qualquer coisa assim.

Você pode apenas tipo de fazer coisas genérico. Assim, a única coisa que realmente usar métodos mais para, métodos de classe, é duas coisas na verdade: as coisas Criação como no slide anterior quando tivemos string com formato - que é um método de classe que estava criando uma cadeia para nós; e depois também os métodos de utilitário como este,

como as constantes de retorno e coisas que, você sabe, nossa classe quer e métodos utilitários. Mas aqui está um exemplo. E a maneira como nós chamamos o método de classe - você já viu me chamar alguns deles - mas aqui está chamando-lo aqui é que colocamos abrir colchete,

o nome de classe, o nome do método. E, novamente, poderia ter argumentos. É como qualquer outro método. Mas todo mundo entender isso? OK. E se você voltar e olhar um par de lâminas e você vê colchete aberto cadeia NS, string com o formato,

mesmo tipo exato de sintaxe. OK? Então é isso que um método de classe parece. Mais uma vez, para a criação de coisas, basicamente, e para os métodos de utilitário. E vamos falar sobre a diferença de: Quando é que vamos criar algo

com um método de classe contra o init alloc? Falaremos sobre isso em breve. Eu também vou fazer ternos válidos público. E de que maneira as pessoas que estão usando o meu cartão de jogo sabe o que os ternos são válidos. E tudo o que eu preciso fazer é colocá-lo no arquivo de cabeçalho.

Boom, que é público agora. OK? Então, vamos fazer uma coisa semelhante aqui com aquelas cordas de classificação. OK? Então eu vou tomar essas posições cordas - que matriz de seqüências de classificação lá em cima - e eu vou colocar isso em um método de classe.

OK? E, novamente, este é para facilitar a leitura, não para o desempenho. Porque cada vez que eu chamo de classificação cordas, ela ainda vai para criar essa coisa novamente. E então eu chamá-lo de vez lá em cima. E eu não vou fazer Ranking si cordas público,

mas eu vou fazer outro método classe chamada classificação max, que só olha para quantas cordas estão em cadeias de classificação. E eu vou voltar que, como um método público. Portanto, há três métodos de classe para você afundar seus dentes into - dois deles pública, não. Tudo certo.

E por isso eles são todos os métodos de utilitário, certo? Nós não estamos acessando quaisquer variáveis ​​de instância em qualquer desses métodos, ok? Essa é a única razão pela qual eu estou mostrando esses, é só para você ver o que um método de classe parece. Nós também poderíamos substituir o setter de classificação apenas

para ser completa aqui para se certificar de que não permite que você para definir uma classificação errada como conjunto de classificação 15 - não há tal cartão como 15. Então, vamos ter certeza de que o posto é menor do que o posto máximo, que é o método utilitário que acabamos de fazer. OK? Será que todos se reúnem para você, faz sentido?

Portanto, este é um tipo de material de referência. Você tem esses slides que têm todas as anotações de todas as coisas que estou dizendo. Portanto, sinta-se livre para ir para trás e olhar para ele e lembre-se sobre todos estes NS matriz, sintaxe, e todos os métodos de classe, todas essas coisas.

OK. A última coisa que nós estamos indo olhar a é o negócio método init. OK? Então, nós vamos ter uma outra classe aqui chamado jogando baralho de cartas. Tudo certo? E um deck de cartão de jogo é uma subclasse de deck.

Tudo certo? E tem nenhuma API pública. Ele só vai substituir um método que herda indiretamente de NS objeto - ok, NS objeto através do convés, o que não tocá-lo - todo o caminho para jogar baralho.

E esse método é chamado de init. OK? Portanto, esta é a mesma de inicialização, mesmo tipo de método que quando nós criamos essa matriz - essa matriz mutável dissemos NS mutável de inicialização de matriz de alocação. Então, alguém vai chamar esta carta de baralho método plataforma de inicialização - ou seja, você na sua casa vão chamar este

fazendo jogando baralho de cartas de alocação, e, em seguida, do lado de fora, o init. OK? E é assim que você vai para criar um baralho de cartas de jogo. E é assim que criamos a maioria das instâncias de objetos - não todos. Às vezes fazemos coisas como o NS string, string com o formato.

Mas na maioria das vezes - mais de metade do tempo - fazemos alloc e depois na inicialização do lado de fora. OK. Ouça com atenção: Nunca chame essa coisa alloc sem envolver um INIT em torno dele. OK? Nunca mais faça isso. Isso não faz sentido ter um objeto alocado

na pilha que nunca foi inicializada. Sempre tem que aninhados. E vice-versa: Nunca chame que o init excepto para quando você envolvê-la em torno de um alloc. E definitivamente nunca chamar o init que mais de uma vez. OK? E se você obedecer a minha regra de apenas chamando-o embrulhado

em torno de um alloc, você não pode chamá-lo mais de uma vez. OK? Init não é algo que você pode re-init. Init acontece uma vez logo após alloc, e é isso. OK? Essa é uma regra dura e rápida que nunca quebrar. OK? Então você ouviu aqui. Não se esqueça.

Tudo certo. Vamos olhar para o tipo de retorno whacky a este método init, ok? Você poderia pensar que este método init deve retornar um cartão de jogo estrela convés porque é o tipo de inicialização e talvez ele retorna em si. E, de fato, o init faz voltar sempre eu, ok?

Então init é sempre vai retornar self. OK. Mais whackiness lá, o que eu vou descrever. Apenas por conveniência, ele sempre retorna auto de modo que você pode fazer, like, jogando baralho de cartas de alocação de inicialização, enviou-lhe uma mensagem. OK? Então é só a conveniência que ele retorna auto. Mas não pode realmente ter seu tipo de retorno a ser cartão de jogo

estrela convés porque herdou isso do NS objeto. E NS objeto já definiu como NS estrela objeto. Entende? Então é meio estranho que você está herdando um método cujo valor de retorno teria para mudar cada vez que você, você sabe, passou por cima dele. Então eles inventaram essa coisa nova - isto é novo para iOS 7,

pela maneira - chamado tipo de instância. E o exemplo tipo significa é que isso vai para retornar um objeto que é da mesma instância - mesmo tipo, mesmo tipo de classe - como o objeto que você enviou esta mensagem. OK? O que faz sentido perfeito para inits.

E nesta classe que é provavelmente tudo que você vai usar isso para aqui. Então, se você realmente não entendo o que eu disse - é explicado nos slides - mas se você realmente não entendo, só sei que sempre que você fizer um inicializador,

que vai retornar tipo de instância como seu tipo de retorno e você está sempre indo para retornar self. OK? Agora, também basta ter a minha palavra para ela. Nós vamos fazer nestes próximos linhas de códigos, bem porque eles são realmente estranho. Essa primeira linha, auto iguala super-inicialização, que é estranho.

Isso é super estranho. OK? Atribuindo algo para si em Objective-C - simplesmente nunca fazer isso, exceto para isso uma vez e que está em sua inicialização. OK? Você ter auto e você atribuir a ele a chamar seu superclasses inicializador

de modo que sua superclasse é inicializado. Por que atribuir o resultado à auto? É o tipo de história antiga por que isso foi feito por um longo tempo. Basicamente estamos verificando o retorno de nossos superclasses de init para ter certeza que devidamente inicializado.

Porque a qualquer momento se o seu inicializador não pode inicializar em si, ele deve retornar nulo. OK? E que permite que toda a gente sabe qualquer um dos seus subclasses ou qualquer um que tenta alloc e inicializar você, você não poderia criar um objeto bem formado. OK? Assim você pode ver como esse código, por estranho que é -

auto iguala super-inicialização, e então, se eu, Eu vou me inicializar, o retorno auto - que vai garantir que eu nem sequer tentar para mim mesmo inicializar se o meu superclasse, quando eu chamo a sua inicialização, você sabe, não é possível inicializar em si. OK? Então, basta fazê-lo.

Se você não entender isso, não se preocupe muito sobre isso. Apenas faça isso. Agora, uma coisa aqui é que nós estamos falando sobre o init sem argumentos. É possível ter initializers com argumentos porque às vezes você precisa de argumentos

para inicializar corretamente uma classe. E vamos falar sobre isso um pouco mais na segunda-feira. OK? Então, hoje nós apenas estamos indo para uma espécie de esqueleto de init. Então o que isso init precisa fazer? O que eu preciso fazer para ter um jogo inicializado bem-formado baralho de cartas?

Bem, um baralho de cartas de jogo tem 52 cartas em que, um de cada tipo de cartão. OK? Rei dos clubes, três de ouros - todos os 52 deles. Então eu só preciso iterar a todos os fatos, e, em seguida, iterar através de todas as fileiras, e criar um cartão, e adicioná-lo para mim mesmo.

Então aqui está me repetindo através dos ternos, iteração através das fileiras. Todos bem com isso? Então eu vou para importar carta de jogar, porque eu vou para criar um cartão de jogo, jogando cartão de alocação de init. Então eu vou para definir

posto que do cartão, definido esse terno do cartão. Valor e naipe são minhas pequenas variáveis ​​de iteração lá. E então eu estou indo para adicioná-lo para mim mesmo. Eu sou uma plataforma, de modo que é perfeitamente bem. Todo mundo legal com esse código? Então agora eu sou um baralho de cartas de jogar bem formado e posso ser usado

desenhar cartas aleatórias e todas essas coisas, o que você vai precisar o que fazer para a sua casa. OK? E, de fato, para a sua casa você vai ter para digitar todos os quatro destas classes. Eu quero que você tenha aulas experiência de entrar, digitando uma coisa, vendo como Xcode reclama para você

como você digitar coisas, e coisas assim. E então você está indo estar usando plataforma de cartão de jogo e cartão de jogo. Bem, jogando baralho de cartas e um cartão realmente são as duas principais você vai estar usando para fazer a sua casa. OK? Perguntas sobre isso?

OK. Então é isso para os slides. Então agora eu vou fazer uma grande demonstração de idade. E esta demo vai para integrar tudo o que vimos até agora, ok? Mais notavelmente que MVC coisas que falamos, como ação de destino, você sabe, deixar cair o alvo

e atirando a ação ou a saída seta verde que aponta para o outro lado. OK? Nós vamos mostrar-lhe o que realmente se parece em Xcode. Eu acho que quando eu perguntei quem de vocês têm feito Xcode, quase cada um de vocês levantaram suas mãos.

Então eu não vou gastar muito tempo falando sobre todos os botões no Xcode. Eu acho que vou passar rapidamente sobre aqueles. Mas se você não tiver usado o Xcode, é em muito detalhe nos slides das aulas. Há uma espécie de este passo a passo.

By the way, se você está acompanhando nos slides de aula, minha demo não vai ser exatamente como o que está nos slides. Os slides cobrir um pouco mais do que eu posso cobrir em quarenta minutos aqui. E também é material de referência.

OK? Então, se eu fazer alguma coisa hoje nesta demo e você está como, "Oh, como ele fez isso?" se você vai olhar para esses slides, ele vai dizer. Portanto, não se sentir como, "Eu comecei a escrever furiosamente para baixo cada clique de botão, ele vai fazer nos próximos quarenta minutos. "

De jeito nenhum. OK? Siga junto nestes transparentes, se quiser, ou simplesmente fechar seu laptop, e assistir, e deixá-lo afundar em porque você vai ter que reproduzir o que eu estou fazendo nos próximos quarenta minutos para a sua casa. E esses slides vão orientá-lo

passo a passo como fazê-lo. Portanto, não sente que precisa fazer alguma coisa agora mas deixe isso tudo pia. Começar uma sensação para o que está acontecendo. OK? E então quando você se senta para fazê-lo, você será guiado através dele.

Na próxima semana vamos falar muito mais sobre Objective-C, responder a algumas dessas perguntas mais detalhadas como o número NS e algumas dessas outras coisas que as pessoas estão pedindo. E vamos falar sobre algumas das coisas específicas sobre Objective-C como ligação dinâmica e protocolos, e as coisas que você não geralmente ver o máximo

em outros idiomas ou não existem em outros idiomas. Então, vamos tentar cobrir tudo isso. Então, até o final da próxima semana você está até a velocidade em Objective-C. Você está realmente começando a correr com o Xcode. E assim a semana depois que podemos realmente começar a fazer alguns,

você sabe, iOS alta potência 7 coisas. OK. Então demonstração aqui. [Inaudível] que. Tudo certo. Assim, o demo que eu vou correr no Xcode. Então eu só vou lançar Xcode.

Então Xcode você começa executando - indo para sua loja de aplicativos Mac. Isso é esta coisa aqui, certo? Obter a App Store no seu Mac, e você só procurar Xcode, encontrá-lo. É grátis. Você baixá-lo e executá-lo.

OK? É simples assim. Isto é o que ele vai olhar como quando você levá-la, esta tela de abertura aqui. Como o trimestre continua, esta irá preencher -se com todos os projetos que você está fazendo. Você provavelmente está acostumado a isso, se você sabe Xcode.

E o que vamos fazer hoje é criar um novo projeto. Você pode verificar um projeto existente de controle de origem ou você pode criar um novo. E assim nós vamos criar um novo. Então, quando nós criamos um novo, ele quer nos dar um pouco de ajuda oferecendo-se para criar um modelo para diferentes tipos

de aplicações como um jogo OpenGL. OK. Ele vai criar alguma estrutura para isso para você. aplicações detalhe mestre, algo que vamos fazer mais tarde no trimestre, embora nós vamos para construir todo o código nós mesmos; não vamos usar esse modelo.

E este único pedido de vista aqui é basicamente um único MVC, que é como vamos começar tudo de nossas aplicações nesta sala de aula - com um único MVC. Em seguida, vamos adicionar mais CVM e construir. OK? Portanto, este é o seu único aplicativo básico MVC. Então eu vou para clicar isso.

E aqui ele vai pedir algumas informações sobre ele como o que você quer chamar este app? Este é um jogo de cartão de harmonização eu decidi para chamar Machismo, ok? Assim que vai ser o nome de nosso aplicativo só por diversão. Eo nome da organização pode ser o que quiser.

Vai aparecer nos cabeçalhos de todas as classes que você criar. Assim que eu faço o meu ser Universidade de Stanford. Você pode fazer o seu ser de Bob Game House ou o que quer. Este identificador deve ser exclusivo para você. Então, eu tenho edu.Stanford.cs193p.instructor.

Você pode ter edu.Stanford.cs193p dot seu ID SUNET. Isso vai ser completamente original. Estes DNS reverso é realmente uma boa maneira para criar um nome único. E está indo para criar um nome exclusivo para este aplicativo

por combinação deste com os nomes. Assim você pode ver que é feito isso aqui, este identificador de pacote. E então esta classe prefixo - esse modelo vai criar uma visão e um controlador para nós. E isso está dizendo: "O que você quer o nome de sua classe de controlador para ser? "

Por padrão, ele vai ser chamado de "controlador de vista", ok? Mas se você digitar algo aqui como "jogo de cartas", agora ele vai a ser chamado de "jogo de cartas controlador de vista," que é um pouco melhor nome para nós. Então, isso é apenas o prefixo que vai colocar o nome do controlador de que ele cria para você.

E então, finalmente, aqui podemos criar um aplicativo aqui apenas para o iPad, ou apenas para iPhone, ou um aplicativo universal que será executado em ambas as plataformas. Agora, quando você cria um aplicativo universal, você ainda tem para projetar a interface do usuário do separadamente porque se você tem mais regras de tela, você só vai

para projetar uma interface de usuário diferente. OK? iPad não é apenas um grande iPhone. Você pode fazer muito mais coisas se você tem mais espaço na tela. Mas você ainda pode ter um monte de seu MVC do compartilhada, direita, porque esse iPad pode ter pequenas subáreas que estão no MVC

que são exatamente o mesmo que em um iPhone ou muito, muito similar. Então, totalmente suportados no iOS 7 para criar aplicativos esse alvo ambas as plataformas e tem grandes ferramentas para deixá-lo construir o seu dois UI separadamente e compartilhar todas as MVCs embaixo. OK? Nós vamos fazer iPhone só aqui apenas

porque mantém a tela pequena e eu só tenho tanto imobiliário aqui. [Inaudível] >> Paul Hegarty: Yeah. Então a questão é: Se eu estou no meu iPad e eu executar um aplicativo que é iPhone só, sim,

há um modo de emulação, essencialmente, que vai tipo de fazer uma grande coisa em forma de iPhone na tela do iPad. Então, nós estamos indo fazer iPhone aqui. Então é isso. Eu estou indo bater em seguida. Em seguida, ele quer saber,

"Onde você está indo ele colocar esse projeto?" Eu recomendo fortemente colocá-lo em seu diretório home - em um diretório chamado "developer" em seu diretório pessoal. OK? A menos que talvez nós estamos trabalhando em classe diferente. Talvez você tem o CS 193P

em seu diretório home e depois outra classe. Mas a linha de fundo: Coloque-o em seu diretório pessoal; não colocá-lo, como, na raiz ou em algum lugar assim. Isto tem, no passado, causou problemas. Mas um ótimo lugar para colocá-lo aqui. Este é o meu diretório home, CS 193P lá.

Vejo diretório home, desenvolvedor. Aqui é onde eu vou colocá-lo. Eu não tenho nenhum projeto ainda. Esta pequena coisa aqui em baixo, controle de origem, vamos estar falando sobre isso. É realmente muito bem integrado no Xcode, mas não vamos

para falar sobre isso hoje. Então deixe que não clicados. E aqui é o nosso novo projeto. Você pode ver isso nos mostra esta tela, que você obtém para clicando neste coisa muito superior até aqui. Portanto, este é tipo de como nossas configurações do projeto.

E há um monte de configurações aqui. Nós estaremos talk sendo todo este material como o bairro continua. Mas hoje não vamos falar sobre nada disso porque queremos nos concentrar em nossa MVC. E o nosso MVC, este aqui, main.storyboard, é a nossa visão. OK? Essa é a nossa visão do nosso MVC.

E então você vê este jogo de cartas controlador de vista M e H? Esse é o nosso controlador. Não há nenhum modelo aqui. Seu modelo vai ser aquelas quatro classes - convés, cartão, cartão de jogo, jogando baralho de cartas - que vai ser o seu modelo.

Então você vai ter que entrar nesse in. Vou mostrar-lhe no final como fazer isso. Esta pequena coisa aqui, jogo de cartas [inaudível] ponto H e M, vamos falar sobre isso brevemente, especialmente quando começar a falar sobre coisas como multitarefa. Mas eu gosto de apenas mover os fora do caminho.

Por isso muitas vezes colocá-los aqui nesta pasta arquivos de suporte. E você pode simplesmente pegar qualquer arquivo, a propósito, e movê-los em qualquer lugar que você quer aqui a espécie de limpar o seu ponto de vista. Então aqui eu tenho a minha visão e meu controlador somente mostrando aqui. OK? Então vamos direto para a visão

e ver o que parece. Então aqui está o meu ponto de vista. É um iPhone branco 5 porte, certo? Uma vista alto e magro. E é em branco. Nada novo.

É branco. Esta área do lado esquerdo, a propósito, onde nós clicado sobre esses arquivos, que é chamado de "navegador". E você não só pode navegar por todos os seus arquivos aqui, mas você pode navegar pelos seus pontos de quebra, e construir problemas, e suas hierarquias de classe.

Todas as coisas que aqui em cima. Então, novamente, a maioria de vocês sabem Xcode, então você provavelmente conhece a maioria deste material. Nós estaremos demos tudo isso como o bairro continua. E esta área aqui é chamado de "área de utilidades." E é aí que você basicamente saber detalhes

sobre o que está acontecendo aqui. Então inspectores para atributos e dimensões, e conexões, e coisas como essa aqui. E este é também onde você pode arrastar as coisas que você vai usar para construir sua interface de usuário porque nós estamos indo para construir a nossa visão inteiramente graficamente.

OK? Nós não estamos indo para escrever código, em sua maior parte, para construir o nosso ponto de vista. Como o trimestre continua, vamos aprender um pouco mais sobre como para construir a nossa visão no código, mas nós vamos começar fora apenas puramente fazendo a nossa visão de coisas graficamente arrastando fora e fiação-los para cima.

E nós vamos colocar o nosso código no nosso controlador. Este dois lados podem ser escondidos e mostrados com os dois botões. Vejo? Você pode ocultar esses. [Inaudível] Isso pode parecer também, esta área bem aqui, este pequeno botão para baixo aqui. Isso é chamado de "esboço do documento."

Isto é realmente útil dandy. Mas, novamente, não vamos lo falar sobre isso hoje. Nós só podemos falar tanto de uma só vez. O esboço do documento. Isso só mostra-lhe todas as instâncias de objetos Na sua opinião, em uma forma de esboço comum.

Então você pode realmente encontrá-los facilmente e suas relações com o outro. A outra coisa que você pode fazer é que eu não quero que este iPhone 5 porte coisa, porque minha tela é baixa resolução aqui assim que trabalha no projetor. Então eu vou para clicar neste botão pouco para baixo aqui,

o que reduz me para baixo para iPhone 4 tamanho. OK? Ou iPhone 4S. Agora eu sou alto e magro. Mas você pode clicar e para trás e movê-los de volta para trás. E eu estou apenas tentando fazer caber tudo na tela aqui. OK. Então vamos mergulhar na direita para a construção de nosso ponto de vista aqui.

O nosso ponto de vista vai ser hoje é um único cartão com um ás de paus escritos nele. OK? Isso vai ser ele. E eu vou ser capaz de clicar no cartão e vai virar, mostram a parte de trás do cartão, e em seguida, clique -lo novamente, ele vai virar para trás para me mostrar o ace

do clube novamente - e para trás, para trás e para frente. OK? E a sua casa vai ser para torná-lo por isso, quando o cartão vira para ele não mostra o ás de clubes, que mostra um cartão aleatório tirado a partir do convés. OK? Isso vai ser todo o seu trabalho de casa que é devido na segunda-feira.

OK. Então, vamos fazer isso. Realmente simples. Vamos para esta área bem aqui, esta biblioteca objeto. OK? Esse é o terceiro botão aqui, mostrar biblioteca de objetos. E é aí que todos os nossos objetos são. Se você olhar no aqui e você não vê esses objetos,

pode valer a pena clicar no seu ponto de vista. Às vezes Xcode quer saber o que o destino é que você vai estar arrastando as coisas em. Então, se você clicar nele, então você vai ver essas coisas. E nós apenas estamos indo para pegar um desses botões bem aqui. Então, eu vou pegar esse botão e arraste-o para fora.

E notem, como eu arrastá-lo para fora, estas pequenas linhas azuis aparecem - estas orientações. OK. Estas orientações são super importante. Eles parecem apenas como uma conveniência para ajudá-lo a colocá-lo no meio ou à direita no canto direito.

E eles são, mas eles são realmente importante para certificar-se que todas as coisas na sua opinião são uma espécie de, como, espaço padrão à parte, certo? E alinhados contra bordas. Para que, como os usuários de ir de um aplicativo para outro, coisas serão todos separados por espaços previsíveis

e tudo vai ficar consistente. É realmente importante. E não há um mecanismo - você pode ver essa opção aqui, usar o layout automático, que foi introduzido no iOS 6 e melhorou bastante no iOS 7, especialmente no Xcode - que permite que quando o seu interface de usuário muda de tamanho,

como se passa de um iPhone 4 para um iPhone 5, ou ele roda de ser vertical para estar horizontal, ou é em um iPad em um espaço maior. Para todos os botões e tudo a tipo de movimento para uma nova posição que faz sentido ou pelo menos a maioria deles, certo?

E então talvez você pode ter que mover alguns deles com a mão, dependendo do que está acontecendo. Mas na maioria automaticamente coloca-lo para fora. E isso é realmente importante porque eu tenho certeza dispositivos continuarão a ser diferentes tamanhos como novo, você sabe, os dispositivos vêm ao longo dos anos.

Assim disposição auto fazendo é importante, e estas orientações azuis são o número mais importante coisa para o layout automático. Nós vamos cobrir o layout auto em detalhe, e há muito a ele. Todos estes botões para baixo aqui tem a ver com o layout automático.

Mas conseguir essas orientações azuis, certificando-se de que você deixar cair coisas com pelo menos um guideline azul em algum lugar é realmente importante para obter tipo que você vai no caminho certo com a auto adequadamente definidos UI. Portanto, temos este botão aqui.

Mas antes - e, claro, nós podemos ir por aqui para isso é o inspetor de atributos e clique sobre ele. E vamos ver todos os tipos de atributos. Na verdade, se eu esconder isso, toneladas e toneladas de atributos para este botão. OK? Não apenas o próprio botão,

mas na verdade sua superclasse tem atributos. O controle é sua superclasse, e, em seguida, vista é superclasse de controle e tem atributos. OK. Portanto, este é um inspector orientada para o objectivo que irá mostrar todos os atributos de todas as coisas

através da hierarquia de herança. E o que está acontecendo aqui é que está editando na verdade um exemplo de um botão aqui. Portanto, não são - e eu sei em alguns sistemas que você layout do botão, você definir o tamanho, e você definir os atributos.

E então, você sabe, por trás das cenas um grupo de código está a ser gerado para criar o botão. Isso não é o que estamos fazendo aqui. Na verdade, estamos editando objetos vivos. Eles vão essencialmente para ser liofilizado. E então quando o seu aplicativo é executado, adicione a água, eles vêm à vida, tudo bem,

com seus atributos definidos, e todos os seus tamanhos e posições, e todas as suas informações de layout automático no objeto. OK? Portanto, é um pouco diferente do que você pode ser usado de em alguns outros sistemas. De qualquer forma, antes de editar os atributos deste botão, porém, vamos mudar o nosso fundo

porque este é um jogo de cartas. E a maioria dos jogos de cartas estão em, como, feltro verde, certo? Então, vamos fazer o nosso fundo ser mais parecido com um feltro verde. Então, eu estou indo só para clicar sobre o fundo, que é este ponto de vista aqui, e você pode ver suas propriedades. Então, eu vou mudar um casal -

ou apenas uma das suas propriedades - que é o fundo. Você vê essa cor de fundo branco aqui? Então, se eu clicar neste, eu tenho algumas cores utilizadas recentemente. Eu tenho todos estes tipos de cores preto e branco. E eu também tenho outra. E eu trago outro, traz os pastéis, ok?

Ele também traz outras maneiras de escolher as cores, Mas eu gosto do lápis de cor. OK? E então onde estão os meus pastéis? Ali estão eles. Então, vamos escolher um verde, como, musgo é uma boa verde. Trevo. Eu meio que gosto musgo melhor.

Então, esse é o tipo de um fundo jogo de cartas. E é isso. Então, nós temos definir a cor de nossos pontos de vista de fundo. OK? E toda a configuração atributo é apenas como este: Você apenas configurá-lo e esquecê-lo. Então, vamos voltar para o botão e suas propriedades.

OK. O botão que eu quero olhar como um cartão. Bem, um botão no iOS 7 basicamente parece muito como um hyperlink em uma página web, apenas como aquele botão faz ali. OK? Esse botão azul. Isso não é realmente apropriado para o que queremos.

Queremos que se parecesse com um cartão com um pouco de rect arredondada e um fundo branco, certo? E eu quero a parte traseira do cartão para a mesma aparência mas têm algum tipo de projeto nele ou algo parecido. Então, a maneira que eu vou fazer é que eu vou para definir uma imagem de fundo para o meu botão.

OK? A imagem de fundo que é como um rect arredondado. Portanto, vamos ter um pouco de lado aqui e falar sobre: Como podemos obter imagens em nosso aplicativo? OK. Queremos usar imagens na nossa aplicação; é muito comum querer usar imagens em uma aplicação gráfica como em um telefone.

Então como você faz isso? E a resposta é que você vá até aqui para este lugar chamado "Imagem biblioteca de ativos" - ativos images.xc ou ativos Xcode. E você pode ver que já há um par de slots para ícones aqui.

Eles não estão definidos, mas este é o ícone do aplicativo. E também você pode ter uma imagem de lançamento que aparece instantaneamente quando alguém lança seu aplicativo. E então, como você está inicializando, tendo por trás da imagem lançamento, e, em seguida, ele vai mostrar que você está UI real. Então é um tipo de imagem de inicialização rápida da.

E nós vamos falar sobre isso na segunda-feira. Vamos definir o fundo app para Machismo aqui. Mas eu vou realmente arrastar em alguma outra imagem. Então, eu tenho algumas imagens aqui. E, por exemplo, eu tenho este logotipo Stanford aqui. Então, eu estou indo para arrastar o logotipo Stanford

em porque eu quero usá-lo. E é isso; você só arrastá-lo aqui. Ele diz Stanford. Mas observe que tipo de tem essa coisa estranha aqui, este 1X e 2X. Você viu isso?

E isso é porque cada imagem que você vai usar no iOS quer ter uma versão de resolução normal o que está acontecendo para ser usado como no iPhone 4 - nonretina exibe basicamente. E em seguida, um 2X, duas vezes mais alta resolução - uma que irá ser utilizado na retina. E ele vai escolher automaticamente o caminho certo,

dependendo do que você está executando. OK? Você não tem que fazer nada sobre isso. Mas você deseja fornecer esses res mais altas. E estas res mais altos não são apenas necessariamente a mesma exata imagem, apenas, você sabe, fez mais alta resolução. Eles podem permitir que você faça -

Por exemplo, aqui eu tenho um logotipo Stanford com a pequena árvore. Vejo? Ver a árvore lá? Então talvez isso seja muito baixa resolução para realmente ter uma árvore de boa aparência. Mas eu posso obter a árvore em uma resolução mais alta,

assim que eu colocá-lo lá. Por isso não é tão comum que os dois seria, na verdade, diferente de aparência, mas eles poderiam ser. Certamente permitiu que poderiam ser. Eu também não quero realmente chamar isso de "Stanford". Vou usar isso como meu cartão de backup.

Em vez de ter, sabe, algum tipo de design, Eu vou ter o logotipo Stanford ser a parte de trás do meu cartão. Quando do meu cartão virado para baixo e eu ver a parte traseira, Vou ver o logotipo padrão. Então, eu vou chamar isso de "cartão de volta." Posso chamá-lo de qualquer coisa que eu quiser.

Eu também tenho coisas para a frente aqui. Este aqui. Este é o cartão em branco com um canto arredondado. Lá está. Você não pode vê-lo. Porque é um cartão branco para que você não pode vê-lo.

Mas eu vou usar isso. Eu vou chamar isso de "parte dianteira do cartão." E eu também vou ter uma versão high-res de que, como bem. OK. Então, isso é bom. Assim, tanto quanto nós podemos ver isso.

OK. Então agora eu tenho algumas imagens. E agora eu quero usá-los na minha opinião. Eu meio que deseja definir este cartão para usar isto. Então eu vou começar com o meu cartão aqui estar cara -se quando ele é executado. Quando meu aplicativo é executado, o cartão vai começar a face para cima.

Em seu aplicativo quando chegar a sua casa você provavelmente vai a querer iniciá-lo de bruços. A razão para isso é o meu aplicativo só mostra um cartão: Ás de clubes. Por isso é bom se ele vem com ás de paus. Mas você não quer que seu cartão para chegar ás de paus, com certeza.

E isso pode ser um pouco mais trabalho para você de codificação-wise para inicializar-lo para chegar a alguma carta aleatória. Então eu vou ter que vir para cima de bruços. Torná-lo muito mais fácil de você. OK? Então, como vamos definir isso? Realmente simples.

Eu tenho o botão selecionado aqui. Aqui está suas propriedades. Uma das suas propriedades é a sua imagem de fundo. OK? Então eu só vou clique aqui, e você pode ver que todas as imagens que estão em minha biblioteca ativos estarão aqui. OK? E se houve realmente um monte deles,

você pode digitar e ele irá igualar. Então, eu vou fazê-lo ser parte dianteira do cartão. Por isso, tornou a parte dianteira do cartão, mas eu não vejo - onde está o rect arredondada? OK? Eu não posso ver o rect arredondado. E isso é porque ele é muito pequeno

para ver os cantos arredondados muito bem aqui. Então você pode apenas tomar essa coisa e redimensioná-la. OK? E eu vou fazer isso - Eu quero que ele seja cerca de 2-3 [inaudível]. Então, eu vou fazê-lo 64 por 96. Eu sei que este passa a ser um muito bom tamanho, e eu redimensionado-lo.

E agora você pode ver os cantos arredondados pequenos. Entende? Portanto, esta é a imagem que eu arrastado no com o botão escrito em cima dela. E, claro, eu mudei um pouco para que eu possa colocá-lo de volta no meio usando minhas orientações azuis, certo? E, claro, eu não quero que o meu cartão para dizer "botão"-la;

Quero que o ás de paus aqui. Então eu vou basta clicar duas vezes sobre ele. Eu também poderia editar esse aqui em cima. Você vê aqui, onde ele diz que "botão"? Clique aqui. Eu só vou dar um duplo clique diretamente sobre ela.

Vou escrever "ace". E como faço para escrever clubes, alguém sabe? Alt coisa ou outra. Eu gosto de fazer dessa maneira. Eu vou para editar menu, caracteres especiais, obter esta coisa mágica.

Você já viu isso, tipo de esfriar? Basta clicar duas vezes - encontrar os clubes e clique duplo. Tudo certo. Portanto, não é o meu ás de paus. Agora, mas, você sabe, isso não é certo, também. Eu realmente não gosto que A. azul Eu realmente quer o Um ser negro.

E poderia ser um pouco maior. Há mais espaço para isso. Então eu posso ir por aqui, por exemplo, e alterar a fonte. Eu posso alterá-lo clicando essa pequena coisa para torná-lo maior, ou posso realmente clicar neste T e até mesmo definir qual fonte é. Uma coisa que é realmente importante

no iOS 7 é a tipografia. OK? Escolhendo os estilos de texto direita é realmente, realmente importante em iOS 7. E nós não vamos realmente falar sobre isso aqui; nós apenas estamos indo para usar a fonte do sistema. Mas isso é algo que vamos falar na palestra,

é ter certeza que você escolhe as fontes certas nos lugares certos para tornar a aparência da interface do usuário muito bom. Posso alterar o tamanho aqui, talvez 24 pontos ou algo assim. Isso ainda vai caber. E então eu não quero este azul, de modo que é esta cor do texto.

Então, vamos em frente e fazer que o preto. Tudo certo. Então, eu tenho o cartão de vista da maneira que eu quero. Isso é bom. Todas essas propriedades que estamos assentados, a propósito, se você olhar para o botão, você vê esta configuração estado aqui?

Padrão? Na verdade, podemos definir todas estas coisas de forma diferente para o Estado em destaque do botão, ou um estado selecionado ou estado desativado. Mas estamos definindo-as como padrão. Assim, todos os nossos botões sempre vai estar exibindo o estado padrão.

OK? Então botões são bastante poderoso. Você pode tê-los parecer diferente como eles destacar ou qualquer outra coisa, mas nós estamos indo trabalhar todos em que é chamado de "Normal" ou estado "default" do botão. Você verá que quando chegarmos ao código. Assim, podemos realmente executar este agora.

Assim sendo executado. Vocês todos - a maioria, de novo, feito Xcode. Você sabe como executar. É este botão pequeno jogo. Você pode realmente segurá-la para baixo, e há outras coisas que você pode fazer como testar e analisar.

Mas nós apenas estamos indo para executar. Então eu clique em Executar, e está indo para executar este em um simulador. OK? E aqui está. E você pode ver que o simulador tão grande que nem sequer se encaixam na minha tela. Então eu meio que tem que rolar em torno dele.

E quando eu clicar nele, ele não faz nada. OK? Então isso não é bom. Tudo certo. Porque eu não colocar qualquer código no meu controlador de responder a essa coisa de ser tocado. Então, isso é o que vamos fazer a seguir.

Então, vamos voltar aqui e parar. OK. Então, como vamos fazer isso? Bem, é muito interessante como fazemos isso, na verdade. Eu vou fazer um pouco mais de espaço aqui. E o que precisamos fazer é conectar-se ao nosso controlador. E fazemos isso, colocando lado o código do nosso controlador

a lado com a nossa visão. Tudo certo? Então eu vou para clicar neste botão pouco aqui, este ícone botão, e que coloca lado a lado. E, por padrão, se você tem uma vista aqui em cima, à esquerda, ele vai colocar o código que do controlador à direita.

E você pode mover este para obter mais espaço para o código, se quiser. Você também pode alternar entre o cabeçalho se quiser para fazer coisas público ou a implementação. OK? Então, isso é bom. Agora, esse código aqui faz parte

do ciclo de vida do controlador de vista, o que nós estamos indo para falar sobre em duas ou três semanas. Mas hoje não vamos falar sobre isso. Assim, podemos simplesmente se livrar dele. E vamos começar por dizer, "Quando este botão fica tocado, queremos que virar. "

Então, precisamos fazer uma conexão entre o nosso ponto de vista e do controlador. E nós vamos fazer aquela coisa onde pendurar o alvo fora e disparar a flecha. OK? Chamado de "ação-alvo." E isso vai ser meio malucas.

Você provavelmente não está nem vai acreditar quando vê-lo. A maneira de fazer isso é que você mantenha pressionada a tecla de controle. Então, eu estou mantendo pressionada a tecla de controle, e eu estou arrastando uma linha do ponto de vista diretamente no nosso código. Tudo certo? OK? E eu deixar ir.

E diz: "Oh, você quer uma conexão entre seu ponto de vista e seu controlador, não é? Aqui está o que eu preciso saber. " Por isso, nos pede: "O que você quer para chamar essa conexão? " Portanto, este vai ser o nome do método.

É realmente vai criar um método aqui que é chamado quando o botão fica tocado. Vou chamá-lo de "botão de cartão de tocar." Isso é um bom nome. Aqui ele está dizendo: "O que você quer que o tipo do argumento de ser? "

Vamos falar sobre isso mais tarde, mas por agora nós obviamente quer que o argumento a ser o botão que está nos enviando essa ação, ok? Que vai ser bom porque então nós vamos para falar de volta para ela e dizer-lhe para virar-se sobre. Há outras coisas que podem ser definidas aqui, como:

Que tipo de evento que você deseja enviar esta ação? E você pode realmente defini-lo por isso não há argumento, ele simplesmente envia botão cartão de toque sem argumentos. Mas aqui nós queremos que ele tem o argumento do remetente, o botão enviar esta mensagem. Você pode até mesmo enviar o evento de toque junto,

mas quase nunca faço isso - um décimo de um por cento do tempo. Então aqui eu vou ter o remetente. Então, quando eu clique em Conectar, cria-se um novo método. E esse método é ligado até que o botão. Na verdade, você vê este pequeno círculo em volta? Se eu mouse sobre ele, ele irá mostrar-lhe que é o que é

conectado a. OK? Portanto, este é apenas um método bastante normal para o futuro bem aqui. O tipo de retorno, ação IB, isso é realmente typedef vazio. Este método realmente retorna vazio. A razão que Xcode coloca acção IB há

e ação IB do typedef de anular, é apenas para que possa dizer quais métodos são alvo de ação de modo que ele pode fazer coisas como esta. OK? O mouse over. Mas o compilador ignora. O compilador vê-lo como nulo porque é typedef de urinar.

É puramente uma coisa Xcode a esta coisa acção IB. E então você pode ver este método tem um argumento, que é o remetente. Isso é o botão de nos enviar esta mensagem. E está indo para enviar esta mensagem a cada vez um toque vai -se dentro do botão.

Toque-se para dentro, certo? Esse foi o evento. Então isso é quando ele vai para enviar esta mensagem. Então, isso é perfeito. Isso é o que queremos. Assim, cada vez que isso acontece, o que nós queremos fazer?

Bem, nós queremos flip o cartão. OK. Então, vamos começar por apenas virá-lo para trás. E a maneira como vamos fazer isso é que vamos para criar uma variável local chamada "imagem do cartão." OK. E você notou que estava tentando me ajudar a escrever lá, e você vai ver um monte de ajudar aqui.

E a imagem UI é uma outra classe em iOS, tudo bem, assim como o botão UI é uma classe. imagem UI é a classe, como você pode imaginar, armazena uma imagem. Poderia ser uma imagem JPEG, poderia ser um GIF animado, poderia ser uma imagem TIFF, qualquer que seja. OK? Portanto, é muito poderosa classe de retenção de imagem.

E tem um método de classe chamado de "imagem com o nome" e você dar-lhe uma string como parte dianteira do cartão ou cartão de volta, certo? E ele vai olhar na biblioteca de ativos e dar uma imagem da resolução direita, dependendo se ele vai para ser ir - na verdade, ele vai te dar uma imagem com ambas as resoluções.

E, em seguida, dependendo de onde você exibi-lo, ele vai, você sabe, escolher a resolução correta, se é em um retina ou não. Então, isso é legal. Temos a imagem. Então, agora nós apenas estamos indo para dizer o botão para definir esta como a sua imagem de fundo, em vez de tudo o que está nele agora.

Então, para falar com o botão, nós fazemos abrir remetente colchete. Certo? Você vê que o remetente é o botão enviar-nos esta mensagem. OK? Conjunto. Ok, eu vou começar a digitar fundo set. E você vê como eu começar a digitar, Xcode está sugerindo

para mim o que eu poderia querer. Agora, ele sabe que o remetente é um botão de interface do usuário, por isso só está sugerindo métodos botão aqui que começam com o conjunto B - definir a cor de fundo, definir imagem de fundo, e definir limites. OK? Repare que eu também estou recebendo alguma ajuda na parte inferior.

Veja, isso não é legal? Um pouco de uma ou duas linhas de ajuda? E eu poderia clicar neste link e ele me levaria a documentação. Nós não vamos fazer isso por razões de tempo. Mas eu também pode simplesmente clicar em um e ele pega que um

e imediatamente seleciona o primeiro argumento. Então, eu posso tomar isso. OK? Então, eu vou fazer isso. imagem do cartão. E observe aqui quando eu digito CA, há um monte de coisas que começam com CA que poderia ir lá.

Mas Xcode é muito inteligente. Ele sabe que uma variável local é muito mais provável que você quero aqui do que todas essas outras CA - funções que começam com CA. Então ele seleciona automaticamente que para mim. E se eu guia atingido, a propósito,

ele vai escapar, basicamente, completa ele. [Inaudível] E se eu acertar outra guia, ele vai por aqui. Esta pequena coisa de quatro estado é apenas o que eu estava falando sobre onde você pode definir isso para o estado destacado, ou o estado, ou estado desativado selecionado. Nós apenas estamos indo para fazer o normal,

ou estado de este botão padrão. OK? Então, nós estamos definindo a imagem de fundo para este botão. E também precisamos definir o título, porque nós não queremos para ver que ás de paus quando vire-o para trás. Então, eu estou indo só para configurá-lo para isso.

OK. Essa é a cadeia vazia. Eu também poderia dizer nada lá. OK. Mas eu estou dizendo cadeia vazia apenas para ver o que string vazia parece. Então, na verdade, se executar este, comandar três. Ok, vamos tentar isso.

Oh, cool. [Inaudível] Então lá vai. Portanto, há uma versão em miniatura do mesmo. OK. Então aqui está o nosso cartão. E se eu clicar sobre ele, oh sim, ele vira. Sim. logotipo Stanford com a árvore. Mas agora se eu clicar, ele não faz outra coisa;

ele sempre vira para trás, que é exatamente o que o nosso código faz, certo? Então, isso é bom. Então, vamos corrigi-lo para que ele vira para os dois lados. OK? E eu vou fazer isso, dizendo se o - na verdade, eu vou fazer outra coisa primeiro

para tornar este código um pouco mais simples é, ao invés de ter essa variável local, eu posso simplesmente tomar este e colocá-la bem ali. OK? E isso é muito comum para fazer isso. E se eu queria envolvê-lo, ele irá quebrar automaticamente se eu fizer isso muito curto.

Mas eu também pode colocar um retorno lá. E quando eu faço, olha o que ele faz com os dois pontos. Veja como ele linhas os dois pontos acima? Ele sempre vai fazer isso. Se você pressionar o retorno no meio de um envio de mensagem que tem vários argumentos, ele irá alinhar os dois pontos

-se de todos os argumentos. Muito legal. Assim você pode ver todos os argumentos alinhados à esquerda e à direita. Então, eu vou verificar para ver se o título atual - bem, que é um método de botão - se é uma string. Se esse comprimento, tudo bem, é diferente de zero, ok -

de modo que é o teste lá para ver se o comprimento diferente de zero - que é uma forma legal de fazê-lo, porque isso vai trabalhar Se o título do botão é nulo ou é se a cadeia vazia. Porque o título do botão começa nulo. Se você não configurá-lo para qualquer coisa, ele começa nulo. Então, aqui com uma linha de código Eu verifiquei tanto o inicial

estado, possivelmente - não no nosso caso porque nós definir o título à Um clube - mas no seu caso pode ser. Então vamos defini-lo como uma coisa, então vamos configurá-lo para a outra coisa. Por isso, só queria definir isso para isso. Tudo certo?

Portanto, se há um título no botão, em outras palavras, tem o ás de paus, então nós vamos para mudar para a parte de trás. E se não há nenhum título no botão, então nós vamos para voltar para a frente. OK? Ás de clubes.

OK? Agora, quando corremos, o nosso cartão vai virar ambos os sentidos. OK? Então, realmente simples de ligar coisas em seu controlador para fazer o que quiser. A próxima coisa que vamos fazer é na - Ok, eu vou lhe mostrar muito rapidamente aqui. Se você mantenha pressionada a tecla de opção, uma chave muito importante,

Você vê como ele coloca um ponto de interrogação e começa a destacar coisas? Isso vai permitir-lhe fazer a transição na documentação. Então, se eu quiser saber mais sobre este título atual, se eu acertar opção, clique sobre ele -

veja, eu recebo um pouco de ajuda aqui. É uma propriedade. É somente leitura, é nonatomic. By the way, se você ver "reter" na documentação, que é o mesmo que "forte". OK? Reter é o mesmo que basicamente forte.

Pouco de descrição aqui, mas também hiperlinks. E se eu clicar em um desses links, como este, leva-me para a documentação. Esta é uma janela separada aqui. E você pode navegar nesta documentação. Você realmente quer se familiarizar com tudo isso.

Eu realmente não posso mostrar tudo para você hoje para limitações de tempo, mas você pode fazer coisas como a pesquisa, como eu posso ir encontrar o botão UI aqui. OK. Não há botão de UI. Eu poderia rolar para baixo e vá para, por exemplo, imagem de fundo conjunto ou imagem de fundo definida

para o estado, o que acabamos de ver. Talvez eu clicar para ir imagem UI. Você vê tudo isso. Há agradáveis ​​descrições da classe no início e, em seguida, todos os métodos, etc., etc. Então, definitivamente quer para se tornar um mestre da referida documentação.

Você pode também opção de clicar duas vezes sobre coisas e ele vai lhe enviar direto para a documentação. Se você não quiser tirar o pouco de ajuda de um primeiro, você pode ir em linha reta. Então opção é a chave para isso. Vamos em frente - tudo bem.

Note-se que este pequeno espaço na parte inferior aqui apareceu quando executou o aplicativo - você vê isso? Este é o depurador do lado esquerdo, e este é o console à direita. OK? E você está definitivamente vai estar usando o depurador eo console tanto nesta classe.

E, na verdade, eu poderia ter tempo para fazer um rápido - mostrar-lhe como fazer o console. Mas de qualquer maneira, você pode escondê-lo, arrastando-o para baixo ou também clicando essa coisa [inaudível]. Tudo certo. Portanto, a próxima coisa que vamos fazer é que vamos

colocar um pouco de etiqueta em nosso UI que conta os flips. OK? A pouca coisa incrementais que incrementa cada vez que há um flip. E fazemos isso, indo de volta para aqui e agarrando-nos um rótulo. Assim, uma etiqueta é um pedaço só de leitura do texto, o texto não editável.

E eu só vou arrastá-lo aqui e colocá-lo no canto inferior esquerdo. Vou dar um duplo clique sobre ele para chamá-lo de "vira cólon zero." Isto é o que eu quero que ele se parece quando a minha UI primeira lança. Agora aqui, eu nunca vou estar tocando neste e causando uma mensagem a ser enviada como o botão;

é o contrário. Meu controlador quer falar com este e dizer-lhe quando os flips muda o tempo todo. OK? Então você pode pensar que você iria arrastar do seu código resume a isto vira, mas, infelizmente, você não fazer isso. Você ainda mantenha o controle e arraste a partir daqui.

Mas, em vez de arrastá-lo para baixo em sua área de aplicação, você arrastá-lo para a área de interface, porque você está indo para criar uma propriedade que conecta a esse rótulo basicamente. Então nós fazemos isso. Recebemos uma coisa aqui.

Ele está nos pedindo um pouco diferentes questões: "Qual é o nome desta casa?" Vou chamá-lo de "vira rótulo." OK? Observe que esta propriedade é fraco. OK? Quando clico ligar, ele vai fazer uma propriedade aqui e vai ser fraco.

Esta é a primeira vez que vimos fraco contra forte. A razão pela qual este é fraco é porque esta etiqueta é realizada fortemente pelo próprio ponto de vista. Então, nós não precisa ter um ponteiro forte para isso, para mantê-lo na pilha. A vista vai.

E se este rótulo nunca deixa a vista, ele vai ficar limpo para fora do heap. E esta propriedade - este ponteiro para ele - vai se definir a zero, que é exatamente o que queremos. Porque se isso vira rótulo não está no ponto de vista, não queremos estar atualizando-a e enviando mensagens para ele.

Portanto, é um grande uso de fraco aqui. Este é propriedade normal que você está acostumado a excetuar para talvez esta tomada IB. Isso é apenas como a ação IB. É uma coisa sem sentido o compilador ignora que Xcode está usando.

OK? Para que ele possa fazer isso - mostrar o que ele está conectado quando você passa o mouse sobre ele. OK? By the way, você pode ver todas as ligações por também clicando com o botão direito sobre as coisas. Então aqui eu apenas para a direita clicou com o botão e você pode ver suas conexões.

Se você quiser mudar o nome - como se eu não gosto botão de cartão de toque, eu quero mudar o nome a alguma coisa, você não pode simplesmente mudar o nome infelizmente. Você tem que ir aqui, clique com o botão direito, usar essa pequena coisa para desligá-lo, e, em seguida, controlar a arrastar novamente.

OK? Todo mundo tem isso? É lamentável. Seria muito bom se Xcode poderia rastrear que, para você, mas não pode. Então, se você quiser mudar o nome de alguma coisa, você tem que desligá-lo aqui clicando com o botão direito sobre ele,

e depois controlar arrastar um novo e definir o nome dessa maneira. Você também pode clicar com o botão direito sobre este rapaz e ele irá mostrar-lhe todas as ligações para seu controlador. Abre esta janela. E eu posso ver o rótulo. Entende? Eu estou passando o mouse sobre o botão.

Rótulo. Há também esta pequena propriedade aqui, que é algo que você não tenha visto, que é basicamente uma propriedade que aponta a toda a vista do seu controlador. Portanto, esta é as conexões para seus controladores. Veja, ele diz que "vista controlador de jogo de cartas"?

OK? Então, isso é um clique-direito. Estou botão direito do mouse aqui. Tudo certo. Então, como é que vamos fazer este trabalho vira rótulo? Vamos colocá-lo de lado por um segundo. Não vamos pensar sobre isso.

Vamos, em vez fazer outra propriedade. Propriedade. Que é nonatomic, que é só ir para ser um inteiro, que eu vou chamar de "contagem de flip." OK? contagem Então aleta é apenas um número inteiro que está acontecendo para manter a contagem de flips. E assistir a este.

Alguns mais espaço aqui. Vá ali. Eu só vou descer aqui e dizer contagem self.flip plus plus. OK? Agora, isso chamar o setter ou o getter para Flip contam? Ambos. Exatamente.

Que está chamando tanto o setter e getter. É chamar o getter para obter a contagem de aleta, então é mais plussing-lo; e então ele está chamando o setter para configurá-lo de volta. OK. Então, isso é uma espécie de forro funky código certo lá. Isso é o mesmo que dizer contagem self.flip igual self.flip

contar mais um. Por isso é chamar o getter e setter. OK. Então, agora nós temos essa contagem agradável flip. É manter o controle da contagem; como é que vamos gancho que se a esta coisa aqui? O que eu vou fazer um pouco maior, pelo caminho.

OK. Como podemos ligar-se que para que diz vira cólon um, vira cólon dois, vira cólon três? Bem, vamos fazê-lo usando o setter para a contagem flip. OK? Então, normalmente um setter para contagem de aleta ficaria assim. OK? E aqui está outro grande uso de setters e getters, que é para manter UI em sincronia com uma propriedade.

E eu vou fazer isso, dizendo rótulo self.flips - vira Label.Text iguais - oops, desculpe. É difícil digitar em pé. É igual a seqüência de NS, string com o formato, que você já viu antes, vira cólon por cento contagem D self.flip. OK? Então agora valer cada aleta de tempo é alterado vamos

para atualizar a interface do usuário. Faz sentido? Qualquer dúvida sobre isso? OK. Então, vamos correr. OK. Aqui está a nossa coisa. Então clique, vira, atualizações de contagem de aleta.

Virar, flip, flip, flip. E voltando a trabalhar, ea contagem de aleta é manter o controle de quantos flips que estamos fazendo. OK? Assim você pode ver este material é realmente simples para conectar-se. OK? E, você sabe, quando você chegar em construção até aplicações complexas,

porque você está sempre indo para usar esses mesmos mecanismos com a ação alvo e pontos de venda e você vai estar usando setters e getters para manter as coisas em sincronia, ele vai ser fácil para as pessoas para entender como o código funciona. Eles sabem onde procurar para ver onde atualizar UI acontece,

etc. Eu vou fazer uma outra coisa aqui. Tome um minuto e mostrar-lhe ns Login. OK. Eu lhe disse que você poderia registrar algo no console. Então, vamos fazer cada vez esta coisa muda, vamos fazer um registro NS. Então é só uma função C.

E você dar-lhe uma cadeia de formato como printf. Então eu vou dizer contagem aleta equivale à porcentagem de contagem V self.flip. OK? Então você só colocar esse registro NS lá, e agora, quando corremos você vai vê-lo no console. Ele vai vir para cima quando eu clico, e vai para dizer o que aconteceu aqui.

By the way, é claro, eu posso fazer isso mais amplo. E voltar para o simulador. Vamos ver. OK. Assim, o registo NS - maneira impressionante para depurar. OK? Às vezes, muito mais fácil de configurar um ponto de interrupção e então quando você chegar lá à procura

as variáveis ​​e outras coisas. Ele só imprime o que está acontecendo e você pode vê-lo. Especialmente na UI coisas às vezes são animado, elas estão acontecendo ao longo do tempo. Às vezes é difícil definir um ponto de interrupção no meio de uma animação para ver o que está acontecendo.

Mas se você fizer alguns registros NS, você pode tipo de ver como as coisas progridem. Tudo certo. A última coisa que eu vou mostrar-lhe aqui é como para adicionar uma nova classe para a sua aplicação porque você está indo a necessidade de fazer isso.

Você vai adicionar quatro classes para isso. OK? Você vai começar com isso, ok, e então você está indo para adicionar quatro classes - cartão, deck, etc. E a maneira de adicionar uma classe é você - e, de fato, a maneira que você adicionar qualquer arquivo para o seu projeto - é que você vá para o menu Arquivo, Novo arquivo.

OK? E há todos os tipos diferentes de coisas que você pode adicionar aqui, arquivo de banco de dados, arquivos de esquema e tudo. Mas você quer que esta classe de Objective-C superior esquerdo. OK? Aqui você está indo só para digitar o nome da classe. Assim, por exemplo, se eu estou indo para adicionar cartão

e o nome da superclasse. OK. Se você estiver fazendo cartão de jogo, você pode digitar cartão aqui. Ele não tem que ser algo que é escolhido a partir dessa lista, ok, que são os iOS. Então aqui eu vou fazer o cartão. Eu poderia colocar o cartão aqui.

Ele está perguntando onde guardar isso. Eu poderia colocá-lo direito no mesmo lugar que o meu controlador de jogo de cartas é, você vê? Mas eu sou realmente um grande fã de colocar o modelo em seu próprio diretório. Então você usaria nova pasta aqui.

Vamos criar como um diretório de modelo, e que cria um diretório modelo aqui. Há um controlador, aqui está o diretório do modelo. E assim criar. Então, isso vai criar cartão de ponto H e M. Aqui está dot cartão H e M, bem, versões tipo de branco deles.

Você pode alternar entre eles aqui. Observe que, se eu mudar a esquerda, as mudanças certas para corresponder. Entende? Mudar isso, isso corresponde. Isso é porque eu tenho homólogos escolhido aqui. Se você vai para manual e escolher este arquivo manualmente,

então ele não vai estar fazendo mais que a magia. Mas você pode sempre voltar para homólogos e vai mantê-los em sincronia. OK. Então você pode ter - algumas pessoas como o seu arquivo de cabeçalho à esquerda, alguns à direita, o que for. Além disso, observe aqui seria bom

se eu também pode agrupar essas coisas no navegador. E eu posso por tê-los selecionado, clique com o botão direito novo grupo. Diga modelo. Bem aqui. E agora eu colocar o meu modelo em seu próprio pequeno lugar certo aqui. Eu até posso mover esta ao redor, colocá-lo aqui em baixo, qualquer que seja.

Eu poderia colocar todos os meus quatro classes lá. É possível vincular este grupo para o sistema de arquivos. Na verdade, se você apenas clique em um arquivo e abrir o inspector sobre ele aqui, você pode ver que ele tem este local onde você pode especificar se é um caminho absoluto, ou relevantes para o grupo que se encontra, ou o que quer.

Assim, você pode controlar isso. E é isso. Então eu acho que isso é tudo que você precisa fazer sua lição de casa. Você só vai para digitar todo o seu código aqui para cartão e adicionar seus outros três queridos. Escreva tudo o que o código em.

E então tudo que você tem a fazer é fazer esse cartão, em vez de mostrar ás de clubes o tempo todo, precisa passar pelo convés, ok? Há um detalhado trabalho de casa escrever-se destacado. Ele tem todos os tipos de sugestões e ajuda, e diz-lhe sobre o que as tarefas necessárias são,

e critérios de avaliação, e todas essas coisas. Então, definitivamente ler aquela coisa em detalhes, ok? Não pule esse material e apenas tentar ir direto para fazê-lo. E se você tiver dúvidas, eu estarei aqui. É isso aí. >> Para mais informações, visite-nos em Stanford.edu.



Video Description

This is the second lecture of the course as it was published by Stanford University. It has Creative Commons rights.