Interfaces e Pacotes em Java

Prévia do material em texto

7ºAula
Interfaces e pacotes
Objetivos de aprendizagem
Ao término desta aula, vocês serão capazes de:
conhecer o que são as Interfaces;
entender os benefícios de uso das interfaces;
saber como funcionam os pacotes.
Prezados(as) alunos(as), tudo bem? 
Bem-vindos à nossa sétima aula sobre interfaces e pacotes. 
Nesta aula, vamos aprender como funcionam dois aspectos que 
são muito conhecidos na linguagem Java: As Interfaces e os 
Pacotes.
Qualquer dúvida entre em contato via quadro de avisos. E 
lembre-se de fazer as atividades dessa aula. Estaremos sempre 
a sua disposição.
Boa aula!
Bons estudos!
Bons estudos!
127
Programação Orientada a Objetos 70
1 - Usando as interfaces
2 - Pacotes em Java
3 - Exercícios resolvidos e propostos
1 - Usando as Interfaces
Na última aula, mostramos como fazer um herança 
das classes na linguagem Java. A herança nos dá muitas 
possibilidades, mas tem um limitador muito importante: 
Uma classe só pode herdar de apenas uma classe-pai. Assim, 
a herança múltipla, que pode causar muitos problemas, é 
proibida.
Mas existem situações em que precisamos de nir 
algum comportamento comum a algumas classes, mas sem 
a necessidade de herdar de alguma classe. Por exemplo, 
podemos criar um comportamento comum de algumas 
Seções de estudo
classes para gerar um certo relatório em CSV. 
Isso funcionaria da seguinte forma: Teríamos um método 
chamado toCSV, que gera uma linha CSV com os dados do 
objeto. Uma classe abstrata chamada CSVGenerator com 
esse método abstrato seria uma boa ideia. Mas, temos um 
problema: todas as classes que herdam de CSVGenerator não 
herdariam de mais alguém. Assim, trocaríamos a possibilidade 
de uma classe herdar de outra classe mais completa para 
herdar de uma classe com apenas um método abstrato.
Para contornar isso, a linguagem Java criou as interfaces. 
As interfaces são como classes abstratas, mas em que podemos 
declarar apenas métodos abstratos. As interfaces são como 
contratos, onde de nem uma série de métodos em que as 
classes devem implementar se querem “herdar” (o correto 
seria implementar) essa interface.
Assim, vamos criar um projeto para exempli car como 
funcionam as interfaces. Crie um projeto no Netbeans. 
Vamos dar o nome de Aula07_Secao01 a este projeto e ao 
arquivo principal.
Depois, clique com o botão direito do mouse em cima do 
nome do projeto criado no painel “Projects”. Depois clique 
em “New >”, e em “Interface”, como mostra essa imagem:
128
71
 Depois, vamos dar um nome para esta interface. Dê o nome de CSVGenerator, e clique em Finish:
A interface será criada e aberta na janela do programa. 
Ela terá a seguinte estrutura:
/*
 * To change this license header, choose License 
Headers in Project Properties.
 * To change this template file, choose Tools | 
Templates
 * and open the template in the editor.
 */
package aula07_secao01;
/**
 *
 * @author unigran
 */
