Linguagem de Programação - Aulas

Prévia do material em texto

LINGUAGEM DE PROGRAMAÇÃO
AULA 1: 
INTRODUÇÃO À LINGUAGEM DE 
PROGRAMAÇÃO JAVA
Nesta aula, você irá:
1.Identificar a importância das 
linguagens de programação;
2.Identificar as características 
da linguagem de programação java;
3.Conhecer os tipos de programas java;
4.Identificar os requisitos necessários para 
se programar;
5.Construir um ambiente de programação 
para a linguagem java;
6.Desenvolver pequenos programas com 
estruturas básicas.
Introdução Às L inguagens De 
Programação
Linguagem de Programação: 
Con jun to de reg ras s i n tá t i cas e 
semânticas, utilizados para se estabelecer 
comunicação entre o programador e o 
computador.
São usadas para se escrever programas 
ou softwares.
Métodos de implementação de 
Linguagens de Programação:
É a forma como uma linguagem de 
programação se comunica (é entendida e 
executada) com o computador.
O computador possui uma linguagem de 
máquina de nível baixo que oferece 
operações primitivas.
O software de sistema deve criar uma 
interface com os programas de nível mais 
alto.
O s i s t e m a o p e r a c i o n a l e a s 
implementações de linguagens são 
dispostos em camadas sobre a interface 
de l inguagem de máquina de um 
computador.
Introdução ao Java
✓ Linguagem de programação orientada 
a objetos desenvolvida por um time de 
programadores, liderados por Patrick 
Naughton, Mike Sheridan e James 
G o s l i n g , n a e m p r e s a S u n 
Microsystems.
✓ Linguagem de Alto desempenho, 
suporta multithreading, compilação 
just-in-time e utilização de código 
nativo.
✓ É uma linguagem que é compilada 
p a r a u m “ b y t e c o d e ” , q u e é 
interpretada por uma máquina virtual 
– JVM.
Principais características:
PORTABILIDADE
O Java pode ser executado em 
qualquer plataforma ou equipamento 
que possua um interpretador Java e 
que tenha s ido espec ia lmente 
compilado para o sistema a ser 
utilizado.
ORIENTADA A OBJETOS
Contém a sintaxe similar a linguagem 
C/C++, mas é baseada no modelo 
Simula67
SEGURANÇA
Pode ser executado via rede, com 
restrições de execução, além de 
proteger o sistema do cliente contra 
possíveis ataques não intencionais.
Por que estudar Java?
•Orientação a Objetos: totalmente 00 
- permitindo herança e reutilização de 
código de forma dinâmica e estática.
•Dinamismo: permite ser aumentado 
durante a execução.
•Facilidade: Derivada do C/C++ - Bem 
fami l i a r. O ambiente re t i ra do 
programador a responsabilidade de 
gerenciar a memória e os ponteiros.
Utilizações E Aplicações Do Java:
✴Desenvolvimento de apl icat ivos 
corporativos de grande porte
✴Desenvolvimento de aplicativos WEB
✴Fornecimento de aplicativos para 
dispositivos voltados para consumo 
popular (celulares, pagers, PDAs, etc.)
✴Muitos outros propósitos
Funcionamento De Um Programa 
Java
EDITOR
É a escrita ou desenvolvimento do 
programa – código fonte. Faz-se 
necessário um editor de texto simples 
como o bloco de notas do Windows ou o 
vi do Linux.
E x i s t e m o s a m b i e n t e s d e 
desenvolvimento integrado (IDE – 
Integrated Development Enviroment) que 
fornecem muitas ferramentas de suporte 
ao processo de desenvolvimento de 
software em Java e outras linguagens.
- NetBeans
- Eclipse
- JCreator
- BlueJ
COMPILADOR
O compilador Java converte o código-
f o n t e J a v a e m b y t e c o d e s , q u e 
representam as tare fas a serem 
realizadas durante a fase de execução. Os 
bytecodes são executados pela Java 
Virtual Machine (JVM) – uma parte do 
JDK e a base da plataforma Java. A 
maquina virtual Java (VM – virtual 
machine) é um aplicativo de software que 
simula um computador, mas oculta o 
sistema operacional e o hardware 
subjacentes dos programa que interagem 
com a VM.
CARREGADOR
Todo programa deve ser colocado na 
memória antes de poder executar. O 
carregador de classe transfere os 
arquivos .class contendo os bytecodes do 
programa para a memória principal. O 
carregador de classe também carrega 
qualquer arquivo .class fornecido pelo 
Java que seu programa utiliza. Os 
arquivos .class podem ser carregados a 
partir de um disco em seu sistema ou em 
uma rede.
VERIFICADOR
Enquanto as classes são carregadas, o 
verificador de bytecode examina os 
códigos para assegurar que eles são 
válidos e não violam restrições de 
segurança do Java. O Java impõe uma 
forte segurança para certificar-se de que 
os programas Java que chegam pela rede 
não danifiquem os arquivos de sistema.
INTERPRETADOR
Execução
A JVM executa o programa interpretando 
o by t e codes ge rado na f a s e de 
compilação. Com isso, sequências de 
ações especificadas pelo programado são, 
enfim, executadas.
Atualmente, as JVM uti l izam uma 
combinação de interpretação e de 
compilação just-in-time (JIT). Nesse 
processo, a JVM analisa os bytecodes à 
medida que eles são interpretados. 
Procurando hot spots (pontos ativos) – 
parte dos bytecodes, que são executadas 
com frequência. Para essas partes, um 
comp i l ado r J IT, conhec i do como 
compilador Java HotSpot, traduz os 
bytecodes para a linguagem de máquina 
do computador subjacente.
Ambiente De Programação Em Java
O ambiente de desenvolvimento de 
software Java, Java SDK (antigamente, 
JDK), é formado, essencialmente, por um 
conjunto de aplicativos que permite, 
entre outras tarefas, realizar a compilação 
e a execução de programas escritos na 
linguagem Java. Este ambiente pode ser 
baixado gratuitamente a partir do site da 
Sun Microsystems http://java.sun.com. 
As ferramentas básicas do kit de 
desenvolvimento Java são:
•O compilador JAVA. javac
•O interpretador de aplicações Java 
(máquina virtual),java.
•O interpretador de applet Java, 
appletviewer.
E N T E N D E N D O A S S I G L A S D O 
AMBIENTE JAVA:
J2SE
Java2 Standard Edi t ion – 
Fornece as principais APIs e enfoca 
o desenvolvimento de aplicações na 
arquitetura Cliente – Servidor. Não 
permite distribuição de objetos 
nem oferece suporte a tecnologias 
para Internet.
J2EE
Java2 Enterprise Edition – 
Fornece um conjunto de APIs para 
o desenvolvimento corporativo e 
en foca na i n teg ração en t re 
s i s temas . D i spon ib i l i za a l ta 
distribuição de objetos e oferece 
total suporte a tecnologias para 
Internet.
J2ME
Java2 Micro Edition – Fornece as 
APIs para o desenvolvimento de 
aplicações para computação móvel, 
em pequenos dispositivos ou 
tecnologias embarcadas.
Tipos De Programas Java
Stand - alone – Aplicações baseadas na 
J2SE que tem total acesso aos recursos 
do sistema, memória, disco, rede, 
dispositivos, etc.
Java applets - Pequenas aplicações que 
não têm acesso aos recursos de 
hardware, necessitando de um navegador 
com supor te a J2SE para serem 
executados.
Java servlets - Programas desenvolvidos 
para serem executados em servidores 
Web, baseados na J2EE, comumente 
usados para gerar conteúdos dinâmicos 
para websites.
Java midlets - Pequenas aplicações, 
extremamente seguras e construídas para 
serem executadas dentro do J2ME.
JavaBeans - São componentes de 
software escritos em Java que podem ser 
manipulados visualmente com a ajuda de 
uma ferramenta de desenvolvimento.
Construindo Um Ambiente Para 
Programação Em Java
Para desenvolver programas em Java, 
p r e c i s a m o s o b t e r o K i t d e 
Desenvolvimento Java, que é gratuito e 
disponível para download no seguinte 
endereço:
http://java.sun.com/javase/downloads/
index.jsp
Neste link, a Sun disponibiliza uma série 
de kit’s para cada perfil. Sugerimos o JDK 
– JRE.
É necessário, ainda, que o usuário 
escolha a plataforma (o computador e 
sistema operacional) onde o kit será 
instalado.
Para instalar, clique no arquivo baixado e 
siga as instruções do site para efetuara 
correta instalação.
Escrevendo E Executando O Primeiro 
Programa
1 . Abra o bloco de notas e digite o código
public class PrimeiroPrograma{
 public static void main(String args[]){
 System.out.println(“Bem vindo ao 
Mundo Java”);
 }
}
2 . Em Java, uma classe pública deve ser 
salva em um arquivo com o mesmo 
nome, com a extensão .java. Como nossa 
classe se chama PrimeiroPrograma, 
devemos salvar este arquivo como 
PrimeiroPrograma.java. Muita atenção 
com a caixa da letra, pois o Java faz 
diferença entre letras maiúsculas e 
minúsculas.
3. Abra o prompt do DOS. Para compilar o 
código, iremos usar uma ferramenta SDK, 
o compilador javac. Isso faz com que o 
bytecode seja gerado. Este processo faz 
c o m q u e o a r q u i v o 
PrimeiroPrograma.class seja gerado.
4. Observe na figura abaixo que estamos 
na pasta onde salvamos o nosso arquivo 
PrimeiroPrograma.java. O comando javac 
f o i e xe cu t ado , nenhum e r r o f o i 
encontrado e foi gerado o arquivo 
PrimeiroPrograma.class.
5 . Para executar este código, temos que 
chamar a máquina virtual. Para isso, 
basta:
java PrimeiroPrograma
6 . Observe que não há necessidade de 
colocar a extensão neste passo.
Parabéns, você conseguiu executar seu 
primeiro programa!
SÍNTESE DA AULA
Nesta aula, você: 
• Compreendeu a importância das 
linguagens de programação;
• Conheceu o ambiente de programa 
java;
• Se familiarizou com os diversos tipos 
de plataformas java;
• Entendeu o funcionamento de um 
ambiente java;
• Aprendeu a montar um ambiente de 
p r og ramação e t e s t e s p a ra a 
linguagem de programação java
REGISTRO DE PARTICIPAÇÃO
1 . N ã o é u m a m b i e n t e d e 
desenvolvimento de software Java.
 1) JVM 
 2) J2SE 
 3) J2EE 
 4) J2ME 
2. Escolha a opção que não é uma 
característica do Java.
 1) Linguagem de programação 
