Desenvolvedores.Net - TechBlog

Definições – Avançado (POO)

4
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (3 votos, média: 4,33 de 5)
Loading...
7 de janeiro de 2011
Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)
Generalização
Generalização é o ato de tornar um objeto geral, agrupar características comuns para objetos dentro de um mesmo contexto, abstrair.
Eu tenho, por hábito e não por regra, a minha classe “Pai de Todas”(superclass) ser sempre abstrata.Veja o diagrama:
Neste caso a minha classe “Pai de Todas”(superclass) é a classe “Pessoa” 

    

Se olharmos de cima para baixo podemos ver todos os objetos gerais, no topo temos a Pessoa, que pode ser um Cliente, um Usuário. O Usuário por sua vez pode ser um Administrador, que tem poderes especiais, o mesmo pode Excluir ou Inserir novos usuários.
E se olharmos de baixo para cima? Aí teremos o próximo tópico Especialização. 🙂

  

Especialização
A especialização nada mais é do que a parte que “especializa” o objeto vindo de uma Generalização, trazer características próprias para o objeto. Seria o mesmo que olhar o diagrama acima de baixo para cima.
Veja:
O objeto Administrador  especializa o objeto Usuario que por sua vez especializa o objeto Pessoa.    

  

Delagates
Os delegates  são ponteiros para funções (métodos).

O que são ponteiros?
Ponteiro é um valor atribuído em memória que aponta para outro valor em memória através de seu endereço. (não gostei, técnico demais pro meu gosto). 
 

 

Quando há a necessidade de usarmos métodos, e ainda não sabemos qual método chamar, pois dependemos de algumas condições, podemos deixar o nosso código mais bonito usando um delegate.   

O delegate irá chamar o método definido de acordo com a nossa necessidade ou condição.   

Veja exemplo:
Abaixo temos um exemplo de uma aplicação Console em C#. 

static class Program
    {
        //declara a assinatura do delegate.
        //os métodos deverão ter a mesma assinatura
        //para que possam ser utilizados pelo delegate
        delegate int Calular(int a, int b);

        static void Main()
        {

            //declara a variável do tipo delegate
            Calular calc;

            //uma condição qualquer
            if (DateTime.Now.Second % 2 == 0)
                //define o método dividir para ser usado no delegate
                calc = new Calular(Dividir);
            else
                //define o método somar para ser usado no delegate
                calc = new Calular(Somar);

            //chama o método
            Console.WriteLine(calc.Invoke(DateTime.Now.Millisecond,
DateTime.Now.Second));

            Console.ReadKey();
        }

        //declara o método somar
        private static int Somar(int a, int b)
        {
            return a + b;
        }

        private static int Dividir(int x, int y)
        {
            return x / y;
        }
    }

Eventos
Eventos são mensagens trocadas pelos sistemas, métodos e objetos para informar um acontecimento, uma ação que se inicia,  que termina dentro da aplicação, como o próprio nome diz, um evento ocorrido.
Vejamos, ao chamar o nosso método Andar() em Pessoa podemos informar que a Pessoa está Andando até que pare de andar , ou podemos informar que a pessoa vai parar de Andar antes de realmente ela parar de Andar. (AntesPararAndar), assim sendo o objeto chamante pode executar alguma ação antes de a Pessoa realmente parar de Andar.  

 Exemplo de eventos em C#:
Para usar eventos em C# temos que fazer uso de delegates como foi visto acima o delegate e um ponteiro para uma função (método), e eventos usam delegates para apontar a qual método o mesmo deverá chamar.   

Declaração de Pessoa

public class Pessoa
    {  
        //declaração da assinatura do delegate
        //que irá tratar os eventos
        public delegate void AndarHandler();

        //este evento irá mostrar que podemos esperar
        //retorno do objeto que chamou
        //o parâmetro pararAndar irá retornar true or false
        //dependendo do caso se for ou não para parar de andar
        public delegate void AndandoHandler(out bool pararAndar);

        //declaração dos eventos
        public event AndarHandler AntesAndar;
        public event AndarHandler AntesPararAndar;

        //repare aqui que iremos usar o segundo delegate
        public event AndandoHandler Andando;
       
        //declaração do método andar
        public void Andar()
        {
            //aqui iremos chamar o evento AntesAndar e avisar
            //o objeto chamante que iremos começar a Andar.
            AntesAndar();

            DateTime pararAs = DateTime.Now.AddSeconds(30);

            //aqui iremos andar por 30 segundos
            while (pararAs > DateTime.Now)
            {
                bool pararAgora = false;
                //aqui iremos notificar que a
                //pessoa continua Andando
                Andando(out pararAgora);

                if (pararAgora)
                {
                    //antes de parar, notificar que vou parar
                    AntesPararAndar();
                    break;
                }

                //aqui apenas iremos parar por um segundo.
                //não se preocupem com esta linha
                System.Threading.Thread.Sleep(1000);
            }
        }
    }

Declaração do objeto para testes.
É uma aplicação do tipo Console. 

static void Main()
        {
            //cria uma pessoa
            Pessoa marcelo = new Pessoa();

            //define os métodos que irão tratar os nossos eventos
            marcelo.Andando +=
new Pessoa.AndandoHandler(marcelo_Andando);
            marcelo.AntesAndar +=
new Pessoa.AndarHandler(marcelo_AntesAndar);
            marcelo.AntesPararAndar +=
new Pessoa.AndarHandler(marcelo_AntesPararAndar);

            //chamar o método para que marcelo possa Andar
            marcelo.Andar();

            Console.WriteLine("Marcelo parou de andar.");

            Console.ReadKey();

        }

        static void marcelo_AntesPararAndar()
        {
            Console.WriteLine("Marcelo irá parar de andar.");
        }

        static void marcelo_AntesAndar()
        {
            Console.WriteLine("Marcelo irá começar a andar.");
        }

        static void marcelo_Andando(out bool pararAndar)
        {
            pararAndar = false;
            //a pessoa marcelo só vai parar se a condição for verdadeira
            if (DateTime.Now.Second % 7 == 0)
                pararAndar = true;

            Console.WriteLine("Marcelo está andando.");
        }
SaberMais Para saber mais sobre delegates.

Foi escrito um novo artigo com tópicos avançados sobre delegates.

Delegates

Com isso terminamos a definição de POO. Aguardem agora os próximos artigos que vamos abordar nesse assunto, ainda temos muita coisa para ver.

Ver Índice

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

Compartilhe!

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

3 Comments for this entry

1 Trackback or Pingback for this entry

Deixe uma resposta

O seu endereço de e-mail não será publicado.

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>