Exemplos práticos de Polimorfismo

Por exemplo se você tem uma class Animal sabe que todo animal come, sendo que Cães por exemplo comem ração e Tigres carne. Você pode chamar o método comer nessas 2 classes mesmo sabendo que elas se comportam diferentemente.

public class Animal {
     public void comer() {
          System.out.println( "Animal Comendo..." );
     }
}


public class Cao  extends Animal {
     public void comer() {
          System.out.println( "Cão Comendo..." );
     }
}


public class Tigre extends Animal {
     public void comer() {
          System.out.println( "Tirgre Comendo..." );
     }
}

no caso a sua chamado de método polimorfico ficaria assim

publci class Test {

  public void fazerAnimalComer( Animal animal ) {
       animal.comer();
  }

  public static void main( String[] args ) {
       Test t = new Test();
        t.fazerAnimalComer( new Animal() );
        t.fazerAnimalComer( new Cao() );
        t.fazerAnimalComer( new Trigre() );
   }
}

você vai notar que cada chamada vai fazer uma coisa diferente, porem como existe herança entre as classes todos os método vao funcionar, porque são do tipo do mais genérico (Animal) ou são filhos do mais genérico.

Na realidade polimorfismo é a capacidade de uma referencia de um tipo generico referenciar um objeto de um tipo mais especifico, ex.:

public interface Carro{
   public void acelerar();
}

public Ferrari implements Carro{
   public void acelerar(){
      System.out.println("Ferrari acelerando...");
   }
}

public Fusca implemets Carro{
   public void acelerar(){
      System.out.println("Fusca tentando acelerar...");
   }
}

Carro c = new Ferrari();
c.acelerar();
c = new Fusca();
c.acelerar();

Veja que o tipo da variavel é Carro, mas o objeto colocado nela não é Carro e sim Ferrari e Fusca.

Outro exemplo:

public interface Conexao{
   public void conectar();
}

public class DialUp implements Conexao{
   public void conectar(){
      System.out.println("Modem discando...");
   }
}

public class Adsl implements Conexao{
   public void conectar(){
      System.out.println("Adsl conectado...");
   }
}

Conexao con = new DialUp();
con.conectar();
con = new Adsl();
con.conectar();

Novamente, o tipo da variavel é Conexao, mas não referencia um objeto do tipo Conexao, mas sim um objeto DialUp ou Adsl, essa variavel con pode referenciar qualquer objeto que implemente a interface Conexao (ou extenda a classe, se for uma).

Veja mais em:
http://pt.wikipedia.org/wiki/Polimorfismo

Espero que tenha ajudado.

Outra categoria de polimorfismo é a sobrecarga de métodos, por exemplo, vc tem 3 métodos, utilizando o exemplo do animal:

public void comer(Peixe peixe)

public void comer(Gato gato)

public void comer(Cachorro cao)

ambos os métodos possuem o mesmo nome, porém o que os torna polimorficos é o tipo de parâmetro, o número de parâmetros tbm pode variar.

Há discussões sobre ‘falso’ polimorfismo, que seria a variação do tipo de retorno, porém isso não é aceito no Java.

Como disseram, existem dois tipos de polimorfia: override e overload

Override: substituir um método de um ascendente (classe-mãe, interface, etc.) por um novo tipo de realizá-lo. Note por exemplo que todo objeto é descendente da classe Object, e portanto, possuem todos os métodos que essa classe tem, como wait() e toString(), embora você possa modificá-los na sua classe a bel prazer, para terem atitudes diferentes (utilizo muito com o toString(), pra mostrar um relatório completo do objeto da forma que eu quiser)

Overload: o mesmo método com parâmetros diferentes, executando ações diferentes (a versão não-gambiarra do parâmetro Optional, por assim dizer). Um exemplo bem dado disso são os diálogos JOptionPane, que recebem diferentes valores, deixando os outros como default: JOptionPane.showMessageDialog (null, “Mensagem”) ou JOptionPane.showMessageDialog(null, “Mensagem”, “Título”, JOptionPane.INFORMATION_MESSAGE) ativa métodos diferentes, mas com o mesmo nome. Largamente utilizado para construtores (deixar atributos como padrão ou já settados)