estruturada 
 2) Portabilidade 
 3) Reutilização de código 
 4) Facilidade de entendimento por 
derivar de outras liguagens 
LINGUAGEM DE PROGRAMAÇÃO
Exercício: CCT0176_EX_A1_201102276103 
1ª Questão 
De acordo com o texto abaixo, qual a 
alternativa correta? (Fonte: adaptado 
IBM)
"é um programa que carrega e executa os 
ap l i cat ivos Java, conver tendo os 
bytecodes em código executável de 
máquina."
( ) JDK ( ) JSR
( ) JRE ( X ) JVM
( ) garbage collector
 2ª Questão 
Pa ra que possamos desenvo l ve r 
aplicações básicas em Java basta termos 
instalado em nosso computador a(s) 
seguinte(s) tecnologias: (assinale 
somente uma alternativa)
( ) O JDK e o Java Standard Edition.
( ) Somente o Java Standard Edition.
( ) Somente o Java Runtime Enviroment-JRE.
( ) Somente a Java Virutal Machine-JVM.
( X ) A Java Runtime Environment (JRE), 
ambiente de execução Java, formado 
pela JVM e bibliotecas,e do Java SE 
(Standard Edition) - JDK.
 3ª Questão 
A c l a s se S t r i ng pos su i d i ve r sas 
funcionalidades importantes para o 
programador. Abaixo seguem alguns dos 
métodos disponíveis. 
Assinale a opção INCORRETA:
( ) equals() - compara duas strings
( ) length() - obtém o tamanho de uma 
string
( ) toUpperCase() - altera a string para 
maiúsculo
( ) charAt(x) - captura o caractere de uma 
string de acordo com o índice estipulado
( X ) trim() - concatena duas strings
AULA 2
TIPOS DE DADOS E ESTRUTURAS 
BÁSICAS DE PROGRAMAÇÃO
Nesta aula, você irá: 
1.Identificar os tipos de dados primários;
2.Utilizar tipos de dados primitivos, 
variáveis simples;
3.Aplicar as estruturas de decisão em 
java;
4.Aplicar as estruturas de repetição em 
java; 
5.Desenvo lver, l e r e i n te rp re ta r 
pequenos programas java, com 
estruturas básicas e seus tipos de 
dados;
AS CONVENÇÕES DO JAVA
A linguagem de programação Java é 
“Case Sens i t ive”. Ex is tem vár ias 
convenções utilizadas. São elas:
•Nomes de var iáveis e métodos 
começam com letras MAIÚSCULAS
•Nomes de classes iniciam com letras 
MAIÚSCULAS
•Nomes compostos: utilizar letras 
MAIÚSCULAS para in ic ia is das 
palavras
•Letras MAIÚSCULAS para constantes
Comentários em Java
Existem três formas de se inserir 
comentários:
1.// comentário em uma linha
2./* comentário em uma ou mais linhas 
*/
3./** Documento Comentário*/
Quando este tipo de comentário é 
colocado imediatamente acima da 
declaração (de uma função ou 
variável), indica que o comentário 
poderá ser incluído automaticamente 
em uma página HTML (gerado pelo 
comando javadoc - gerador de 
documentação do java)
TIPOS DE DADOS EM JAVA
O Java é uma linguagem de programação 
fortemente tipada, ou melhor, necessita 
que todas as variáveis tenham um tipo 
declarado. Existem 8 tipos primitivos. 
Seis deles são numéricos, um é o 
caractere e o último é o booleano.
D E C L A R A N D O E A T R I B U I N D O 
VALORES A VARIÁVEIS
A declaração de variáveis em Java exige 
que o tipo da variável seja declarado. 
Você inicia a declaração, indicando o tipo 
da variável e o nome desejado, como nos 
exemplos a seguir:
int x, y; //declarando duas variáveis 
inteiras
x = 6; //atribuindo valores a variáveis
y = 1000;
 
float f = 3,141516f; //ponto flutuante
double w = 3,2310834; //ponto flutuante 
de dupla precisão
char ch = ‘a’; //Caractere
 
final int MAX = 9; Define a constante MAX 
com o valor de 9
OPERADORES ARITMÉTICOS E 
RELACIONAIS
OPERADOR ARITMÉTICOS
OPERADORES RELACIONAIS
O operador ! é chamado de not ou 
negado.
E S T R U T U R A S B Á S I C A S D E 
PROGRAMAÇÃO
Os comandos da linguagem permitem 
contro lar o f luxo do programa e 
expressões condicionais.
BLOCOS
Conjunto de linhas de códigos situadas 
entre um abre e um fecha chaves( {} ). É 
permitido criar blocos dentro de blocos. 
 
{ //início de bloco
...
 /*bloco de comandos*/
...
} //fim de bloco
ESCOPO DAS VARIÁVEIS
Escopo de uma variável indica em que 
parte do código ou bloco de comandos do 
programa que podemos utilizar ou 
enxergar a variável. Existem variáveis 
locais e variáveis globais. O escopo define 
também quando a variável será criada e 
destruída da memória. As locais estão 
visíveis apenas dentro do bloco enquanto 
as globais estão disponíveis em qualquer 
bloco do programa.
Observação: escopo é diferente de 
visibilidade, o qual se aplica as variáveis 
de classe e tem a ver com a utilização 
destas fora da classe.
COMANDO CONDICIONAL
Desvia o fluxo natural do programa de 
acordo com um teste lógico.
if (expressão booleana)
 comando1 ou {bloco de comandos1}
 else
 comando2 ou {bloco de comandos2}
Quando o programa encontra um 
comando if, a expressão booleana é 
ava l iada. Caso a expressão se ja 
verdadeira o comando 1 é executado e o 
comando 2 não. Caso a expressão seja 
falsa o comando 2 é executado e o 
comando 1 não. Vale lembrar que o else é 
opcional.
Quando existe um conjunto de opções, 
podemos utilizar a estrutura switch-case
switch(variável)
{
 case(valor1):comando1;break;
 case(valor2):comando2;break;
 case(valor3):comando3;break;
 …
 default:comando_genérico; break;
}
Nesta estrutura, o programa avalia a 
variável. Caso o valor seja o valor1, o 
comando 1 é executado; caso seja o valor 
2, o comando 2 é executado; e assim 
sucess i vamente… Caso não se j a 
encontrado o valor, o comando genérico é 
executado.
DESVIO DE FLUXO
Existem dois comandos de desvios de 
fluxo
break
continue;
break; O comando termina a execução de 
um loop sem executar o resto dos 
comandos e força a saída do laço.
continue; O comando termina a execução 
de um laço sem executar o resto dos 
comandos, voltando ao início do laço para 
uma nova iteração.
ESTRUTURAS DE REPETIÇÃO OU 
LAÇO
1. while(expressão)
 comando ou {bloco de comandos}
Enquanto a expressão forverdadeira, o 
comando será executado. Quando a 
expressão for falsa o programa segue 
para o seu caminho normal.
2. do
 comando ou {bloco de comandos}
 while(expressão);
Faz o comando,, enquanto a expressão 
for verdadeira. Quando a expressão for 
falsa o programa segue para o seu 
caminho normal. A grande diferença entre 
o do-while e o while é que no laço do-
while o programa executa pelo menos 
uma vez o comando do laço.
3. for(inicialização; expressão; incremento)
 comando ou {bloco de comandos}
O comando for executa o laço enquanto a 
expressão for verdadeira, só que pode ser 
controlada por um contador. Esta 
expressão permite que o usuário inicialize 
e incremente o contador no controle do 
laço
MANIPULANDO COM STRINGS
Java é uma linguagem totalmente 
orientada a objetos. Então, todos os 
valores utilizados são objetos descritos 
por classes. Os tipos primitivos de dados 
permitem que possamos criar todos os 
tipos de objetos necessários para se 
implementar qualquer sistema. Um dos 
objetos mais utilizados é o String (com S 
maiúsculo porque, como vimos nas 
convenções, String é uma classe).
String é uma sequência de caracteres.
Ex.:
String um = “Curso”;
String dois = “Java”;
ATENÇÃO
Objetos da classe String não 
devem ser comparados usando 
os operadores relacionais, 
porque são objetos. Existem 
m é t o d o s e s p e c i a i s p a r a 
executar tais funções. O objeto 
String em Java possui mais de 
50 métodos diferentes.
MANIPULANDO COM VETORES
Vetores são estruturas utilizadas para 
armazenar um conjunto de dados do 
mesmo tipo. Esses podem ser de 
qualquer tipo, desde variáveis primitivas 
até objetos complexos. A sua alocação na 
memória é sempre contínua.
CONVERSÃO ENTRE TIPOS DE DADOS
Quando trabalhamos com expressões, o 
resultado de uma expressão pode ser de 
um tipo diferente dos seus operandos. Ou 
ainda, temos dois tipos de dados 
diferentes e queremos efetuar uma 
operação. Não é possível efetuar 
comparações ou operações com tipos 
diferentes. Para resolver este problema, 
podemos converter os tipos de dados.
Existem, basicamente, dois tipos de 
conversões de dados. A conversão 
implícita e a explícita de dados.
IMPLÍCITA
O primeiro caso ocorre sem a necessidade 
do programador interferir. Os valores são 
convertidos automaticamente. Isso ocorre 
na conversão de inteiro para real, de 
números para strings ou com o uso de 
operadores unários.
Ex.:
double x;
int i = 20;
 
x = i; // x recebe um valor inteiro
System.out.print(“i= ” + x); /* O valor de 
x é convertido para string e concatenado 
com a outra string para ser apresentada 
na tela */
EXPLÍCITA
O segundo caso, o programador controla 
a conversão informando qual tipo será 
utilizado, através de um operador unário. 
Ex.:
float eventos = 25.7;
float dias = 7.2;
 
x = (int) (eventos / dias); // O resultado 
é o inteiro 3, pois 25/3 é 3.57
Exercícios
1) Com o seu ambiente de programação 
Java, escreva o programa abaixo no bloco 
de notas, salve em uma pasta de 
trabalho. No prompt de comando, vá até 
a pasta de trabalho e compile (utilizando 
o javac) seu programa.
Execute o programa (utiliza java <nome 
da classe>) e veja o resultado.
Além disso, faça as alterações abaixo e 
veja o resultado:
public class DemoTipo{
 public class static void main(String[] 
args){
 int i = 10;
 double d = 9.85;
 char c = ‘a’;
 boolean b = true;
 System out.print(“i= “+i);
 
 }
}
REGISTRO DE PARTICIPAÇÃO
1. O programa abaixo converte um inteiro 
em um byte. Qual o resultado 
apresentado como saída? Marque a opção 
correta.
 
