Logo Passei Direto
Buscar
Material
páginas com resultados encontrados.
páginas com resultados encontrados.

Prévia do material em texto

Técnico em Informática para Internet 
Linguagem de Programação 2
Análise de Sistemas
MÓDULO 3
�
�
�
� �
�
�
�
�
�
�
�
�
�
�
Linguagem de Programação II 
Caderno de Conteúdo da Disciplina 
 (Linguagem de Programação II) 
Prof. Gustavo Campos Menezes 
Co-autores: Prof. Ygor Colen Morato , Prof. Hilário Seibel Júnior�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 2
�
�
�
�
Tutor (Pode ser editado)�
�
�
�
����������������������������������
Prof. Autor: Gustavo Campos Menezes , Ygor Colen Morato, Hilário Seibel Júnior
e-Tec Brasil � Linguagem de Programação II 
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 3
�
�
�
Meta 
�
Apresentar�uma�visão�histórica�do�surgimento�da�linguagem�de�
Programação�Java�e�conhecer�as�principais�características�
desta�linguagem�de�Programação
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Entender�as�principais�características�da�Linguagem�
Java.�
� Conhecer�os�procedimentos�necessários�para�a�
instalação de�ferramentas��utilizadas�para�o�desenvolvimento�
dos�primeiros�programas�em�Java.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 4
�
�
�
�
�
1���Sobre�a�Linguagem�Java�
� A�linguagem�Java�foi�concebida�inicialmente�para�ser�utilizada�em�praticamente�
qualquer� dispositivo� eletrônico� (controle� remoto,� eletrodomésticos,� computadores,�
carros,�etc).�Entretanto,�com a�falta�de�financiamento�na�época�(por�volta�de�1993),�a�
linguagem�Java�só�foi�se�popularizar�em�meados�de�1995�e�1996�com�o�surgimento�e�
popularização� da� Internet.� Desde� então� a� linguagem� Java� não� para� de� crescer.�
Atualmente�ela�é�utilizada�desde�pequenos�dispositivos�(telefones�celulares,�GPS,�livros�
eletrônicos,�etc)�até�no�controle�de�grandes�aplicações�corporativas�e,�evidentemente,�
na�Internet.�
�
2���Criação�de�Programas�em�Java�
� A�tecnologia�Java�é�composta�por�uma�gama�de�produtos,�baseados�no�poder�
da� rede� e� na� idéia� de� que� um� software� deveria� ser� capaz� de� rodar� em� diferentes�
máquinas,� sistemas� e� dispositivos.� Assim� como� em� qualquer� outra� linguagem,� Java�
precisa� de� um� processo� de� compilação� para� ser� analisada� a� existência� de� erros� de�
sintaxe.�O�compilador�é�responsável�pela�tradução�do�programa�escrito�em�Java�para�
uma�linguagem�intermediária�chamada�Java�bytecodes�–�um�código�independente�de�
plataforma�que�é� interpretado�por�um� interpretador�Java.�Para�que�um�programa�em�
Java� seja�executado,�portanto,�é�necessário�possuir�uma�outra� ferramenta� chamada�
interpretador,� que� estará� emulando� a� JVM� (Máquina� Virtual� do� Java)� em� qualquer�
computador� e� sistema� operacional� que� esteja� usando.� Para� instalar� o� Kit� de�
Desenvolvimento�da�Sun,�é�necessário�seguir�os�seguintes�passos:�
1. Realizar�o�download�do�kit�de�desenvolvimento�Java�6�SDK�(Standard�Edition�–�
J2SE),� popularmente� conhecido� como� JDK� (Java�Development� Kit).� Para� isso,�
acesse�o�site�http://java.sun.com�e�escolha�a�versão�de�acordo�com�o�sistema�
operacional�que�será�utilizado.�
2. Após� instalar� a� ferramenta,� é� necessário� criar� uma� variável� de� ambiente�
chamada� JAVA_HOME� (que�deve�guardar�o�caminho�do�diretório�onde�o� Java�
foi� instalado) e adicioná�la ao PATH do seu S.O. No Windows, a sintaxe é a
seguinte�(para�a�versão�1.5.0�do�JDK,�por�exemplo), variáveis�de�ambiente:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 5
�
�
�
Abaixo�segue�os�passos�necessários�para�alterar�as�variáveis�de�ambiente�no�Windows�
XP:�
O�primeiro�passo�é�abrir�o�painel�de�controle�do�Windows,�como�na�figura�abaixo:�
�
�
�
Figura�1.1:�Visão�do�Painel�de�Controle�do�Windows��
�
Feito�isso�dê�duplo�clique�no�Ícone�Sistemas.�
A�tela�de�“Propriedades�do�Sistema”�será�exibida�como�mostra�a�figura�abaixo:�
�
�
Figura�1.2:�Visão�das�propriedades�de�sistema�do�Windows��
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 6
�
�
�
Selecione�a�guia�“Avançado”,�depois�clique�em�“Variáveis�de�ambiente”.�
Será�exibida�a�tela�abaixo:�
�
�
Figura�1.3:�Visão�das�variáveis�de�ambiente�do�Windows��
�
�
Depois�de�abrir�a�tela�de�Variáveis�de�Ambiente,�o�nosso�próximo�passo�é�encontrar�
onde�está�nossa�JDK�“Pacote�Java”�Instalado.�
Normalmente�fica�no�Diretório:�“C:\Arquivos�de�programas\Java”,�caso�não�encontre�
nesse�diretório,�localize�em�seu�sistema�a�pasta�JAVA.�
Com�o�diretório�java�localizado,�vamos�continuar.�
Clique�no�botão�“Nova”,�localizado�na�GroupBox�“Variáveis�do�sistema”.�
�
Figura�1.4:�Criando�nova�variável�de�ambiente�do�Windows��
�
�
Nesta�tela�vamos�informar,�
Nome�de�Variável:�JAVA_HOME�
Valor�da�Variável:�C:\Arquivos�de�programas\Java\jdk1.6.0_02�
Obs.:�Cuidado�que�a�versão�da�sua�JDK�pode�ser�diferente,�confirme�o�nome�do�
diretório�jdk1.6.0_02�
Feito�pode�clicar�em�“OK”!�
Vamos�clicar�novamente�no�mesmo�Botão�“Nova”,�localizado�na�GroupBox�“Variáveis�
do�sistema”.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 7
�
�
�
E�agora�vamos�informar�esses valores:�
�
�
Figura�1.5:�Criando�nova�variável�de�ambiente�do�Windows��
�
Nesta�tela�vamos�informar,�
Nome�de�Variável:�CLASSPATH�
Valor�da�Variável:�.;%JAVA_HOME%\lib\tools.jar�
Feito�isso�pode�clicar�no�“OK”!�
Agora�vamos�localizar�a�Variável�PATH,�selecionar�e�depois�clicar�em�“Editar”�
�
�
Figura�1.6:�Editando�a�Variável�PATH��
�
�
�
�
�
�
�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 8
�
�
�
A�nova�tela�irá�se�abrir,�como�mostro�a�figura�abaixo:�
�
�
Figura�1.7:Detalhe�editando�a�Variável�PATH��
�
�
�
Nesta�tela,�iremos�acrescentar�a�seguinte�informação�no�campo�“Valor�da�
Variável”.�
Valor�Acrescentado:�;%JAVA_HOME%\bin�
Irá�ficar�assim:�
�
�
Figura�1.8:Detalhe�editando�a�Variável�PATH��
�
�
Feito�isso�você�já�pode�clicar�no�“OK”!�
Clique�no�“OK”�da�tela�de�traz�e�depois�só�fechar�a�tela.�
Com�isso�você�terá�as�Variáveis�de�Ambiente�Java�configurada!�
Não�se�esqueça�de�Reinicializar�o�PC!�
�
�
3. Para�testar�a�instalação,�entre no�prompt�do�DOS�(Menu�Iniciar�>�Programas�>�
Acessórios�>�Prompt�de�Comando),�digite� javac�e�pressione� a� tecla�Enter.� Se�
aparecer�uma�tela�contendo�informações�de�help,�significa�que�a�instalação�foi�
realizada�com�sucesso.�Caso�contrário,�aparecerá�uma�mensagem� informando�
que�o�programa�ainda�não�é�reconhecido�pelo�sistema.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 9
�
�
�
Existem�diversos�IDEs�(do� inglês�“Integrated�Development�Environment”,�que�significa�
Ambiente� Integrado� de� Desenvolvimento)� com� ferramentas� de� apoio� ao�
desenvolvimento�de�softwares�em�Java,�com�o�objetivo�de�agilizar�este�processo.�
�
Nesta� disciplina,� utilizaremos� o� �NetBeans� IDE�.� Para� baixá�lo,� acesse� o� site�
http://www.netbeans.org/index_pt_BR.html� e�baixe�a�versão�mais� recente� (a�versão�
utilizada�neste�material�é�a�6.7.1).�Na�página�de�downloads,�você�também�pode�baixar�
diretamente� o� JDK� com� o�NetBeans� IDE� Java� SE� já� embutido.�Neste� caso,� não� será�
necessário�executar�os�passos�de�instalação�e�configuração�do�Java�descritos�acima.�
�
Antes�de�realizar�o�download,�não�se�esqueça�de�confirmar�que�o�programa�será�baixado�em�
português.�
�
3���Primeiro�Exemplo�de�Programa�em�Java�
�
� Para�começar�nossos�estudos,�criaremos�um�programa�em� Java�que�ao�clicar�
em�um�botão�será�mostrada�uma�mensagem�dizendo�“Olá�Mundo!”.��
�
O�primeiro�passo�é�abrirmos�o�NetBeans�e�criarmos�um�novo�projeto.�
Para�isso,�realize�os�passos�a�seguir:�
1. Clique�em�“Arquivo”�>�“Novo�Projeto”.�
�
2. Dentre� as� opções� “Categorias”� da� janela� aberta,� escolha� “Java”.� Dentro� de�
“Projetos”,�escolha�“Aplicativo�Java”.�Clique�em�“Próximo”.�
�
3. Escolha�um�nome�para�o�projeto� (por�exemplo,�“Ola_Mundo”)�e�certifique�se�
de� que� apenas� a� opção� “Definir� como�projeto�principal”� esteja selecionada.�
Clique�em�“Finalizar”.�
�
Após�criarmos�o�projeto,�ele�passa�a�ser�exibido�na�aba�“Projetos”,�que�fica�no�canto�ligar,�desligar,�atender,�etc. O�que�muda�é�como�eles�fazem�cada�funcionalidade,�mas�
repare�que�para�o�usuário�comum�pouco�importa�se�o�celular�é�GSM�ou�CDMA,�isso�fica�
encapsulado.�
Como�vimos�anteriormente,�além�do�private�existe�o�modificador�public,�que�permite�a�
todos� acessarem� um� determinado� atributo� ou�método.� Quando� não� declaramos� o�
modificador�de�acesso�de�um�atributo�ou�método,�ele�é�definido�como�protected,�uma�
espécie� de� estado� intermediário� entre� private� e� public.� Um� atributo� ou� método�
protected�só�pode�ser�acessado�(visível)�pela�própria�classe�ou�suas�subclasses.�
�
Exercício�44���Adicione�o�modificador�de�visibilidade�(private,�se�necessário)�para�cada�
atributo� e�método� da� classe� Funcionario.� Tente� criar� um� Funcionario� no� “main”� e�
modificar�ou�ler�um�de�seus�atributos�privados.�O�que�acontece?�
Exercício� 45� �� Crie�métodos� que� alteram� e� que� retornam� cada� atributo� da� classe�
Funcionario.�Exemplo:�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 76
�
�
�
Modifique�os�códigos�que�acessavam�atributos�da�classe�Funcionario�e� faça�com�que�
eles�passem�a�utilizar�as�funções�acima.�
�
Exemplo:�
f.salario�=�100;�
System.out.println(f.salario);�
passa�a�ser:�
�
f.setSalario(100);�
System.out.println(f.getSalario());�
�
�
Exemplo�de�Código�
Segue�abaixo�o�código�de�um�programa�que�guarda�os�dados�digitados�por�um�usuário�
e�retorna�os�valores.�
� Pessoa.java�
Nesta�classe�definimos�os�atributos�como�privados�usando�private.�Depois�criamos�os�
métodos�set�e�get�para�cada�atributo�da�classe,�lembrando�que�o�primeiro�nos�permite�
definir�um�valor�para�o�atributo,�enquanto�o�segundo�retorna�o�valor�do�atributo.�
Da�mesma�forma�que�nos�métodos�construtores�mais�simples�usados�nos�códigos�das�
aulas� anteriores,� o�método� set� usa� o� this� para� diferenciar� o� atributo� de� classe� do�
parâmetro�que�será�passado.�Já�o�método�get�usa�o�return,�que�serve�justamente�para�
retornar�o�valor.�
Podemos�também�observar�que�no�método�set�foi�usado�o�void,�já�que�o�método�set�
não� retornará� nenhuma� valor,� apenas� servirá� para� definir� um.� O� método� get� no�
exemplo�abaixo�foi�construido�usando�String,� já�que�o�atributo�usado�é�uma�String�e,�
por�isso,�retornará�String.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 77
�
�
Main.java�
O� código� abaixo,� é�da� classe�principal,�que� será� a�primeira� a� ser� executada.�
Como� podemos� perceber,� ela� é� feita� praticamente� da�mesma� forma� que� as� classes�
principais�dos�exemplos�mostrados�nas�aulas�anteriores.�A�diferença�aqui�é�o�uso�dos�
métodos�set�e�get�para�definirmos�e�lermos�os valores.�
Começamos�dando�o� import�necessário�para�usarmos�o�JOptionPane�e�depois�
declaramos� e� instanciamos� o� objeto� da� classe� Pessoas� para� podermos� usar� seus�
métodos�set�e�get.�
Podemos�ver�que�usamos�o�método�set�da�seguinte�forma:�
objPessoa.setNome(JOptionPane.showInputDialog("Digite�o�nome"));�
Isso� fez� com� que� aparecesse� uma� caixa� de� diálogo� (JOptionPane.showInputDialog)�
pedindo�para�o�usuário�digitar�um�nome�e�depois�esse�nome�foi�passado�pelo�método�
set�para�o�atributo�nome�da�classe�Pessoa.�Ou� seja,�o�valor�dentro�dos�parentes�do�
método�set�é�o�que�foi�definido.�Uma�forma�de�passar�o�valor�direto�no�código,�sem�a�
interação�do�usuário,�seria:�
objPessoa.setNome("Marcos�Penha");�
Depois� usamos� o�método� get� sem� parâmetros� adicionais� para� retornar� o� valor.� O�
JOptionPane.showMessageDialog�mostra�uma� caixa�de�diálogo� com�uma�mensagem�
específica.�No�código�ele�foi�colocado�com�os�métodos�get�justamente�para�mostrar�a�
caixa�de�mensagens�com�os�valores�digitados�pelo�usuário.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 78
�
�
 
 
O�NetBeans�possui�uma�funcionalidade�que�realiza�o�encapsulamento�dos�dados�para�
nós.�Para�isso,�clique�com�o�botão�direito�sobre�a�classe,�escolha�a�opção�“Refatorar”�e�
depois�clique�em�“Encapsular�campos”.�
Aparecerá�uma�janela�semelhante�à�mostrada�na�Figura�24:�
 
