Objetos

3. OBJETOS

        O que caracteriza a programação orientada a objetos são os objetos. De um modo
geral podemos encarar os objetos como sendo os objetos físicos do mundo real, tal como:
carro, avião, cachorro, casa, telefone, computador, etc., por isso que às vezes é dito que
orientação a objetos representa os problemas mais próximo ao mundo real, dando assim mais
facilidade a programação como um todo, mais isso não é sempre verdade, porque às vezes
                                  xtremamente funcionais1. Nesses problemas funcionais é difícil
temos problemas que são e
representar a estrutura lógica em torno de objetos. Com isso, não são todos os problemas que
giram em torno dos objetos facilmente visíveis.
        De maneira simples, um objeto é uma entidade lógica que contém dados e código para
manipular esses dados. Os dados são denominados como sendo atributos do objeto, ou seja,
a estrutura que o objeto tem, e o código que o manipula denominamos método. Um método é
uma função que manipula a estrutura de dados do objeto.
        Um objeto é um ente independente, composto por:
??   estado interno, uma memória interna em que valores podem ser armazenados e
     modificados ao longo da vida do objeto.
?? comportamento, um conjunto de ações pré-definidas (métodos), através das quais o
     objeto responderá a demanda de processamento por parte de outros objetos.
        Por exemplo:
           Uma tela de computador pode ter os seguintes atributos e métodos:
                atributos
                modo de operação /* texto/gráfico */
1
  funcionais: gira em torno de processos
                                                                                __________________________________________________________________________________
___
           tamanho horizontal
           tamanho vertical
           paleta de cores
           cor atual
           métodos
           modo texto ( )
           modo gráfico ( )
           fecha modo gráfico ( )
           muda cor ( )
           escreve caracter ( )
           coloca pixel ( )
           muda dimensões (x,y)
           ...
        Um guarda-roupa:
           estrutura
           conjunto de roupas /* tipo, tamanho, cor, estilo, preço, etc. */
           portas
           número de portas
           capacidade máxima
           métodos
           abre porta ( )
           fecha porta ( )
           escolhe roupa ( )
           tira roupa ( )
           coloca roupa ( )
           estado do guarda-roupa ( ) /* portas abertas e fechadas, quantidade de roupas,
                                                etc. */
           ...
        Uma lista:
           estrutura
           (nodo e um apontador para um próximo nodo) Primeiro e atual
           métodos
           cria lista ( ) /* cria célula cabeça e inicializa */
           próximo ( ) /*vai para o próximo elemento da lista */
           insere ( ) /* insere um elemento na posição atual */
           deleta ( ) /* apaga posição atual */
           volta ao começo ( ) /* atual = primeiro */
           ...
                                                                            __________________________________________________________________________________
___
       Podemos notar que um objeto é composto por estrutura e processos, onde esses
processos giram em torno da estrutura, ao contrário das linguagens funcionais, nas quais a
estrutura se adapta a função. Um objeto só pode ser manipulado por sua estrutura e seus
métodos, nada mais do que isso.
       Somente um objeto de um determinado tipo pode acessar seus métodos e estrutura, um
outro tipo de objeto não tem nenhum acesso a estes. Por exemplo, em uma classe cachorro
temos o método fala. Se por exemplo definirmos um objeto da classe gato, este objeto não
tem acesso nenhum ao método fala de cachorro.
       Dentro de um objeto, alguns métodos e/ou estrutura podem ser privados ao objeto, o
que nos diz que são inacessíveis diretamente para qualquer elemento fora dele, o que impede
que outros objetos tenham acesso direto às partes privadas do objeto referenciado. Para o
objeto poder referenciar seus elementos privados ele deve passar pelos seus métodos, neste
caso um método específico que faça a operação desejada, ou seja, ele pode acessar sua
estrutura privada somente através de seus métodos, dando assim uma certa abstração de como
é feita a manipulação da estrutura. Isso consiste no encapsulamento de dados que será
explicado na seção referente a este tema. A princípio toda a estrutura deve ser privada, mas
algumas linguagens como C++ permitem que a estrutura de um objeto possa ser acessada
diretamente por outros objetos. Já em SmallTalk toda a estrutura é privada. Dessa maneira,
um objeto evita significativamente que algumas outras partes não relacionadas de programa
modifiquem ou usem incorretamente as partes privadas do objeto referenciado, dando assim
maior confiabilidade na manipulação do objeto. Isso tudo nos mostra uma característica muito
grande para construção de módulos independentes e abstração ao usuário.
       Mais exatamente, cada objeto é uma instância de sua classe. É a classe que contém a
