6 – Objetos – Parte 1

Objetos – Programação Orientada a Objetos Parte 1

Introdução

Ola!

Neste documento temos a continuação sobre POO abordada na primeira parte falando sobre os outros conceitos de P.O.O.

 Porém devido ao tamanho do assunto e deste documento, irei dividir as postagem novamente em 3 partes, esta será a primeira parte.

Neste artigo vou focar em Objetos, e em como aplicar os conhecimentos passados anteriormente utilizando Obj-C nos exemplos. Consequentemente, irei abordar de maneira superficial, alguns conceitos da linguagem. Mas não se preocupe. Esses elementos serão melhor apresentados em um futuro tutorial.

Ainda seguindo um modelo de explicação simplificado, trarei somente o conteúdo sobre Objetos ao fim de apresentar os conceitos ligados a Objetos.  Pois para melhor entendimento, assuntos como Classes, Herança, Polimorfismo, Encapsulamento, Abstração são assuntos já estudados e estão disponível para consulta no seguinte link:

Para esclarecimento, você pode postar suas dúvidas no grupo de estudos, no seguinte link:

Grupo Objective-C Brasil.

Para quem gostou e gostaria de acompanhar as novidades no blog é só entrar na página no Facebook: Objectice-C Brasil.

E dar o seu like se gostar :D!!!

Para quem quiser ajudar, o que seria muito legal, basta entrar em contato comigo pelo meu email ou deixar um post no blog.

Email para contato: tiagofly@hotmail.com

Blog:  www.objectivecbrasil.blogspot.com.br

Bons Estudos!!!

Objetos

Legal, chegamos a um ponto crítico em nossa história! Você tem uma caneta em mãos? Ótimo! Podemos começar a usá-la. A idéia é simples, basta abstrair um pouco as coisas.

Bem esta caneta é um objeto, fruto de especificações técnicas que foram traçadas seguindo alguns critérios para satisfazer o usuário final. A primeira, e mais óbvia atividade que podemos exercer com ela é a possibilidade de escrever! :D. Critérios como tipo de traço, duração de carga e cor da tinta, são levados em consideração. Mas ficam a cargo do Designer questões de beleza… se você não for o designer, talvez não tenha muito que se preocupar com a aparência… Talvez…

Seguindo a idéia de P.O.O. é possível notar que a caneta possui características que a fazem bem parecida com um lápis e com lapiseiras ou outros itens que permitem escrever manualmente, como a maneira de segurar, suas dimensões, cor da tinta ou cor do corpo, tipo de bico… essas características são herdadas de um conceito abstrato de caneta, de onde também vem o lápis a lapizeira, o hidrocor, o giz de cera e outros. Que por sua vez guarda em si como todos os atributos e métodos que o aplicativo caneta pode ter.

Como se trata de um conceito abstrato, ele não pode ser instanciado, ou seja, não pode existir um objeto abstrato. Mas podemos dar especificações a ele que permita a criação de um objeto real.

Como saber quais são essas especificações? Simples, quando você perde uma caneta, você pergunta a alguém se a viu e fornece as características que  definem a sua caneta, informações que ajudem a identificá-la, ou seja, fornece informações sobre sua identidade.

Essas informações são parecidas com aquelas que temos no arquivo .h (header) que é a carta de apresentação de nossa classe. Mas diferente do que está na classe abstrata, a classe que serviu como base para nossa caneta, possui informações definidas como cor, tamanho, tipo de tinta, tipo de bico, tampa e etc. Isso demonstra que ela é uma subclasse e está definida com mais detalhes, permitindo que possa ser instanciada.

Confuso?

Vamos simplificar:

Vá em uma papelaria e no balcão peça ao atendente deste jeito: Por favor, me venda uma caneta.

Logo ele vai te perguntar: Senhor(a), qual você prefere? Azul, branca, pequena, grande, com bico fino, qual a cor da tinta, vermelha, azul, preto?

Logo você vai ter que DEFINIR a caneta para informar qual você deseja comprar.

Então mãos no código!