Figura�24:�Encapsulamento�dos�dados�
Clique� no� botão� “Selecionar� tudo”� para� que� sejam� criados� todos� os�métodos� que�
modificam� e� os� que� retornam� os� atributos� da� classe.� Em� seguida,� clique� em�
“Refatorar”.� Veja� que� o� código� da� classe� foi� automaticamente� modificado� pelo�
NetBeans.�Os�atributos�agora�possuem�o�modificador�“private”�e� já� foram�criados�os�
métodos�para�manipularmos�nossos�dados.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 79
�
�
�
�������������
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 80
�
�
Meta 
�
Apresentar�os�conceitos�de�polimorfismo,�sobrecarga�e�
herança.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Entender�os�conceitos�de�polimorfismo,�sobrecarga�e�
herança,�além�das�aplicações�destes�conceitos�na�Orientação�a�
Objetos.�
� Implementar�soluções�que�utilizem�de�herança,�sobrecarga�e�
polimorfismo.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 81
�
�
�
1���Polimorfismo�
Uma� grande� contribuição� da� orientação� a� objetos� para� o� projeto� e�
desenvolvimento�de�sistemas�é�o�polimorfismo.�A�palavra�polimorfismo�vem�do�grego�
poli�morfos�e� significa�muitas� formas.�Na�orientação�a�objetos,� isso� representa�uma�
característica�em�que�se�admite�tratamento�idêntico�para�formas�diferentes�(baseado�
em�relações�de�semelhança,�isto�é,�entidades�diferentes�podem�ser�tratadas�de�forma�
semelhante� conferindo� grande� versatilidade� aos� programas� e� classes� que� se�
beneficiam�dessas�características).�
�
POLIMORFISMO�é�a�capacidade�de�assumir�várias�formas.�“Conceito”�
�
Mostraremos�três�formas�principais�de�polimorfismo:�a�sobrecarga�de�métodos,�
a� reescrita� e� a� herança.� Em� algumas� referências� na� literatura,� polimorfismo� é�
simplesmente� o� nome� dado� à� sobrecarga� ou�mesmo� à� reescrita� de�métodos.� Nas�
próximas�seções,�detalharemos�cada�uma�delas.�
�
2���Herança�
A� idéia� da� herança� é� permitir� que� uma� classe� possa� ser� derivada� de� outra�
classe.� Um� Aluno,� por� exemplo,� é� uma� Pessoa.� Dessa� forma,� um� objeto� da� classe�
Aluno�(subclasse)�deve�“herdar”�todos�os�atributos�da�classe�
Pessoa�(superclasse),�como�altura,�peso,�etc,�bem�como�seus�métodos�(andar,�correr,�
etc).�
�
Uma�subclasse�pode�possuir�tudo�que�está�definido�na�superclasse,�além�de�ter�
suas� características�próprias.�Todo�Aluno,�por exemplo,�pode�possuir�altura�e�peso,�
características�de�qualquer�Pessoa,�e�também�um�
Número� de�Matrícula,� característica� que� nem� toda� Pessoa� possui.� O� diagrama� da�
figura�25�mostra�o�relacionamento�entre�essas�duas�classes.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 82
�
�
Figura�25:�relacionamento�das�classes�
HERANÇA�é�o�compartilhamento�de�atributos�e�operações�entre�classes�com�base�em�
um�relacionamento�hierárquico.�
�
� o�mecanismo� que� permite� a� uma� subclasse� possuir� tudo� aquilo� definido� em� sua�
superclasse,�além�de�atributos�e�operações�localmente�adicionados.�
�
A� grande� vantagem�da�herança�é�o� reuso.�O� conceito�de�herança,�quando�utilizado�
corretamente,� reduz� o� número� de� linhas� de� programação,� gera�maior� qualidade� e�
facilita�a�programação,�a�verificação�de�erros�e�
futuras�correções.�Mais�de�uma�subclasse,�por�exemplo,�pode�herdar�de�uma�mesma�
superclasse.�Podemos�criar�uma�classe�Professor�que�também�herda�da�classe�Pessoa�
descrita�acima.�O�diagrama�da�Figura�26���
mostra�o�relacionamento�entre�as�classes�Professor,�Aluno�e�Pessoa.�
 
Figura�26:�Superclasse�com�duas�subclasses�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 83
�
�
Herança� pode� ser� entendida� como� uma� técnica� na� qual� uma� classe� passa� a�
utilizar� atributos� e� operações� definidas� em� outra� classe� especificada� como� seu�
ancestral.� Rigorosamente� falando,� a� herança� é� o� compartilhamento� de� atributos� e�
operações�entre�classes�baseado�num�relacionamento�hierárquico�do�tipo�pai�e�filho,�ou�seja,�a�classe�pai�contém�definições�que�podem�ser�utilizadas�nas�classes�definidas�
como�filho.�
�
A� classe� pai� é� chamada� de� classe�base�ou� superclasse� e� as� classes� filho� são�
chamadas�de�classes�derivadas�ou�subclasses.�Este�mecanismo�sugere�que�uma�classe�
poderia� ser� definida� em� termos� mais� genéricos� ou� amplos� e� depois� refinada�
sucessivamente�em�uma�ou�mais�subclasses�específicas.�Daí�a�origem�do�termo�técnico�
que�descreve�a�herança:�especialização.�Por�exemplo,�vamos�criar�uma�classe�para�os�
funcionários�do�nosso�banco,�e�outra�específica�para�os�gerentes.�Um�gerente�guarda�
as�mesmas�informações�que�um�funcionário�comum,�mas�também�possui�
informações� e� funcionalidades� próprias� (por� exemplo,� uma� senha� que� permite� seu�
acesso�ao�sistema�interno�do�banco).�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 84
�
�
�
Nesse�caso,�o�ideal�seria�fazer�com�que�o�Gerente�possuísse�tudo�o�que�um�Funcionario�
possui� sem� reescrevermos� códigos,�ou� seja,�gostaríamos�que�a� segunda� classe� fosse�
uma�extensão�da�primeira.�Em�Java,�
fazemos�isso�utilizando�a�palavra�chave�extends.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 85
�
�
Cada�vez�que� criarmos�um�objeto�do� tipo�Gerente,�este�objeto�possuirá� também�os�
atributos�definidos�na�classe�Funcionario,�pois�agora�um�Gerente�é�um�Funcionario.�
�
Uma�subclasse�herda�todos�os�atributos�e�métodos�de�uma�superclasse.�
�
Entretanto,� não� consegue� acessar� diretamente� os� atributos� e� métodos� privados�
(private)�que�foram�herdados.�Se�quisermos�que�determinados�atributos�e�métodos�de�
uma�classe�possam�ser�acessados�diretamente�por�suas�subclasses,�mas�sem�que�eles�
sejam�públicos�(pois,�neste�caso,�poderiam�ser�alterados�por�qualquer�um),�podemos�
defini�los� como�protegidos� (protected).�Um�atributo�protected� só�pode� ser�acessado�
pela�própria�classe�ou�suas�sublasses. Exemplo:�
�
A�Figura�27���mostra�o�diagrama�das�classes�criadas�acima:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 86
�
�
Figura�27���Classes�Funcionário�e�Gerente�
 
Exercício� 46� �� Implemente� uma� classe� Aluno,� em� um� novo� projeto,� que� herda� de�
Pessoa� e�possui�o� atributo� “matricula”.� Em� seguida,� implemente� a� classe� Professor,�
que�também�herda�de�aluno.�
Qual�atributo�próprio�esta�classe�poderia�ter?�
�
Exercício�47���Implemente�a�classe�Conta�e�adicione�um�método�chamado�“atualizar”,�
que� atualiza�o� saldo�de�uma� conta�de� acordo� com�uma� “taxa”�percentual,� recebida�
como�parâmetro.�
�
Exercício� 48� �� Crie� duas� subclasses� que� herdam� da� classe� Conta:� ContaCorrente� e�
Poupanca.�
3���Sobrecarga�de�Métodos�
Outra� forma�de�polimorfismo�é�a�sobrecarga de�métodos� (method�overload),�
que� é� a� possibilidade� de� existirem� vários� métodos� com� o�mesmo� nome� em� uma�
mesma�classe.�Esses�métodos�homônimos�podem�ser�distinguidos,�por�exemplo,�pela�
quantidade�e/ou�tipo�dos�parâmetros�que�cada�um�deles�recebe.�
�
Em� outras� palavras,� para� que� esses�métodos� de�mesmo� nome� possam� ser�
distinguidos,�eles�devem�possuir�uma�assinatura�diferente.�A�assinatura�(signature)�de�
um método� é� uma� lista� que� indica� os� tipos� de� todos� os� seus� argumentos.� Assim,�
métodos� com�mesmo� nome� são� considerados� diferentes� se� recebem� um diferente�
número�ou�tipo�de�argumentos�e�têm,�portanto,�uma�assinatura�diferente.�Um�método�
que�não�recebe�argumentos�tem�como�assinatura�o�tipo�void.�Um�método�que�recebe�
dois� inteiros� como� argumentos� tem� como� assinatura� os� tipos� “int,� int”� como� no�
exemplo�abaixo:�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 87
�
�
Quando� criamos� dois� construtores� para� a� classe� “Conta”,� estávamos� utilizando�
sobrecarga�de�métodos,�mais�especificamente�sobrecarga�de�construtores.�
�
Exercício� 49� �� O�método� “aniversario”� da� classe� Pessoa� não� recebia� parâmetros� e�
incrementava�a�idade�de�um�objeto�dessa�classe.�
Crie�agora�outro�método�chamado�“aniversario”�nessa�mesma�classe,�que�receba�um�
inteiro�como�parâmetro,�indicando�quantos�aniversários�a�pessoa�fez.�
4���Reescrita�de�métodos�
Outra� forma�de�polimorfismo�é�a� reescrita�de�métodos.�Esta� técnica�permite�
implementar�um�método�em�uma�subclasse�que�tenha�o�comportamento�diferente�do�
método�na�sua�superclasse.�Vamos�supor�que,�no�final�do�ano,�os�funcionários�comuns�
do�banco�recebem�uma�bonificação�de�10%�de�seus�salários,�mas�os�gerentes�recebem�
15%.�As�classes�ficariam�da�seguinte�forma:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 88
�
�
Se�for�necessário�acessar�o�método�da�superclasse�que�foi�reescrito,�devemos�fazê�lo�
com� o� comando� “super.bonificacao(� )”.� A� palavra� “super”� se� refere� à� superclasse�
herdada.�
�
Exercício� 50� �� Reescreva� o� método� “atualizar”� da� classe� Conta� nas� subclasses�
ContaCorrente�e�Poupanca.�Na�primeira,�o�método�atualizará�o�saldo�com�o�dobro�da�
taxa�recebida�como�parâmetro.�
Na�segunda,�atualizará�com�o�triplo�da�taxa�(utilize�super�para�acessar�o�valor�do�saldo�
na� superclasse).� Reescreva� tambémo�método� “depositar”� na� classe� ContaCorrente,�
descontando�do�saldo�o�valor�de�0,35% do�que�foi�depositado.�
�
Exercício�51���Crie�um�objeto�da�classe�Conta,�um�da�classe�ContaCorrente�e�outro�da�
classe� Poupanca.� Deposite� R$1000,00� em� cada� uma� delas,� chame� em� seguida� o�
método�“atualizar”�e�depois�veja�o�saldo�final�de�cada�uma.�
 
 
 
 
 
 
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 89
�
�
 
4���Pacotes�
Quando�utilizamos�códigos�feitos�por�outros�programadores,�podemos�deparar�
com�classes�de�mesmo�nome,�o�que�pode�nos� trazer�problemas.�Um�deles�é�que�os�
sistemas�operacionais�não�permitem�que� criemos�arquivos� com�o�mesmo�nome�em�
um� mesmo� diretório;� portanto,� precisamos� organizar� essas� classes� em� diretórios�
diferentes.�
�
Os� diretórios� estão� diretamente� relacionados� aos� chamados� pacotes� e�
costumam�agrupar�classes�de�funcionalidades�similares�ou�relacionadas.�Por�exemplo,�
no�pacote�“java.util”�temos�as�classes�Date,�Simple�DateFormat�e�GregorianCalendar�
(todas�elas�trabalham�com�datas�de�formas�diferentes).�
�
Se�queremos�que�a�classe�Cliente�esteja�em�um�pacote�chamado�“banco”,�ela�deverá�
estar�em�um�diretório�chamado�“banco”.�A�classe�Cliente,�que�se�localiza�nesse�último�
diretório�mencionado,�deve�ser�escrita�da�
seguinte�forma:�
 
A�palavra�chave�package�indica�qual�o�pacote/diretório�onde�está�a�classe.�
Um� pacote� pode� conter� nenhum� ou�mais� subpacotes� e/ou� classes� dentro� dele.�Os�
pacotes�só�possuem�letras�minúsculas,�não�importa�quantas�palavras�estejam�contidas�
nele.� Esse� padrão� existe� para� evitar� ao�máximo� o� conflito� de� pacotes� de� empresas�
diferentes.�
�
Para�utilizarmos�uma� classe�definida�em�outro�arquivo,�mas� contida�em�um�mesmo�
pacote,�basta�fazermos�referência�simples�a�ela.�Vamos�supor�a�existência�das�classes�
Cliente�e�Banco�no�pacote�“banco”.�A�classe�
Cliente�deve�ser�escrita�assim:�
�
 
E�Banco�assim:�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 90
�
�
Note� que� Banco� se� referenciou� a� Cliente� da�mesma� forma� como� fazíamos� quando�
colocávamos�as�classes�em�um�mesmo�arquivo.�Para�utilizarmos�classes�definidas�em�
outro�pacote,�utilizamos�a�palavra�chave�
import�(como�já�havíamos�feito�em�capítulos�anteriores).�Exemplo:�
�
Exercício�52���Separe�as�classes�Empresa,�Funcionario�e�Data�em�arquivos�diferentes,�mas�em�
um�mesmo�pacote.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 91
�
�
�
�
�����������������
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 92
�
�
Meta 
�
Apresentar��os�mecanismos�em�Java�para�tratamento�de�erros�
e�exceções.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Conhecer�os�principais�comandos�em�Java�para�
tratamento�de�erros�e�exceções.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�� 93
�
�
�
�
1���Controle�de�Erros�
O� Java� oferece� duas� importantes� estruturas� para� o� controle� de� erros,�muito�
semelhantes�às�estruturas�existentes�na� linguagem�C++:�try�catch�e�try�finally.�Ambas�
têm�o�propósito�de�evitar�que�o�programador�tenha�que�realizar�testes�de�verificação�e�
avaliação�antes�da�realização�de�certas�operações,�desviando�automaticamente�o�fluxo�
de�execução�para�rotinas�de�tratamento�de�erro.�
�
Utilizando�estas�diretivas,�detalhadas�nas�próximas�seções,�delimita�se�um� trecho�de�
código�que�será�monitorado�automaticamente�pelo�sistema.�
�
2����Try�catch�
Quando� ocorre� um� ou�mais� tipos� de� erros� dentro� de� um� trecho� de� código�
delimitado,� o� TRY�CATCH� desvia� automaticamente� a� execução� para� uma� rotina�
designada�para�o�tratamento�específico�desse�erro.�A�sintaxe�é�a�seguinte:�
 
Por�exemplo,�podemos�criar�um�programa�que�precisa�receber�um�número� inteiro�da�
linha� de� comando.� Como� os� argumentos� são� passados� em� um� vetor� de� Strings,�
precisamos�transformar�a�String�contendo�o�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 94
�
�
número�para�um�inteiro.�Se�a�conversão�gerar�um�erro,�significa�que�o�argumento�não�
é� um� número� inteiro� válido.� A� exceção� usada,� neste� caso,� é� a�
java.lang.NumberFormatException.�
�
Outro� erro� que� podemos� tratar� é� o� caso� de� não� ser� fornecido� o� argumento� desse�
mesmo�programa,�utilizando�a�exceção�ArrayIndexOutOf�BoundsException.�Neste�caso,�
ocorrerá�um�erro�ao�tentarmos�acessar�o� índice�0�do�vetor�(que�está�vazio).�O�código�
abaixo�mostra�como�fazemos�esses�dois�tratamentos�com�o�TRY�CATCH.�
 
Podem�existir�inúmeros�blocos�catch�no�tratamento�de�erros�(cada�um�para�um�tipo�de�
exceção).�
 
3����Try�finally�
Com� o� TRY�FINALLY,� podemos� assegurar� que� uma� rotina� de� finalização� seja�
garantidamente� executada�mesmo� que� ocorra� um� erro� (isto� é,� o� trecho� de� código�
contido�na�cláusula�FINALLY�é�executado�sempre�que�o�programa�passa�pela�cláusula�
TRY).�A�sintaxe�do�try�finally�é�a�seguinte:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 95
�
�
Isso�é�particularmente� interessante�quando�certos�recursos�do�sistema�ou�estruturas�
de�dados�devem�ser�liberadas,�independentemente�de�sua�utilização.�
�
Um�mesmo�try�pode�ser�usado�com�as�diretivas�catch�e�finally.�
�
A�seguir,�mostramos�um�exemplo�de�código�utilizando�try,�catch�e�finally.�
 
 
Teste�o�exemplo�acima�em�seu�computador.�O�que�será�exibido�na�tela?�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 96
�
�
�
�
4����Tipos�de�erros�
Existem�3�diferentes�tipos�de�erros�em�Java:�
�
1. Erro�de�Runtime�(java.lang.Runtime):�são�causados�por�bugs�do�programa que�
desconhecemos,� ou� seja,� uma� condição� especial� que� sequer� havíamos�
imaginado.� Os� erros� de� Runtime� são� subclasses� da� classe� Runtime,� que� é�
subclasse�de�Exception.�
�
2. Erro�de�Sistema�(java.lang.Error):�são�erros�imprevisíveis,�causados�por�falha�do�
sistema,� como� acesso� a� disco,� erro� do� banco� de� dados,� etc.� Esses� erros� são�
subclasses�da�classe�Error.�
�
3. Erro� Customizado� (java.lang.Exception):� são� erros� ou� condições� especiais�
previstas�no�programa.�Esses�erros�são�subclasse�da�classe�Exception.�
�
Algumas�exceções�muito�comuns�são:�
�
•�ArithmeticException:�Ocorre,�por�exemplo,�quando�dividimos�um�valor�por�zero;�
�
•�NullPointerException:�Ocorre�quando�utilizamos�um�objeto�que�não�foi�instanciado.�
�
•�ArrayIndexOutOfBoundsException:�Ocorre�quando� tento�acessar�um�elemento�do�
array�que�não�existe.�
 
5����Gerando�uma�exceção�
 
Podemos�querer� tratar�erros�de� lógica�da�nossa� aplicação.�Vamos� retomar�o�
método� de� controle� bancário� que� controla� os� débitos� em� uma� conta� corrente.�Um�
cenário�possível�é�o� cliente� tentar� fazer�um� saque,�no� caixa,� acima�do� valor�do� seu�
saldo.�Até�agora,�esse�“problema”�havia�sido�tratado�da�seguinte�forma:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 97
�
�
Poderíamos� tratar�esse�caso�como�uma�exceção.�Quando�nosso�método� identificar�o�
cenário�acima,�vamos� lançar�a�exceção�IllegalArgumentException,�que�significa�que�o�
argumento� passado� para� o�método� não� era� o�que� ele� esperava.�Veja� no� trecho� de�
código�a�seguir:�
 
