segunda-feira, 17 de novembro de 2008

Série objective-C 04 - Orientação a Objetos

Neste quarto artigo da série iremos ver os conceitos iniciais sobre orientação a objetos com objective-c, iremos utilizar um exemplo bem simples para ilustrar conceitos iniciais, aguardo os comentários. Leia o restante do artigo.



**** AVISO IMPORTANTE *****
O código completo eu coloquei nos comentários ou seja o que deve ser digitado, por problemas no Blogger ele ignora alguns caracteres como ">", nos comentários tem mais explicações.
Qualquer dúvida postem nos comentários ou mandem e-mail.
.





Artigos da Série


Série Objective-C 01 - Primeira aplicação via Console Texto
Série Objective-C 02 - Primeira aplicação compilada via XCode


Estou de volta ao blog e 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 tem 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 abaixo:

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 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 acessiveis 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 as classes, nesta diagrama de classe definimos 3 métodos:
setConta, setSaldo e printSaldo. Eles tem escopo público(public), diferente dos nossos atributos, eles podem ser acessados de fora da nossa classe, o parametro void indica que eles não terão retorno algum. Os métodos setConta e setSaldo serão chamados mas terão um parametro 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:

01. Diretrizes para o pré-processador
02. Definição da interface das classes
03. Implementação dos métodos definidos na interface
04. A função main e o ínicio do programa em si.

Listagem do programa em azul:


// 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 este parte do código, definimos as diretrizes do pré-processador, neste caso, incluimos 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 compoem 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 3 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 instanciada o objeto da classe, mas adiante veremos mais detalhes sobre isto. setConta e setSaldo necessitam de um parametro do tipo int e a variavel usada para este parametro é 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




Inicio 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 variavel numberConta no corpo do método definido pelos "{}" 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 variavel valorOperacao no corpo do método definido pelos "{}" 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 parametros 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




4 - 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 parametros podem ser passados via linha de comando, mais adiante veremos como isto funciona.

int main (int argc, char *argv[])
{

Nesta linha criamos uma variavel chamada itau, que guardará valores da classe Conta, ou seja poderemos acessar os métodos e atributos desta classe atraves 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 variaveis 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. 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 bancario
-----------------------
Conta:12
Saldo:200.000000




Bem, ficamos por aqui, estude o exemplo, crie um programa qualquer parecido e poste 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.




10 comentários:

  1. Gostaria de pedir neste artigo que as telas mostrando como ficou. Logo depois da execução dos códigos. Obrigado.

    (mauriciojunior.org)

    ResponderExcluir
  2. por acaso a declaração da interface Conta não seria:

    @interface Conta : NSObject

    Parabens pelo site e pela iniciativa !!

    []'s

    ResponderExcluir
  3. Estou acompanhando o obj-c e estou gostando está mto divertido! e interessante! já pensou em fazer alguma apostila em pdf e por no apostilando.com?

    ResponderExcluir
  4. Nelson Filgueiras7 de abril de 2009 18:26

    Também estou acompanhando essa série e parabenizo o autor pela grande iniciativa e a ótima didática. Infelismente estou tendo dificuldades em fazer o programa funcionar... no item Listagem do programa em azul: você começa com os comentários e parte para a definição de interface... Quando vai explicar o código surge um item anterior a esses: Definindo as diretrizes, que pelo qu entendi tem duas linhas, certo? No meu compilador dá erro: object.h: No such file or directory... No final do código aparece o seguinte erro: Warning 'Conta' may not respond to'-free'... Se removo as duas primeiras linhas e substituo Object pelo NSObject sugerido pelo Fábio o programa executa mais cheio de erros junto com as respostas.

    ResponderExcluir
  5. Amigos,

    Este exemplo tem um problema devido ao Blogger plataforma do Google ignorar alguns caracteres especiais.

    Nos imports vocês devem colocar:
    "#import < stdio.h >"
    "#import < objc/Object.h >"

    Tirem as aspas do exemplos, o sistema de publicação do Blog da problemas com ">".

    ResponderExcluir
  6. // Programa exemplo orientação a objetos
    // Programador: Pierre Freire
    // E-mail: blog@pierrefreire.com.br
    // Versao: 0.01
    // Lembrem de tirar as aspas do codigo abaixo
    // Coloquei apenas para o o sistema do Blog // Aceitar


    "#import < stdio.h >"
    "#import < objc/Object.h >"


    //------------- 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;
    }

    ResponderExcluir
  7. Fabio,

    Na verdade o NSObject é quando você esta usando as classes da Foundation. Como estamos apenas com objective-c a classe herda de Object mesmo.

    Abraços.

    ResponderExcluir
  8. Parabéns pelo blog!

    Tutoriais simples, mas é um bom material pra quem tá iniciando objc.
    Pena que somente foram feitos 6 tutoriais, rs

    ResponderExcluir
  9. Olá Pierre!

    mesmo sendo de 2008 o seu tutorial é fantastico!! parabens

    estou tendo um pequeno probleminha,
    quando compilo o programa é exibido o erro:
    "may not responde to '+alloc'"
    "may not responde to '-unit'"
    "may not responde to '-free'",

    mesmo com os #import's corretos, até testei usar o codigo postado, mas mesmo assim não funciona...

    desde já muito obrigado

    ResponderExcluir
  10. Neylor,

    Tudo bem contigo? Realmente os tutoriais são antigos sim e de lá para cá muita coisa mudou. Inclusive para compilar no Snow Leopard alguns erros existem, pela mudanças do compilador.
    Eu fiz um post explicando o assunto e como se deve compilar no Snow Leopard.
    Veja se resolve.

    http://blog.pierrefreire.com.br/2009/11/curso-de-objective-c-snow-leopard-106.html

    Abraços.

    Pierre

    PS: Estou fazendos novos tutoriais e sugestões serão bem vindas.

    Obrigado pelo comentário.

    ResponderExcluir