Para utilizar o objeto, é necessário conhecer sobre a sintaxe da linguagem em questão. Então iremos ver um pouco sobre a sintaxe e teremos um entendimento melhor do que é e como podemos trabalhar com os objetos.

Estrutura de uma Classe em Objective-C

Uma dúvida muito grande, é como colocar o conceito de classe em prática em alguma linguagem, para quem começa em programação. Pois bem, vamos ver como isso funciona em Objc-C.

Uma classe em linguagens herdadas de C seguem um padrão de 2 arquivos para conter o código fonte de uma classe, mas no caso de Obj-C temos mais um arquivo que guarda e nos serve como ferramenta para a construção e configuração visual da aplicação, no caso o arquivo de extenção .xib, e que atualmente foi substituído pelo .storyboard. Vejamos na lista abaixo:

– Header(.h)

– Implementation(.m)

– Main(.m)

– NeXT Interface Builder (.xib) ou storyboard

O arquivo Header (Cabeçalho), é a carta de apresentação da classe, e nela conterá informações sobre as variáveis (Tipo, Nome), e métodos. Este arquivo tem o nome da classe e a extenção“.h” (ponto-final e a letra ‘h’). Ficando por exemplo a classe Avião = Aviao.h.

Neste arquivo podemos informar várias coisas sobre esse objeto, e será o arquivo que informará as outras classes quais são suas variáveis e métodos públicos e privados. Por exemplo:

#import <Foundation/Foundation>
@interface Aviao: NSObject
@end

Nesta declaração simples, não existe nenhum método declarado explicitamente. Porém, essa classe está sendo criada seguindo um padrão de segurança muito comum dentro de Objective-C.

A Classe NSObject é a classe mais importante nesta linguagem, ela trás em sua implementação todos os métodos e configurações básicas para todas as outras classes de Obj-C.

Portanto na expressão: “Aviao: NSObject”, estamos nos utilizando de herança e nossa classe Aviao, herda todos os métodos e variáveis já declaradas em NSObject. Na verdade, todas as classes existente em Obj-C são classes filhas de NSObject. E é de extrema importância que suas futuras classes também herdem dela, isso irá evitar que suas classes simplesmente não funcionem ou funcionem com problemas ou que você leve horas programando uma implementação básica que já existe.

Para quem está habituado a programar em C, já está acostumado com o termo “ #import “ ou “#include” que surge logo no inicio do arquivo. Este termo informa que as operações que irão ser feitas por aquela classe ( no caso Objetos daquela classe), estão descritas em outro arquivo, cujo nome é colocado entre aspas ou entre os sinais < e >  a esquerda da declaração “ #import”, ficando geralmente com o seguinte layout:

#import “NOME DO ARQUIVO IMPORTADO” //ou

#import <NOME DO ARQUIVO IMPORTADO>

Abaixo do termo import, temos o termo “ @interface”, este termo informa que se trata de uma interface de uma classe. No nosso exemplo temos:

@interface Aviao : NSObject

Em futuras abordagens irão surgir outros elementos neste arquivo, como a declaração de delegates, protocol, variáveis de instancia e property.

No final de todos os arquivos sempre encontraremos o termo @end, que informa o fim do arquivo para o compilador, e tudo que estiver depois dele será ignorado em termos de compilação, mas será notificado pelo SDK, a não ser que esteja comentado.

Ok! Já temos nossa classe declarada, agora precisamos do arquivo de implementação. O Arquivo de implementação é o arquivo onde iremos construir o corpo dos métodos e como eles irão atuar sobre as variáveis, como irá modificá-las, dentre muitas outras atividades.

A implementação segue o seguinte modelo:

#import “Aviao.h"
@implementation Aviao
@end

Este arquivo, temos uma importação do arquivo que explica oque ele poderá conter e trabalhar. A partir do termo @implamentation começa a implementação da classe, que é informada logo ao lado do termo. E no fim do arquivo podemos encontrar o termo @end novamente informando onde termina a implementação.