public class TesteConvByte{
 public static void main(String 
args[]){
 int l=300;
 byte b;
 b=(byte) l;
 System.out.println("O valor 
de b é "+b);
 }
}
 1) 300. 
 2) -300. 
 3) 44. 
 4) -44. 
LINGUAGEM DE PROGRAMAÇÃO
Exercício: CCT0176_EX_A2_201102276103 
 1a Questão (Ref.: 201102334858)
Dada a saída: DooBeeDooBeeDo
Preencha as lacunas do código: (Fonte: Livro 
USE a Cabeça JAVA)
public class DooBee{
 public static void 
main(String[] args){
 int x = 1;
 while ( x < __________) {
 
System.out.__________("Doo");
 
System.out.__________("Bee");
 x = x + 1;
 }
 if (x == __________){
 
System.out.print("Do");
 }
 }
}
Assinale a alternativa que indique o 
preenchimento das lacunas respectivamente:
( X ) 3; print; print; 3
( ) 3; println; print; 4
( ) 3; println; println; 3
( ) 5; println; println; 5
( ) 4; println; println; 4
 2a Questão (Ref.: 201102335311)
Observe o fragmento do código JAVA a seguir:
public class Avaliacao {
 public static int e(int x) {
  return x * 1;
 }
 public static int d(int x) {
  return x * 2;
 }
 public static int b(int x) {
  if (x < 1)
   return 0;
  else
   return 5 - d(x + 1);
 }
 public static int a(int y) {
  return 3 + b(y) + d(y) + e(y);
 }
 public static void main(String[] args) {
  System.out.println(a(5));
 }
}
Como resultado de sua execução teremos o seguinte 
resultado:
( X ) 11
( ) 12
( ) 10
( ) 13
( ) 14
 3a Questão (Ref.: 201102334982)
Reorganize os trechos de código para criar um 
programa Java funcional que produzisse a saída 
listada abaixo: (Fonte: Livro USE a Cabeça JAVA)
 
c:\ETE>java DrumKitTestDrive
bang bang ba-bang
ding ding da-ding
 
Assinale a alternativa que indique a sequência 
correta:
( ) 8-3-5-4-1-6-11-2-10-7-9
( X ) 10-3-11-4-8-5-2-1-7-9-6
( ) 8-3-9-4-1-5-11-2-10-6-7
( ) 8-3-9-4-1-5-11-2-10-7-6
( ) 1-3-9-4-11-5-2-10-7-8-6
AULA 3
INTRODUÇÃO AS INTERFACES 
GRÁFICAS
Nesta aula, você irá:
1.Identificar e utilizar ides;
2.Utilizar netbeans;
3.Criar interfaces básicas, realizando 
operações simples;
4.Entender a hierarquia do pacote swing.
Introdução As Ides
IDE, do inglês Integrated Development 
Enviroment ou Ambiente Integrado de 
Desenvolvimento, é um software que 
engloba características e ferramentas 
para o desenvolvimento de programas. 
As IDEs facilitam a técnica de RAD que 
tem como principal objetivo a maior 
produtividade de seus desenvolvedores.
Existem várias IDEs disponíveis. Abaixo, a 
lista de algumas IDEs 
RAD- Rapid Application Development – 
Desenvolvimento Rápido de Aplicativos.
CONHECENDO A IDE NETBEANS
O NetBeans é uma IDE gratuita e de 
código aberto, totalmente escrito em Java 
para desenvolvedores de software na 
linguagem Java, C/C++, PHP, Groovy, 
Ruby e muito mais. Por ser escrito em 
Java, é multi-plataforma, ou melhor, 
funciona em vários ambientes como 
Windows, Linux, Solaris e MacOS. O 
N e t B e a n s I D E o f e r e c e a o s 
desenvolvedores ferramentas necessárias 
para criar aplicativos profissionais de 
desktop, empresariais, Web e móveis.
Com projeto iniciado em 1996 por dois 
estudantes tchecos, teve como primeiro 
nome Xelfi, em alusão ao Delphi, porém 
foi totalmente desenvolvido em Java.
Em 1999, o projeto já havia evoluído para 
uma IDE proprietário, com o nome de 
NetBeans DeveloperX2, nome este que 
ve io da idé ia de reut i l i zação de 
componentes, que era a base do Java.
N e s s a é p o c a , a e m p r e s a S u n 
Microsystems havia desistido de sua IDE 
Java Workshop e, procurando por novas 
iniciativas, adquiriu o projeto NetBeans 
DeveloperX2 ,incorporando-o a sua linha 
de softwares.
Por alguns meses, a Sun mudou o nome 
do projeto para Forte for Java e o 
manteve por um bom tempo como 
software proprietário, porém, em junho 
de 2000, a Sun disponibilizou o código 
fonte do IDE NetBeans tornando-o uma 
plataforma OpenSource. Desde então, a 
comunidade de desenvolvedores que 
utilizam e contribuem com o projeto não 
parou de crescer, tornando-se uma das 
IDE´s mais populares atualmente.
O NetBeansé considerado a melhor IDE 
para desenvolvedores iniciantes, pois, 
facilita o processo de programação, 
compilação e execução dos programas. 
Este sistema cria um ambiente completo 
de teste. O único problema é que para 
montar todo este ambiente, esta IDE 
exige uma configuração de hardware um 
pouco me lho r, p r i n c i pa lmen te a 
quantidade de memória. 
Existem várias opções de download. A 
partir desta aula, iremos utilizar o 
NetBeans 6.9.1
Para fazer o Download da IDE, basta ir ao 
endereço:
http://netbeans.org/
Utilizando o NetBeans
Para utilizar o NetBeans, é necessário 
criar um projeto, e, para isto, siga os 
passos a seguir:
1º Passo: No menu Arquivo, clique em 
Novo projeto.
3º Passo: É aberta então a tela do 
NetBeans onde será criado o arquivo.java 
(arquivos fontes).
4 º Pa s s o : N o t e q u e , n a j a n e l a 
pertencente à aba Main.java, está o 
método:
public static main(String[] args)
{
 
//TODO code application logic 
here
 
}
Este é o método inicial, então 
escrevemos alguns comandos de 
maneira a realizar a primeira execução 
de um programa em Java.
5º Passo: Agora digite o código abaixo no 
método main.
public static main(String[] args)
{
//TODO code application logic 
here
 int num1=2;
 int num2=8;
 int soma;
 
soma = num1+num2;
System.out.printf(“A soma é %d
\n”, soma);
}
6º Passo: Com o código fonte digitado, 
vamos executar o projeto principal. Para 
isso, podemos utilizar a tecla de atalho – 
F6, ou apertar no botão executar.
7º Passo: Note na janela saída, na parte 
inferior da tela, a execução do projeto e a 
apresentação do resultado de modo 
semelhante ao que ocorria quando 
executávamos no terminal da console.
Agora você está apto a executar um 
programa nesta IDE, basta explorar mais 
a ferramenta para tirar o máximo de 
proveito de seus recursos e facilidades.
INTRODUÇÃO A CONCEPÇÃO DE 
INTERFACES GRÁFICAS
Muitos dos programas conhecidos 
interagem com os usuários através da 
troca de informações. O meio pelo qual a 
parte humana solicita ao programa a 
execução de tarefas, alguma resposta, ou 
qualquer comunicação entre as partes é 
feito pela Interface. Muitas vezes 
confundida com o programa em si. 
A interface gráfica com o usuário (GUI) 
fornece a um programa um conjunto 
consistente de componentes intuitivos, 
familiarizando o usuário com as diversas 
funções e diminuindo o tempo de 
aprendizado da nova ferramenta. As GUIs 
são construídas a partir de componentes 
GUI, que são objetos com o qual o 
usuário interage através dos dispositivos 
de entrada, ou seja, o mouse, o teclado, 
a voz, etc. 
Imagine que construir interfaces consiste 
em colar adesivos em uma tela de vidro 
ou colocar componentes em um contêiner 
de componentes. Antes de tudo, é 
necessário possuir uma tela, que será 
representada pelos contêineres. Também 
dispor de adesivos de diversos tamanhos 
que podem ser distribuídos e anexados 
livremente pela superfície do vidro. Tais 
adesivos elementares serão os painéis. 
Além disso, dispor de adesivos mais 
elaborados que já estão pré-definidos 
com figuras de botões, rótulos, etc. Estes 
podem ser colados diretamente no vidro, 
ou sobre os outros adesivos rudimentares 
(painéis), tal qual é a nossa vontade, 
embora se limitando à capacidade do 
espaço físico disponível. Na imagem você 
pode ver alguns dos componentes que 
estudaremos mais a frente.
CRIAÇÃO DE INTERFACES GRÁFICAS
Em Java, as classes necessárias para 
criação de componentes gráficos, bem 
como para fornecer-lhes funcionalidade, 
estão agrupadas em dois grandes 
pacotes: java.awt (pacote do núcleo)e 
javax.swing (pacote de extensão). Os 
dois pacotes definem componentes com 
peculiaridades distintas e que serão 
discutidas a seguir.
COMPONENTES SWING
O pacote javax.swing foi criado em 1997 
e inclui os componentes GUI que se 
tornaram padrão em Java a partir da 
versão 1.2 da plataforma Java 2. A 
maioria dos componentes Swing é escrita, 
manipulada e exibida completamente em 
Java, estes são conhecidos como 
componentes Java puros. Isso oferece a 
eles um maior nível de portabilidade e 
f l e x i b i l i d ade . Os nomes de t a i s 
componentes recebem um “J”, como, por 
exemplo: JLabel, JButton, JFrame, JPanel, 
etc. Tal peculiaridade se justifica para 
diferenciar esses componentes dos que 
serão mencionados logo adiante. Os 
c o m p o n e n t e s S w i n g f o r n e c e m 
funcionalidade e aparência uniforme em 
todas as plataforma, sendo denominada 
de aparência de metal. 
O Swing também fornece flexibilidade 
para personalizar a aparência e o 
comportamento dos componentes de 
acordo com o modo particular de cada 
p lataforma, ou mesmo a l terá- los 
enquanto o programa está sendo 
e x e c u t a d o . A s o p ç õ e s s ã o a 
personalização com o estilo do Microsoft 
Windows, do Apple Macintosh ou do Motif 
(UNIX).
metal look-and-feel
COMPONENTES BÁSICOS
O esquema a seguir mostra a maioria das 
classes que compõem o Java Swing e 
mostra também a relação entre as classes 
AWT (claro) e as classes Swing (escuro):
PAINÉIS
são áreas que comportam outros 
componentes, inclusive outros painéis. 
Em outras palavras, são elementos que 
fazem a intermediação entre um 
container e os demais GUI anexados. São 
criados com a classe JPanel, que é 
derivada da classe Container. A classe 
JPanel não tem painel de conteúdo como 
JFrames, assim, os elementos devem ser 
diretamente adicionados ao objeto painel. 
Além de agregar um conjunto de 
componentes GUI para fins de layout, 
pode-se criar áreas dedicadas de desenho 
e áreas que recebem eventos do mouse.
Criando O Primeiro Formulário
Componentes SWING
import javax.swing.*; 
public class Frm01 
{ 
 public void criaTela() 
 { 
 JFrame f= new 
JFrame(); 
 f.setSize(290,100); 
 f.setTitle("Cadastro"); 
 f.setLocation(10,10); 
 f.setDefaultCloseOperat
ion(JFrame.EXIT_ON_CLOSE); 
 f.setVisible(true); 
 } 
}
Componentes básicos
public class TestaFrm01 { 
 public static void 
main(String []args){ 
 Frm01 tela = new 
Frm01(); 
 tela.criaTela(); 
 } 
}
A saída deste programa é:
O m é t o d o 
setDefaultCloseOperation()também pode 
ser executado com outras constantes 
como argumento:
•DISPOSE_ON_CLOSE - Destróia a 
janela
•HIDE_ON_CLOSE - Apenas fecha a 
janela
•DO_NOTHING_ON_CLOSE - Desabilita 
opção
•EXIT_ON_CLOSE - Encerra a aplicação
INSERINDO COMPONENTES NA TELA
import javax.swing.*; 
public class Frm02 
{ 
public void criaTela() 
{ 
//criando o Frame 
JFrame f= new JFrame(); 
f.setSize(300,100); 
f . s e t T i t l e ( " C a d a s t r o d e 
Categorias"); 
f.setLocation(150,200); 
f.setDefaultCloseOperation(JFrame.
EXIT_ON_CLOSE); 
//criando o Painel 
JPanel pl = new JPanel(); 
pl.setLayout(null);// gerenciador de 
Layout 
//Criando os componentes: 
//Label 
J L a b e l m e u L a b e l = n e w 
JLabel("Código"); 
meuLabel.setBounds(10, 10, 60, 
20); 
// Campo de Texto 
JTextField meuCampoTexto = new 
JTextField(" "); 
meuCampoTexto.setBounds(80, 10, 
60, 20); 
// Botão 
J B u t t o n m e u B o t a o = n e w 
JButton("NomeBotão"); 
meuBotao.setBounds(150, 10, 100, 
20); 
//colando os componentes no Painel 
pl.add(meuLabel); 
pl.add(meuCampoTexto); 
pl.add(meuBotao); 
//colando o painel no frame 
f.add(pl); 
f.setVisible(true); 
} 
}
Saída do programa:
Nesta aula, você: 
• Identificou a importância das ides;
• Utilizou uma IDE chamada netbeans;
• Manipulou interfaces gráficas;
• Desenvolveu eexecutou pequenos 
programas com interfaces gráficas e 
dentro de uma IDE.
Registro de Participação
1. Contêineres, painéis e botões são 
componentes:
 1) Interfaces com usuários. 
 2) Páginas HTML. 
 3) Apenas da AWT 
 4) GUI. 
