:::Interfaces :::

[code]

interface Ação{
public Acelera();
public staciona();
public Para();
}

public class Veiculo implements Ação{
public Acelera(){
Andar++
}

}
[/code]

    Tenho algumas dúvidas com relação a interfaces uma delas é a seguinte digamos que 

eu tenho esta inteface Ação é a class Veiculo que implementa a inetface ação…

Agora o que eu estou querendo dizer com isso aqui ???

Ação Carro = new Veiculo () ;

Vejam se meu pensamento está certo.

estou criando um objeto novaAcao que é um veiculo certo ??? e porque tenho q referenciar a
Interface ??? vejam…

Ação Carro = …

Na verdade estou criando um objeto Ação ou Veiculo ??? ou os Dois ???

Ação Carro = new Veiculo () ;

Obrigado Amigos

vc está criando um objeto Veiculo, é isso q o “new” faz, cria objetos, portanto sempre q vc fizer new AlgumaCoisa(), vc vai esta criando um.

No seu exemplo a classe Veiculo implementa a interface Ação, portanto vc pode considerar que Veiculo é uma Ação, portanto vc pode referenciar um Veiculo em uma variavel q referenciaria uma Ação (pois o veiculo É uma Ação).

Então em

Ação carro= new Veiculo();

o seu objeto carro (q é uma instancia de veiculo) esta sendo referenciado por uma variavel do tipo Ação.

Ola Kartler

a explicação do Daniel foi certinha… mas vou deixar um exemplo aqui pra entender melhor esse lance, vamos supor que temos duas classes e uma herda os métodos da outra

[code]class Classe1 {
public void metodo1() {
}
public void metodo2() {
}
}

public class Classe2 extends Classe1 {
public static void main(String args[]) {
Classe1 c = new Classe2();
}
}[/code]

Funciona perfeitamente, verifica que eu colouei Classe1 c = new Classe2(), ou seja, o objeto c é uma instancia da Classe2 e a Classe2 como herda todos os métodos da Classe1, ela é mais completa, pois tem os métodos delas e da Classe1, já a Classe1 tem apenas os métodos da Classe1, entoa por isso eu posso instanciar um objeto da Classe2 mesmo ela sendo referenciada da Classe1, mas se for o contrario nao da

Classe2 c = new Classe1();

Pq o objeto c vai estar referenciado da Classe2, e pra instanciar a Classe1, a Classe1 não possui todos os métodos da Classe2, ae vai dar erro de Tipos incompativeis

espero ter ajudado
Junior

Esse modo de utilização de interfaces é o que é recomendado, por exemplo, quando você utiliza coleções.

Você pode receber como argumento de um método um java.util.Map e quem estiver acessando o método pode escolher a implementação Map que mais satisfaz as necessidades e passar objetos java.util.HashMap ou java.awt.RenderingHints ou qualquer outro objeto que implemente a interface.

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 :slight_smile: 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 :wink:

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,

Eu assino embaixo nas declarações do Claudio.

Abraços.

Hehe! que beleza; a galera acordou animada!
Esse cogumelo era do bom!!! 8)

Sooohhh!

:wink: