Blogue do Rafael

   Exemplo 1

// mostra acesso público, privado e protegido à classe-base
#include
using namespace std;
class Base
{
           protected : int secreto;
           private : int ultraSecreto;
           public : int publico;
};
class Derivada1 : public Base
{
           private:
                      int a, b, c;
           public:
                      Derivada1( )
                      {
                                   a = secreto;        // ok
                                   //b = ultraSecreto; // erro: não acessível
                                   c = publico;        // ok
                      }
};

class Derivada2 : private Base
{
           private:
                     int a, b, c;
           public:
                     Derivada2( )
                     {
                                  a = secreto;        // ok
                                  //b = ultraSecreto; // erro: não acessível
                                  c = publico;        // ok
                     }
};
class Derivada3 : protected Base
{
           private:
                     int a, b, c;
           public:
                     Derivada3( )
                     {
                                  a = secreto;        // ok
                                  //b = ultraSecreto; // erro: não acessível
                                  c = publico;        // ok
                     }

};

int main( )
{
   int x;
   Derivada1 obj1;              // Derivada1 é pública
   //x = obj1.secreto;                 // erro: não acessível
   //x = obj1.ultraSecreto;         // erro: não acessível
   obj1.publico = 1;                   // ok
   x = obj1.publico;
   Derivada2 obj2;              // Derivada2 é privada
   //x = obj2.secreto;           // erro: não acessível
   //x = obj2.ultraSecreto;      // erro: não acessível
   //x = obj2.publico;           // erro: não acessível
   Derivada3 obj3;              // Derivada3 é protegida
   //x = obj3.secreto;           // erro: não acessível
   //x = obj3.ultraSecreto;      // erro: não acessível
   //x = obj3.publico;           // erro: não acessível
   cout << "x = obj1.publico: " << x << endl << endl;
   system("pause");
   return 0;

}

Herança - Introdução

2011-01-06T04:18:00.000-08:00

   Introdução

• Herança
   – Reusabilidade de software;
   – Cria uma nova classe de uma classe existente.
      • Absorve os dados e os comportamentos da classe
        existente;
      • Aprimora esses dados com novas capacidades;
   – A classe derivada herda da classe básica.
      • Classe derivada
          – Grupo mais especializado de objetos;
          – Contém comportamentos herdados da classe básica;
              • Os quais podem ser personalizados;
          – E outros comportamentos.

• Hierarquia de classes

   – Classe básica direta
      • É herdada explicitamente (de um nível acima da
        hierarquia);
   – Classe básica indireta
      • É herdada de dois ou mais níveis da hierarquia;
   – Herança simples
      • Herda de uma classe básica;
   – Herança múltipla
      • Herda de múltiplas classes básicas;
          – Classes básicas possivelmente não relacionadas.

• Três tipos de herança

   class Agente : public BaseAgente
   – public
      • Os membros públicos da classe-base serão membros públicos da
        classe derivada;
      • Os membros protegidos da classe-base serão membros
        protegidos da classe derivada;
      • Assim, membros públicos da classe-base podem ser acessados
        por um objeto da classe derivada;
   class Agente : private Agente
   – private
      • Os membros públicos e protegidos da classe-base serão
        membros privados da classe derivada;
      • Esses membros estarão acessíveis aos da classe derivada, mas
        um objeto da classe derivada não terá acesso a nenhum membro
        da classe-base;

• Três tipos de herança

   class Agente : protected BaseAgente
   – protected
      • Os membros públicos quanto os protegidos da classe-base
        serão protegidos da classe derivada;
      • Esses membros estarão disponíveis aos da classe derivada
        e a classes herdadas desta;
      • Um objeto da classe derivada não terá acesso a nenhum
        membro da classe-base.

Linkk no Seu Blog

2011-01-06T04:02:00.000-08:00

Click Banner

2011-01-05T08:36:00.000-08:00

http://www.cliquebanner.com/?indic=Rafa84

Mensagem

2011-01-05T04:59:00.000-08:00

4. MENSAGENS

      Mensagens são requisições para que um objeto execute uma de suas ações. Cada objeto