CCT0176_EX_A3_201102276103
Disciplina: CCT0176 - LINGUAGEM DE PROGRAM 
Período Acad.: 2014.1 - EAD (G) / EX
1. Relacione as definições e marque a 
alternativa correspondente:
a-toLowerCase() ! ! d-length() 
b-toUpperCase() ! ! e-substring()
c-trim() 
(a) converte maiúscula por minúscula. 
(b) converte minúscula por maiúscula. 
(d) descobre o tamanho de uma string. 
(c) elimina espaços iniciais e finais. 
(e) extrai um conjunto de string.
[ ] a - b - c - e - d
[ ] a - b - d - e - c
[ ] b - a - d - c - e
[ ] b - a - d - e - c
[X] a - b - d - c - e
2. Levando em consideração os conceitos 
sobre vetores, assinale a opção correta:
[ ] um vetor somente pode armazenar tipos 
primitivos de dados
[ ] o índice de um vetor sempre começa em 1
[ ] o limite de um vetor em Java é de 255 
posições
[ ] declara-se um vetor: int c[5] = new int();
[X] é possível executar a seguinte operação 
em um vetor de inteiros: x = vet[5] + vet[8];
3. Em Java utiliza-se muito a expressão 
superclasse, ou seja, toda nova classe criada 
subclasse desta superclasse, que é a classe 
Object. Diante disto, assinale a alternativa 
verdadeira a respeito desta superclasse:
[ ] Não fornece métodos que todos os objetos 
em Java precisam (no mínimo).
[ ] Os métodos podem ser declarados com 
argumentos ou tipo de retorno Vector.
[ ] A classe Object pertence ao pacote 
java.swing.
[X] Age como um tipo polimórfico para métodos 
que tenham que ser usados em qualquer 
classe.
[ ] A classe Object não possui nenhum método 
que o objeto possa utilizar.
AULA 4
PRINCÍPIOS DA ORIENTAÇÃO A OBJETOS
Nesta aula, você irá:
1.identificar os conceitos básicos da 
Orientação a Objetos;
2.criar e manipular classes e objetos em 
Java;
3.utilizar interfaces gráficas interagindo 
com objetos e classes previamente 
definidos;
4.implementar classes e instanciar 
objetos em Java.
INTRODUÇÃO CLASSES E OBJETOS
Todo sistema orientado a objetos pode 
ser definido como um conjunto de objetos 
que trocam mensagens entre si. Então, 
quando programamos em Java, que é 
uma l i nguagem de p rog ramação 
orientada a objetos, estamos escrevendo 
ou definindo um conjunto de objetos que 
trocam mensagens. 
Bom, mas o que é um Objeto? O que é 
uma classe? O que é mensagens?
As classes definem a estrutura e o 
comportamento de um tipo de objeto. 
O b s e r v e a f i g u r a a b a i x o :
A classe Árvore define um arcabouço de 
qualquer tipo de árvore. Uma árvore real, 
será um objeto com a estrutura definida 
pela classe, mas os valores de cada 
árvore serão únicas.
CLASSES
Um protótipo que define os atributos e os 
métodos comuns a todos os objetos de 
um determinado tipo e da própria classe, 
com a finalidade de servir de molde para 
a criação de objetos.
OBJETOS
São a representação de uma entidade do 
mundo real, que tem identificador único, 
propriedades embutidas e a habilidade de 
interagir com outros objetos e consigo 
mesmo. Um objeto é uma instância de 
uma classe. A classe descreve todas as 
características e funcionalidades de um 
objeto. Modelamos os objetos através das 
classes.
ABSTRAÇÃO
•Extrair tudo que for essencial e mais 
nada para o escopo do sistema;
•É o processo de filtragem de detalhes 
sem importância do objeto real, para 
q u e a p e n a s a s c a ra c t e r í s t i c a s 
apropriadas que o descrevam e que 
tenham relevância para o sistema 
permaneçam;
•Conceito aplicado a criação de software 
baseado em objetos, partindo do 
princípio que devemos considerar a 
essência de cada objeto e não pensar 
e m t o d o s o s d e t a l h e s d e 
implementação;
CLASSES E OBJETOS EM JAVA
•Na caixa de dialogo do novo projeto, 
escolhemos um aplicativo Java
•Um programa Java é uma coleção de 
objetos que são descritos por um 
conjunto de arquivos texto, onde são 
definidas as classes. Pelo menos uma 
destas classes é “public” e contém o 
método main(), que possui esta forma 
específica:
public  sta+c  void  main(String  []  args)  {
        //  aqui  o  programador  insere  os  comandos
}
Como vimos nas aulas anteriores todos os 
programas feitos tinham esta estrutura. E 
o nome da classe era o nome do arquivo. 
Então, podemos concluir que uma classe 
em Java é construída dentro de um 
arquivo texto com o mesmo nome da 
classe e extensão .java.
 javac Oi.java
 java Oi
Nos comandos acima, o compilador Java 
compila o arquivo texto Oi.java, gerando 
o bytecode. A máquina virtual interpreta 
a classe Oi, quando o comando java Oi é 
executado. 
Lembro que a classe que contém o 
método main() é chamada de classe 
principal.
ENCAPSULAMENTO
•Mecanismo utilizado em orientação a 
objetos para obter segurança, 
modularidade e autonomia dos objetos;
•Implementamos através da definição de 
visibilidade privada dos atributos;
•Então, devemos sempre definir os 
atributos de uma classe como privados;
•Este mecanismo protege o acesso direto 
aos dados do objeto;
•Permite acesso através dos métodos 
públicos;
NÍVEL DE ENCAPSULAMENTO
•É a disponibilização de uma interface 
pública, com granularidade controlada, 
para manipular os estados e executar as 
operações de um objeto ( * acesso 
permitido ).
Modificadores   Mesma  classe   Mesmo  pacote   Subclasses   Universo  
private   *  
<sem  modif>   *   *  
protected   *   *   *  
public   *   *   *   *  
Em outras palavras, os atributos e 
métodos de um objeto podem ser 
escondidos de outros objetos por uma 
interface pública de métodos, de modo a 
impedir acesso indevidos.
Para def in i r d i ferentes n íve is de 
encapsulamento, faz-se uso do conjunto 
de modificadores de acesso disponíveis no 
Java para os membros de classe, com 
mostrado na tabela.
Definindo uma classe em Java
•São definidas através do uso da 
palavra-chave class.
• Construindo uma classe:
•
[modif] class NomeDaClasse { 
 // corpo da classe... 
}
•A primeira linha é um comando que 
inicia a declaração da classe. Após a 
palavra-chave class, segue-se o nome 
da classe, que deve ser um identificador 
válido para a linguagem. O modificador 
modif é opcional; se presente, pode ser 
uma combinação de public e abstract ou 
f i n a l . A d e f i n i ç ã o d a c l a s s e 
propriamente dita está entre as chaves 
{ e }, que delimitam blocos na 
linguagem Java.
CORPO DA CLASSE
1.As variáveis de classe (definidas como 
static), ordenadas segundo sua 
visibilidade: iniciando pelas public, 
seguidos pelas protected, pelas com 
visibilidade padrão (sem modificador) e 
finalmente pelas private. 
2.Os atributos (ou variáveis de instância) 
dos objetos dessa classe, seguindo a 
mesma ordenação segundo a visibilidade 
definida para as variáveis de classe. 
3.Os construtores de objetos dessa 
classe. 
4.Os métodos da classe, geralmente 
agrupados por funcionalidade.
CRIANDO OBJETOS EM JAVA
•Toda classe possui atributos e métodos. 
Em especial, toda classe tem um 
c o n s t r u t o r, q u e é u m m é t o d o 
responsável pela instanciação do objeto. 
•Este processo faz com que o objeto seja 
criado com as características desejadas. 
•O construtor é o responsável por alocar 
a memória do objeto. 
•A criação de um objeto se dá através da 
aplicação do operador new.
 C l a s s e N o m e o b j e t o = n e w 
ClasseNome();
O método a direita do operador new é o 
construtor da classe ClasseNome. 
Podemos instanciar quantos objetos 
forem necessár ios. Contanto que 
guardemos a referência para o objeto emquestão. A referência é como poderemos 
acessar aquele objeto. 
Caso um objeto não tenha mais nenhuma 
referência para ele, o coletor de lixo 
(garbage collector - GC) elimina o objeto, 
liberando a memória.
ATRIBUTOS E MÉTODOS
•Atributos
–Eles representam as características 
de um objeto. Devem ser privados, 
para manter o encapsulamento. A 
definição de atributos de uma classe 
Java reflete de forma quase direta a 
informação que estaria contida na 
representação da classe em um 
diagrama UML. 
•Métodos
–Os mé todos r ep resen tam as 
funcionalidades que os objetos 
p o d e m d e s e m p e n h a r. S ã o 
essencialmente procedimentos que 
podem manipular atributos de 
objetos para os quais o método foi 
definido. Além dos atributos de 
objetos, métodos podem definir e 
manipular variáveis locais; também 
podem receber parâmetros por valor 
através da lista de argumentos.
ATRIBUTOS
•A sintaxe utilizada para definir um 
atributo de um objeto é: 
 [modificador] tipo nome [ = 
default]; 
•Onde: 
–modificador é opcional, especificando 
a visibilidade diferente da padrão 
(public, protected ou private); 
–tipo deve ser um dos tipos primitivos 
da linguagem Java ou o nome de 
uma classe; 
–nome deve ser um identificador 
válido da linguagem Java; 
–valor default é opcional; se presente, 
especifica um valor inicial para a 
variável.
Métodos
O s m é t o d o s r e p r e s e n t a m a s 
funcionalidades que os objetos podem 
desempenhar. São essencialmente 
procedimentos que podem manipular 
atributos de objetos para os quais o 
método foi definido. Além dos atributos 
de objetos, métodos podem definir e 
manipular variáveis locais; também 
podem receber parâmetros por valor 
através da lista de argumentos.
•A forma genérica para a definição de 
um método em uma classe é 
 [ m o d i f i c a d o r ] t i p o 
nome(argumentos) { 
 corpo do método 
 } 
•Onde: 
–o modificador (opcional) é uma 
combinação de: public, protected ou 
private; abstract ou final; e static. 
–o tipo é um indicador do valor de 
retorno, sendo void se o método não 
tiver um valor de retorno; 
–o nome do método deve ser um 
identificador válido na linguagem 
Java; 
–os argumentos são representados 
por uma l i s ta de parâmetros 
separados por vírgulas, onde para 
cada parâmetro é indicado primeiro o 
tipo e depois (separado por espaço) 
o nome.
Uma boa prática de programação é 
manter a funcionalidade de um método 
simples, desempenhando uma única 
tarefa. O nome do método deve refletir 
de modo adequado a tarefa realizada. Se 
a funcionalidade do método for simples, 
será fácil encontrar um nome adequado 
para o método. 
Como ocorre para a def inição de 
atributos, a definição de métodos reflete 
de forma quase direta a informação que 
estaria presente em um diagrama de 
classes UML, a não ser por uma diferença 
vital: o corpo do método. 
Métodos de mesmo nome podem co-
existir em uma mesma classe desde que 
a lista de argumentos seja distinta, 
usando o mecanismo de sobrecarga
Exemplo:
public class Ponto2D { 
 private int x; 
 private int y; 
 public Ponto2D(int a, int b) 
{ 
 x = a; 
 y = b; 
 } 
 p u b l i c d o u b l e 
distancia(Ponto2D p) { 
 double distX = p.x - 
x; 
 double distY = p.y - 
y; 
 r e t u r n 
Math.sqrt(distX*distX + distY*distY); 
 } 
}
•Neste exemplo, definimos a classe 
Ponto2D com dois atributos e dois 
métodos. Os atributos são, x e y 
enquanto os métodos são:
•Ponto2D – Construtor
•distancia – método que calcula a 
distância entre o ponto e um outro 
dado.
Nesta aula, você: 
•Identificou o que é programação 
orientada à objetos;
•Identificou classes e objetos;
•Aprendeu a manipular classes e objetos 
em java;
•Desenvolveu e executou pequenos 
programas com orientação a objetos.
REGISTRO DE PARTICIPAÇÃO
1. Um atributo encapsulado deve ter o 
seguinte modificador:
 1) Public. 
 2) Private. 
 3) Protected. 
 4) Não definida. 
 
2. Em Orientação a Objetos, um objeto é:
 1) um conjunto de classes do mundo 
real. 
 2) um conjunto de objetos que trocam 
mensagens entre si. 
 3) uma instância de uma classe. 
 4) um conjunto de atributos 
armazenados que troca mensagens com o 
mundo externo. 
 
AULA 5
HERANÇA
Nesta aula, você irá:
1.Apresentar os conceitos de herança;
2.Criar e manipular classes e objetos que 
se relacionem através de herança;
3.Sobrecarga de métodos;
4.Utilizar interfaces gráficas, interagindo 
com objetos e classes previamente 
definidos;
5.Explorar o conceito de herança, 
sobrecarga de métodos, em exemplos e 
exercícios;
Herança
•Significa a capacidade de incorporar as 
características e as funcionalidades de 
uma classe. Assim como a herança de 
todas as operações e dados, você pode 
especializar métodos da super classe e 
especificar novas operações e dados, 
para refinar, especializar, substituir ou 
estender a funcionalidade da classe 
progenitora.
•Uma classe define um conjunto de 
dados – Atributos – e um conjunto de 
métodos 
•Todos os objetos de uma classe mantêm 
o mesmo conjunto de atributos e 
métodos. 
•Através do mecanismo de herança, 
tendo definido uma classe base é 
possível criar classes derivadas que: 
–herdam os atributos e métodos da 
classe base 
–definem novos atributos e métodos 
–podem rede f i n i r o s métodos 
herdados
Abaixo, podemos ver que a classe “Meios 
de Transportes” é uma classe genérica. Já 
as classes Terrestres, representam as 
características dos Meios de Transportes 
mais as peculiaridades dos veículos 
terrestres. Os meios Aéreos, também são 
meios de t ranspor tes , mas suas 
peculiaridades são diferentes dos outros 
tipos de meios de transportes, assim 
como os Marítimos.
TERMINOLOGIAS
•Estender – Criar uma nova classe que 
herda todo o conteúdo da classe 
existente.
•Superclasse – Uma classe progenitora 
ou base.
•Subclasse – Uma classe filha que herda 
ou estende uma superclasse
CLASSE ABSTRATA
•Uma classe abstrata em Java define 
atributos e métodos. 
•Numa classe abstrata, um método pode 
ser def in ido com o modi f icador 
“abstract”. Nesse caso: 
–A classe abstrata não implementa os 
método abstratos. 
–As c l a s ses de r i vadas devem 
implementar os métodos abstratos. 
•Uma classe abstrata é utilizada quando 
deseja-se fornecer uma interface 
comum a diversos membros de uma 
hierarquia de classes. Os métodos 
declarados na classe abstrata serão 
implementados em suas subclasses, 
através de polimorfismo.
•Imagine uma classe que no seu 
sistema, a uma funcionalidade existente 
em todas as subclasses quer ser 
apresentada na superclasse. 
•Este método é definido na superclasse 
como Abstract. Nas subclasses, estes 
métodos serão implementados, cada 
um com a sua peculiaridade.
NOTAS IMPORTANTES
•Como visto anteriormente, subclasses 
podem redefinir (sobrepor) um método 
de sua superclasse. 
•Para indicar que um método de uma 
classe deve necessariamente ser 
redefinido em cada uma de suas 
subclasses devemos usar o modificador 
abstract. 
•Uma classe que contém um ou mais 
métodos abstratos deve ser declarada 
explicitamente como abstrata. Essa 
c l a s s e , n o e n t a n t o , p o d e t e r 
construtores e métodos concretos (não-
abstratos). 
•Se uma classe é declarada como 
abstract, não podem ser criados objetos 
desta classe.
•Se uma subclasse é derivada de uma 
superclasse que contém um método 
abstrato e se esse método abstrato não 
for redefinido na subclasse, esse 
método permanece abs t rac t na 
subclasse. Com isso, a subclasse deverá 
ser declarada explicitamente como 
abstract. 
•Declarar um método como abstrato é 
uma forma de obrigar o programador a 
redefinir esse método em todas assubclasses para as quais se deseja criar 
objetos. 
•Como um método abstrato deve ser 
r e d e f i n i d o n a s s u b c l a s s e s , n a 
superc lasse e le não prec isa ter 
implementação alguma.
VAMOS IMAGINAR A SEGUINTE HIERARQUIA DE 
CLASSES:
•onde Chefe, PorComissao, PorItem e 
PorHora são classes finais.
•Todas essas subclasses vão precisar 
redefinir o método ganha(). Como se 
t r a t am de t i p o s d i f e r en t e s d e 
empregado, cada um ganha de uma 
forma: 
–Chefe: salário fixo e predefinido; 
–PorComissao: valor fixo + comissão 
* vendas; 
–PorItem: valor por produção * 
quantidade produzida; 
–PorHora: valor por hora * total de 
horas trabalhadas.
if  p  >  0
      producao  =  p
else
      producao  =  0.0
