1) O documento apresenta um tutorial sobre interfaces Java, mostrando como criar uma interface Pagamento para calcular pagamentos de forma polimórfica para funcionários e faturas. 2) A interface define um método getPaymentAmount() para retornar o valor do pagamento. Classes Fatura e Empregado implementam a interface para permitir o cálculo uniforme. 3) Um programa principal cria objetos Fatura e Empregado e os processa de forma polimórfica usando a interface Pagamento para calcular e exibir os pagamentos.

1. TUTORIAL JAVA:
INTERFACES
DISCIPLINA: LINGUAGEM DE
PROGRAMAÇÃO II
Prof.ª M.ª Eng.ª Elaine Cecília Gatto
Bauru-SP
2015

2. _____________________________________
Página 2 de 4
INTRODUÇÃO
Este tutorial foi feito com base no livro JAVA COMO PROGRAMAR dos autores DEITEL & DEITEL. Neste
Tutorial reexaminaremos o sistema de folha de pagamento utilizando Interfaces. No Tutorial anterior, o mesmo sistema foi
feito utilizando polimorfismo.
Suponha que a empresa deseja realizar várias operações de contabilidade em um único aplicativo Java de contas a
apagar. Além de calcular os vencimentos que devem ser pagos para cada funcionário, a empresa também deve calcular o
pagamento devido de cada uma das várias faturas – ou seja, contas de mercadorias adquiridas. Embora aplicadas a coisas não
relacionadas – ou seja, funcionários e faturas – as duas operações tema ver coma obtenção de alguma quantia de pagamento.
Para um funcionário, o pagamento refere-se aos vencimentos do funcionário. Para uma fatura, o pagamento refere-se
ao custo totaldas mercadorias listadas na fatura. Poderíamos, então,calcular coisas tão diferentes como os pagamentos devidos
a funcionários e faturas em um único aplicativo de forma polimórfica? A resposta é SIM, pois, o Java oferece uma capacidade
que exige que classes não relacionadas implementem um conjunto de métodos comuns – por exemplo, ummétodo que calcula
a quantia de um pagamento – as Interfaces do Java oferecem exatamente essa capacidade.
1: Desenvolvendo a hierarquia Pagamento
Observe a Figura (10.10) abaixo. Ela auxiliará na criação de um aplicativo Java que determinará os pagamentos para
funcionários e faturas semelhantes. Esta Interface contém um método que retorna um valor que deve ser pago para umobjeto
de qualquer classe que a implemente. O método é uma versão de uso geral do método EARNINGS da hierarquia
EMPREGADO – o método EARNINGS calcula especificamente um valor de pagamento para uma classe EMPREGADO,
enquanto que o método da Interface pode ser aplicado a umamplo intervalo de objetos não relacionados.
As classes FATURA e EMPREGADO representam aspectos para os quais a empresa deve ser capaz de calcular um
valor de pagamento. As duas classes implementam PAGAMENTO, assim um programa pode invocar o método da Interface
em objetos FATURA e em objetos EMPREGADO semelhantes. Isso permite o processamento polimórfico de classes
necessárias ao aplicativo.

