C# : Polimorfismo nas suas diversas formas (Parte 1)

Fala aí galera.
Hoje o assunto é bem objetivo, vamos falar a respeito de Polimorfismo.

O que é Polimorfismo?
A primeira vista, parece algo como "Várias Formas", na verdade não é tudo isso. Encontrei uma definição bem interessante dada pelo Ivan Ricarte, da Unicamp, onde: "Polimorfismo é o princípio pelo qual duas ou mais classes derivadas de uma mesma superclasse podem invocar métodos que têm a mesma identificação (assinatura) mas comportamentos distintos, especializados para cada classe derivada, usando para tanto uma referência a um objeto do tipo da superclasse. A decisão sobre qual o método que deve ser selecionado, de acordo com o tipo da classe derivada, é tomada em tempo de execução, através do mecanismo de ligação tardia."

Bom e aí, será que ficou claro? Talvez com um exemplo mais simples, dê para entender.

Vou escrever em C#, é bem simples de replicar em Java.
Imagine que você tenha a necessidade de fazer com que Diferentes Classes possuam comportamentos semelhantes:

Em um dos meus exercícios aqui na Lambda3, tive que construir um "processador de URL's", algo que avalia o conteúdo de uma URL e de acordo faz determinada ação.

Nosso processador, não precisa encapsular diversos métodos, pois assim estaríamos dando muita responsabilidade para apenas uma classe, então basicamente o que nosso processador fará é Armazenar uma

Armazenará uma URL e a processará.

ProcessadorUrl:

class ProcessadorUrl
{
    private readonly String endereco;

    public ProcessadorUrl(String url) { this.endereco = url;}

    public String ProcessaUrl() { return endereco; }
}

Feito isso, da pra entender um pouco o que precisamos fazer. Basicamente, agora faremos as classes avaliadoras:
Farei apenas duas, para compreensão simples.

Primeira classe avaliadora:

class AvaliadorGoogle
{
    private readonly String endereco;
    
    public AvaliadorGoogle(String endereco) { this.endereco = endereco; }
    
    public bool Avalia() { return endereco.Contains("google"); }
        
    public string Executa() {
            return endereco.Replace("google", "bing"); }
}

Segunda classe avaliadora:

class AvaliadorAsdrubal
{
    private readonly String endereco;
    
    public AvaliadorAsdrubal(String endereco) { 

       this.endereco = endereco; }

    
    public bool Avalia() { 

       return endereco.Contains("asdrubal"); }
        
    public string Executa(){ 

       return endereco.Replace("asdrubal", "outro"); }
}

Agora nosso processador de URL pode fazer as comparações e retornar o necessário:

class ProcessadorUrl
{
    private readonly String endereco;
        
    public ProcessadorUrl(String url) { this.endereco = url; }
        
    public String ProcessaUrl()
    {
        if(new AvaliadorGoogle(endereco).Avalia())
               return new AvaliadorGoogle(endereco).Executa(); 
        if(new AvaliadorAsdrubal(endereco).Avalia())
               return new AvaliadorAsdrubal(endereco).Executa();
        return "";
    }
}

Então podemos notar que ambas classes, AvaliadorGoogle e AvaliadorAsdrubal, possuem comportamentos semelhantes, por que não fazer uso do Polimorfismo?

Crie uma nova Interface e de o nome de Avaliacao:

interface Avaliacao {
    bool Avalia();
    String Executa();
}

Agora os nossos Avaliadores implementarão essa interface:

class AvaliadorAsdrubal : Avaliacao
{
    private readonly String endereco;

    public AvaliadorAsdrubal(String endereco) { 

       this.endereco = endereco; }

    public bool Avalia() { 

       return endereco.Contains("asdrubal"); }
    
    public string Executa() { 

       return endereco.Replace("asdrubal", "outro"); }
}

Faça o mesmo para o avaliador Google e beleza! Vamos a classe que processa, podemos fazer bom uso do Polimorfismo:

public class ProcessadorUrl
  {
        private readonly String endereco;
        

        public ProcessadorUrl(String url)
        {
            this.endereco = url;
        }
        

        public String ProcessaUrl()
        {
           List<Avaliacao> lista = new List<Avaliacao>();
           lista.Add(new AvaliadorGoogle(endereco));
           lista.Add(new AvaliadorAsdrubal(endereco));
         
           for (var i = 0; i < lista.Count; i++){
               if(lista[i].Avalia()
                  lista[i].Executa();
           }
           return "";
        }
  }

Conseguiram compreender um bom uso do polimorfismo?

Criamos uma Lista de Objetos que implementam a interface Avaliação. Essa, como diz o Jonas, é a parte gostosa da "Herança" :).

Exemplos no meu Github:
https://github.com/aterribili/Mapeando
https://github.com/aterribili/AvaliacaoEnderecosWeb

Qualquer dúvida email-me: abner.terribili@lambda3.com.br ou comente abaixo.

Valeu galera!

Java, C# : Imutabilidade

Fala galera, tudo tranquilo?

