Programação II - UniCesumar

Prévia do material em texto

PROGRAMAÇÃO II
Professor Dr. Edson A. Oliveira Junior
Professor Me. André Abdala Noel
GRADUAÇÃO
Unicesumar
C397 CENTRO UNIVERSITÁRIO DE MARINGÁ. Núcleo de Educação a 
Distância; JUNIOR, Edson A. Oliveira; NOEL, Andre Abdala.
 Programação II. Edson A. Oliveira Junior; André Abdala Noel.
 Maringá-Pr.: UniCesumar, 2018. 
 200 p.
“Graduação - EaD”.
 
 1. Programação. 2. Java. 3. EaD. I. Título.
ISBN 978-85-459-1160-9
CDD - 22 ed. 005.1
CIP - NBR 12899 - AACR/2
Ficha catalográica elaborada pelo bibliotecário 
João Vivaldo de Souza - CRB-8 - 6828
Impresso por:
Reitor
Wilson de Matos Silva
Vice-Reitor
Wilson de Matos Silva Filho
Pró-Reitor Executivo de EAD
William Victor Kendrick de Matos Silva
Pró-Reitor de Ensino de EAD
Janes Fidélis Tomelin
Presidente da Mantenedora
Cláudio Ferdinandi
NEAD - Núcleo de Educação a Distância
Diretoria Executiva
Chrystiano Minco�
James Prestes
Tiago Stachon 
Diretoria de Graduação e Pós-graduação 
Kátia Coelho
Diretoria de Permanência 
Leonardo Spaine
Diretoria de Design Educacional
Débora Leite
Head de Produção de Conteúdos
Celso Luiz Braga de Souza Filho
Head de Curadoria e Inovação
Tania Cristiane Yoshie Fukushima
Gerência de Produção de Conteúdo
Diogo Ribeiro Garcia
Gerência de Projetos Especiais
Daniel Fuverki Hey
Gerência de Processos Acadêmicos
Taessa Penha Shiraishi Vieira
Supervisão de Produção de Conteúdo
Nádila Toledo
Coordenador de Conteúdo
Danillo Xavier Saes
Designer Educacional
Camila Zaguini Silva
Lilian Vespa da Silva 
Nádila de Almeida Toledo
Rossana Costa Giani
Projeto Gráico
Jaime de Marchi Junior
José Jhonny Coelho
Arte Capa
Arthur Cantareli Silva
Editoração
Robson Yuiti Saito
Qualidade Textual
Ana Paula da Silva, 
Flaviana Bersan Santos
Jaquelina Kutsunugi
Keren Pardini
Maria Fernanda Canova Vasconcelos
Nayara Valenciano
Rhaysa Ricci Correa
Viviane Favaro Notari
Ilustração
Bruno Pardinho
Em um mundo global e dinâmico, nós trabalhamos 
com princípios éticos e proissionalismo, não so-
mente para oferecer uma educação de qualidade, 
mas, acima de tudo, para gerar uma conversão in-
tegral das pessoas ao conhecimento. Baseamo-nos 
em 4 pilares: intelectual, proissional, emocional e 
espiritual.
Iniciamos a Unicesumar em 1990, com dois cursos 
de graduação e 180 alunos. Hoje, temos mais de 
100 mil estudantes espalhados em todo o Brasil: 
nos quatro campi presenciais (Maringá, Curitiba, 
Ponta Grossa e Londrina) e em mais de 300 polos 
EAD no país, com dezenas de cursos de graduação e 
pós-graduação. Produzimos e revisamos 500 livros 
e distribuímos mais de 500 mil exemplares por 
ano. Somos reconhecidos pelo MEC como uma 
instituição de excelência, com IGC 4 em 7 anos 
consecutivos. Estamos entre os 10 maiores grupos 
educacionais do Brasil.
A rapidez do mundo moderno exige dos educa-
dores soluções inteligentes para as necessidades 
de todos. Para continuar relevante, a instituição 
de educação precisa ter pelo menos três virtudes: 
inovação, coragem e compromisso com a quali-
dade. Por isso, desenvolvemos, para os cursos de 
Engenharia, metodologias ativas, as quais visam 
reunir o melhor do ensino presencial e a distância.
Tudo isso para honrarmos a nossa missão que é 
promover a educação de qualidade nas diferentes 
áreas do conhecimento, formando proissionais 
cidadãos que contribuam para o desenvolvimento 
de uma sociedade justa e solidária.
Vamos juntos!
Seja bem-vindo(a), caro(a) acadêmico(a)! Você está 
iniciando um processo de transformação, pois quando 
investimos em nossa formação, seja ela pessoal ou 
proissional, nos transformamos e, consequentemente, 
transformamos também a sociedade na qual estamos 
inseridos. De que forma o fazemos? Criando oportu-
nidades e/ou estabelecendo mudanças capazes de 
alcançar um nível de desenvolvimento compatível com 
os desaios que surgem no mundo contemporâneo. 
O Centro Universitário Cesumar mediante o Núcleo de 
Educação a Distância, o(a) acompanhará durante todo 
este processo, pois conforme Freire (1996): “Os homens 
se educam juntos, na transformação do mundo”.
Os materiais produzidos oferecem linguagem dialógica 
e encontram-se integrados à proposta pedagógica, con-
tribuindo no processo educacional, complementando 
sua formação proissional, desenvolvendo competên-
cias e habilidades, e aplicando conceitos teóricos em 
situação de realidade, de maneira a inseri-lo no mercado 
de trabalho. Ou seja, estes materiais têm como principal 
objetivo “provocar uma aproximação entre você e o 
conteúdo”, desta forma possibilita o desenvolvimento 
da autonomia em busca dos conhecimentos necessá-
rios para a sua formação pessoal e proissional.
Portanto, nossa distância nesse processo de cresci-
mento e construção do conhecimento deve ser apenas 
geográica. Utilize os diversos recursos pedagógicos 
que o Centro Universitário Cesumar lhe possibilita. 
Ou seja, acesse regularmente o Studeo, que é o seu 
Ambiente Virtual de Aprendizagem, interaja nos fóruns 
e enquetes, assista às aulas ao vivo e participe das dis-
cussões. Além disso, lembre-se que existe uma equipe 
de professores e tutores que se encontra disponível para 
sanar suas dúvidas e auxiliá-lo(a) em seu processo de 
aprendizagem, possibilitando-lhe trilhar com tranqui-
lidade e segurança sua trajetória acadêmica.
Professor Dr. Edson A. Oliveira Junior
Bacharel em Informática pela Universidade Estadual de Maringá (UEM), Mestre 
em Ciência da Computação pela Universidade Estadual de Maringá (UEM) 
e Doutor em Ciências de Computação e Matemática Computacional pelo 
Instituto de Ciências Matemáticas e de Computação (ICMC) da Universidade 
de São Paulo (USP). Todos esses títulos foram obtidos na área de concentração 
de Engenharia de Software, em que minha especialidade é Linha de Produto 
de Software e Gerenciamento de Variabilidade, além de Arquitetura de 
Software, Desenvolvimento Baseado em Componentes (DBC), Frameworks e 
Metamodelagem e Modelagem UML. DBC e Frameworks são temas de pesquisa 
que envolvem não só a modelagem de sistemas, mas a implementação de 
sistemas e suas arquiteturas. Participo de vários cursos de Pós-Graduação em 
diversas instituições de ensino superior, como a própria UEM, UNIPAR, Faculdade 
Integrado, UniCesumar, Faculdade Alfa, Instituto Paranaense de Ensino e 
Faculdade Cidade Verde. Possuo as seguintes certiicações da Tecnologia Java: 
Sun Certiied Java Associate, Sun Certiied Java Programmer, Sun Certiied Java 
Developer, Sun Certiied Web Component Developer e Sun Certiied Business 
Component Developer, todas elas certiicadas pela Sun Microsystems, entre 
os anos de 2003 e 2007. Ministro esta disciplina em cursos de treinamento 
técnico, graduação e pós-graduação desde o ano de 2000.
Professor Me. Andre Abdala Noel
Professor e programador,mestre em Ciência da Computação pela Universidade 
Estadual de Maringá, com ênfase em sistemas de computação, e bacharel em 
Ciência da Computação pela Universidade Estadual de Maringá. Possui boa 
experiência em programação, aplicando também na docência superior, desde 
2008. Autor do site Vida de Programador, se mantém bem ativo na comunidade 
de desenvolvedores.
C
U
R
R
ÍC
U
LO
SEJA BEM-VINDO(A)!
Prezado(a) acadêmico(a), é com grande satisfação que apresento a você o livro de Pro-
gramação em Java II. Este material foi elaborado com o objetivo de contribuir em sua 
formação, especialmente a de desenvolvedor(a) de software. Sou o professor Edson A. 
Oliveira Junior, autor deste material. Você pode ter certeza que este material foi prepara-
do com carinho especial para que você possa entender o que essa disciplina pode te tra-
zer de benefício ao longo de sua vida como desenvolvedor(a) e/ou analistade sistemas.
Inicialmente, como você já deve ter lido e exercitado todos os conceitos básicos de Java 
no livro Programação em Java I, este livro abordará conceitos mais avançados de orien-
tação a objetos como sobrecarga em Java, que é diferente da sobreposição que estuda-
mos no livro I. A sobreposição permite redeir o comportamento (implementação) de 
um método que foi herdado, possibilitando que a subclasse possua os dois comporta-
mentos: o herdado e o implementado. Já a sobrecarga permite que você use um mes-
mo identiicador (nome) para métodos e construtores de uma mesma classe, mudando 
somente a assinatura destes, além de tratamento de exceções.
A Unidade II abordará classes abstratas e interfaces. As classes abstratas podem possuir 
métodos concretos (com implementação) e métodos abstratos (somente a assinatu-
ra) sem fornecer uma implementação padrão. As subclasses concretas de uma classe 
concreta devem implementar os métodos concretos. Esta é uma forma de garantir que 
o método será implementado de acordo com a classe a qual se destina. Já interfaces 
possuem somente métodos abstratos, porém não fornecem suporte à característica de 
herança.
Na Unidade III, você entenderá os elementos essenciais para se trabalhar com vários 
objetos de uma mesma classe ao mesmo tempo: arrays e coleções Java. Existem vários 
tipos de coleções, cada uma com um propósito e um conjunto de características pró-
prias que são usadas em diversas situações diferentes.
A Unidade IV abordará a criação de interfaces gráicas desktop por meio das API AWT 
e Swing. Interfaces gráicas em Java envolvem o projeto e a construção de layouts para 
que os elementos gráicos de interação (botões, caixas, campos etc.) possam ser acomo-
dados. Interfaces gráicas não podem dispensar o tratamento de exceções, caracteriza-
das por interrupções abruptas da execução de código Java, sem que o usuário possa ter 
a chance de interagir com o programa. Para tanto, isolamos esses códigos permitindo 
que o programa Java não seja simplemente abortado sem uma justiicativa.
APRESENTAÇÃO
PROGRAMAÇÃO II
Por im, na Unidade V, serão apresentados os conceitos de persistência de dados por 
meio das APIs JDBC e JPA. JDBC é o método tradicional de armazenamento de dados em 
um banco de dados. Já JPA permite mapear as classes Java para entidades de um banco 
de dados, facilitando a persistência dos dados.
Lembre-se sempre que programar é uma “arte moderna” em que aquele que detém o 
maior poder de abstração possível é aquele que melhor saberá desenvolver os seus pro-
gramas.
Ótima leitura e sucesso em sua vida de desenvolvedor de software.
Prof. Dr. Edson A. Oliveira Junior / Professor Me. André Abdala Noel
APRESENTAÇÃO
SUMÁRIO
09
UNIDADE I
SOBRECARGA E EXCEÇÕES
17 Introdução
18 Sobrecarga de Métodos 
18 Exemplos de Sobrecarga 
23 Conversões Implícitas 
24 Construtores com Sobrecarga 
27 Tratamento de Exceções 
28 Captura de Exceções 
30 Deinindo Exceções 
31 Hierarquia de Exceções 
32 Declaração de Exceções e a Interface Pública 
34 Considerações Finais 
SUMÁRIO
UNIDADE II
CLASSES ABSTRATAS E INTERFACES
41 Introdução
41 O Que é Classe Abstrata? 
43 Modelando um Projeto com Classes Abstratas 
44 Implementando um Projeto com Classes Abstratas 
50 Regras Sobre Classes e Métodos Abstratos 
56 O Que são Interfaces? 
56 Características das Interfaces 
58 Modelando um Projeto com Interfaces 
59 Implementando um Projeto com Interfaces 
64 Comparando Interfaces e Classes Abstratas 
66 Considerações Finais 
SUMÁRIO
11
UNIDADE III
ARRAYS E COLEÇÕES
73 Introdução
73 Entendendo um Array 
74 Declarando Arrays de Objetos e de Tipos Primitivos 
76 Construindo Arrays Unidimensionais 
77 Construindo Arrays Multidimensionais 
79 Inicializando Arrays 
83 Passando Arrays para Métodos 
85 Exemplos com Arrays 
92 Visão Geral das Coleções 
93 A Interface List 
98 A Interface Set 
103 A Interface Map 
106 A Interface Queue 
109 Considerações Finais 
SUMÁRIO
UNIDADE IV
INTRODUÇÃO À INTERFACE GRÁFICA
115 Introdução
115 O Que é a Biblioteca Swing? 
116 Criando um Projeto no Netbeans Ide 
117 Criando um Contêiner Jframe 
118 Adicionando Componentes Swing 
120 Construindo a Interface 
126 Escrevendo o Código 
134 Considerações Finais 
SUMÁRIO
13
UNIDADE V
PERSISTÊNCIA DE DADOS COM JPA
141 Introdução
142 Jdbc – Java Database Connectivity 
142 Drivers Jdbc 
143 Conectando a um Sgdb com Connection 
148 Executando Instruções Sql com Statement 
151 Executando Instruções SQL com Preparedstatement 
155 Recuperando e Utilizando Dados de um RESULTSET 
158 O Jpa – Java Persistence Api 
171 Considerações Finais 
190 CONCLUSÃO
191 GABARITO
198 REFERÊNCIAS
199 ANOTAÇÕES
U
N
ID
A
D
E I
Professor Dr. Edson A. Oliveira Junior
Professor Me. André Abdala Noel
SOBRECARGA E EXCEÇÕES
Objetivos de Aprendizagem
 ■ Criar códigos com métodos que utilizam conceitos de sobreposição e 