A� diretiva� throw� lança� uma� exceção,� para� que� um� bloco� catch� a� capture� e� faça� o�
tratamento�necessário.�Já�a�diretiva�throws�(na�primeira�linha�do�código)�apenas�avisa�
da�possibilidade�de�um�determinado�método� lançar�uma�exceção�(diferente�de�throw,�
que�efetivamente�lança�uma�exceção).�
�
Agora,�podemos�tratar�o�erro�num�nível�mais�alto,�ou�seja,�onde�o�método�de�“sacar()”�
foi� chamado.�Para� isso,�não�usaremos�mais�um� ifelse�e� sim�um� try�catch� (o�que� faz�
mais�sentido,�já�que�a�falta�de�saldo�é�uma�exceção):�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 98
�
�
Para� melhorar� ainda� mais� nosso� tratamento� de� erro,� podemos� fazer� com� que� o�
método�“sacar”�passe�uma�mensagem� junto�com�a�exceção,�explicando�o�motivo�do�
erro:�
 
Para�termos�acesso�a�essa�mensagem,�utilizamos�o�método�“getMessage()”:�
 
Se� a� exceção� lançada� for� capturada,� o� restante� do� código� dentro� do� try� não� será�
executado.�Se�tentássemos� imprimir�uma�mensagem�confirmando�o�saque� logo�após�
chamarmos�o�método�“sacar”,�ela�seria�realmente�impressa�somente�se�o�método�não�
retornar�uma�exceção.�Veja�no�exemplo�a�seguir:�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 99
�
�
6����Criando�suas�próprias�exceções�
É� comum� criarmos� uma� própria� classe� de� exceção� para� controlarmos� melhor� o�
tratamento� de� erros.� Vamos� criar� nossa� própria� classe� de� exceção,� chamada�
SaldoInsuficienteException,�que� será�uma� subclasse�de�Exception.�Veja�o� trecho�de�
código�a�seguir:�
 
Agora,�ao�invés�de�lançarmos�a�exceção�IllegalArgumentException�no�método�“sacar”,�
podemos�lançar�a�SaldoInsuficienteException.�
Por�nossa�classe�ter�herdado�de�Exception,�qualquer�método�que�lançá��la�(utilizando�a�
diretiva� throw)�deverá,�obrigatoriamente,�anunciá�la� com�a�diretiva� throws,� como� já�
havíamos�feito�no�último�código�do�método�sacar.�Isso�faz�com�que�qualquer�chamada�
a�esse�método�tenha�que�estar� inserida�num�bloco�try�que�capture�essa�exceção.�No�
caso� de� usarmos� a� IllegalArgumentException,� isso� não� seria� necessário.� O� código�
poderia�simplesmente�ser:�
 
A�chamada�do�método,�neste�caso,�poderia�ser:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 100
�
�
Sempre�que�a�exceção�for�descrita�(utilizando�throws),�ela�precisa�ser�tratada�no�local�
onde�o�método�foi�chamado.�
�
 
Exercício�53���Insira�exceções�no�método�“depositar”�da�classe�Conta,�verificando�se�o�
valor� passado� como� parâmetro� for� inválido� (negativo,� por� exemplo),� utilizando�
IllegalArgumentException.�Teste�o�método�criado.�
�
Exercício�54���Crie�sua�própria�exceção�chamada�ValorInvalido��Exception�e�utilize�a�no�
método�acima.�
�
Exercício�55���Em�quais�outros�métodos�vistos�neste�material�(nos�exemplos�e�nos�exercícios)�
podemos�inserir�o�tratamento�de�exceções?�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 101
�
�
�
�����������������������������������
��������
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 102
�
�
Meta 
�
Apresentar�ao�aluno�como�a�Linguagem�Java,�juntamente�com�
a�ferramenta�NetBeans,�permite�a�criação�e�manipulação�de�
Banco�de�Dados.�Além�disso,�a�proposta�desta�aula�inclui�uma�
visão�sobre�desenvolvimento�de�Interfaces�Gráficas.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Criar�e�realizar�a�manutenção�em�pequenos�Bancos�de�
Dados.�
� Conhecer�e�utilizar�os�principais�componentes�de�uma�
Interface�Gráfica�em�Java.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 103
�
�
�
1���Criando�e�populando�um�Banco�de�Dados�
 
Antes�de� conectarmos�nosso�código�a�um�banco�de�dados,�é�necessário�que�
esse�banco�seja�criado.�O�NetBeans�possui�uma�ferramenta�para�gerenciar�bancos�de�
dados�que�permite,�por�exemplo,�criar�um�banco,�criar�suas�tabelas,�realizar�consultas�
e� inserir�dados�nas�tabelas�do�banco.�Além�disso,�as� instalações�padrões� já�vêm�com�
um banco�de�dados�chamado�“Java�DB”�previamente�instalado.�
�
Neste�material,�iremos�utilizar�o�banco�“Java�DB”,�mas�a�lógica�dos�programas�é�
a�mesma�caso�fosse�utilizado�outro�banco,�como�MySQL�ou�PostgreSQL.�É�provável�que�
o�banco�“Java�DB”� já�esteja� instalado�e�configurado�em�seu�NetBeans. Para�conferir,�
clique�na� aba� “Serviços”� (no� canto� superior� esquerdo�de� seu�NetBeans),�expanda� a�
opção� “Banco�de�Dados”,� clique� com�o�botão�direito�em� “Java�DB”�e� crie�um�novo�
banco�de�dados�(como�na�Figura�28):�
�
Figura�28���Criando�um�banco�de�dados�no�NetBeans�
 
Em� seguida,� escolha� um� nome� para� o� banco� (por� exemplo,� “LP”),� um� login� e� uma�
senha�(que�serão�necessários�para�a�conexão�com�o�banco).�Veja�na�Figura�29:�
 
Figura�29���Nome,�usuário�e�senha�do�banco�de�dados�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 104
�
�
O�banco�criado�irá�aparecer�na�aba�“Serviços”.�Clique�com�o�botão�direito�do�mouse�no�
banco,�escolha�a�opção�“Conectar�ao�banco”�e�depois�a�expanda.�Repare�que�agora�é�
possível�visualizar�as�tabelas�do�banco�(por�enquanto�nenhuma�tabela�foi�criada).�Para�
criar�uma� tabela,� clique� com�o�botão direito�em� “Tabelas”�e�escolha�a�opção� “Criar�
Tabela”.�
�
O� banco� de dados� que� estamos� criando� irá� armazenar� os� alunos� de� um� projeto�
qualquer.�Gravando�os�dados�no�banco,�eles�continuarão�existindo�quando�o�programa�
for�iniciado�novamente.�Daí�vem�o�nome�“persistência�de�dados”.�
�
O�banco�de�dados�conterá�uma�tabela�chamada�“Aluno”,�que�irá�armazenar�um�nome�
(VARCHAR�de�tamanho�30),�uma�matrícula�(VARCHAR�de�tamanho�15)�e�as�notas�das�
provas�do�aluno�(DOUBLE).�Veja�a�janela�de�criação�da�tabela�na�Figura�30:�
�
Figura�30���Criando�a�tabela�Aluno�
 
Repare�que�a�matrícula�é�chave�primária�da� tabela,�pois�não�pode�haver�dois�alunos�
com�uma�mesma�matrícula.�Após�a�criação�da�tabela, se�clicarmos�com�o�botão�direito�
sobre�ela�na�aba�“Serviços”,�podemos�escolher�a�opção�“Visualizar�Dados”.�Esta�opção�
nos�mostra�os�dados� já� inseridos�e�permite� inserirmos�dados�na�tabela.�O�botão�para�
inserirmos�dados�na�tabela�aparece�em�destaque�na�Figura�31:�
 
Figura�31���Botão�para�inserirmos�dados�na�tabela�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 105
�
�
Clicando� no� botão,� podemos� popular� nossa� tabela� com� dados� referentes� a� alguns�
alunos.� Isso�pode�ser�útil�para� testarmos�nosso�código�mais�adiante;�portanto,� insira�
dados�para�alguns�alunos�em�sua�tabela.�
�
2���Como�conectar�e�inserir�dados�no�BD�
�
Para� conectarmos� a� um� banco� de� dados� em� Java,� precisamos� importar� a�
biblioteca�contendo�o�driver�do�banco�de�dados�que�será�utilizado.�
Clique�com�o�botão�direito�do�mouse�sobre�a�aba�“Bibliotecas”,�que�fica�dentro�da�aba�
com�seu�projeto,�e�escolha�a�opção�“Adicionar�biblioteca”.�Veja�um�exemplo�na�Figura�
32:�
�
Figura�32���Inserindo�uma�biblioteca�ao�projeto�
 
Depois,�procure�a�opção�“Driver�do�Java�DB”�ou�“JAVADB�DRIVER�LABEL”.�
Se� não� encontrar� nenhuma� das� opções,� peça� ajuda� a� seu� tutor.� Em� seguida,�
precisamos� importar� o� pacote� “java.sql.*”� no� arquivo� em� que� iremos� realizar� a�
conexão:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 106
�
�
Em�seguida,�precisamos� inserir�um�trecho�de�código�para�carregar�o�driver�do�banco,�
estabelecer�uma� conexão� com�o�banco�e� realizar�os� comandos�SQL�necessários.�Em�
nosso�projeto� inicial,�precisaremos�acessar�o�banco�de�dados�na�classe�“Interface”�a�
cada�vez�que�formos�inserir�um�novo�aluno.�Para�isso,�criaremos�o�método�mostrado�a�
seguir�(não�se�esqueça�de�importar�o�pacote�“java.sql.*”�na�classe�“Interface”):�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 107
�
�
As�strings�“driver”,�“url”,�“username”�e�“password”�precisam�estar�corretas�para�que�a�
conexão�seja�estabelecida�com�sucesso.�Para�conferir�seus�valores,�clique�com�o�botão�
direito�no�banco�de�dados� (na� aba� “Serviços”)� e�escolha� a�opção� “Propriedades”.�A�
string� contendo� o� comando� SQL� também� deve� estar� correta.�Note� que� em� SQL� os�
elementos�do�tipo�VARCHAR�precisam�estar�entre�aspas�simples�(‘).�
�
Agora,� basta� chamarmos� o� método� “inserirAlunoBD”� ao� invés� de� “incluirAluno”,�
quando�o�usuário�confirma�que�deseja�adicionar�os�dados.�
A�diferença�é�que�o�anterior�inseria�em�um�ArrayList,�agora�inserimos�em�um�Banco�de�
Dados.�Portanto,�o�atributo�da�classe�que�armazenava�o�ArrayList�de�alunos�pode�ser�
removido,�assim�como�o�método�“incluirAluno”.�
�
3���Como�recuperar�dados�do�BD�
Para�recuperarmos�valores�de�uma�tabela�no�banco�de�dados,�precisamos�nos�conectar�
a�ela�da�mesma�forma�que�fizemos�na�última�seção.�
�
No� código�fonte� da� classe� “ListaAluno”� os� dados� seram� retornados� por� um�método�
que�fará�uma�consulta�ao�banco�de�dados.�Veja�a�seguir�como�ficará�o�construtor�da�
classe�“ListaAluno”:�
 
 
 
 
 
Por�fim,�devemos�criar�o�método�para�a�consulta�ao�banco�de�dados.�
Veja�o�a�seguir:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 108
�
�
 
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 109
�
�
 
 
Note�que� fizemos�chamada�a�um�método�estático�da classe�“Interface”� (um�método�
estático�pode�ser�executado�sem�que�haja�uma�instância�da�classe)�nos�blocos�CATCH.�
�
Como� visto� no� código� acima,� o� conjunto� de� resultados� de� uma� consulta� fica�
armazenado�em�um�objeto�do�tipo�“ResultSet”.�Este�objeto�possui�um�método�“next(�
)”�que�nos�permite�percorrer�cada�linha�da�consulta�resultante.�Para�acessarmos�cada�
coluna�de� cada� linha, utilizamos�os�métodos� “getString”� (para� retornar�uma� String),�
“getDouble”�(para�retornar�um�Double),�“getInt”�(para�retornar�um�inteiro),�etc.�Cada�
um desses�métodos�recebe�como�parâmetro�o�nome�da�coluna�a�ser�retornada.�
�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 110
�
�
4���Interfaces�Gráficas�
A� seguir,�mostramos� os� principais� componentes� de� uma� interface� gráfica� em� Java.�
Alguns�deles�foram�utilizados�ao�longo�deste�material:�
�
•�JFrame:�É�onde�ficarão�todos�os�componentes�da�interface.�O�Frame,�que�contém�os�
componentes�da�interface,�possui�alguns�métodos�que�podem�ser�úteis:�
�
o�JFrame(�):�Cria�uma�janela�vazia.�
�
o�getTitle(�):�Obtém�o�título�da�janela.�
�
o�setTitle(�):�Define�o�nome�da�janela.�
�
o�setSize(�):�Define�o�tamanho�da�janela.�
�
o�setLocation(�):�Define�a�posição�da�janela�na�tela.�
�
o�isResizable(�):�Verifica�se�a�janela�é�ou�não�redimensionável.�
�
o�setResizable(boolean):�Especifica�se�a�janela�é�ou�não�redimensionável.�
�
•�Painel� (JPanel):�É�um�painel� criado�em� cima�de�um� JFrame.�Permite,�entre�outras�
opções,�adicionar�cor�de�fundo�e�borda�ao�JFrame.�
Pode� haver�mais� de� um� painel� em� um�mesmo� JFrame� e� é� utilizado� para� organizar�
melhor�sua�interface.�A�Figura�33�mostra�um�JFrame�com�dois�painéis:�
 
 
Figura�33���Frame�com�dois�painéis�
 
•�Rótulo�(JLabel):�É�um�campo�no�qual�podemos�inserir�textos�e�até�imagens.�A�Figura�
34�mostra�um�exemplo:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 111
�
�
 
Figura�34�–�Rótulo�
 
•� Campo� de� Texto� (JTextField):� É� um� campo� de� texto� cujo� conteúdo� pode� ser�
modificado�pelo�usuário.�É�nele�que�o�usuário� insere�dados�que�serão�utilizados�pelo�
programa.� Todos� os� dados� inseridos� em� um� JTextField� são� tratados� como� String.�
Portanto,� dados� numéricos� precisam� ser� convertidos.� Veja� um� campo� de� texto� na�
Figura�35:�
 
 
Figura�35���Campo�de�texto�
 
•�Área�de�Texto� (JTextArea):�É� semelhante�ao� JTextField,�mas�permite�a�entrada�de�
textos�maiores�(com�mais�de�uma�linha),�como�na�0:��
 
Figura�36���Área�de�texto�
 
•�Botão�de�Opção�(JRadioButton):�É�um�conjunto�de�opções�no�qual�apenas�uma�pode�
ser�selecionada�pelo�usuário.�Um�Grupo�de�Botões�(ButtonGroup)�é�um�componente�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 112
�
�
utilizado�para�criar�grupos�de� JRadioButtons� (é�útil�para�não�haver�confusão�quando�
temos� vários� conjuntos� de� JRadioButton).� Veja� um� exemplo� de� botão� de� opção� na�
Figura�37:�
 
 
Figura�37���Botão�de�opção�
�
 
•� Caixa� de� Seleção� (JCheckBox):� É� parecido� com� o� JRadioButton,�mas� permite� que�
vários�itens�sejam�selecionados�ao�mesmo�tempo.�
Veja�um�exemplo�na�Figura�38:�
�
�
 
Figura�38���Caixa�de�seleção�
 
 
 
 
 
 
•�Caixa�de�Combinação� (JComboBox):� É� como�uma� lista�de� itens�na�qual�o�usuário�
pode�escolher�apenas�uma�opção,�como�na�Figura�39:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 113
�
�
 
Figura�39���Caixa�de�combinação�
 
•� Botão� (JButton):� É� um� botão� que� permite� que� executemos� determinadas� ações�
quando�são�clicados.�Veja�um�exemplo�na�Figura�40:�
 
 
Figura�40�–�Botão�
 
 
 
 
 
 
 
 
 
 
 
 
 
•�Barra�de�Rolagem�(JScrollBar):�Permite�ajustar�o�conteúdo�da�área�de�visualização,�
como�na�Figura�41:�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 114
�
�
 
Figura�41���Barra�de�rolagem�
 
•�Barra�de�Progresso�(JProgessBar):�Mostra�o�progresso�e�a�porcentagem�de�conclusão�
de�uma�determinada�ação.�
�
Além� destes,� existem� componentes� para� adicionarmos� menus� a� uma� interface.� O�
NetBeans�permite�a�manipulação�dos�componentes�de�forma�fácil.�
�
Os� componentes� do� Frame� possuem� atributos que� modificam� suas� propriedades�
(como�posicionamento,�textos,�bordas,�etc).�Esses�atributos�não�serão�mostrados�aqui,�
já�que�o�NetBeans�possui�ferramentas para�facilitar�a�construção�das�interfaces.�
 