Você já teve interesse de conhecer como são as implementações de Listas ? (List do C#, Java)

Basicamente, as interfaces(List) definem os tipos de operações que podem ser realizadas nas Lista. Vou escrever algo bem bacana, faremos uma implementação de Lista Imutável.

Imutabilidade
Basicamente, é uma característica de um objeto permanecer o mesmo sempre. Quer saber mais sobre Imutabilidade: Bruno Nardini http://www.brunonardini.com.br/artigos/favoreca-a-imutabilidade-e-a-simplicidade

A classe String, tanto do Java quanto C# , encapsula alguns métodos de manipulação de String, como o toUpperCase() (C# = ToUpper()), que têm o objetivo de converter sua string para maiúsculo. Porém por baixo dos panos, o que acontece é você receberá uma nova instância, com o conteúdo de sua string antiga convertida para maiúsculo. (Você pode verificar isso nos links acima)

Já definido o que é Imutabilidade, vamos ao conceito básico de Listas Ligadas (Linked List). (http://www.caelum.com.br/apostila-java-estrutura-dados/listas-ligadas/#5-1-solucao-classica-de-lista-ligada)

Uma Lista Ligada é uma lista onde o elemento atual "aponta"(tem o endereço) para/do o seu próximo irmão, analisem a fotografia abaixo:

Um conceito simples, agora vamos a prática, assim podemos misturar os dois conceitos! (Imutabilidade e Linked List). No exemplo vai rolar um pouco Generics, se já sabe legal, caso não: http://en.wikipedia.org/wiki/Generic_programming#Generics_in_Java .

Primeiro, vamos criar uma interface para nossas listas, para isso, crie um projeto novo no Eclipse, dê um nome e vamos lá:

New -> Interface

public interface List {
    T cabeca();
    List cauda();
    List adicionaNoComeco(T elemento);
    T pegaPosicao(int position);
    List removePrimeiraPosicao();
}

Bom e o que é cabeça e cauda?
Cabeça é o elemento superior de nossa lista, ou seja a head da Lista.
Cauda é todo o restante da lista, é composta por sua cabeça e outra cauda, e assim respectivamente.

Nosso método adicionaNoComeco(T elemento) recebe um parâmetro e retorna uma nova Lista com o respectivo elemento adicionado. Bem parecido com o método removePrimeiraPosicao() que remove o primeiro elemento e retorna a cauda da lista.

Bom vamos as implementações, vamos criar uma nova classe, que podemos chamar de No, ou seja, serão os respectivos nós de nossa Lista:

public class No implements List {
    private final T cabeca;
    private final List cauda;

    public No(T cabeca, List cauda) {
        this.cabeca = cabeca;
        this.cauda = cauda;
    }
    @Override
    public T cabeca() {
        return cabeca;
    }
    @Override
    public List cauda() {
        return cauda;
    }
    @Override
    public List adicionaNoComeco(T elemento) {
        return new No(elemento, this);
    }
    @Override
    public T pegaPosicao(int position) {
        if (position == 0)
            return cabeca();

        return cauda.pegaPosicao(position - 1);
     }
    @Override
    public List removePrimeiraPosicao() {
    return cauda();
    }
}

Entenda:
Ao criar um No, nós receberemos a cabeça (elemento) e sua respectiva cauda (List). Fora o método pegaPosicao, o restante é bem trivial, por isso não entrarei em maiores detalhes.

pegaPosicao(T elemento)
Esse método faz uso recursivo de si próprio, ou seja, ele percorre a cauda, caso o posicao não seja 0, e recursivamente ele vai caminhando de cabeça em cabeça, das caudas, para encontrar o elemento desejado. Bem simples e objetivo.

Certo, feito isso, fica simples entender algumas coisas, a primeira de todas, como será o fim de nossa lista?
Temos que saber onde a Lista tem seu final e como o fazemos?

Faremos outra implementação de List, que agora chamaremos de Nil, será o fim de nossa lista.

public class Nil implements List {
    @Override
    public T cabeca() {
        throw new RuntimeException("Lista Vazia");
    }
    @Override
    public List cauda() {
        throw new RuntimeException("Lista Vazia");
    }
    @Override
    public List adicionaNoComeco(T elemento) {
        return new No(elemento, this);
    }
    @Override
    public T pegaPosicao(int position) {
        throw new RuntimeException("A lista não possui elementos");
    }
    @Override
    public List removePrimeiraPosicao() {
        throw new RuntimeException(
        "Impossível remover elementos de uma lista vazia");
    }
}

O Nil, que como dito acima, tem o objetivo de ser o fim da lista, a única coisa que podemos escrever interessante ao seu respeito é que a reescrita do método adicionaNoComeco vai retornar uma nova instância de No, ou seja, iniciaremos uma lista.

Feito isso, temos um Container, o List, que armazena valores e possui funções para alterar os dados internos, isso nos ajuda muito com a Imutabilidade, nos sentimos mais seguros e sabemos que nosso objeto não será um mutante, que pode perder/alterar seus valores em tempo de execução.

Bom galera, o conceito de hoje foi bem bacana e construtivo, é o que tenho mais feito no meu treinamento com o Jonas, aqui na Lambda3. Espero que tenha ficado claro.

Para os C# manjadores, no meu Github tem um exemplo parecido escrito em C#. Para os Javas, deixarei outro repositório no GitHub já com os testes implementados.

Qualquer dúvida ou sugestão email-me: abner.terribili@lambda3.com.br ou comente abaixo!

Valeu galera!