Simplesmente pra ler depois...

Usos Práticos da Interface
Tendo conhecimento do uso básico de uma Interface, podemos entender qual a verdadeira funcionalidade dela em um caso real.

Seguindo o Padrão
A Interface é muito utilizada em grandes projetos para obrigar o programador a seguir o padrão do projeto, por esta tratar-se de um contrato onde o mesmo é obrigado a implementar seus métodos, ele deverá sempre seguir o padrão de implementação da Interface.

Vamos supor o seguinte caso: Temos uma Interface BasicoDAO que dirá aos programadores do nosso projeto o que suas classes DAO devem ter (para efeito de conhecimento, o DAO é onde ficará nosso CRUD), qualquer método diferente do que tem na nossa Interface DAO será ignorado e não utilizado.

Listagem 3: Nossa Interface DAO

import java.util.List;

public interface BasicoDAO {

	public void salvar(Object bean);
	public void atualizar(Object bean);
	public void deletar(int id);
	public Object getById(int id);
	public List<Object> getAll();


}
Agora um dos programadores que está trabalhando no módulo de RH quer criar um DAO para realizar o CRUD de Funcionários, ele implementa a Interface acima e ainda adiciona métodos a parte (que serão ignorados mais a frente).

Listagem 4: Implementado a Interface DAO

import java.util.List;

public class FuncionarioDAO implements BasicoDAO {

	@Override
	public void salvar(Object bean) {
		// TODO Auto-generated method stub

	}

	@Override
	public void atualizar(Object bean) {
		// TODO Auto-generated method stub

	}

	@Override
	public void deletar(int id) {
		// TODO Auto-generated method stub

	}

	@Override
	public Object getById(int id) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public List<Object> getAll() {
		// TODO Auto-generated method stub
		return null;
	}

	//Método a parte criado e implementado pelo próprio programador
	public void calcularSalario(){

	}


}
Temos agora todos os itens da “receita”, vamos agora utilizá-lo em nossa aplicação. Suponha que um novo programador (que não criou a classe FuncionarioDAO), precise inserir um novo funcionário.

Este novo programador não tem idéia de como foi implementada a classe FuncionarioDAO, ele nem mesmo tem acesso a esta classe, porém ele sabe de algo muito mais importante: A Definição da Interface. Sendo assim ele irá usar todo o poder do polimorfismo e criar um novo objeto FuncionarioDAO do tipo BasicoDAO. Veja a listagem 5.

Listagem 5: Usando o polimorfismo

public class MeuApp {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		BasicoDAO funcionarioDAO = new FuncionarioDAO();

		funcionarioDAO.salvar(Funcionario001);

	}

}
Perceba que criamos o objeto FuncionarioDAO do tipo BasicoDAO, sendo assim só conseguimos chamar os métodos da Interface BasicoDAO. Mas o mais importante é que o novo programador que utilizará a classe FuncionarioDAO, poderá chamar os métodos descritos na Interface.

Mas o que obriga que o programador que criou a classe FuncionarioDAO implemente BasicoDAO ? Na verdade nada, ele pode criar FuncionarioDAO sem implementar a interface, porém o novo programador que utilizará essa classe não conseguirá realizar o polimorfismo acima e verá que a classe está errada, foi criada de forma errada, fora do padrão. Há ainda outra forma de sabermos se a classe que foi criada implementou a interface BasicoDAO, veja na listagem 6.

Listagem 6: Uso do instanceof

public class MeuApp {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		FuncionarioDAO funcionarioDAO = new FuncionarioDAO();

		if (funcionarioDAO instanceof BasicoDAO)
		funcionarioDAO.salvar(Funcionario001);
		else
			System.err.println("A Classe FuncionarioDAO não implementa BasicoDAO, nenhum procedimento foi realizado");

	}

}
Agora conseguimos ver os métodos implementados a parte pelo programador (fora da implementação da interface), porém testamos antes se a classe é uma instancia (instanceof) de BasicoDAO.