5���Caixas�de�Diálogos�
 
A� inclusão� de� mensagens� é� realizada� por� meio� da� classe� “JOptionPane”,�
especializada�na�geração�de�caixas�de�diálogo,�isto�é,�pequenas�janelas�que�fazem�uma�
pergunta,� avisam� algo� ao� usuário� ou� fornecem� uma� mensagem� qualquer.� É� uma�
característica� particular� dessa� classe� a� não�necessidade� de� sua� instanciação,� pois� as�
caixas�de�mensagens�são�criadas�diretamente�pelo�método�da�classe.�
�
Existem�quatro�tipos�padrão�de�caixas�de�diálogo:�
�
1. MessageDialog:� Caixa� de� diálogo� que� apresenta� uma� mensagem,�
possibilitando�acrescentar�ícones�de�alerta�ao�usuário.�É�utilizada�para�mostrar�
ao�usuário�alguma�informação�e�não�retorna�nenhum�tipo�de�valor�de�resposta.�
Sua�sintaxe�é:�
�
�JOptionPane.showMessageDialog(Component,� ,� ,)�
�
Onde:�
�
•� Component:� Define� a� posição� da� tela� em� que� a� caixa� de�mensagem� aparecerá.�
Quando�deixado�com�“null”,�aparecerá�centralizada�na�tela.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 115
�
�
•�Mensagem:�String�com�a�mensagem�a�ser�exibida�para�o�usuário.�
�
•�Título�da�mensagem:�É�o�título�da�janela�que�será�aberta.�
�
•�Tipo�de�mensagem:�É�o�ícone�que�representa�o�tipo�de�mensagem.�
�
O�Quadro�2���apresenta�as�constantes�da�linguagem�Java�para�definição�dos�ícones.�
 
 
Quadro�2���Tipos�de�mensagens�e�de�ícones�
 
Na�fígura�42,�mostramos�uma�caixa�de�diálogo�do�tipo�“informação”:�
 
 
Figura�42���MessageDialog.�
�
 
2. InputDialog:�Caixa�de�diálogo�que,�além�de�emitir�uma�mensagem,�permite�a�
entrada�de�um�texto.�Utilizada�para�fazer�uma�pergunta�e�solicitar�a�entrada�de�
um�texto.�Sua�sintaxe�é:�
��String� resp� =� JOptionPane.showInputDialog� (null,,,)�
�
�
�
�
Veja um exemplo na Figura 43: 
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 116
�
�
 
Figura�43���InputDialog.�
 
3. ConfirmDialog:�Caixa�de�diálogo�que,�além�de�emitir�uma�mensagem,�
possibilita�ao�usuário�responder�a�uma�pergunta.�Utilizadas�para�o�usuário�
responder�“Yes”,�“No”,�“OK”�e�“Cancel”.�Existem�três�tipos�de�caixa�de�
confirmação:�
 
•�Yes/No:�YES_NO_OPTION�(ou�0);�
•�Yes/No/Cancel:�YES_NO_CANCEL_OPTION�(ou�1);�
•�OK/Cancel:�OK_CANCEL_OPTION�(ou�2).�
 
A�sintaxe�é:�
int�resposta�=�JOptionPane.showConfirmDialog(Component,�,�,�,�)�
A�fígura�44,�mostra�uma�caixa�de�confirmação�do�tipo�Yes/No:�
�
 
Figura�44���ConfirmDialog.�
 