descrição da representação interna e dos métodos comuns a todas as suas instâncias
(objetos). Cada instância da classe, por sua vez, possui sua própria memória privativa (seu
estado interno) onde ficam armazenados os valores de seus componentes, que representam
suas características individuais. Associando com a linguagem C, uando v define uma
                                                                             ocê
estrutura como por exemplo:
          struct aluno {
                         char nome [30];
                         char telefone [20];
                         int número;
          };
       Quando você declara uma variável do tipo struct aluno você define uma instância da
estrutura aluno.
          main ( ) {
                   struct aluno a; /* a é uma variável do tipo da estrutura aluno */
                   ...
          }
                                                                              __________________________________________________________________________________
___
       Agora quando define uma classe aluno
          class Aluno {
                      char nome [30];
                      char telefone [20];
                      int número;
                      lista_notas notas;
                      ...
          public:
                      insereNota (matéria, nota);
                      listaNotas ( );
                      ...
          };
       Definiremos uma variável aluno
          void main ( ) {
                      Aluno João;
                      ...
          }
       Neste caso João é uma variável (instância) do tipo aluno, o qual denominamos de
objeto, porque a classe aluno descreve uma estrutura que o caracteriza e métodos que o
manipulam.
       Com isso podemos diferenciar claramente uma classe de objeto. A classe é apenas um
tipo de dado, que somente representa características comuns a determinados objetos. Uma
classe pode ser comparada com uma estrutura, com apenas uma forma definida, mas nenhuma
variável que a manipula. Para manipulá-las é preciso definir uma variável. Esta variável do tipo
da classe é que é chamada de objeto.
       Os objetos de uma determinada classe não são iguais. Por exemplo, podemos ter os
objetos João e Pedro da classe Aluno, cada um vai ter um nome, telefone, número, notas, e
uma posição na memória. A sua similaridade consiste apenas no fato de que possuem
propriedades idênticas.
       Uma coisa importante de um objeto é seu ciclo de vida, que engloba o momento em que
é declarado até sua eliminação. No instante em que um objeto é declarado, é alocado um
espaço em memória para ele e automaticamente executado seu construtor. A partir deste
momento o objeto está pronto para ser usado. Esta fase vai até a eliminação do objeto. A sua
eliminação pode ser de duas formas: a primeira, que todas as linguagens utilizam, elimina o
objeto no final do programa se ele for global, no final de um módulo se for local, e no final de
um bloco se for declarado dentro deste. A segunda forma de eliminação é chamada de
Garbage Collection. Esta maneira de eliminação não é implementada em todas as linguagens e
                                                                               __________________________________________________________________________________
___
não é uma característica somente de orientação a objetos. Garbage Collection consiste em
eliminação pelo compilador do objeto/variável depois de sua última utilização. A partir do
momento em que ele não é mais referenciado, passa a não existir mais na memória. Por
exemplo, Garbage Collection é implementado em Lisp e SmallTalk enquanto que em C++ e
Pascal não. Quando o objeto é eliminado ele automaticamente executa seu destrutor.
       Em programação orientada a objetos, primeiramente o que deve ser identificado são os
objetos que o problema requer (até mesmo os tipos simples de dados são vistos como objetos,
porque têm estrutura e operações (métodos) que o manipulam). Por exemplo um objeto inteiro
é comparado com outro, recebe uma atribuição, tem operações aritméticas. Esta nova
concepção não é tão fácil de ser encarada, principalmente para quem já é experiente em
programação imperativa. As principais dificuldades a princípio são a identificação dos objetos,
e o tratamento do problema somente através de objetos.