 [Música] 
 >> Universidade de Stanford. 
 >> Tudo bem, então bem-vindo ao Stanford CS193p, 
 outono do ano letivo 2013-14. 
 Esta é a nossa primeira palestra e vamos 
 estar cobrindo o desenvolvimento de aplicativos 
 para iOS, tão especificamente iOS7. 
 A palestra de hoje tem uma espécie de primeira parte e uma segunda parte. 
 A primeira parte é um pouco de logística. 
 A segunda parte é que eu vou mergulhar 
 para o material do curso, pois há uma grande quantidade para cobrir e assim, 
 precisamos começar a cobri-la. 
 [Pausa] Então, o que vou aprender neste curso? 
 Eu acho que você sabe o que você vai aprender neste curso. 
 Você vai aprender a construir aplicativos interessantes, ok? 
 iOS é uma plataforma muito legal para aplicações de construção, 
 você provavelmente já sabe disso. 
 Os aplicativos parecer legal, eles têm animação. 
 O que é muito legal é que eles estão em seus bolsos 
 assim você pode chicoteá-los e mostrar-lhes a seus amigos. 
 Você não tem que enviá-los para um site ou ir buscar um computador. 
 É também muito fácil de desenvolver aplicativos realmente poderosas 
 num muito curto espaço de tempo, como você vai encontrar. 
 Este curso é de apenas 10 semanas de duração, 
 e enquanto isso é Stanford, eu sei, você é tudo, na verdade, 
 realmente bons programadores e todos os que, ainda, 
 10 semanas não é muito tempo, então quando chegamos ao fim, 
 você vai ver que ele é uma plataforma muito alavancada 
 para construir coisas. 
 E, você sabe, a comunidade é muito vibrante, 
 ser capaz de distribuir seus aplicativos via App Store 
 e não ter que colocá-los em uma caixa e colocá-los em uma prateleira 
 em uma loja, é realmente um grande, grande diferença quando se trata 
 a comercialização de um produto. 
 Ok? E você vai, você vai ver isso. 
 A segunda coisa que você vai aprender 
 neste curso, porém, é aplicação no mundo real, 
 um monte de coisas de ciência da computação que você está aprendendo 
 em outras classes. 
 Ok? Então, nós vamos estar fazendo networking, 
 vamos fazer vários segmentos, 
 nós vamos estar fazendo todos os tipos de gráficos, 
 nós vamos estar fazendo animação, 
 vamos fazer os bancos de dados orientados a objetos, 
 vamos fazer todas essas coisas de verdade, ok? 
 Você vai ver o que parece 
 gostaria de aplicar todos os conceitos de ciência da computação, especialmente como 
 combiná-los em uma plataforma do mundo real, 
 onde você está fazendo aplicações reais, ok? 
 E algumas, muitas dezenas 
 de meus ex-alunos têm enviado seus aplicativos 
 na App Store e você pode muito bem também. 
 Ok? Portanto, este é, na verdade, este é um bom curso para tipo de combinar 
 ou sintetizar todas as coisas que você aprendeu em um monte 
 de suas outras aulas de informática e tocá-lo 
 contra o mundo real. 
 Ok? Os pré-requisitos para esta classe são super super importante, 
 ok? 
 Este, é apenas a chave para ter certeza de que esses pré-requisitos 
 e realmente pensar muito, se você não fizer isso, se você quer 
 para dar atrás, esta classe. 
 CS 106 A & B, ou, ou CS16x são absolutamente necessários, ok? 
 Se você não tem isso, ou equivalente, com certeza, 
 nem sequer pensar nisso. 
 O segundo requisito que eu adicionei neste trimestre, 
 com base na experiência, é CS107 ou CS108, que é grande, 
 a propósito, se você está tomando CS108, 
 você realmente estará pronto para esta classe. 
 Ou mesmo CS110, e parte 
 da razão que eu estou exigindo essas aulas extras é apenas 
 então você está mais distante ao longo da curva de experiência de programação 
 porque esta classe é um monte de programação, e então para aqueles 
 de vocês que estão acostumados a um monte de programação, 
 você, você está acostumado a isso. 
 Mas para aqueles de vocês que não estão é meio como, uau, 
 fazer um monte de programação aqui. 
 Vai ser um pouco de desequilíbrio. 
 Então, é por isso que eu exigia que todos esses. 
 Agora, se você já fez um estágio de verão 
 de que você tenha feito alguma programação ou algo parecido, 
 isso é definitivamente um substituto para o CS107, 108, ou 110, certo? 
 Ou se você tiver feito alguma outra classe CS que é ainda mais avançado 
 além destas, tudo bem também. 
 Você apenas tem que entender que esta classe é, você sabe, 
 uma classe de programação, há uma grande quantidade de programação. 
 E o mais importante, você tem que realmente ser confortável 
 com programação orientada a objeto. 
 Então eu coloquei um monte de termos aqui, como mensagem 
 e variável de instância e superclasse e subclasse, 
 se você não sabe estes termos como a palma da sua mão, 
 que vai ser difícil para você obter essa classe, 
 porque eu vou estar jogando esses termos 
 a esquerda, direita e centro. 
 iOS7 é totalmente orientada a objetos. 
 Ok, toda a estrutura, 
 o design da coisa, é orientada a objetos. 
 Assim, você só tem que saber que, e se você não sabe que, 
 você definitivamente quero pegar isso primeiro. 
 Ok? Tome CS106a & b equivalente em primeiro lugar, 
 e em seguida, obter um pouco mais de experiência em programação 
 e então você está pronto para ir. 
 Ok? Vamos, você vai estar escrevendo aplicações nesta classe 
 com dezenas de classes que você vai escrever 
 pelo quinto, sexto semana para que, você sabe, 
 se o maior aplicativo que você já escrevi tenho 3 ou 4, 
 ou 5 classes em que, oh, isso vai ser um passo para cima. 
 Ok? As atribuições, temos este tarefas semanais 
 para os primeiros seis ou sete semanas, 
 e então você tem um projeto final no final. 
 Todas as tarefas de casa detalharam write-up 
 da tarefa desejada e o que estamos avaliando sobre. 
 E eles também têm sugestões de lá, porque eu não estou tentando 
 fazer as tarefas de casa ser muito, muito difícil, 
 e todas as tarefas de casa também estão diretamente re [pausa], 
 eles são, basicamente, reforçando o que foi ensinado na aula 
 nessa semana, eles não são um bando 
 material novo de forma aleatória para aprender. 
 Sou um grande crente em uma metodologia de ensino, o que é que eu vou 
 para falar sobre um conceito, através de slides, e então eu vou 
 para mostrar-lhe que por demos-lhe, 
 realmente escrever um aplicativo que não, então eu vou 
 pedir-lhe para fazê-lo na lição de casa. 
 Então, isso é três vezes que você vai 
 para ver todas as coisas muito bem nesta classe. 
 No final de tudo, você vai saber como fazê-lo. 
 Ok? E você vai se sentir confiante 
 e experiente para fazê-lo. 
 Assim, o dever de casa é tudo sobre isso. 
 É sobre apenas fazendo o que você me viu fazer em sala de aula e falar 
 sobre a classe e aplicá-lo. 
 Tudo bem. Agora eu estou indo para ir muito brevemente sobre o que está em iOS, 
 Acho que a maioria de vocês sabem o que está no iOS, 
 espero que todos vimos um dispositivo iOS ou você tem um 
 em seu bolso, eu aposto 90 por cento do que você faz nesta sala, 
 mas vou tentar resumi-lo, 
 isso é realmente difícil de fazer, porque eu vou tentar 
 e fazê-lo em quatro minutos ou menos, ou cinco minutos, 
 e é tão grande que, eu quero dizer, eu poderia ter duas palestras 
 onde eu apenas falar sobre todas as coisas diferentes 
 e apenas resumi-los. 
 Então, isso vai tentar agrupá-los em algum tipo 
 de grupos sensíveis para que você tenha uma ideia do que está lá 
 do ponto de vista de desenvolvimento, então, quando saímos 
 e começar a fazer tudo isso, então você vai começar a perceber, 
 e uma vez que você aprender a olhar na documentação que você vai ver, 
 Oh, olhe para todas as coisas que lá, e você vai descobrir isso. 
 Portanto, esta é apenas uma visão geral de alto nível. 
 Então, eu, eu usei esta divisão em estes quatro, tipo de grupos. 
 OS Core, que é o material que está próximo ao hardware. 
 Serviços básicos, o que é um em cima do que orientada a objetos, 
 esse tipo de torna 
 assim você sempre está programando uma camada orientada a objetos. 
 Mídia, porque esses dispositivos são, basicamente, iPods com um telefone 
 neles ou com uma grande tela sobre eles, 
 mas a mídia é muito importante para estes dispositivos, 
 e, em seguida, finalmente, Cocoa Touch, que é a camada de interface. 
 Ok? De botões e todos os switches, coisas desse tipo. 
 Então vamos falar sobre o que está em cada uma dessas camadas, tipo, 
 pouco roçando a superfície do que é nessas camadas. 
 Na camada de núcle o do SO, perto da ferragem, um núcle o Unix. 
 Ok? Este é um sistema operacional Unix neste dispositivo. 
 E simulada BFD-base, e assim que você começa tudo que você conseguir 
 com Unix. 
 Você está ficando tomadas e você está ficando sistema de arquivos, 
 permissões, todas essas coisas, além de que você está recebendo um monte 
 de outras coisas que é meio específico para um dispositivo móvel 
 assim, como gerenciamento de energia, e acesso da corrente chave 
 para gerenciar o tipo de segurança das coisas. 
 Bonjour, que é este tipo de rede, 
 encontrando outras coisas na rede. 
 Assim, ele tem todas essas coisas, 
 É um poderoso sistema operacional subjacente. 
 Mas tudo isso API ou a maior parte dela é em C, 
 e nós queremos ser a programação tipo 
 de puramente orientada a objetos camada. 
 Então, nós vamos estar operando principalmente quando estamos falando, 
 tocando aquelas coisas na camada de superfícies Core. 
 Portanto, esta camada tem coisas como linguagem, coisas que, 
 esse tipo de tornar a linguagem mais poderosa, como matrizes 
 e dicionários, e cordas e coisas assim, 
 além de ter formas de orientação a objetos para acessar o sistema de arquivos, 
 tem formas de orientação a objetos para descobrir a localização GPS 
 do seu dispositivo, por exemplo. 
 Ele tem maneiras de fazer multithreading. 
 Tudo isso que você quer ser capaz de fazer, mas você quer 
 ficar em um tipo orientada a objeto de mentalidade 
 como você está fazendo todos eles. 
 Há uma enorme camada, camada de fundação não 
 em serviços básicos para fazer isso. 
 Na camada de mídia, não dormir sobre esta camada, 
 camada realmente importante, você tem víde o aqui, 
 você tem de edição de víde o, você tem imagens, é claro, 
 que ele pode exibir, é incrivelmente poderoso áudio 
 para fazer áudio 3D, se você tem jogos, 
 você pode fazer os lutadores tailandeses sentir 
 como se eles estivessem rasgando por você e outras coisas. 
 Todas as coisas que está aqui. 
 Isso faz parte de, a parte de iOS 
 que realmente eu não posso cobrir em um monte de profundidade. 
 Eu só vou tentar deixá-lo saber que ele está lá 
 e você vai mergulhar para baixo, dependendo de que tipo 
 de aplicações, mais tarde em sua vida, você quer construir. 
 Mas há uma quantidade enorme lá. 
 Esta é uma fundamentalmente, um dispositivo multimídia, obviamente, 
 e então, Cocoa Touch é para onde estamos indo 
 passar a maior parte do nosso tempo. 
 Este é o lugar onde você vai ser a construção de botões e sliders 
 e campos de texto, conversando uns com os outros, e animação acontecendo, 
 coisas deslizando para dentro e para fora, e, você sabe, 
 desaparecendo e desaparecendo dentro 
 Se você deseja obter o, uma imagem da câmera 
 do usuário, você pode fazer isso. 
 Coisas como localização para que você esteja aplicativo pode ser executado 
 em muitos países do mundo e acima de suas vendas por fazer isso. 
 Um mapa kit inteiro para fazer todos os mapas em 3D 
 que você provavelmente já viu em iOS7 e todos 
 esse material é tudo lá dentro. 
 E, há ainda uma visão 
 lá isso é um navegador web inteiro em um pequeno retângulo 
 que você pode simplesmente por para a direita em seu aplicativo. 
 Então, essas são realmente objetos de alto nível, e vamos 
 para ser realmente mergulhar neste camada, certo? 
 Portanto, este é realmente o primário. 
 E ele é chamado Cocoa Touch, porque a API 
 aqui foi originalmente desenvolvido para Mac OS X, 
 e foi chamado de cacau, e, claro, em seguida, quando foram 
 para iOS, eles se adaptaram, e um monte de API é compartilhada 
 entre as duas plataformas, e, na verdade, 
 se você desenvolver um aplicativo iOS e então você diz, um dia, oh, 
 Eu quero desenvolver um aplicativo para o Mac usando Cocoa, 
 isso vai ser muito similar. 
 Ok? Você vai ser realmente, ele vai parecer familiar. 
 Então, Cocoa Touch, obviamente, 
 é a versão touchscreen de que, de cacau. 
 Ok? 
 Esta tecnologia, Cacau, tem sido em torno de um longo tempo, ok? 
 Provavelmente quase 30 anos, acredite ou não. 
 Do mesmo antes de a Apple adquiriu para fazer Mac OS, 
 que é hoje o Mac OS X, e por isso é um API muito maduro, ok? 
 E está muito bem pensado, assim, especialmente se você for 
 com o fluxo do mesmo, é muito fácil 
 para construir coisas realmente poderosas. 
 Então, isso é o que está lá. 
 Então, vamos falar sobre as ferramentas que usamos como programadores, 
 como desenvolvedores, para construir esses aplicativos, ok? 
 E eu tenho dividido aqueles em tipo de quatro seções aqui. 
 Uma é as ferramentas, as ferramentas de programação reais, 
 E o que é ótimo, nesta plataforma, 
 é o ITA • s praticamente uma ferramenta único para todos. 
 Ok? Há esta ferramenta, XCode 5, 
 e tudo está lá. 
 Você é depurador está lá, toda sua edição de código-fonte, 
 seu controle de código fonte, o edifício UI, 
 tudo está em este aplicativo. 
 Há um pouco adjunto lá, os instrumentos, o que é que as coisas 
 como o perfil de seu aplicativo e coisas assim. 
 O uso de memória, esse tipo de coisas, mas você é realmente, 
 tudo estava dentro XCode 5, que é muito bom, porque, você sabe, 
 quando você estiver depurando, você está normalmente editar o seu código 
 ao mesmo tempo, para trás e para frente, para trás e para frente, 
 você está indo para diferentes aplicações e tudo o que seria uma dor 
 no pescoço, e eles realmente fizeram um bom trabalho 
 de arranjar para que ele está compartilhando o espaço na tela 
 entre todos estes diferentes tarefas que você precisa fazer. 
 Então essa é a principal ferramenta, XCode 5, você deve tudo, 
 logo após essa classe, se quiser, ir até a loja Mac App, 
 não a loja em seu dispositivo iOS, a Mac App Store 
 no seu Mac, e baixar este. 
 É gratuito, disponível, saiu sexta-feira passada, 
 e você pode baixá-lo, instalá-lo, e, você sabe, 
 começar a brincar com ele. 
 Alguns de vocês já pode ter usado o Xcode, como em CS106, 
 levante a mão se você já usou o Xcode antes de qualquer coisa. 
 Ok, então dois terços ou mais, três quartos de você. 
 Então, você está indo para ser usado nele. 
 Você só vai começar a usar o Xcode agora 
 desenvolver para iOS, certo? 
 Há uma nova linguagem para você aprender, C objetiva, 
 é uma espécie de linguagem de aparência engraçada, tudo bem, 
 seus colchetes e dois pontos, sem parênteses nas chamadas de mensagens, 
 que é um pouco estranho para as pessoas que estão chegando 
 de Java ou C + + ou qualquer outra coisa. 
 Os argumentos não são postas em parênteses ou qualquer outra coisa, 
 e eu vou mostrar-lhe tudo sobre C objetiva, 
 Eu não espero que você saiba nada sobre isso nos próximos, 
 e se você sabe Java e C + +, o que você deve 
 se você tomou CS106A & B, então C objetivo não vai 
 para ser um grande salto para você. 
 É um pouco idioma diferente, 
 É um pouco mais rápido e solto do que o Java, por exemplo, 
 e é um pouco mais, uma espécie de simples e elegante, de C + +, 
 quando se trata de coisas orientada a objetos. 
 Então, eu acho que você vai gostar. 
 Não vai. Alguns de vocês que são muito, você sabe, 
 tipo de programação correta de coisa, você ama Java, 
 pode encontrar C objetivo um pouco oeste selvagem para você, 
 mas você vai superar isso. 
 Frameworks, obviamente, qualquer grande sistema como este todos os grupos 
 de seus objetos em bibliotecas, essencialmente. 
 Nós os chamamos de Frameworks em iOS, 
 por isso há dezenas de estruturas no iOS. 
 Os dois principais que vamos ver, no início 
 do curso, são o fundamento, que é onde tudo 
 esse material serviços essenciais é, como matrizes 
 e dicionários e tudo mais. 
 E então kit UI, tudo bem, é aí que os botões e sliders 
 e todos aqueles área coisas, então essas são as duas principais, 
 mas, toda há um monte de outras, como, 
 você vê o Core Data escrito lá em cima, 
 que é o banco de dados orientado a objetos. 
 Ok? Então nós vamos estar fazendo isso. 
 Movimento Core, que é o giroscópio e acelerômetro. 
 MapKit, obviamente, os mapas. 
 E há dezenas de outros, certo? 
 E nós vamos cobrir o maior número deles que pudermos, 
 obviamente, não podemos fazer tudo em 10 semanas, 
 mas vamos fazer o máximo que pudermos. 
 E, em seguida, a última parte do desenvolvimento de aplicativo 
 nesta plataforma é uma estratégia de projeto chamado MVC. 
 Agora, isso não é exclusivo para iOS, outras plataformas de usar MVC, 
 Model View Controller, como sua estratégia fundamental design. 
 Assim como muitas pessoas nesta sala têm usado MVC em qualquer plataforma? 
 Ok, então cerca de metade, para que você saiba o que é isso. 
 Então, eu estou indo realmente para passar por cima de MVC para aqueles de vocês 
 quem não tem e eu vou passar por isso muito rapidamente, 
 porque parece que a maioria de vocês, a metade de você ter feito isso, 
 e [pausa] a principal coisa a ver em MVC aqui, 
 para aqueles de vocês que já sabem o que é, 
 é para ver como eu falar sobre isso para que quando chegarmos em iOS 
 e eu começar a dizer coisas como o seu modelo é independente da interface do usuário, 
 você saberá o que eu estou falando 
 e todos nós vamos estar na mesma página. 
 Portanto, esta é mais uma espécie de conseguir que todos nós 
 na mesma página terminologia-wise. 
 Então, MVC, Model View Controller, é, essencialmente, uma estratégia 
 para saber como organizar todas as classes em sua aplicação. 
 E o que nós, fundamentalmente, é que nós dividimos todas as classes 
 em um dos três campos. 
 O acampamento modelo, o campo controlador, ou o campo de visão, 
 e que, como você decide o que se passa em cada um desses campos, 
 bem, o modelo é essencialmente o que do seu programa. 
 Qual é o seu programa? 
 Assim, como nós estamos fazendo essa conversa MVC, eu vou falar 
 sobre a nossa primeira aplicação vamos construir 
 que é um jogo de correspondência de cartão. 
 Ok? Então, nós estamos indo para construir este jogo, tem que bando 
 de cartas na tela, como cartas de jogar, você sabe, 
 Ás de Paus e tudo isso, e você vai ser capaz 
 para ir escolher as cartas 
 e você vai ter alguns pontos, se a partida. 
 Como o terno fósforos ou o posto fósforos, ou o que seja, 
 você conseguir mais pontos, menos pontos que quer, mas você está fazendo isso. 
 Nesse tipo de aplicação, um pouco de jogo de correspondência de cartão, 
 os cartões e baralho, e até mesmo a lógica 
 para a forma como o jogo é jogado são todos UI independente 
 e no modelo. 
 Ok? 
 Assim como as cartas se mete 
 na tela é o trabalho do controlador. 
 Assim, o controlador é, é trabalho de descobrir como é que eu vou, 
 você sabe, levar este conjunto de cartas e exibi-los na tela, 
 e, em seguida, animar seu movimento e coisas assim. 
 Ok? Isso é com o controlador. 
 Assim, o controlador controla a forma como o modelo é apresentado 
 na tela, e a vista, os asseclas, 
 as classes que o controlador vai usar, 
 tipo como os blocos de construção, o Lincoln Logs, 
 Eu não sei talvez seja antes de todo o seu tempo, mas, você sabe, 
 as coisas que vamos fazer construir a nossa interface do usuário que vai usar 
 na visão, por isso, o material que está 
 no ponto de vista é bastante genérico. 
 Elementos de interface do usuário genéricos, o material 
 no controlador é muito específica de como a interface do usuário funciona, 
 e as coisas no modelo é completamente independente 
 de como você está trabalhos UI. 
 Ok? Então, fazendo MVC é saber onde as coisas vão, 
 mas também sobre como se comunicar 
 entre estes três campos e então eu vou tentar 
 e resumir como funciona a comunicação 
 entre esses campos e eu usei marcas rodoviárias, 
 você vê a linha amarela dupla e, em seguida, a linha branca tracejada, 
 de modo que é como se você estivesse dirigindo em seu carro, tente usá-los 
 como que eu tenho uma imagem de como essa comunicação aconteça, 
 onde é permitido, onde não é permitido. 
 Ok? Então vamos falar sobre o controlador de falar com a modelo. 
 Ok? Indo de que lado da estrada 
 para o lado do modelo é uma linha branca tracejada, 
 em outras palavras, você pode ir do outro lado lá, 
 você provavelmente vai querer olhar antes de ir, 
 mas você pode ir em frente, ok? 
 O controlador tem que saber tudo sobre o modelo 
 e tem que ter a capacidade completa para falar com o modelo, 
 usar sua API pública, tanto quanto ele quer, 
 porque o trabalho do controlador é apresentar o modelo 
 para o usuário usando seu ponto de vista como os seus asseclas, 
 por isso tem que ter esse acesso. 
 Então, isso é o acesso total e irrestrito o controlador tem 
 conversando com o modelo. 
 Esta é uma era de mão única, ou a seta de sentido único, 
 do controlador para o modelo. 
 E da mesma forma a partir do controlador para a vista, 
 é também a comunicação ilimitada 
 porque o controlador é responsável por falar, usando, 
 É próprios asseclas, a vista é dos controladores ' asseclas para leigos 
 a interface do usuário e todas essas coisas, 
 de modo que o controlador pode fazer o que quiser, 
 Eu coloquei essa pequena palavra tomada verde lá em cima 
 porque quando temos uma propriedade de um controlador que aponta 
 para o ponto de vista, podemos chamá-lo de uma tomada. 
 Ok? E você vai ver que na demo na quarta-feira, 
 Eu vou dizer oh, vamos criar uma tomada 
 do nosso controlador para a nossa visão 
 por isso o nosso controlador pode falar com seu ponto de vista. 
 Tudo bem? E essa comunicação? 
 Modelo para ver, nunca, e por que isso? 
 100 por cento óbvia. 
 O modelo é completamente independente UI. 
 Portanto, não há absolutamente nenhuma maneira que poderia falar com uma visão ou objeto 
 ou qualquer um em que o acampamento. 
 Porque os objetos de exibição são objetos fundamentalmente interface do usuário, 
 eles são uma espécie de genérico, 
 mas eles ainda são objetos fundamentalmente UI. 
 Da mesma forma, uma vez que os objetos de exibição são uma espécie de genérico, 
 eles não podem estar falando com qualquer modelo específico. 
 Eles precisam de um controlador para interpretar um modelo para eles. 
 Ok? Assim, nunca há qualquer comunicação desta forma, 
 é por isso É uma linha dupla amarela, 
 é por isso que estas linhas são o vermelho, é por isso que há fogo, certo? 
 Nunca atravessar essa linha, nunca. 
 [Pausa] E sobre o ponto de vista de falar de volta para o controlador? 
 Você tem esses genéricos exibir objetos, como botões, 
 eles podem falar com o controlador? 
 Bem ... sim, eles podem, mas eles têm que ter cuidado 
 porque os objetos de exibição são genéricas, 
 então eles não podem realmente saber muito sobre o controle, então, 
 que só pode comunicar de volta para o controlador 
 de uma forma cega, onde eles não sabem a classe 
 da coisa que está falando, e, de uma forma estruturada, 
 uma forma em que todos estamos de acordo, vamos comunicar desta forma, 
 entre a visão e o controlador, 
 então o que é um exemplo de uma forma estruturada? 
 Bem, um é chamado de ação alvo. 
 Assim, o controlador basicamente cai um alvo em si 
 e, em seguida, distribui uma ação, que é como uma flecha, 
 à vista e diz para a vista, tudo bem, 
 quando você faz o que faz, como se você fosse um botão 
 e alguém toca em você ou você é um controle deslizante 
 e alguém te move, me envie essa ação. 
 Ok? Assim, deste modo, o botão genérico, ou deslizante, 
 está se comunicando volta para o controlador, ele não tem idéia 
 esse controlador jogo de cartas É um ou um controlador de jogo espaço, 
 ele não sabe que tipo de controlador é, 
 tudo o que sabe é que quando acontece alguma coisa em si, 
 bum, ele envia mensagens para alvos. 
 Então isto é a maneira cega, simples, estruturada para a vista 
 para se comunicar com o controlador, ok? 
 Mas o que sobre as formas mais complicadas? 
 Às vezes, o ponto de vista, as coisas estão acontecendo na visão 
 que são as necessidades do controlador pouco complicado e 
 ser informado do que está acontecendo, 
 sincronizar o que está acontecendo. 
 E uma maneira de pensar sobre isso é estas palavras que eu coloquei aqui, vontade, 
 deveria, e fez, quando a vista é como [pausa], 
 digamos que na visão de rolagem e eu estou rolando por aí, 
 e eu quero deixar o, o controlador, alguém, 
 sei que o usuário acabou de fazer rolagem. 
 Ok? 
 Ou o usuário põe o toque e está prestes a rolar, 
 Eu quero que o controlador saiba o usuário será a rolagem. 
 Ok? Ou o usuário coloca um toque para baixo e a vista de rolagem quer 
 saber, eu deveria permitir que o usuário navegue aqui, é permitido? 
 Todas essas coisas, a própria exibição de rolagem pode não ter 
 lógica o suficiente para saber a resposta a essas perguntas, 
 então o que ele faz é que delega a autoridade 
 para responder a essas perguntas para algum outro objeto. 
 Agora ele não sabe a classe do objeto, tudo o que sabe é 
 que outro objeto pode responder a estas perguntas, vontade, deve, 
 fez, isto, aquilo ou a outra coisa, como, 
 deve permitir a rolagem, 
 se deslocar para apontar, coisas desse tipo. 
 Então, esse é o tipo de métodos que você vai ver 
 nestes protocolos de delegado. 
 Agora eu sei que CS106A & B não ensinam protocolos, a palavra protocolo, 
 quantas pessoas sabem o que significa a palavra protocolo 
 na programação orientada a objeto? 
 Veja, muito poucos de vocês, por isso vou estar ensinando isso. 
 Um protocolo é apenas uma maneira cega para falar com outro objeto. 
 Você está, você está indo, quando eu te ensinar, você vai 
 para ser como, oh sim, eu sei o que é, 
 nós realmente não chamá-lo de protocolo, ou o que seja. 
 Mas, é assim que fazemos delegação, tudo bem, 
 esta comunicação cego. 
 Além disso, outra coisa importante é 
 que as opiniões não deve possuir os dados que eles estão exibindo. 
 Eles não devem possuí-lo. 
 Em outras palavras, não deve ser uma propriedade dentro deles 
 onde essa é a verdade de que os dados. 
 E o exemplo mais fácil para isso é todas as músicas em seu iPhone, 
 em seu telefone ou o seu iPad, certo? 
 Você pode ter 10 mil músicas lá. 
 Então se você tem algum tipo de genérico exibição de lista, na sua opinião, 
 você não pode transferir todas as músicas 10000 para suas variáveis ​​de instância 
 e esperar que ele mantenha 10.000 músicas para que ele possa listar através dele. 
 A, que seria ineficiente, e B, essa informação, 
 essas músicas 10.000 pertence onde? 
 No modelo, ok? 
 Porque você é banco de dados de música é um modelo. 
 Não tem nada a ver com a interface do usuário, apenas uma lista de músicas e artistas 
 e álbuns e tudo isso, é no modelo. 
 Alguns controlador tem de olhar para esse banco de dados 
 e contar uma vista como exibir todas essas músicas, ok? 
 Então, precisamos que a comunicação aconteça aqui 
 e a vista está exibindo algum tipo de lista, 
 e você está tocando baixo e você está passando rapidamente na lista 
 e tentando ver mais músicas, 
 como é que a comunicação aconteça, e a resposta é, 
 nós temos um outro tipo especial de delegado, 
 que chamamos de uma fonte de dados. 
 Agora, a fonte de dados não fazer a vontade, fez, deveria, 
 ele vai fazer perguntas como contagem, 
 como quantas músicas estão lá? 
 E o controlador olha no modelo, 10.000. 
 Resposta à vista, há 10.000. 
 A visão torna espaço, internamente, para 10.000 coisas, 
 ele não sabe o que são, 
 move o indicador da barra de rolagem um pouco, para que você saiba 
 onde ele está, e então você começa a rolagem, folheá-lo, 
 e seu início de enviar a mensagem para o controlador, 
 dá-me os dados em [pausa] linha 150, os 10 itens seguintes. 
 Veja o que eu quero dizer? 
 E, em seguida, pressionar levemente para baixo um pouco mais, agora ele está dizendo 250, 
 Mais 10 itens, e assim o controlador vai voltar 
 ao modelo e dizendo-me dar mais, dá-me mais dados, 
 e está fornecendo-o para o ponto de vista desta forma cega. 
 Então veja como a vista é a obtenção de dados a partir do modelo 
 através do controlador, neste tipo de forma estruturada cego. 
 Ok? Isso faz sentido para todo mundo? 
 Então fonte de dados é apenas um tipo de delegado, é um tipo específico 
 de delegar para a obtenção de dados. 
 Então, você vai ver que há aulas em iOS 
 que tem uma fonte de dados, 
 e eles geralmente têm também um delegado. 
 Classes mais sofisticadas no iOS tem um delegado, a vontade, 
 fez, deve tipo de coisas. 
 Alguns deles têm uma fonte de dados, 
 isso depende se eles estão mostrando uma grande quantidade de dados ou não. 
 Agora dados simples, como se eu tivesse um ponto de vista, se eu inventei uma visão 
 para o meu jogo de cartas chamado tocando vista do cartão, 
 e ele só tem um terno e um posto, tudo bem, não vamos 
 para fazer dados de contagem em apenas por terno e rank, vamos 
 para definir essas propriedades. 
 E assim, a vista, em seguida, teria aqueles, que conjunto de dados na mesma, 
 mas não seria possuí-lo, certo? 
 O modelo ainda seria possuir o naipe e categoria, 
 a visão está apenas começando os dados para apresentá-lo. 
 Ok? Dados Tão simples podemos transferir para a vista, 
 mas é apenas para ele para exibi-lo. 
 Okay. Tudo isto contribui para o trabalho do controlador ser 
 interpretar e formatar os dados do modelo para a vista. 
 Esse é o trabalho do controlador. 
 E quando fazemos a nossa demo, eu vou estar marcando como, oh, 
 Veja, eu estou escrevendo este código, 
 isto faz com que o controlador de realizar o seu trabalho, 
 que é o de levar os dados do modelo e colocá-lo em, e usá-lo 
 para ver asseclas, colocá-lo na tela, certo? 
 Isso é o que o controlador faz. 
 E essa comunicação? 
 O modelo pode falar com o controlador? 
 Mais uma vez, obviamente, isso é proibido por lei porque o modelo não sabe nada 
 sobre UI, por isso não poderia falar 
 para um objeto de interface do usuário, como o controlador. 
 Mas às vezes as coisas mudam no modelo 
 e o controlador precisa saber sobre ele. 
 Ok, alterações de dados, um banco de dados muda 
 ou o modelo de algum banco de dados de rede 
 e alguém muda algo na rede e muda, 
 e o controlador precisa descobrir. 
 Então, como vamos fazer essa comunicação? 
 Fazemos isso usando um tipo de modelo de estação de rádio. 
 Ok? Assim, o modelo, um conceito de estação de rádio, 
 o modelo usará este conceito 
 a informação transmitida essencialmente 
 para quem está interessado, ok? 
 E os mecanismos para fazer isso 
 no iOS são chamados de notificação e valor da chave observando-se, 
 KVO podemos chamá-lo, e por isso o modelo pode simplesmente dizer, oh, 
 qualquer momento algo muda no meu modelo, eu só vou 
 para transmitir em minha estação de rádio 
 e, em seguida, o controlador simplesmente sintoniza em que estação de rádio. 
 E pode descobrir as coisas estão mudando. 
 E quando se descobre que algo muda, 
 ele vai se comunicar através da sua seta verde para o modelo, 
 e dizer, tudo bem, dá-me de que os dados que mudou. 
 Tudo bem? Será que isso faz sentido? 
 Então, no final do trimestre, 
 vamos começar a ver um pouco de como fazer a notificação de descobrir, 
 por exemplo, se os dados em que as alterações da base de dados. 
 Vamos receber uma notificação, a interface do usuário pode, então, você sabe, 
 o controlador pode, então, ir falar com o modelo para obter a informação. 
 Ok? [Pausa] Algumas pessoas têm perguntado, pode uma vista sintonia 
 para a estação de rádio? 
 Eles provavelmente poderia, mas você provavelmente não gostaria 
 para fazer isso. 
 Essa provavelmente seria uma violação da MVC. 
 Tudo bem, então, vamos fazer isso, nós temos toda essa agradável comunicação 
 e todas essas regras, e podemos imaginar a construção de algo 
 simples de usar este, mas o que se quer 
 construir um grande, app complicado? 
 Um aplicativo que tem várias telas em nosso iPhone 
 ou em um iPad que tem, você sabe, 
 três ou quatro áreas diferentes na tela 
 onde as coisas estão acontecendo, como é que vamos fazer isso? 
 Bem, vamos essencialmente para combinar múltiplos MVC de, ok? 
 Porque você, um MVC pode usar, como parte de seu ponto de vista, um outro MVC. 
 Ok? Assim, um MVC, todo um MVC, 
 pode ser um dos asseclas de alguns MVC maior. 
 Ok? E fazendo isso, e em cascata para baixo, 
 podemos construir aplicações mais e mais complicadas. 
 Então, um exemplo disso é que você pode ter o seu aplicativo de calendário, 
 e ele está mostrando a você o ano inteiro, e você clica em um mês, 
 e agora ele mostra uma tela de mês. 
 Bem vistas mês parece muito diferente do que uma visão ano. 
 Vista mensal só tem todos os dias e talvez algum círculo 
 que lhe diz onde você tem um compromisso em um dia, 
 e, em seguida, quando você clica em um dia, e agora você tem uma vista do dia. 
 Ok? E o dia está mostrando-lhe as horas 
 e que todos os seus compromissos são, e clicar em 
 em uma entrevista, e agora você terá uma visão nomeação 
 e ele está mostrando o detalhe de onde você está indo 
 e quando é, etc, ok? 
 Bem cada um desses pontos de vista, a visão de ano, a vista do mês, 
 a vista do dia, e a vista são a sua nomeação 
 próprio MVC do. 
 Ok? Mas você pode ver como os três últimos, tudo bem, são usados ​​como, 
 essencialmente, um assecla do exibição de nível superior, 
 a visão de ano, para mostrar mais detalhes. 
 Ok? Assim, a vista ano, você clica em um mês, 
 ele vai usar a exibição de mês MVC para mostrar mais detalhes, 
 por isso é parte de seu ponto de vista, ok? 
 Então, você vê isso também em iOS com os controladores da barra guia, certo? 
 Você tem a barra de abas, ao longo do fundo, eu tenho quatro 
 ou cinco coisas que você pode escolher, bem há algum MVC no topo 
 que tem quatro ponteiros para quatro asseclas, 
 que são os quatro MVC do que estão indo cada 
 para aparecer em uma barra de abas, ok? 
 Nós vamos estar fazendo isso, por exemplo, 
 em número de atribuição de dois ou três, 
 onde estaremos fazendo uma barra de abas e você vai 
 ter que fazer múltiplas MVC do. 
 Ok? Então, que, basicamente, resulta em uma imagem 
 que parece muito com isso. 
 Tudo bem? Onde você conseguiu este MVC 
 e você vê o roxo que é 
 como sob a palavra juntos lá, e ele aponta 
 para três fora do outro MVC de sua coisa vista, ok? 
 É assim que vamos construir isso, 
 que pode ser um controlador de barra de abas 
 e aqueles que podem ser os três guias. 
 Ok, e cada um é o seu próprio pequeno MVC, 
 totalmente independente, opera por conta própria, 
 nem sabe É um genérico, vista reutilizável 
 como coisa neste momento, ele ainda não sabe 
 que está em uma barra de abas. 
 Ok? Ele só sabe que é suposto fazer o que ele faz. 
 E por isso é modular dessa forma. 
 Você também pode ver que não há comunicação entre qualquer outro, 
 não há outros setas, com exceção de alguns dos modelos. 
 Você vê alguns dos modelos estão se comunicando uns com os outros, 
 você sabe, um grande aplicativo pode ter um modelo único, compartilhado. 
 Ou, você sabe, os modelos pode ser separado em pedaços 
 para ser usado por sub MVC de, ok? 
 Mas esse é o único tipo de comunicação que você vai 
 ter lá, todas as outras comunicações ou é o 
 comunicação estruturada vimos no MVC ou ele está usando MVC do 
 como parte da visão de um outro MVC. 
 Qualquer dúvida sobre isso? 
 Então, nós definitivamente não quero estar a ter projetos 
 que se parecem com isso, ok? 
 Onde todo mundo está falando com todo mundo, 
 não podemos dizer quem está falando o quê, é simplesmente impossível 
 para depurar um programa como este e não escala. 
 Você não pode construir realmente grandes programas desta forma, 
 ele só se torna impossível 
 para saber como tocar qualquer coisa iria quebrar tudo, certo? 
 Então, nós definitivamente não vamos fazer isso. 
 Ok? Ok, então isso é MVC. 
 Não há dúvida sobre isso? 
 Tudo bem. Dentro do objective-C. 
 Assim, o objetivo C é um superconjunto estrito de C, 
 então tudo o que você pode fazer e ver, você pode fazer em Objective-C. 
 Ok? E nós vamos fazer um monte de coisas C nesta classe. 
 Nós vamos fazer um monte de coisas orientada a objetos também, 
 mas nós vamos fazer um monte de coisas C, também. 
 Mas, há, obviamente, algumas coisas que você quer 
 para pensar de forma diferente 
 sobre porque você tem coisas orientada a objetos adicionados 
 em uma língua, e nós vamos falar sobre um deles hoje, 
 além de mostrar a vocês um pouco da sintaxe, 
 vamos falar sobre um deles diferente, 
 pensar de forma diferente sobre as coisas objective-C que é diferente 
 que C + + ou Java, que é propriedades. 
 Ok? E eu não vou ler tudo isso, 
 Eu só vou mostrá-lo a você, 
 mas as propriedades são, basicamente, como temos acesso a nossa variável de instância, 
 certo? 
 Todo mundo sabe o que eu quero dizer com, levante a mão 
 se você sabe o que quero dizer com variável de instância? 
 Ok bom. 
 Assim, praticamente todo mundo. 
 Então, queremos acessar os dados de instância de nossos objetos. 
 E, normalmente, em Java ou C + +, você só, você sabe, 
 ter alguma sintaxe para acessá-los e você só acessá-los. 
 Em Objective-C não fazemos isso. 
 Em Objective-C, temos o que é chamado de um imóvel, 
 e uma propriedade é basicamente um método get setter 
 e um método getter. 
 E é assim que todo o acesso à variável de instância vai, 
 através de um método setter para definir o valor 
 e um método getter para obtê-lo. 
 E algumas pessoas que talvez sejam tipo 
 de [pausa] junkies de desempenho pode-se dizer, oh meu Deus, 
 cada variável de instância que tenho 
 para chamar um método para defini-la ou obtê-lo? 
 Mas, lembre-se, você está construindo 
 para um sistema de interface de usuário aqui, 
 quando o usuário toca baixo, que está levando milhões, 
 um código de milhões, você sabe, 
 você está executando um milhão de instruções lá 
 em que a quantidade de tempo. 
 Assim, tendo alguns setters extras 
 e getters é completamente irrelevante, certo? 
 Então é a velha coisa [inaudível], certo? 
 Você não deseja otimizar as coisas que não precisam 
 a ser otimizado, ok? 
 Você deseja otimizar as coisas que estão a ter um monte de tempo 
 e acesso a variável de instância acaba por não tomar muito 
 do seu tempo, por isso, vamos olhar para o que parece, 
 não se assustou aqui vendo essa sintaxe. 
 É tudo novo, por isso, vai levar algum tempo para se acostumar. 
 Em Objective-C, todas as classes que temos e da classe que eu vou 
 para mostrar a você hoje é um, está na nossa, essencialmente nosso modelo 
 que vamos construir para o nosso app correspondente jogo de cartas. 
 Nós vamos ter um cartão e um deck, e nós também vamos 
 ter uma subclasse de cartão de chamada carta de baralho 
 e uma subclasse de baralho chamado jogando baralho. 
 Essas são as quatro classes que vão ser 
 em nosso modelo, para começar. 
 E, assim, eu vou te mostrar, 
 na aula de hoje eu só vou mostrar-lhe cartão, 
 só cartão, e em seguida, na quarta-feira eu vou lhe mostrar baralho 
 e jogando baralho e jogar cartas. 
 Assim, cada classe em Objective-C, você tem um arquivo de cabeçalho, card.h, 
 e você tem um arquivo de implementação, card.m. Ok, este é apenas 
 como em C + + que você pode ter que he ponto c, ou o que seja, 
 este é m ponto, m eu acho que é para a implementação, eu não sei. 
 Mas isto é [risos], e então você tem essas coisas separadas, 
 a diferença aqui é card.h é a API pública. 
 Isso é o que o seu ponto h é. 
 É a sua API pública. 
 Card.m é a sua API privado e toda a sua implementação, ok? 
 Não fique confuso sobre .h 
 e .m todos .h é a sua API pública, isso é tudo que é. 
 É o que os métodos em sua classe que você deseja tornar público 
 para que outras pessoas podem chamá-los, ok? 
 Então, vamos ver o que a sintaxe se parece. 
 Em sua API pública, você deve dizer que o seu é superclasse. 
 Ok? Você não tem permissão 
 para tornar a sua superclasse ser um segredo, ok? 
 Tem que ser público, de modo que temos de colocá-lo no cabeçalho do arquivo, 
 e você pode ver a sintaxe que usamos é a interface de sinal, 
 o nome da nossa classe, que deve sempre corresponder ao nome 
 do arquivo, por sinal, 
 card.h deve sempre ter a interface para o cartão de classe. 
 E depois de dois pontos e, em seguida, sua superclasse. 
 Agora, a superclasse da classe cartão é NSObject. 
 NSObject é no quadro fundação 
 e é praticamente a classe raiz de toda classe única 
 em todos iOS, incluindo todas as classes que você escreve. 
 Ok? É este tipo de classe básica, vamos falar sobre isso 
 quando falamos de fundação, mas vai 
 ser os superclasse eventualmente de cada classe única. 
 Certo? Tudo, eventualmente, herda NSObject. 
 Agora, no lado da aplicação, ele é muito parecido, 
 mas em vez de dizer a interface de sinal, 
 você diz a implementação sinal e o nome da classe. 
 E aqui você não especificar sua superclasse, ok? 
 Porque você só está autorizado a especificar que uma vez, 
 e seu público, por isso vai em seu arquivo de cabeçalho. 
 Note-se que a parte inferior de ambos, 
 pouco no final sinal, você vê isso? 
 Ok, isso apenas significa que é o fim da interface 
 ou do implante. 
 Ok? Então, toda a sua API pública vai dentro deste 
 no bloco interface de sinal, a interface de sinal, 
 e toda a sua implementação, sua implementação privado vai 
 na parte de implementação em sinal. 
 Agora, se você importar, se você tiver especificado o seu superclasse aqui, 
 você tem que importá-lo. 
 Ok? Que é como sinal de libra, incluir. 
 É um pouco mais poderoso do que o sinal de libra, incluem, de fato, 
 É um muito mais poderoso, como eu vou falar 
 cerca de um segundo. 
 >> Mas você deve importá-lo, 
 caso contrário, o compilador objective-C não vai saber o que 
 superclasse que é, então você tem que, obviamente, 
 importar sua superclasse. 
 No entanto, não o fazemos normalmente, 
 quando a nossa superclasse é algo que está no iOS, 
 nós não costumamos importar apenas que as aulas de cabeçalho do arquivo, 
 que neste caso é a base, 
 nós realmente importar o quadro inteiro. 
 Ok? Agora você pode dizer, oh, isso é ineficiente. 
 [Pausa] Uma estrutura enorme, 
 mas é claro que tudo isso é pré-compilado e otimizado. 
 E, de fato, em iOS7, a sintaxe para isso é realmente a dizer 
 arroba importação fundação. 
 Isso significa que eu vou usar todas as classes públicas 
 na estrutura base. 
 iOS7 ainda suporta o antigo importante barra fundação 
 foundation.h para que você possa usar isso se quiser. 
 Agora em nosso arquivo de implementação, 
 temos de importar o nosso arquivo de cabeçalho, obviamente. 
 Ok? Porque as nossas necessidades de arquivo de implementação 
 para saber o que estamos cometendo ao público, em termos de nossa API, 
 por isso temos de importar esse. 
 Faz todo o sentido. 
 Também podemos ter declarações particulares, ok? 
 As declarações de propriedades e métodos que estão dentro de privada 
 do nosso arquivo de implementação, colocando este pequeno 
 a interface de sinal, o nome da nossa classe, 
 parênteses abertos, parênteses fechado. 
 Ok? E então, no final de sinais. 
 Assim, podemos ter um pouco de espaço aqui 
 onde podemos pequenos declarações privadas. 
 Agora, o objetivo-C não exige que você 
 para declarar algo antes de usá-lo em um arquivo, 
 você sabe o que quero dizer com isso? 
 E há um monte, um monte de línguas, 
 você tem que declarar um método para que você possa chamá-lo, certo? 
 Mas você pode fazê-lo fora de ordem em Objective-C, 
 você pode implementar um método aqui que se chama, 
 você pode implementar o método A, chama o método B, 
 e, em seguida, o método B é implementado aqui no final do arquivo. 
 Ok? Então você não tem que declarar o método B em primeiro lugar, 
 em seguida, implementar o método A, e, em seguida, implementar o método B. Assim, 
 este pequeno privada na interface sinal que vamos sobretudo 
 usar para propriedades. 
 Ok? Porque quando nós declaramos uma propriedade, como você vai ver, 
 que setter e getter são escritos por nós. 
 Então vamos ver o que parece para declarar um imóvel. 
 Então, aqui está a propriedade simples. 
 É chamado de conteúdo. 
 Assim, este é o conteúdo do cartão. 
 Isto é o que está no cartão. 
 Então, isso pode ser ás de paus. 
 Ok? E porque este é o seu primeiro dia, 
 vamos fazer o conteúdo ser muito simples, apenas uma corda. 
 Ok? Então, esses cartões, eles podem ser como um flashcard, talvez, 
 para a aprendizagem de uma língua estrangeira, talvez esta seja a, 
 o conteúdo é a palavra que você está tentando aprender 
 e talvez É um flashcard de imagens 
 onde este conteúdo é o nome de alguma imagem e cabe a UI 
 para exibir uma imagem que corresponda a ele. 
 Ou, no caso de nossas cartas de baralho, 
 vamos ter este ser, literalmente, o caráter de um 
 e, em seguida, os clubes de caracteres, 
 porque não há clubes de caracteres Unicode, para que os clubes A, 
 que seria o conteúdo. 
 Portanto, este é o conteúdo do cartão, o que está no cartão. 
 E você pode ver que é uma estrela NSString. 
 Você vê arroba propriedade é como vamos declarar 
 que precisamos de armazenamento, por exemplo, de cartão, 
 em outras palavras, cada cartão tem seu próprio conteúdo, e vai 
 para ser uma string, e então dizemos estrela propriedade NSString, agora, 
 é importante compreender que em Objective-C todos os objetos, 
 todos eles, viver na pilha e temos ponteiros para eles. 
 Ok? Não há tal coisa como fazer um objeto na pilha 
 ou qualquer coisa assim, ok? 
 Eles estão todos no heap. 
 Todo mundo sabe o que a pilha é? 
 Qualquer dúvida sobre isso? 
 Isso é apenas onde você alocar memória livre. 
 Então, todos os objetos estão lá. 
 O que há ' muito legal sobre Objective-C é, 
 objective-C irá gerir todo o armazenamento para você. 
 Ele irá alocar para você e libertá-la para você. 
 Ok? Agora como ele sabe quando para libertá-la? 
 E a resposta é essa coisa forte, 
 você vê a palavra forte lá? 
 Se, suas propriedades podem ser forte, como este, 
 ou fraco, duas coisas, forte ou fraco. 
 Ok? E todas as propriedades ponteiro tem que ser forte ou fraco 
 porque o objetivo-C tem que saber o que fazer 
 com a memória e a pilha. 
 Meios fortes manter a memória para isso, 
 para a coisa isso aponta para, no heap, enquanto eu 
 ou qualquer outra pessoa tem um forte indicador para ele. 
 Ok? Então, isso é chamado de contagem de referência, 
 não é a coleta de lixo, a sua contagem de referência. 
 Então, nós estamos indo para o objetivo-C vai 
 para manter o controle de cada ponteiro forte único para um objeto 
 na pilha e enquanto existir pelo menos um ponteiro forte, 
 ele vai manter essa coisa em heap. 
 Assim como não há indicadores fortes de esquerda, 
 ele irá liberar a memória para fora da pilha, instantaneamente. 
 Não lixo coletado posteriormente. 
 Mas, na verdade, de imediato, recuperar essa memória. 
 Ok? Portanto, esta é provavelmente novo para você, você provavelmente está acostumado 
 gostar de coleta de lixo em Java, por exemplo, 
 ou gerenciamento de memória explícita em outras línguas. 
 Isso é chamado de contagem de referência automático 
 e é incrível. 
 É realmente muito previsível, isso é muito melhor 
 de coleta de lixo, porque, você sabe, 
 o coletor de lixo pode vir mais tarde e fazer, 
 causar estragos no desempenho de sua aplicação, uma vez que vai 
 e recolhe as coisas a partir do heap. 
 Isso é muito previsível, você sabe exatamente 
 quando as coisas estão indo para ser liberado, 
 é quando não há indicações fortes deixados para ele. 
 O que significaria se isso era fraco? 
 Ok, se você tem um ponteiro fraco, que diz Objective-C, 
 Tudo bem, eu tenho um ponteiro para essa coisa na pilha e mantê-lo 
 na memória, desde que alguém tem um forte indicador para ele. 
 Mas assim que ninguém mais tem um forte indicador para aquela coisa, 
 ele é liberado de memória e este ponteiro, 
 se ele era fraco, fica definido para zero. 
 Nil significa este ponteiro não aponta para qualquer coisa, ok? 
 Nil é o mesmo que zero. 
 Ok? Em outras linguagens, você provavelmente está com medo de ponteiros nulos. 
 Ok? Porque você faz referência a um ponteiro nulo, 
 ele trava o seu programa, certo? 
 Em Objective-C, você pode enviar mensagens para ponteiros nulos mesmo 
 e que não irá travar o seu programa. 
 Na verdade, se você enviar uma mensagem para um programa de zero, 
 para um ponteiro nulo, não irá executar qualquer código, obviamente, 
 porque não há nenhuma instância lá. 
 E vai retornar zero de, 
 se essa mensagem tinha um valor de retorno, ele vai retornar zero. 
 Então você tem que ser um pouco cuidadoso de mensagens 
 que estruturas de retorno, aprovação, 
 mas desde que ele retorna um tipo primitivo, ou um ponteiro, 
 ele só vai retornar zero. 
 Então, isso vai levar tempo para se acostumar. 
 O fato de que nós estamos indo para programar sabendo 
 que podemos enviar mensagens para zero, 
 aos ponteiros que são nulas e que isso é bom. 
 Nós, na verdade, vai tornar o nosso trabalho código bem e usaremos 
 que a nossa vantagem. 
 E isso, certamente, vai ser uma mudança para vocês que são usados 
 para se ponteiros não nulo, 
 em seguida, enviar mensagem o tempo todo, certo? 
 Protegendo-se contra acidentes, você não fazer isso em Objective-C, 
 você simplesmente não codificá-lo dessa forma. 
 Ok? Assim, este indicador poderia ter o valor nulo, nulo, 
 o que significa que não aponta para qualquer coisa. 
 Tudo bem? Então se você tem um ponteiro forte e aponta 
 para alguma coisa e, em seguida, configurá-lo para zero, 
 agora esse ponteiro forte não aponta para aquela coisa, 
 contanto que ninguém aponta para ele, você pode limpar 
 -se que a memória, objetiva-C irá limpar a memória para você. 
 Ou se você tem um ponteiro que aponta para algo no heap, 
 então você fazê-lo apontar para outra coisa no heap, 
 então você não tem mais um forte indicador para que outra coisa 
 na pilha e, enquanto ninguém faz, ele vai se limpar. 
 Ok? E lembre-se fraco, não só limpa-lo, 
 mas define o ponteiro para zero, 
 porque você só queria um ponteiro fraco, só queria 
 para apontar para aquela coisa, desde que alguém o faça. 
 Ok? Então esse é o forte contra fraco. 
 A outra coisa que nós vamos colocar 
 neste pequeno parênteses é atômica, ok? 
 Meios não atômica chamando este setter e getter que ir junto 
 com essa propriedade não é thread-safe. 
 Ok, então você não pode ter dois tópicos que tentam 
 para definir essa propriedade ao mesmo tempo. 
 Por que dizemos não atômica aqui, por que nós queremos que este 
 a não ser thread-safe? 
 Porque a maneira que fazemos multithreading no iOS não é 
 por ter um único objeto que vários segmentos estão definindo em, 
 geralmente temos um conjunto separado de objetos que estão sendo executados 
 em outro segmento, como seu modelo, e depois outro, 
 do que o seu material UI está em execução no segmento interface do usuário 
 e eles estão conversando fio a fio. 
 Ok? Então, nós não precisamos disso e não só isso, o que está acontecendo 
 acontecer aqui quando fazemos isso 
 na propriedade sinal é Objective-C é que vai criar getter 
 e métodos setter que eu lhe disse 
 prestes a definir esses conteúdos automaticamente para nós, 
 e nós queremos que eles sejam simples, certo? 
 Isto é o que eles vão se parecer. 
 Nós queremos que eles sejam simples. 
 Se não dizemos não atômica, não vai ser todos os tipos 
 do código de bloqueio lá, certo? 
 Se você tem vários tópicos e você está permitindo que vários segmentos 
 para acessar o setter e getter aqui, 
 então você precisa de um código de bloqueio, e nós não queremos código de bloqueio, 
 especialmente se vamos implementar o setter 
 e nós mesmos getter, que vamos, às vezes. 
 Ok? Mas o padrão aqui é 
 que nós não implementar esta setter e getter, 
 é automaticamente lá da floresta. 
 Então você pode ver que há três partes para isso. 
 Há a arroba sintetizar, você vê isso? 
 Isso é, basicamente, apenas dizendo conteúdo Underbar é o nome 
 da variável de instância 
 em que o conteúdo da propriedade que vai ser armazenado. 
 Agora podemos dizer arroba sintetizar o conteúdo é igual a foo 
 [Fonética] e conteúdos propriedade seria armazenado 
 em uma variável de instância chamada foo. 
 Mas isso seria muito confuso, 
 por isso sempre usar underbar nome da propriedade. 
 Ok? E isso é uma parte, 
 basicamente só alocar uma variável de instância 
 para armazenar esta propriedade conteúdo. 
 Depois, há o getter, isso é conteúdo NSString, 
 retornar conteúdo, de modo que o traço, parênteses, 
 NSString conteúdo é uma declaração de método em Objective-C, 
 o traço significa que este é um método, 
 parênteses NSString estrela significa que este é um método 
 que retorna um ponteiro para uma string, 
 e conteúdo é o nome do método. 
 Ok? Assim, o nome do método do absorvente é a mesma 
 como o nome da propriedade. 
 Em seguida, a implementação é apenas retorno 
 que a variável de instância que sintetizada. 
 Ok? E de igual modo, o método seguinte é um método 
 em Objective-C para defini-lo. 
 E, novamente, traço [inaudível] método. 
 Parênteses vazio significa que este método não retorna nada. 
 Ok? Isso é o que parênteses meio vazio. 
 Em seguida, defina o conteúdo do cólon, que é o nome 
 deste método, definir o conteúdo do cólon. 
 Parênteses NSString estrela é o argumento para esse método. 
 Conteúdo é apenas o nome do argumento, o nome do local 
 da variável nos conteúdos locais, o contexto, 
 e a implementação é apenas conteúdo Underbar, 
 nossa variável de instância é igual a esse argumento. 
 Ok? Então, antes de eu seguir em frente, 
 que todo mundo entender como esses dois métodos estão permitindo 
 você para definir e obter um espaço de armazenamento NSString dentro do seu cartão? 
 Todo mundo entende isso? 
 Pergunta? [Inaudível fundo pergunta] Ok, 
 para que a linha sintetizar, de novo, é apenas especificando o nome 
 da variável de instância que vamos usar 
 para armazenar este material em, conteúdos Underbar. 
 É meio estranho, você poderia, talvez, talvez seja melhor dizer 
 arroba sintetizar conteúdos de usar variável de instância 
 com nome, Underbar conteúdo. 
 Isso equivale a, eu sei, é um pouco estranho. 
 Parece que ele está atribuindo alguma coisa, mas é só, 
 isso é o que, pense igual como, você sabe, 
 vamos usar a variável de instância 
 com o nome, Underbar conteúdo. 
 Então é isso que a sintetizar está fazendo. 
 Se você não colocar a sintetizar, que não vai 
 para criar o espaço em sua instância cartão, e ele não vai, 
 não haverá qualquer nome para ele assim que você não pode se referir a ele 
 em seu getter e setter, ok? 
 Todo mundo entende isso? 
 Alguma outra pergunta? 
 Ok, agora, a coisa é, quando você digita o 
 na propriedade sinal à esquerda, este é adicionado à sua 
 a implementação sinal; no entanto, você não vai vê-lo lá. 
 [Pausa] Ok? 
 Então, ele está lá, mas você não vê-lo. 
 Ok, Objective-C é, fez isso por você, mas não mostrá-lo 
 para você, mas ele está lá, tudo bem, que o método setter 
 e que o método setter-getter estão lá. 
 Ok? Eles existem. 
 E não só isso, eles são públicos, porque você colocar 
 que a declaração de propriedade sinal em seu arquivo de cabeçalho. 
 Todo mundo tem isso? 
 Então, vamos olhar para um outro casal apenas propriedades 
 para ver a sintaxe um pouco mais. 
 Então aqui está duas propriedades que são lingotes [fonéticas]. 
 Ok? Não há ouro primitiva em C, 
 assim objective-C tem de encontrar, typedef todos tampas BULL, 
 provavelmente um curto ou algo assim ou um int ou um char, 
 Eu não sei o que, mas você pode pensar nisso como um tipo primitivo, 
 É um boolean, o seu valor pode ser sim, 
 que é algum valor diferente de zero, ou não, que é zero. 
 E essas propriedades não precisa do forte ou fraco. 
 Você entende por que isso acontece? 
 Porque eles são tipos primitivos, 
 eles não estão armazenados no heap, ok? 
 Eles são apenas um int ou um float, por isso não há memória para gerenciar 
 assim você não precisa saber sobre ponteiros fortes e fracos, 
 não há nenhum ponteiros envolvidos aqui, 
 este é apenas um touro, um ouro. 
 Portanto, não há forte ou fraco, mas ainda temos o atômica, 
 porque nós ainda queremos o setter e getter para ser simples, 
 não ter qualquer código de bloqueio ou qualquer desse negócio. 
 Então, nós estamos sempre vai ter nonatomic 
 em todas as propriedades desta classe. 
 Nós não teremos uma única propriedade nesta classe inteira 
 que não é nonatomic. 
 Então, basta colocá-lo lá, eu gostaria que fosse o padrão. 
 Ok? Então, isso é o que vamos fazer. 
 Você pode ver que temos sintetizado ambos 
 e nós temos o setter e getter para os dois, 
 e isso é tudo o que está sendo feito para nós por objective-C. 
 Agora, uma coisa que é legal é que podem não gostar do nome 
 deste getter, porque queremos que o nosso código para ler algo 
 como se o cartão for escolhida, em seguida, fazer alguma coisa. 
 Se o cartão é correspondido, então faça alguma coisa. 
 Então nós realmente queremos o getter chamado é escolhido, 
 não apenas escolhido. 
 Você sabe, se o cartão escolhido, não tão agradável como se o cartão for escolhido. 
 Então, é realmente possível mudar o nome do getter 
 dizendo getter iguala o novo nome que você quiser. 
 Ok? E isso é essencialmente renome ou, a mesma coisa, 
 vamos fazer a mesma coisa com este. 
 Getter é igual é correspondido, 
 agora que é chamado de getter é correspondido. 
 E estou dizendo isso porque você está indo 
 para ver como iOS faz isso com propriedades de ouro, 
 ele tende a renomeá-los para isso é ou tem isso, 
 dependendo do que o verbo que existe. 
 Ok? E, novamente, Objective-C é escrever tudo isso em código, 
 na implementação, mas você não vê-lo. 
 Mas ele está lá. 
 Ok? Agora, [pausa] vamos falar 
 sobre por que as propriedades são bons e por isso que é melhor 
 do que apenas o acesso as variáveis ​​de instância diretamente, 
 [Pausa] em palestras posteriores, mas a linha de fundo é que é bom 
 para fazer as coisas, como a verificação de equilíbrio, 
 é bom para fazer as coisas como quando você definir uma propriedade 
 e você quer atualizar o UI. 
 É fazer o bem para as coisas para inicializar ponteiros. 
 Como tal conteúdo corda estrela propriedade vai 
 para começar nulo. 
 Todas as propriedades, em Objective-C, todos eles, começar zero. 
 Assim, para ponteiro, que é zero. 
 Ok? Assim que o conteúdo da propriedade, quando criamos um novo cartão, 
 vai não apontam para qualquer conteúdo. 
 Que os cartões vão ser em branco, tudo bem, isso não vai 
 ter nada com isso. 
 Então, é bom usar o setter e getter, 
 implementamos nosso próprio setter e getter que irá verificar 
 se é nulo, e se não é, e às vezes, 
 não com o conteúdo, mas com algumas propriedades, se é nulo, 
 vamos criar algo na memória. 
 Ok? Então, essa é outra razão pela qual você usá-lo. 
 Então você vai ver todas essas razões por que queremos propriedades 
 Na próxima aula, basicamente. 
 Tudo bem, agora, vamos olhar para um método. 
 Ok? Apenas um método regular, velho. 
 Você já viu alguns métodos, os métodos setter e getter, 
 mas o que se queria encontrar o nosso próprio método, 
 o nosso próprio método público, então eu vou 
 para definir este método chamado jogo. 
 Lembre-se que eu estou construindo um modelo aqui 
 para um jogo de correspondência de cartão, onde eu vou colocar todos estes cartões 
 na tela e o usuário vai tentar combiná-los. 
 Escolha aqueles que correspondem, certo? 
 Então eu preciso de um método de jogo. 
 Um método que me diz se duas cartas iguais. 
 Ok? Então, eu estou tentando fazer este simples, 
 então eu fiz um método de jogo simples 
 que tem a seguinte semântica. 
 É preciso um outro cartão como o argumento, 
 e retorna um inteiro. 
 Esse número inteiro é zero se os cartões não forem iguais, caso contrário, 
 é um número inteiro que é maior, melhor um jogo que é. 
 Ok? Assim como um bom jogo pode ser um mil, 
 mas um não tão bom jogo pode ser apenas uma centena, e, 
 ou, ou pode ser um. 
 Agora, a semântica de que esse número é, depende totalmente 
 nos cartões, porque nós estamos indo apenas para combinar cartões 
 contra outros cartões, certo? 
 E nós vamos descobrir o quão bom um jogo que eles são 
 pela forma como que, o que quer que a classe cartão é, e nós estamos indo 
 para fazer uma subclasse desta classe, chamada de cartão de jogo, 
 que vai dar mais pontos para combinar o posto, tudo bem, 
 do que é para combinar o terno. 
 Ok? Mas isso é até subclasses de cartões 
 para determinar o que o sistema de pontos é, ok? 
 Assim, para a nossa implementação de jogo, tudo bem, 
 vamos fazer uma implementação muito simples, por isso, 
 primeiro vamos supor que eles não são iguais. 
 Ok, então eu só fiz essa pontuação int variável local é igual a zero, 
 você pode ver que você pode atribuir uma variável, 
 na verdade, todas as variáveis ​​locais também começam zero, 
 então eu mesmo não precisa realmente que é igual a zero, 
 mas eu sou um grande crente em colocar isso em 
 se isso é verdade, você sabe, o que você pretende, 
 e, neste caso, eu pretendo a pontuação para ser realmente zero. 
 A pontuação deste jogo até que eu vá e veja 
 se estes cartões de jogo, certo? 
 Então é só um tipo de coisa estilo de programação aqui. 
 Então, como é que eu vou dizer, como é que eu vou dizer 
 Se esta carta que foi aprovada em fósforo, fósforos do cartão 
 que ele está sendo enviado? 
 E a resposta é que eu vou mandar algumas mensagens, ok? 
 Você vê a céu aberto colchetes notação lá, 
 essa é a primeira vez que você está vendo me enviar uma mensagem 
 em Objective-C, e eu também estou enviando duas outras mensagens 
 neste uma linha. 
 Card.contents e self.conteudo, você vê as duas coisas, 
 esses são envia mensagem, também. 
 Portanto, há duas sintaxes diferentes aqui 
 para o envio de uma mensagem. 
 Uma delas é abrir colchetes, tudo bem, e vamos conversar 
 sobre isso em um segundo. 
 E outra é a notação de ponto, card.contents. 
 Quando é que vamos usá-los? 
 Nós só usamos a notação de ponto para as propriedades. 
 É assim que nós chamamos o setter e getter 
 de propriedades, usando a notação de ponto. 
 Ok? Agora, aqui estamos chamando o getter, 
 card.contents está chamando a getter 
 da propriedade conteúdo na instância do cartão. 
 Ok? Como é que podemos chamar o setter? 
 Exatamente o mesmo. 
 Card.contents, mas vamos colocá-la 
 no lado da mão esquerda dos iguais. 
 Card.contents iguais, agora estamos chamando o setter para conteúdo. 
 Você vê? Então, aqui estamos chamando o getter. 
 Também estamos chamando o getter 
 para conteúdos em si mesmo, em nosso self. 
 Assim, em outra linguagem isso pode ser chamado, né, 
 mas você sabe o que eu é, certo, eu é esta instância 
 que este código está a funcionar com. 
 Então, nós estamos indo para comparar essas duas cordas, card.contents 
 e self.conteudo para ver se eles são iguais e vamos fazer 
 que com o método NSString é igual a cadeia cólon. 
 Então, [inaudível] igual a seqüência de dois pontos só podem ser enviadas 
 para uma string [pausa], então é igual a corda só podem ser enviadas 
 a uma corda e card.contents é um método getter 
 que retorna um NSString, por isso está pronto para ir, certo? 
 Estamos enviando é igual string para uma string, e os NS igual 
 a corda toma como um argumento, um NSString e, novamente, 
 self.conteudo é um método getter que retorna NSString; 
 portanto, ter satisfeito todos os requisitos desta igual 
 a corda e vamos colocar colchetes em torno dele, 
 e ele vai retornar um lingote é igual 
 a corda é definido para retornar um lingote se o conteúdo 
 destas duas cadeias são os mesmos. 
 Observe que não é igual a dizer iguais. 
 Ok, nós não dissemos card.contents iguais 
 é igual self.conteudo. 
 Porque nós apenas estaria prejudicando os ponteiros em seguida, 
 não o que os ponteiros apontam para, ok? 
 Todo mundo entender por que nós não usamos iguais é igual para ver 
 se essas duas cordas são os mesmos? 
 Então, se essas cordas são as mesmas, 
 Eu vou dar um ponto, ok? 
 Portanto, esta é tanto a sujeira implementação simples de jogo, 
 que é se os cartões são exatamente os mesmos, 
 seu conteúdo é exatamente o mesmo, 
 Vou pegar um ponto, caso contrário, eu recebo zero. 
 Ok? Agora vamos fazer muito melhor implementação em jogo 
 quando nós cartão de jogo, 
 mas este é o nosso tipo de sujeira uma simples. 
 Agora, para dar-lhe apenas um pouco mais sobre Objective-C, 
 que se mudou este método, oh, sim, sim, 
 aqui está pouco sobre quem é o remetente 
 e quem é o receptor aqui. 
 Você pode olhar para isso em slides mais tarde. 
 Ok? Mas eu vou fazer isso um pouco mais complicado. 
 Eu vou fazer o argumento para combinar ser uma matriz de cartões. 
 Ok? Então agora eu estou combinando esta carta que estou enviando este para, 
 para um monte de outros cartões. 
 Então agora eu vou precisar de um novo algoritmo para combinar, né? 
 Então, mais uma vez, um jogo de carta de baralho, 
 se vamos dizer que você tinha combinando três cartões, 
 você pode dar um monte de pontos 
 se todas as três cartas são do mesmo nível, eles são todas as tomadas, 
 você terá um monte de pontos. 
 Se apenas dois deles são tomadas 
 e o outro é outra coisa, 
 bem você não obter muitos pontos em tudo. 
 Se eles são todos através do mesmo naipe, 
 que tipo de obter uma quantidade média de pontos, você vê o que eu quero dizer? 
 Então, aqui eu estou mudando jogo para tomar uma matriz 
 como argumento em vez de apenas um único cartão. 
 E como eu mudar a minha aplicação 
 para lidar com isso? 
 Bem, eu só vou colocar um loop de quatro em volta do meu caso 
 e percorrer todos os cartões 
 e assim por esta implementação, espero que aqueles de vocês 
 que são pensadores rápidos, você pode saber o que isso faz, 
 isto dá-lhe um ponto 
 se o cartão que está recebendo esta corresponde a qualquer 
 dos cartões na matriz. 
 Qualquer, não todos, qualquer. 
 Ok? Agora você pode imaginar muito melhores algoritmos aqui. 
 Talvez você ganha um ponto para cada cartão você combinar 
 na matriz ou você tem dois pontos para um jogo 
 e quatro pontos para dois e oito pontos para três, 
 você sabe, algum tipo de coisa binária, ponto exponencial, 
 seja o que for, este é o primeiro dia de aula, nós apenas estamos indo 
 para dar um ponto se ele combina com qualquer, ok? 
 Mas, principalmente, o que eu queria mostrar aqui é o que parece 
 gostaria de ter uma matriz 
 como o argumento de um único cartão. 
 Para que você entenda que o argumento, o que o argumento 
 para o método é e também 
 para que eu possa mostrar-lhe o laço de quatro lá. 
 Você vê que quatro n [fonética] 
 um monte de línguas têm que nos dias de hoje. 
 Isso só significa basicamente É um quatro-circuito onde ele está indo para ir 
 através de todos os objetos dessa matriz NS e atribuí-lo ao cartão, 
 cartão é a variável de iteração, e executar uma vez que se 
 para cada uma das placas de matriz. 
 Todo mundo entende isso? 
 Se você tem uma pergunta sobre isso, pergunte? 
 Não? Sim? [Inaudível fundo comentário] Oh, ok. 
 Isso é um grande questão. 
 Então a questão é, se eu só tenho que quatro linhas, 
 mas eu disse quatro cartão de cartão, 
 não quatro Cartão de estrela, em outros cartões, ok? 
 Teríamos um erro de sintaxe. 
 Por quê? Como todos os objetos são sempre apontados 
 para isso temos sempre aquela estrela. 
 Ok? Sempre. 
 Tudo bem? Você não pode ter um cartão de não ser um ponteiro para ele, 
 então, você sabe, objetiva-C lhe daria um erro de sintaxe 
 lá, é impossível não ter aquela estrela. 
 Sempre que você tem o nome da classe, 
 ele sempre vai ter essa estrela. 
 Pergunta? [Inaudível fundo comentário] Sim. 
 A questão é, outro grande, 
 Eu posso usar os colchetes para chamar o setter 
 e getter em vez de usar que a notação de ponto? 
 E isso é um pergunta muito perspicaz 
 e a resposta é absolutamente possível, é perfeitamente legal, 
 porque esse setter e getter são métodos completamente normais. 
 Não há nada de especial sobre eles qualquer. 
 Ok? Essa notação de ponto é uma minúcia, apenas açúcar sintático. 
 A questão é que você deve usar colchetes para setter 
 e getter, e penso que é uma questão de estilo. 
 Você com certeza gostaria de gostaria de estar 100 por cento consistente, 
 você nunca iria querer misturá-los. 
 E eu acho que a maioria das pessoas, 
 a maioria das pessoas diria que usar a notação de ponto. 
 Torna-se mais clara, é um pouco mais simples, mais agradável, 
 mas, você sabe, você poderia. 
 Nesta classe, por favor use a notação de ponto apenas 
 então eu sei que você sabe como usar a notação de ponto. 
 Pergunta? [Inaudível fundo comentário] Ok, 
 pergunta incrível novamente. 
 Puxa, vocês são tão boas. 
 Posso usar a notação de ponto para um método que leva sem argumentos, 
 mas não é um getter ou setter? 
 E a resposta é objetiva-C irá avisá-lo sobre isso, 
 não dar-lhe um erro, mas adverti-lo, 
 e você nunca deve fazer isso nesta classe. 
 Ok? Isso não é realmente tão boa forma, 
 enquanto a sua pergunta era como você pode argumentar, 
 que um, não faça isso. 
 Ok? Assim. Use anotações de pontos apenas para setters e getters. 
 Outras perguntas? 
 Sim? 
 >> Como você usa um setter com anotações de pontos? 
 >> Então, sim, a pergunta é como você usar um setter 
 com a notação de ponto? 
 E é exatamente o mesmo que um getter, 
 É que você está usando 
 no lado esquerdo de uma iguais. 
 Então card.contents iguais, você sabe, um dos clubes, 
 que iria chamar o setter de conteúdos, que, você sabe, 
 isso é chamar o getter, porque não é 
 no lado da mão esquerda do mesmo. 
 Ok? Excelente! 
 Isso é tudo que eu tive hoje, então na quarta-feira, vamos fazer o convés 
 e cartão de jogo e jogar cartão e eu vou mergulhar 
 em um grande e velho demo do XCode 5 
 e mostrar-lhe como tudo isso é realmente feito, 
 e, em seguida, na próxima semana vamos fazer, ainda mais objetiva-C. 
 Muito obrigado! 
 >> Para mais informações, por favor visite-nos em stanford.edu. 