somente pode responder às mensagens que constem do seu protocolo. O protocolo de um
objeto são as mensagens correspondentes as suas operações, além do protocolo de sua
superclasse.
      Os objetos interagem através de mensagens.
      O atendimento de uma mensagem envolve a execução de algum tipo de código, ou seja,
os métodos, sobre um dado associado àquela operação, ou seja, sobre os atributos.
      Quando um objeto é criado, o acesso a suas características é feito através de
mensagens. Para cada mensagem recebida pelo objeto, existe um método associado para
respondê-la. Quando a mensagem estiver se referenciando a um atributo, o valor deste deve
ser devolvido, e no caso de uma operação, o procedimento desta é executado.
      As operações podem ter parâmetros de entrada e saída com tipos determinados. Esta
característica, juntamente com o seu nome, definem a assinatura de uma mensagem.
      Exemplo de mensagem, utilizando a classe fila:
        seja a declaração de um objeto:
        fila fila_atual;
        .
        .
        .
        A mensagem a este objeto seria:

__________________________________________________________________________________
___
       fila_atual.get( );

Objetos

2011-01-05T04:52:00.000-08:00

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.

Classes, Métodos e Atributos

2011-01-05T04:48:00.000-08:00

2. CLASSE

       Classe é o termo técnico utilizado em linguagens orientadas a objetos que descreve um
conjunto de dados estruturados que são caracterizados por propriedades comuns. Também
pode ser interpretado como uma estrututura modular completa que descreve as propriedades
estáticas e dinâmicas dos elementos manipulados pelo programa.
       Pode-se definir classes de objetos como a descrição de um grupo de objetos por meio
de um conjunto uniforme de atributos e serviços. Uma classe é um conjunto de objetos que
compartilham as mesmas operações.
       Enquanto um objeto individual é uma entidade concreta que executa algum papel no
sistema como um todo, uma classe captura a estrutura e o comportamento comum a todos os
objetos que são relacionados. Um objeto possui uma identidade e suas características serão
definidas para a classe.
       Uma classe é definida por:
?? um nome da classe;
?? o nome da sua superclasse;
?? o nome de suas variáveis privadas;
?? os nomes e as definições de todas as operações associadas a esta classe;
       Classe é um conceito estático: uma classe é um elemento reconhecido num texto de
programa. por outro lado, um objeto é um conceito puramente dinâmico, o qual pertence não
ao texto do programa, mas à memória do computador, local onde os objetos ocupam espaço
durante a execução. (Conceitualmente, classes não são necessárias durante a execução, mas
em linguagens interpretadas elas podem ser mantidas).
       Exemplo de classe:
       Uma classe é semelhante a uma struct e em C++ podemos definir a classe fila do
seguinte modo:
class fila {
         int f [100];
         int primeiro, ultimo;
                                                                               __________________________________________________________________________________
___
public:
         void inicio (void);
         void put (int valor);
         int get (void)
};
       Examinando a declaração anterior, vemos:
       Uma classe pode contertanto partes públicas como privadas. Por exemplo, as variáveis f
, primeiro e ultimo são privadas. Isto significa que não podem ser acessadas por qualquer
função que nao seja membro dessa classe.
       Para tornar públicas as partes de uma classe, ou seja, acessíveis o outras partes do
programa, é preciso declará-las após a palavra public.

2.1 ATRIBUTOS

       Um atributo é um dado para o qual cada objeto tem seu próprio valor.
       Atributos são, basicamente, a estrutura de dados que vai representar a classe.
       Exemplo de atributos, usando a classe fila:
       int f [100] ;
       int primeiro, ultimo;

2.2 MÉTODOS

       Métodos são declarados dentro de uma classe para representar as operações que os
objetos pertencentes a esta classe podem executar.
       Um método é a implementação de uma rotina, ou seja, o código propriamente dito. Pode
ser comparado a um procedimento ou função das linguagens imperativas.
       Exemplo de métodos, utilizando a classe fila:
void iniciar (void)
{
         primeiro = 0;
         ultimo = 0;
};
                                                                                 __________________________________________________________________________________
___
void put ( int valor)
{
         f [ultimo] = valor;
         ultimo++;
};
int get (void)
{
         return f [primeiro];
         primeiro++;
};

Introdução - POO

2011-01-05T04:45:00.000-08:00