sobrecarga.
Plano de Estudo
A seguir, apresentam-se os tópicos que você estudará nesta unidade:
 ■ Sobrecarga de métodos
 ■ Exemplos de Sobrecarga
 ■ Conversões implícitas
 ■ Construtores com sobrecarga
 ■ Tratamento de exceções
 ■ Captura de Exceções
 ■ Deinindo Exceções
 ■ Hierarquia de Exceções
 ■ Declaração de Exceções e Interface Pública
INTRODUÇÃO
Caro(a) aluno(a), nesta etapa do nosso treinamento iremos trabalhar o conceito 
de sobreposição em Java” por “sobrecarga de métodos. É um conceito simples, 
porém com muitos detalhes, detalhes estes que nos farão diferenciar facilmente 
uma sobreposição de uma sobrecarga. Para isto é necessário que os conceitos 
de herança que já vimos esteja muito claro de agora em diante. Faremos alguns 
exemplos práticos e também utilizaremos métodos da classe Object como exem-
plo de uma sobreposição ou reescrita (overriding). Trataremos algumas regras 
especíicas para entender melhor nossa utilização de sobreposição.
Também serão apresentadas técnicas básicas de tratamento de exceções. 
Estas ocorrem quando algo imprevisto acontece, elas podem ser provenientes 
de erros de lógica ou acesso a recursos que talvez não estejam disponíveis. O tra-
tamento de exceções ajuda a aprimorar a tolerância a falhas de um programa.
17
Introdução
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
SOBRECARGA DE MÉTODOS
Caro(a) aluno(a), é importante aqui, no início do nosso trabalho com a sobre-
carga, que tenhamos claro as diferenças entre sobreposição e sobrecarga. A 
sobreposição, como já vimos, nada mais é do que escrever um método que já 
possuímos, sendo possível pelos recursos de herança, já a sobrecarga consiste 
no recurso que a linguagem Java nos oferece de escrever métodos com o mesmo 
nome, fazendo-se a distinção apenas pelos parâmetros de entrada que obrigato-
riamente precisam ser diferentes.
O recurso oferecido pela sobrecarga vai nos ajudar muito, pois podemos tra-
balhar métodos com mesmo nome, mas de várias formas diferentes sem perder o 
sentido do que o método se propõe a oferecer. Como na igura anterior, imagine 
a seguinte situação: seu sistema precisa fazer um cadastro de cliente, em que este 
pode tantoser uma pessoa física como uma pessoa jurídica. Se for pessoa física, 
o sistema irá fazer uma validação de CPF no momento em que é preenchido o 
cadastro; mas caso nosso cliente seja pessoa jurídica, o sistema irá fazer uma 
validação de CNPJ. Tanto o CPF quanto o CNPJ são campos que têm a mesma 
função, só que um se refere à pessoa física e a outra a jurídica. Podemos criar 
dois métodos com o mesmo nome, mas que possuem parâmetros de entrada 
diferente e podemos fazer a chamada do método com o mesmo nome, só que, 
em um momento, passaremos um CPF para ser validado e, em outro, passare-
mos um CNPJ para ser validado. 
EXEMPLOS DE SOBRECARGA
Caro(a) aluno(a), vejamos, então, alguns exemplos de sobrecarga para enten-
der melhor. Começaremos com um exemplo bem simples. Vamos criar uma 
classe chamada ExemplosSobreCarga e, nela, colocar um método chamado 
calculaNumeroMaior(). No primeiro momento, nosso método receberá ape-
nas dois parâmetros de entrada, que serão duas variáveis do tipo double, depois 
19
Exemplos de Sobrecarga
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
criaremos outro método com o mesmo nome, mas vamos passar três números 
para serem veriicados dentre os três quem é o maior.
Veja como icou nossa classe ExemplosSobreCarga():
Quadro 1 - Classe com exemplo de sobrecarga 
public class ExemplosSobrecarga {
 //criamos aqui a variável maior que será usada na veriicação do
 // maior número digitado
 double maior;
 //método que veriica o maior entre dois números digitados
 public double calculaNumeroMaior(double n1, double n2){ 
 if (n1 == n2){
 maior = 0;
 }else if(n1 > n2){
 maior = n1;
 }else if(n2 > n1){
 maior = n2;
 } 
 return maior;
 } 
 