4. OptionDialog:�Caixa�de�diálogo�que�abrange�os�três�tipos�anteriores.��
�
Sua�sintaxe�é:�
int�resposta�=�(null,�,�,�,�,�,�,�)�
 
 
 
 
Onde:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 117
�
�
•�Array�de�objetos:� É�um� array� de�objetos� que� contém�os� componentes� ou� outros�
objetos� que� representam� as� escolhas� na� caixa� de� diálogo,� caso� YES_NO_OPTION,�
YES_NO_CANCEL_OPTION�ou�OK_CANCEL_OPTION�não�estejam�sendo�utilizados.�
�
•�Seleção�padrão:�O�objeto�que�representa�a�seleção�padrão,�caso�YES_NO_OPTION,�
YES_NO_CANCEL_OPTION�ou�OK_CANCEL_OPTION�não�estejam�sendo�utilizados.�
�
Exercício� 56� �� Para� terminar� seus� estudos� de� Java,� crie� um� novo� projeto� com� uma�
interface�gráfica�semelhante�à�da�Figura�41.�
Quando�o�usuário�clicar�no�botão,�devem�ser�exibidas�as�caixas�de�diálogo�da�Figura�
42,�da�Figura�43�e�da�Figura�44.�
�
�
Sobre�os�autores:�
Gustavo Campos Menezes � Graduado em Tecnologia em Informática 
pelo Unicentro Newton Paiva � Mestre em Ciência da Computação pela 
UFMG. Professor efetivo do CEFET-MG desde setembro de 2006, 
trabalha principalmente com disciplinas relacionadas a Linguagens de 
Programação e Algoritmos para cursos de Informática (Ensino técnico) e 
Engenharias (Graduação). 
Ygor Colen Morato - Técnico em Eletrônica formado pelo Colégio 
COTEOM em 1998, Graduado em Sistemas de Informação pela Fadom 
em Divinópolis no Ano de 2005. Trabalhou na Gerdau Divinópolis como 
Técnico em Eletrônica durante 11 anos. Hoje é Coordenador Técnico do 
Colégio Cecon e professor Substituto do CEFET-MG Campus V 
Divinópolis, onde leciona: Aplicativos para Web 2, Linguagem de 
Programação 2, Redes de Computadores e Sistemas Operacionais.
Hilário Seibel Júnior - Mestre em Informática e Graduação em Ciência 
da Computação pela Universidade Federal do Espírito Santo - Ufes. 
Professor efetivo do Ifes desde dezembro de 2007, tendo lecionado para 
o Bacharelado em Sistemas de Informação, Tecnólogo de Redes e 
Tecnólogo de Análise e Desenvolvimento de Sistemas. Atualmente, é 
coordenador dos Cursos Superiores de Informática do IFES (Campus 
Serra). Foi professor substituto na Ufes de 2005 a 2007, tendo lecionado 
para Ciência da Computação, Engenharia da Computação, Engenharia 
Elétrica e Física.
�
Referências�
�
JÚNIOR, HILÁRIO SEIBEL. Linguagens de Programação. Colatina:Ifes ,2009. 
DEITEL & DEITEL. Java como programar. São Paulo: Prentice-Hall, 2005. 
SANTOS, RAFAEL. Introdução a Programação OO usando Java. Editora: Campus, 
2003.
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 118
�
�
COSTA, Daniel Gouveia. Java em Rede: Programação Distribuída na Internet. Editora:
Brasport. 
�
�
�
��
�esquerdo do NetBeans. Para facilitar seu aprendizado, começaremos o projeto
desenvolvendo�a�interface�gráfica�de�nosso�programa.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 10
�
�
Para� isso,� precisamos� criar� um� “quadro”� (ou� frame),� que� é� o� espaço� onde� os�
componentes� de� nossa� interface� serão� exibidos.� Este� quadro� pode� ser� criado� da�
seguinte�forma:�
�
�
�
1. Na�aba�de�“Projeto”,�clique�com�o�botão�direito�do�mouse�no nome�de�nosso�
projeto.�
�
2. Escolha�as�opções�“Novo”�>�“Formulário�JFrame”.�
�
3. Escolha� um� nome� para� o� frame� e� outro� para� o� pacote� em� que� ele� estará�
inserido�(por�exemplo,�“Interface”�para�o�nome�do�frame�e�“pacoteInterface”�
para�o�nome�do�pacote).�Mais�adiante,�explicaremos�detalhadamente�para�que�
servem�os�“pacotes”�em�Java.�Clique�em�“Finalizar”.�
�
A�Figura�2���apresenta�um�trecho�da�tela�mostrada�após�a�realização�dos�passos�acima:�
�
�
Figura�2���Criando�um�Frame�para�a�interface�do�programa�
�
O�quadro�cinza�à�esquerda�da�Figura�2���é�o�frame�onde�os�componentes�da�interface�
irão�aparecer.�Na�aba�“Paleta”,�no�canto�direito�da�figura,�estão�os�componentes�que�
iremos�inserir.�Para�começar,�criaremos�um�“Painel”�onde�o�usuário�irá�digitar�o�nome�
e�a�matrícula�de�um�aluno.�Para�isso,�clique�em�“Painel”�na�opção�“Contêineres�Swing”�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 11
�
�
da�aba�“Paleta”.�Arraste�o�ponteiro�do�mouse�para�a�área�do�frame�e�você�verá�uma�
tela�como�a�mostrada�na�Figura�3.�
�
�
Figura�3���Inserindo�um�Painel�na�interface�do�programa�
�
A�área�quadrada�com�uma�borda�laranja�vista�na�figura�indica�o�local�onde�o�painel�
será�inserido�no�frame.�A�linha�pontilhada�mostra�uma�margem�dentro�do�frame,�útil�
para�alinharmos�os�componentes.�Devemos�
clicar�com�o�mouse�no�local�indicado�para�definir�a�área�onde�será�inserido�o�painel.�
Em�seguida,�iremos�redimensionar�o�painel,�para�que�caibam�os�componentes�que�
criaremos�mais�adiante.��
A�Figura�4�–�mostra�o�redimensionamento�do�painel.�
�
�
Figura�4���Redimensionando�um�painel�
�
Agora�iremos�inserir�um�botão�de�ação�dentro�do�Jpanel,�deveremos�mudar�o�texto�
que�aparece�no�botão�para�“Exibir�Mensagem”.�Como�na�figura�5,�abaixo:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 12
�
�
�
Figura�5�–�Inserindo�botão�de�ação�
�
Para�efetuar�a�mudança�deste�texto,�você�precisa�clicar�no�botão�e�abrir�as�
propriedades�do�mesmo�que�fica�a�direita�e�na�propriedade�text,�como�na�figura�6�
basta�você�colocar�o�valor�desejado.�
�
�
Figura�6�–�Janela�de�Propriedades�
�
�
Devemos�agora� colocar�um� título�na� janela,�que�é�nosso� Jframe,�para� isto�devemos�
clicar�no� Jframe�e� chamar� suas�propriedades,�devemos�alterar�a�propriedade� “Title”�
para�o�valor�desejado�como�na�figura�7.�
�
�
Figura�7�–�Janela�de�Propriedades�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 13
�
�
Agora� iremos� fazer�nossa�primeira� codificação�em� Java,�para� isso�dê�dois� cliques�no�
botão�de�ação,� irá�aparecer�a� janela�de�codificação�como�na� figura�8�abaixo,�digite�o�
código�como�esta�na�figura�8�e�rode�o�programa�através�de�“SHIFT�+�F6”.�
�
�
Figura�8�–�área�de�codificação�
�
Irá�aparecer�uma� janela�que�é�seu�programa�que�foi�desenhado,�e�ao�clicar�no�botão�
de�ação�deverá�aparecer�como�abaixo,�uma�mensagem�que�esta�ao�lado�do�programa�
e�lá�embaixo�como�saída�via�console�aparece�nossa�segunda�mensagem:�
�
�
Figura�8�–�Resultado�de�saída�do�primeiro�programa�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 14
�
�
ATIVIDADES:�
�
Exercício�1� ��É�extremamente� importante�que�você� tente�executar�os�passos�acima�antes�de�
continuar� a� leitura� do� material.� Portanto,� tente� desenvolver� um� projeto� com� a� interface�
semelhante�à�que�fizemos�até�aqui.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 15
�
�
�
������������������
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 16
�
�
Meta 
�
Continuar�apresentando�modelos�de�programas�em�Java,�bem�
como�características�do�ambiente�de desenvolvimento.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Entender�os�mecanismos�básicos�de�desenvolvimento�
utilizando�um�ambiente�de�desenvolvimento.�
� Conhecer�comandos�e�funcionalidades�da�linguagem�Java�e�
do�ambiente�de�desenvolvimento.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 17
�
�
�
�
1���Segundo�Exemplo�de�Programa�em�Java�
Criaremos� um� programa� em� Java� que� calcula� as� áreas� de� 3� figuras� geométricas,�
triângulo,�Quadrado�e�Retângulo.�No�programa,�você�deverá�marcar�qual�área�deseja�
calcular,� com� base� nisso� deverão� aparecer� as� caixas� onde� informar� os� valores�
necessários�para�o�cálculo�de�determinada�área�e�ao�clicar�no�botão�calcular�o�valor�
encontrado�deve�ser�informado�em�uma�caixa�de�resultado.�
�
O�primeiro�passo�é�abrirmos�o�NetBeans�e�criarmos�um�novo�projeto.�
Para isso,�realize�os�passos�a�seguir:�
�
1. Clique�em�“Arquivo”�>�“Novo�Projeto”.�
�
2. Dentre� as� opções� “Categorias”� da� janela� aberta,� escolha� “Java”.� Dentro� de�
“Projetos”,�escolha�“Aplicativo�Java”.�Clique�em�“Próximo”.�
�
3. Escolha�um�nome�para�o�projeto�(por�exemplo,�“Area”)�e�certifique��se�de�que�
apenas�a�opção�“Definir�como�projeto�principal”�esteja�selecionada.�Clique�em�
“Finalizar”.�
�
�
Após�criarmos�o�projeto,�ele�passa�a�ser�exibido�na�aba�“Projetos”,�que�fica�no�canto�
esquerdo� do� NetBeans.� Para� facilitar� seu� aprendizado,� começaremos� o� projeto�
desenvolvendo�a� interface�gráfica�de�nosso�programa.Para� isso,�precisamos�criar�um�
“quadro”� (ou� frame),�que�é�o�espaço�onde�os�componentes�de�nossa� interface�serão�
exibidos.�Este�quadro�pode�ser�criado�da�seguinte�forma:�
�
�
1. Na�aba�de�“Projeto”,�clique�com�o�botão�direito�do�mouse�no nome�de�nosso�
projeto.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 18
�
�
�
2. Escolha�as�opções�“Novo”�>�“Formulário�JFrame”.�
�
3. Escolha� um� nome� para� o� frame� e� outro� para� o� pacote� em� que� ele� estará�
inserido�(por�exemplo,�“Interface”�para�o�nome do�frame�e�“pacoteInterface”�
para�o�nome�do�pacote).�Mais�adiante,�explicaremos�detalhadamente�para�que�
servem�os�“pacotes”�em�Java.�Clique�em�“Finalizar”.�
�
�
Figura�9�–�Interface�gerada�após�os�passos�acima.�
�
Lembre�se�que�na�aba�“Paleta”,�no�canto�direito�da�figura,�estão�os�componentes�que�
iremos� inserir.� Para� começar,� criaremos� um� “Painel”� onde� o� usuário� irá� escolher� a�
opção�que�deseja�calcular.�Para�isso,�clique�em�“Painel”�na�opção�“Contêineres�Swing”�
da�aba�“Paleta”.�Arraste�o�ponteiro�do�mouse�para�a�área�do�frame�e�você�verá�uma�
tela�como�a�mostrada�na�Figura�10.�A�área�quadrada�com�uma�borda� laranja�vista�na�
figura� indica�o� local�onde�o�painel�será� inserido�no� frame.�A� linha�pontilhada�mostra�
uma�margem�dentro�do�frame,�útil�para�alinharmos�os�componentes.�Devemos�clicar�
com�o�mouse�no� local� indicado�para�definir� a� área�onde� será� inserido�o�painel.� Em�
seguida,� iremos� redimensionar� o� painel,� para� que� caibam� os� componentes� que�
criaremos�mais�adiante.�A�Figura�9�–�mostra�o�redimensionamento�do�painel.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 19
�
�
�
Figura�10�–�Conteiners.�
�
Nosso�programa�conterá�dois�painéis:�um�para�escolha�de�qual�área�deverá�ser�calcula�
e�outro�para�informar�os�dados�da�área�a�ser�calculada.�Tente�executar�os�passos�feitos�
acima,�e�em�seguida� insira�outro�painel�em�seu�programa.�A�Figura10� ��mostra�como�
deve�ficar,�por�enquanto,�o�frame�de�nosso�programa.�
�
�
�
Como� queremos� distinguir� as� opções� de� área� e� o� local� de� entrada� dos� dados,�
adicionaremos�uma�borda�e�um� título� aos�nossos�painéis.�Primeiro,� clicamos� com�o�
botão� direito� sobre� o� painel� de� cima,� e� escolhemos� a� opção “Propriedades”.� Será�
exibida�uma�tela�como�a�mostrada�na�figura�11.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�� 20
�
�
�
Figura�11�–�janela�de�propriedades.�
�
O�item�“border”,�que�aprece�em�destaque�na�figura,�define�como�será�esta�borda�que�
queremos�alterar�no�painel.�Para�modificar�este�atributo,�devemos�clicar�no�botão�do�
item.�Clicando�nele,�será�exibida�uma�tela�semelhante�à�mostrada�na�Figura�12.�
�
�
Figura�12���Modificando�a�borda�do�painel�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 21
�
�
Na�tela�mostrada�na�Figura�12,�escolhemos�o�tipo�da�borda�como�“Borda�de�título”,�e�
definimos�o�Título�como�“Tipos�de�Áres”.�Podemos�também�alterar�a�fonte�com�a�qual�
o�título�será�escrito,�clicando�no�botão�ao�lado�do� item�“Fonte”.�Após�clicar�no�botão�
do�item�“Fonte”,�definimos�a�fonte�com�estilo�“Negrito”�e�de�tamanho�“12”,�e�clicamos�
em� seguida� em� “OK”.� Voltando� à� tela� da� Figura� 12,� clicamos� novamente� em� “OK”,�
depois�no�botão�“Fechar”,�e�visualizamos�o�painel�com�a�borda�e�o�título�definidos�nos�
passos�anteriores.�A�Figura�13�mostra�a�modificação�na�borda�e�no�título�do�painel:�
�
�
Figura�13���Bordas�dos�painéis�modificadas�
�
Na�tela�mostrada�na�Figura�13,�a�borda�e�o�título�do�painel�onde�ficarão�as�opções�que�
já� foram�modificados� (repita� os� passos� anteriores� para� que� isso� seja� feito� em seu�
programa).�
�
Exercício� 2� �� É� extremamente� importante� que� você� tente� executar�os� passos� acima�
antes�de�continuar�a�leitura�do�material.�Portanto,�tente�desenvolver�um�projeto�com�
a�interface�semelhante�à�que�fizemos�até�aqui.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 22
�
�
2���Incluindo�Componentes�nos�painéis�
Expandindo� a� opção� “Controles� Swing”� da� aba� “Paleta”,� encontramos� os�
componentes�que�iremos�inserir�em�nossos�painéis.�O�primeiro�item�a�ser�preenchido�
pelo�usuário�será�a�escolha�de�uma�das�opções�de�cálculo.�Para�isso,�iremos�inserir�um�
“Botão� de� Opção”,� onde� deverá� ser� marcado� uma� das� opções,� que� serve� para�
explicação�do�que�deve�ser�inserido�nesse�campo.�
Para� isso,�clicamos�primeiro�em�“Botão�de�Opção”�e�definimos�o� local�onde�o�
botão�será�inserido,�como�mostrado�na�Figura�14:�
�
�
Figura�14�–�Inserindo�um�botão�de�opção�
�
Para�definirmos�o�texto�que�aparecerá�no�botão�de�opção,�clicamos�com�o�
botão�direito�no�mesmo�e�escolhemos�a�opção�“Editar�texto”,�inserindo�o�texto�
“Triângulo”. Devemos�repetir�este�processo�3�vezes�pois�precisamos�ter�ao�3�“botões�
de�opção”,�como�mostra�a�figura�15:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 23
�
�
�
Figura�15�–�Detalhes�botões�de�opção�
�
Expandindo� a� opção� “Controles� Swing”� da� aba� “Paleta”,� encontramos� os�
componentes� que� iremos� inserir� o� nosso� painel� Cálculo.� O� primeiro� item� a� ser�
preenchido�pelo�usuário�nesta�área,�se�o�cálculo�for�da�área�do�triângulo�será�o�valor�
da�base�deste� triêngulo.�Para� isso,� iremos� inserir�um� “Campo�de� Texto”,�onde� esse�
valor�será�digitado,�e�um�“Rótulo”,�que�serve�para�explicação�do�que�deve�ser�inserido�
nesse�campo.�
Para�isso,�clicamos�primeiro�em�“Rótulo”�e�definimos�o�local�onde�o�rótulo�será�
inserido,�como�mostrado�na�Figura�16:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 24
�
�
�
Figura�16�–�Inserindo�um�rótulo�
�
Para� definirmos� o� texto� que� aparecerá� no� rótulo,� clicamos� com� o� botão� direito� no�
mesmo� e� escolhemos� a� opção� “Editar� texto”,� inserindo� o� texto� “Base”.�Ao� lado� do�
rótulo�incluímos�um�“Campo�de�Texto”,�como�mostrado�na�Figura�17:�
�
Figura�17���Inserindo�um�campo�de�texto�
�
Em�seguida,�editamos�o�texto�do�“Campo�de� texto”�criado�acima� (neste�caso,�
deixamos� o� campo� em� branco� para� que� o� usuário� digite� o� valor� da� base)� e�
redimensionamos�o�campo,�produzindo�uma�tela�semelhante�à�mostrada�na�Figura�18:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 25
�
�
�
Figura�18�–�Limpando�e�redimensionando�o�campo�de�texto�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 26
�
�
Exercício�02���Continue�desenvolvendo�a�interface�de�nosso�programa.�
Para isso,�crie�uma�tela�semelhante�à�mostrada�na�Figura�19:�
�
�
Figura�19���Tela�do�Exercício�2�
�
�
�
�
�
Atenção! 
A�próxima�seção�apresenta�a�continuação�da�interface�de�nosso�programa.�
�
Por�isso,�tente�realizar�o�Exercício�2���antes�de�continuar�a�leitura�do�material.�
Para�executarmos�nosso�programa�no�NetBeans,�basta�executarmos�o�projeto�no�
qual�o�estamos�criando.�
�
Para� isso,�clique�com�o�botão�direito�sobre�o�nome�do�projeto�na�aba�“Projetos”�
(no�canto�esquerdo�do�NetBeans),�e�depois�em�“Executar”.�
Se�preferir,�basta�clicar�a�tecla�“F6”.�
�
Ao� executá�lo,� o� NetBeans� pedirá� para� escolhermos� a� classe� principal� a� ser�
executada� (mais� adiante� explicaremos� o� que� é� uma� classe� principal).� Por�
enquanto,�escolha�a�classe�“pacoteInterface.Interface”,�
que�é�a�única�opção�da�lista.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 27
�
�
3���Adicionando�Funcionalidades�ao�programa�
Nas� últimas� seções,� começamos� a� desenvolver� a� interface� gráfica� de� nosso�
primeiro�programa�em�Java.�Entretanto,�o�programa�ainda�não�possui�funcionalidades.�
Para isso,� vamos� incluir� um� botão� para� que� seja� calculada� as� áreas.� Um� botão� é�
inserido�por�meio�do� item�“Botão”�da�opção�“Controles�Swing”�na�aba�“Paleta”� (no�
mesmo� local� onde� encontramos� o� “Rótulo”� e� o� “Campo� de� texto”� anteriormente).�
Incluímos� então� um� botão� ao� lado� do� campo� de� texto� com� a� área� e,� em� seguida,�
editamos�o�texto�do�botão�(de�forma�que�seja�exibida�a�frase�“Calcular�Área”).�Temos�
que�ressaltar�que�nosso�programa�irá�calcular�3�áreas�diferentes.�Veja�na�Figura�20���o�
botão�inserido�em�nossa�interface.�
�
�
Figura�20���Tornando�um�campo�de�texto�não�editável�
�
Além� disso,� fizemos� com� que� os� campos� de� texto� com� o� resultado� da� área�
deixasse�de�estar�disponível�para�ser�editado�pelo�usuário.�Para� isso,�clicamos�com�o�
botão� direito� em� cada� um� dos� campos� e� escolhemos� a� opção� “Propriedades”.� Em�
seguida,� desmarcamos� a� opção� “editable”� (que� faz� com� que� ele� não� seja� editável).�
Agora� vamos� criar� o� código� que� irá� calcular� a� área� do� triângulo,� para� isso� iremos�
verificar� se� o� “jRadioButton1”� que� é� a� opção� de� triângulo� está�marcado� se� estiver�
vamos�efetuar�o�cálculo�que�é:�
�
�
�
Área�é�igual�a�base�vezes�altura,�dividido�por�2!�
�
Para� isso,� clicamos� com�o�botão�direito�do�mouse� sobre�o�botão�que� acabamos�de�
criar,�depois�em�“Eventos”,�depois�em�“Action”�(que�significa�“ação”�em�português)�e�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 28
�
�
depois� na� única� opção� disponível� (actionPerformed� [jButton1ActionPerformed]).�
Repare� que� agora� o� NetBeans� está� exibindo� o� código� fonte� da� interface� de� nosso�
programa.�
�
Na�verdade,�o�código� fonte� já�podia�ser�exibido�desde�quando�criamos�nosso�Frame.�
Para�isso,�bastava�alternarmos�entre�os�botões�“Código��Fonte”�e�“Projeto”�acima�do�
código�(mostrados�no�topo�das�telas�da).O�código�fonte�exibido�pelo�NetBeans�contém�
vários�detalhes�da�linguagem�Java�que�ainda�não�foram�explicados�neste�material.�Não�
se�preocupe�com�isso�agora.�Mais�adiante�explicaremos�todos�esses�detalhes.�
�
Por�enquanto,�nossas�atenções�devem� ser�voltadas�ao� trecho�de� código�mostrado�a�
seguir:�
�
�
�
A�seguir,�mostramos�o�trecho�de�código�necessário�para�efetuarmos�o�cálculo�da�área�
do�triângulo�e,�em�seguida,�explicamos�o�que�o�código�faz:�
�
�
�
Como� podemos� observar� no� trecho� de� código� acima,� Java� possui� o� tipo�
“double”,� assim� como� C,� que� é� utilizado� para� representar� um� número� real� com�
precisão� dupla.� Entretanto,� os� campos� de� texto� digitados� pelo� usuário� são� tratados�
sempre� como� String.� Para� calcularmos� a� área,� portanto,� precisamos� encontrar� os�
valores�digitados�e�transformá�los�em�double.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�� 29
�
�
�
O�método�“this.jTextField1.getText(�)”,�por�exemplo,�recupera�o�texto�digitado�
no� campo� “jTextField”� (que� corresponde� à� base� do� triângulo).� O� método�
“Double.parseDouble”� foi�utilizado,�então,�para� transformar�o texto�em�double.�Por�
fim,�“Double.toString(media)”�transforma�a�média�final�(que�é�um�double)�em�String,�
para� que� ela� seja� definida� como� o� texto� do� campo� com� a� área� através� do�método�
“this.jTextField3.setText(Double.toString(result))”.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 30
�
�
Exercício�03���Agora�desenvolva�seu�programa�com�calma,�execute�o,�e�verifique�se�o�
cálculo�está�sendo�feito�corretamente.�
Não�se�preocupe�muito�com�aspectos�da� linguagem�Java�que�você�não�conhece,�pois�
os�mesmos�serão�explicados�em�detalhes�a�partir�do�próximo�capítulo.�
No�mais,�seja�bem�vindo�ao�mundo�dos�programadores�Java,�que�é�a� linguagem�mais�
utilizada�no�mercado�de�trabalho�atualmente!�
Agora� é� necessário� que� você� faça� seu� programa� calcular� as� demais� áreas,� isso� fica�
como�desafio!�
�
Atenção !! 
Não�apague�seu�projeto!�Iremos�retomá�lo�no�capítulo�4.��
Se�precisar�acessar�os�arquivos�de�seu�projeto,�eles�ficam�armazenados�dentro�
da�pasta��NetBeans�Projects�,�que�fica�na�pasta��Meus�Documentos�.�
 
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 31
�
�
�
������������������
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 32
�
�
Meta 
�
Apresentar�ao�aluno�os�principais��tipos�de�dados�e�comandos�
na�linguagem��Java:��Strings,�Arrays,�Operadores,�Funções�
Matemáticas,�Controle�de�Fluxo,�Escopo�de�Variáveis,�Garbage�
Collection.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Desenvolver�pequenos�aplicativos�em�Java.�
� Conhecer�as�principais�estruturas�e�comandos�em�Java�
para�solução�de�problemas.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 33
�
�
�
�
1���Código�em�Java�
Neste� capítulo� ainda� não�mostraremos� os� conceitos� de� orientação� a� objeto,�
que�é�uma�das�principais�características�da� linguagem� Java.�Também�deixaremos�um�
pouco�de� lado�a�criação�de� interfaces�gráficas,�que� iniciamos�no�capítulo�passado,�e�
retomaremos� mais� para� a� frente.� Por� enquanto,� vamos� nos� focar� na� criação� de�
programas�em�Java�semelhantes�aos�que�criávamos�em�C.�Apresentamos�a�seguir�um�
exemplo�simples�de�código�na�linguagem�Java.�
�
�
�
A�principal�diferença�que�podemos�notar�já�de�início�é�que�todo�programa�em�
Java�inicia�se�com�a�definição�de�uma�classe.�Uma�classe�é�definida�através�da�palavra�
reservada�class,�seguida�pelo�nome�da�classe�(neste�caso,�o�nome�da�classe�é�“Um”).�
Por� convenção,� todo� nome� de� classe� inicia�se� com� uma� letra� maiúscula.� Preste�
bastante�atenção�na� sintaxe,�pois� Java�é� case� sensitive� (sensível�ao� caso),�ou� seja,�o�
compilador� diferencia� letras� maiúsculas� de� minúsculas.� Uma� classe� em� Java� é�
composta�por�métodos�(considerados�funções�ou�procedimentos�em�outras�linguagens�
de� programação).� Obrigatoriamente, a� classe� principal� (aquela� que� será� executada�
inicialmente�pelo�programa)�deve�possuir�um�método�chamado�main,�assim�como�em�
C,�que�é�invocado�quando�a�classe�é�executada.�
A�palavra�main�significa�principal�em� inglês.�O�método�main,�portanto,�será�o�
método� principal� do� seu� programa.�Os� atributos� “public”� e� “static”� serão� descritos�
mais�adiante.�O�atributo� “void”,�assim� como�em�C,� indica�que�o�método�não�possui�
retorno.�O� argumento� “String� args[� ]”� é� um� vetor� de� Strings� formado� por� todos� os�
argumentos� passados� ao� programa� na� linha� de� comando� quando� o� programa� é�
invocado.�O�comando�“System.out.println�(�)”�imprime�algo�na�tela.�
�
Para�compilar�e�executar�o�programa,�primeiro�é�preciso�salvá�lo�com�o�nome�
“Um.java”.� Você� pode� fazê�lo� até� mesmo� em� um� editor� de� texto� simples,� mas�
continuaremos�a�mostrar�nossos�exemplos�no�NetBeans.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 34
�
�
Para�não�haver� confusão� com�os� códigos�do capítulo�passado,� crie�um�novo�
projeto� no� NetBeans.� Desta� vez,� deixe�marcadas� as� opções� “Criar� classe� principal”�
(defina�o�nome�da�classe�principal�como�“Um”)�e�“Definir�como�projeto�principal”.�A�
classe� “Um”� criada� já� irá� possuir� um�método� “main”.�Neste� caso,� apenas� insira� no�
método�o�comando�“System.out.println�(“Programa�UM!!!!!”)”.�
� Em� Java,�o�nome�do�
arquivo�deve�ser�sempre�igual�ao�nome�da�classe,�seguida�da�extensão�“.java”.�No�caso�
do�nosso�exemplo,�o nome�do�arquivo�precisa�ser�“Um.java”�porque�o�nome�da�classe�
é�“Um”.�
Em� seguida,� execute� o� projeto.� Como� não� criamos� uma� interface� para� o�
programa,�a�saída�será�exibida�na�aba�“Saída”,�localizada�abaixo�dos�códigos�fontes�no�
NetBeans.�Veja�em�destaque�na�Figura�21���esta�região�com�a�saída�do�programa:�
�
�
Figura�21���Saída�de�um�programa�Java�no�NetBeans�
�
Se� você� for� executar�o�programa� fora�do�NetBeans,�é�necessário� abrir�o�prompt�na�
pasta�em�que�salvou�o�arquivo�e�digitar�os�seguintes�comandos:�
�
�
�
O� primeiro� comando� gera� o� bytecode� do� programa,� chamado� “Um.class”.�O�
segundo�executa�o�programa�a�partir�do�bytecode�gerado�no�primeiro�comando.�Se�for�
necessário�incluir�mais�de�uma�classe�em�um�mesmo�arquivo,�só�uma�delas�poderá�ser�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 35
�
�
public.� Esta� será� a� classe� principal� do� arquivo.� Caso� nenhuma� classe� seja� public,� o�
compilador�entenderá�que�a�classe�principal�é�aquela�com�o�mesmo�nome�do�arquivo.�
�
�
Curiosidade:�O�que�acontece�se�você� tentar�compilar�um�arquivo�sem�nada�dentro�
(nenhuma�letra�e�nenhuma�quebra�de�linha)?�
�
Exercício�04 ��Modifique�o�programa�anterior�para�que�ele�imprima�mais�que�duas�
mensagens,�sendo�uma�em�cada�linha.
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
Leia�mais�sobre�Java�em:�
�
�http://javafree.uol.com.br/artigo/871498/Tutorial�Java�O�que�e�Java.html�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 36
�
�
2���Tipos�de�Dados�e�Definições�de�Variáveis�
Além�dos�tipos�de�dados�existente�no�C,�o�Java�possui�também�um�tipo� lógico�
(boolean),�que�pode�assumir�os�valores�verdadeiro�(true)�ou�falso�(false).�Os�tipos�de�
dados� primitivos da� linguagem� Java� estão� enumerados� no� Quadro� 1,� mostrado� a�
seguir:�
�
�
Quadro�1���Tipos�de�dados�primitivos�em�Java�
�
Para�uma�variável� ser�utilizada,�ela�precisa� ser�declarada.�Opcionalmente,�ela�
pode� ser� inicializada� já� no�momento� de� sua� declaração.� O� código� a� seguir�mostra�
alguns�exemplos�de�manipulação�de�variáveis�em Java:�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 37
�
�
�
Como�você�pôde�perceber�no�último�exemplo,�um�comentário�em�Java�pode�ser�escrito�
com�//�(para�comentar�apenas�até�o�final�da�linha)�ou�com�/*�*/�(para�comentar�tudo�o�
que�estiver�entre�o�/*�e�o�*/).�
Para�identificar�a�documentação,�utilizamos�/**�*/�
�
A�saída�do�programa�acima�será:�
�
�
�
Caso� uma� variável� do� tipo� char,� byte,� short,� int,� long,� float� ou� Double� não� seja�
inicializada,�ela�é�criada�com�o�valor�0.�Se�ela� for�do� tipo�boolean,� seu�valor�padrão�
será�false.�
�
�
É�possível�criar�mais�de�uma�variável�do�mesmo�tipo�na�mesma�linha,�separando�as�por�
uma�vírgula.�
Exemplo:�int�x,�y,�z;�
�
Exercício�05��� Insira�em�seu�programa�duas�variáveis�de�cada�um�dos�tipos�primitivos�
do�Java.�Coloque�valores�diferentes�em�cada�uma�delas�e�depois�as�imprima.�
�
Exercício�06� ��Altere� três� vezes�o� valor�de�uma�das� variáveis�do�programa� anterior.�
Imprima�a�variável�a�cada�nova�atribuição.�
�
Em�Java,�existem�duas�formas�de�convertermos�valores�de�um�tipo�para�outro:�
1. A� conversão� implícita,� na� qual� os� dados� são� convertidos� automaticamente,�
sem� a� preocupação� do� programador.� Ela� ocorre,� por� exemplo,� quando�
convertemos�um�número�inteiro�para�um�número�real.�Neste�caso,�a�conversão�é�implícita�porque�é�óbvio�para�o�compilador�que�um�número�inteiro�pode�ser�
representado�também�como�um�número�real.�
Veja�um�exemplo�a�seguir:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 38
�
�
�
�
2. A�conversão�explícita,�quando�o�programador�precisa�explicitar no�código�que�
um�valor�será�convertido�de�um�tipo�para�outro.�No�caso�de�um�número�real�
para�um� inteiro,�por�exemplo,�pode�haver�perda�na�precisão�do�número� (por�
isso� é� necessário� que� o� usuário� deixe� explícito� que� ele� quer� realizar� a�
conversão).�Veja�um�exemplo�a�seguir:�
�
�
�
O�resultado�da�execução�do�trecho�de�código�acima�é:�
�
�
�
Cuidado:�O�tipo�boolean�não�pode�ser�convertido�para�nenhum�outro�tipo.
�
Seguindo� o� sentido� das� setas� da� Figura� 22� �,� vemos� os� tipos� que� podem� ser�
implicitamente�convertidos�em�outros.�Seguindo�o�sentido�contrário,�vemos�os� tipos�
que�precisam�ser�convertidos�explicitamente:�
�
�
Figura�22���Conversões�possíveis�entre�tipos�primitivos�em�Java�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 39
�
�
Exercício�07���Crie�três�variáveis�do�tipo�int�contendo�os�valores�12,�13�e�14.�Converta�
cada�uma�para�um�float�e�imprima�o�valor�convertido.�Qual�o�resultado�impresso�na�
tela?�
�
Exercício�08���Agora,�crie�três�variáveis�do�tipo�float�contendo�os�valores�12.3,�12.5�e�
12.8.�Converta�cada�uma�para�int�e�imprima�o�valor�convertido.�Qual�o�resultado�
impresso�na�tela?�
�
Exercício�09���Tente�imprimir�a�soma�de�uma�variável�inteira�com�uma�do�tipo�float.�O�
que�acontece?�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 40
�
�
3����Strings�,�Vetores�,�Operadores,�Funções�Matemáticas�e�
Controle�de�Fluxo�
String� é� uma� classe� em� Java� que� guarda� uma� palavra,� ou� seja,� uma� sequência� de�
caracteres.�String�é�uma�classe�para�representarmos�uma�cadeia�de�caracteres,�e�que�
oferece� diversos�métodos� para�manipularmos� essa� cadeia.�Objetos� da� classe� String�
podem�ser�concatenados�com�o�operador�“+”.�Exemplos:�
�
�
�
A�saída�do�trecho�de�código�acima�é:�
�
�
�
Para�compararmos�se�o�valor de�duas�Strings�são�iguais,�utilizamos�o�método�equals�(o�
operador�“=�=”�não�compara�Strings).�Veja�no�exemplo�a�seguir:�
�
�
�
O�trecho�de�código�a�seguir�mostra�outros�métodos�úteis�da�classe�String:�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 41
�
�
A�saída�do�trecho�de�código�acima�é:�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 42
�
�
Exercício�10���Crie�uma�String�com�seu�nome�completo�e�sobrescreva�as�ocorrências�da�
letra�‘a’�pela�letra�‘p’.�Como�ficou�seu�nome?�
�
Exercício�11���Utilize�o�método�“split”�para�separar�cada�nome�e�sobrenome�da�String�
acima.�
�
�
�
Arrays� (vetores)� em� Java� podem� conter� qualquer� tipo� de� elemento� valorado� (tipos�
primitivos�ou�objetos),�mas�você�não�pode�armazenar�diferentes�tipos�em�um�simples�
array�(por�exemplo,�você�pode�criar�um�array�de� inteiros,�ou�um�array�de�strings,�ou�
um array�de�array,�mas�você�não�pode�criar�um�array�que�contenha�ambos�os�objetos�
strings�e�inteiros).�O�trecho�de�código�abaixo�mostra�algumas�declarações�possíveis�de�
arrays:�
�
�
�
Uma�das�formas�de�criarmos�um�objeto�array�é�usando�o�operador�new,�que�cria�uma�
nova�instância�de�um�array,�por�exemplo:�
�
�
�
Neste�caso,�será�criado�um�array�de�30�inteiros�(inicializados�com�o�valor�0).�Também�é�
possível�criarmos�um�array�ao�mesmo�tempo�em�que�o�declaramos.�
�
�
�
Uma�vez�que�o�array�já�foi�devidamente�criado,�podemos�acessar�e/ou�alterar�o�valor�
dos�elementos�em�cada�um�de� seus� índices.�Os�arrays�em� Java� sempre� iniciam�com�
elementos�na�posição�0.�Por�exemplo:�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 43
�
�
A�última�linha�do�trecho�de�código�acima�causa�um�erro�de�compilação,�pois�o�índice�2�
não�existe�em�um�array�com�apenas�dois�elementos.�Arrays�podem�ter mais�de�uma�
dimensão.�Um�array�bidimensional,�por�
exemplo,� é� um� array� de� arrays.� Podemos� simular� uma� matriz� de� números,� por�
exemplo,�usando�arrays�bidimensionais.�Veja�um�exemplo�a�seguir:�
�
�
�
Para� sabermos�o� tamanho�de�um�array,�podemos�utilizar�o�atributo� �length�,�assim�
como�em�uma�String.�
A�partir�do�momento�em�que�um�array�foi�criado,�ele�não�pode�mudar�de�tamanho.�Se�
você�precisar�de�mais�espaço,�será�necessário�criar�um�novo�array�e,�antes�de�se�referir�
a�ele,�copie�os�elementos�do�array�antigo.�
Mais� adiante,� aprenderemos� técnicas� mais� eficientes� para� preencher� e� manipular�
nossos�Arrays.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 44
�
�
Exercício�12���Crie�um�novo�programa,�que�armazene�um�vetor�float�com�as�notas�de�
10�alunos,�e�imprima�a�média�dessas�notas.�
�
Exercício�13���Crie�no�mesmo�programa�acima�um�array�de�Strings�com�o�nome�dos�
meses�do�ano.�Crie�uma�variável�inteira�com�um�valor�entre�1�e�12,�e�imprima�o�nome�
do�mês�correspondente�ao�valor�da�variável�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 45
�
�
Operadores:�
Os� operadores� aritméticos� para� manipularmos� as� variáveis� em� Java� são� os�
mesmos�da�linguagem�C.�Utilizamos�“+”�para�somar�dois�valores,�“�”�para�subtrair,�“*”�
para�multiplicar,�“/”�para�dividir,�“%”�para�calcular�o�resto�da�divisão�inteira,�“++”�para�
incrementar�um�valor�e�“��”�para�decrementar.�Java�também�possui�vários�operadores�
para�testar� igualdade�e�magnitude.�Utilizamos�“=�=”�para�verificar�se�dois�valores�são�
iguais,�“!=”�para�verificar�se�são�diferentes,�“”�para�verificar�se�ele�é�maior,�“=”�para�
maior�ou�igual.�
Para�combinarmos�valores�ou�expressões� lógicas,�utilizamos�“&&”�(operação�E),�“|�|”�
(operação�OU)�e�“!”�para�negar�um�valor.�
�
Exercício�14���Crie�um�número�inteiro�de�3�dígitos.�Utilize�os�operadores�“/”�e�“%”�para�
obter�o�número�com�os�algarismos�na�ordem�inversa.�
Exemplo:�“x�=�356�e�y�=�653”�
�
Exercício�15���Crie�uma�variável�inteira�contendo�um�número�de�segundos,�e�imprima�o�
número�equivalente�de�horas,�minutos�e�segundos.�
�
Exercício�16���Avalie�o�resultado�da�expressão�a�seguir:�
((33)�&&�!(40))�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 46
�
�
Funções�matemáticas:�
Na� classe�Math,� existe� uma� série� de�métodos� estáticos� que� fazem� operações�
com�números� como,�por�exemplo,�arredondar� (round),�obter�o�valor�absoluto� (abs),�
obter�a�raiz�(sqrt),�calcular�o�seno�(sin)�e�outros.�
�
�
�
A� documentação� do� Java� apresenta� outros� métodos� que� podem� ser� úteis,� como�
números�aleatórios,�tangentes,�logaritmo,�etc.�
�
Exercício�17���Calcule�a�área�e�o�comprimento�de�uma�circunferência�de�raio�r�=�12.�
�
Exercício�18���Crie�as�variáveis�reais�a,�b�e�c�e�calcule�as�raízes�da�equação��
ax2�+�bx�+�c.�
�
Controle�de�fluxo:�
Comandos�condicionais�em�Java�são�semelhantes�aos�de�C.�O�trecho�de�código�a�
seguir,�por�exemplo,�verifica�se�uma�pessoa�é�maior�de�idade.�
�
�
Não�é�necessário�que�todo�IF�seja�acompanhado�de�um�ELSE,�mas�todo�ELSE�só�pode�
existir� após� um� IF.� Podemos� também� concatenar expressões� booleanas� com� os�
operadores�lógicos�“E”�e�“OU”.�O�primeiro�é�representado�por�“&&”,�e�o�segundo�por�
“|�|”.�No exemplo�a�seguir, o�programa�verifica�se�uma�pessoa�precisa�pagar�passagem�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 47
�
�
de�acordo�com�sua�idade�(neste�caso,�não�pagam�passagens�pessoas�de�até�2�anos�ou�a�
partir�de�60�anos):�
�
�
�
A�estrutura�SWITCH�CASE�equivale�a�um�conjunto�de�cláusulas�IF�encadeadas,�
deixando�o�código�mais�legível�e�eficiente�no�caso�de�grandes�desvios�condicionais.�
Exemplo:�
�
�
�
Você�seria�capaz�de�criar�um�trecho�de�código�que�faça�o�mesmo�que�o�exemplo�
acima,�mas�utilizando�apenas�IF�ELSE�ao�invés�de�SWITCH�CASE?�
�
�
�
�
�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�� 48
�
�
Vamos�agora�treinar�os�comandos�condicionais.�
�
Exercício�19���O�que�faz�o�trecho�de�código�a�seguir?�
�
�
�
Exercício�20���Crie�três�variáveis�reais,�defina�valores�quaisquer�para�elas,�e�defina�um�
código�que�verifique�se�elas�mesmas�podem�ser�lados�de�um�triângulo�(ou�seja,�
nenhuma�pode�ser�maior�que�a�soma�das�outras�duas).�
Exercício�21���Crie�uma�variável�contendo�a�idade de�uma�pessoa,�e�verifique�sua�
condição�eleitoral:�
•�até�16�anos�não�pode�votar;�
•�entre�16�e�18�anos�ou�mais�que�65�é�facultativo;�
•�entre�18�e�65�anos�é�obrigatório.�
Exercício�22���Crie�uma�variável�inteira�contendo�um�dia�do�ano�e�outra�contendo�um�
mês,�e�verifique�se�elas�formam�uma�data�válida�(considere�que�fevereiro�sempre�
possui�28�dias).�
Exercício� 23� �� Verifique� se� um� número� inteiro� qualquer� corresponde� a� um� ano�
bissexto.�Anos�bissextos�são�os�múltiplos�de�4�que�não�são�múltiplos�de�100,�e�ainda�os�
múltiplos�de�400.� � Exemplo:�1996�e�2000� são�bissextos,� enquanto�1998�e� 1900� são�
comuns.�
Exercício�24���Crie�dois�números�inteiros�e�imprima:�
a)�A�soma�dos�dois,�caso�ambos�sejam�ímpares;�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 49
�
�
b)�O�produto,�caso�sejam�pares;�
c)�O�número�ímpar,�caso�um�seja�par�e�outro�não.�
Exercício�25� ��Escreva�um�programa�que� verifique� se�uma�nota�é�péssima� (nota=1),�
ruim� (2),� regular� (3),�boa� (4),�ótima� (5)�ou�nenhuma�delas� (nota� inválida).�Utilizamos�
um�WHILE�para�criarmos�um�laço�(loop),�ou�seja,�repetir�um�trecho�de�código�algumas�
vezes�enquanto�uma�determinada�condição�for�verdadeira.�O�exemplo�abaixo�imprime�
os�5�primeiros�múltiplos�de�9:�
�
O�trecho�de�código�dentro�do�WHILE�será�executado�enquanto�a�condição�x�� 5.�O� comando� FOR�
também� é� utilizado� para� criarmos� loops.� A� idéia� é� a�mesma� que� a� do�WHILE,�mas�
existe�um�espaço�próprio�para� inicializar�e�modificar� a� variável�de� controle�do� laço,�
deixando�o�mais�legível.�O�exemplo�abaixo�gera�o�mesmo�resultado�do�WHILE�acima.�
�
�
O�FOR�e�o�WHILE�podem�ser�utilizados�para�o�mesmo�propósito.�Porém,�o�código�do�
FOR�indica�claramente�que�a�variável�i�serve,�em�especial,�para�controlar�a�quantidade�
de� laços�executados.�Use�cada�um quando�achar�mais�conveniente.�O� for� também�é�
muito�útil�para�percorrermos�um�array.�Para� isso,�basta�usarmos�o�atributo�“length”,�
que�retorna�o�tamanho�do�array.�Veja um�exemplo:�
�
�
Use�WHILE�ou�FOR�nos�exercícios�a�seguir:�
Exercício�26���Imprima�todos�os�números�de�100�a�300.�
Exercício�27���Imprima�a�soma�de�todos�os�números�de�1�a�999.�
Exercício�28���Crie�um�número�inteiro�e�verifique�se�ele�é�primo.�
Exercício�29���Qual�o�valor�de�n�no�final�do�código�a�seguir?�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 50
�
�
�
Exercício�30 –�Calcule�e�imprima�o�fatorial�de�um�número�inteiro�qualquer.�
Exercício�31�–�Calcule�e� imprima�o� fatorial�dos�números�de�1�a�15.�Crie�um� for�que�
comece� imprimindo�o� fatorial�de�1,�e�a�cada�passo�utilize�o�último� resultado�para�o�
cálculo�do�fatorial�seguinte.�
Exercício�32�–�Calcule�e� imprima�os�30�primeiros�elementos�da�série�de�Fibonacci.�A�
série�é�a� seguinte:�1,�1,�2,�3,�5,�8,�13,�21,�etc.�Para�calculá�la,�o�primeiro�e� segundo�
elementos� valem�1;�daí�por�diante,� cada�elemento� vale� a� soma�dos�dois� elementos�
anteriores�(ex:�8�=�5�+�3).�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 51
�
�
Escopo das variáveis: 
Em�Java,�podemos�declarar�variáveis�a�qualquer�momento.�Entretanto,�o�trecho�
de�código�em�que�a�variável�será�válida�dependerá�de�onde�ela�foi�declarada.�Escopo�
da�variável�é�o�nome�dado�ao�trecho�de�código�em�que�a�variável�existe�e�no�qual�é�
possível� acessá�la.� Quando� abrimos� um� novo� bloco� com� as� chaves,� as� variáveis�
declaradas�ali�dentro�só�existirão�até�o�fim�daquele�bloco.�
�
�
Tenha�cuidado!�Se�criar�uma�variável�dentro�de�um�bloco�e�tentar�utilizá�la�fora�desse�
bloco,�haverá�um�erro�de�compilação.�
�
Também�é�possível�declararmos�um�bloco�dentro�de�outro.�Podemos�inserir�um�IF�
dentro�de�um�laço,�um�laço�dentro�de�um�IF,�um�laço�dentro�de�outro,�e�assim�
sucessivamente.�Veja�um�exemplo�a�seguir:�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 52
�
�
Garbage�collection�
Java�não�segura�áreas�de�memória�que�não�estão�sendo�utilizadas,�porque�possui�
uma�alocação�dinâmica�de�memória�em�tempo�de�execução.�Os�objetos�que�não�são�
mais� referenciados� são� coletados� pelo�Garbage� Collector,� liberando� a�memória� que�
não�está�mais�em�uso.�Em�C�e C++�(e�em�outras�linguagens)�o�programa�desenvolvido�é�
responsável�pela�alocação�e�desalocação�da�memória.�Durante�o�ciclo�de�execução�do�
programa,�o�Java�verifica�se�as�variáveis�de�memória�estão�sendo�utilizadas;�caso�não�
estejam,�o� Java� libera� automaticamente� a� área�que�não�está� sendo�utilizada.� Isto� é�
feito�de�uma�forma�automática.��
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 53
�
�
�
���������������������������������������
����������
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 54
�
�
Meta 
�
Nesta�aula,�serão�discutidos�os�conceitos�básicos�da�
Orientação�a�Objetos,�e,�em�seguida,�como�que�estes�
conceitos�básicos�são�implementados�na�Linguagem�Java.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Compreender�os�principais�conceitos�da�Orientação�a�
Objetos�(OO)��envolvendo�classe,�objetos�e�métodos.�
� Implementar�programas�em�java�utilizando�dos�conceitos�da�
Orientação�a�Objetos.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 55
�
�
�
1���Introdução�à�Orientação�a�Objetos�
Boa� parte� de� nosso� entendimento� e� relacionamento� com� o� mundo� se� dá�
através�do�conceito�de�objetos.�Ao�observarmos�as�coisas�e�seres�que�existem�ao�nosso�
redor,�existe�uma�natural�tendência�a�tentarmos� identificar�o�que�é�cada�uma�dessas�
diferentes� entidades.� Ao� olharmos� para� uma� bola� de� basquete,� reconhecemos� sua�
forma� esférica,� seu� tamanho� usual,� colorido� típico� e� aplicação.� Mas� a� bola� que�
observamos� não� é� a� única� que� existe,� inúmeras� outras� estão� “por� aí”� e,� mesmo�
possuindo�características�idênticas,�são�objetos�diferentes.�
Como�o�próprio�nome�indica,�a�bola�é�de�basquete,�ou�seja,�para�ser�usada�no�
esporte� que� denominamos� basquete,� é� um� tipo� de� bola� específica.� Assim,� bola� de�
basquete� representa�uma�classe�de�objetos�que�apresentam�características�próprias.�
Cada� uma� das� bolas� de� basquete� existentes� é� um� objeto� desta� classe� de� objetos.�
Existem�outras�bolas�(outros�tipos)�que�não�são�de�basquete.�Bolas�especiais�para�os�
múltiplos�esportes�diferentes�e�bolas�de�recreação�são�exemplos�de�outras�classes�de�
objetos� que� compartilham� das�mesmas� características� de� uma� bola,� ou�melhor,� de�
uma�esfera.�
Pode� parecer� óbvio,�mas� a� dificuldade� inicial� do� paradigma� da�Orientação� a�
Objetos�é� justamente� saber�distinguir�o�que�é� classe�e�o�que�é�objeto.�É� comum�o�
iniciante�utilizar,�obviamente�de�forma�errada,�essas�duas�palavras�como�sinônimas.�
�
Nas�próximas� sessões�deste�e�dos�próximos� capítulos,�mostraremos� algumas�
das� principais� terminologias� utilizadas� na� POO� que� serão� utilizadas� em� todo� este�
material,�como�classes,�objetos,�herança,�métodos,�polimorfismo�e�encapsulamento.�
�
2���Classe�e�Objeto�
Uma�classe�é�um�tipo�de�objeto�que�pode�ser�definido�pelo�programador�para�
descrever� uma� entidade� real� ou� abstrata.� Podemos� entender� uma� classe� como� um�
“modelo”� ou� como� uma� “especificação”� para� certos� objetos,� ou� seja,� a� descrição�
genérica�dos�objetos�individuais�pertencentes�a�um�dado�conjunto.�A�bola�de�basquete�
pode� ser�uma�classe�que�descreve�os�objetos�bola�de�basquete.�A�definição�de�uma�
classe�envolve�a�definição�de�variáveis�às�quais�se�associam�funções�que�controlam�o�
acesso� a� esses� objetos.�Assim,� a� criação� de� uma� classe� implica� definir� um� tipo� de�
objeto�em�termos�de�seus�atributos�(variáveis�que�conterão�os�dados)�e�seus�métodos�
(funções�que�manipulam�tais�dados).�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 56
�
�
Uma� classe� representa� uma� entidade� e,� como� tal,� define� o� seu� comportamento�
(métodos)� e� as� suas� características� (propriedades).� Os� acontecimentos� que� podem�
ocorrer�para�uma�dada�entidade�em�determinada�altura�são�chamados�de�eventos.�
Classe� é� um� componente� de� programa� que� descreve� a� “estrutura”� e� o�
“comportamento”�de�um�grupo�de�objetos�semelhantes�–� isto�é,�as� informações�que�
caracterizam� o� estado� desses� objetos� e� as� ações� (ou� operações)� que� eles� podem�
realizar.�
Já�um�objeto�é�uma�instância�de�uma�classe.�Ele�é�capaz�de�armazenar�estados�através�
de� seus� atributos� e� reagir� a�mensagens� enviadas� a� ele,� assim� como� se� relacionar� e�
enviar�mensagens� a� outros� objetos.� João,� José� e�Maria,� por� exemplo,� podem� ser�
exemplos�de�objetos�da�classe�Pessoa,�descrita�acima.�
Objeto� é� a� criação� de� uma� instância� da� classe.� Quando� instanciamos� um� objeto,�
criamos�fisicamente�uma�representação�concreta�de�sua�classe.�“Ser�Humano”�é�uma�
classe,�um�molde,�já�“Roberto”�é�uma�instância�de�“Ser�Humano”.�Apesar�de�carregar�
todas� as� características� do� molde� “Ser� Humano”,� ele� é� completamente� diferente�
(independente)�das�outras�instâncias�de�“Ser�Humano”.�
Um�outro�exemplo:�uma�receita�de�bolo.�Você�come�uma�receita�de�bolo?�A�resposta�é�
“Não”.�Precisamos� instanciá�la,� criar�um�objeto�bolo� a�partir�dessa� especificação� (a�
classe)�para�utilizá�la.�Podemos�criar�centenas�de�bolos�a�partir�dessa�classe�(a�receita,�
no� caso)�e�eles�podem� ser�bem� semelhantes,�alguns�até� idênticos,�mas� são�objetos�
diferentes.�
Podemos� fazer� várias� analogias� semelhantes.� A� planta� de� uma� casa� é� uma� casa?�
Definitivamente� não.� Não� podemos� morar� dentro� da� planta� de� uma� casa,� nem�
podemos� abrir� sua� porta� ou� pintar� suas� paredes.� Precisamos,� antes,� construir�
instâncias� a� partir� dessa� planta.� Essas� instâncias,� sim,� podemos� pintar,� decorar� ou�
morar�dentro�delas.�
�
�
�
�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 57
�
�
3���Classes�e�Objetos�em�Java�
Para�exemplificar�a�implementação�de�classes�em�Java,�vamos�criar�uma�classe�
que� armazena� os� dados� da� conta� de� um� usuário� no� banco.� Por� enquanto,� vamos�
escrever�apenas�o�que�a�conta�possui�(atributos),�e�não�o�que�ela�faz�(métodos).�
�
�
�
Esses� são�os�atributos�que� toda�conta,�quando�criada,� irá�possuir.�Repare�que�essas�
variáveis�foram�declaradas�fora�de�um�bloco,�diferente�do�que�fizemos�na�classe�que�
possuía�um�método�main.�Quando�uma�variável�é�declarada�diretamente�dentro�do�
escopo�da� classe,�ela�é�chamada�de�variável�de�objeto,�ou�atributo.�O�diagrama�da�
Figura�23���mostra�o�que�temos�em�nossa�classe�até�agora:�
�
�
Figura�23���Atributos�da�classe Conta�
�
A� classe�Conta� especifica�o�que� todos�os�objetos�dessa� classe�devem� conter.�Neste�
caso,� ela� não� possuirá� um� método� chamado� main� porque� ela� não� será� a� classe�
principal�do�nosso�programa.�Para�isso,�criaremos�uma�classe�Programa,�que�criará�um�
objeto�da�classe�Conta.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 58
�
�
�
�
�
�
�
Preste� atenção� no� ponto� que� foi� utilizado� em� “minhaConta.nome”� e�
“minhaConta.saldo”.�É� assim�que�acessamos�uma� variável�de�objeto.�Agora,� sempre�
que�o�programa�for� iniciado,�a�conta�pertencerá�ao�usuário�“Hilário”�e�seu�saldo�será�
de�mil�reais.�
�
A� criação� de� um� objeto� a� partir� de� uma� classe� é� chamada� de� processo� de�
instanciação.�Para�realizar�a�instanciação�de�um�objeto�qualquer,�é�usado�o�operador�
new� (FURGERI,� 2005).� Se� quiséssemos� criar�mais� de� uma� conta,� bastaria� criarmos�
vários�objetos�da�classe�conta�com�o�operador�new,�dando�um�nome�diferente�para�
cada�conta.�Cada�uma�delas�teria um�valor�independente�para�seus�atributos.�
�
�
�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 59
�
�
Ao�salvarmos�o�código�correspondente�a�uma�classe�em�um�arquivo,�devemos�tomar�
os�seguintes�cuidados:�
�
1. Em�um�único�arquivo�Java�podem�existir�várias diferentes�definições�de�classes,�
mas�apenas�uma��delas�pode�ser�pública.�
�
2. �O� nome� do� arquivo� deve� ser� o� nome� da� classe� pública,� observando�se�
cuidadosamente�o�uso�do�mesmo�caixa�(maiúsculas�e�minúsculas)�tanto�para�o�
nome�da�classe�como�para�o�nome�do�arquivo.�
�
No�nosso�caso,�o�programa�deve�se�chamar�“Programa.java”.�
�
Exercício�33� �� Implemente�a�classe�Pessoa,�contendo�os�atributos�“nome”,�“altura”�e�
“peso”,�pelo�menos.�Crie�alguns�objetos�dessa�classe�e�defina�valores�diferentes�para�
os�atributos�de�cada�um�deles.�
�
Exercício� 34� ��Crie� 10� objetos�da� classe�Pessoa� e� insira�os� em�um� array�de�objetos�
dessa�classe.�Utilize�um�for�para�imprimir�todos�os�atributos�dos�objetos�do�array.�
�
Exercício� 35� �� Crie� uma� classe� para� um� “Funcionário”.� Ela� deve� ter� o� nome� do�
funcionário,�o�departamento�onde�trabalha,�seu�salário�(double),�a�data�de�entrada�no�
banco�(String),�seu�RG�(String)�e�um�valor�booleano�que�indique�se�o�funcionário�está�
na�empresa�no�momento�ou�se�já�foi�embora.�
�
Exercício� 36� �� Crie� uma� classe� Empresa� que� possua� “nome”,� “cnpj”,�
“qtde_de_funcionario”� e� um� array� de� objetos� da� classe� Funcionario� (o� array� pode�
armazenar�até�100�funcionários).�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 60
�
�
4���Métodos�
Dentro�da�classe,�também�declaramos�o�que�cada�conta�faz�e�como�isso�é�feito�
(os�comportamentos�que�cada�classe�tem,�isto�é,�o�que�ela�faz).�As�operações�que�um�
objeto� oferece� são� chamadas� de�métodos.� Andar,� Correr� e� Comer,� por� exemplo,�
podem�ser�métodos�da�classe�Pessoa.�Métodos�são�comportamentos�que�os�objetos�
de� uma� classe� podem� possuir.� A� operação� de� ligar� um� objeto� da� classe�Moto,� por�
exemplo,�pode�ser�feita�com�o�método�ligar(�).�
Por� exemplo,� de� que�maneira� uma� quantia� em� dinheiro� é� sacada� de� uma� conta?�
Especificaremos� isso�dentro�da�própria� classe�Conta.�É�por� isso�que�essas� “funções”�
são� chamadas� de�métodos:� pois� esta� é� a�maneira� (o�método)� de� fazermos� alguma�
operação� com� um� objeto.� No� código� a� seguir,� adaptaremos� a� classe� Conta� criada�
anteriormente�para�incluir�o�método�“sacar”.�
�
�
�
O�método�“sacar”�recebe�como�argumento�(ou�parâmetro)�um�valor�do�tipo�“double”�
contendo� a� quantidade� de� dinheiro� a� ser� sacada� da� conta� do� usuário.� Sem� o�
argumento,�é�impossível�sabermos�o�quanto�devemos�subtrair�do�saldo�da�conta.�Essa�
variável�chamada�“quantidade”�pode�ser�acessada�durante�todo�o�método�e�deixa�de�
existir�ao� final�do�método.�A�palavra�“void”� indica�que�nenhum�valor�será� retornado�
por�esse�método.�
�
A� palavra� “this”� (que� já� estava� presente� no� código� da� interface� que� criamos� no�
primeiro�capítulo)�permite�que�acessemos�o�valor�de�um�atributo�da�própria�classe�em�
questão,�no�nosso�caso�a�classe�Conta.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 61
�
�
A�palavra�reservada�this�é�muito�importante�e�útil.�Ela�referencia�a�própria�instância�de�
dentro�de�sua�classe.�Cuidado,�this�não�pode�ser�usada�em�métodos�estáticos, como�
veremos�mais�adiante.Agora�criaremos�um�método�parecido�com�o�anterior,�mas�para�
depositar�dinheiro na�conta.�
�
�
�
O�“+=”�soma�o�valor�de�“quantidade”�ao�valor�antigo�do�“saldo”�e�guarda�o�resultado�
no�próprio� “saldo”.�Para� fazer� com�que�um�objeto�execute�algum�método,� também�
colocamos�um�“ponto”.�
�
�
Figura�24���Atributos�e�métodos�da�classe�Conta�
�
�
A�Figura�24���mostra�o�diagrama�da�classe�Conta�com�os�métodos criados�acima:�
�
No�código�a�seguir,�alteramos�a�classe�“Programa”�para�sacarmos�dinheiro�da�conta�e�depois�depositarmos.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 62
�
�
�
�
Exercício� 37� �� Crie� os� seguintes� métodos� para� a� classe� Funcionario,� criada�
anteriormente:�
a)� Método� “bonificar”,� que� aumenta� o� salário� do� funcionário� de� acordo� com� o�
parâmetro�passado�como�argumento.�
b)� Método� “demitir”,� que� não� recebe� parâmetro� algum,� apenas� modifica� o� valor�
booleano�indicando�que�o�funcionário�não�trabalha�mais�na�empresa.�
c)�Método� “mostrarDados”,� que� simplesmente� imprime� todos� os� atributos� de� um�
funcionário.�
Exercício� 38� �� Crie� dois� objetos� da� classe� Funcionario� com� os� mesmos� atributos.�
Compare�os�dois�com�o�operador�“=�=”�e�veja�se�o�resultado�é�true�ou�false.�
Exercício� 39� �� Insira� na� classe� Pessoa,� também� criada� anteriormente,� o� atributo�
“idade”�e�o�método�“aniversario”,�que� incrementa�sua�“idade”.�Crie�um�objeto�desta�
classe,� defina� a� “idade”,� chame� o� método� “aniversario”� algumas� vezes� e� depois�
imprima�novamente�a�“idade”.�
Dicas:�
1.� Vá� compilando� seus� arquivos� à� medida� que� for� incluindo� classes,� variáveis� e�
métodos.�Se�criar�um�programa�grande�e�compilá�lo�todo�de�uma�vez,�pode�ficar�mais�
difícil�encontrar�os�vários�erros�de�
digitação�que�podem�aparecer.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 63
�
�
2.� Por� enquanto,� você� pode� colocar� várias� classes� em� um� mesmo� arquivo.� Mais�
adiante,� veremos� que� em� alguns� casos� é� importante� escrever� algumas� classes� em�
arquivos�separados.�Não�se�preocupe�com�isso�neste�momento!�
Em� todo�método� devemos� especificar� o� tipo� de� seu� retorno.�Nos� casos� anteriores,�
utilizamos�a�palavra�“void”,�que�significa�que�não�há�um�valor�de�retorno�do�método.�
Quando�um�método�possui�um�valor�de�retorno,�esse�valor�é�devolvido�para�o�código�
que�o�chamou.�O�método�“sacar”,�por�exemplo,�poderia�retornar�um�valor�booleano�
indicando� se� a� operação� foi� bem� sucedida� (o� que� acontece� se� a� quantidade� a� ser�
sacada�não�for�maior�que�o�valor�do�saldo�mais�o�limite�da�conta).�Veja�no�exemplo�a�
seguir:�
�
�
�
Note�que� agora� a�declaração�do�método�mudou.�O� retorno�do�método�não� é�mais�
“void”,�e�sim�“boolean”.�A�palavra�“return”�indica�que�o�método�será�retornado�ali,�e�o�
valor�ao� lado�dela�é�que�será�devolvido�como�retorno.�Abaixo�temos�um�exemplo�de�
como�utilizar�o�valor�de�retorno�da�nova�função�“sacar”.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 64
�
�
�
Para�simplificar�o�código,�podemos�obter�o�mesmo�resultado�da�seguinte�forma:�
�
�
�
Por� fim,� um�método� também� pode� ser� criado� com� estático.� Para� isso,� basta�
adicionarmos�a�palavra�static�à�declaração�do�método.�Um�método�estático�não�nos�
obriga� a� instanciarmos� um� objeto� de� sua� classe� para� que� tenhamos� acesso� a� seus�
serviços:�ele�serve�apenas�para�que�possamos�aproveitá�lo�em�pequenas�computações.�
Os� métodos� estáticos� foram� criados� para� resolver� situações� especiais� na�
orientação�a�objetos,�e�também�para�simplificar�certas�operações.�Imagine�que�exista�
uma� classe� chamada� CPF,� criada� por� outro� programador,� que� tenha� apenas� um�
método�chamado�validaCPF�que�verifica�se�um�CPF�é�válido�ou�não.�Segundo�a�lógica�
da� orientação� a� objetos,� precisaríamos� instanciar� um� objeto� desse� tipo� para�
utilizarmos�seu�método�para�a�verificação�do�CPF.� Isso�é�um�tanto�quanto� incômodo,�
pois�o�que�necessitamos,�neste�caso,�é�simplesmente�de�uma�funcionalidade,�e�não�de�
um� objeto.� Da� mesma� maneira,� existem� dezenas� de� funções� matemáticas,� físicas,�
estatísticas�que�precisamos�utilizar�sem�a�necessidade�de�instanciarmos�um�objeto.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 65
�
�
O�que�queremos�é�apenas�enviar�os�parâmetros�e�receber�resultados,�como�se�esses�
métodos�fossem�funções.�Assim,�para�verificarmos�se�um�CPF�é�válido,�precisaríamos�
apenas�da�seguinte�instrução:�
�
�
�
Veja�que�o�método�“validaCPF”�pode� ser�utilizado�mesmo�que�não� tenhamos�criado�
uma�instância�da�classe�CPF.�Mas�para�que�um�método�possa�ser�criado�como�estático,�
ele� só� pode� usar� as� variáveis� da� classe� que� forem� estáticas� (além� das� variáveis�
recebidas� como�parâmetro�pelo�método). Uma�variável�estática,�declarada�em�uma�
determinada�classe,�é�compartilhada�por�todos�os�objetos�dessa�classe�e�é�criada�uma�
única�vez�durante�a�execução�do�programa.�Uma�variável�de�objeto,�ao�contrário,�é�
criada� a� cada� vez� que� um� novo� objeto� dessa� classe� é� criado.�Uma� variável� estática�
também�é�definida�através�da�palavra�static.�
�
�
A�partir�da�próxima�aula,�mostraremos�como�incluir�estes�novos�conceitos�na�interface�criada�
nas�aulas�01�e�02.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 66
�
�
�
��������������������������������
��������������
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 67
�
�
Meta 
�
Consolidar�os�conhecimentos�referentes�a�Orientação�a�
Objetos,�além�de�introduzir�os�conceitos�referentes��a�
métodos�e�encapsulamento�em�Java.
Objetivos 
�
Ao�final�desta�aula,�você�deverá�ser�capaz�de:�
� Utilizar�os�conceitos�no�dia�a�dia�do�desenvolvimento�de�
sistemas�em�Java.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 68
�
�
�
�
1�� Orientação�a�Objetos:�Métodos�e�Encapsulamento�
�
Vamos� relembrar�alguns� conceitos� importantes�da�programação�orientada�a�objetos�
aprendidos�no�capítulo�anterior:�
�
•�Classe:�É�um�tipo�de�objeto�que�pode�ser�definido�pelo�programador�para�descrever�
uma�entidade�real�ou�abstrata.�
�
•�Objeto:� É�uma� instância�de�uma� classe.�Por�exemplo,� vamos� imaginar�uma� classe�
chamada�Moto.� Cada�moto� existente� é� uma� instância� (ou� um� objeto)� dessa� classe.�
Apesar�de�parecidas,�cada�moto�possui�
características�próprias,�como�cor,�chassi,�arranhões,�etc.�
�
• Métodos são comportamentos que os objetos de uma classe podem possuir. Eles
definem�as�operações�que�podemos�realizar�com�os�objetos�de�uma�classe.�
�
�
Construtores:�
Quando� usamos� a� palavra� “new”,� como� fizemos� no� código� da� classe� “Programa”,�
estamos�construindo�um�novo�objeto.�Sempre�que�isso�é�feito,�o�construtor�da�classe�é�
executado.�O�construtor�da�classe�é�um�bloco�declarado�com�o�mesmo�nome�que�a�
classe.�Veja�um�exemplo�no�código�a�seguir:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 69
�
�
�
�
No�caso�do�exemplo�acima,�sempre�que�um�novo�objeto�da�classe�Conta�for�criado,�a�
mensagem�“Nova�conta�criada”�aparecerá�na�tela.�É�como�uma�rotina�de�inicialização�
que� é� chamada� sempre� que� um� novo� objeto� é� criado.� Apesar� de� parecer,� um�
construtor� não� é� um�método.� Até� agora,� as� nossas� classes� não� possuíam� nenhum�
construtor.� Então,� o� que� acontecia,� se� o� construtor� da� classe� é� sempre� executado�
quando�um�novo�objeto�é�criado?�Quando�você�não�declara�algum�construtor�na�sua�
classe,� o� Java� cria� um� para� você.� Esse� construtor� é� o� construtor� padrão,� que� não�
recebe�nenhum�argumento�e�cujo�corpo�é�vazio.�A�partir�do�momento�em�que�você�
declara�um�construtor,�o�construtor�padrão�não�existe�mais.�
O�interessante�é�que�o�construtor�pode�receber�parâmetros,�assim�como�um�método.�
Para�aprimorar�o�construtor�da�classe�Conta,�por�exemplo,�poderíamos�receber�o�valor�
do�“nome”�do�titular�da�conta�como�parâmetro.�
Veja�no�trecho�de�código�a�seguir:�
�
�
�
Agora�não�precisamos�mais�atribuir�os�valores�a�esses�parâmetros�após�instanciarmos�
o� objeto� “minhaConta”� da� classe� “Programa”.� Ao� invés� disso,� passamos� os� valores�
como�parâmetro�para�o�construtor�da�classe�Conta�ao�criarmos�o�objeto.�Veja�a�nova�
classe�“Programa”�no�código�a�seguir:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 70
�
�
�
�
Se�tudo�estava�funcionando�até�agora,�para�que�utilizamos�um�construtor?�
A�idéia�é�bem�simples:�se�toda�conta�precisa�de�um�usuário�titular,�como�obrigar�todos�os�objetos�que�forem�criados�a�ter�um�valor�desse�tipo?�Basta�criar�um�construtor�que�
recebe�essa�String!�
O�construtor�se�resume�a�isso:�dar�possibilidades�ou�obrigar�o�usuário�de�uma�classe�a�
passar�argumentos�para�o�objeto�durante�o�processo�de�criação�do�mesmo.�
Por�exemplo,�não�podemos�abrir�um�arquivo�para� leitura�sem�dizer�qual�é�o�nome�do�
arquivo� que� desejamos� ler!� Portanto,� nada� mais� natural� que� passar� uma� String�
representando�o�nome�de�um�arquivo�
na�hora�de�criar�um�objeto�do�tipo�de�leitura�de�arquivo,�e�que�isso�seja�obrigatório.�
Além�disso, se�criamos�um�construtor�com�vários�parâmetros,�o�usuário�não�precisará�
criar� várias� sentenças� ao� longo� do� programa� para� atribuir� os� valores� de� cada� um�
desses�parâmetros.�
�
Também�é�possível�que�criemos�mais�de�um�construtor�em�uma�mesma�classe,�cada�
um�com�um�número�diferente�de�parâmetros.�Quando�o�objeto�for�criado,�o�
construtor�apropriado�será�escolhido.�Veja�o�exemplo:�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 71
�
�
�
�
A� seguir,� temos� o� exemplo� de� um� trecho� de� código� que� cria� dois� objetos� à� classe�
Conta.�O�primeiro�passa�uma�String�e�um�float�como�parâmetros�na�criação�do�objeto,�
utilizando�o� segundo�método� construtor�definido�na� classe� acima.�O� segundo�passa�
apenas�uma�String�como�parâmetro,�utilizando�o�primeiro�método�construtor�definido�
na�classe:�
�
�
�
A�saída�do�trecho�de�código�acima�é:�
�
�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 72
�
�
Exercício�41���Crie�um�construtor�para�a�classe�Empresa,�que�recebe�como�parâmetros�
um� “nome”� e� um� “cnpj”� e� o� tamanho� do� array� de� funcionários.� O� atributo�
“qtde_de_funcionario”�deve� começar� com�o�valor� zero.�Crie� também�um� construtor�
para� a� classe� Empresa� que� não� receba� o� tamanho� do� array� de� funcionários.�Neste�
caso,�defina�que�o�padrão�é�criá�lo�com�tamanho�100.�
�
Exercício�42� ��Crie�um� construtor�para�a� classe�Funcionario�que� receba�os�atributos�
“nome”,� “departamento”,� “salario”� e RG.� No� atributo� booleano,� considere� que� o�
funcionário�está�empregado.�
Crie�também�um�construtor�para�a�classe�Funcionario�que�receba�apenas�nome�e�RG,�e�
outro�que�não�receba�parâmetros.�
�
Exercício�43� ��Crie�um�objeto�da� classe�Empresa.�Em� seguida,� crie� vários�objetos�da�
classe� Funcionario� e� inclua�os� na� Empresa. Demita� alguns� e� depois� imprima� a�
quantidade�de�funcionários�da�empresa�utilizando�o�método�“numeroDeFuncionarios”.�
�
Os� destrutores� são� chamados� logo� antes� do� “coletor� de� lixo”� (garbage� collector,�
descrito�no�capítulo�anterior)�passar�e�sua�memória�ser�liberada.�O�método�destrutor�é�
chamado�de�“finalize()”.�Cada�objeto�possui�um�método�destrutor�padrão,�que�não�faz�
nada.� Para� criar� um�método� destrutor� para� suas� próprias� classes,� basta� sobrepor� o�
método�“finalize()”�com�o�seguinte�cabeçalho:�
�
�
�
Utilizando�corretamente�o�método,�devolvemos�corretamente�ao�sistema�o�espaço�de�
memória� que� sabemos� que� não� será� mais� utilizado.� Caso� o� destrutor� não� seja�
explicitamente�chamado,�o�gerenciador�automático�
do�Java�irá�destruir�os�objetos�perdidos�apenas�quando�o�programa�estiver�ocioso�(por�
exemplo,�esperando�uma�por�uma�entrada�de�dados).�
Para� forçar� a� coleta� de� lixo� em� determinado� momento,� basta� chamar� o� método�
“System.gc()”.�
�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 73
�
�
Encapsulamento:�
Em�Java,�existem�atributos�que�modificam�o�nível�de�acesso�às�variáveis�definidas�em�
uma�classe,�aos�métodos,�aos�construtores�e�às�próprias�classes.�São�eles:�protected,�
private�e�public.�
�
� Public�indica�que�uma�classe,�variável,�método�ou�construtor�podem�ser�usados�
externamente�ao�pacote�em�que� foram�definidos.�Sem�ele,�o�uso�só�pode�ser�
feito�internamente�ao�pacote�no�qual�ocorre�a�definição.�
�
� Private� indica�que�uma� variável,�método�ou� construtor� só�pode� ser�utilizado�
internamente�à�classe�em�que�foi�declarado.�
�
� Protected�indica�que�o�uso�só�pode�ser�feito�na�classe�ou�em�uma�subclasse.�
�
�
�
Esses� modificadores� permitem� a� implementação� do� encapsulamento� no� Java.� O�
encapsulamento� faz� com� que� não� seja� permitido� acessarmos� diretamente� as�
propriedades� de� um� objeto.� Neste� caso,� precisamos� operar� sempre� por�meio� dos�
métodos� pertencentes� a� ele.� A� complexidade� de� um� objeto� é� escondida,� portanto,�
através�da�abstração�de�dados�que�estão�“por�trás”�de�suas�operações.�
�
ENCAPSULAMENTO�consiste�na�separação�entre�os�aspectos�externos�de�um�objeto,�
acessíveis�por�outros�objetos.�
�
Não�entendeu?�
É�simples:�Você�não�precisa,�por�exemplo,�conhecer�os�detalhes�dos�circuitos� internos�
do�seu�computador�para�utilizá�lo.�A�carcaça�do�computador�encapsula�esses�detalhes,�
provendo�a�você�uma�interface�
mais�amigável�(monitor,�teclado,�mouse�etc)�para�utilizá�lo.�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 74
�
�
�
Um� problema� da� classe� Conta� criada� no� capítulo� anterior� é� que� não� há� qualquer�
impedimento�com�relação�a�um�saque�que�deixe�a�conta�com�saldo�menor�que�o�limite�
permitido.�Na�verdade,�o�método�“sacar”�já�foi�alterado�de�forma�que�essa�verificação�
seja� feita.� Entretanto,� nada� garante� que� o� usuário� da� classe� Conta� irá� utilizar� esse�
método�sempre�que�precisar�o�valor�do�atributo�“saldo”.�O�código�a�seguir�ultrapassa�
o�limite�diretamente:�
�
A�melhor� forma� de� impedir� que� isso� aconteça� é� forçar� que� o� desenvolvedor� seja�
sempre�obrigado,�por�exemplo,�a�utilizar�o�método� “sacar”.�Para� fazer� isso�no� Java,�
basta�declararmos�que�os�atributos�não�podem�ser�acessados�fora�da�classe,�utilizando�
o�modificador�de�acesso�private,�da�seguinte�forma:�
�
�
�
�
Dessa�forma,�o�exemplo�anterior�(que�acessa�diretamente�o�valor�do�atributo�“saldo”)�
não�iria�compilar.�Cada�classe�é�responsável�por�controlar�seus�atributos,�portanto�ela�
deve� julgar� se� aquele� novo� valor� é� válido� ou� não.� Essa� validação� não� deve� ser�
controlada�por�quem�está�utilizando�a�classe,�e�sim�por�ela�mesma�(centralizando�essa�
responsabilidade�e�facilitando�futuras�mudanças�no�sistema).�
Repare�que,�agora,�quem�chama�o�método�“sacar”�não�faz�a�menor�idéia�de�que�existe�
um limite�que�está�sendo�checado.�Para�quem�for�usar�essa�classe,�basta�saber�o�que�o�
método�faz�e�não�exatamente�como�ele�o�faz�(“o�que”�um�método�faz�é�sempre�mais�
importante� do� que� “como”� ele� faz:� mudar� a� implementação� é� fácil,� já� mudar� a�
assinatura�de�um�método�vai�gerar�problemas).�
�
Centro�Federal�de�Educação�Tecnológica�de�Minas�Gerais�
� 75
�
�
A�palavra�chave�private�também�pode�ser�usada�para�modificar�o�acesso�a�um�método.�
Tal�funcionalidade�é�normalmente�utilizada�quando�existe�um�método�apenas�auxiliar�
para�a�própria�classe�e�não�queremos�que�outras�pessoas�o�utilizem�(ou�apenas�para�
seguir�a�boa�prática�de�se�expor�ao�mínimo).�Sempre�devemos�expor�o�mínimo�possível�
de�funcionalidades,�para�criar�um�baixo�acoplamento�entre�as�nossas�classes.�
O�que�vimos�acima�é�a�idéia�de�encapsular,�isto�é,�esconder�todos�os�membros�de�uma�
classe,�além�de�esconder�como� funcionam�as� rotinas� (métodos)�do�nosso�programa.�
Encapsular� é� fundamental� para� que� seu� sistema� seja� suscetível� a� mudanças:� não�
precisaremos�mudar�uma�regra�de�negócio�em�vários�lugares,�mas�sim�em�apenas um�
único�lugar,�já�que�essa�regra�está�encapsulada�(veja�o�caso�do�método�“sacar”).�
Quando�você�dirige�um�carro,�o�que�importa�são�os�pedais�e�o�volante,�e�não�o�motor�
que� você� está� usando.� É� claro� que� um� motor� diferente� pode� lhe� dar� melhores�
resultados,�mas� o� que� ele� faz� é� a�mesma� coisa� que� um�motor�menos� potente,� a�
diferença�está�em�como�ele�faz.�Para�trocar�um�carro�a�álcool�por�um�a�gasolina�você�
não�precisa�reaprender�a�dirigir!�
Todos�os�celulares�fazem�a�mesma�coisa:�eles�possuem�maneiras�(métodos)�de�discar,�

Mais conteúdos dessa disciplina