PROGRAMAÇÃO
ORIENTADA
      A
   OBJETOS
1. INTRODUÇÃO                                          1
1.1 UM BREVE HISTÓRICO DE LINGUAGENS DE PROGRAMAÇÃO 1
1.2 PROGRAMAÇÃO ORIENTADA A OBJETOS                  2
2. CLASSE                                              5
2.1 ATRIBUTOS                                        6
2.2 MÉTODOS                                          6
3. OBJETOS                                             7
4. MENSAGENS                                          11
5. ENCAPSULAMENTO                                     12
6. HERANÇA                                            14
7. POLIMORFISMO                                       20
7.1 Definição:                                      20
7.2 Tipos Clássicos de Polimorfismo:                23
8. LATE BINDING                                       23
8.1 Definição                                       23
8.2 Tipos                                           24
8.3 Ligação Precoce e Tardia (O. O.)                25
    8.3.1 Dynamic Typing E Dynamic Binding - O.O.     25
8.4 Conclusões                                      27
9. BIBLIOGRAFIA                                       28
__________________________________________________________________________________
___
1. INTRODUÇÃO
1.1 UM BREVE HISTÓRICO DE LINGUAGENS DE PROGRAMAÇÃO
       Os caminhos da programação têm mudado dramaticamente desde a invenção do
computador. A primeira razão para as mudanças é acomodar o aumento da complexidade dos
programas. Por exemplo, quando os computadores foram inventados, a programação era feita
por chaveamentos em instruções binárias de máquina, usando-se o painel frontal. Enquanto os
programas continham somente algumas centenas de instruções, esse método funcionava.
Quando cresceram, a linguagem assembly foi inventada para permitir a um programador
manipular complexidades. A primeira linguagem de alto nível difundida foi, obviamente,
FORTRAN. Ainda que o FORTRAN tenha dado um primeiro passo bastante considerável, é
uma linguagem que somente torna os programas mais claros e fáceis de entender do que o
assembly, sem introduzir mudanças consideráveis no estilo de programação.
       Nos anos 60 nasceu a programação estruturada. Esse é o método estimulado por
linguagens como C e Pascal. Usando-se linguagens estruturadas, foi possível, pela primeira vez,
escrever programas moderadamente complexos de maneira razoavelmente fácil. Entretanto,
com programação estruturada, quando um projeto atinge um certo tamanho, torna-se
extremamente difícil e muito custoso efetuar sua manutenção e fazer qualquer modificação. A
cada marco no desenvolvimento da programação, métodos foram criados para permitir ao
programador tratar com complexidades incrivelmente grandes. Cada passo combinava os
melhores elementos dos métodos anteriores com elementos mais avançados. Atualmente,
muitos projetos estão próximos ou no ponto em que o tratamento estruturado não mais
funciona. Para resolver esse problema, a programação orientada a objetos foi criada.
       A programação orientada a objetos aproveitou as melhores idéias da programação
estruturada e combinou-as com novos conceitos poderosos que levam a ver na tarefa de
programação uma nova luz, permitindo que um problema seja mais facilmente decomposto em
subgrupos relacionados. Então, usando-se a linguagem, pode-se traduzir esses subgrupos em
objetos.
       A primeira linguagem a incorporar facilidades para definir classes de objetos genéricos na
forma de uma hierarquia de classes e subclasses foi a linguagem Simula, que foi idealizada em
1966, na Noruega, como uma extensão da linguagem ALGOL 60.
       Uma classe em Simula, é um módulo englobando a definição da estrutura e do
comportamento comuns a todas as suas instâncias (objetos). Como o nome indica, é uma
linguagem adequada à programação de simulações de sistemas que podem ser modelados pela
interação de um grande número de objetos distintos.

__________________________________________________________________________________
___
       As idéias de Simula serviram de base para as propostas de utilização de Tipos Abstratos
de Dados, e também para Smalltalk. Smalltalk foi desenvolvida no Centro de Pesquisas da
Xerox durante a década de 70, e incorporou, além das idéias de Simula, um outro conceito
importante, devido a Alan Kay, um de seus idealizadores: o princípio de objetos ativos, prontos
a “reagir” a “mensagens” que ativam “comportamentos” específicos do objeto. Ou seja, os
objetos em Smalltalk deixam de ser meros “dados” manipulados por “programas”, e passam a
ser encarados como “processadores idealizados” individuais e independentes, aos quais podem
ser transmitidos comandos em forma de “mensagens”.
       Outras linguagens orientadas para objetos tem sido desenvolvidas. Notadamente C++,