 //método que veriica o maior número entre ter números 
digitados
 public double calculaNumeroMaior(double n1, double n2, double 
n3){
 if ( (n1>n2) && (n1>n3) ){
 maior = n1;
 }else if ( (n2>n1) && (n2>n3) ){
 maior = n2;
 }else if ( (n3>n1) && (n3>n2) ){
 maior = n3;
 }else {
 maior = 0;
 } 
 return maior;
 } 
}
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
Agora veja como icou nossa classe TestaSobreCarga:
Quadro 2 - Classe com método main para testar sobrecarga
import javax.swing.JOptionPane;
import main.ExemplosSobrecarga;
public class TestaSobreCarga {
 public static void main(String[] args) {
 double n1,n2,n3,maior; 
 //testando o primeiro metodo
 n1 = Double.parseDouble(JOptionPane.showInputDialog(
 "Digite o primeiro numero:"));
 n2 = Double.parseDouble(JOptionPane.showInputDialog(
 "Digite o segundo numero:")); 
 
 ExemplosSobrecarga e1 = new ExemplosSobrecarga();
 maior = e1.calculaNumeroMaior(n1, n2);
 JOptionPane.showMessageDialog(null,"Maior numero 
digitado: "+
 maior);
 
 //testando o primeiro segundo metodo
 n1 = Double.parseDouble(JOptionPane.showInputDialog(
 "Digite o primeiro numero:"));
 n2 = Double.parseDouble(JOptionPane.showInputDialog(
 "Digite o segundo numero:")); 
 n3 = Double.parseDouble(JOptionPane.showInputDialog(
 "Digite o terceiro numero:")); 
 
 ExemplosSobrecarga e2 = new ExemplosSobrecarga();
 maior = e2.calculaNumeroMaior(n1, n2, n3);
 JOptionPane.showMessageDialog(null,"Maior numero 
digitado: "+
 maior); 
 } 
}
21
Exemplos de Sobrecarga
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Executando esse nosso código, podemos ver claramente que temos a utilização 
de um método que veriica o maior número, só que de duas formas diferentes: 
no primeiro, passamos dois números para serem veriicados; no segundo, pas-
samos três números para serem veriicados. Os dois métodos contêm o mesmo 
nome, mas com parâmetros de entrada diferente. Este é um exemplo bem sim-
ples de sobrecarga.
Caro(a) aluno(a), podemos também perceber que os parâmetros de entrada 
podem diferenciar-se somente pelo tipo de dados que estamos passando para o 
método. Como exemplo, vamos criar uma classe chamada SegundoExemplo. 
Essa classe contém dois métodos chamados retornaDddMascara(); nesse método, 
vamos passar primeiro um DDD do tipo int e depois um DDD do tipo string e o 
método vai nos retornar somente uma string com o DDD formatado com máscara.
Veja como icou a classe SegundoExemplo:
Quadro 3 - Classe do segundo exemplo de sobrecarga
 public class SegundoExemplo {
 // criamos aqui uma string que sera o ddd formatado
 String dddComMascara;
 //criamos aqui um metodo que retorna o ddd formatado 
recebendo
 //um DDD to dipo int
 String retornaDddMascara(int ddd){
 dddComMascara = "(" +ddd+ ")";
 return dddComMascara;
 }
 
 //criamos aqui um método que retorna o ddd formatado 
recebendo
 //um DDD to dipo string
 String retornaDddMascara(String ddd){
 dddComMascara = "(" +ddd+ ")";
 return dddComMascara;
 } 
}
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
Agora veja como icou nossa classe TestaDdd:
Quadro 4 - Classe com método main para testar sobrecarga
import javax.swing.JOptionPane;
public class TestaDdd {
 public static void main(String[] args) {
 //criamos aqui duas variaveis para ddd uma int oura 
string
 int ddd;
 String strDdd;
 //vamos ler aqui a variavel ddd que é integer
 ddd = Integer.parseInt(JOptionPane.showInputDialog(
 "Digite o ddd de sua cidade:") );
 //vamos ler aqui a variavel ddd que é string
 strDdd = JOptionPane.showInputDialog("Digite o ddd de sua 
cidade:");
 
 SegundoExemplo se = new SegundoExemplo();
 //vamos imprimir primeiro o ddd int com mascara
 JOptionPane.showMessageDialog(null,"DDD int com mascara: 
"+
 se.retornaDddMascara(ddd));
 //vamos imprimir agora o ddd string com mascara
 JOptionPane.showMessageDialog(null,"DDD string com 
mascara: "+
 se.retornaDddMascara(strDdd));
 }
}
Portanto, executando nosso código, vamos concluir que podemos criar méto-
dos com mesmo nome e até os nomes dos parâmetros de entrada iguais, nomes 
e quantidade, tendo apenas o tipo de dados diferente. Assim como no exemplo 
anterior, nós podemos usar o método retornaDddMascara(), passando tanto 
um DDD do tipo int como um DDD do tipo String, o sentido de utilização do 
método é o mesmo, mas em várias situações no dia a dia denossa programa-
ção, teremos casos desse gênero, em que um mesmo método que se comporta 
da mesma forma pode receber o mesmo valor de entrada só que com tipos de 
dados diferentes.
23
Conversões Implícitas
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
CONVERSÕES IMPLÍCITAS
Caro(a) aluno(a), também é possível usar conversões implícitas em nossos métodos 
utilizados na sobrecarga, embora, dependendo da situação, nossos valores iquem 
incorretos. Veja um exemplo: criamos uma classe chamada ConversaoImplicita 
e depois criamos outra classe chamada TestaConversaoImplicita, se o valor 
passado no argumento for válido pela conversão implícita, o método poderá 
ser utilizado sem erro de execução, mas seus valores poderão sofrer alterações, 
como podemos ver no exemplo a seguir:
Quadro 5 - Classe para exemplo de conversão Implícita usada na sobrecarga
 public class ConversaoImplicita { 
 int retornaQuadradoNumero(int numero){
 numero = numero * numero; 
 return numero;
 }
}
Agora veja como icou nossa classe TestaConversaoImplicita:
Quadro 6 - Classe com método main para testar conversão implícita
public class TestaConversaoImplicita {
 public static void main(String[] args) {
 ConversaoImplicita c1 = new ConversaoImplicita();
 JOptionPane.showMessageDialog(null,"Quadrado de 3= " + 
c1.retornaQuadradoNumero(3) );
 JOptionPane.showMessageDialog(null,"Quadrado de 3= " + 
c1.retornaQuadradoNumero(‘3’));
 } 
}
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
CONSTRUTORES COM SOBRECARGA
Caro(a) aluno(a), quando falamos de sobrecarga, abre-se um leque muito grande 
de recursos que ajudam, e muito, na nossa programação do dia a dia. Um recurso 
muito utilizado é usar sobrecarga com o construtor da classe. Veja, sabemos 
que o construtor é o primeiro método a ser executado quando instanciamos um 
objeto, ou seja, quando nós instanciamos, é executado o da classe. Vamos ver um 
exemplo simples do construtor e entender por que faz-se necessário em vários 
momentos usarmos sobrecarga no construtor. Vamos criar uma classe chamada 
Cliente com um construtor vazio, veja:
Quadro 7 - Classe para exempliicar construtores sem sobrecarga
public class Cliente {
 //criamos aqui um constructor vazio para a classe
 public Cliente() { 
 } 
 //criamos aqui atributos normais de uma classe Cliente
 int codigo;
 String nome;
 String cpf;
 String endereco; 
}
Agora vejamos como ica nossa classe que instancia a classe Cliente. Vamos dar 
o nome a ela de TestaCliente:
Quadro 8 - Classe com método main para testar construtores sem sobrecarga
public class TestaCliente {
 public static void main(String[] args) {
 //veja instanciamos um objeto do tipo cliente
 //neste momento estamos executando o construtor
 // que deinimos como vazio 
 Cliente c1 = new Cliente();
 }
}
25
Construtores com Sobrecarga
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Caro(a) aluno(a), veja que quando fazemos isso, nossos atributos do objeto c1 
estão nulos, ou seja, ainda sem valor; agora, imagine a seguinte situação: se nós, 
já no momento em que vamos instanciar o objeto c1, precisarmos passar valo-
res para os atributos, como faríamos isto? É ai que podemos usar a sobrecarga 
com os construtores, pois podemos já criar um objeto e iniciar os atributos com 
valores já no momento de instanciar. Se usarmos a sobrecarga, podemos ins-
tanciar o objeto das duas formas diferentes, passando valores iniciais ou não 
passando valores iniciais.
Veja como icou nossa classe Cliente:
Quadro 9 - Classe com construtores usando sobrecarga
public class Cliente { 
 //criamos aqui atributos normais de uma classe Cliente
 int codigo;
 String nome;
 String cpf;
 String endereco;
 //criamos aqui um constructor vazio para a classe
 public Cliente() { 
 }
 //criamos aqui outro constructor passando valores
 //de entrada para inicializar os atributos
 public Cliente(int codigo, String nome, String cpf, String 
endereco) {
 this.codigo = codigo;
 this.nome = nome;
 this.cpf = cpf;
 this.endereco = endereco;
 }
}
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
Agora veja como icou nossa classe TestaCliente:
Quadro 10 - Classe com método main testando construtores com sobrecarga
import javax.swing.JOptionPane;
public class TestaCliente {
 public static void main(String[] args) {
 //criamos aqui os atributos a serem lidos 
 //referente ao cliente 1 e cliente 2
 int codigo;
 String nome;
 String cpf;
 String endereco;
 //aqui lemos os valores dos atributos pelo usuario
 //referente ao primeiro cliente
 codigo = Integer.parseInt(JOptionPane.
showInputDialog( 
 "Digite o codigo do primeiro cliente:"));
 nome = JOptionPane.showInputDialog(
 "Digite o nome do primeiro cliente");
 cpf = JOptionPane.showInputDialog(
 "Digite o cpf do primeiro cliente");
 endereco = JOptionPane.showInputDialog(
 "Digite o endereço do primeiro cliente");
 //criamos um objeto do tipo cliente e usamos um
 //construtor vazio, passamos os valores para 
 //os atributos depois dele instanciado 
 Cliente c1 = new Cliente();
 c1.codigo = codigo;
 c1.nome = nome;
 c1.cpf = cpf;
 c1.endereco = endereco;
 //aqui lemos os valores dos atributos pelo usuaio
 //referente ao segundo cliente
 codigo = Integer.parseInt(JOptionPane.
showInputDialog( 
 "Digite o codigo do segundo cliente:"));
 nome = JOptionPane.showInputDialog(
 "Digite o nome do segundo cliente");
 cpf = JOptionPane.showInputDialog(
 "Digite o cpf do segundo cliente");
 endereco = JOptionPane.showInputDialog(
 "Digite o endereço do segundo cliente");
 //aqui então instanciamos o objeto passando para 
 //o construtor os valores dos atributos já neste
 //momento
 Cliente c2 = new Cliente(codigo,nome,cpf,endereco); 
 }
}
27
Tratamento de Exceções
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Caro(a) aluno(a), veja que a sobrecarga em construtores é muito útil e que nos 
oferece uma facilidade muito grande para a lexibilidade na utilização de passagem 
de valores dos atributos. Muitas vezes, objetos de uma mesma classe necessitam 
de seremutilizados de formas diferentes. Em alguns momentos, precisamos pas-
sar valor para os atributos já no momento de instanciar o objeto; já em outros, 
não temos essa informação e precisamos passar valores para os atributos depois, 
se criarmos somente um construtor que inicializa os atributos quando execu-
tado, icamos sempre obrigados a passar os valores nesse momento de criação do 
objeto; caso usamos a sobrecarga, temos a lexibilidade de utilizar as duas formas. 
TRATAMENTO DE EXCEÇÕES
Quando um evento excepcional ocorre em Java, diz-se que uma exceção será 
lançada. O código que é responsável por fazer algo com a exceção é chamado de 
manipulador de exceções; ele captura a exceção lançada.
Uma exceção é uma ocorrência que altera o luxo normal do programa. Ela 
pode ocorrer por diversos motivos, incluindo os seguintes:
 ■ Um usuário encontrou dados inválidos.
 ■ Um arquivo que precisa ser aberto não pode ser encontrado.
 ■ A conexão de rede foi perdida no meio de comunicação, ou a JVM está 
sem memória.
 ■ Falhas no Hardware.
 ■ Exaustão de recursos.
Com o tratamento de exceções, um programa pode continuar executando (em 
vez de encerrar) depois de lidar com um problema. Isso ajuda a assegurar a 
robustez dos aplicativos.
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
CAPTURA DE EXCEÇÕES
A manipulação da exceção funciona pela transferência da execução de um pro-
grama para um manipulador de exceções apropriado quando uma exceção 
ocorrer. Por exemplo, se você chamar um método que abra um arquivo, mas o 
arquivo não puder ser aberto, a execução desse método será encerrada e o código 
que foi escrito para lidar com essa situação será processado. Portando, precisa-
mos de uma maneira para informar a JVM (Java Virtual Machine) que código 
executar quando uma determinada exceção ocorrer. Para fazer isso, usamos as 
palavras-chaves try e catch.
TRY / CATCH
Esta é a forma mais usada. O Código dentro de um bloco try / catch é chamado 
de código protegidos. Quando uma exceção é capturada, temos de dar trata-
mento à exceção, ou seja, temos de ter um plano de contingência para resolver 
o problema que ela signiica. Podemos declarar mais do que um bloco catch. Isso 
é importante porque podemos ter vários tipos diferentes de exceção sendo lan-
çados e necessitar de um tratamento especíico para cada um.
Figura 1 - Implementação da exceção em bloco try/catch
29
Captura de Exceções
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
No exemplo da igura anterior, as linhas 18 e 19 constituem a região protegida 
que será controlada pela cláusula try. A linha 20 é o manipulador para uma exce-
ção do tipo Exception. Observe que o bloco catch aparece imediatamente após o 
bloco try. Isso é um requisito. Se você tiver um ou mais blocos catch, eles devem 
aparecer imediatamente após o bloco try. Além disso, todos os blocos catch pre-
cisam icar um após o outro, sem nenhuma outra instrução ou bloco entre eles. 
A ordem na qual os blocos catch forem inseridos também importa.
A execução iniciará na linha 18. Se o programa for processado até a linha 
19 sem nenhuma exceção lançada, a execução será transferida para a linha 25, 
ou seja, no nosso exemplo, fora do bloco try / catch, e continuará daí em diante. 
Porém, se entre a linha 18 a 19 (o bloco try) uma exceção do tipo Exception for 
lançada, a execução será imediatamente transferida para a linha 21. Em seguida, 
as linhas 21 a 23 serão processadas para que todo o bloco catch seja executado e 
depois o processamento passará para a linha 25 e dará seguimento ao programa.
USANDO FINALLY
O bloco Finally é usado quando precisamos executar um código mesmo se houver 
uma exceção. Por exemplo, se você está escrevendo em um arquivo e acontece um 
erro, o arquivo tem que ser fechado mesmo assim. Ou se você está usando uma cone-
xão a banco de dados e acontece algum problema, a conexão tem que ser fechada. 
Figura 2 - Implementação da exceção em bloco try/inally
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
DEFININDO EXCEÇÕES
Discutimos as exceções como um conceito. Sabemos que elas são lançadas quando 
um problema de algum tipo ocorre e que efeito terá sobre o luxo de seu pro-
grama. Dissemos que a exceção é uma ocorrência que altera o luxo normal do 
programa. Toda exceção é a instância de uma classe que possui a classe Exception 
em sua hierarquia de herança. 
Quando uma exceção é lançada, o objeto de um subtipo Exception especí-
ico é instanciado e inserido no manipulador de exceções como um argumento 
para a cláusula catch. Veja a seguir um exemplo:
Figura 3 - Implementação da exceção em bloco try/catch
Nesse exemplo, é a instância de uma classe chamada resumidamente de 
ArrayIndexOutOfBoundsException. Como ocorrência com qualquer outro 
objeto, você pode chamar seus métodos.
31
Hierarquia de Exceções
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
HIERARQUIA DE EXCEÇÕES
Todas as classes de exceções são subtipos da classe Exception. Essa classe é deri-
vada da classe hrowable (que é derivada da classe Object). 
Figura 4 - Hierarquia de exceções em Java
Java deine 2 tipos de exceções:
 ■ As exceções veriicadas: que herdam da classe Exception. O código do 
cliente tem de lidar com as exceções veriicadas lançadas pelo API, ou 
em uma cláusula try /catch ou encaminhando-o para fora com a cláu-
sula throws.
 ■ As Exceções não veriicadas: são as RuntimeException que também 
se estende de Exception. No entanto, todas as exceções que herdam de 
RuntimeException recebem tratamento especial. Não há nenhuma exi-
gência para o código do cliente para lidar com eles, portanto, eles são 
chamados de exceções não veriicadas (unchecked). 
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
Ao decidir sobre exceções veriicadas versus exceções não veriicadas, pergunte 
a si mesmo: “quais medidas o código pode tomar quando a exceção ocorrer?” 
Se o cliente conseguir tomar alguma ação alternativa para recuperar a exceção, 
essa será uma exceção veriicada. Se o cliente não puder fazer nada para contor-
nar a exceção, então essa é uma exceção não veriicada. 
Observe na imagem anterior que NullPointerException estende de 
RuntimeException e, portanto, é uma exceção não veriicada.
**Error: não são exceções, mas sim erros que jamais poderiam ter acontecido. 
Erros indicam que alguma coisa está realmente muito errada na construção do 
código ou no ambiente de execução. Ex.: (OutOfMemoryError) quando o pro-
grama precisa de mais memória e (StackOverlowError ) que acontece quando 
a pilha estoura, por exemplo, quando um método chama a si mesmo sem nunca 
retornar.
DECLARAÇÃO DE EXCEÇÕES E A INTERFACE PÚBLICA
THROWS / THROW:
Como saberemosque um método lançará uma exceção que teremos de capturar? 
Da mesma forma que um método precisa especiicar que tipo, quantos argu-
mentos aceitará e o que será retornado. As exceções que um método pode lançar 
devem ser declaradas (a menos que sejam subclasses de RuntimeException). A 
lista de exceções lançadas faz parte da interface pública de um método. A pala-
vra-chave throws é usada na forma descrita, a seguir, para listar exceções que 
um método pode lançar:
33
Declaração de Exceções e a Interface Pública
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Figura 5 - Método com exceção throws
Esse método é um tipo de retorno void, que não aceita argumentos e declara 
que lança exceções do tipo MyException1 e MyException2 (só porque o método 
declara que lança uma exceção não signiica que sempre o fará. Ele apenas informa 
que pode fazê-lo).
O conceito é semelhante ao de return, mas enquanto return está devolvendo 
um resultado de dentro do método, throws está lançando uma exceção. Nunca é 
possível considerar uma exceção como o resultado de um método, o objetivo do 
método é obter resultados sem lançar exceções. Veja, a seguir, um exemplo de 
método utilizando o throws e o throw. Vamos explicar a diferença deles.
Figura 6 - Implementação da exceção throw e throws
A Principal diferença entre throw e throws é o uso e a funcionalidade. O throws 
é usado na assinatura do método para declarar exceção possivelmente lançadas 
por qualquer método; throw é usado para lançar exceção no código Java, acima 
está um exemplo de ambos throw e throws.
SOBRECARGA E EXCEÇÕES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
I
CONSIDERAÇÕES FINAIS
Aproveitamos o exemplo do construtor para trabalharmos o conceito de sobre-
carga, que nada mais é do que ter mais de um método com o mesmo nome, só 
que com assinaturas diferentes.
Percebemos que, com esse conteúdo, podemos facilitar nossa programação 
e também entender um pouco mais sobre os conceitos de orientação a objetos 
utilizada na linguagem Java.
Você aprendeu, também, que a linguagem Java fornece um mecanismo sois-
ticado de manipulação de exceções. A manipulação de exceções permite que 
você isole seu código de correção de erros em blocos separados, de modo que o 
código principal não ique confuso por causa dele. Outro recurso interessante 
permite que você manipule erros semelhantes com um único bloco de manipu-
lações de erros, sem a duplicação de código. 
Você aprendeu que a palavra-chave try da linguagem Java é usada para espe-
ciicar uma região protegida – um bloco de código no qual os problemas podem 
ser detectados. O bloco inally não é obrigatório, mas se houver um terá de vir 
após o bloco catch. 
35 
1. Crie uma classe chamada ValidaImpostos e nela coloque dois métodos cha-
mados calculaImpostos, só que um método receberá um double valor e 
uma String imposto, e o outro método receberá somente uma String im-
posto. O método que recebe apenas a String imposto veriica se o conteúdo 
da String é “INSS” ou “IR”. Se for o primeiro, retorna “8”, se for o segundo 
retorna “20”. O método que recebe um valor e mais a String imposto calcula 
o valor de imposto pelo valor recebido, por exemplo, se chamar o método 
calculaImpostos(100.00, ‘INSS’), o retorno será “8.00”.
2. Crie uma classe chamada Fornecedor, adicione os atributos int codigo, 
string razaoSocial e coloque dois construtores, um inicializando os atri-
butos e outro vazio, depois crie uma classe TestaFornecedor nela e coloque 
dois objetos do tipo Fornecedor, um usando um construtor e o outro objeto 
o outro construtor.
3. Dado o código a seguir:
1. System.out.print (“Inicio”);
2. try{
3. System.out.print (“ola_mundo”);
4. throw new FileNotFoundException();
5. }
6. System.out.print (“capturar_aqui”);
7. catch (EOFException e){
8. System.out.print (“im_da_exceção_do_arquivo”);
9. }
10. catch (FileNotFoundException e){
11. System.out.print (“arquivo_nao_encontrado”);
12. }
Sabendo-se que tanto o EOFException quanto FileNotFoundException são 
subclasses de IOException e presumindo que esse bloco de código seja in-
serido em uma classe, que declaração estará mais perto da verdade com re-
lação a esse código?
a. O código não será compilado.
b. Saída do código: Inicio ola_mundo arquivo_nao_encontrado.
c. Saída do código: Inicio ola_mundo im_da_exceção_do_arquivo.
d. Saída do código: Inicio ola_mundo capturar_aqui arquivo_nao_encon-
trado.
4. Há algo de errado com o manipulador de exceção a seguir? Será que este 
código compila? 
try {
} catch (Exception e) {
} catch (ArithmeticException a) {
}
Material Complementar
MATERIAL COMPLEMENTAR
Sobrecarga e sobreposição em Java
Por javafree.org
Fonte: <http://javafree.uol.com.br/artigo/6947/Cap-5-Orientacao-a-Objetos.html>.
Sobreposição (override) em Java
Fonte: <http://www.youtube.com/watch?v=NSH8CvaJ6Qs>.
U
N
ID
A
D
E II
Professor Dr. Edson A. Oliveira Junior 
CLASSES ABSTRATAS E 
INTERFACES
Objetivos de Aprendizagem
 ■ Entender o que é a classe Abstrata.
 ■ Entender o que é Interface.
Plano de Estudo
A seguir, apresentam-se os tópicos que você estudará nesta unidade:
 ■ O que é classe abstrata
 ■ Modelando um projeto com classes abstratas
 ■ Implementando um projeto com classes abstratas
 ■ Regras sobre classes e métodos abstratos
 ■ O que são Interfaces
 ■ Modelando um Projeto com Interfaces
 ■ Implementando um projeto com Interfaces
 ■ Comparando Interfaces e Classes Abstratas
INTRODUÇÃO
Caro(a) aluno(a), nesta unidade iremos compreender o que são classes abstra-
tas e interfaces e implementar um simples sistema para cada tópico analisado. 
O objetivo é elucidar as dúvidas referentes a esses dois conceitos importantes.
A inalidade de uma classe abstrata é a de funcionar como um modelo para 
as subclasses. Ao contrário de interfaces, classes abstratas podem conter campos 
(atributos) que não são static e inal, e elas podem conter métodos não abs-
tratos implementados. Tais classes abstratas são semelhantes às interfaces, exceto 
que elas fornecem uma implementação parcial, deixando a subclasses completar 
a execução. Se uma classe abstrata contém apenas declarações de métodos abs-
tratos, deve ser declarada como uma interface e não como uma classe abstrata.
As interfaces podem ser implementadas por classes em qualquer lugar na 
hierarquia de classe, quer estejam ou não relacionados uns com os outros. Em 
comparação, classe abstrata é uma subclasse de classes semelhantes que têm 
muito em comum (as partes implementadas da classe abstrata), mas também 
tem algumas diferenças (os métodos abstratos).
O QUE É CLASSE ABSTRATA?
Uma classe abstrata é desenvolvida para representar classes e conceitos abstratos. 
A classe abstrata é sempre uma superclasse que não permite que nenhum objeto 
seja criado a partir dela, ou seja, não pode ser instanciada. O uso das classes abs-
tratas é dirigido para a construção de classes que constituirão um modelo, isto é, 
classes abstratas servirão como especiicações básicas de novas classes, que serão 
implementadas por meio do mecanismo de herança. Assim, uma classe abstrata 
deve ser estendida, ou seja, deve ser a classe-base de outra, mais especíica, que 
contenha os detalhes que não puderam ser incluídos na superclasse(abstrata).
Para formalizar que uma classe seja abstrata, usamos a palavra reservada 
abstract antes da palavra reservada class. Vejamos um exemplo: 
41
Introdução
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
Figura 7: Classe Abstrata
Métodos abstratos são declarados com o modiicador abstract. Se uma classe 
tiver algum método abstrato, a classe também deverá obrigatoriamente ser declarada 
com o modiicador abstract. Os métodos de uma classe abstrata classiicados 
como abstratos devem terminar sempre com ; (ponto e vírgula) e a classe que a 
estender deverá implementá-los. Vejamos um exemplo de método abstrato:
Figura 8: Classe Abstrata
Note que esses métodos não têm uma implementação, isto é, não possuem um 
corpo delimitado por chaves contendo qualquer código. 
Uma classe também pode ser declarada abstrata mesmo que tenha um 
método não abstrato, ou a combinação de métodos abstratos e não abstratos. 
Veja exemplo abaixo:
Figura 9: Classe Abstrata
Como geralmente as classes abstratas pertencem ao nível superior de uma hierar-
quia de classes, recomenda-se que contenham tanto código quanto for possível, 
deixando para suas subclasses apenas as implementações especíicas dos méto-
dos abstratos. 
43
Modelando um Projeto com Classes Abstratas
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
É importante lembrar que uma classe abstrata que herda de outra classe 
abstrata não precisará fornecer implementação de todos os métodos abstratos 
herdados.
MODELANDO UM PROJETO COM CLASSES 
ABSTRATAS
Agora que entendemos o que é classe abstrata vamos implementar um simples 
sistema de locadora de Dvds e Cds utilizando os mais variados recursos que 
as classes abstratas oferecem. Lembrando que o sistema a ser desenvolvido é 
meramente instrutivo para que você possa compreender o funcionamento desse 
componente importante da linguagem orientada a objetos. 
É importante observar que o uso do conceito de classes abstratas precisa 
ser modelado nas atividades de aná-
lise e design do projeto, caso contrário, 
se usarmos a técnica de codiicação 
direta, talvez nunca apareça a necessi-
dade de usar esse conceito. O programa, 
a seguir, representa a implementação do 
diagrama de classe presente na igura 
abaixo.
A modelagem acima demonstra uma 
árvore de herança com uma classe abs-
trata (ItemAbstrato) e duas concretas 
(Dvd e Cds). Observe que tanto a classe 
como os métodos abstratos estão repre-
sentados com a fonte em itálico e esse 
comportamento representa um padrão 
nas modelagens UML. 
Figura 10: Diagrama de Classe do sistema de locadora
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
IMPLEMENTANDO UM PROJETO COM CLASSES 
ABSTRATAS
Vamos seguir a modelagem da igura anterior e implementar um sistema sim-
ples de locadora de Dvds e Cds. 
CRIANDO A CLASSE ABSTRATA ITEMABSTRATO
Primeiramente, vamos criar um projeto no NetBeans IDE 7.3 chamado locadora-
Abstrata; desmarque o campo Criar Classe Principal. Em seguida, crie uma classe 
nova com o nome ItemAbstrato e coloque como nome do pacote locadora.
Figura 11: Criando a classe ItemAbstrato
Agora que temos nossa classe, insira a palavra abstract antes de class 
ItemAbstrato e também os seguintes atributos e métodos abstratos da igura 
abaixo após isso gere os respectivos gets e sets dos atributos:
45
Implementando um Projeto com Classes Abstratas
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
. Figura 12: Classe abstrata ItemAbstrato
Observe que nossa classe ItemAbstrato apresenta a deinição de uma classe abs-
trata que representa um item de uma locadora. Nessa classe deinimos atributos 
e métodos comuns a um Dvd, Cd. Como a nossa intenção é analisar o compor-
tamento de classes abstratas não será implementado aqui todos os atributos e 
objetos que poderiam existir em uma locadora real, mas sim o elementar para 
compreendermos quando devemos usar classes abstratas. 
CRIANDO A CLASSE DVD QUE HERDARÁ A CLASSE ITEMABSTRATO
Agora vamos criar outra classe chamada Dvd que irá herdar a classe ItemAbstrato. 
Para isso basta acrescentar a palavra-chave extends e logo após o nome da 
classe que desejamos herdar os métodos e atributos, no caso, ItemAbstrato. Veja 
a igura abaixo como icou nossa classe:
Figura 13: Classe Dvd
Observe na igura acima que o NetBeans IDE faz uma marcação no nome da classe 
Dvd indicando que devemos implementar os métodos da classe pai, ItemAbstrato, 
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
para isso basta posicionar o ponteiro do mouse sobre o nome da classe e pres-
sionar as teclas alt+enter para abrir o menu que implementará todos os métodos 
automaticamente ou você pode utilizar o alt+insert e selecionar quais métodos 
você deseja implementar. Lembrando que uma classe não é obrigada a imple-
mentar todos os métodos abstratos da classe pai.
Figura 14: Classe Dvd
Após gerar os métodos a nossa classe Dvd icará igual a igura abaixo:
Figura 15: Classe Dvd
Observe que foi gerado todos os métodos abstratos da classe ItemAbstrato. Caso 
o NetBeans IDE gere automaticamente um código para cada método basta ignorá-
-los deletando ou apenas comentando. Note que foi gerado uma anotação acima 
dos métodos: @Override. Embora não seja necessário usar esta anotação reco-
mendo que use, pois você terá a vantagem do compilador veriicar algum erro 
de ortograia e/ou erro na combinação dos parâmetros no método da classe pai 
e também tornará seu código mais fácil de ser compreendido.
Agora é necessário implementar o código de cada método. Como o nosso 
objetivo é o estudo das classes abstratas aqui, iremos simpliicar o código. Veja 
47
Implementando um Projeto com Classes Abstratas
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
na igura abaixo o código para cada método.
Figura 16: Classe Dvd
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
Observe na igura acima que utilizamos todos os atributos da classe ItemAbstrato 
e também implementamos mais dois novos métodos concretosna classe Dvd: 
(imprimir( ) e getInstance( )). O método estático getInstance( ) retorna uma 
instância da classe Dvd que será utilizada na nossa Classe Principal. Depois fala-
remos mais sobre seu funcionamento.
CRIANDO A CLASSE CD QUE HERDARÁ A CLASSE DVD
Agora, vamos criar mais uma classe chamada Cds e vamos estender da classe 
Dvd conforme pode ser visto na igura abaixo:
Figura 17: Classe Cds
Observe que dessa vez o NetBeans não destacou o nome da Classe forçando a 
implementação dos métodos da classe herdada, pois a classe herdada não é uma 
classe abstrata como o é a classe ItemAbstrato. Porém, assim como a classe Dvd 
que herda diretamente da classe abstrata, a classe Cds passa a poder reutilizar 
todos os atributos e métodos da classe ItemAbstrato e Dvd, como também dei-
nir suas particularidades e usá-las. 
49
Implementando um Projeto com Classes Abstratas
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Dessa forma, vamos implementar a classe Cds conforme a igura abaixo:
Figura 18: Classe Cds
Observe que estamos utilizando métodos da classe ItemAbstrato e também da 
classe Dvd além de escrever métodos exclusivos da classe Cds como o método 
vender( ) e getInstance( ). A classe Cds herda esses métodos, pois eles são públi-
cos e concretos. 
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
REGRAS SOBRE CLASSES E MÉTODOS ABSTRATOS
Alguns pontos interessantes das imagens acima exempliicam algumas das regras 
de criação de classe e métodos abstratos que são:
 ■ Os métodos construtores não podem ser declarados como abstratos. 
Mesmo que a classe abstrata não possa ser instanciada, seus construtores 
podem inicializar os campos da classe que serão usados por subclasses, 
sendo imprescindível em praticamente todos os casos.
 ■ Métodos declarados como abstratos não podem ser privados (private). 
 ■ Classes abstratas não podem conter métodos estáticos (static).
 ■ Os campos de uma classe abstrata serão herdados pelas classes descen-
dentes e poderão ser usados por instâncias destas a não ser que sejam 
declarados como private. 
CRIANDO A CLASSE PROGRAMA PARA EXECUTAR NOSSO SISTEMA
Para inalizar nosso sistema, vamos criar mais uma classe com o método main 
chamada Programa. E nela vamos criar um menu e um método de escolha para 
que possamos chamar todos os métodos implementados em nosso exemplo. Veja 
na igura abaixo o código dessa classe:
51
Regras Sobre Classes e Métodos Abstratos
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Figura 19: Classe Programa
Explicando o código
Observe que criamos um laço de repetição com o método while( ) sendo 
a condição de parada a variável opcao igual a 0. Fizemos uso também da classe 
java.util.Scanner que permite a leitura de dados vindos do teclado. Com 
o método switch criamos um menu de opções. Cada opção (case) recebe 
uma instância da classe fazendo uso do método getInstance( ). Esse método 
não cria um objeto toda vez que ele é chamado e se torna ideal para o nosso 
exemplo, pois o nosso objetivo é apenas demonstrar o uso e as chamadas dos 
métodos abstratos. 
Agora que você já implementou o código acima execute o programa e visu-
alize os resultados na saída do NetBeans IDE. 
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
run
Digite 0 para SAIR ou a opcao abaixo desejada
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 1
DVD Cadastrado: - Cod: 1 - Titulo: Senhor dos Aneis - Situacao: L
DVD cadastrado utilizando método abstrato herdado da classe abstrata Item 
Abstrato
Digite 0 para SAIR ou a opcao abaixo desejada:
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 2
Dvd Emprestado: - Situacao: E - Data Emprestimo: 10/03/2013
DVD Emprestado utilizando método abstrato herdado da classe abstrata Item 
Abstrato
Digite 0 para SAIR ou a opcao abaixo desejada:
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 3
Dvd Devolvido: - Situacao: E - Data Devolucao: 10/03/2013
DVD Devolvido utilizando método abstrato herdado da classe abstrata ItemAbs-
trato
Digite 0 para SAIR ou a opcao abaixo desejada:
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 4
CD Cadastrado: - Cod: 1 - Titulo: The Best of Joy Division - Situacao: L
Cd Cadastrado utilizando método herdado da classe abstrata ItemAbstrato
53
Regras Sobre Classes e Métodos Abstratos
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Digite 0 para SAIR ou a opcao abaixo desejada:
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 5
CD Vendido utilizando método concreto da classe Cds
Digite 0 para SAIR ou a opcao abaixo desejada:
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 6
Impressao da Lista de CDs método herdado da classe Dvds
Digite 0 para SAIR ou a opcao abaixo desejada:
1- Cadastrar DVD 2- Emprestar DVD 3- Devolver DVD
4- Cadastrar CDs 5- Vender CD 6- Imprimir CDs
Opcao: 0
CONSTRUÍDO COM SUCESSO (tempo total: 1 minuto 0 segundos)
Quadro 11: Resultado do Programa
Importante lembrar que o uso de classes abstratas é realizado com classes que tem 
métodos e atributos em comum, ou pelo menos a maioria. No nosso exemplo 
a mídia DVD possui muito em comum com CDs. Além dos atributos os méto-
dos podem ser utilizados para ambas as classes. O nosso programa de locadora 
se limitou a cadastrar e vender os CDs, o que não impediria de colocá-los para 
serem alugados assim como os Dvds. 
Item 1: Considerando o uso de métodos de fabricação estáticos ao invés de 
construtores
A maneira comum de uma classe permitir que um cliente obtenha uma instância 
de si próprio é fornecendo um construtor público. Há outra técnica que deve fazer 
parte do kit de ferramentas de qualquer programador. A classe pode fornecer um 
método de fabricação estático público, que é simplesmente um método estático 
que retorna uma instância da classe. Aqui está um exemplo com a classe Boolean 
(a classe primitiva encaixotada referente ao tipo primitivo boolean). Esse método 
converte um valor primitivo boolean em um objeto de referência Boolean:
Observe que um método de fabricação estático não é o mesmo que o padrão Fac-
tory Method de Design Patterns [Gamma95, p. 107]. O método de fabricação estáti-
co descrito neste item, não tem equivalente direto com em Design Patterns.
Uma classe pode oferecer a seus clientes métodos de fabricação estáticos ao invés 
de, ou além de construtores. OFornecimento de um método de fabricação estático 
em vez de um construtor público apresenta vantagens e desvantagens.
Vantagens (citando o livro):
Uma das vantagens de métodos de fábrica estáticos é que, ao contrário de constru-
tores, eles têm nomes.
Uma segunda vantagem de métodos de fabricação estáticos é que, ao contrário 
de construtores, eles não são obrigados a criar um novo objeto sempre que são 
chamados.
Uma terceira vantagem de métodos de fabricação estáticos é que, diferente dos 
construtores, eles podem retornar um objeto de qualquer subtipo do seu tipo de 
retorno.
A quarta vantagem dos métodos de fabricação estáticos é que eles reduzem a ver-
bosidade na criação de instâncias de tipo parametrizadas.
 public static Boolean valueOf (boolean b) {
 voltar b? Boolean.TRUE: Boolean.FALSE;
 }
55
Desvantagens (ainda citando o livro):
A principal desvantagem do fornecimento exclusivo de métodos de fabricação es-
táticos é que as classes, sem construtores públicos ou protegidos, não podem ter 
subclasse.
Uma segunda desvantagem dos métodos de fabricação estáticos é que não é possí-
vel distingui-los imediatamente de outros métodos estáticos. 
getInstance – retorna uma instância que é descrita pelos parâmetros, mas não temos 
como saber se tem o mesmo valor. No caso de um singleton, getInstace não usa 
parâmetros e retorna somente a instância.
Fonte: Efective Java – Segunda Edição Joshua Bloch.
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
O QUE SÃO INTERFACES?
Há uma série de situações em engenharia de sotware onde é importante para 
diferentes grupos de programadores concordarem com um “contrato” que expõe 
a forma como o sotware vai interagir. Cada grupo deve ser capaz de escrever o 
seu código, sem qualquer conhecimento de como o código do outro grupo está 
escrito. De um modo geral isso se aplica ao importante componente da orienta-
ção a objetos conhecido por interfaces. 
Interface é um recurso da orientação a objeto utilizado em Java que deine 
ações que devem ser obrigatoriamente executadas, mas que cada classe pode 
executar de forma diferente.
Na linguagem de programação Java, uma interface é um tipo de referên-
cia, semelhante a uma classe, que pode conter apenas constante, assinaturas de 
métodos e tipos aninhados. Não há corpo de método. Interfaces não podem 
ser instanciadas, elas só podem ser implementadas por classes ou prorrogado 
por outras interfaces. E por que isso? Isso se deve ao fato de que muitos objetos 
(classes) podem possuir a mesma ação (método), porém, podem executá-la de 
maneira diferente.
Usando um exemplo bem remoto, podemos ter uma interface chamada 
marinho que possui a assinatura do método nadar( ). Ou seja, toda classe 
que implementar marinho deve dizer como nadar(). Portanto, se eu tenho 
uma classe chamada pessoa e outra chamada peixe, ambas implementando a 
interface marinho, então, nestas duas classes devemos codiicar a forma como 
cada um irá nadar( ).
CARACTERÍSTICAS DAS INTERFACES
Uma interface tem as seguintes características:
 ■ Uma interface não pode ser instanciada, mas podem ser deinidos refe-
rências do seu tipo. Vejamos um exemplo:
57
Características das Interfaces
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
Figura 20: Interface
Nesse exemplo não executamos o operador new, por isto temos apenas uma 
referência.
 ■ Todos os métodos deinidos são implicitamente do tipo public ou abs-
tract. Por essa razão, ao declarar um método em uma interface, não é 
necessário fornecer a palavra-chave public. Os métodos não podem 
ter corpo deinido, somente deinimos sua assinatura.
Figura 21: Interface
 ■ Uma interface pode estender mais de uma interface. É importante lem-
brar que uma classe pode estender somente de uma outra classe.
Figura 22: Interface
 ■ A classe que implementa uma interface deve obrigatoriamente implemen-
tar todos os métodos deinidos na interface.
 ■ Uma interface é formalmente uma classe abstrata, somente com atributos 
constantes (inal) e estáticos (static) e métodos sem corpo. Estes 
deverão ser implementados pelas classes que irão implementar a inter-
face. É importante observar que os atributos na interface precisam ser 
inicializados. Vejamos um exemplo na igura abaixo:
Figura 24: Diagrama de Classe do Sistema cadastro de Blu-Ray
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
Figura 23: Interface
MODELANDO UM PROJETO COM INTERFACES
Após compreendermos sobre interfaces e seu comportamento vamos imple-
mentar um simples sistema de cadastro de Blu-Rays, utilizando a interface como 
principal recurso. 
As interfaces são um conjunto de ope-
rações que deinem os serviços de uma 
classe ou de um componente. No nosso 
caso as interfaces existirão apenas na 
classe. Segue abaixo o diagrama de classe 
do nosso projeto de cadastro de Blu-Rays. 
A igura acima mostra as características básicas para representar Interfaces. A 
linha tracejada e com uma ponta de lecha vazada demonstra que a classe Bluray 
implementa a interface. Outra forma de mostrar que uma classe implementa uma 
interface é desenhar uma linha com um círculo em uma das extremidades com 
59
Implementando um Projeto com Interfaces
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
o nome dessa interface. As interfaces e seus métodos sempre são abstratos em 
Java. Estranhamente, ambos não aprecem em itálico, como ocorre com as clas-
ses abstratas e os métodos abstratos em classes.
IMPLEMENTANDO UM PROJETO COM INTERFACES
Vamos seguir a modelagem da igura anterior e implementar um sistema de ven-
das de Blu-Rays.
CRIANDO A CLASSE ITEMBLURAY
Primeiramente, vamos criar um projeto no NetBeans IDE 7.3 chamado blu-
rayInterface; desmarque o campo Criar Classe Principal. Em seguida, crie 
uma classe nova com o nome ItemBluRay e coloque como nome do pacote 
blurayInterface.
Na classe ItemBluRay vamos criar dois atributos e implementar os métodos 
gets e sets conforme pode ser visualizado na igura abaixo: 
Figura 25: Classe ItemBluRay
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
Essa classe será o nosso objeto para armazenarmos os dados salvos em nosso 
cadastro.
CRIANDO A INTERFACE INTERFACEBLURAY
Para criar uma interface no NetBeans IDE basta clicar com o botão direito do 
mouse sobre o pacote do projeto e no menu escolher Novo > Interface Java... e 
adicionar InterfaceBluRay como nome da Interface e clique em Finalizar.
Figura 26: Interface InterfaceBluRay
Nessa interface vamos criar um atributo estático e dois métodos conforme a 
igura abaixo: 
Figura 27: Interface InterfaceBluRay
Observe que estamos utilizando um atributodo tipo inal e static. A instru-
ção inal indica que a classe, método ou variável assim declarada tem uma única 
atribuição que se mantém constante, ou seja, não pode ser alterada no decorrer 
do processamento. A instrução static é utilizada para se criar uma variável que 
poderá ser acessada por todas as instâncias de objetos desta classe como uma vari-
ável comum. No nosso exemplo atribuímos para a variável estática PROMOCAO 
o valor de 20, e essa variável será responsável por gerar o desconto em nosso sis-
tema. A vantagem em ter um atributo estático e inal é que ao alterar a variável 
61
Implementando um Projeto com Interfaces
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
estática, todo o sistema receberá o novo valor atualizado. 
Observe que os métodos estão sem os modiicadores de acesso public, e 
conforme já apresentado anteriormente não é necessário declarar os modiica-
dores de acesso, pois todos os métodos e atributos de uma Interface são públicos.
CRIANDO A CLASSE BLURAY E ESTENDENDO A INTERFACE
Agora crie a classe Bluray e acrescente a palavra reservada implements e a 
nossa interface InterfaceBluRay. Observe na igura abaixo que o NetBeans 
IDE destacou a nossa classe para que seja criado todos os métodos exigidos pela 
interface. A interface obriga o uso de todos os métodos declarados, porém você 
quem decide como implementá-los. 
Figura 28: Classe Bluray
Implemente os métodos utilizando o atalho do NetBeans IDE posicionando o 
mouse sobre o nome da classe em destaque e pressione alt+enter.
Figura 29: Classe Bluray
Observe que o NetBeans IDE gerou os métodos automaticamente e adicionou 
a anotação @override, pois estamos sobrescrevendo os métodos da Interface. 
Vamos deletar o código que o NetBeans gerou e escrever as instruções conforme 
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
a igura a seguir:
Figura 30: Código da Classe Bluray
Nessa classe criamos um vetor de ItemBluray para armazenar os objetos 
ItemBluRay e assim obter uma lista. O método adicionarLista( ) recebe 
por parâmetro o objeto salvo na classe. Programa que será implementado a 
seguir. O método imprimirLista( ) apresenta a relação de BluRay sal-
vos no programa. 
Ainda falta um método para realizarmos os cadastros de todos os Blu-Rays. 
Como ele não foi implementado na Interface vamos criá-lo diretamente na classe 
conforme a igura abaixo:
Figura 31: Método cadastrar da Classe Bluray
O método cadastrarBluRay( ) recebe por parâmetro o objeto ItemBluRay 
da classe Programa que será implementado a seguir. 
63
Implementando um Projeto com Interfaces
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
CRIANDO A CLASSE PROGRAMA
Para inalizar vamos criar a classe Programa para executar nosso projeto. Conira 
na imagem abaixo o código para essa Classe. 
Figura 32: Código da Classe Programa
CLASSES ABSTRATAS E INTERFACES
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 Le
i 9
.6
1
0
 d
e
 1
9
 d
e
 fe
v
e
re
iro
 d
e
 1
9
9
8
.
II
Explicando o código
Observe na linha 16 da classe Programa que criamos uma instância da classe 
Bluray, chamada objBluray, lembrando que o termo instância e objeto são 
sinônimos. A criação do objeto envolve o operador new( ) que foi o utilizado 
no código acima. Em seguida, criamos a variável do tipo ItemBluRay cha-
mado objItem. 
Na linha 18 criamos o método while( ) que controla a saída ou perma-
nência no programa e logo em seguida instanciamos a variável do tipo objItem 
que será responsável por salvar as informações de cada item de Blu-Ray no 
objeto Bluray. 
Utilizamos também a classe Scanner( ) para adquirir todas opções do 
menu digitadas pelo usuário. 
Observe que por meio do objeto objBluray temos acesso a todos os méto-
dos da classe Bluray. E na linha 40 fazemos uso, pela primeira vez, do atributo 
estático que criamos na InterfaceBluRay, lembra? Na linha 41 aproveita-
mos esse recurso para realizar um cálculo de desconto ao cadastrar o Blu-Ray. 
Na nossa interface deinimos que o valor do desconto seria de 20%. Caso um 
dia o desconto mude, basta alterar o valor da variável estática e todos os progra-
mas que fazem uso dela serão atualizados automaticamente.
Pronto! Agora é só executar o programa e visualizar os resultados. 
COMPARANDO INTERFACES E CLASSES ABSTRATAS
Se você leu a seção sobre classes abstratas, talvez esteja se perguntando por que 
os projetistas da linguagem Java se deram ao trabalho de introduzir o conceito 
de interfaces? Por que a interface que criamos InterfaceBluRay não pode 
ser simplesmente uma classe abstrata? 
Há, infelizmente, um sério problema com o uso de uma classe básica abs-
trata para expressar uma propriedade genérica. Uma classe só pode estender 
uma única classe. Suponha que a classe Bluray já estenda uma classe diferente, 
65
Comparando Interfaces e Classes Abstratas
R
e
p
ro
d
u
çã
o
 p
ro
ib
id
a
. A
rt
. 1
8
4
 d
o
 C
ó
d
ig
o
 P
e
n
a
l e
 L
e
i 9
.6
1
0
 d
e
 1
9
 d
e
 f
e
v
e
re
ir
o
 d
e
 1
9
9
8
.
digamos Midia. Ela então, não poderá estender uma segunda classe. Mas cada 
classe pode implementar quantas interfaces quiser.
Outras linguagens de programação, especialmente o C++, permitem que 
uma classe tenha mais de uma superclasse. Esse recurso é chamado de Herança 
Múltipla. Os projetistas do Java optaram por não dar suporte à herança múlti-
pla, porque ela torna a linguagem muito complexa (como no C++). 
Ao invés disso, as interfaces suportam a maioria dos benefícios da herança 
múltipla e, ao mesmo tempo, evitam as complexidades e ineiciências. 
Abaixo um quadro comparativo para tornar mais fácil a compreensão entre 
diferenças e similaridades entre Classes Abstratas e Interfaces.
CARACTERÍSTICA INTERFACE CLASSE ABSTRATA
Herança
múltipla
Uma classe pode implementar 
diversas interfaces.
Uma classe pode herdar somente 
uma classe.
Implementação
Padrão
Uma interface não pode conter 
qualquer tipo de código, muito 
menos código padrão.
Uma classe abstrata pode for-
necer código completo, código 
padrão ou ter apenas a decla-
ração de seu esqueleto para ser 
posteriormente sobrescrita.
Constantes
Suporta somente constantes 
do tipo estática.
Pode conter constantes estáticas 
e de instância.
Componentes
de terceiros
Uma implementação de uma 
interface pode ser incluída a 
qualquer classe de terceiros.
Uma classe de terceiros precisa 
ser reescrita para estender so-
mente a partir da classe abstrata.
Homogeneidade
Se todas as diversas imple-
mentações compartilham a 
assinatura do método então a 
interface funciona melhor.
Se as várias implementações são 
todas do tipo e compartilham um 
comportamento e status comum, 
então a classe abstrata funciona 
melhor.
Manutenção
Se o código do seu cliente 
conversa somente em termos 
de uma interface, você pode 
facilmente