Declarando o método como abstrato na 
superclasse, garante-se que nas 4 
subclasses haverá a implementação do 
método ganha() para cada tipo de 
empregado (do contrário, objetos destas 
classes não poderão ser criados).
POLIMORFISMO
•É a capacidade que os métodos de 
mesmo nome têm de efetuarem tarefas 
diferentes.
•O mesmo método com várias formas.
•Acontece de duas maneiras em Java: 
quando os métodos são definidos em 
função da c lasse que os ut i l iza 
(sobreposição) ou dos diferentes 
conjuntos de argumentos definidos para 
cada método (sobrecarga).
•Uso do “this”
–Chamada para outro construtor da 
mesma classe. É um excelente 
artifício para combinar código dos 
construtores.
EXEMPLO
public class Cliente ()
{
 private String nome; //campo de 
instância
 private int numConta; //campo de 
instancia
 public Cliente(String n, int c) //
Construtor da Classe
 { 
 nome = n;
 numConta = c;
 }
}
EXEMPLO 2
public class Cliente ( ) {
 private String nome; //campo de 
instância
 private int numConta; //campo de 
instancia
 public Cliente(String n) //Construtor 1 
da Classe Cliente { 
 this(n, 0) //Chama o Construtor 2 
da própria classe
 }
 public Cliente(String n, int c) { 
 nome = n;
 numConta = c;
 }
 public int getNumConta () { 
 return numConta;
 }
 public void setNumConta (int numero) 
{ 
 numConta = numero;
 }
}
•Uso do “super”
O comando super sempre se refere a uma 
superclasse. Todo método construtor de uma 
subclasse precisa também chamar um 
construtor para os campos de dados da 
superclasse, caso existam campos de instância 
também na superclasse.
Se a superclasse tiver um construtor, então as 
subclasses precisam usar super para passar os 
parâmetros, a fim de utilizar este construtor da 
superclasse.
Exemplo (com a classe cliente)
public class ClienteOuro extends Cliente
{
 private double 
limiteChequeEspecial; //Atributo da 
Classe
 
 public ClienteOuro (String n, int c, 
double limite) 
 { 
 super(n, c ); //precisa ser primeiro 
comando método
 limiteChequeEspecial = limite;
 }
}
Nesta aula, você: 
•Identificou o conceito de herança em 
orientação a objetos;
•Criou e manipulou classes e objetos 
através da herança;
•Utilizou interfaces gráficas, interagindo 
com objetos e classes, previamente 
definidos;
•Identificou os conceitos de sobrecarga 
de métodos;
•Desenvolveu e executou pequenos 
programas com orientação a objetos.
REGISTRO DE PARTICIPAÇÃO
1. A superclasse pode ser entendida 
como:
1) Uma nova Classe que herda todo o 
conteúdo da classe existente. 
2) Uma Classe progenitora ou base. 
3) Uma Classe filha que herda. 
4) Uma Classe filha que estende a sua 
progenitora. 
 
2. Podemos entender como Herança:
1) A utilização do classificador this. 
2) Capacidade de isolar os atributos dos 
Métodos. 
3) Capacidade de incorporar os dados e 
métodos de uma classe previamente 
definida. 
4 ) C a p a c i d a d e d e u t i l i z a r a s 
características da classe progenitora sem 
poder alterar suas características. 
 
AULA 6
ENCAPSULAMENTO E ASSOCIAÇÕES DE CLASSES
Nesta aula, você irá:
1.Apresentar os conceitos de encapsulamento e 
associações de classes;
2.Criar e manipular classes e objetos, com seus 
atributos encapsulados, e que se relacionem 
através de associações;
3.Utilizar interfaces gráficas interagindo com 
objetos e classes previamente definidos;
4.Explorar o conceito de encapsulamento e 
associações de classes, em exemplos e 
exercícios;
Encapsulamento
Mecanismo utilizado na Programação Orientada a 
Objetos, que visa obter segurança, modularidade e 
autonomia para os objetos;
Conseguido, através da definição de visibilidade 
privada dos atributos, ganhando-se, assim, 
autonomia, para definir o que o mundo externo a 
classe poderá visualizar e acessar, normalmente 
através de métodos públicos.
CONCLUSÃO
Sempre defina os atributos de uma classe como 
privados, a não ser que tenha uma boa justificativa 
para isso.
O Encapsulamento protege os atributos de acesso 
direto e permite apenas acesso através de métodos 
públicos
MODIFICADORES DE VISIBILIDADE
Um modificador de acesso determina como será a 
visibilidade de uma classe, método ou atributo a 
partir de outras classes.
• Modificadores de Acesso: public, protected, 
private e sem modificador (default)
• Modificadores de Não Acesso: final e abstract
– public – Atributos e métodos são acessíveis 
em todos os métodos de todas as classes. 
Este é o nível menos rígido de 
encapsulamento, que dizemos que o 
encapsulamento foi rompido.
– private - Atributos e métodos são acessíveis 
somente nos métodos da própria classe. 
Este é o nível mais rígido de 
encapsulamento. 
– protected - Atributos e métodos são 
acessíveis no pacote, nos métodos da 
própria classe e suas subclasses. 
– Sem Modificador – A visibilidade nas classes 
do mesmo pacote e a própria classe.
– private - Atributos e métodos são acessíveis 
somente nos métodos da própria classe. 
Este é o nível mais rígido de 
encapsulamento. 
–
Outros Modificadores
• abstract – Um método abstrato não 
implementa nenhuma funcionalidade, somente 
assina o método e faz com que a primeira 
subclasse concreta seja obrigada a 
implementar. Uma classe que possui um 
método abstrato deve ser obrigatoriamente 
abstrata, como vimos na aula passada.
• final – Pode ser aplicado em classes, métodos 
e atributos. Indica que esta é a última 
atribuição ou definição da estrutura. Não será 
permitida uma nova re-escrita. Para uma 
classe, não há herança em classes final. Um 
método não pode ser sobrescrito. E um atributo 
é considerado uma constante.
• static – Um método ou atributo estático define 
que este pode ser executado sem que exista 
uma instância da classe – o objeto.
EXEMPLO: SEM ENCAPSULAMENTO
class NaoEncapsulado {
 //implicitamentamente há modificador de 
acesso, 
 //mas não é o mais restritivo
 int semProtecao;
}
public class TesteNaoEncapsulado {
 public static void main(String[] args) {
 NaoEncapsulado ne = new 
NaoEncapsulado(); 
 //ne é uma instância de NaoEncapsulado
 ne.semProtecao = 10; //acesso direto ao 
atributo
 System.out.println("Valor sem proteção: " 
+ ne.semProtecao); 
 //acesso direto aos atributos
 }
 }
EXEMPLO: COM ENCAPSULAMENTO
class Encapsulado {
 //private é um modificador de acesso de 
restrição máxima
 private int comProtecao;
 public void setComProtecao(int comProtecao) {
 this.comProtecao = comProtecao;
 }
 public int getComProtecao() {
 return this.comProtecao;
 }
}
public class TesteEncapsulado {
 public static void main(String[] args) {
 Encapsulado e = new Encapsulado(); 
 // O Objeto "e" é uma instância de 
Encapsulado
 e.comProtecao = 10; //Esta linha dá erro
 e.setComProtecao(10);
 System.out.println("Valor com proteção: " 
+ e.getComProtecao() ); 
 }
}
Métodos Get’s e Set’s
Como vimos, é preciso criar um mecanismo para 
acessaros campos private de uma classe. Para 
isso, é comum fornecer métodos públicos para 
acessar as informações encapsuladas. Estes 
métodos são chamados de set e get. O método set 
atribui valores ao atributo, enquanto que o método 
get obtém seus valores.
A composição do nome destes métodos é sempre 
com o nome set + <nome atributo> ou get + 
<nome atributo>.
Abaixo vemos um exemplo de atributo que não 
permite alteração, logo seus atributos são privados 
e só foi disponibilizado os métodos et’s. g
class CorpoCeleste {
 public long id;
 public String nome;
 .....
}
Garante acesso externo somente no modo "read-
only".
class CorpoCeleste {
 private long id;
 private String nome;
 .....
 public long getId ()
 {
 return id;
 }
 public String getNome ()
 {
 return nome;
 }
 .....
}
ASSOCIAÇÃO DE CLASSES
É um vínculo que permite que objetos de uma ou 
mais classes se relacionem. Através destes 
vínculos, é possível que um objeto troque 
mensagens ou chame os métodos de outros 
objetos.
Na UML, quando estamos modelando o diagrama 
de classes, temos a Associação, a Composição e a 
Agregação, como tipos de Associações.
As Associações têm acoplamento fraco.
As Composições têm acoplamento forte.
A Agregação faz parte de.
Na implementação, não há diferença entre as 
abordagens, o que as distingue são os controles 
adicionados pelo desenvolvedor.
Unified Modeling Language 
Linguagem de modelagem unificada. 
Exemplo
public class Aviao { 
 Motor motor = new Motor(); // 
composição - O Avião é composto de Motor
 public void adiciona(Passageiro p)
{ // isto é agregação 
 p.embarque(this); 
 } 
 public void remove(Passageiro p){ 
 p.desembarque(this) 
 } 
 // isto é uma associação 
 
public void setControladorVoo (ControladorVoo 
controlador); 
 public ControladorVoo getControladorVoo (); 
} 
public class Passageiro { 
 Aviao aviao ; 
 public void embarque(Aviao aviao ){ 
 if (this.aviao ==null){ 
 
throw new IllegalStateException("O passageiro 
já embarcou. Remova-o 
antes de o incluir em outro"); 
 } 
 this.aviao = aviao ; 
 } 
 public void desembarque(Aviao aviao){ 
 if (aviao.equals(this.aviao)){ 
 this.aviao = null; 
 } 
 } 
} 
Em resumo, a associação representada pela ligação 
de duas classes no modelo, inclui um novo atributo 
na classe. A navegabilidade indica que classe 
enxerga a outra.
COMPOSIÇÃO
Tipo de associação onde uma nova classe usa 
classes existentes como atributos; 
Relacionamento “tem um”.
Ex.: uma conta tem um dono (cliente), um cliente 
tem um nome (string);
class Aleatorio { 
 int numero; 
 Aleatorio(int max) { 
 numero = new Random().nextInt(max); 
 } 
} 
public class NumeroAleatorio { 
 private String nome; 
 private Aleatorio valor; 
 
 NumeroAleatorio(String nome, int valor) { 
 this.nome = nome; 
 this.valor = new Aleatorio(valor); 
 } 
 