Como é herdado de C, todo o código precisa de um arquivo fonte principal que é onde termos uma função principal chamada MAIN. Em C, C++, Java, Objective-C e em outras linguagens baseadas em POO, temos que ter essa uma classe principal e nesta classe temos o método principal para que seja o ponto de arranque de todo o resto de sua aplicação. Pois é esta função, ou método, que é procurado primeiro pelo compilador.

Seu layout geral é assim:

#import <Foundation/Foundation>
int main(int argc, const char *argv[]){
@autoreleasepool{
//insert code here...
}
return 0;

Podemos utilizá-lo normalmente como fazemos em JAVA, C ou C++. Mas podemos também somente nos focarmos nos arquivos .h e .m e no arquivo .xib (Arquivo que contem o layout visual de nossa aplicação) sem nos preocupar em modificar este arquivo, pois seu uso já é controlado pela implementação base da linguagem.

Não somente de código viverás!

Well!

Uma coisa muito legal que muitos gostam de fazer é ficar programando a parte visual da aplicação. Imagine horas e horas programando cada quadrado, circulo, elipse, cores, degradê e muitas outras formas e combinações visuais de sua aplicação. Para depois sim você poder pensar nas funcionalidades. Nossa, chega a deixar meu coração emocionado… de tristeza é claro!

É certo, que em muitos casos, você realmente terá que fazer isso, principalmente quando se trata de um novo produto, ou precise modificar/criar um comportamento visual do app.

A Apple tornou isso muito mais rápido e prático e claro ao incluir um editor de interface humana para que você possa criar a “cara” do teu aplicativo, mais rápido e com menos dor de cabeça. Já que tempo vale muito, muito mesmo!

Esta ferramenta se chama Interface Build, uma herança da NextStep, que também tinha uma ferramenta de mesmo nome. Quando o desenvolvedor cria a sua interface para o aplicativo, este aplicativo armazena essas informações em um arquivo de extenção .XIB ou .STORYBOARD, que é uma abrviação do NeXT Interface Builder (.xib), antigamente era chamada de .nib.

Vejamos abaixo uma imagem da interface gráfica de um app sendo elaborado no Interface Build

Em versões anteriores do Xcode, o Interface Builder era separado do Xcode, depois houve uma integração, hoje basta clicar no arquivo .xib que o Interface Builder será carregado, como na imagem acima, podendo ainda dividir espaço na tela com os arquivos .m e .h para interligar elementos da tela com trechos do código, como variáveis e métodos.

Entendendo o Dialeto!

Não basta somente ver os arquivos e saber quem são, é preciso saber falar a língua deles para que eles entendam oque você deseja e façam para você, então a partir daqui iremos ver como funciona a sintaxe desta linguagem.

Partindo do Básico

Como estamos careca de saber, já sabemos que Objective-C tem origem na linguagem C, e portanto recebe muitos comandos e  adaptações de aplicações de C sem quase nenhum, ou nenhum problema. Isso pode ser notado muito bem quando se trabalha com Blocks, que veremos a seguir. E não só suporta códigos escritos em C mas sua própria sintaxe é identica, e em alguns pontos a mesma que em C.

Para dinamizar e ajudar no entendimento, irei disponibilizar uma apostila que encontrei sobre C. E um comentário pessoal ela é muito bem feita e ideal para qualquer pessoa que esteja começando em programação. É claro que estudar com um acompanhamento de um programador experiente e que saiba passar o conhecimento é algo muito bom e ajuda bastante, mas na falta de um, basta estudar esta apostila com determinação que você não terá problemas.

Obs: Esta apostila está passível de ser removida ou não de acordo com o seu proprietário. Todo o conteúdo e demais relevantes responsabilidades pertencem ao seu autor.

Link para Apostila.

A partir deste ponto irei considerar que o leitor já tenha um certo conhecimento da sintaxe de C , depois de ler essa apostila acima, e que saiba como criar e usar variáveis, funções e funções com retorno. Mas irei tocar nesses assuntos de passagem, acentuando detalhes que pertencem a linguagem da Apple.

Mini sumário:

  • Variáveis e Ponteiros

  • Métodos

  • Property

  • Controladores de Fluxo

  • Controladores de Repetição

  • Objetos

Variáveis

Variáveis em em Obj-C herdam sua sintaxe básica da Linguagem C e recebem novas particularidades. A seguir irei apresentar uma explicação básica das variáveis em Objc-C, sua finalidade e como utilizá-las.

Quando se fala em variáveis, lembramos logo das variáveis aplicadas nas aulas de matemática, utilizadas nas equações. Como exemplo podemos ter a equação de 2º Grau, onde possuímos 2 variáveis:

ax²+ bx+c = 0

Onde x é uma variável e sendo a, b e c constantes. Existem mais regras explicando como funciona esta equação, com o objetivo final de encontrar o valor de X.

Porém existe um sentido parecido de uma variável dentro do contexto de programação e é o fato de que ela poderá armazenar uma informação. E esse similaridade se encerra neste sentido.

Em programação uma variável  tem a finalidade de armazenar informação, e essas informações podem ser números, textos, valores lógicos (Verdadeiro ou Falso). Em nenhum momento uma variável irá realizar alguma operação, ou uma ação, seja ela de qualquer tipo. Somente serve para guardar informações.

Criando variáveis

Para se criar uma variável antes devemos pensar no tipo de informação que desejamos guardar nela. Opa, espera, tipo? Sim tipo. Os computadores interpretam os dados seguindo padrões e tabelas internacionais, para determinar números e caracteres diversos. Então precisamos informar o tipo de informação que queremos e esses tipos podem ser:

–          Tipo Inteiro: Um número inteiro, negativo ou positivo e não fracionário, ou seja, que não contenha valores após virgula. Exemplo: 1, -15, 27, 0.

–          Tipo Caractere: Este tipo permite armazenar letras e palavras. Exemplo: a, b, Brasil, p, P.

–          Tipo Booleano: Este tipo de informação se refere a VERDADEIRO ou FALSO. Em Obj-C usamos YES para Verdadeiro ou NO para Falso.

–          Tipo Float (Flutuante): Este tipo tem a mesma finalidade do Tipo Inteiro, suportando os mesmos valores e ainda dando suporte a números fracionários. Exemplo: 3.14/ 89.300 / 15.359.

–          Tipo String: Este tipo suporta além de caracteres como no Tipo Caractere, e ainda dá suporte a sentenças de caracteres, como frases ou textos completos, permitindo maior opções de operações. Exemplo: O rio começa entre as montanhas. Um lindo dia para caminhar.

–           Tipo Objeto: Em Obj-C é implementado alguns tipos de Objetos que servem para armazenar os dados, e nos fornece métodos para tratá-los com maior agilidade, sem termos que criar funções ou métodos para isso. Ou seja, não precisamos criar a roda novamente.

Os tipos int (inteiro), char (caractere), bool (boleano) e float (flutuante) são tipos escalares (não-objetos), são variáveis simples e claras. Também são chamadas de variáveis primitivas, por diversos motivos, mais principalmente por que não contém nenhum método associado e podem ser facilmente acessadas, conforme a implementação.

Com o tipo de dados Objetos, podemos ver primeiramente os tipos NSString e NSNumber. Seus nomes começam com letras maiúsculas pois é um tipo de convenção, ou seja, um acordo entre os programadores que os nomes de classes devem começar com as letras maiúsculas.

Esse tipo de dado além de armazenar os mesmos dados escalares, já citados, também oferecerem um conjunto de métodos que nos permitem manipular os dados ou obter informações deles, de forma segura e rápida, sem termos que implementar novamente sempre que for preciso.

Um exemplo de uso de uma NSString seria enviar a mensagem length (chamar o método length) para nossa string, e ela irá retornar um valor informando o quantidade de caracteres em nossa string.

Mãos na massa, Criando Variáveis

Bom declarar uma variável não é difícil basta seguir os seguintes passos:

1º – Declarar o tipo;

2º – Declarar o nome da variável

3º – Decidir ou não se ela será criada já contendo um valor.

Exemplo:

int meuNumeroInteiro; // sem inicialização
int meuSegundoNumeroInteiro = 523; // com inicialização

Tambem podemos criar variáveis com objetos da seguinte maneira:

NSString *meuTextoAqui; // sem inicialização
NSString *meuOutroTexto = @”Meu texto de inicio”;  // com inicialização

Onde o asterisco ( * ) informa que é um ponteiro para um objeto que armazena a string

Como você irá notar, o nome das variáveis, e dos métodos também são bem verbosos, pois é muito importante a identificação dos elementos dentro da criação de uma classe, para melhor entendimento e manutenção, e até mesmo para quando trabalhar com outros programadores.

Um outro elemento muito importante e extremamente usado nas entrelinhas de Obj-C são os Ponteiros. Para quem já conhece essa ferramenta, e a usa, vai falar bem dela, agora quem está conhecendo ainda, vai reclamar muito, devido a idéia lógica no uso dela. Os ponteiros são muito usados em C, principalmente programas que exigem alto desempenho, isso se torna uma ferramenta básica.

Quando falamos em Ponteiros, falamos em endereço de memória. Bom qual memória? A resposta simples: A memória do dispositivo que está executando o programa. Quando declaramos uma variável e dizemos o seu tipo, então o computador reserva um espaço da memória para armazenar aquela informação. Então para realizar algumas operações, em vez de passar a informação( transportar todo o conteúdo de maneira bruta de um lugar da memória para outro) é preferível simplesmente dizer onde ela está, passando o endereço da memória . Isso torna a tarefa mais ágil em termos de processamento.

Utilizamos um asterisco, para dizer que se trata de um ponteiro, e não uma variável qualquer.

Por exemplo:

int *minhaIdade; // é diferente disso
int minhaIdade; //

Em cima temos uma variável que irá armazenar um ponteiro(o endereço da memória), enquanto embaixo temos diretamente a variável. O ponteiro portanto é uma variável que guarda o endereço de outra variável, e não possui o mesmo conteúdo.

Ponteiros podem ser usados para caracteres, inteiros, ponteiros para registros (structs) e etc.  O computador faz questão de saber de que tipo da variável que o ponteiro você está apontando. Por isso sua sintaxe é idêntica a criação de variáveis.

Então usamos o “ * ” para declarar uma variável que irá ser um ponteiro. Mas precisamos passar para ela o endereço da variável que ela irá conter. Para obter o endereço de uma variável utilizamos a letra E comercial (&) antes da variável que queremos o endereço. Ficando como no exemplo abaixo:

int meuNumero;
int *ponteiro = &meuNumero;

Em Objc-C a utilização ainda fica muito fácil, já que se tornará um hábito a criação de ponteiros quando criamos um objeto. Veja abaixo como ficaria a criação de uma string usando NSString:

NSString *meuPonteiro = @”Minha string”;

// Ou

NSString *meuSegPonteiro;

Podemos passar um ponteiro para outro assim sendo o segundo ponteiro irá equivaler o mesmo que o primeiro, veja abaixo:

meuSegPonteiro = meuPonteiro;
//Ao mandar imprimir meuSegPonteiro iremos
//ter o seguinte resultado escrito na tela:

NSLog(“%@”, meuSegPonteiro); // não é preciso colocar
                             //“ * ” para usar um ponteiro.

//Resultado: Minha string

Métodos

Os métodos são os nossos braços operários nesse ramo! Tão importante quanto saber criar um método, é saber usar os já existentes na biblioteca. Em breve vamos falar das classes já existentes nas bibliotecas, ou melhor nos Cores do IOS. A sintaxe para usar um método ( ou função para aqueles que estão acostumados com C) pode ser comparado como um método em Java ou na própria linguagem C.

Exemplos de funções/ métodos sem argumento ou parametros:

Ling. C:

void calculaInteiros (){
// Corpo da função
}

Ling. Java:

public void calculaInteiros(){
// Corpo do método
}

Ling. Objective-C:

-(void) calculaInteiros{
 //Corpo do método
}

Ou pode ser feito com argumentos, ou seja, os argumentos são valores que são passados para um método, e esse método irá realizar uma tarefa com eles, e poderá ou não retornar um resultado. Veja os exemplos abaixo:

Ling. C com argumentos:

void calculaDiferenca( int valorA, int valorB){
// Corpo da função
}

Ling. Java:

public void calculaDiferenca(int valorA, int valorB){
// Corpo do método
}

Ling. Objective-C:

-(void) calculaDiferenca:(int) valorA (int) valorB{
//Corpo do método
}

A idéia para criar a declaração do método é bem simples, e como vocês podem notar a idéia geral é muito clara, utilizei exemplos em Java para que fica-se mais claro como a estrutura dos métodos funcionam de maneira bem parecida. Vou explicar com mais detalhes agora:

Assim como as variáveis, precisamos especificar o tipo de dados que o método trabalham, no caso usamos o void (ou nulo). Depois criamos o nome do método, que irá ser usado para invocá-lo, e deve ser único dentro do escopo da classe, no caso usamos calulaInteiros e calculaDiferenca.  Os argumentos ou parâmetros, permitem que diversos tipos de valores possam ser inseridos  no método em tempo de execução. Esses valores precisaram ser armazenados em variáveis, que são declaradas dentro do escopo do método, e precisam ter um tipo definido.

Em uma visão geral teremos:

Bom agora já sabemos como declarar um método, agora vamos ver como funciona a implementação deles, sabendo que ainda falta vermos algumas funções que vem diretamente de C, as funções FOR, WHILE, DO-WHILE, IF-ELSE, SWITCH-CASE.

Mas antes disso, já podemos fazer algumas operações básicas com os operadores aritméticos,  que são as operações de adição, subtração, multiplicação e divisão, incremento ou decremento. As operaçoes com valores Boleanos deixarei quando estivermos usando as funções controladoras de fluxo ou repetição… FOR, WHILE, DO-WHILE, IF…

Bom como dito, quando se cria uma classe, você declara a classe no arquivo .h, no caso o arquivo cabeçalho da classe. Vamos ver o exemplo abaixo com a classe Aviao:

#import<Foundation/Foundation>

@interface Aviao: NSObject
-(void)enviarAvisoPassageiros; //Método simples sem argumentos.
@end

Agora que já temos sua declaração, vamos até o arquivo Aviao.m para implementar este método.

#import “Aviao.h”

@implementation Aviao

-(void)enviarAvisoPassageiros
{
NSLog(@“Senhores passageiros, estamos chegando ao nosso destino.”);
}
// Quando criarmos uma instância, ou melhor, um objeto desta classe e usarmos este
// método, iremos ver esta mensagem sendo escrita no console do Xcode.
@end

A frente veremos como criar este objeto e usar este método, e até mesmo como exibi-la na tela de nossa aplicação e não na tela do console. Mas nosso foco no momento é ver como funciona a implementação de um método e não o seu uso ainda.

Um método que recebe um argumento pode ser feito do seguinte modo:

-( void )torreParaAviao:(NSString *)mensagem{
NSLog(@“Coordenadas para pouso: %@”, mensagem);
}

Explicando o método: Neste método temos uma variável declarada no escopo do método, assim como em C essa variável só pode ser enchergada dentro da implementação do método, não podendo ser usada fora dele. A variável mensagem, só poderá receber valores do tipo NSString.

Como a idéia da mensagem que a torre envia para o avião é quase a mesma, somente variando as coordenadas, então esse valor é passado para o método quando ele é chamado, e depois é concatenado na NSLog para ser exibido na tela de console.

O token (%@) utilizado dentro da função NSLog, funciona da mesma maneira que o %d na linguagem C para exibir números inteiros, porém  o %@ é usado em Obj-C para exibir valores vindos de objetos. Como nossas coordenadas estão dentro de um objeto, então utilizamos este token para recuperar seu conteúdo e imprimi-lô na tela.

Métodos Com Retorno

Métodos podem retonar um valor para o objeto que os chamam, ou melhor, quando uma mensagem é enviada ao objeto… Não entendeu, ok irei explicar.

Filosofia Next Step:

Normalmente quando nos referimos a ter um objeto e ordenar que ele faça uma ação, usamos os termos: “Chamar um método”, “Invocar um método”, e alguns outros.

Mas em Objective-C é usado a idéia de: “Enviar uma mensagem ao Objeto”. Wait, please!

Confuso? Sim também achei, principalmente quando penso: Dá onde vem essa mensagem?

Na verdade a mensagem que é enviada para um objeto é um método que pertence a ele! Não é um bicho de sete cabeça, quando se lembra isso.

Ok?!… Então continuemos!

Como havia dito, métodos podem retornar algo para o objeto que o chamou, ou melhor, quando é enviado a mensagem para o objeto. Oque é retornado? Bem normalmente este retorno pode ser o resultado de uma operação, pode ser um objeto inicializado, entre outras coisas.

Irei demostrar com dois exemplos alguns meios de enviar uma mensagem para um objeto, com retorno e sem retorno, mas os detalhes sobre como utilizar um método será visto após o assunto Objetos.

Envio de mensagem com retorno (chamando método e dando um argumento para ele retornar um resultado com base nesse argumento):

Exemplo 1

// Método com retorno
-(NSNumber *)calculaQuadrado:(NSNumber*)ladoA (NSNumber*)ladoB{
NSNumber *resultado = ladoA * ladoB;
return resultado;
}

Exemplo 2

// Método sem retorno
-(void)setResultado:(int)resultado
_variavelProperty = resultado;
}