uma extensão de C, Objetive-C, outra extensão de C, menos popular que a anterior, Pascal
orientado a objetos, Eiffel e mais recentemente, no Brasil, TOOL.
       Além da Xerox, que criou a ParcPlace Systems especialmente para comercializar
Smalltalk-80 e seus sucedâneos (objectWorks), a Digitalk lançou em 1986 uma versão de
Smalltalk para ambiente DOS, e mais recentemente a versão para Windows, o que contribuiu
para uma maior difusão da linguagem [Digitalk].
       Smalltalk, uma das mais populares linguagens orientadas a objetos, assim como outras
linguagens orientadas para objetos, tem sido usada em aplicações variadas onde a ênfase está
na simulação de modelos de sistemas, como automação de escritórios, animação gráfica,
informática educativa, instrumentos virtuais, editores de texto e bancos de dados em geral,
entre outras. Tais aplicações diferem substancialmente daquelas em que a ênfase está na
resolução de problemas através de algoritmos, tais como problemas de busca, otimização e
resolução numérica de equações. Para essas aplicações, é mais adequado o uso de linguagens
algorítmicas convencionais, como Pascal, Algol e Fortran.
1.2 PROGRAMAÇÃO ORIENTADA A OBJETOS
       Uma das atividades mais interessantes em Informática é certamente a busca constante de
melhorias nas linguagens e técnicas para o desenvolvimento de software. Desta busca decorrem
as transformações e evoluções das linguagens de programação, surgindo novas linguagens e
novos paradigmas.
       A Programação Orientada a Objetos utiliza os conceitos que aprendemos no jardim de
infância: objetos e atributos, todos e partes, classes e membros. É difícil explicar por que
demoramos tanto a aplicar estes conceitos à análise e especificação de sistemas de informações
- talvez porque estivéssemos ocupados demais “seguindo a boiada” durante o auge da análise
estruturada para imaginar que havia alternativas.
       A Enciclopédia Britânica afirma:
       Na compreensão do mundo real, as pessoas empregam constantemente três métodos de
organização, sempre presentes em todos os seus pensamentos:

__________________________________________________________________________________
___
       (1) Diferenciação, baseado na experiência de cada um, de objetos particulares e seus
atributos - quando distinguem uma árvore, e seu tamanho ou relações espaciais, dos outros
objetos,
       (2) Distinção entre objetos como um todo e entre suas partes componentes - por
exemplo, quando separam uma árvore dos seus galhos, e
       (3) Formação de, e distinção entre, as diferentes classes de objetos - por exemplo,
quando formam uma classe de todas as árvores, uma outra classe de todas as rochas e
distinguem-nas.
       A Programação Orientada a Objetos se apóia nestes três métodos usuais de
organização.
       Programação Orientada a Objetos é a programação implementada pelo envio de
mensagens a objetos. Cada objeto irá responder às mensagens conhecidas por este, e cada
objeto poderá enviar mensagens a outros, para que sejam atendidas, de maneira que ao final
do programa, todas as mensagens enviadas foram respondidas, atingindo-se o objetivo do
programa. Programação Orientada a Objetos, técnicas e artefatos ditos “orientados a objetos”
incluem linguagens, sistemas, interfaces, ambientes de desenvolvimento, bases de dados, etc.
       No entanto, cabe ressaltar que o conceito de Orientação Objeto depende mais da
mentalidade do programador do que da linguagem de programação que está sendo utilizada.
Pode-se conseguir programas razoavelmente orientados a objeto em linguagens tipicamente
estruturadas, assim como pode-se conseguir programas estruturados em linguagens voltadas
para objetos. Tomemos como exemplo a frase:
                       “O navio atraca no porto e descarrega sua carga.”
