Leia outros artigos desse autor:
Série Objective-C 01 – Primeira aplicação via Console Texto
Série Objective-C 02 – Primeira aplicação compilada via XCode
Série objective-C 03 – Exercícios de fixação
*
Hoje iremos falar sobre orientação a objetos no Objective-C. Iremos trabalhar com um exemplo simples e ilustrar os
conceitos de classe, objetos métodos e atributos.
Aos que não
têm familiaridade com este paradigma de programação, recomendo ler
materiais sobre o assunto, pois o domínio da programação orientada a
objetos é vital no desenvolvimento de aplicações em objective-c.
Vejam o link: Orientação a objetos – Wikipédia
Até agora vimos exemplos extremamente simples e usando apenas a função main, nada diferente dos programas feitos em C ansi. Vamos
estudar alguns aspectos mais específicos do objective-c, em especial a
orientação a objetos. Vamos escrever um pequeno programa que armazena e
exibe o saldo de uma conta corrente. Como se trata de um exemplo, nesta
versão, não iremos contemplar saques, depósitos, apenas o número da
conta e saldo.
Abaixo temos um diagrama de classe bem
simples do que iremos implementar. Recomendo darem uma olhada em UML
em especial no diagrama de classes para quem tiver dúvidas.
Diagrama da Classe Conta:
No diagrama acima, estamos definindo a classe Conta:
Nome da nossa classe: Class Conta
São definidos 2 atributos, saldo e conta, private
indica que eles serão acessíveis apenas dentro da classe, isto mostra
um exemplo de um dos conceitos de OOP o encapsulamento, logo a seguir
definimos os tipos destes atributos int e float.
private int: conta
private float: saldo
Métodos da classe
Os métodos trazem funcionalidades às classes. Neste diagrama de classe definimos 3 métodos: setConta, setSaldo e printSaldo. Eles têm escopo público (public), diferente dos nossos atributos, eles podem ser acessados de fora da nossa classe. O parâmetro void
indica que eles não terão retorno algum. Os métodos setConta e setSaldo
serão chamados, mas terão um parâmetro obrigatório na hora da chamada
respectivamente int e float.
public void setConta(int)
public void setSaldo(float)
public void printSaldo()
Codificando em objective-c
Agora
que entendemos o nosso diagrama de classe, temos os atributos e os
métodos definidos vamos escrever o nosso primeiro programa em
objective-c com programação orientada a objetos.
Use o seu editor ou IDE favorito e vamos iniciar os trabalhos.
É importante saber que um programa em objective-c tem 4 partes bem definidas:
- Diretrizes para o pré-processador
- Definição da interface das classes
- Implementação dos métodos definidos na interface
- A função main e o ínicio do programa em si.
Listagem do programa:
// Programa exemplo orientação a objetos
// Programador: Pierre Freire
// E-mail: blog@pierrefreire.com.br
// Versao: 0.01
//------------- Definição da interface das classes --------------
@interface Conta:Object
{
int conta;
float saldo;
}
-(void) setConta: (int) numberConta;
-(void) setSaldo: (float) valorOperacao;
-(void) printSaldo;
@end
//----------------- Implementação dos métodos definidos na classe --------------------
@implementation Conta
-(void) setConta: (int) numberConta
{
conta=numberConta;
}
-(void) setSaldo: (float) valorOperacao
{
saldo=valorOperacao;
}
-(void) printSaldo;
{
printf("Extrato bancario \n\n");
printf("-----------------------\n");
printf("Conta:%i\n",conta);
printf("Saldo:%f\n",saldo);
}
@end
//------------- Programa principal ---------------
int main (int argc, char *argv[])
{
// Cria um objeto do tipo Conta
Conta *itau;
// Aloca um espaco para o objeto itau e inicializa
itau = [Conta alloc];
itau = [itau init];
// Usando metodo setConta do objeto itau
[itau setConta: 12];
// Usando metodo setSaldo do objeto itau
[itau setSaldo: 200.00];
// Usando o metodo printSaldo
[itau printSaldo];
// Liberando o objeto da memoria - Metodo free
[itau free];
return 0;
}
Entendendo o código
01 – Definindo as diretrizes do pré-processador
//------------ Definindo as diretrizes -------------
#import <>
#import <>
Como
comentamos anteriormente esta parte do código, definimos as diretrizes
do pré-processador. Neste caso incluímos a biblioteca stdio.h, porque
estamos usando a função printf, e a Object.h, porque estamos usando a
classe Object.
02 – Definindo a interface da classe
//------------- Definição da interface das classes --------------
@interface Conta:Object
{
int conta;
float saldo;
}
-(void) setConta: (int) numberConta;
-(void) setSaldo: (float) valorOperacao;
-(void) printSaldo;
@end
A
definição da interface da classe é uma espécie de contrato, onde você
define o nome da sua classe, se ela herda característica de outra
classe, os atributos que a compõem e os métodos que ela irá ter. Ou seja,
definimos apenas a estrutura da classe.
Definimos
a interface, o nome da classe será Conta e ela é subclasse de Object, ou
seja, ele herda todos os métodos e atributos desta classe. Definimos os
atributos conta e saldo sendo tipo int ( inteiro) e float,
respectivamente.
@interface Conta:Object
{
int conta;
float saldo;
}
Definimos
os três métodos da classe. O sinal de – indica que será um método de
instância, ou seja, ele só pode ser acessado depois de instanciado o
objeto da classe. Mais adiante veremos mais detalhes sobre isto.
setConta e setSaldo necessitam de um parâmetro do tipo int, e a variável
usada para este parâmetro é definida logo adiante, numberConta e
valorOperação, respectivamente. O @end fecha o bloco.
-(void) setConta: (int) numberConta;
-(void) setSaldo: (float) valorOperacao;
-(void) printSaldo;
@end
03 – Implementação dos métodos definidos na classe
Início do bloco de implementação da classe Conta
@implementation Conta
Implementação
do método setConta. O método não retorna nada (void), na sua chamada ele
recebe um inteiro(int) que será armazenado na variável numberConta, no
corpo do método definido pelas “{}”. Ele armazena no atributo conta o
número passado por parâmetro.
-(void) setConta: (int) numberConta
{
conta=numberConta;
}
Implementação
do método setSaldo. O método não retorna nada (void), na sua chamada ele
recebe um float (float) que será armazenado na variável valorOperacao, no
corpo do método definido pelas “{}”. Ele armazena no atributo saldo o
número passado por parâmetro.
-(void) setSaldo: (float) valorOperacao
{
saldo=valorOperacao;
}
Este método nada retorna (void), não recebe parâmetros e simplesmente imprime as informações armazenadas por setConta e setSaldo.
-(void) printSaldo;
{
printf("Extrato bancario \n\n");
printf("-----------------------\n");
printf("Conta:%i\n",conta);
printf("Saldo:%f\n",saldo);
}
@end
04 – Programa principal
Nesta parte do código é de fato onde se inicia a execução do nosso programa. Vamos ver passo-a-passo o que acontece.
Função
main, é o inicio do programa. Ela retorna um inteiro ao seu final e
alguns parâmetros podem ser passados via linha de comando, mais adiante
veremos como isto funciona.
int main (int argc, char *argv[])
{
Nesta
linha criamos uma variável chamada itau, que guardará valores da classe
Conta. Ou seja, poderemos acessar os métodos e atributos desta classe
através deste objeto. O * informa que itau é também um ponteiro.
Conta *itau;
Antes de usarmos o objeto é necessário alocar espaço na memória para ele.
itau = [Conta alloc];
Após alocar espaço inicializamos as variáveis que fazem parte do objeto, no nosso exemplo os atributos conta e saldo.
itau = [itau init];
Tudo
pronto, começamos a usar o nosso objeto. Acessamos o método setConta
definido na classe e passamos o parâmetro 12 para ele. Em algumas
linguagens se usam o ponto, por exemplo em Java esta chamada poderia
ser itau.setconta(12). Abaixo a chamada deste método em objective-c.
[itau setConta: 12];
Aqui estamos executando o método setSaldo e passando o valor 200.00. Como ele aceita um float, podemos passar a parte decimal.
[itau setSaldo: 200.00];
Agora que preenchemos os atributos do objeto conta e saldo, usamos o método print para imprimir o resultado na console.
itau printSaldo];
Já
usamos o objeto para atribuir os valores e imprimir, agora usamos o
método free para liberar a memória. Este método não foi criado por
você. Como a nossa classe Conta herda Object, ela pode usar este método
que pertence a Object, este é o conceito de herança, não tivemos o
trabalho de implementar este método, simplesmente herdamos ele de outra
classe.
[itau free];
Estamos
finalizando a função main e, na declaração dela, ela exige que se retorne
um inteiro. Estamos retornando o valor zero, que na verdade é um código
para informar ao Sistema operacional que o programa terminou com
sucesso.
return 0;}
Resultado do programa
Extrato bancário
———————–
Conta:12
Saldo:200.000000
Bem,
ficamos por aqui. Estude o exemplo, crie um programa qualquer parecido
e deixe suas dúvidas nos comentários ou me mande um e-mail.
Na
próxima aula iremos fazer alguns exercícios e incrementaremos o nosso
programa de conta, adicionando novos métodos. E estude orientação a
objetos.
Abraço a todos.