 public static void main(String[] args) { 
 NumeroAleatorio n; 
 n = new NumeroAleatorio("Número 
secreto", 50); 
 } 
}
Podemos ter as seguintes multiplicidades de 
associações:
1 para 1
1 para *
* para *
Onde * equivale a muitos.
Exemplos
• Um automóvel tem um motor instalado
public class Carro { 
 private String modelo; 
 private short ano;
 private Motor motor; // Atributo gerado pela 
associação 
 public void Carro(short a, String mod, Motor m)
{
 this.modelo = mod;
 this.ano = a;
 this.motor = m;
 } 
} 
public class Motor { 
 private String combustivel; 
 private float potencia;
 public void Motor(float pot, String comb){
 this.potencia = pot;
 this.combustivel = comb;
 } 
} 
 public class TestaCarro { 
 public static void main(String[] args) { 
 Motor motFusca = new Motor(999f, 
“gasolina”);
 Carro fusca82 = new Carro(“Fusca”,
(short)1982, motFusca);
 Carro kombi2010 = new Carro(“Kombi”,
(short)2010, new Motor(1399f,”flex”));
 } 
} 
Nesta aula, você: 
•Identificou o conceito de encapsulamento em 
orientação a objetos;
•Criou e manipulou classes e objetos com atributos 
encapsulados;
•Associou classes e manipulou objetos associados;
•Exercitou exemplos;
•Desenvolveu e executou pequenos programas 
com orientação a objetos.
Registro de Participação
1. Para que todos os atributos de uma classe 
estejam encapsulados, o programador deverá 
utilizar qual modificador:
1) Public. 
2) Private. 
3) Protected. 
4) Nenhum modificador. 
 
2. Os métodos Get’s e Set’s são fundamentais 
para:
1) publicar atributos na classe. 
2) prover acesso aos dados públicos. 
3) prover acesso aos dados encapsulados. 
4) são feitos em todas as classes sem atributos. 
 
LINGUAGEM DE PROGRAMAÇÃO
Exercício: CCT0176_EX_A6_201102276103 
 1a Questão (Ref.: 201102535434)
Seja a classe:
public class Carro {
 private String cor;
 private boolean estadoMotor;
 public void ligaMotor() {estadoMotor=true;}
 p u b l i c v o i d d e s l i g a M o t o r ( ) 
{estadoMotor=false;}
 public boolean motor( ){ return estadoMotor;}
}
Se o código abaixo for executado, pode-se dizer 
que:
public class Teste {
 public static void main(String[] args) {
 Carro c=new Carro();
 c.cor="Preto";
 }
}
( ) O objeto c não pode ser instanciado, pois não 
há construtor na classe.
( ) Será gerado erro de compilação pois há erro 
de sintaxe em: c.cor="Preto";
( ) O código é executado normalmente, pois c é 
uma instancia da mesma classe que o atributo.
( X ) Será gerado um erro de compilação, pois o 
atributo é private.
( ) Será gerado erro de execução pois o tipo do 
atributo está em desacordo com o valor atribuído.
 2a Questão (Ref.: 201102334851)
Dada a instrução: Pessoa p = new Pessoa(), 
assinale a alternativa que represente melhor o que 
acontece quando esta instrução é interpretada.
( ) está sendo criada uma variável primitiva 
chamada Pessoa que está sendo associada a um 
novo objeto.
( ) está sendo criada uma variável primitiva 
chamada p que está sendo associada a um novo 
objeto.
( ) está sendo criada uma variável de referência 
chamada Pessoa, que está sendo associada a um 
objeto do tipo Pessoa.
( X ) está sendo criada uma variável de referência 
chamada p do tipo Pessoa, que está sendo 
associada a um objeto do tipo Pessoa que está 
sendo criado e instanciado para a memória heap da 
JVM.
( ) está sendo criada uma variável de referência 
chamada Pessoa, que está sendo associada a uma 
nova variável primitiva.
 3a Questão (Ref.: 201102335347)
Dado o seguinte modelo:
 
Marque a alternativa que define a classe Pessoa.
( )
public Pessoa { 
private int codigoPessoa; 
private String nome; 
private String endereco; 
private int telefone; 
}
( X ) 
public class Pessoa { 
private int codigoPessoa; 
private String nome; 
private String endereco; 
private int telefone; 
}
( )
public Pessoa { 
public static main (String args[]) { 
private int codigoPessoa; 
private String nome; 
private String endereco; 
private int telefone; 
} 
}
( )
public class Pessoa { 
public static main (String args[]) { 
private int codigoPessoa; 
private String nome; 
private String endereco; 
private int telefone; 
} 
}
( ) 
public Pessoa { 
public static main (String args[]) { 
private codigoPessoa int; 
private nome String; 
private endereco String; 
private telefone int; 
} 
}
AULA 7
INTERFACES E POLIMORFISMO
Nesta aula, você irá:
1.Explorar o pacote swing para desenvolverinterfaces em java.
2.Criar e manipular menus.
3.Utilizar interfaces gráficas, interagindo com 
objetos e classes previamente definidos.
4.Apresentar o conceito de polimorfismo. utilizar 
classes abstratas.
5.Aplicar as interfaces, criando menus e os 
conceitos de polimorfismo em exemplos e 
exercícios.
As interfaces gráficas em Java
O Java fornece uma infinidade de funcionalidades 
para prover comunicação humano-computado, ou 
melhor, para desenvolver interfaces. São fornecidas 
duas bibliotecas para desenvolver um GUI. Elas 
são:
- java.awt : Abstract Window Toolkit (classes 
básicas);
- javax.swing : Swing Componets – Fornece um 
conjunto de components alternativos, mais 
funcionais que os conjuntos fornecidos pela 
java.awt. 
Essas bibliotecas são fornecidas pelo JFC.
Java Foundation Classes
Componentes atômicos
São elementos ou componentes que não permitem 
conter outros elementos. Podemos citar, dentre 
outros, botões, labels, textFields, sliders, check 
boxes, scrollbars, etc.
JLabel
São rótu los es tát i cos que, gera lmente, 
ap r e sen t am f unc i ona l i d ades de ou t r o s 
componentes GUI, como por exemplo, campos de 
texto, ícones etc. Também, serve para apresentar 
um pequeno texto. As instruções são mostradas 
por meio de uma linha de texto: somente leitura, 
uma imagem ou ambas. O construtor mais 
elaborado é JLabel (String, Icon, int). Os 
argumentos representam o rótulo a ser exibido, 
um ícone e o alinhamento, respectivamente. 
Também, é possível a exibição de ícones em muito 
dos componentes Swing. Para JLabels, basta 
especificar um arquivo com extensão png, gif ou 
jpg no segundo argumento do construtor do 
JLabel, ou utilizar o método setIcon(Icon), o 
arquivo da imagem algumNome.xxx deve 
encontrar-se no mesmo diretório do programa, ou 
especifica-se corretamente a estrutura de 
diretórios até ele. 
As constantes SwingConstants, que definem o 
posicionamento de vários componentes GUI e aqui, 
são apropr iadas ao terce i ro argumento, 
determinam a locação do ícone em relação ao 
texto. São elas: 
• SwingConstants.NORTH, 
• SwingConstants.SOUTH, 
• SwingConstants.EAST, 
• SwingConstants.WEST, 
• SwingConstants.TOP, 
• SwingConstants.BOTTOM, 
• SwingConstants.CENTER, 
• SwingConstants.HORIZONTAL, 
• SwingConstants.VERTICAL, 
• SwingConstants.LEADING, 
• SwingConstants.TRAILING, 
• SwingConstants.NORTH EAST, 
• SwingConstants.NORTH WEST, 
• SwingConstants.SOUTH WEST, 
• SwingConstants.SOUTH EAST, 
• SwingConstants.RIGHT, 
• SwingConstants.LEFT
Botões
• É um componente que tem o comportamento 
semelhante ao de um botão real, quer dizer, ao 
clicarmos ou apertarmos o botão, uma ação é 
executada. Um programa Java pode utilizar 
vários tipos de botões, incluindo botões de 
comando, caixas de marcação, botões de 
alternância e botões de opção. Para se criar 
algum desses tipos de botões, deve-se 
instanciar uma das muitas classes que 
descendem da classe AbstractButton, a qual 
define muito dos recursos que são comuns aos 
botões do Swing. Este comportamento 
semelhante ao mundo real ajuda aos usuários 
na compreensão da interface.
•
• JButton
– É um dos componentes mais familiares e 
intuitivos ao usuário. Os botões de comando 
são criados com a classe JButton e seu 
pressionamento geralmente dispara a ação 
especificada em seu rótulo, que também 
suporta a exibição de pequenas imagens. 
Ao pressionar o botão, é gerado um evento 
ActionEvent que, juntamente com outros 
eventos, executam algum comando 
desejado. Estudaremos a fundo este 
comportamento na próxima aula (aula 8).
JCheckBox
• A classe JCheckBox dá suporte à criação de 
botões com caixa de marcação, sendo que 
qualquer número de itens pode se selecionado. 
• Quando um item é selecionado, um ItemEvent 
é gerado. 
• O mesmo pode ser tratado por um objeto que 
implemente a interface ItemListener. A classe 
que fornece as funcionalidades para este objeto 
deve definir o método itemStateChanged.
JRadioButton
• Os botões de opção, que são definidos na 
classe JRadioButton, assemelham-se às 
caixas de marcação no que concerne aos seus 
estados (selecionado ou não selecionado). 
Entretanto, costumeiramente são usados em 
grupo no qual apenas um botão de opção pode 
ser marcado, forçando os demais botões ao 
estado não-selecionado.
JTextField / JPasswordField
• Compreende a área de uma única linha que 
suporta a inserção ou exibição de texto. Pode-
se definir se o texto pode ser manipulado com 
o método setEditable(boolean), utilizando no 
argumento o valor true. Quando o usuário 
digita os dados em uma JTexField e pressiona 
Enter, ocorre um evento de ação. Esse evento é 
processado pelo ouvinte de evento registrado 
que pode usar os dados que estão no JTexField 
no momento em que o evento ocorre. Estes 
procedimentos serão mais bem abordados na 
aula 8.
JTextArea
• É uma área dimensionável que permite que 
múltiplas linhas de texto sejam editadas com a 
mesma fonte. Esta classe é herdada de 
JTextComponent, que define métodos 
comuns para JTextField, JTextArea e outros 
elementos GUI baseados em texto.
JComboBox
• Assemelha-se a um botão, porém, quando 
clicado, abre uma lista de possíveis valores ou 
opções. Mais precisamente é uma caixa de 
combinação que permite ao usuário fazer uma 
seleção a partir de uma lista de itens. Atende-
se para que a lista da caixa de combinação, 
quando aberta, não ultrapasse os limites da 
janela da aplicação. Também é possível digitar 
nas linhas de uma caixa de combinação. Elas 
são implementadas com a classe JComboBox, 
herdada de JComponent. Tais caixas de 
combinação geram ItemEvents, assim como 
as JCheckBoxes.
Menus
• Os menus, que são instanciados a partir da 
classe JMenu, são anexados a uma barra de 
menus com o método add(JMenu) de 
JMenuBar, sendo que instâncias dessa última 
classe comportam-se como containers para 
menus. A classe JMenuBar fornece os 
métodos necessários ao gerenciamento da 
barra onde os menus são anexados. A 
ordenação dos mesmos depende da ordem em 
que foram adicionados, sendo que são 
“empilhados” horizontalmente da esquerda 
para a direita. Evidentemente, só pode-se 
anexar menus a janelas da classe JApplet, 
JDialog, JFrame e JInternalFrame, e faze-se 
i s s o u s a n d o - s e o m é t o d o 
s e t JMenuBa r ( J M e n u B a r ) . A c l a s s e 
JMenuItem capacita a criação de itens de 
menu que, por sua vez, devem ser anexados a 
um menu. Pode-se usar um item de menu para 
executar alguma ação ou para gerir o 
acionamento de um submenu, o qual fornece 
mais itens que estão relacionados por alguma 
característica comum.
Passo a Passo para Montagem de Menu
1. Instancie um JMenuBar. Ele é o responsável 
pela estrutura do menu.
2. Adicione tantos JMenu’s quantos forem 
necessários para as opções.
1. Dentro de cada JMenu, coloque o 
JMenuItem, que é o responsável pela 
opção a ser escolhida.
Código para montar a barra de menus
jMenuBar1.setName("jMenuBar1"); // NOI18N
 jMenu1.setText("Arquivo")); // Aba Arquivo da 