se analisássemos esta frase estruturadamente, pensaríamos logo em como o navio atraca no
porto e como ele faz para descarregar sua carga, ou seja, pensaríamos na ação que está sendo
feita (que na frase é representada pelos verbos) para transformá-la em procedimento. Em
orientação objeto, o enfoque com que se encara a frase é diferente: primeiro pensaríamos no
objeto navio, no objeto porto e no objeto carga, pensando como eles seriam e procurando
definir seu comportamento. Após isto é que pensaremos em como o navio se relaciona com o
porto e com a carga, e como o porto se relaciona com carga. De modo grosseiro, podemos
dizer que ao analisarmos uma frase pensando estruturadamente, damos ênfase aos verbos, e
pensando orientado a objetos, damos ênfase aos substantivos.
       Pelo que foi visto acima, percebe-se que o programador experiente terá inicialmente
grande dificuldade em migrar para a orientação a objeto, pois terá que esquecer os anos de
prática analisando os problemas estruturadamente, para reaprender a analisá-los de forma
voltada a objeto. Ninguém f ria isto se não tivesse bons motivos. Abaixo são mostradas
                               a
algumas das vantagens que motivam veteranos programadores a readaptar-se para o
paradigma de orientação a objeto:
       ? ?Sensível redução no custo de manutenção do software
       ? ?Aumento na reutilização de código

__________________________________________________________________________________
___
?? Redução no custo de manutenção:
      Na programação orientada a objetos, existem certas características (herança e
encapsulamento) que permitem que, quando for necessária alguma alteração, modifique-se
apenas o objeto que necessita desta alteração, e ela propagar-se-á automaticamente às demais
partes do software que utilizam este objeto. Veremos mais detalhadamente o motivo desta
propagação e os conceitos de herança e encapsulamento em capítulos adiante na apostila.
?? Aumento na reutilização de código:
      Pode-se dizer, de modo simplório, que o conceito de orientação objeto fornece a
possibilidade de um objeto acessar e usar como se fossem seus os métodos e a estrutura de
outro objeto. Deste modo, quando, por exemplo, existirem dois objetos bastante semelhantes,
com mínimas diferenças, pode-se escrever os métodos apenas uma vez e usá-los para os dois
objetos. Apenas os métodos que realmente forem diferentes para os dois objetos é que
precisam ser escritos individualmente. Observamos o exemplo abaixo:
Neste caso, tanto PROFESSOR quanto ALUNO comem, andam e respiram, e foi necessário
escrever o código do método Come ( ), Anda ( ) e Respira ( ) somente uma vez. Apenas os
métodos específicos de PROFESSOR (no caso, Leciona ( ) e Corrige_Prova ( ) ) e de
ALUNO (Assiste_Aula ( ) e Faz_Prova ( ) ) é que precisam ser escritos
      Atualmente existe uma grande discussão sobre o que é exatamente uma linguagem
orientada a objetos. É importante lembrar que um claro conceito de objeto, não caracteriza um
sistema como orientado a objetos. Ao invés de entrarmos na discussão do que seja uma
linguagem orientada a objetos, vamos apresentar os principais mecanismos utilizados nestas
linguagens, sem uma preocupação de explicitar quais deles seriam necessários para dar a uma
linguagem o "Título" de Orientada a Objetos.
      Este texto visa então, introduzir o leitor às principais idéias e conceitos de Programação
Orientada a Objetos. Serão expostos exemplos de implementação em C++ e ilustrações que

__________________________________________________________________________________
___
permitirão um melhor entendimento do assunto. Nas páginas seguintes abordaremos os
conceitos básicos do Paradigma de Orientação a Objetos: Objetos, Classes, Mensagens,
Métodos, Herança, Generalização, Especialização, Abstração, Polimorfismo, Encapsulamento
e Late-Binding. Conheceremos suas definições conceituais, como podem ser aplicados,
quando devem ser utilizados e principalmente por que devemos usar estes conceitos e quais
são suas vantagens e desvantagens sobre a programação estruturada.

Ponto Frio Novo

2011-01-04T09:40:00.000-08:00

Mini System Panasonic c/ Entrada USB - 250 W
De: R$ 899,00 Por: R$ 449,00

DVD Automotivo Philco c/ Tela LCD 7" Touchscreen
De: R$ 999,00 Por: R$ 476,10

Saldão de Eletro
Tudo com 50% de desconto