Blogue do Rafael: 2011

   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

   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

quarta-feira, 5 de janeiro de 2011

Click Banner

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

Mensagem

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

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.

Quem sou eu

BEM VINDO!!

quarta-feira, 19 de janeiro de 2011

Cursos on-line 24 horas com Certificado

Cursos 24 Horas

segunda-feira, 17 de janeiro de 2011

Cursos on-line 24 horas com Certificado

Cursos 24 horas com Certificado

Cobra Tecnologia – 3,7 mil vagas

Click Banner

segunda-feira, 10 de janeiro de 2011

Eucomparo

sexta-feira, 7 de janeiro de 2011

UM MILHÃO DE VISITAS EM SEU SITE!!

QUER TER UM MILHÃO DE ACESSOS EM SEU SITE OU BLOG??

Mala Pronta Novo

Lojas KD

Jamster Novo

Imperdível Novo

Extra Novo

Empregos Novo

quinta-feira, 6 de janeiro de 2011

Empregos Novo

Editora Europa Novo

Desejo Mania Novo

Herança - Exemplo

Herança - Introdução

Linkk no Seu Blog

quarta-feira, 5 de janeiro de 2011

Click Banner

Mensagem

Objetos

Arquivo do blog

Doe e ajude a melhorar o Blog

Quem sou eu

BEM VINDO!!

Inscrever-se

quarta-feira, 19 de janeiro de 2011

Cursos 24 Horas

segunda-feira, 17 de janeiro de 2011

Cursos 24 horas com Certificado

segunda-feira, 10 de janeiro de 2011

sexta-feira, 7 de janeiro de 2011

quinta-feira, 6 de janeiro de 2011

quarta-feira, 5 de janeiro de 2011

Arquivo do blog

Doe e ajude a melhorar o Blog