3. _____________________________________
Página 3 de 4
2: Declarando a Interface Pagamento
Entre no Netbeans. Vá ao menu arquivo, escolha a opção NOVO PROJETO. Selecione Java, Aplicação Java e clique
em próximo. Em seguida, dê o nome ao projeto de Tutorial3 e desmarque a opção para criar automaticamente uma classe Java
principal. Quando o projeto estiver criado, clique com o botão direito em cima do nome do projeto, selecione NOVO, escolha
NOVO PACOTE e dê o nome de “br.com.tutorial3”. Agora, clique com o botão direito no pacote e escolha NOVO. Peça uma
nova INTERFACE Java. Dê a ela o nome de “Pagamento”. Agora adicione o método double getPaymentAmount(); na
Interface.
3: Criando a classe Fatura
A classe FATURA representa uma fatura simples que contéminformações de cobrança para somente umtipo de peça.
Como ocorre com todas as classes, a classe FATURA também estende implicitamente OBJECT. O Java não permite que
subclasses herdem de mais de uma superclasse, mas permitem que uma classe herde de uma superclasse E implemente mais de
uma interface. Uma classe pode implementar quantas interfaces precisar, além de estender outra classe. Todos os objetos de
uma classe que implementam múltiplas interfaces tem o relacionamento É UM com cada tipo de interface implementado.
Passo 1: Clique com o botão direito sob o pacote da classe “br.com.tutorial2”. Selecione NOVO. Selecione CLASSE JAVA.
Dê a ela o nome de Fatura. Em seguida, faça esta classe IMPLEMENTAR a inferface Fatura. (public class Fatura implements
Pagamento)
Passo 2: Crie o seguinte atributo PRIVADO da classe: private String numeroPeça; private String descricaoPeça; private int
quantidadePedida; private double precoPorItem;
Passo 3: Crie um construtor vazio
Passo 4: Crie os construtores parametrizados
Passo 5: Crie os métodos SET e GET
Passo 6: Modifique o método
public void setQuantidadePedida(int quantidadePedida) {
this.quantidadePedida = (quantidadePedida < 0) ? 0 : quantidadePedida;
}
Passo 7: Modifique o método
public void setPrecoPorItem(double precoPorItem) {
this.precoPorItem = (precoPorItem < 0.0) ? 0.0 : precoPorItem;
}
Passo 8: Adicione os métodos abaixo ao final da classe
@Override
public String toString() {
return String.format("%s: n%s: %s (%s) n%s: %d n%s: $%,.2f", "invoice", "part
number", getNumeroPeça(), getDescricaoPeça(), "quantity", getQuantidadePedida(), "price per
item", getPrecoPorItem());
}
@Override
public double getPaymentAmount() {
return getQuantidadePedida() * getPrecoPorItem();
}

4. _____________________________________
Página 4 de 4
4: Modificando a classe EMPREGADO para implementar a interface PAGAMENTO
A classe EMPREGADO será modificada para que ela implemente a interface PAGAMENTO. Quando uma classe
implementa uma interface, a classe faz um contrato com o compilador afirmando que a classe implementará cada um dos
métodos na interface ou que a classe será declarada ABSTRACT. Se a última opção for escolhida, não precisamos declarar os
métodos de interface como abstract na classe abstrata – eles já o são implicitamente. Qualquer subclasse concreta da classe
abstrata deve implementar os métodos da interface para cumprir o contrato da superclasse com o compilador. Se a subclasse
não fizer isso, ela também deverá ser declarada como abstract.
Passo 1: Vá no projeto TUTORIAL2. Copie o arquivo EMPREGADO. Vá até o projeto TUTORIAL3. Selecione o pacote da
classe “br.com.tutorial3”. Cole o arquivo ai. Peça para refatorar. Em seguida, faça a classe Empregado implementar a interface
pagamento (public abstract class Empregado implements Pagamento)
5: Modificando a classe SalarioEmpregado para uso na hierarquia PAGAMENTO
Passo 1: Vá no projeto TUTORIAL2. Copie o arquivo SALARIOEMPREGADO. Vá até o projeto TUTORIAL3. Selecione o
pacote da classe “br.com.tutorial3”. Cole o arquivo ai. Peça para refatorar.
Passo 2: Adicione o seguinte método ao final da classe
@Override
public double getPaymentAmount() {
return getSalarioSemanal();
}
6: Utilizando a Interface Pagamento para processar Fatura e Empregado
polimorficamente
Passo 1: Crie uma classe Java Principal chamada Teste
Passo 2: Adicione o seguinte código no programa principal
Pagamento p[] = new Pagamento[4];
p[0] = new Fatura("01234", "seat", 2, 375.00);
p[1] = new Fatura("56789", "tire", 4, 79.95);
p[2] = new SalarioEmpregado(800.00, "John", "Smith", "111-111");
p[3] = new SalarioEmpregado(1200.00, "Lisa", "Barnes", "888-888");
System.out.println(" Faturas e Empregados processados polimorficamente ");
for ( Pagamento pAtual : p) {
System.out.printf("%s n%s: $%,.2fnn", pAtual.toString(), " pagamento ",
pAtual.getPaymentAmount());
}
Passo 3: Limpar e construir o projeto. Executar.