Bom amigos,
todos disseram exatamente como funciona o mecanismo, mas
porque existem as interfaces?
As interfaces existem para que vc possa criar um agrupamento de objetos diferentes nao relacionados por heranca que possuam algo em comum!
Por exemplo, o que tem em comum uma conta bancaria, uma conta poupanca e uma acao da bolsa de valores?Bom, entre as contas exite uma heranca clara, logo poderiamos ter uma classe Conta, um outra classe ContaCorrente que extende Conta e uma outra classe ContaPoupanca que tambem extende Conta.
Ok nosso design esta ficando bom, mas o que tem em comum essas contas e uma acao da bolsa de valores?? Simples para o meu banco, tudo isso ai eh um produto interno. No momento que os meus rendimentos mensais forem calculados nao importa o que seja: conta, acoes, pic itau
para o banco tudo eh produto interno, entao poderemos criar uma interface ProdutoInterno.
Com essa interface poderemos agrupar coisas diferentes dentro da heranca, mas que dado um determinado ponto de vista elas sao iguais!
logo:
[code]/*
Como as contas filhas sao as que realmente possuem o negocio
nao queremos objetos Conta por ai, logo Conta eh abstrata!
*/
public abstract class Conta{
private double saldo;
}
public class ContaCorrente extends Conta{
private double chequeEspecial;
}
public class ContaPoupanca extends Conta{
private static double taxaDeRendimento;
}
public class PicItau{
private double valor;
private double taxaDeRendimentos;
}
[/code]
criamos a interface e tudo muda um pouco:
public interface ProdutoInterno{
public double calculaRendimentos();
}
Com essa Interface criamos um processo para calcular rendimentos obrigando que cada ProdutoInterno tenha seu metodo calculaRendimentos sendo que o tipo exato do produto interno sera transparente:
[code]/*como conta eh abstrata nao obriga a escrita do metodo, mas
as classes filhas irao escreve-lo
*/
public abstract class Conta implements ProdutoInterno{
private double saldo;
}
public class ContaCorrente extends Conta
private double chequeEspecial;
public double calculaRendimentos(){…}
}
public class ContaPoupanca extends Conta
pirvate static double taxaDeRendimento;
public double calculaRendimentos(){…}
}
public class PicItau implements ProdutoInterno{
private double valor;
private double taxaDeRendimentos;
public double calculaRendimentos(){…}
}
[/code]
Dessa maneira temos certeza que todos os Produtos internos teram um metodo “public double calculaRendimentos(){…}” mas o interessante eh que cada um deles fara de uma maneira diferente, possibilitando que o calculo do rendimento do pic itau tenha suas proprias regras e seja completamente diferente das regras do calculo de rendimentos da poupanca por exemplo. E o melhor, totalmente encapsulado e transaparente 
Ai o processo que calcula o rendimento mensal ficaria assim:
....
public static void main(String[] args){
// array de pi com 3 posicoes:
ProutoInterno[] pi = new ProutoInterno[3];
pi[0] = new ContaPoupanca();
pi[1] = new PicItau();
pi[3] = new ContaCorrente();
System.out.println("Rendimento mensal de:" + calculaRendimento(pi));
}
public static double calculaRendimentoMensal(ProdutoInterno[] pi){
double result = 0.0;
for(int i=0; i< pi.length; i++){
result += pi.[i].calculaRendimentos();
}
return result;
}
Assim o Processo de calculo mensal fica independente do tipo de produto possibilitando que novos produtos sejam criados sem que se tenha que alterar o processo de calculo!
[obs]
Isso eh que me fez adorar a Orientacao a Objetos com Java
[/obs]
Abraco,