public interface CSVGenerator {
}
Dentro das chaves, declaramos os métodos que devem 
ser implementados para essa interface. Em nosso caso, vamos 
escrever apenas um método, chamado de toCSV, que retorna 
uma String:
public String toCSV();
Agora, crie uma classe chamada Pessoa. Crie três 
atributos privados: nome, endereço e telefone, seguidos por 
seus métodos getters e setters. 
Depois de criar a classe, procure a linha de declaração 
da classe:
Public class Pessoa{
Antes do colchete, digite o texto extendsCSVGenerator. 
Assim, a declaração da classe ca da seguinte maneira:
public class Pessoa implements CSVGenerator{
Agora que a classe Pessoa se comprometeu a implementar 
a interface CSVGenerator, devemos implementar o método 
toCSV. Segue abaixo o código da implementação desse 
método:
@Override
public String toCSV() {
 return this.nome+”;”+this.endereco+”;”+this.
telefone;
}
Com isso, a classe Pessoa tem a seguinte estrutura nal:
public class Pessoa implements CSVGenerator{
 private String nome;
 private String endereco;
 private String telefone;
 public String getNome() {
 return nome;
 }
 public void setNome(String nome) {
 this.nome = nome;
 }
 public String getEndereco() {
129
Programação Orientada a Objetos 72
 return endereco;
 }
 public void setEndereco(String endereco) {
 this.endereco = endereco;
 }
 public String getTelefone() {
 return telefone;
 }
 public void setTelefone(String telefone) {
 this.telefone = telefone;
 }
 
}
Agora, vamos para a classe Aula07_Secao01. No método 
main, digite os seguintes comandos: 
Pessoa p = new Pessoa();
p.setNome(“Antonio”);
p.setEndereco(“Rua B 657”);
p.setTelefone(“44-3333”);
//Criamos uma variável de referência csv
//Ele recebe a instância de Pessoa
//Isto é válido.
CSVGenerator csv = p;
System.out.println(csv.toCSV());
O que nós estamos fazendo é simples. Criamos uma 
nova instância da classe Pessoa e populamos os seus dados. 
Depois, criamos uma variável de referência para a interface 
CSVGenerator, que aceita qualquer instância de uma classe 
que o implementa. Assim, ele aceita a referência para a 
instância da classe p.
Da mesma forma que acontece com variáveis de 
referência para classes pai, essa variável só vai conseguir acessar 
os métodos de nidos na interface, que no caso é a toCSV. 
Chamamos esse método e exibimos esse resultado na tela.
Assim, compile o programa e execute. Veri que o 
resultado:
As interfaces nos proporcionam mais exibilidade. 
Podemos criar métodos cujos argumentos são instâncias que 
implementam uma determinada interface. E só chamamos 
os métodos que precisamos, desde que estejam declarados 
nessa interface. Não nos preocuparemos em saber como 
o programador da classe X implementou ele, ou em quais 
atributos esse objeto possui. Desde que siga os conformes 
de nidos na interface, está ok.
A seguir, vamos explicar como funcionam os pacotes na 
linguagem Java.
2 - Pacotes em Java
Os pacotes são a forma que a linguagem Java tem para 
organizar as suas bibliotecas no sistema. Para mostrarmos 
como funciona, vamos criar um novo projeto no Netbeans. 
Siga as mesmas instruções, dando o nome do projeto de 
Aula07_Secao02. 
Observe que o Netbeans criou uma classe com um 
método main, do mesmo nome do projeto criado. Se você 
observar no painel “Projects”, localizado no canto superior 
esquerdo da janela, observará que essa classe está abaixo de 
uma caixinha, nomeado com o mesmo nome do projeto.
Essa caixinha é um pacote. Seu nome indica o local onde 
devemos localizar a classe relacionada. Além disso, observe 
nas primeiras linhas do arquivo Aula07_Secao02.java:
package aula07_secao02;
Ele está de nindo que a classe Aula07_Secao02 pertence 
ao pacote Aula07_Secao02.
Vamos criar uma classe simples, denominada de Pessoa. 
Clique em “File” > “New File”, clique em “Next >”, e na tela 
seguinte, dê o nome de Pessoa. Desta vez, observe o quarto 
campo da janela. Ela de ne em qual pacote queremos inserir a 
classe. Deixe como está (“aula07_secao02”), para indicarmos 
que queremos deixar no mesmo pacote. Clique em Finish 
para criar a classe.
130
73
Perceba que o painel Projects ganhou mais um item, 
subordinado ao pacote aula07_secao02. É a nova classe que 
foi adicionada ao nosso programa.
Vamos adicionar alguns atributos a esta classe. Além dos 
seus métodos getters e setters. Observe como cou a classe:
Agora, vamos criar um novo pacote. Clique com o botão esquerdo sobre o nome do projeto, no painel Projects. Clique em 
“New >” > “Package”.
131
Programação Orientada a Objetos 74
Na janela que aparecer, observe o campo “PackageName”. 
É nele que vamos inserir o nome do pacote a ser criado. Um 
pacote pode ser dividido em vários subpacotes por pontos. 
A convenção diz que devemos escrever o pacote da 
seguinte forma: A primeira e a segunda parte devem ser os 
identi cadores do autor deste pacote. Uma ideia é usar uma 
url invertida. Por exemplo, se o autor for a Unigran, que tem o 
site unigran.br, podemos iniciar o nomedo pacote da seguinte 
forma: br.unigran.
A partir desse ponto, podemos de nir os subpacotes 
da maneira que quisermos. Para o pacote que vamos criar, 
vamos colocar o nome de br.unigran.entidades, indicando 
que esse pacote armazena as entidades do sistema.
Dê o nome a esse pacote como especi camos e clique 
em Finish, como mostra a imagem:
Agora, vamos transferir a classe Pessoa para esse novo 
pacote. Clique no arquivo Pessoa.java, segure nele e arraste 
em direção ao pacote br.unigran.entidades. 
Uma janela de con rmação vai aparecer. Clique em 
Refactor.
 A classe foi movida de pacote. Perceba que o 
Netbeans alterou o nome do pacote, presente no cabeçalho 
de Pessoa.java:
Agora, vamos ver como usar essa nova classe. Não 
adianta criar no método main uma variável de referência para 
a classe Pessoa. Isso é porque a classe Pessoa, por si só, não é 
mais encontrada pela classe principal. O cenário que criamos 
é correspondente ao diagrama de pacotes, mostrado a seguir:
132
75
Para usarmos a classe Pessoa, devemos indicar onde 
está ela. Para fazer isso, devemos fazer um import da classe 
Pessoa. Esse import consiste em declarar o pacote a qual essa 
classe faz parte, seguido pelo nome da classe.
Portanto, vá ao arquivo Aula07_Secao02.java. Procure a 
linha escrita “package aula07_secao02”. Imediatamente após 
essa linha, escreva o seguinte em uma nova linha:
import br.unigran.entidades.Pessoa;
A partir desse ponto, podemos usar a classe Pessoa 
normalmente. Sinta-se livre em modi car o método main, 
para manipular os atributos da pessoa.
Mas, como os pacotes são organizados? Simples. Eles 
são organizados em pastas, sendo que cada palavra é uma 
pasta. Quando escrevemos a instrução:
import br.unigran.entidades.Pessoa;
Na verdade estamos pedindo para a linguagem Java 
encontrar a classe Pessoa, contida na pasta br, subpasta 
unigran, e depois na subpasta entidades. Para comprovar 
isso, vá ao painel do canto superior esquerdo, e clique na 
aba “Files”. Neste ponto, você está vendo a organização do 
projeto, da mesma forma que está salvo no disco rígido.
Expanda a pasta do projeto. Depois, expanda a pasta src, 
onde o Netbeans salva os arquivos de código. Em seguida, 
expanda as subpastas. Perceba que as subpastas correspondem 
aos nomes dos pacotes que nós damos.
A título de e plicação, você verá outras duas pastas, além de src. A 
pasta nbproject é uma pasta gerenciada pelo Netbeans, local este 
onde ele salva os metadadosdo projeto. Já a pasta build é onde o 
Netbeans salva os arquivos .class, que são os arquivos compilados 
para a linguagem de bytecode.
Assim, podemos de nir os pacotes como a maneira da 
linguagem Java organizar os seus arquivos de código, sendo 
que cada pacote na verdade é uma pasta no disco rígido. 
A forma de declaração foi criada para facilitar a busca dos 
arquivos de código.
A seguir, vamos para os exercícios resolvidos.
3 - E ercícios resolvidos e propostos
Exercício - 1
Escreva uma interface denominada ObjetoGeometrico. Essa interface 
deve ter os métodos área, para calcular a área do objeto e perímetro, 
para calcular o perímetro do objeto. Em seguida, declare uma classe 
do tipo Retângulo que implemente essa interface.
Primeiro criamos a interface ObjetoGeometrico. Essa 
interface só vai conter dois métodos, um para calcular a área 
e outro para calcular o perímetro. A seguir, vamos mostrar 
como escrevemos essa interface.
public interface ObjetoGeometrico {
 public double area();
 public double perimetro();
}
Em seguida, criamos a classe Retangulo. Ele vai conter 
dois atributos. Um para armazenar o seu lado maior e outro 
para armazenar o seu lado menor. Além disso, implementamos 
os métodos da interface ObjetoGeometrico. Observe:
public class Retangulo implements 
ObjetoGeometrico{
 private double ladoMaior;
 private double ladoMenor;
 @Override
 public double area() {
 return this.ladoMaior * this.ladoMenor;
133
Programação Orientada a Objetos 76
 }
 @Override
 public double perimetro() {
 return this.ladoMaior * 2 + this.ladoMenor 
* 2;
 }
 public double getLadoMaior() {
 return ladoMaior;
 }
 public void setLadoMaior(double ladoMaior) {
 this.ladoMaior = ladoMaior;
 }
 public double getLadoMenor() {
 return ladoMenor;
 }
 public void setLadoMenor(double ladoMenor) {
 this.ladoMenor = ladoMenor;
 }
}
Vamos para outro exemplo:
Exercício - 2
Ainda com o código do E ercício 1, crie uma classe chamada 
Quadrado, que implemente a interface ObjetoGeometrico. Essa 
classe deve car no pacote denominado entidades.
Para isso, vamos criar uma classe. No menu, clique 
em “New”, depois em “File”. Depois clique em “Next”. 
Em seguida, na janela que aparecer, indique um nome em 
“ClassName”. Em “Package”, apague o texto (se houver) 
e digite: entidades. Isso vai fazer que a classe seja criada no 
pacote entidades. Para terminar clique em Finish.
134
77
Depois disso, adicione o atributo lado, os métodos 
acessores e as implementações da interface ObjetoGeometrico. 
Veja como cou:
package entidades;
import aula07_exercicio01.ObjetoGeometrico;
/**
 *
 * @author unigran
 */
public class Quadrado implements ObjetoGeometrico{
 private double lado;
 public double getLado() {
 return lado;
 }
 public void setLado(double lado) {
 this.lado = lado;
 }
 @Override
 public double area() {
 return this.lado * this.lado;
 }
 @Override
 public double perimetro() {
 return this.lado*4;
 }
}
Vamos para os exercícios propostos:
Exercício - 3
Com base no e emplo da seção 1, crie uma classe chamada 
GeradorDeRelatorios, com um método gerarCSV, que recebe um 
array de instâncias que implementam a classe CSVGenerator. Ele 
deve gerar um relatório CSV de todas as instâncias presentes nesse 
array.
Exercício - 4
Com base no e ercício 1, crie as classes Círculo e Triângulo, que 
implementam a interface ObjetoGeometrico.
Exercício - 5
Reorganize as interfaces e as classes do e ercício 4, com e ceção da 
classe principal, da seguinte forma:
 br.unigrannet.interfaces: Nesse pacote cam todas as interfaces.
 br.unigrannet.classes: Nesse pacote cam todas as classes.
Na próxima aula, veremos o que são Design Patterns. 
Até logo!
Retomando a aula
Chegamos ao nal da nossa sétima aula. Espera-se 
que agora tenha mais claro o entendimento de vocês 
sobre Interface e pacotes. Vamos, então, relembrar?
1 - Usando as Interfaces
Nessa seção, vimos como funcionam as interfaces, 
que são similares às classes abstratas, mas com a diferença 
de declarar apenas métodos abstratos e de que uma classe 
pode implementar quantas interfaces desejar. As interfaces 
nos proporcionam mais exibilidade. Uma possibilidade é 
a criação de métodos cujos argumentos são instâncias que 
implementam uma determinada interface. E só chamamos os 
métodos que precisamos, desde que esteja declarados nessa 
interface.
2 - Pacotes em Java
Na segunda seção, estudamos o que são os pacotes, 
podemos de ni-los como a maneira da linguagem Java 
organizar os seus arquivos de código, sendo que cada pacote 
na verdade é uma pasta no disco rígido. Vimos também como 
usar as classes que estão fora do pacote, usando a palavra-
chave import.
3 - Exercícios Resolvidos e Propostos
 
Na terceira e última seção, apresentamos alguns 
exercícios resolvidos, acompanhados do seu código. Além 
disso, sugerimos alguns exercícios propostos, para a xação 
do conteúdo.
CORNELL, Gary; HORSTMANN, Cay S.; 
FURMANKIEWICZ, Edson.et al. Core Java, volume I : 
fundamentos. 8. ed. São Paulo: Pearson Prentice Hall, 2010.
CORNELL, Gary; HORSTMANN, Cay S.; 
TORTELLO, José Eduardo N. et al. CoreJava 2: 
fundamentos. São Paulo: Makron Books do Brasil, 2001.
DEITEL, H.M. Java: como programar. 8. ed. São 
Paulo: Pearson Prentice Hall, 2012.
SCHILDT, Herbert. Java Para Iniciantes - Crie, Compile 
e Execute Programas Java Rapidamente. 6. ed. Porto Alegre: 
Bookman,2015.
Vale a pena ler
Vale a pena
135
Programação Orientada a Objetos 78
GOMES, Robson Fernando. Entendendo interfaces em 
Java. DevMedia, 2012. Disponível em: <https://www.
devmedia.com.br/entendendo-os-conceitos-dos-padroes-
de-projetos-em-java/29083>. Acesso em: 19 out. 2018.
Vale a pena acessar
Minhas anotações
136