barra de opções
 jMenu1.setName("jMenu1"); // NOI18N
 jMenuItem1.setText("Abrir")); // Opção Abrir do 
menu
 jMenuItem1.setName("jMenuItem1"); // NOI18N
 jMenu1.add(jMenuItem1);
 jMenuItem2.setText("Editar")); // Opção Editar do 
menu
 jMenuItem2.setName("jMenuItem2"); // NOI18N
 jMenu1.add(jMenuItem2);
 jMenuItem3.setText("Salvar")); // Opção Ajuda 
do menu
 jMenuItem3.setName("jMenuItem3"); // NOI18N
 jMenu1.add(jMenuItem3);
jMenuBar1.add(jMenu1); //Inclui o menu Arquivoo 
na barra de menus
jMenu2.setText("Ajuda")); // Aba Ajuda da barra 
de opções
 jMenu2.setName("jMenu2"); // NOI18N
 jMenuItem4.setText("Ajuda")); // Opção Ajuda do 
menu
jMenuItem4.setName("jMenuItem4"); // NOI18NjMenu2.add(jMenuItem4);
jMenuItem6.setText("Pesquisa")); // Opção 
Pesquisa do menu
jMenuItem6.setName("jMenuItem6"); // NOI18N
jMenu2.add(jMenuItem6);
jMenuItem5.setText("Sobre")); // Opção Sobre do 
menu
jMenuItem5.setName("jMenuItem5"); // NOI18N
jMenu2.add(jMenuItem5);
jMenuBar1.add(jMenu2); //Inclui o menu Ajuda na 
barra de menus
jMenu3.setText("Sair")); // Aba Sair da barra de 
opções
 jMenu3.setName("jMenu3"); // NOI18N
 jMenu3.add(jMenuItem7);
 jMenuBar1.add(jMenu3); //Inclui o menu Sair na 
barra de menus
Criando telas Polimórficas
• Para aplicar os conceitos de classe abstrata, 
criação de telas, herança e polimorfismo, 
iremos fazer uma classe genérica de cadastro 
que possa ser utilizada para várias classes de 
negócio.
• Para este sistema funcionar, precisamos 
construir uma tela de cadastro com uma barra 
de menus. Esta tela se liga a TelaCad. 
Dependendo da opção escolhida no menu, a 
tela de cadastro terá o comportamento de 
cadastro de Clube ou cadastro de Sócio. Isso é 
uma aplicação de polimorfismo.
Criando telas Polimórficas
• As telas acima são herdadas de telaCad. Mas, 
cada uma contém um painel que determina as 
peculiaridades de cada cadastro.
• Todas as funcionalidades comuns são descritas 
em TelaCad, enquanto que as necessidades 
particulares são re-escritas
Nesta aula, você: 
•Explorou o pacote swing, desenvolvendo 
interfaces em java.
•Criou e manipulou menus.
•Utilizou interfaces gráficas interagindo com 
objetos e classes previamente definidos.
•Identificou o conceito de polimorfismo. utilizou 
classes abstratas.
•Aplicou os conhecimentos, construindo exemplos 
de interfaces, criando menus.
•Desenvolveu e executou pequenos programas 
com orientação a objetos, com o pacote swing 
associadas a objetos.
REGISTRO DE PARTICIPAÇÃO
1. Quantas bibliotecas de GUI existem em Java:
1) Uma: Swing. 
2) Duas: AWT e Swing. 
3) Nenhuma. O Java não suporta GUI. 
4) Mais de duas bibliotecas. 
 
2. O Componente JLabel serve para:
1) Entrada de Dados. 
2) Entrada de Senha. 
3) Apresentar uma etiqueta com um texto. 
4) Medir o tempo. 
 
3. O JCheckBox é um componente que serve para:
1) Entrada dados com apenas uma resposta certa. 
2) Saída de dados com múltiplas alternativas. 
3) Saída de dados com uma única resposta certa. 
4) Ent rada de dados com múl t ip las 
alternativas; 
 
AULA 8
LISTENERS E ADAPTERS
Nesta aula, você irá:
1.Apresentar os conceitos de listener e os 
tratamentos de eventos.
2.Apresentar os adapters que implementam 
as interfaces de eventos.
3.Utilizar interfaces gráficas, interagindo, com 
objetos e classes previamente definidos, 
com listeners e adapter.
4.Explorar o conceito de tratamento de 
eventos em exemplos e exercícios.
Eventos
Evento é um acontecimento relevante no meio 
externo ao sistema relevante. Pode ser considerado 
como o resultado da interação do usuário com 
algum componente GUI. Mover o mouse, clicá-lo, 
digitar num campo de texto, selecionar um item de 
menu, fechar uma janela, clicar num botão etc. são 
interações que enviam eventos para o programa, 
normalmente realizando serviços. 
Eventos também podem ser gerados em resposta a 
modificações do ambiente. Em outras palavras, 
definem-se eventos GUI como mensagens 
(chamadas a métodos) que indicam que o usuário 
do programa interagiu com um dos componentes 
GUI.
Um sistema orientado a objetos é definido como 
um conjunto de objetos interagindo ou trocando 
mensagens. Os eventos representam as ações dos 
atores nesse processo ou alguma resposta a uma 
mudança de estado.
Tratamento de Eventos
Quase todos os componentes propagam eventos. 
Esses eventos devem ser tratados em algum ponto 
do código da aplicação. Os eventos nunca são 
tratados no próprio componente (dado que não se 
tem acesso ao código do componente). Para ligar o 
código do tratamento de eventos ao componentes 
existem, no Java, um conjunto de interfaces 
chamadas listeners. Um listener é uma interface 
que especifica os métodos que uma aplicação deve 
ter para ser notificada da ocorrência de um 
determinado evento. Os componentes que geram 
eventos permitem que sejam adicionados ou 
removidos listeners em qualquer altura. 
O modelo de eventos do Java funciona da seguinte 
forma: 
O componente que produz eventos possui métodos 
especiais do tipo addXXListener(XXListener) que 
permite adicionar ou remover listeners. XX 
representa o nome do evento. O método 
addXXListener recebe, por parâmetro, o objeto que 
implementa a interface XXListener.
A implementação do método addXXListener no 
componente apenas adiciona o objeto, passado por 
parâmetro a uma lista interna. Sempre que ocorrer 
um evento (exp.: botão pressionado), o 
componente percorre a lista e invoca, para cada 
elemento, o método definido na interface 
XXListener. 
No exemplo seguinte é construída uma GUI simples 
com um botão e uma caixa de texto. Sempre que o 
botão é pressionado a aplicação deve escrever na 
caixa de texto um número inteiro aleatório. Para 
processar os eventos, é necessário analisar os 
eventos que o botão produz. É preciso saber que, 
sempre que um botão é pressionado, é criado um 
evento do tipo ActionEvent. 
Para adicionar listeners, a classe que representa o 
botão (JButton) possui um método chamado 
addActionListener, que recebe por parâmetro um 
objeto que implemente a interface ActionListener. 
Na API, vê-se que a interface ActionListener 
especifica um método chamado actionPerformed.
Resumindo
• ActionEvent – evento gerado pelo botão 
quando pressionado. Sempre que o botão 
for pressionado, este irá percorrer a sua 
lista interna de listeners, chamando para 
cada um, o método actionPerformed; 
• ActionListener– interface que especifica 
os objetos que tratam eventos do tipo 
ActionEvent; Existem várias soluções 
possíveis para tratar o evento: 
– Recorrendo à própria classe (GUI) – a 
aplicação gráfica tem de implementar 
os listeners necessários; 
– Recorrendo a classes locais – é criada 
uma classe local que implementa os 
listeners necessários; 
– Recorrendo a classes internas – é 
criada uma classe dentro da GUI. A 
classe interna implementa os listeners 
necessários; 
– Recorrendo a classes anônimas – 
cr iam-se c lasses anônimas que 
implementem os listeners dos eventos 
a tratar. As classes anônimas são 
classes internas especiais;
Utilizando a própria classe
import javax.swing.*;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Random;
 
public class EventosGUI_1 extends JFrame 
implements ActionListener {
 
 private JTextField texto;
 private JButton bCriar, bApagar;
 private Random gerador;
 
 public static void main(String[] args) {
 EventosGUI_1 gui = new 
EventosGUI_1("Tratamento eventos na 
própria classe");
 }
 
 public EventosGUI_1(String titulo) {
 super(titulo);
 gerador =new Random();
 adicionaComponentes();
 /* Faz com que a janela seja 
dimensionada para caber os seus 
subcomponentes.*/
 pack();
 setVisible(true);
 }
private void adicionaComponentes() {
 // Cria um painel onde irá guardar os 
componentes
 JPanel painelPrincipal = new JPanel();
 // Adiciona uma legenda
 JLabel label = new JLabel("Número 
aleatório: ");
 painelPrincipal.add(label);
 // Adiciona o campo de texto com 20 
colunas
 // O campo de texto não pode ser 
editado
 texto = new JTextField(20);
 texto.setEditable(false);
 painelPrincipal.add(texto);
 // Adiciona um botão que cria o 
número
 bCriar = new JButton("Criar");
 painelPrincipal.add(bCriar);
 // Adiciona um botão que apaga o 
número
 bApagar =new JButton("Apagar");
 painelPrincipal.add(bApagar);
 // Adiciona o painel principal