Explicação do exemplo 1: Neste método o retorno é caraterizado pelo termo “return” logo no fim do método. E para ele indicamos que a variável resultado deve ser retornada ao objeto para o qual a mensagem foi enviada.

Como você pode notar, esse método recebe dois argumentos. A frente iremos ver como fazemos essa passagem de argumento. Continuando,  em outras palavras podemos dizer que chamamos esse método que pertence a um objeto e ele nos deu como resultado a multiplicação de dois valores, que são colocados nas variáveis ladoA e ladoB, cujo resultado foi colocado em resultado.

Portanto dizemos que esse método realiza um retorno.

Explicação do exemplo 2: Neste método não temos retorno. Embora ele tenha uma variável para receber um argumento, o tipo do método é void (nulo), isso informa ao compilador que o método não retorna nada. Embora, ele possa colocar o resultado em uma variável visível fora do escopo do método,no caso

 _variavelProperty

,  mas ele não retorna valor algum para o Objeto para qual a mensagem foi enviada.

Mais opções e dúvidas sobre esse assunto serão vistos depois que abordarmos o assunto Objetos.

Nome ou Assinatura? Eis a questão!

Um outro assunto ligado a essa questão de nome do método é a Assinatura de um Método, que nada mais é do que o nome do método com os tipos de retorno e do tipo do argumento.

Ficando igual como na declaração dele no arquivo .h:

-(NSString *) torreParaAviao:(NSString *)mensagem; //Assinatura do método

torreParaAviao:mensagem // Nome do método

Ou seja o nome do método é somente seu nome com os dois-pontos “ : ”.

Não é difícil… o problema é que em muito casos precisamos usar um termo técnico para informar corretamente oque se pretende ou oque se quer fazer, então para não haver problemas de entendimento, os termos técnicos são feitos para isso. Procure conhecê-los o máximo possível.

Mas de uma maneira geral, a assinatura de um método, é o conjunto dos tipos, mais o nome dele. E para se obter o nome basta substrair os TIPOS.

Meu caros, finalizando essa primeira parte, abordamos uma série de elementos básicos que serviram para trabalhar com objetos, já que passaremos a maior parte do tempo programando, será manipulando objetos e suas conexões.

No próximo post iremos abordar propriedades (@property) e controladores de fluxo e repetição. E no terceiro e ultimo post desta série iremos massagear nossos cérebros com Objetos!

Espero que goste! Coloquem suas dúvidas, queixas e opniões nos comentários ou no grupo de estudo no Google Groups!

Obrigado!

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s