Interface de Marcação
Existe ainda um conceito que chamamos de: Interface de Marcação. São interfaces que servem apenas para marcar classes, de forma que ao realizar os “instanceof” podemos testar um conjunto de classe.

Vamos a outro exemplo prático: Temos uma Interface Funcionario sem nenhum método ou atributo, isso porque será apenas uma interface de marcação. Veja na listagem 7.

Listagem 7: Interface de Marcação Funcionario

public interface Funcionario {

}

Agora criamos 3 Beans, que correspondem a 3 tipos distintos de funcionários: Gerente, Coordenador e Operador. Todos implementando Funcionario.

Listagem 8: Criação de Gerente, Coordenador e Operador

public class Gerente implements Funcionario {

	private int id;
	private String nome;

}

public class Coordenador implements Funcionario {

	private int id;
	private String nome;


}

public class Operador implements Funcionario {

	private int id;
	private String nome;

}
Agora em nossa aplicação temos um método que realiza um procedimento de calculo de salário diferente para cada tipo de funcionário. Poderiamos não utilizar o poder da Interface e fazer a implementação abaixo.

Listagem 9: Uso indevido da Interface de Marcação

public class MeuApp {

	public void calcularSalarioParaGerente(Gerente gerente){

	}

public void calcularSalarioParaCoordenador(Coordenador coordenador){

	}

public void calcularSalarioParaOperador(Operador operador){

}

}

Muito trabalho pode ser reduzido a apenas 1 método, mostrado na listagem 9.

Listagem 10: Usando a interface de marcação

public class MeuApp {

	public void calculaSalarioDeFuncionario(Funcionario funcionario){

		if (funcionario instanceof Gerente){
			//calculo para gerente
		}else if (funcionario instanceof Coordenador){
			//calculo para coordenador
		}else if (funcionario instanceof Operador){
			//calculo para operador
		}

	}



}
Em vez de ficar criando um método para cada tipo de funcionário, juntamos tudo em apenas 1 utilizando a interface de marcação.

CONCLUSÃO
Quando bem utilizada, a interface acaba tornando-se uma poderosa ferramenta nas mãos de um programador ou Analista, e torna-se indispensável o seu uso no dia-a-dia. As boas práticas de programação regem que o uso da Interface é indispensável para um bom projeto de software.



--------------------------------------------------------------------

Interfaces
Interface é um recurso da orientação a objeto utilizado em Java que define ações que devem ser obrigatoriamente executadas, mas que cada classe pode executar de forma diferente.

Interfaces contém valores constantes ou assinaturas de métodos que devem ser implementados dentro de uma classe.

E por que isso?

Isso se deve ao fato que muitos objetos (classes) podem possuir a mesma ação (método), porém, podem executá-la de maneira diferente.

Usando um exemplo bem drástico, podemos ter uma interface chamada aéreo que possui a assinatura do método voar(). Ou seja, toda classe que implementar aéreo deve dizer como voar(). Portanto, se eu tenho uma classe chamada pássaro e outra chamada avião, ambas implementando a interface aéreo, então, nestas duas classes devemos codificar a forma como cada um irá voar().

Uma interface é criada da mesma forma que uma classe, mas utilizando a palavra-chave interface no lugar de class.

interface nomeDaInterface { métodoAbstrato (argumentos); }

--------------------------------------------------------------------------------

Antes de começar a discutir onde usá-las, vamos entender o que são. Uma interface pode ser vista como um protocolo de comportamento. Ela é simplesmente uma lista de métodos abstratos, podendo também incluir variáveis. Para utilizá-la, é criada uma classe que implemente-a. Esta classe será obrigada a definir todos os métodos das interfaces que está implementando, como mostrado no exemplo abaixo, em que temos as interfaces Leitor e Programador sendo implementadas pela classe ParticipanteForum.

Read more: http://www.linhadecodigo.com.br/artigo/80/utilizando-interfaces.aspx#ixzz4JOlOqDlQ