edit: me passaram link disso e postei sem ver a data, aff que raiva -.-"
sorry

Mephy:

Como disseram, existem dois tipos de polimorfia: override e overload

Override: substituir um método de um ascendente (classe-mãe, interface, etc.) por um novo tipo de realizá-lo. Note por exemplo que todo objeto é descendente da classe Object, e portanto, possuem todos os métodos que essa classe tem, como wait() e toString(), embora você possa modificá-los na sua classe a bel prazer, para terem atitudes diferentes (utilizo muito com o toString(), pra mostrar um relatório completo do objeto da forma que eu quiser)

Overload: o mesmo método com parâmetros diferentes, executando ações diferentes (a versão não-gambiarra do parâmetro Optional, por assim dizer). Um exemplo bem dado disso são os diálogos JOptionPane, que recebem diferentes valores, deixando os outros como default: JOptionPane.showMessageDialog (null, “Mensagem”) ou JOptionPane.showMessageDialog(null, “Mensagem”, “Título”, JOptionPane.INFORMATION_MESSAGE) ativa métodos diferentes, mas com o mesmo nome. Largamente utilizado para construtores (deixar atributos como padrão ou já settados)

edit: me passaram link disso e postei sem ver a data, aff que raiva -.-"
sorry

sim, a data é velha, mas sua contribuição de 2011 acabou de ser lida em 2013 … hihih obrigado.

haha, é isso ai!

mesmo depois de um tempo, os posts ainda são sempre muito bem utlizados

Sempre recomendo esse exemplo:

Realmente Rodrigo Sasaki , este exemplo é muito prático e fácil de entender.
Porém, observe o código a seguir, eu tenho uma opinião sobre o assunto:

http://fernandofranzini.wordpress.com/2010/07/07/pizzaria-polimorfica-2/

O exemplo da imagem, pode ser melhorado!
Já que foi utilizado interface, o mais correto e mais utilizado, seria:

Pizza pizzaCalabresa  = new Calabresa();
Pizza pizzaNapolitana  = new Napolitana();

declarar as variáveis do tipo da interface, ja que as classes de Calabresa e Napolitana implementam a interface Pizza…

mudando um pouco do assunto, só para adicionar um pouco mais o assunto, o exemplo citado com interface se encaixa ‘quase’ em Padrões de Projeto : modelo Strategy.

Polimorfismo + Encapsulamento são uma arma muito forte para um programador, alem dos exemplos dados imagine a seguinte situação você tem um método que retorne um ArrayList contendo uma lista (por exemplo : lista de compras), depois de alguns dias você resolve mudar o objeto de retorno de ArrayList para LinkedList (mas ainda sendo uma lista de compras), você faz isso por causa do desempenho você notou que o LinkedList era mais eficaz mas essa pequena mudança é perigoso pois você terá que sair procurando no seu código todo todos os lugares que você utiliza o seu metodo, e se o projeto for um projeto grande (tipo grande mesmo), isso provavelmente irá geral muitos bugs e dores de cabeça, uma simples mudança dessa

Mas como evitar isso ?

simples o LinkedList e o ArrayList implementa as funcionalidades de um List então se desde o inicio quando você tivesse criado o seu método para gerar a lista ao invés de você falar que ele gera um ArrayList você diz que ele gera um List, a vantagem disso é que se você mudar o objeto de retorno de ArrayList para LinkedList não vai dar problema nem dor de cabeça e você n vai precisar sair procurando no código as utilizações e etc.

esse é um exemplo também de Polimorfismo então sempre que você for definir o retorno de um método se possível indique sempre uma classe interface ou abstrata ou mãe, da quela que você está trabalhando mas como eu disse SE possivel, sempre procure usar esses recursos