Apostila JAVA - Pronatec

Prévia do material em texto

JavaJava
IntermediárioIntermediário
 
Fortaleza, junho/2014
Sumário
Introdução.............................................................................................................................................5
Capitulo 1.O que é a linguagem java....................................................................................................6
1.1.- Histórico da linguagem............................................................................................................6
1.2.Uso da linguagem no mercado atualmente(especificação das tecnologias)..............................7
1.3.Principais características da linguagem de programação java...................................................7
1.4. Ambientes e ferramentas de desenvolvimento com java........................................................11
1.4.1. Instalação do JDK ou SDK e JRE e suas configurações.................................................11
1.5.Meu primeiro programa em java..............................................................................................11
1.5.1.Comentários em Java:......................................................................................................13
1.5.2.Compilando meu primeiro programa em Java.................................................................13
1.5.3.Dicas para resolução de problemas em programas java...................................................14
1.6.Erros comum em programas java............................................................................................15
1.6.1.Erros em java:..................................................................................................................15
1.6.2.Erro em tempo de compilação :.......................................................................................15
1.6.3.Erro em tempo de execução:............................................................................................15
1.7.Netbeans...................................................................................................................................15
1.8.Visão de outras IDEs para o desenvolvimento com java.........................................................16
1.8.1.IDE Eclipse......................................................................................................................16
1.8.2.A IDE Bluej......................................................................................................................16
1.8.3.A IDE Gel.........................................................................................................................16
1.8.4.A IDE Jdeveloper.............................................................................................................16
1.9.Identificadores e palavras-chaves............................................................................................17
1.10.Tipos primitivos:....................................................................................................................18
1.10.1.Uso de valores literais de todos os tipos de dados existentes........................................18
1.10.1.1.Literais Inteiros:.....................................................................................................19
1.10.1.2.Literais decimal:.....................................................................................................19
1.10.1.3.Literais octal:..........................................................................................................19
1.10.1.4.Literais hexadecimal:.............................................................................................19
1.10.1.5.Literais de ponto flutuante:.....................................................................................20
1.10.1.6.Literais booleanos:.................................................................................................21
1.10.1.7.Literais de caracteres:.............................................................................................21
1.10.1.8.Literais para String:................................................................................................22
1.11.Operadores em Java:..............................................................................................................22
1.11.1.Operadores de atribuição composto...............................................................................23
1.11.2. Operadores de comparação...........................................................................................24
1.11.3.Igualdade de tipos primitivos :.......................................................................................24
1.11.4.Igualdade de variáveis de referências:...........................................................................25
1.11.5.Operador Instanceof:......................................................................................................25
1.11.6.Operador concatenação de strings:.................................................................................26
1.12. Operadores aritméticos.........................................................................................................27
1.12.1.Operador resto (%) :.......................................................................................................27
1.12.2.Operadores de Incremento e Decremento:.....................................................................28
1.12.6.OBS: A diferença que nesse caso podemos visualizar os resultados, 5,4 e 3;...............28
1.12.7.Exercício resolvido........................................................................................................29
1.12.8.Operadores relacionais:..................................................................................................29
1.12.9.Operadores lógicos.........................................................................................................29
1.12.10.Os operadores Bitwise :...............................................................................................30
1.12.11. Operadores lógicos de abreviação:..............................................................................30
1.12.12.Operadores lógicos ^ e !:..............................................................................................31
1.12.13.Operadores condicionais..............................................................................................31
1.12.14.Operador Ternário........................................................................................................32
1.12.15. Precedência de Operadores.........................................................................................33
Capitulo 2.Controle de fluxo em java.................................................................................................34
2.1.Utilizar código que use instruções if........................................................................................34
2.1.1.Expressões válidas para instruções if...............................................................................34
2.1.2.Expressões válidas para instruções if-else.......................................................................35
2.1.3. Expressões válidas para instruções if-else-if...................................................................36
2.2.Expressões válidas para instruções switch e case....................................................................37
2.3.Loops e iteradores (usando os loops for, while e do while).....................................................39
2.3.1.Loop do while:.................................................................................................................40
2.3.2.Loop for:..........................................................................................................................41
2.4. Loop for aprimorado (para arrays)..........................................................................................422.5.Uso de break, continue e return...............................................................................................43
2.5.1.Break:...............................................................................................................................43
2.5.2.Continue:..........................................................................................................................44
2.5.3.Return:..............................................................................................................................45
Capitulo 3.Tipos de Variáveis, Constantes e Casting.........................................................................46
3.1.O que é uma variável :.............................................................................................................46
3.1.1.Tipos de Variáveis:...........................................................................................................46
3.2. Variáveis estáticas:..................................................................................................................47
3.3. Constantes...............................................................................................................................48
3.4.Conversão ou Cast (explícita e implícita das variáveis de tipos primitivos)...........................48
3.5. Atribuindo uma variável de referência a outra.......................................................................51
3.5.1. Escopo de variáveis.........................................................................................................51
3.5.2.Variáveis de instâncias de tipos primitivos......................................................................51
Capitulo 4.POO com Java..................................................................................................................52
4.1.Introdução................................................................................................................................52
4.2.Classe, Atributos e Métodos....................................................................................................53
4.3.Construindo uma Classe..........................................................................................................54
4.4.Encapsulamento.......................................................................................................................54
4.5.Retorno.....................................................................................................................................55
4.6.Construtores, métodos seteres e geteres..................................................................................55
4.6.1.Construtores.....................................................................................................................55
4.6.2.Métodos seteres e geteres.................................................................................................55
4.7.Estanciando (Construindo um Objeto)....................................................................................56
4.8.Variáveis Estáticas...................................................................................................................56
Concluímos então que as variáveis estáticas não pertencem especificamente a nenhuma instancia de
objeto e sim uma referencia da classe. O que explica a substituição do termo “this” para o nome da 
classe que que contém a variável estática, no exemplo acima alteramos o termo “this” no método 
setOndeVivo pelo nome da classe que contém a variável estática (Pessoa)......................................57
4.9.Métodos Estáticos....................................................................................................................57
Capitulo 5.Herança e Interface...........................................................................................................58
5.1.Introdução................................................................................................................................58
5.2.Herança....................................................................................................................................58
5.3.Object: A superclasse cósmica do java....................................................................................59
5.3.1.Construtores da subclasse................................................................................................63
5.3.2.Classe Abstrata.................................................................................................................63
5.4.Interface...................................................................................................................................65
Capitulo 6.Herança (Polimorfismo )..................................................................................................66
6.1.Introdução................................................................................................................................66
6.2.Sobrecarga................................................................................................................................66
6.3.SobreEscrita.............................................................................................................................66
6.4.Polimorfismo...........................................................................................................................67
Capitulo 7.Tratamento de Exceções...................................................................................................69
7.1.Capturando uma exceção usando o bloco (try e catch)...........................................................69
7.1.1.Finally..............................................................................................................................70
7.1.2.Lançado uma exceção com o throws...............................................................................71
7.1.3.Criando uma exceção com throw.....................................................................................71
Capitulo 8.UML.................................................................................................................................73
8.1.Introdução................................................................................................................................73
8.1.1.Diagrama de Atividade:...................................................................................................73
8.1.2.Diagrama de Sequencia....................................................................................................73
8.1.3.Diagrama de Caso de Uso................................................................................................73
8.1.4.Diagrama de Classe..........................................................................................................73
8.2.Abrindo o Projeto.....................................................................................................................74
Capitulo 9.Fila e Pilha........................................................................................................................76
9.1.Fila...........................................................................................................................................76
9.1.1.Implementando Fila em Java...........................................................................................76
9.2.Pilha.........................................................................................................................................78
9.2.1.Implementando Pilha em Java.........................................................................................78
Capitulo 10.Coleções: List e Map......................................................................................................80
10.1. Introdução a Coleções/Collections.......................................................................................8010.2. Collection List ou Coleção Lista..........................................................................................82
10.3.ArrayList................................................................................................................................83
10.3.1.Criando uma Lista em Java usando a Classe ArrayList.................................................84
10.3.2.Adicionando elementos em uma Lista...........................................................................84
10.3.3.Removendo elementos de uma Lista..............................................................................86
10.3.4.Acessando elementos da Lista.......................................................................................87
10.3.5.Pesquisando elementos na Lista.....................................................................................90
10.4. Collection Map ou Coleção Mapa........................................................................................91
10.5.HashMap................................................................................................................................92
10.5.1.Criando uma coleção do tipo Mapa usando a Classe HashMap....................................92
10.5.2.Adicionando elementos em uma coleção do tipo Mapa.................................................93
10.5.3.Removendo elementos em uma coleção do tipo Mapa..................................................94
10.5.4.Selecionando/Pesquisando elementos em uma coleção do tipo Mapa...........................95
10.5.5.Número de elementos em uma coleção do tipo Mapa...................................................95
Capitulo 11.Interface Gráfica com Usuário – GUI.............................................................................97
11.1.Interface Gráfica com usuário - GUI.....................................................................................97
11.2.Bibliotecas AWT e SWING...................................................................................................98
11.3.JFrame....................................................................................................................................98
11.3.1.Camadas JFrame............................................................................................................98
11.3.2.Nossa primeira Janela com JFrame................................................................................99
11.4.Criando uma classe com propriedades JFrame....................................................................100
11.5. JLabel..................................................................................................................................102
11.6. JButton................................................................................................................................103
11.7. JTextField............................................................................................................................104
11.8. Icon.....................................................................................................................................105
11.9. Editando fonte com o setFont()...........................................................................................106
11.10.JMenuBar, JMenu e JMenuItem........................................................................................106
11.11.JCheckBox.........................................................................................................................108
11.12.JRadioButton......................................................................................................................109
11.13.JComboBox........................................................................................................................110
11.14.Mais Componentes Swing..................................................................................................111
Capitulo 12.Gerenciadores de Layout..............................................................................................112
12.1. Gerenciadores de Layout....................................................................................................112
12.2. BorderLayout......................................................................................................................113
12.3.BoxLayout............................................................................................................................114
12.4.FlowLayout..........................................................................................................................115
12.5.GridLayout...........................................................................................................................116
12.6.GridBabLayout....................................................................................................................117
Capitulo 13.Eventos (Listeners).......................................................................................................118
13.1.ActionListener......................................................................................................................118
13.2.FocusListener.......................................................................................................................120
13.3.KeyListener..........................................................................................................................121
13.4.MouseListener.....................................................................................................................122
Bibliografia.......................................................................................................................................123
Introdução
Essa   apostila     tem   como   objetivo   ajudar   ao   aluno   na   disciplina   de   Introdução   a
Programação Orientada a Objetos do nosso curso,visto que o requisito básico para que se
possa alcançar todos os objetivo do nosso curso nesta
disciplina é que o aluno tenha passado pela disciplina
de   Introdução   a   Lógica   de   Programação   para
Computadores.   Mas   não   nos   atearemos   em
barrá­los,sem   o   pré­requisito   básico,isso   porque
confiamos   e   acreditamos   na   capacidade   dos   nossos
alunos que com muitas força,dedicação e vontade de
vencer   na   vida,conseguirá   ultrapassar   qualquer
preconceito contra o acesso ao conhecimento tecnológico. 
O nosso objetivo principal com este material é capacitar o aluno para um entendimento
critico a respeito do Paradigma de Programação Orientada a Objetos. Visto que é uma das
tendência atualmente no mercados usar esse paradigma no desenvolvimento de sistemas
em geral. 
Aliado   ao   Software   Livre   que   é   uma   tendência   e   uma   alternativa   para   o  mundo
corporativo no que se refere a softwares,e que também tem sido
atualmente desenvolvido por programadores espalhados ao redor
mundo,sendo   que   boa   parte   dessas   tecnologias   veem   sendo
desenvolvidas   utilizando   ferramentas   livres   na  maioria   de   seus
projetos, contribuindo para os avanços e colaborando para o acesso
de milhares de pessoas as inclusões digitais no que tange as tecnologias da informação no
mundo.  Daremos   também a  nossa   disciplina  uma   ênfase  maior   no  uso  desse   tipo  de
tecnologia,passando para os nossos alunos um modelo e uma alternativa fantástica,que é a
utilização das ferramentas livres disponíveis na internet. 
Primeiramente vamos estudar um pouco sobre a história da linguagem de programação
java  que   iremos  utilizar  na  nossa  disciplina.  Relatamos  as   características  principais  da
linguagem que para muitos ainda é desconhecido, ou seja,conhecer a ferramenta antes de
dominá­la é de estrema importância para os futuros programadores.  
Obrigado professor! Eu sou o Tutor e os ajudarei, respondendo
as perguntasque forem surgindo ao longo do nosso curso, mas,
algumas     dessas   perguntas   se   dirija   ao     Instrutor   que   deverá
auxiliar meus colegas de sala, os alunos!
Alias professor, por onde começaremos a estudar  java?Nos dê
uma dica!Calma!Muita calma meus colegas. Porque o ejavashow
ainda vai começar. Apresentaremos nesta apostilas no final de cada
capítulo   uma   lista  muitos   dos   exercícios,que  muitas   vezes   são
aparentemente   repetitivos   e   até   mesmo   redundantes.   Isso   é
proposital:   se  o   estudante  conseguir   resolver  um dos  exercícios
aparentemente repetidos, poderá deduzir a solução de outros mais facilmente. A criação de
vários exercícios aparentemente redundantes também facilita ao instrutor na criação de
listas   de   exercícios   distintas   e   complementares.
É claro! Começaremos a estudar sobre os fundamentos de programação e falaremos em
seguida sobre as estruturas básicas da linguagem java.
Curso Java SE - UTD 6
Capitulo 1.O que é a linguagem java.
Bem vindos  ao   futuro!   Java  não  é   somente  uma  linguagem de  programação,  mas   sim uma
tecnologia  que  tem como objetivo  construir  programas que possam ser  utilizados  em qualquer
plataforma ou computador, com o mínimo possível de dependência com um sistema operacional ou
ambiente de desenvolvimento. Java possui uma sintaxe extremamente similar à do C++, e com
diversas características herdadas de outras linguagens,como Smalltalk e Modula­3. É antes de tudo é
uma boa linguagem,simples,com um ambiente de execução de alta qualidade e uma vasta biblioteca
de classes disponíveis.  Essa combinação é  que  torna Java uma proposta   irresistível para tantos
programadores.   Além   de   contar   com     as   seguintes   características,totalmente   orientada   a
objetos,fortemente   tipada,   independente  de  arquitetura,robusta,segura,portável,bem estruturada,
suporta programação distribuída, multithreaded e conta com garbage collection.
1.1. ­  Histórico da linguagem.
Em 1991, na empresa Sun MicroSystems ,foi iniciado o Green Project, o berço do Java uma
linguagem de  programação  orientada   a   objetos.  Os  mentores  do  projeto   eram Patrick
Naughton, Mike Sheridan, e James Gosling. O objetivo do projeto não era a criação de uma
nova linguagem de programação, mas antecipar e planejar a “próxima onda” do mundo
digital.   Eles   acreditavam   que   em   algum   tempo   haveria   uma   convergência   dos
computadores com os equipamentos e eletrodomésticos comumente usados pelas pessoas
no seu dia a dia.
James Gosling especificou uma nova linguagem de programação para o seu novo projeto
e   decidiu   batizá­la   de   “Oak”,   que   quer   dizer   carvalho,   uma
árvore que ele podia observar quando olhava pela sua janela. O
próximo passo era encontrar um mercado para o *7. A equipe
achava que uma boa ideia seria controlar televisões e vídeo por
demanda   com   o   equipamento.   Eles   construíram   um   demo
chamado MovieWood, mas infelizmente era muito cedo para que
o   vídeo  por  demanda  bem  como  as   empresas  de  TV  a   cabo
pudessem viabilizar o negócio. A ideia que o *7 tentava vender,
hoje   já   é   realidade   em   programas   interativos   e   também   na
televisão   digital.   Permitir   ao   telespectador   interagir   com   a
emissora e com a programação em uma grande rede a cabos,era
algo  muito  visionário  e  estava  muito   longe do  que as  empresas  de  TV a cabo  tinham
capacidade de entender e comprar.
O protótipo se chamava *7 (leia­se “StarSeven”),um controle remoto   com uma interface
gráfica   touchscreen.  Para  o  *7   foi   criado um mascote,  hoje  amplamente  conhecido  no
mundo  Java,  o  Duke.  O   trabalho  do  Duke  no  *7  era   ser  um guia  virtual  ajudando  e
ensinando o usuário a utilizar o equipamento. O *7 tinha a habilidade de controlar diversos
dispositivos e aplicações.
 A ideia certa, na época errada. A sorte é que o bom da Internet aconteceu,e rapidamente
uma grande rede interativa estava se estabelecendo. Era este tipo de rede interativa que a
equipe do *7 estava tentando vender para as empresas de TV a cabo. E, da noite para o dia,
não era mais necessário construir a infraestrutura para a rede, em um golpe de sorte, ela
simplesmente estava  lá.  Gosling foi   incumbido de adaptar o Oak para a  Internet e em
janeiro   1995   foi   lançada   uma   nova   versão   do  Oak   que   foi   rebatizada   para   Java.   A
tecnologia Java  tinha sido projetada para se mover por meio das redes de dispositivos
6
Curso Java SE - UTD 7
heterogêneos,redes como a Internet. Agora aplicações poderiam ser executadas dentro dos
Browsers nos Applets Java e tudo seria disponibilizado pela Internet instantaneamente. Foi
o estático HTML dos Browsers que promoveu a rápida disseminação da dinâmica tecnologia
Java.  A velocidade dos  acontecimentos   seguintes   foi  assustadora,o  número de  usuários
cresceu rapidamente, grandes players, como a IBM anunciaram suporte para a tecnologia
Java.   
1.2. Uso   da   linguagem   no   mercado   atualmente(especificação   das
tecnologias). 
    Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais rapidamente do
que qualquer outra linguagem de programação na história da computação. Em 2003 Java atingiu a
marca de 4 milhões de desenvolvedores em todo mundo. Java continuou e continua crescendo e
hoje é  com certeza um padrão  para o mercado oferecendo qualidade, performance e segurança
ainda   sem nenhum competidor  a  altura.  Atualmente  Java   é   a  escolha  para   construir   sistemas
robustos, confiáveis e distribuídos,rodando desde grandes servidores,por isso tornou­se popular pelo
seu   uso   na   Internet   e   hoje   possui   seu   ambiente   de   execução  presente   em   web   browsers,
mainframes, SOs, celulares, palmtops e cartões inteligentes,entre outros dispositivos.   
1.3. Principais características da linguagem de programação java
ORIENTAÇÃO A OBJETOS: Java é uma linguagem orientada a objetos que segue a linha
purista  iniciada por  Smalltalk  que é  considerada puramente O.O   e que tudo nesta são
objetos. Com a exceção dos tipos primitivos da linguagem (char, int, float, etc.), a maior
parte dos elementos de um programa java são objetos.
No que rege esse paradigma,o projeto orientado a objetos é
uma técnica de programação que se concentra nos dados( =
objetos)   e   nas   interfaces   para   este   objeto.   O   código   é
organizado   em   classes,   que   podem   estabelecer
relacionamentos de herança simples entre si, somente a herança simples é permitida em
java. Há uma forma de "simular" herança múltipla em Java com o uso de interfaces. 
SIMPLICIDADE:  Java, é muito parecida com   C++,mas muito mais simples. Java não possui
sobrecarga de  operadores,   structs,  unions,  aritmética  de ponteiros,  herança múltipla,arquivos.h,
diretivas  de  pré­processamento e  a  memória  alocada dinamicamente é  gerenciada pela  própria
linguagem,que usa algoritmos de garbage collection para desalocar regiões de memória que não
estão mais em uso. Outro aspecto da simplicidade do Java é o tamanho pequeno. Um dos objetivos
do Java é  permitir  a construção de software que possa rodar  independentemente em qualquer
máquina de pequeno porte. O tamanho do interpretador básico e do suporte a classes é de cerca de
40K bytes; adicionando as bibliotecas básicas padrão e o suporte a linhas de execução
(essencialmente um microkenel auto­contido),têm­se outros 175 K.
SEGURA: Java foi elaborada para ser usada em ambientes de rede distribuída, por
isso permite a construção de sistemas livres de vírus e intrusões. A presença de coleta
automática de lixo, evita erros comuns que os programadores cometem quando são
obrigados a gerenciar diretamente a memória  (C, C++, Pascal ). 
A eliminação do uso de ponteiros,  em favor do uso de vetores,objetos e
outras estruturassubstitutivas   traz benefícios em termos de segurança. O programador é
proibido de obter acesso a memória que não pertence ao seu  programa, além de não ter
chances   de   cometer   erros   comuns   tais   como   “reference   aliasing”   e   uso   indevido   de
aritmética de ponteiros. Estas medidas são particularmente úteis  quando
pensarmos em aplicações comerciais desenvolvidas para a internet.
7
Curso Java SE - UTD 8
ROBUSTA:  Java foi  elaborada para a produção de programas que devam ser confiáveis em
vários sentido. Java põe bastante ênfase na verificação rápida de possíveis problemas,na verificação
dinâmica posterior(em tempo de execução),e em eliminar situações propensas a erros. A principal
diferença   entre   Java   e   C/C++   é   que   Java   possui   um  modelo   de   ponteiros   que   elimina   a
possibilidade de sobrescrever a memória e corromper dados. 
PROCESSAMENTO DISTRIBUÍDO:  A linguagem de programação Java possui uma extensa
biblioteca de rotinas para lidar com protocolos TCP/IP,como HTTP e FTP. As aplicações Java podem
abrir e acessar objetos através da rede via URLs,com a mesma facilidade com que acessa um sistema
de arquivos local.
MULTITHREADING: Múltiplas linhas de execução. Em  Java é uma surpresa agradável e fácil.
Linhas de execução em Java podem também beneficiar­se  de sistemas multiprocessadores   se  o
sistema operacional de base o fizer. O lado ruim é que as implementações de linhas de execução nas
plataformas  mais   importantes  diferem radicalmente,e  o  Java  não   faz  nenhum esforço  para   ser
neutro em relação as plataformas nesse aspecto. Somente o código para chamar o  multhreading
permanece o mesmo para todas as máquinas.
EXCEÇÕES:  Todo   programador   em   geral   está   bastante   acostumado   com   o   computador
"travando" por causa de um erro em um programa. Em C++, por exemplo, a simples tentativa de
abertura   de   um   arquivo   inexistente   pode   obrigar   ao   programador   a   reiniciar   o   computador.
Programas Java, contudo, não "dão pau" no computador, já que a máquina virtual Java faz uma
verificação em tempo de execução quanto aos acessos de memória,abertura de arquivos e uma série
de eventos que podem gerar uma "travada" em outras linguagens, mas que geram exceções em
programas   Java.   Em   geral,   ao   escrever   programas   Java   utilizando­se   de   herança   de   classes
predefinidas, força­se em geral ao programador escrever algumas rotinas de tratamento de exceção,
um trabalho que, se de início pode parecer forçado, irá poupar o programador de bastante dor de
cabeça no futuro.
GARBAGE   COLLECTOR:  Em   Java,   os   programadores   não   necessitam   preocupar­se   com   o
gerenciamento   de   memória   como   em   C++.   Em   C++,   todo   bloco   de   memória   alocado
dinamicamente   (com  new,   malloc   ou   função   similar)   deveria   ser   liberado
quando  não   fosse  mais   usado   (com  free,   delete   e   parentes   próximos).   Isso
acarretava  diversos  problemas  mesmo ao  programador  mais   experiente,   que
tinha  que manter   sempre  um controle  das  áreas  de  memória  alocadas  para
poder  liberá­las  em seguida.  Java,  ao contrário,  utiliza­se  de  um conceito   já
explorado pela linguagem Smalltalk, que é o de  garbage collection  (coleta de
lixo).  Sua  função é  a  de  varrer  a  memória  de   tempos  em tempos,liberando
automaticamente os blocos que não estão sendo utilizados. Se por um lado isso
pode deixar o aplicativo um pouco mais lento, por manter uma thread paralela
que   dura   todo   o   tempo   de   execução   do   programa,evita   problemas   como
referências perdidas e avisos de falta de memória quando sabe­se que há megas
e megas disponíveis na máquina.
COMPILADA  E  INTERPRETADA: Uma das características de Java que tornou­a ideal para
seu uso na elaboração de aplicativos distribuídos foi a sua independência de plataforma. Isso porque
o compilador gera um formato de arquivo de objetos neutro em relação a arquitetura,o código
compilado é executável em vários processadores,desde que haja a presença do sistema em tempo de
8
Curso Java SE - UTD 9
execução Java. O compilador java consegue isso gerando instruções bytecode que não tem nada a
ver com uma arquitetura computacional específica. Ao contrário eles são elaborados para ser de
fácil   interpretação   em  qualquer  máquina   e   de   fácil   tradução   para   código   de  máquina   nativo
imediatamente.
MÁQUINA VIRTUAL : É uma máquina imaginária que é implementada através de um
software emulador em uma máquina real.
A JVM provê especificações de plataforma de hardware na qual compila­se todo código
de tecnologia Java. Essas especificações permitem que o software Java seja uma plataforma
independente pois a compilação é feita por uma máquina genérica conhecida como JVM.
  PORTÁVEL:  Ao contrário do C e C++ que não
existem   aspectos   da   especificação   que   sejam
dependentes da implementação. Os tamanhos dos
tipos   de   dados   primitivos   são   especificados,bem
como   o   comportamento   da   aritmética   neles.   Por
exemplo   em   Java   um   int   é   sempre   um   número
inteiro   de   32   bits,enquanto   que   em  C/C++,   int
pode significar um inteiro de 16 bits ou um inteiro
de   32   bits.   Com   o   tamanho   fixo   para   tipos
numéricos elimina­se a causa de grande dores de
cabeça   relacionadas   a   portabilidade.   A
portabilidade   em     java   é   atingida   através   da
utilização de bytecodes. Bytecode é um formato de
código intermediário entre o código fonte, o texto que o programador consegue manipular,
e   o   código   de  máquina,   que   o   computador   consegue   executar.  Na   plataforma   Java,o
9
Curso Java SE - UTD 10
bytecode é interpretado por uma máquina virtual Java. A portabilidade do código Java é
obtida à medida que máquinas virtuais Java estão disponíveis para diferentes plataformas.
Assim, o código java que foi compilado em uma máquina pode ser executado em qualquer
máquina   virtual   Java,independentemente   de   qual   seja   o   sistema   operacional   ou   o
processador que executa o código. 
JAVA E A INTERNET:   Os   programas java que rodam em páginas web são chamados applets.
Para usar applets,  você  precisa de um navegador web habilitado para Java,o qual executará  os
bytecodes   para   você.   Em   particular   servidores   de   aplicação   podem   usar   as   capacidades   de
monitoramento da máquina virtual java para realizar o equilíbrio automático de carga,controle de
conexões a banco de dados,sincronização de objetos,desligamento e reinicialização seguros,além de
outros serviços necessários para aplicações escaláveis de serviços,mas que são notoriamente difíceis
de   se   implementar   corretamente.   Em   java,é   possível   escrever   aplicações   completas,inclusive
acessando bancos de dados relacionais independentemente do servidor web,bem como é possível
implementar os níveis de interface com o usuário e de lógica do negocio,utilizando um servidor de
banco de dados para implementar o nível de acesso aos dados.
Distribuição da tecnologia java: O J2SE (Java 2 Standard Edition) ou Java SE é uma
ferramenta   de   desenvolvimento   para   a   plataforma   Java.   Ela   contém  todo  o   ambiente
necessário para a criação e execução de aplicações Java, incluindo a máquina virtual Java
(JVM), o compilador Java, as APIs do Java e outras ferramentas utilitárias.
JME,   java   Plataforma,Micro   Edition   (Java   ME),ainda   conhecida   por   J2ME,   é   uma
tecnologia   que   possibilita   o   desenvolvimento   de   software   para   sistemas   e   aplicações
embarcadas,   ou   seja,   toda   aquela   que   roda   em   um   dispositivo   de   propósito
específico,desempenhando alguma tarefa que seja útil para o dispositivo.  É a plataforma
Java para dispositivos compactos, como telemóveis, PDAs, controles remotos,e uma outra
gama de dispositivos.
Java   EE  (ou   J2EE,   ou   Java   2   Enterprise   Edition,   ou   em   português   Java   Edição
Empresarial)   é   uma   plataforma   de   programação   de   computadores   que   faz   parte   da
plataforma   Java.  O   JEE   (Java  Enterprise  Edition)   é   a   plataforma   Java   voltada   para
redes,internet, intranets e afins. Assim,ela contém bibliotecas especialmente desenvolvidas
para   o   acesso   a   servidores,a   sistemas   de   e­mail,a   banco   de   dados,etc.   Por   essas
características,o JEE foi desenvolvido para suportar uma grande quantidade de usuários
simultâneos.  A   plataforma   JEE   contém   uma   série   de   especificações,cada   uma   com
funcionalidades distintas. Que  são:
 JDBC (Java Database Connectivity), utilizado no acesso a banco de dados.
 JSP   (Java  Server  Pages),um   tipo   de   servidor  Web.   Os   servidores   web   são   as
aplicações que permitem a você acessar um site na internet.
 Servlets,para o desenvolvimento de aplicações Web,isto é,esse recurso "estende" o
10
Curso Java SE - UTD 11
funcionamento dos servidores web,permitindo a geração de conteúdo dinâmico nos
sites.
1.4.  Ambientes e ferramentas de desenvolvimento com java.
A tecnologia java fornece como ambiente de desenvolvimento um grande conjunto de
ferramentas   que   engloba:   um   compilador,um   interpretador,um   gerador   de
documentação,ferramenta de empacotamento de classes de arquivos e outros.
1.4.1.   Instalação do JDK ou SDK e JRE e suas configurações.
A   Sun   a   empresa   proprietária   do   Java     que   atualmente   pertence   a   empresa   (Oracle).   Ela
disponibiliza, basicamente, duas versões de sua máquina
virtual: o JRE (Java Runtime Environment) e JDK (Java
Development Kit). O JRE contém a máquina virtual que
permite   rodar  programas   feitos  na   linguagem Java   em
uma  máquina.  O   JDK,   por   sua   vez,é   um   pacote   para
desenvolvedores  programarem suas aplicações em Java,
possuindo   vários   utilitários,   inclusive   compilador   e
bibliotecas. Uma das versões mais usadas do Java foi a
1.4.x, que possuía inclusive um visual um pouco (para ser
modesto) rústico. Mais para frente a Sun lançou a versão
1.5.0, com várias melhorias em termos de programação e
um visual um pouco melhor. Foi lançado em dezembro do
de 2006 o Java 1.6.0, conhecido também como Java 6,
que   trouxe,finalmente,uma   integração   total   com   o
desktop em termos visuais,e várias melhorias também para quem é programador. 
  Mustang é o nome dado para a nova versão 6 de Java,que saiu no final do ano passado.
Entre as novidades mais conhecidas estão o suporte a linguagens de script, melhores ferramentas
para o monitoramento de aplicações Java e mais integração com o sistema operacional. Mas o qual
é realmente a diferença entre o JDK e Java SDK? : O kit de desenvolvimento para java (Sofware
Development Kit). Trata­se de um conjunto de softwares para programadores em java que você não
precisa   instalar   se   sua   intenção   for   apenas   usar   os   programas   feitos   em   java.   Para   rodar   os
programas em java basta instalar o JRE (Java Runtime Environment) .
 http://www.guiadohardware.net/tutoriais/java­linux/ 
1.5.Meu primeiro programa em java
Como java é uma linguagem que é primeiramente compilada e em seguida interpretada.
Para   compilar     e   executar   um programa  escrito  nessa   linguagem devemos  o  primeiro
construir o arquivo como o código fonte,que deve ter como extensão .java. Que no caso do
exemplo o arquivo foi chamado de HelloWorld.java. Em seguida,o código fonte é compilado
e um programa fonte em bytecodes (HelloWorld.class) é gerado. Durante a compilação, há
uma checagem de erros do código fonte. O fonte em bytecodes só será gerado se nenhum
erro tiver  sido detectado.  Por  fim, qualquer  dispositivo que execute  java será  capaz de
interpretar   este   novo   arquivo   fonte   e   executar   a   aplicação.  Os   bytecodes   são   lidos   e
executados   (ou   seja,   interpretados)   pela   Máquina   Virtual   Java   (JVM   –   Java   Virtual
Machine)   em   um   computador,em   um   celular,   etc.,   além  de   serem   independentes   de
plataforma.
11
Curso Java SE - UTD 12
A geração dos bytecodes ou, para o exemplo, do arquivo HelloWorld.class é feita a partir
da execução do comando javac HelloWorld.java. Então, o próximo passo é fazer com que
a JVM execute o arquivo HelloWorld.java, através do comando  java HelloWorld.class  .
Dessa  maneira,a   JVM traduz o  código  compilado para  uma  linguagem que a máquina
entenda e o programa é  executado,por  isto os  programas em java podem executar em
qualquer plataforma de hardware ou software que possua uma versão da JVM. A Máquina
Virtual java é definida como uma máquina imaginária implementada através da emulação
em um software executado em uma máquina real. Ela possui uma arquitetura que permite
garantir segurança. Quando um programa Java é executado,seus bytecodes são verificados
pela JVM para que estejam de acordo com os seus requisitos de segurança,impedindo a
execução de código com alguma irregularidade. Assim,códigos­fonte com instruções que
acessem   áreas   restritas   da   memória   ou   até   mesmo   recursos   do   hardware   não   são
executados pela JVM.
A palavra public indica que a classe terá um nível de acesso público, ou seja, que ela será
acessível por qualquer classe. A palavra class indica que uma classe está sendo declarada e
seu nome é HelloWorld. A {  delimita o limite inicial da classe.
A   palavra  public  já   foi   descrita,   portanto   permite   que   o   método   seja   acessado
publicamente. A palavra  static  será descrita posteriormente. O lugar onde fica a palavra
void é onde se deve indicar o tipo de retorno do método. Neste caso, não retorna nenhum
valor, dessa maneira o método é declarado como void. O conjunto String[] args presentes
entre  (   )  são   os   argumentos   do  método.   Neste   exemplo,o  método   possui   um  único
argumento (um vetor de Strings denominado args. A { delimita o limite inicial do método. 
A   terceira   linha consiste  no  conteúdo do  método  principal,   formado  apenas  por  um
comando,ou uma instrução que é composta de uma ou mais linhas terminadas por ponto e
vírgula. Exemplo:
O  System.out.println  é   usado   para   exibir   algo   na   saída   padrão,   por   padrão,   na   linha   de
comando. Será exibido o que tiver entre (“”), no caso,Hello world. No final deste comando, tem­se
um; que o finaliza. Por fim,há duas “fecha chaves”   }   }  , que delimitam o fim do método e da
classe,respectivamente.
Blocos de código: Um bloco é formado
por 
uma   ou   mais   instruções   agrupadas
entre chaves indicando que formam uma
só unidade. Blocos podem ser organizados em estruturas aninhadas
Indefinidamente.  Qualquer quantidade de espaços em branco é permitida. Um exemplo
de  bloco código mostrado ao lado ilustra perfeitamente como são organizadas as estruturas de
12
Curso Java SE - UTD 13
blocos.
1.5.1.Comentários em Java:
Comentários são notas escritas pelo programador para fins de documentação. Estas notas
não fazem parte do programa e não afetam o fluxo de controle. Java suporta três tipos de
comentários:   comentário   de   linha   estilo   C++,comentário   de   bloco   estilo   C   e   um
comentário estilo Javadoc (utilizado compor a documentação do programa).
Comentário  de linha:  Comentários  com estilo  em C++ se  iniciam por "//".  Todo e
qualquer texto colocado após as // é ignorado pelo compilador e tratado como comentário.
Por exemplo:
Comentário de bloco: Comentários com estilo em C,também chamados de comentários
multi­linhas,se   iniciam com  /*  e   terminam com  */.  Todo  o   texto  posto  entre  os  dois
delimitadores é tratado como comentário. Diferente do comentárioestilo C++, este pode
se expandir para várias linhas. Por exemplo:
Comentário estilo Javadoc:  Este comentário é utilizado na geração da documentação
em HTML dos programas escritos em Java. Para se criar um comentário em estilo Javadoc
deve se iniciar o comentário com  /**  e terminá­lo com  */.  Assim como os comentários
estilo  C,  este   também pode conter  várias   linhas.  Este   comentário   também pode conter
certas tags que dão mais informações à documentação. Por exemplo:
 
1.5.2. Compilando meu primeiro programa em Java
1°­ Passo: Para compilarmos o nosso primeiro programa em Java utilizamos o seguinte comando
javac  seguindo   do   nome   da
classe (ponto) .java
2°­ Passo: Para executarmos o
nosso primeiro programa em Java utilizamos o seguinte comando Java, seguido do nome da classe.
Nesse   segundo   exemplo   vamos   usar   um   editor   de   texto   qualquer   para   editor   o
código­fonte do nosso segundo exemplo e vamos compilar usando terminal(Konsole) do
13
Curso Java SE - UTD 14
sistema operacional.
Compilando nosso 2° exemplo com o comando     → javac
Executando nosso 2° exemplo com o comando    → java
Obs.: Cuidados importantes a serem tomados: 
■  Se o javac reclamar que não acha a classe HelloWorld.java,é porquê você não está  no
diretório correto ou salvou o arquivo em outro lugar.
     ■ Se o javac reclamar de algum erro no fonte,é porque você digitou algo errado. Não troque
letras maiúsculas por minúsculas e vice­versa, em nenhuma parte do código! 
■ Finalmente, ANTES de chamar o seu instrutor para ele inserir um ; ou fechar uma chave
no seu código, revise mais uma vez o seu código completamente.
1.5.3. Dicas para resolução de problemas em programas java
■  Se  digitar  o  programa na  mão,certifique­se de prestar  atenção as   letras  maiúsculas  e
minúsculas. Em particular um nome de classe por exemplo.
■  Se receber uma mensagem como “Bad command or file name” ou “javac command not
found”,volte e verifique novamente a sua instalação,em particular a configuração do caminho de
execução.
■ O compilador requer um nome de arquivo (Teste.java) por exemplo. Quando você rodar o
programa,você especifica um nome de classe (Teste) sem a extensão .java nem .class.
■ Se o compilador javac relatar um erro “connot read”: “Teste.java” ,você deve verificar se
esse arquivo está presente no diretório.
■  Se houver erros demais em seu programa,todas as mensagens de erros voarão pela sua
tela muito rapidamente.  O compilador envia as mensagens de erro para a saída padrão;então,é um
pouco complicado capturá­las se elas ocuparem mais espaço do que a janela pode exibir.   
14
Curso Java SE - UTD 15
1.6. Erros comum em programas java
1.6.1.Erros em java: 
Durante o desenvolvimento de programas,é muito comum que erros podem ocorrer,em java
pode ser em dois domínios: tempo de compilação e tempo de execução.
1.6.2. Erro em tempo de compilação :
Erros ocorridos durante a fase de compilação ocorrem quando se executa o javac, e são fáceis de
corrigir. Há dois tipos:
■ Erros de processamento do arquivo (parsing): ponto e vírgula faltando,parênteses,
aspas, chaves ou colchetes descasados. Identifica apenas o arquivo e a linha onde o erro
pode ter iniciado. Um erro causa vários outros e nem sempre a mensagem é precisa.
■  Erros de compilação do código,realizada depois do parsing: além da linha e do
arquivo, identificam a classe e método. Geralmente as mensagens são bastante elucidativas.
1.6.3. Erro em tempo de execução: 
Erros que   ocorrem durante o tempo de execução (runtime) ocorrem  quando se executa o
interpretador java, e são muito mais difíceis de localizar e consertar.
■  Exception in thread "main": NoClassDefFoundError: Classe: a classe "Classe" não
foi encontrada no CLASSPATH.
■   Exception in thread "main": NoSuchMethodError: main: o sistema tentou chamar
main() mas não o encontrou.
■   ArrayIndexOutOfBoundsException:   programa   tentou   acessar   vetor   além   dos
limites definidos,ou negativo.
■   NullPointerException: referência para objeto é nula,ou variável de um tipo objeto
foi declarada mas não inicializada.
1.7.Netbeans
O termo IDE em inglês,que quer dizer(Integrated
Development  Environment).  O NetBeans  IDE é  um
ambiente   de   desenvolvimento   integrado   e   está
disponível  para  Windows,  Mac,  Linux  e  Solaris.  O
projeto   NetBeans   consiste   em   um   IDE   de
código­fonte aberto e uma plataforma de aplicações
que   permitem   que   os   desenvolvedores   criem
rapidamente aplicativos web, corporativos, desktop e
aplicações móveis utilizando a plataforma Java,bem como JavaFX, PHP, JavaScript e Ajax Ruby e
Ruby on Rails  , Groovy e Grails,  e C / C + +.  O projeto do NetBeans é  apoiado por uma
vibrante   comunidade   de   desenvolvedores   e   oferece   uma   extensa   documentação   e
treinamento de recursos, bem como uma diversificada seleção de terceiros plugins . 
IDE 6.9 introduz o JavaFX, Compositor uma ferramenta visual para construção de layout
visual JavaFX aplicativos, interface gráfica semelhante ao construtor de GUI Swing para
aplicações   Java.   SE   NetBeans   Outros   destaques   incluem   OSGi   Plataforma   de
interoperabilidade para aplicações NetBeans e apoio para o desenvolvimento de bundles
OSGi com Maven, o apoio à JavaFX SDK, Framework Zend para PHP e Ruby on Rails 3.0,
15
Curso Java SE - UTD 16
bem como melhorias no editor de Java, Java Debugger problema de rastreamento,e muito
mais. Para baixar o netbeans acesse o site do link:
http://www.netbeans.org/
1.8. Visão de outras IDEs para o desenvolvimento com java 
1.8.1.IDE Eclipse
O  Eclipse  é   uma   IDE   para   o   desenvolvimento   aplicações
Java,ele   também   pode   ser   usado   para   o   desenvolvimento   de
aplicações utilizando outras linguagens como PHP, C++, etc. O
Ambiente de desenvolvimento multi  linguagens de programação
cujo projeto é patrocinado pela IBM. É bastante flexível e integra
com   vários   projetos   bastante   comuns   na   comunidade   java   tais   como   cvs
(versionamento),ant(scripts) e junit (testes unitários). Não possui ainda um bom editor visual de
interface gráfica. O atual, chamado visual editor (VE) funciona com SWT e Swing mas ainda está na
versão 0.5.  O desenvolvimento J2EE é  viável com o uso de plugins obtidos de terceiros.  Nesta
apostila não iremos nos aprofunda nessa IDE,mas pode baixar e instalar no seu sistema par criar
seus projeto de programação com java usando a IDE Eclipse. O Eclipse atualmente encontra­se na
versão   3.6   chamada   de   HELIOS,para   baixá­lo   acesse   o   seguinte   link   ao   lado:
http://www.eclipse.org/ 
1.8.2. A IDE Bluej
BlueJ  é   um   ambiente   de   desenvolvimento   java   projetado
especificamente para o ensino em um nível introdutório. BlueJ foi
projetado e implementado pelas equipes das universidade Monash 
University,Melbourne,Australia  e   The   University   of   Southern
Denmark,Odense. Maiores informações sobre BlueJ estão disponíveis no
site  oficial   (http://www.bluej.org).  O  BlueJ  é   um excelente  ambiente
para o fim a que se destina: a aprendizagem da programação orientada pelos objetos utilizando a
linguagem Java. No entanto e especialmente quando é  utilizada uma linguagem muito popular
como   a   linguagem   Java,o   desenvolvimento   de   programas   é   feito   utilizando   IDEs  muito  mais
complexos e sofisticados. Tal é necessário para lidar com a complexidade de muitos dos programas
atuais.
Estes  atingem  frequentemente  dezenas de  milhares  de  linhas de  código e,  em alguns  casos,
muitas, muitas mais. Tal implica a utilização de várias ferramentas de auxílio ao desenvolvimento
de código.  BlueJ 3.0.4,uma versão de manutenção que  inclui  uma série  de  correções  de  erros
importantes,está agora disponível para download. 
1.8.3. A IDEGel
É  um editor  pequeno e  rápido.Escrito  em Delphi  para computadores  com Windows.  Destaca
sintaxe   para   java,jsp,xml,   html   entre   outras   gramáticas,   facilita   o   gerenciamento   de   projetos,
mantém histórico local de mudanças, possui suporte a CVS, JUnit e Ant entre outras facilidades.
Livre   para   uso   comercial.Mais   informações   sobre   essa   IDE   visite   o   site:
http://www.dukeduck.com.br/
1.8.4. A IDE Jdeveloper
Uma   das   principais  opções  open   source,uma   terceira   boa   opção
16
Curso Java SE - UTD 17
existe desde que a Oracle tornou seu IDE Jdeveloper totalmente gratuito. Isso devido ao
fato   de   a   Oracle   tornar  open   source  dois   frameworks   de   desenvolvimento   Java:   o
mecanismo   de   persistência   Oracle   TopLink   (se   tornou   a   base   da   implementação   de
referência   JPA   do   Glassfish)   e   os   componentes   JavaServer   Faces   (JSF)   Oracle   ADF
Faces,parte do Oracle Aplication Development Framework. São dois ótimos recursos e o seu
uso no desenvolvimento está totalmente integrado e suportado no Oracle JDeveloper.
O Oracle   JDeveloper  é   assim uma opção gratuita  abrangente  e  amadurecida  para  o
desenvolvimento Java corporativo,principalmente em ambientes onde produtos Oracle já
são utilizados (Database Server,BI,Application Server,Portal). http://www.oracle.com/
Nota: Muito bem! A partir daqui fica a critério de seu instrutor a utilização ou não de uma
IDE de desenvolvimento de software durante o curso da nossa disciplina. Uso de uma IDE
vai   nos   facilitar   em  muito   pontos   importantes,dentre   eles   a   aproximação   com   uma
ferramenta   utilizada   no   mercado   de   trabalho   atualmente,vai   tornar   o   aluno   mais
preparado para enfrentar as dificuldades decorrentes de programar em um simples editor
de texto e prompt,mas,também é muito importante que vocês aprendam a compilar seus
programa   no   Console(prompt   de   comandos)para   daí   então   ficarem   habilitados   a
seguerem programando em java.  Fica ai o recado e bons trabalhos.Vamos usar a IDE
netbeans. Segue um toturial sobre o netbeans que será repassado antes.
1.9. Identificadores e palavras­chaves.
Java   é  uma  linguagem  centrada   nos   pacotes;   os   desenvolvedores   da
linguagem assumiram que,   para  uma  boa  organização  de  nomes,   seria
fundamental   na   estrutura   de   programas   em   java.   Imagine   o   seguinte
pesadelo:três   programadores,na   mesma   empresa,mas   trabalhando   em
diferentes  partes  de um projeto,escrevem cada um uma classe chamada
Utilitários. Se essas três classes Utilitários não tiverem sido declaradas em
nenhum pacote explícito, e estiverem no classpath,não seria possível dizer ao compilador
ou à JVM qual das três classes está tentando referenciar. 
Identificadores legais são regras que o compilador usa para determinar se um dado nome
é   legal.   Em   Java,os   identificadores   devem   ser   compostos   apenas   por   caracteres.
Unicode,números,símbolos de moedas e caracteres de conexão como underscore. 
Regras válidas:
■  Devem iniciar com uma letra,símbolo comercial cifrão ($) ou underscore (_);
■   Após o primeiro carácter podem ter qualquer combinação de letras, caracteres e
números;
■  Não possuem limite de tamanho;
■  Não podem ser palavras reservadas restritas da linguagem;
■    Em   Java   os   identificadores   são  case­sensitive  isto   é,   “JAVA”   é   totalmente
diferente de “java”  isso porque o compilador diferencia maiúsculos de minúsculos.
17
Curso Java SE - UTD 18
Palavras­chave  : São identificadores que, em Java, foram pré­definidas com propósitos
específicos.  Não se  pode usar  esses   identificadores  como nomes  de variáveis,  métodos,
classes, etc. A seguir, temos a lista com as palavras­chave em Java.
Nota: true, false e null não são palavras­chave, porém, são palavras reservadas, e,  da
mesma maneira, não  é permitido seu uso na atribuição a nomes de variáveis, métodos ou
classes.
1.10.Tipos primitivos:
Todo programa de computador deve ser capaz de lidar com dados para conseguir fazer
seus   processos   como,   por   exemplo,   somar,
multiplicar, dividir, etc. Usar atributos é a melhor
forma de manipular os dados. Os tipos de dados
são o que definem a quantidade de memória  do
computador   que   será   utilizado   para   guardar   tal
dado. As variáveis primitivas pode ser declaradas
como   variáveis   de   classe(static),   variáveis
instâncias,   parâmetros   de   métodos   ou   variáveis
locais. Uma vez declarado, seu tipo primitivo não
pode nunca ser modificado,embora na maioria dos
casos seu valor possa se modificar. Java é um linguagem fortemente tipada. Isso significa
que toda variável deve ter um tipo declarado. Existem oito tipos primitivos em java. Quatro
deles são do tipo inteiros; dois são do tipo de números de ponto flutuante; um é o tipo de
caracteres char,usado para unidades de código no esquema de codificação Unicode e um
deles é do tipo lógico para valores true/false(verdadeiro/falso).
1.10.1. Uso de valores literais de todos os tipos de dados existentes.
Um  literal  primitivo é  simplesmente a representação do código­fonte dos tipos dados
primitivos em outros palavras um inteiro,um número de ponto flutuante,um boolean ou
caracteres que você digite enquanto escreve um código.
18
Curso Java SE - UTD 19
1.10.1.1. Literais Inteiros:
Há  três maneiras de representar números na linguagem Java: decimal (base 10), octal
(base 8) e hexadecimal (base 16).
1.10.1.2. Literais decimal: 
Os  inteiros   decimais   não   precisam  de   explicação,eles   são   representados   da  maneira
tradicional,sem prefixo de nenhum tipo, como no exemplo abaixo:
1.10.1.3. Literais octal: 
Os inteiros octais usam somente dígitos de 0 a 7. Em Java, o inteiro é representado na
forma octal com a inclusão de um zero na frente do número, veja o exemplo abaixo:
1.10.1.4. Literais hexadecimal:
 Os números hexadecimais são construídos com o uso de 16 símbolos distintos. Já que
não foram criados símbolos numéricos unitários para os algarismos que vão de 10 a 15,
usamos caracteres alfanuméricos para representar esses dígitos.
Na Java linguagem todos os literais inteiros(octal, decimal e hexadecimal) são definidos
como int (ou seja inteiros) por padrão, mas também podem ser representados como Long
com a inclusão de um sufixo L ou l depois do número: 
Exemplos.
19
Curso Java SE - UTD 20
Os  tipos  de  dados  inteiros  que são os  mais  conhecidos e  mais  simples.  Em Java,  os
números inteiros são divididos em quatro tipos: byte, short, int e long.
O  tipo byte é o de menor alcance entre os inteiros. Como o próprio nome sugere, ele
consome apenas um byte (8 bits) e pode guardar valores entre ­128 e 127.
O tipo short guarda inteiros de 2 bytes (16 bits) e pode guardar números entre ­32.768 a
32.767.
O tipo int é o tipo de dado mais comum. Ele consome 4 bytes (32 bits) e guarda valores
entre ­2.147.483.648 e 2.147.483.647.
Long é o tipo de dado com maior alcance entre os inteiros. Consequentemente,também é
o que ocupa mais espaço (8 bytes ou 64 bits).  Tem um grande alcance que fica entre
­9,22E+18   (exatos   ­9.223.372.036.854.775.808)   e   9,22E+18   (exatos
9.223.372.036.854.775.807).
1.10.1.5. Literais de ponto flutuante:
Os números de ponto flutuante são definidos com um número,um símbolo decimal e os
outros números que representam a fração. Para número decimais fracionários com grande
precisão   ou   valores   extraordinários   (geralmente   utilizados   em  matemática   aplicada   e
complexa como cálculos físicos, químicos, astrológicos, meteorológicos, etc) utilizamos o
tipo de dado double. 
Double é o tipo de dado mais complexo que existe em Java e o maior valor possível de se
armazenar é  1,797.693.134.862.315.7E+308.Muito mais do que qualquer programador
precisa.
20
Curso Java SE - UTD 21
Float os literais de ponto flutuante são definidos Double (64 bits) por padrão,portanto,se
desejarmos atribuir um literal de ponto flutuante a uma variável float (32 bits), terá que
anexar o sufixo F ou f ao número. Se não o fizer, o compilador reclamará de uma possível
falta de precisão,porque estará tentando inserir em um container (potencialmente) menos
preciso. 
1.10.1.6. Literais booleanos: 
Os literais booleanos são a representação do código­fonte para valores boolean. Um valor
boolean só poderá ser definido como true ou false. 
1.10.1.7. Literais de caracteres: 
O literal char é representado por um único caractere entre aspas simples. Eles podem
também   representar   valores   Unicode   do   caractere,usando   a   notação   Unicode   que
acrescenta o prefixo \u ao valor,atribuir um literal numérico,contanto que ele esteja no
intervalo de 16 bits sem sinal (65535 ou menor).
  Válidos:
 
 
Inválidos:
21
Curso Java SE - UTD 22
1.10.1.8. Literais para String: 
O literal de string é a representação do código­fonte para o valor de um objeto String.
Embora as strings não sejam primitivas,foram incluídas neste capitulo porque são utilizadas
para   representar   valores   literais,em   outras   palavras,digitadas   diretamente   no   código.
Veremos mais sobre Strings no capitulo 9.
Exemplo 01:
1.11.Operadores em Java:
Os  operadores  em  Java  produzem novos   valores   a
partir   de   um   ou  mais  valores  ,os   quais   são   itens   á
esquerda   ou   a   direita   do   operador.   O   resultado   da
maioria das operações é um valor boleano ou numérico.
É   importante   lembrar   que   na   linguagem  Java   não   é
possível sobrecarregar os operadores. Um dos objetivos
da linguagem java é a portabilidade. por isto muitos processadores da intel computam x * y
e deixam em registrador de 80 bits,em seguida dividem por z  e  finalmente  truncam o
resultado de volta para 64 bits. Isso pode gerar um resultado mais preciso e pode evitar o
estouro de exponentes. Mas o resultado pode ser diferente de uma computação que usa 64
bits o tempo todo. 
Por  esse  motivo  a   especificação   inicial  da  máquina  virtual   java  exigia   que   todas   as
computações   fossem  truncadas.  Não   somente   as   computações   truncadas  podem causar
estouro,como   também   são,na   verdade     mais   lentas   do   que   as   computações   mais
precisas,porque a operação de truncamento é demorada. Por essa razão, a linguagem de
programação java foi atualizada para reconhecer as exigências conflitantes de desempenho
otimizado e reprodutibilidade perfeita.
22
Curso Java SE - UTD 23
1.11.1. Operadores de atribuição composto.
Os  operadores  de   atribuição
compostos   permitem   que   os
programadores preguiçosos economizem
algum   trabalho   de   digitação.   Na
verdade, existem cerca de 11 operadores
de atribuição composto,mas apenas os 4
mais comumente usados são:(+= , ­= ,
*= , /= ).
Exemplo sem usar operador composto:
Exemplo usando operador composto:
Nota: Importante lembrar que as duas atribuições mostradas dão no mesmo resultado
que as duas primeiras.
23
Curso Java SE - UTD 24
1.11.2.     Operadores de comparação. 
■   = =  igual a. 
■   ! =  diferente de. 
Na linguagem java são utilizados dois operadores de comparação(chamados também de
operadores de igualdade ou desigualdade) que compara dois itens semelhantes e retornam
um valor booleano que representa o que é verdadeiro sobre os dois itens serem iguais.
Exemplo utilizando o operador de igualdade:
 
Exemplo 02:
Exemplo utilizando o operador de diferente:
Exemplo 02:
1.11.3. Igualdade de tipos primitivos : 
A  maioria  dos programadores java estão familiarizados com a comparação de valores
primitivos. Isso porque cada comparação pode envolver dois valores números (incluindo o
tipo char),dois valores booleanos ou duas variáveis de referências de objetos. O que não
pode ser comparado: não é possível comparar tipos dados incompatíveis,por exemplo se um
tipo boolean é igual a um tipo char. Existem quatro tipos de itens que podemos testar:
■   Números 
■ Caracteres 
■   Tipos booleanos primitivos 
■    Variáveis de referências de objeto; porém é importante lembrar que o operador
(==) examina o valor da variável,ou seja o padrão de bits. 
24
Curso Java SE - UTD 25
1.11.4. Igualdade de variáveis de referências: 
As variáveis de referências podem ser testadas com o operador (==) para sabermos se
estão referenciando um objeto em comum. Mas é muito importante ressaltar que o mesmo
operador estará  examinando os bits  da
variável,portanto   com   relação   as
variáveis  de   referências,   se  os  bits  das
duas   variáveis   forem   idênticos,   elas
estarão   referenciando   (apontando)   o
mesmo objeto.
Neste exemplo do código acima, foi criado três variáveis de referência a partir da classe
Funcionário. As duas primeiras f1 e f2, são objetos de Funcionário diferentes, que por acaso
tem o mesmo valor inicial, a terceira variável de referência f3,é inicializada para referenciar
o mesmo objeto que a variável f1 está referenciando. O operador == não testará se dois
objetos   são   significativamente   equivalentes,isso   porque   ele   compara   os   bits   das
variáveis,então as referência de memórias das variáveis não soa iguais. 
1.11.5. Operador Instanceof: 
Permite­nos saber se um objeto pertence a uma classe ou não,ou seja se o objeto passa no
teste é­um. Este operador é usado somente com variáveis de referências de objetos, e pode
ser empregado para verificar se um objeto é do tipo específico. Quando tratamos de tipos,
queremos dizer tipo de interface ou classe. Em outras palavras,se o objeto referenciado pela
variável à esquerda do operador passaria no teste é­um do tipo de interface ou classe do
lado direito do operador.
Sintaxe do operador instanceof:
if (tipo_1  instanceof  tipo_2)
 {
      /**bloco de código aqui...*/
 }
25
Curso Java SE - UTD 26
 Exemplo 01.
Exemplo 02.
Nota: Neste exemplo acontece um erro de compilação;isso porque a variável  [ e ] é do
tipo String e não do tipo Funcionário,nesse caso as classes não participam da árvore de
herança.
Exemplo 03: 
1.11.6. Operador concatenação de strings:
 O sinal de adição(+) também pode ser usado para concatenar duas strings. Se um dos
valores   for   uma  String,  o  operador  +  atuará   como  um operador  de   concatenação  de
Strings. E se os dois valores forem números, o operando + funcionará como o operador de
adição.
 Exemplo 01.
Resultado  do   código   acima,   executado   dentro  de  uma   classe   que   possua  o  método
main().
26
Curso Java SE - UTD 27
Exemplo 02. Resultado do código será mostrado ao lado,executado dentro de uma classe
que possua o método main().
1.12.  Operadores aritméticos.
Eles podem ser usados da maneira padrão. Exemplos: 
1.12.1. Operador resto (%) : 
O operador resto da divisão divide o operando a esquerda pelo direito com o resultado
sendo o resto dessa divisão.
27
Curso Java SE - UTD 28
1.12.2. Operadores de Incremento e Decremento:
 São os operadores que nos permitem incrementar as variáveis em uma unidade. Podem
ser   usados   diante   ou   atrás   da   variável   dependendo   das   necessidades,   ou   seja,   se
precisarmos que se incremente ou vice­versa antes de utilizar ou o contrário.
Exemplo 01:
OBS: 
• R1 temos o resultado = 5, pois nesse caso, primeiro imprimimos o valor original da
variável, logo em seguida incrementamos o valor.
• R2 temos o resultado = 6, pois nesse caso, mostramos a variável incrementada pelo
comando interior, porém nesse momento não alteramos o valor da variável.
• R3 temos o resultado = 7, pois nesse caso,    incrementamosprimeiro a variável,
depois mostramos a variável incrementada.
Podemos ter um processo semelhando com o decremento.
Exemplo 02:
1.12.3.
1.12.4.
1.12.5.
1.12.6. OBS: A diferença que nesse caso podemos visualizar os resultados, 5,4 e 3;
28
Curso Java SE - UTD 29
1.12.7. Exercício resolvido
01 – Crie um programa em java que decremente uma variável 4 vezes e mostre cada
parte do calculo,sendo que a variável se inicia com valor igual a 5.
1.12.8. Operadores relacionais: 
Os operadores de relacionais de comparação sempre resulta em um valor booleano (true
ou false). Esse valor booleano é usado com mais frequência em teste if. Java possui quatro
operadores   de   comparação   que   podem   ser   usados   para   comparar   qualquer   valores
inteiros,numéricos de pontos flutuantes ou caracteres.
1.12.9. Operadores lógicos.
Expressões  lógicas são aquelas que realizam uma operação lógica (ou, e, não, etc...) e
retorna verdadeiro ou falso. A linguagem java especificam seis operadores lógicos (! , & , | ,
^ , && , || ).
29
Curso Java SE - UTD 30
1.12.10. Os operadores Bitwise : 
Os operadores  (^ , & , | ) são chamados de operadores de  Bitwise. Esses operadores
comparam duas variáveis bit por bit, e retornam uma variável cuja os bits foram definidos
com base em se as duas variáveis sendo comparadas tinham bits  correspondentes.  Eles
podem ser : ambos ligados (&), um outro ligado (|), ou ou exatamente um ligado (^).
1.12.11. Operadores lógicos de abreviação: 
O operador de abreviação (&&) consiste no fato de ele não perder seu tempo avaliações
inúteis.O operador de abreviação (&&) avaliará  o lado esquerdo da operação (operando
um) e se  esse operando  tiver  um resultado  false,  ele  não examinará  o   lado direito  da
equação(operando dois),já que o operador saberá que a expressão completa não será true.
■   AND abreviação (&&)
■   OR abreviação (||)
Exemplos:
30
Curso Java SE - UTD 31
1.12.12. Operadores lógicos ^ e !: 
O operador lógico ^(ou exclusivo) avalia valores booleanos. O operador ^ relaciona­se
com os operadores de não­abreviação,no sentido de que sempre avalia ambos os valores,o
do   lado   direito   e   o   do   lado   esquerdo,em   uma   expressão.   Para   uma   expressão   OU
exclusivo(^) ser verdadeira,exatamente um operando precisa ser true. Exemplo.
■   ^ OR exclusivo (xor)
■   !  inversão boleana.
 Exemplos:
Nota:  A expressão acima avalia  como false  porque  tanto o  primeiro operando (2<3)
quanto o segundo(4>3) avaliam como true.
Exemplos 01: 
  Exemplos 02:
1.12.13. Operadores condicionais.
O  operador  condicional  é  um operador   ternário   tem  três  valores  usado  para  avaliar
expressões boleanas de modo semelhante a instrução IF ,exceto por em vez de executar um
bloco  de  código   se  o   resultado  do   teste   for   true,atribuir  um valor   à   variável.  Ou seja
objetivo do operador condicional é decidir qual dos valores atribuir a uma variável.Ele é
constituído   dos   símbolos   ?(ponto   de   interrogação)   e   (dois   pontos),os   parênteses   são
opcionais.Veja a sintaxe:
X = (expressão boleana) ?valor a atribuir se true : valor atribuir se false
Exemplo 01.
 
31
Curso Java SE - UTD 32
   Exemplo 02.   
Exemplo 03.
1.12.14. Operador Ternário
Operador  ternário ou operador condicional  tem objetivo de atribuir  um valor  a uma
variável de acordo com o resultado de um teste lógico.
Vejamos a sintaxe:
Teste lógico (?) valor se for verdadeiro (:) valor se for falso.
O teste lógico é qualquer expressão que pode ser avaliado como verdadeiro ou falso
Exemplo 01:
32
Curso Java SE - UTD 33
1.12.15.  Precedência de Operadores
A precedência serve para indicar a ordem na qual o compilador interpretará os diferentes
tipos
de operadores,  para que ele   sempre  tenha como saída um resultado coerente  e  não
ambíguo.
ordem operador
1 () parênteses
2 ++ pós­incremento e ­ ­ pós­decremento
3 ++ pré­incremento e ­ ­ pré­decremento
4 ! negação lógica
5 *  Multiplicação e / divisão
6 % Resto da divisão
7 + soma e ­ subtração
8 < menor que, <= menor igual, > maior que, >= maior igual
9 == igual e ! = não igual
10 & AND binário
11 | OU binário
12 ^ OU exclusivo binário
13 && AND lógico
14 || OU  lógico
15 ?: condicional
16 = atribuição
33
Curso Java SE - UTD 34
Capitulo 2.Controle de fluxo em java.
As estruturas de controle definem a sequência de execução das instruções. Não é possível
implementar um algoritmo que não seja trivial em uma linguagem de programação que não
tenha um conjunto mínimo de estruturas de controle. As estruturas de controle podem ser
divididas   em  seleção,  repetição  e  sequência.   A   sequência   é   simplesmente   definida   pela
execução sequencial dos comandos, de cima para baixo.
2.1.Utilizar código que use instruções if
A expressão entre parênteses deve ter como resultado um valor booleano true ou false.
Normalmente   testará   algo  para   saber   se  é   verdadeiro,   seguida  executará  um bloco  de
código (uma ou mais instruções) se o resultado for mesmo verdadeiro e opcional outro
bloco de código se não false. Sintaxe da declaração if:
 
Fluxograma da declaração  if.
2.1.1. Expressões válidas para instruções if
Exemplos 01:
Neste exemplo ambas as    instruções são   avaliadas como verdadeira tanto a do lado
direito quanto a do lado esquerdo, pois, o valor da variável x for maior do que o valor da
variável y, então o bloco de instrução é executado, e a mensagem será  imprimida na saída
padrão.
Exemplos 02: 
34
Curso Java SE - UTD 35
Neste outro exemplo a instrução é avaliada como true, pois, o valor da variável teste é
false,mais quando o fluxo entra no if a variável teste recebe true, logo bloco de instrução
será executado e resultando  impresso na saída padrão. 
2.1.2.Expressões válidas para instruções if­else
A   declaração  if­else  é   usada   quando   queremos   executar   determinado   conjunto   de
instruções se a condição for verdadeira e outro conjunto se a condição for falsa.
 Sintaxe da declaração if-else.
 Fluxograma da declaração  if – else.
Notas: Nestes exemplos a instrução do lado esquerdo é avaliada como verdadeira, pois, o
valor da variável x não é maior do que o valor da variável y e a instrução do lado direito
também é  avaliada como verdadeira, pois a variável teste tinha valor inicial  ‘false’, mas
dentro da instrução é atribuído um novo valor igual a ‘true’, logo bloco de instrução tanto
da esquerda como o da direita serão executados,atribuindo um novo valor para a variável y
igual a 25 imprimindo o valor de y na saída padrão. 
Exemplos 01: 
Notas: Nestes exemplos ambas os código do if serão avaliada como verdadeira,então ela
executa a instrução imprimindo teste 1. Se as instrução if fosse falsa ele executariam o
eles,imprimindo teste 2,mas no nosso caso foram verdadeiras.
35
Curso Java SE - UTD 36
Regra para o uso do else e de else if
 ­ Pode ter um ou nenhum else para if, e ele deve vir depois de quaisquer instruções else if. 
 ­ Pode ter de muitos ou nenhum else if para um if, e eles devem vir antes do else.
 ­ Depois que um else tem sucesso, nenhum dos demais else if ou else será testado.   
2.1.3. Expressões válidas para instruções if­else­if.
A declaração else  pode conter outra estrutura  if­else. Este cascateamento de estruturas
permite ter decisões lógicas muito mais complexas.
A sintaxe da declaração if­else­if:
Podemos  ter várias  estruturas  else­if  depois de uma declaração  if.  A estrutura else  é
opcional   e   pode   ser   omitida.   No   exemplo  mostrado   acima,   se   a   expressão_lógica1   é
verdadeira, o programa executa a instrução1 e salta as outras instruções.Caso contrário, se
a expressão_lógica1 é falsa, o fluxo de controle segue para a análise da expressão_lógica2.
Se   esta   for   verdadeira,   o   programa   executa   a   instrução2   e   salta   a   instrução3.   Caso
contrário, se a expressão_lógica2 é falsa, então a instrução3 é executada.
Fluxograma da instrução if­else­if
36
Curso Java SE - UTD 37
Exemplo 01:
2.2. Expressões válidas para instruções switch e case.
          Sintaxe da declaração switch.
Onde, variável_inteira é uma variável
de tipo byte, short, char ou int. valor1,
valor2, e assim por diante, são valores
constantes   que   esta   variável   pode
assumir. Quando a declaração switch é
encontrada,  o   fluxo  de   controle  avalia
inicialmente  a   variável_inteira   e   segue
para o case que possui o valor igual ao
da   variável.  O  programa  executa   todas   instruções   a   partir   deste   ponto,  mesmo  as  do
próximo case, até encontrar uma instrução break, que interromperá a execução do switch.
Se nenhum  dos  valores case for satisfeito,  o bloco default será  executado. Este é  um
bloco opcional. O bloco default não é obrigatório na declaração switch.
37
Curso Java SE - UTD 38
                                               Fluxograma da declaração switch.
Exemplos 01:
As constantes CASE são avaliadas de cima para baixo,e a primeira constante CASE que
bater com a expressão SWITCH será o ponto de entrada da execução.
Exemplos 02:
 Solução Incorreta.
Solução Correta.
Este exemplo é  perfeitamente válido para a  declaração switch­case,  porque mesmo a
variável sendo do tipo String,porém quando entrar na instrução switch,o método invocado
pela variável  s.length  que retornará um valor inteiro,ou seja o tamanho da string,que no
nosso caso é igual a 7.
       Exemplo 03:
38
Curso Java SE - UTD 39
No  exemplo  acima,quando   fornecido   argumento,a   aplicação   identifica   se   o   primeiro
caractere deste é  uma vogal.  Se o argumento não for  iniciado por uma vogal ocorre a
execução da  seção default  da  diretiva  switch.  Caso  não exista  argumentos   fornecido  o
programa imprime uma mensagem correspondente.
Regras para uso da instrução switch­ case:
 ­ Cada instrução case deve ser seguida de uma instrução break.
­ Certifique­se de que uma variável char seja declarada antes da instrução switch.
2.3. Loops e iteradores (usando os loops for, while e do while). 
Os  comandos  de   repetição,  ou  de   iteração,  executam um comando ou um bloco  de
comandos várias vezes. É uma das formas para executar repetidamente um comando. A
outra é a recursão que é a chamada direta ou indireta de um método durante a execução
do próprio método. Em Java existem três formas de comandos de repetição: o while; o
do­while; e o for.
                 Sintaxe: loop while                                          Fluxograma do loop  while
A  declaração  while   executa   repetidas   vezes   um   bloco   de   instruções   enquanto   uma
determinada condição lógica for verdadeira.
39
Curso Java SE - UTD 40
Exemplo 01:
Como em todos os loops a expressão(teste) terá que resultar em um valor booleano.O
corpo   de   loop   while   só   será   executado   se   a   expressão(também   conhecida   como
condição)resultar   em   um   valor   true(verdadeiro).   Uma   vez   que   entramos   no   loop,seu
conteúdo será  repetido até  que a condição não possa mais ser atendida e seja avaliada
como false(falsa),encerrando o loop.
Exemplo 02:
Neste exemplo a variável x é inicializada com 0 ao entrar no loop a condição é verificada
como   sendo   verdadeira,isso   porque   0   é  menor   do   que   5,então   o   bloco   de   código   é
executado,imprimindo na tela a string x e o valor da variável x que no caso é 0,depois a
execução do código passa para a próxima linha que é o incremento da variável x,passando
a valer 1. Agora a execução volta ao inicio do loop para verificar novamente a condição e
assim por diante até que a condição seja avaliada como falsa.
                                                       Sintaxe: do while : fluxograma do loop  do­while
2.3.1.Loop  do while: 
A declaração do­while é similar ao while. As instruções dentro do laço do­while serão executadas
pelo menos uma vez. Inicialmente, as instruções dentro do laço do­while são executadas. Então, a
condição na  expressão lógica é avaliada. Se for verdadeira, as instruções dentro do laço do­while
serão executadas novamente.
40
Curso Java SE - UTD 41
 Exemplo 01:
Neste exemplo a variável  x é   inicializada com 0,o bloco de código é  executado pelo
menos uma vez antes que a condição seja verificada. Após a condição ser avaliada como
verdadeira,a variável será incrementada em 1 e a execução do código volta para o inicio do
bloco e isso  se repetirá até que a condição seja avaliada como falsa.               
2.3.2.Loop  for: 
A declaração for, como nas declarações anteriores, permite a execução do mesmo bloco de código
uma quantidade determinada de vezes. 
Sintaxe: do loop for: 
Fluxograma For
Exemplo 01: 
Exemplo 02:
41
Curso Java SE - UTD 42
2.4.   Loop for aprimorado (para arrays).
O comando FOREACH é utilizado quando você quantas vezes precisa fazer a interação.
Ele é composto por três expressões, sendo elas: a) Declaração e inicialização, b)  Expressão
condicional e c) Expressão de interação.
  Exemplo 01:
 Exemplo 02:
Nota:  A saída dos exemplos anteriores, após compilado e executado, deverá ser uma
exibição dos números inteiros do arranjo com nome “semana”. Esta estrutura otimiza a
interação no arranjo ou coleção passada para a expressão podendo ser efetuada a
navegação sem a necessidade de índices ou interadores.  
42
Curso Java SE - UTD 43
2.5. Uso de break, continue e return.
2.5.1.Break: 
A instrução break fará com que o programa encerre a execução do loop atual e inicie o
processamento na linha de código posterior ao bloco.,isso porque este comando serve para
interromper a sequência de execução dos comando e sair  do comando switch. Isto não
acontece apenas no comando switch. Toda vez que um break é  encontrado, o fluxo de
execução “salta” para fora do bloco onde está contido o break, sendo retomado no comando
após o bloco.
É a declaração de desvio usada para sair de um laço antes do normal. O tipo determina
para onde é   transferido o controle.  O break    transfere o controle para o  final  de uma
construção de laço (for, do, while ou switch). O laço vai encerrar independentemente de
seu valor de comparação e a declaração após o laço será executada. Exemplo:
Nota: Vamos analisar este exemplo acima que tem como resultado a impressão de todos
os números cuja o módulo da divisão por 10 seja igual a 0. Daí o resultado é o mostrado
abaixo:
[ i = 100, i = 90, i= 80, i = 70, i= 60, i = 50, i = 40, i= 30, i = 20, i = 10  ]
 Exemplo 02:
Agora vamos analisar o exemplo 02,que mostra o mesmo programa com uma pequena
diferença que é a inclusão do comando break depois do comando System.out.println();
Nota: Depois de analisarmos chegamos a seguinte conclusão: Este comando interrompe a
execução do loop satisfazendo a condição no bloco if. Então o resultado é a impressão de
apenas o primeiro que satisfaz a condição,que no nosso caso é o 100.
[ i = 100] 
43
Curso Java SE - UTD 44
2.5.2.Continue: 
A instrução continue fará com que somente a iteração atual do loop seja encerrada e que
a próxima iteração do mesmo loop seja iniciada deste que for atendida. Quando usar uma
instrução continue em um loop for, você terá que considerar seus efeitos na iteração do
loop. A declaração continue faz com que a execução do programa volte imediatamente para
o início do laço, porém para a próxima interação. O continue faz o interpretador pular para
a próxima iteração e obriga­o a testar a condição. Exemplo:A pergunta é: Esse é um loop infinito? A resposta é não. Quando a instrução continue for
atingida,a  expressão de  iteração ainda será  executada!  Ela  será  exatamente  como se  a
iteração   atual   terminasse   de   maneira   natural.   Portanto,no   exemplo   anterior,   ainda
aumentará o valor antes da condição (i < 10) ser verificada novamente. Mas geralmente a
instrução continue é usada dentro de um teste if como segue abaixo:
Nota:   Este  dois   comando   também podem  ser   usados   como   instruções   rotuladas.  As
instruções rotuladas estão além do escopo do nosso curso,mas,embora muitas instruções
em java possam ser rotuladas,é mais comum usar rótulos com instruções loop tais como for
e while, em conjunto com instruções break e continue. Uma instrução de rótulo deve ser
colocada   antes   da   instrução   sendo   rotulada,e   consiste   de  um   identificador   válido   que
termina   com   dois   pontos(:).   As   instruções   rotuladas   serão   necessárias   somente   nas
situações em que você tiver um loop aninhado e precisa indicar qual quer encerrar ou a
partir do qual deseja continuar a próxima iteração.
44
Curso Java SE - UTD 45
2.5.3.Return: 
A declaração return é utilizada para sair de um método. O fluxo de controle retorna para
a declaração que segue a chamada do método original. A declaração de retorno possui dois
modos: o que retorna um valor e o que não retorna nada. 
Exemplo:
Anotações
45
Curso Java SE - UTD 46
Capitulo 3.Tipos de Variáveis, Constantes e Casting.
3.1.O que é uma variável :
Variável:  É   um   espaço   na  memória   usado   para   armazenar   o
estado de um objeto. Uma variável deve ter um nome e um tipo. O
tipo da variável indica o tipo de dado que ela pode conter. O nome
das variáveis deve seguir as mesmas regras de nomenclatura que os
identificadores.
3.1.1.Tipos de Variáveis:
Variáveis  de   instância:    Estas   variáveis   são  não­estáticas,   ou   seja,  declaradas   sem o
modificador   static.  Variáveis  de   instância  são assim chamadas  porque   seus  valores   são
únicos   para   cada   instância   da   classe.   Assim,   as   variáveis     podem   armazenar   valores
diferentes para cada cópia de objetos da classe.
Variáveis   de   classes:     Estas   variáveis   são  declaradas   com o  modificador   static.   Isso
informa ao compilador que há exatamente uma única cópia desta variável, independente
do número de instâncias da classe.
Variáveis   locais:     São   usadas   para   armazenar   o   estado   temporário   de   um  método.
Variáveis   locais   são   acessíveis   somente   dentro   do  método   em   que   são   declaradas,   e
automaticamente abandonadas na saída do método.
Parâmetros:   São os parâmetros de métodos. Tais variáveis são acessíveis somente ao
código no corpo do método.
Nota: Veremos nos próximos capítulos detalhes e exemplos de todos os tipos
de variáveis aqui mostrado. Geralmente quando falamos de "campos em geral"
(excluindo   variáveis   locais   e   parâmetros),   podemos   simplesmente   dizer
"campos".   Se   a   discussão   se   aplica   a   todas   as   variáveis   acima,   usamos
"variáveis".   Se   o   contexto   pede   uma   distinção,   usamos   termos   específicos
(campo estático, variável local, etc) como apropriado. Podemos ainda usar o
termo "membro". Os campos, métodos e tipos aninhados de um tipo podem ser
chamados de seus membros. 
Exemplo de variáveis locais:
Na  linguagem de programação Java  não é  permitido  o  uso  de  variáveis   indefinidas.
46
Curso Java SE - UTD 47
Variáveis definidas dentro do método são chamadas de variáveis locais,  temporárias ou
estáticas e devem ser inicializadas antes do uso. Vejamos a tabela abaixo com os seguintes
valores iniciais.
Exemplo 02:
Atribuir  um valor a uma variável  parece bem simples; simplesmente insira  o valor  á
direita do sinal (=) para atribuí­lo á variável que estará á esquerda. Exemplos:
3.2.  Variáveis estáticas:
 É um membro que pertence a classe,uma variável estática é compartilhada por todas as
instâncias de classe, por que isto é  apenas uma cópia da variável  estática é  mantida e
somente a própria classe é suficiente para acessar a variável marcada como estática.
Exemplo 01:
Exemplo 02:
Exemplo 03:
Neste   exemplo   vamos
mostrar   através   de   um
programa   como   usar   as
variáveis estáticas.
47
Curso Java SE - UTD 48
3.3.   Constantes
O valor de uma variável pode ser alterado durante a execução do programa. Mas,o valor
de uma constante não é alterado jamais.  Por padrão, recomendamos que crie constantes
sempre   com  letras  maiúsculas  por   seguirem as  normas  da  SUN,  as   constantes   trazem
algumas vantagens,entre elas o fato de que nomes descritivos para constantes podem tornar
o programa mais fácil de ser lido. 
Sintaxe:     
final  static  tipo_de_dado  IDENTIFICADOR = valor;
 Exemplo 01:
3.4. Conversão ou  Cast (explícita e   implícita das variáveis  de tipos
primitivos).
 
A conversão permitirá que seja transformado valores primitivos de um tipo em outro. As
conversões   podem   ser   implícitas   ou   explícitas   das   variáveis   de   tipos   primitivos.   Uma
conversão implícita ocorre quando fazemos uma transformação que envolve ampliação. Em
outras palavras,quando inserimos um item menor (exemplo,um tipo byte) em um container
maior(como   um   tipo   int).   A   transformação   valor   maior   em   um   container   menor   é
conhecida como compactação e requer uma conversão explícita,em que será informado ao
compilador   que   conhece   o   perigo   e   aceita   toda   a   responsabilidade.   O   Java   converte
automaticamente valores de um tipo numérico para outro tipo maior. Vejamos algumas
conversões válidas em java. 
Utilizamos o casting para converter um objeto ou uma variável de um tipo primitivo para
48
Curso Java SE - UTD 49
outra de um tipo também primitivo. Podemos converter um double em um int, ou uma
subclasse em uma superclasse.
A regra fundamental para o cast é: o casting não modifica o objeto ou valor que está
sendo moldado; porém, o receptor do cast constitui um novo objeto ou um novo tipo. O
casting de dados primitivos ocorre com bastante frequência. A maneira pelo qual o casting
age   depende   da   precisão  dos   dados   envolvidos.   Por   sua   vez,   a   precisão   depende   da
quantidade de informações que um tipo pode conter; assim, um tipo de ponto flutuante
double tem maior precisão que um float, pois o primeiro é um tipo de 64 bits e o segundo,
de 32 bits.
  Um byte pode ser convertido em um short, int, long, float ou double■
  Um short pode ser convertido em um int, long, float ou double■
  Um char pode ser convertido em um int, long, float ou double■
  Um int pode ser convertido em um long, float ou double■
  Um long pode ser convertido em um float ou double■
  Um float pode ser convertido em um double■
Sempre que houver uma transferência de dados de um tipo menos preciso para um mais
preciso, o casting explícito não é obrigatório.
 
Regras para casting:
Já a transferência de dados de um tipo mais preciso para um menos preciso requer um
casting explícito. Isso ocorre porque pode haver perda de dados durante a moldagem. Java
pretende alertar o programador do possível perigo de uma conversão desse tipo: 
Exemplo 01:
Exemplo 02:
49
Curso Java SE - UTD 50
Exemplo 03:
Exemplo 04:
Exemplo 05:
O Java não faz automaticamente o “downcast.”
O casting  entre  objetos   requer  um pouco mais  de  cuidado.  Veremos no  decorrer  da
apostila como fazer o casting de objetos. 
50
Curso Java SE - UTD 51
3.5.  Atribuindo uma variável de referência a outra.
As variáveis de referências são usadas para se referir(ou acessar) um
objeto. Uma variável de referência é declarada como sendo de um tipo
específico, e essetipo não pode nunca ser modificado. Uma variável de
pode ser usada para referir­se a qualquer objeto do tipo declarado,ou
de   um   subtipo   do   tipo   declarado(um   compatível).   Variáveis   de
referência podem ser declaradas como variáveis estáticas, variáveis de
instâncias, parâmetros de métodos ou variáveis locais.
3.5.1.  Escopo de variáveis.
Depois que declarou e inicializou uma variável,uma questão natural e muito importante é
por quanto tempo essa variável vai existir? Essa é uma pergunta que se refere ao escopo das
variáveis em java. O escopo define onde uma variável é acessível durante a execução de um
programa e quando a variável é criada e destruída. A localização de uma variável dentro do
programa  estabelece   seu   escopo.   Existem quatro   categorias   de   escopo  de   variáveis   na
linguagem Java, são elas:
3.5.2.Variáveis de instâncias de tipos primitivos.
As variáveis de instâncias são definidas dentro da classe,mas fora de qualquer método,e só
são inicializadas quando a classe é instanciada. As variáveis de instâncias são os campo que
pertencem a cada objeto único. 
Exemplos:
    
  
Ou 
51
Curso Java SE - UTD 52
Capitulo 4.POO com Java
4.1. Introdução
Programação Orientado a Objeto, constitui em um conjunto de regras de programação.
Estudamos anteriormente como programar de forma estruturada,  iniciávamos a execução
do código e finalizando todos os processos na mesma classe . Porém sem saber estávamos
usando algumas regras de POO(Programação Orientada a Objetos)   como por exemplo,
usando a classe  “System” ou “JOptionPane”.    Essas  classes  não  foram criadas por  nós,
porém elas   foram reaproveitadas  em nosso  código  com objetivo  de   resolver  os  nossos
algoritmos. Vamos fazer uma comparação com o dia­ a ­dia para entendermos melhor .
       Fabrica de Computadores.      Serviço de Digitação.
Relatório Final.
Imagine que você trabalha com digitação de
textos.   Você   não   precisa   saber   como   o
computador   foi   criado,   nem   como   o
Software  que  usa  para  digitar   o   texto   foi
desenvolvido. O seu objetivo é  usar desses
recursos e criar um novo produto final. Um
relatório de texto.
A Programação orientado a objeto, é uma metodologia que os programadores utilizam
com objetivo de atingir alguns requisitos importantes na construção de um bom programa
como:
• Organizar   o   código   :  Com   o   nosso   código   dividido,   podemos   facilmente   dar
manutenção ou encontrar algum erro mais facilidade.
• Reutilização   do   código:  Não   precismos   reescrever   todo   o   código,   quando
necessitamos dele novamente.
• Manter   Padrões   :  Utilização   de   um  mesmo   padrão   conceitual   durante   todo   o
processo de criação do código.
Até  o  final  do curso  iremos aprender e  trabalhar nessa metodologia. Então, bastante
atenção nesse e nos próximos capitulos.
52
Curso Java SE - UTD 53
4.2. Classe, Atributos e Métodos.
Como estamos trabalhndo com POO(Programação Orienntada a Objeto), o nosso objetivo
final é construir um Objeto que tenha suas características. Um Objeto é criado apartir de 
uma “Classe”. Ela irá servir como modelo para criação do Objeto.Vamos fazer uma 
comparação com o dia­ a ­dia para entendermos melhor .
Um prédio não é construido de qualquer forma,  o pedreiro irá construir o prédio
de acordo com as   instruções  da planta.  Tamanho do banheiro,  quantos  quartos,
porta de entreda. A planta do prédio, seria uma “Classe” ele server como referencia
na construção do prédio que é um “Objeto”. 
Iremos aprender, como criar uma “Classe”, ou seja, referencia para futuros “Objetos”.
Imagine que queremos criar um “Pessoa”.   Para poder criar uma “Pessoa” teremos antes
que fazer 2 perguntas básicas.
• Anote tudo que uma pessoa pode ter, como  nome,
data de nascimento, RG, CPF, etc.. Para a resposta da
primeira pergunta,  nós   temos o que chamamos de
“Atributos da classe Pessoa”
• Anote Tudo que uma pessoa pode fazer, ou seja, suas
ações, como  acordar, dormir, falar o seu nome, etc...
Para a   resposta da segunda pergunta nós   temos o
que chamamos de “Métodos da classe Pessoa”
Com   o   conceito   de  Classe,   atributos   e
métodos.    Podemos agora  criar  uma classe
em código java, veja no próximo tópico como
iremos criar­lo.
53
O que poderei ter?
O que poderei fazer ?
Curso Java SE - UTD 54
4.3. Construindo uma Classe.
Para criar uma classe, clicaremos com o botão direito do mouse no pacote do Projeto >
novo > Classe Java.
Agora construímos a nossa classe, mas o que significa este “public” antes dos atributos e
métodos e  o que significa  o “void”? Para entender  melhor  ,   temos que aprender sobre
“Encapsulamento”  e  “tipo de retorno de dados”.  Assunto que iremos ver no próximo
tópico.
4.4. Encapsulamento.
Encapsulamento é  uma forma de proteção do nosso código, existem informações que
queremos que outras classes vejam, outras não. Imagine a sua conta de e­mail. A conta do
seu usuário poderá ser vista por outras pessoas, pois ele irá identificar o seu e­mails dos
demais,  porém a sua senha é  algo “privado” onde só  você  poderá   ter acesso a ela.  Da
mesma forma que queremos mostrar ou proteger os nossos dados, uma classe também tem
as mesmas necessidades e podemos defini­las através do encapsulamento.
• public ­ ou publico, qualquer classe pode ter acesso) 
• private  ­   ou   privado,   apenas   os  métodos   da   própria   classe   pode  manipular   o
atributo)
• protected  ­ ou protegido, pode ser acessado apenas pela própria classe ou pelas suas
subclasses).
Assim podemos alterar o “public” da nossa classe por outro valor de encapsulamento,
dependendo da necessidade de proteção dos nossos atributos ou métodos. Por boas práticas
de programação, os atributos da nossa classe Pessoa esterá como “private”. 
Faça alteração de encapsulamento na classe “Pessoa”.
54
CLASSE
 ATRIBUTOS
 MÉTODOS
Curso Java SE - UTD 55
4.5. Retorno
Os métodos podem realizar uma ação interna e podem influenciar em outros métodos
através do seu Retorno. Ele pode representar os tipos primitivos de dados que conhecemos
como :  int, string, double, float,  chat, boolean  por exemplo, ou pode retornar vazio,
simbolizado por “void”. Os métodos que tiver retorno, deverá ter dentro do seu corpo um
“return” que irá representar o resultado final da minha operação.
Veja o exemplo abaixo:
Neste exemplo alteramos o método “falarNome” da classe pessoa. O tipo de retorno desse
método é String. Então além da classe imprimir a frase, ele deverá guardar a String em
uma variável chamada “minhaFrase” e retornar ela para ser usada em outras classes na
linha 23.
4.6. Construtores, métodos seteres e geteres.
4.6.1.Construtores
São métodos  especiais,  que são acionados no  momento  da construção da  classe,  ela
deverá ter o mesmo nome da Classe criada. Imagine que para que uma pessoa possa existir,
ele precise inicialmente de um nome e data de nascimento. Então podemos construir o
nosso construitor da seguinte forma:
Nesse código o nosso construtor é responsável por alimentar os atributos nome e data de
nascimento da pessoa. também garantimos que ao momento da construção do objeto, uma
“Pessoa” não poderá existir se não tiver um nome e uma data de nascimento.
Mas como eu poderei alterar o meu CPF, RG, e como poderei mostrar esses valores de
atributos? Assunto que veremos no próximo tópico.
4.6.2.Métodos seteres e geteres
Os métodos nomeados como “set” e “get” são responsáveis respectivamente por alterar
um atributo e mostrar um atributo da minha classe.  Para que o netbeans possa gerar esse
código,   iremos   digitar   :  ALT+   INSERT  >   INSERIRCÓDIGO  e  marcar   os   atributos,
“nome”, “cpf”, “rg”.
Como eu poderei  usar o  meu construtor,  meus métodos do tipo “set”  e “get”  ?  Este
assunto veremos no próximo tópico.
55
Curso Java SE - UTD 56
4.7. Estanciando (Construindo um Objeto)
Agora estamos prontos para construir o nosso objeto usando a nossa classe  “Pessoa”
como  referencia.  Então,   iremos  voltar   a   classe  que   tenha  o  método  main  e   realizar   a
seguinte operação:
Agora  estou estanciando o meu objeto  e  de  acordo com meu construtor,   eu preciso
obrigatoriamente de um nome = “Fabrício” e uma data de nascimento = “17/02/87” todos
eles do tipo String. Vamos agora usar os métodos da nossa classe criada.
Dessa   forma  podemos  modificar   e   acessar  qualquer  variável  dependendo  das  nossas
necessidades.   Todas as informações do “Fabrício” estão dentro de uma variável do tipo
“Pessoa” chamada de “x”. Se eu quiser criar uma nova pessoa, posso chamá­la de qualquer
outro valor.
4.8. Variáveis Estáticas
Variáveis estáticas são valores que se for alterado em um objeto de uma determinada 
classe todos os objetos da estanciados da mesma classe, automaticamente terá o mesmo 
valor Ele normalmente é usado quando todas as classes tem algo em comum. Imagine a 
seguinte situação. 
A Classe “Pessoa” terá um atributo chamado : ondeVivo = “Planeta Terra”
Todas   as   pessoas   moram   em   um   planeta   que
conhecemos por “Planeta Terra”. Porém pesquisas
mais   recentes   mostram   que   o   nome   do   nosso
planeta deveria ser chamado de  “Planeta Água”
pois nele encontra­se mais água do que a terra . 
Se tivermos 300 objetos estanciados do tipo pessoa, como alterar ondeVivo = “Planeta 
Água”  em todos os objetos em uma única instrução sem precisar percorrer todos eles?
Basta criar uma variável estática no atributo “ondeVivo”, assim se alteramos em 1 dos 
objetos essa variável, todas elas sofrerão a mesma alteração. Veja como criá­lo:
56
Curso Java SE - UTD 57
//Atributo estático criado na classe Pessoa
private static String ondeVivo = "Planeta Terra";
//Método set para alterar a variável estática
public void setOndeVivo(String ondeVivo) {
        Pessoa.ondeVivo = ondeVivo;
    }
//Método get para a variável estática
 public String getOndeVivo() {
        return Pessoa.ondeVivo;
    }
Concluímos então que as variáveis estáticas não pertencem especificamente a nenhuma
instancia de objeto e sim uma referencia da classe. O que explica a substituição do 
termo “this” para o nome da classe que que contém a variável estática, no exemplo 
acima alteramos o termo “this”  no método setOndeVivo pelo nome da classe que 
contém a variável estática (Pessoa). 
4.9.Métodos Estáticos
O Métodos Estáticos se caracterizam por ser um referencia de método da Classe, sem a 
necessidade de instanciarmos um objeto para utilizá­lo. Se quisermos por exemplo aletar ou
mostrar o  habitat das pessoas sem precisar construir um objeto podemos realizar essa ação 
apenas adicionando a palavra reservada static nos métodos, dessa forma.
//Atributo estático criado na classe Pessoa
private static String ondeVivo = "Planeta Terra";
//Método ESTÁTICO set para alterar a variável estática
public static void setOndeVivo(String ondeVivo) {
        Pessoa.ondeVivo = ondeVivo;
    }
//Método ESTÁTICO get para a variável estática
 public static String getOndeVivo() {
        return ondeVivo;
    }
Obs.: Métodos estático aceitam apenas variáveis estáticas.
Para que possamos utilizar os métodos estáticos precisamos inserir o nome da classe com 
o método estático criado.
57
Curso Java SE - UTD 58
Capitulo 5.Herança e Interface. 
5.1. Introdução
Estudamos anteriormente como estruturar as nossas classes, agora precisamos gerar uma
interação entre classe criadas.  Para  isso no conceito  de POO também temos que saber
Interface   e   herança.   Iremos   aprender   casa   uma   delas,   seu   conceito   e   como
implementá­las.
5.2.Herança
É fundamental para Java e outras linguagens de programação orientadas a objetos,o 
conceito de herança,que permite ao código definido em uma classe ser reutilizado em 
outras classes.
Sintaxe de herança em java:
class NomeDaClasseASerCriada extends NomeDaClasseASerHerdada
Em Java,pode ser definido uma superclasse geral (mais abstrata), e depois estendê­la com 
subclasses mais específicas. A superclasse não sabe nada sobre as classes que herdam dela, mas 
todas as subclasses precisam declarar explicitamente a relação de herança. Uma superclasse recebe 
automaticamente as variáveis de instâncias acessíveis e os métodos definidos pela superclasse, mas 
é também livre para substituir métodos da superclasse para definir comportamento mais específicos.
Os objetos de uma mesma classe podem tirar proveito de relações de herança, onde objetos 
recém­criados absorvem características de outros já existentes e adicionam­se novas características.
58
Curso Java SE - UTD 59
5.3.Object: A superclasse cósmica do java
A class Object: A classe Object é o último ancestral – toda classe em java estende  de 
Object. Entretanto,nunca será preciso gerar sua herança diretamente:
A superclasse terminal Object é automaticamente inclusa se nenhuma superclasse for 
mencionada explicitamente. Pelo fato de todas as classes em java estenderem Object, é 
importante familiarizar­se com os serviços fornecidos pela classe Object. Remeteremos ao 
leitor a pesquisarem em artigos na internet ou até mesmo ver a documentação on­line que 
lista os vários métodos da classe Object,mas que só aparecem quando lidamos com 
threads(linhas de execução).Você pode usar variáveis do tipo Object para referir­se a 
objetos de qualquer tipo: 
É claro que uma variável do tipo Object somente será útil como um marcador genérico 
para valores arbitrários. Para fazer qualquer coisa específica com o valor,você precisa ter 
algum conhecimento sobre o tipo original e,então,aplicar uma conversão: Em java,somente 
os tipos primitivos(números,caracteres e valores lógicos)não são objetos. Todos os tipos de 
arrays,independentemente de serem arrays de objetos ou arrays de tipos primitivos,são 
tipos de classes que estendem a classe Object.
Super: A palavra super seguida imediatamente de parênteses chama o construtor da 
superclasse de mesma assinatura, deve ser a primeira instrução dentro de um construtor da 
subclasse.
Super­classe: É uma classe da qual se herda outras classes. A cláusula opcional estende em uma 
declaração de classe especifica a superclasse diretamente da classe atual. Uma classe é dito ser uma 
subclasse direta da classe,que se estende. A superclasse direta é a classe a partir de cuja aplicação a 
implementação da classe atual é derivado. A cláusula extends não deve aparecer na definição da 
classe java.lang.Object,pois é primordial a classe e não tem nenhuma superclasse direta. Se a 
declaração de classe para qualquer outra classe não tem nenhuma cláusula extends, então a classe 
tem a classe java.lang.Object como implícita superclasse direta.
Sub­classes: É uma classe que herda de uma classe ou de uma interface. Uma subclasse herda 
estado e comportamento de todos os seus antepassados. A superclasse o termo refere­se ancestral 
direto de uma classe,assim como todas as suas classes ascendentes. Essa hierarquia de classes 
segue uma apresentação na forma de árvore,em que a raiz é a superclasse de todo o 
sistema. Cada nível abaixo dessa superclasse do sistema acrescenta funções específicas. 
59
Curso Java SE - UTD 60
Exemplo 01: Neste exemplo vamos mostrar como proceder com esse poderoso recurso do
java que chamamos de herança simples. 
Código da superclasse Conta.
 
 Código da subclasse CPoupanca que estende da superclasse Conta.
60
Curso Java SE - UTD 61
Código da subclasse CEspecial que estende da superclasse Conta.Diagrama de classes representando a herança entre as classes citadas acima.  
 
Nota: Java permite que uma classe herde apenas as características de uma única classe, 
ou seja, não pode haver heranças múltiplas. Porém, é permitido heranças em cadeias, por 
exemplo: se a classe Mamífero herda a classe Animal, quando fizermos a classe Cachorro 
herdar a classe Mamífero, a classe Cachorro também herdará as características da classe 
Animal.
Como estamos tratando de herança de classes,
toda classe tem seu método construtor. Portanto,
se estamos trabalhando com duas classes, temos 
dois métodos construtores. Para acessarmos o 
método construtor da classe que está sendo 
herdada usamos o super().
61
Curso Java SE - UTD 62
Exemplo 02:
Para demonstrar como definir o relacionamento de herança, considera­se o contexto de 
ter que desenvolver um programa que simule o comportamento de vários tipos de animais 
como mostrado na figura ao lado em um determinado ambiente. 
Inicialmente, apenas um grupo de
animais estará presente neste ambiente
e cada animal deve ser representado
por um objeto. Além disso, os animais
movem­se no ambiente ao seu modo e
podem fazer um conjunto de coisas. O
programa deverá prever que novos tipos
de animais poderão ser incluídos no
ambiente.
O primeiro passo é observar cada animal e definir o que cada objeto do tipo animal tem 
em comum no que diz respeito aos atributos e comportamentos (métodos). Deve­se definir 
também como os tipos de animais se relacionam. Inicialmente, o programa deve simular o 
comportamento dos animais ilustrados na figura, ou seja, de um leão,de um lobo,de um 
gato, de um hipopótamo, de um tigre e de um cachorro .
O segundo passo consiste em projetar a superclasse, ou seja, a classe que representa o estado e o 
comportamento em comum a todos os animais. Para este exemplo, como todos os objetos são 
animais, a superclasse foi denominada como Animal e as variáveis e métodos em comuns a todos os
animais foram atribuídos a ela, como ilustrado na Figura. Neste exemplo, cinco variáveis foram 
definidas: (o tipo de comida que o animal come), (o nível de fome do animal), (representação da 
altura e largura do espaço que o animal vagará ao seu redor) e (as coordenadas X e Y do animal no 
espaço). Além disso, quatro métodos foram definidos para definir o comportamento dos animais: 
(comportamento do animal ao fazer algum ruído),(comportamento 57 do animal ao comer), 
(comportamento do animal dormindo) e (comportamento do animal quando não está nem 
dormindo nem comendo, provavelmente vagueando no ambiente).
O terceiro passo é o de decidir se alguma subclasse precisa de comportamentos 
(métodos) específicos ao seu tipo de subclasse. Analisando a classe Animal, pode­se extrair 
que os métodos devem ter implementações diferentes em cada classe de animais, afinal, 
cada tipo de animal tem comportamento distinto ao comer e fazer ruídos. Assim, esses 
métodos da superclasse devem ser sobrescritos nas subclasses, ou seja, redefinidos. Os 
métodos não foram escolhidos para serem redefinidos por achar que esses comportamentos 
podem ser generalizados a todos os tipos de animais.
62
Curso Java SE - UTD 63
5.3.1.Construtores da subclasse
Os construtores da superclasse não são herdados pela subclasse, logo, esta deverá ter seus 
próprios construtores para inicializar seus atributos. Todavia, ao instanciar um objeto da 
subclasse, devemos inicializar aqueles atributos que ela está herdando, e o fazemos 
chamando algum construtor da superclasse, usando a chamada super(...).
5.3.2.Classe Abstrata
Para entender  o conceito  de herança,  precisamos primeiro entender  No Português,  a
palavra “Abstrata” refere­se a algo que não existe fisicamente, então se convertermos essa
expressão em Java podemos dizer que Classe Abstrata é uma classe que não pode ser um
Objeto.   Assim ela precisará ser herdada ou implementada, no próximo tópico iremos ver
como funciona em um exemplo de código.
Imagine que você tenha uma classe Carros que tenha métodos genéricos comuns a todos
os veículos. Mas você não quer que alguém de fato crie um objeto carro genérico,abstrato.
Como   se   inicializaria   o   seu  estado?  De  que   cor   ele   seria?Quantos   assentos?  ou,  mais
importante, de que forma ele se comportaria?Em outras palavra, como os métodos seriam
implementados?  Temos certeza de que o dono de uma BMW lhe diria que o carro dele é
capaz de fazer coisas que o GOL apenas sonha em fazer.
A implementação pode ser dessa forma mostrada acima,como também pode ser como 
segue no exemplo abaixo:
63
Curso Java SE - UTD 64
Dessa forma podemos dizer que “MeuCarro” que poderá ser um Objeto, herda de “Carro”
que é uma classe abstrata.
Na Classe que contém o método Main, nós temos:
64
Curso Java SE - UTD 65
5.4. Interface
Interface é uma espécie de superclasse 100% abstrata que define os métodos que uma
subclasse deve suportar, mas não como esse suporte deve ser implementado. Isso porque ao
criar   uma   interface,estará   definindo   um   contrato   com  o   que   a   classe   pode   fazer,sem
mencionar nada sobre como o fará. Uma interface é um contrato. Qualquer tipo de classe
(concreta) e de qualquer árvore de herança pode implementar uma interface. 
 Exemplo 01:
Exemplo 02:
 Exemplo 03:
Regras para as interfaces:
 ­ Uma interface em Java é uma coleção de métodos abstratos que pode ser implementada por
uma classe.
 ­ Uma interface na pode implementar outra interface ou classe. 
 ­ Os tipos de interface podem ser usados polimorficamente.
 ­ Os métodos de um interface não devem ser estáticos.
 ­ Uma interface deve ser declarada com a palavra­chave interface.
 ­ Todos os métodos de uma interface são implicitamente public e abstract. As interfaces só
podem ser declaradas. Uma interface pode estender uma ou mais interfaces diferentes.
– Todas as variáveis definidas em uma interface devem ser public,static e final. As interfaces
só podem ser declarar constantes e não variáveis de instância.
65
Curso Java SE - UTD 66
Capitulo 6.Herança (Polimorfismo )
6.1. Introdução
Neste   capitulo   veremos   como   funciona   a   interação   com   classes   em  Polimorfismo.
Usamos esse recurso quando queremos que modificar métodos herdados para isso temos
que aprender o conceito e prática de sobrecarga e sobrescrita. Veremos estes assuntos no
próximo tópico.
6.2. Sobrecarga.
Usamos   sobrecarregar  de  métodos  quando   temos   um   determinado  método   com   o
mesmo nome, porém com assinaturas diferentes,  sou seja,  parâmetros diferentes,  dessa
forma quando usamos um determinado método com sobrecarga podemos escolher qual
método   sobrecarregado   será   usado   de     acordo   com   o   número   e   tipo   de   dados   do
parâmetros oferecidos. Veja um exemplo abaixo :
Na Classe animal criamos 2 método chamado comer,  o método que não contém nenhum
parâmetro, o animal apenas mostra a ação de comer,   estado da carne. O nosso segundo
método,   também chama­se comer, porém ele tem um  assinatura diferente,  ele recebe
como parâmetro um valor boleano que refere­se ao estado da carne, dessa forma o animal
pode simplesmente comer ou verificar o tipo de alimento antes de se alimentar.
6.3. SobreEscrita
Usamos  sobrescrita de métodos  quando temos que modificar um método herdado da
classe pai, para sobrescrever os métodos teremos que criar o mesmo método herdado na
classe filha com o nome assinaturas igual. Levando em consideração a classe Animal criada
no tópico anterior, veja no exemplo abaixo:
No   exemplo   anterior,   o   cachorro   já   herda   o  método   comer,   porém o   animal   come
66
Curso Java SE - UTD 67
qualquer alimento, este nosso cachorro não comer qualquer alimento, ele só come ração. O
termo “@Override” no exemplo, não é obrigatório, apenas para avisar a IDE queeste é um
método de sobrescrita.
6.4. Polimorfismo
Podemos dizer que polimorfismo é quanto temos métodos de sobrescritas distintos entre 
classes filhas que referencia um mesmo Pai. Veja o exemplo abaixo.
Note as roupas que eles usam. A pessoa por padrão, tem um estilo de roupa, porém
dependendo   da   situação,   temos   que   usar   roupas  específicas  para   cada   situação.   Um
professor   também é  uma pessoa,  porém do  tipo “Professor”    e  ele  precisa  de um  tipo
específico de uniforme para dar suas aulas.  O aluno também é  uma Pessoa, porém ele
precisa  de  um  fardamento  adequado para  assistir  as  aulas.    Assim nós   temos  a  classe
“Professor”   e   “Aluno”  herdando   de  “Pessoa”  Porém   cada   uma   delas   tem  métodos
diferentes quando nos referimos como eles se vestem. Vamos ver como ficaria em código
java o nosso Polimorfismo.
67
Professor
Curso Java SE - UTD 68
Anotações:
68
Classe Filha de "Pessoa" que sobrescreve método vestirRoupa
Classe Filha de "Pessoa" que sobrescreve método vestirRoupa
Curso Java SE - UTD 69
Capitulo 7.Tratamento de Exceções
7.1. Capturando uma exceção usando o bloco (try e catch).
A  linguagem  java   fornece   aos   desenvolvedores   um   mecanismo
sofisticado para manipulação de erros que produz códigos de manipulação
eficientes e organizados: a manipulação de exceções. A manipulação de
exceções permite que os desenvolvedores detectem erros facilmente sem
escrever   um   código   especial   para   testar   valores   retornados.   Permite
também   manter   o   código   de   manipulação   de   exceções   nitidamente
separado   do   código   que   gerará   a   exceção.  Além disso,permite   que   o
mesmo código de manipulação de exceções lide com as diferentes exceções possíveis.
A  classe  Throwable  é   a  única  classe  cujas   instâncias  diretas  ou  indiretas  podem ser
usadas   para   serem   lançadas.   A   classe   Throwable   é   pré­definida   na   linguagem   Java,
juntamente com várias outras classes definindo um grande número de categorias de erro.
Os programadores Java, por convenção, caso queiram criar novas exceções devem estender
a classe Exception que é uma subclasse de Throwable. Duas classes descendentes da classe
Throwable podem ser consideradas especiais: a classe Error e a classe RuntimeException. A
  linguagem   java   não   obriga   o   programador   a   tratar   os   lançamentos   de   exceção
envolvendo   instâncias  da   classe  Error,   da   classe  RuntimeException  e  das   classes  delas
derivadas, todos os outros lançamentos de exceção devem ser tratados pelo programador.
Capturando uma exceção com o bloco try e catch.
Vejamos a sintaxe.
O termo exceções significa ‘’condição excepcional’’, e é uma ocorrência que altera o fluxo
normal   do   programa.   Várias   coisas   podem   levar   a   exceções,incluindo   falhas   do
hardware,exaustão de recurso e os famosos erros. Quando isso acontece,ou seja quando
ocorre   um   evento   excepcional   ocorre   em   Java,diz   se   que   uma   exceção   será   lançada.
Exemplo 01:
69
Curso Java SE - UTD 70
Nota: O método calc se for chamado com y igual zero(0),gerará um erro e uma exceção
será   lançada,  esse erro  poderá   ser   sinalizado no bloco  try­catch,então a  execução do
método pulará para a bloco de código catch,onde será mostrado uma mensagem de erro.
Exemplo 02:
Caso 01: Neste exemplo vamos chamar o método converteStr(),passando uma   string
numérica,que no nosso caso é 8 e o resultado é a conversão da string em um número de
ponto   flutuante,daí  a  divisão é   feita  e  a  execução do programa acontece sem nenhum
problema.
Caso 02:  Neste mesmo exemplo vamos chamar agora o método converteStr(),passando
uma  string não numérica,que no nosso caso é a caractere 'n' e o resultado é o lançamento
de   uma   exceção,jogando   o   fluxo   de   execução   do   programa   para   o   bloco   catch,onde
imprime uma mensagem na no console.
7.1.1.Finally
Finally: É o trecho de código final. A função básica de finally é sempre executar seu
bloco de dados mesmo que uma exceção seja lançada. É muito útil para liberar recursos do
sistema quando utilizamos, por exemplo, conexões de banco de dados e abertura de buffer
para leitura ou escrita de arquivos.
70
Curso Java SE - UTD 71
Resultado do código acima:
7.1.2.Lançado uma exceção com o throws.
O objeto de  exceção  é  uma instância  da  classe Exception ou de uma de  uma de  suas
subclasses.  A  cláusula   catch  usa,como parâmetro,uma  instância  de  objeto  de  uma  tipo
derivado da classe Exception. A linguagem java exige que todo método capture a exceção
verificada que pode vir a lançar ou então declare que lançará a exceção. A declaração da
exceção  faz  parte  da   interface  pública  do método.  Na declaração de uma exceção que
poderá ser lançada,a palavra­chave throws é usada em uma definição do método,junto com
uma lista de todas as exceções verificadas que poderão ser lançadas. 
Exemplo 01:
Exemplo 02:
7.1.3.Criando uma exceção com throw.
A máquina Virtual Java lança referências para instâncias de maneira implícita utilizando
as classes pré­definidas. O programador pode utilizar o comando throw de forma explícita.
Quando o fluxo de controle
atinge   o   comando  throw
<expressão>,   a   expressão   é
avaliada.   Esta   expressão
corresponde,   em   geral   à
criação   de   um   objeto   e
resulta  numa   referência,   p.
ex.  throw   new   ErroDoTipoX();.
A   partir   daí   o   fluxo   de
controle será  desviado para
71
Curso Java SE - UTD 72
uma cláusula catch apropriada de algum comando try­catch. 
O fluxo de controle segue a cadeia dinâmica dos registros de ativação das invocações dos
métodos, ou seja a execução de um método pode terminar (i) por que o fluxo de controle
atingiu o final do método (return implícito, somente no caso de métodos do tipo void!), (ii)
porque o fluxo de controle atingiu um comando return, ou (iii) porque foi executado um
throw  implícito  ou explícito  que não  foi  apanhado por  um comando  try­catch  daquele
método. A procura por um try­catch apropriado é propagada até o ponto em que há um
retorno para o método main,  neste  caso a  execução do programa será   finalizada,  com
mensagem de erro provida pela MVJ dizendo que uma exceção foi lançada sem que fosse
apanhada. E deverá ser mostrado algo como:
Exemplos de exceções já definidas no pacote java.lang:
ArithmeticException: indica situações de erros em processamento aritmético, tal como
uma divisão inteira por 0. A divisão de um valor real  por 0 não gera uma exceção (o
resultado é o valor infinito).
NumberFormatException:  indica  que  tentou­se  a   conversão de  uma string  para  um
formato numérico,mas seu conteúdo não representava adequadamente um número para
aquele formato. É uma subclasse de IllegalArgumentException;
IndexOutOfBounds: indica a tentativa de acesso a um elemento de um agregado aquém
ou além dos limites válidos.  É  a superclasse de ArrayIndexOutOfBoundsException, para
arranjos, e de StringIndexOutOfBounds, para strings.
NullPointerException:  indica que a aplicação tentou usar uma referência a um objeto
que não foi ainda definida.
ClassNotFoundException:  indica que a máquina virtual Java tentou carregar uma
classe mas não foi possível encontrá­la durante a execução da aplicação.
72
Curso Java SE - UTD 73
Capitulo 8.UML
8.1. Introdução
Neste   capítulo   iremos   aprender   como,   instalar   e   criar   uma   diagramação   de   classes
usando o Netbeans para a linguagem Java. UML significa : “Unified Modeling Language”,
ou   seja   “Linguagem de  Modelagem unificada”.  Modelar   nossa   código   com objetivo  de
documentar e visualizar melhor o projeto.
Para realizar a instalação é simples, basta ir em Ferramentas > Plugins  e buscar por
UML. Este pluginestá disponível livremente a partir da versão 6.7.
Antes de começarmos a trabalhar com eles, precisam saber quais is tipos de diagramas
podemos desenvolver e qual a utilidade de cada uma dentro de um Projeto de qualquer
escala.Tipos de Diagramas.
8.1.1.Diagrama de Atividade:
• Um diagrama de estado especial, onde a maioria dos estados é estado de ação, e a 
maioria das transições é ativada por conclusão das ações nos estados de origem. 
• O objetivo é estudar os fluxos dirigidos por processamento interno, descrevendo as 
atividades desempenhadas em uma operação. 
8.1.2.Diagrama de Sequencia
• Apresenta a interação de tempo dos objetos que participam na interação. 
• O diagrama  de   sequência  mostra   a   colaboração  dinâmica   entre  um número  de
objetos, e visa mostrar a sequência de mensagens enviadas entre objetos. 
8.1.3.Diagrama de Caso de Uso
• Casos de uso descrevem funcionalidades do sistema percebidas por atores externos. 
• Um ator é uma pessoa (ou dispositivo, ou outro sistema) que interage com o sistema.
8.1.4.Diagrama de Classe
• Denota a estrutura estática de um sistema. As classes representam coisas que são
manipuladas   por   um   sistema.   Esse   diagrama   é   considerado   estático   porque   a
estrutura de classes é válida em qualquer ponto do ciclo de vida do sistema. 
Neste Curso aprenderemos como trabalhar com Diagrama de Classe, pois esse diagrama
é bem próximo da criação e estruturação de classes e herança entre as classes criadas.
73
Curso Java SE - UTD 74
8.2. Abrindo o Projeto
Criando um Novo Projeto de Diagrama
Nomeando Projeto de Diagrama
Escolhendo Diagrama de Classe
74
Curso Java SE - UTD 75
Entrando no Diagrama criado, podemos visualizar no Lado direito da IDE Netbeans, um
botão  chamado  “Paleta”  ele   será   responsável  abrir  uma aba  onde  podemos  montar  os
pacotes de classe.  Veja a interface da aplicação:
Na direita Clicando em  “Class”,  clique no palco principal que será  gerado uma nova
classe  indefinida.  Para alterar  a  Classe,  basta  clicar  em  Create Atributes  para criar  os
atributos  ,  e  Create Operation  para criar os métodos,  lembre­se que para o diagrama,
primeiro vem o nome da variável ou método, em seguida vem o seu tipo:
Exemplo:   nome : String
Veja como criar uma classe simples com o tipo, pessoa:
Dessa forma podemos criar qualquer classe com os seus atributos e métodos de forma a
poder visualizar melhor a estrutura do projeto.
Para criar interface ou Herança, basta clicarmos em uma classe ao qual você quer montar
uma relação e aparecerá o seguinte menu ao lado:
Implementation – podemos criar uma implementação, ou seja 
uma interface.
Dependency – Uma forma de gerar herança entre Classe em Java
75
Curso Java SE - UTD 76
Capitulo 9.Fila e Pilha
Iremos estudar Alguns estilos de agrupamento e organização de dados, onde podemos
listar, retirar ou colocar elementos desse grupo de dados de forma organizada, levando em
consideração a sua posição no grupo, para isso podemos estudar conceitos de Fila e Pilha
para essas aplicações, veremos nos próximos tópicos como trabalhar com cada uma delas.
9.1. Fila
Imagine que você tem uma Fila de atendimento em um Banco.
O que podemos observar em uma Fila?
• A   fila   poderá   está   vazia,   onde   o
caixa não irá ter que trabalhar.
• A fila poderá está cheia, onde não
poderá entrar ninguém mais na fila
até   que   pelo   menos   saia   uma
pessoa dela.
• Quando alguém novo chega, ele vai para o final da fila.
• A pessoa que é  atendida, é  sempre o primeiro em uma fila e logo depois de ser
atendido,   ele   sai   da   fila,   dando   lugar   a   outras   pessoas   alterando   a   ordem  de
chamada de todo mundo. Quem era o terceiro, passa a ser o segundo, quem era o
segundo passa a ser primeiro na fila.
Tudo   o   que   acontece   em   uma   fila   normal   também   pode   ser   implementado   na
Programação Java.
9.1.1.Implementando Fila em Java
Para que possamos implementar uma fila em Java temos que usar os métodos da 
interface “Queue” da classe “LinkedList” Dessa forma:
 Queue fila = new LinkedList();
O Objeto “fila” será responsável por conter método ao qual poderemos incluir, retirar,  e 
mostrar o próximo elemento da fila, veja na tabela abaixo os seus métodos e suas funções:
Método Função
element(Object); Mostra o primeiro elemento da fila sem removê­lo
offer(); Insere um novo elemento da fila
poll(); Retorna e retira o próximo elemento da fila. Retorna “null” se a fila
estiver vazia
76
Curso Java SE - UTD 77
Veja a implementação abaixo:
Os elementos nesse exemplo estão inseridos na seguinte ordem
5 6 1 7 3
Retirando os 3 primeiros elementos da Fila  com o método “Poll”, temos:
7 3
 Inserindo o Elemento 10 e 1 na Fila usando o método “offer” , temos:
7 3 10 1
 Sendo assim, se usarmos o método “Poll” mais 5 vezes, estes elementos seriam retornados e 
retirados da fila nessa ordem mantendo a fila vazia. Quando a Fila estiver vazia, o comando “Poll” 
passará a retornar “null”.
Vários sistemas usam esse recurso, como sistema de atendimento ao cliente, um sistema de fila de 
impressora onde os primeiros documentos a serem impresso terão prioridade em relação aos outros 
documento que serão impresso em seguida. Pesquise por mais implementações usando o recurso de 
Fila.
77
Curso Java SE - UTD 78
9.2. Pilha
Imagine uma Pilha de Pratos a ser lavados o que podemos observar?
• A   pilha   poderá   está   vazia,   onde   não   precisamos
lavar nenhum prato
• A pilha poderá está cheia, onde não poderá entrar
nenhum prato a mais, até ser lavado algum 
• O prato que que chegar na pilha estará logo acima
dos demais.
• O prato a ser lavado é justamento o de cima ou seja, o ultimo prato da pilha, então
os últimos pratos a entrarem na pilha, serão os primeiro a ser lavados, logo que eles
forem  lavados eles   sairão da pilha,  dando espaço para os  pratos  de baixo a  ser
lavados. 
Claramente podemos perceber o velho ditado “Os  últimos serão os primeiros”  e esta
regra também poderá ser implementado em JAVA.
9.2.1.Implementando Pilha em Java
Para que possamos implementar uma pilha em Java temos que usar  a Classe Stack, dessa
forma:
 Stack pilha = new Stack();
O Objeto “pilha” será responsável por conter método ao qual poderemos incluir, retirar,  
e mostrar o ultimo elemento da pilha, veja na tabela abaixo os seus métodos e suas 
funções:
Método Função
empty() Verifica se a pilha está vazia retornando um Boolean
push(); Insere um novo elemento da pilha
pop(); Retorna e retira o ultimo elemento da pilha. 
peek(); Retorna o ultimo elemento da pilha sem retirá­lo.
Veja uma implementação pratica:
78
Curso Java SE - UTD 79
Os elementos nesse exemplo estão inseridos na seguinte ordem:
5 6 1 7 3
Retirando os 3 primeiros elementos da pilha com o método “pop”, temos:
5 6
 Inserindo o Elemento 10 e 1 na Pilha usando o método “push” , temos:
5 6 10 1
 Sendo assim, se usarmos o método “pop” mais 4 vezes, estes elementos seriam retornados e 
retirados da pilha na ordem inversa mantendo a pilha vazia. O Comando “pop” não retorna null 
quando a pilha estiver vazia, então recomanda-se sempre verificar se contém elementos na pilha 
usando o método “empty”.
Vários sistemas usam esse recurso, um deles é bem usado por nós sem percebermos, imagine que 
está digitando um texto e precisa “desfazer” uma operação. Cada elemento de “Input” é posto em 
uma pilha e quando usamos o “CTRL+Z” é como usar um “pop” na pilha de retirando apenas o 
ultimo elemento digitado.Pesquise por mais implementações usando o recurso de Pilha.
79
Curso de Java SE - UTD
Capitulo 10. Coleções: List e Map
10.1. Introdução a Coleções/Collections
Aprendemos em capítulos anteriores que existeuma estrutura de dados chamada Array.
Essa estrutura de dados ela foi  criada para guardar na memória do computador dados
primitivos ou objetos do mesmo tipo, de maneira organizada (bloco de dados contínuo), em
que cada informação pode ser acessada por índices(index), 
A estrutura de dados Array é muito inflexível, é preciso definir seu tamanho assim que
nós a criamos. E isso pode gerar um problema para nós programadores Java.
Vamos analisar a seguinte situação:
Criaremos um Array para guardar os nomes de uma lista de 10 alunos do Curso de Java
UTD:
Mas se no meio do meu programa eu precisar acrescentar a minha lista mais 20 alunos.
Como o tamanho do Array  alunosNomes  foi definido com 10 posições então não seria
possível adicionar os 20 novos alunos a essa estrutura, teríamos que tratar isso.  Uma das
alternativas para fazer isso é acrescentar o seguinte código:
80
Curso de Java SE - UTD
Como facilitar isto?
Como usar o conceito de Array, porém com um pouco mais de flexibilidade?
Coleções podem ser a saída para este problema. Uma das formas de pensar nas coleções é
como Arrays turbinadas, incrementadas com várias funcionalidades e regras.
A  definição   formal   de  Coleções  é:   estruturas  de   dados   utilizadas   para   armazenar   e
manipular informações, ou seja, são objetos que representam um grupo de objetos.
Esse capítulo tem como objetivo abordar as principais funcionalidades e regras de duas
das principais coleções do Java: List e Map.
Anotações
81
Curso de Java SE - UTD
10.2. Collection List ou Coleção Lista
Uma lista é uma coleção de elementos arrumados numa ordem linear, isto é, onde cada
elemento   tem   um   antecessor   (exceto   o   primeiro)   e   um   sucessor   (exceto   o   último).
Normalmente implementada como "Array" ou "Lista Encadeada". A Lista pode ser mantida
ordenada ou não e as operações mais importantes de uma coleção do tipo Lista são:
Adição de elementos
• Adicionar um objeto em qualquer lugar da lista, fornecendo o índice desejado;
Remoção de elementos
• Remover   um   objeto   presente   em   qualquer   lugar   da   lista,   fornecendo   o   índice
desejado;
 Acesso aos elementos
• Obter o elemento de qualquer posição da lista, fornecendo o índice desejado;
• Iterar sobre os elementos;
Pesquisa de elementos
• Descobrir se um certo elemento está na lista;
• Descobrir o índice de um certo elemento na lista (onde está);
Indagar sobre atributos
• Obter o número de elementos da coleção;
Em Java existem três classes que trabalham com a Coleção do tipo Lista ou List elas se
encontram no pacote/package java.util . São elas:
• Vector
• ArrayList
• LinkedList
Escolhemos explanar nesse capítulo a classe Java mais utilizada para implementar listas
que é a classe ArrayList.
82
Curso de Java SE - UTD
10.3.ArrayList
Acessando a documentação do Java 7 podemos visualizar todas as especificações dessa
classe, usada para programar coleções do tipo lista. Abaixo tabela com todos os métodos da
classe ArrayList:
83
Curso de Java SE - UTD
Desses   métodos   listados   na   documentação   do   Java   7   iremos   estudar   os   métodos
principais, os quais fazem as ações de  adição de elementos, remoção de elementos, acesso
aos elementos, pesquisa de elementos e indagar sobre atributos de uma determinada lista.
10.3.1. Criando uma Lista em Java usando a Classe ArrayList
Para  criar  uma  lista  usando a  Classe  ArrayList  do  Java,  escreva em seu programa a
seguinte linha de código:
tipo: tipo do objeto que você quer guarda na lista. Ex: Integer, String, Carro, Pessoa...
Exemplo:
Na versão 7 do Java você também pode criar uma lista dessa forma:
Observação:
Todas os códigos que trabalharem com listas usando a classe ArrayList precisam importar
a classe ArrayList. Isso pode ser feito adicionando a seguinte instrução no cabeçalho da
classe: 
import java.util.ArrayList;
10.3.2. Adicionando elementos  em uma Lista
Agora que você já criou seu objeto Lista você pode adicionar elementos dentro dela. As
Listas quando criadas elas não possuem nenhum elemento, ou seja, elas são Listas Vazias. 
Na Lista,  diferente do Array,    você  não especifica  seu  tamanho, ela  cresce de  forma
dinâmica à medida que você acrescenta dados a ela.
Vamos aprender como adicionar elementos a uma Lista, para isso iremos usar o método
add() que pertence a classe ArrayList.
84
Curso de Java SE - UTD
Exemplo:
O  método   add(),   usado   da   forma  mostrada   acima   ele   sempre   coloca   o  novo  dado
adicionado à lista na ultima posição da mesma, mas podemos utilizá­lo de outra maneira,
de tal forma que podemos escolher a posição em que queremos adicionar o novo elemento. 
Vamos ver como fica essa outra forma de usar método add().
Exemplo:
Para visualizar todos os lados da lista na forma de uma String use o método toString(),
desta forma:
Vamos aplicar esse método no exemplo em que criamos uma lista de anos, ficará desta
maneira:
85
Curso de Java SE - UTD
Saída do programa:
10.3.3. Removendo elementos de uma Lista
Para remover um dado da lista utilizamos o  método remove()  da classe ArrayList. O
método remove() funciona da seguinte forma:
Vamos aplicar esse método no exemplo em que criamos uma lista de anos, ficará desta
maneira:
86
Curso de Java SE - UTD
Outra forma de usar o método remove() é passando para o método o objeto que você
quer remover. Ficando desta forma:
Exemplo:
Saída do programa sem o método remove():
Saída do programa aplicando o método remove():
10.3.4. Acessando elementos da Lista
Para   acessar   um valor  de  uma  determinada   lista  usamos  o  método  get()  da   classe
ArrayList dessa forma:
Exemplo:
Temos métodos na classe ArrayList para auxiliar na interação da lista, ou seja, percorrer a
lista acessando os seus valores em todas as direções possíveis. 
Esses métodos precisam, além da lista que iram auxiliar a percorre, um objeto do tipo
87
Curso de Java SE - UTD
ListIterator onde esse objeto será como um leitor de posições da  lista que pode percorrer a
lista em todos os sentidos possíveis. 
Vamos entender melhor com o seguinte exemplo:
Vamos criar uma lista em Java, usando a classe ArrayList,  para guardar o nome das
linhas de ônibus de Fortaleza. 
Agora vamos criar um objeto do tipo ListIterator, onde esse objeto será como um leitor de
posições da lista que pode ser deslocado para frente e para trás ao longo de uma lista. Para
criar um objeto do tipo ListIterator precisamos importar a classe que cria esse objeto para o
nosso   programa,   pois   esse   objeto   não   pode   ser   instanciado   pela   classe   ArrayList.   A
importação da classe é feita adicionando a seguinte instrução no cabeçalho de sua classe:
import java.util.ListIterator;
Após   importar  o método podemos criar  nosso objeto do  tipo ListIterator  da seguinte
maneira:
Por fim, podemos usar os métodos da classe ArrayList que nos ajudam a percorrer uma
lista, da seguinte forma:
88
Curso de Java SE - UTD
Saída do programa:
De forma semelhante ao método hasNext() e o método next() podemos ainda usar em
nossos programas Java os seguintes métodos:
Métodos para auxiliar percorre uma Lista usando a classe ArrayList
   hasNext(): retorna true se o elemento lido pelo percorredorLista tem sucessor, caso
contrário retorna false;
  hasPrevious(): retorna true se o elemento lido pelo percorredorLista tem antecessor,
caso contrário retorna false;
   next(): faz o percorreLista avançar para a posição seguinte da lista e retornar o novo
valor lido;
 previous(): faz o percorreLista retroceder para a posição anterior da lista e retornar o
novo valor lido;
 nextIndex(): retorna o índice do elemento sucessor ao elemento lido pelo percorreLista;
89
Cursode Java SE - UTD
previousIndex():   retorna   o   índice   do   elemento   antecessor   ao   elemento   lido   pelo
percorreLista;
10.3.5. Pesquisando elementos na Lista
Pesquisar um elemento na lista é bastante simples. Vamos usar o método indexOf() que
se encontra na classe ArrayList para pesquisa em uma lista. Esse método retorna o valor do
índice do objeto procurado se ele existir  na lista, caso contrário retorna ­1.
Exemplo:
Saída do programa:
90
Curso de Java SE - UTD
10.4. Collection Map ou Coleção Mapa
Um mapa armazena pares (chave, valor) chamados itens, essas chaves e valores podem
ser de qualquer tipo, portanto, a chave é utilizada para achar um elemento rapidamente.
Estruturas especiais são usadas para que a pesquisa seja rápida, como "Tabela Hash" ou
"Árvore". Os dados armazenados nos mapas podem ser mantidos ordenados ou não (com
respeito às chaves). 
A coleção do tipo Mapa difere das Listas por diversas características, as principais são: 
• as estruturas de dados que as implementam;
• na   coleção   do   tipo   Mapa   podemos   escolher   o   tipo   e   o   valor   que   terão   as
chaves(índices), através delas teremos acesso aos dados. As chaves (índices) e dados dos
Mapas podem ser de qualquer tipo, inclusive um objeto. Já nas Listas somente os valores
armazenados   podem   ser   de   qualquer   tipo,   seus   índices   são   sempre   números   inteiros
indexados   a   partir   do   zero   de   forma   automática,   à   medida   que   vamos   adicionando
elementos à coleção.
As operações mais importantes de uma coleção do tipo Mapa são:
Adição de elementos
• Adicionar um item no mapa (fornecendo chave e valor)
Remoção de elementos
• Remover um item com chave dada
Acesso aos elementos
• Iterar sobre os itens
Pesquisa de elementos
• Descobrir se um elemento com chave dada está na coleção
Indagar sobre atributos
• Obter o número de elementos
• Observe que o acesso à coleção sempre é feita conhecendo a chave
 Vamos utilizar a classe HashMap para trabalhar com coleções do tipo mapa ou map.
91
Curso de Java SE - UTD
10.5.HashMap
A   classe   HashMap   é   uma   implementação   da   interface  Map   do   pacote   java.util,   e
possibilita   trabalhar   com  mapeamento   de   objetos   no   esquema   chave/valor,   ou   seja,
informada a chave, resgato o valor. 
Acessando a documentação do Java 7 podemos visualizar todas as especificações dessa
classe,  usada para programar coleções do tipo mapa/map. Abaixo  tabela com todos os
métodos da classe HashMap:
Vamos explanar os principais métodos da classe HashMap, métodos que nos permitirá
criar, adicionar, remover, selecionar e pesquisar itens em uma coleção do tipo Map.
10.5.1. Criando uma coleção do tipo Mapa usando a Classe HashMap
Para criar um mapa usando a Classe   HashMap do Java, escreva em seu programa a
seguinte linha de código:
tipo_da_chave: coloque o tipo que terá    a chave/índice do seu Map, essa chave será
usada para acessar os valores guardados no Map;
tipo_do_valor:  coloque o tipo que terá  os valores que serão guardados em seu Map;
92
Curso de Java SE - UTD
Pronto, dessa forma já instanciamos  uma coleção do tipo Map usando a classe HashMap.
Agora temos que inserir elementos a coleção do tipo Map , pois só criamos o Map, mas
não há elementos dentro dele. 
Lembre se de importar a Classe HashMap para seu programa, já que estamos usando­a
para   implementar  e   trabalhar   com Coleções  do   tipo  Mapa.  Podemos  importar  a   classe
colocando a seguinte instrução no cabeçalho do programa o qual estamos escrevendo:
import java.util.HashMap;
10.5.2. Adicionando elementos em uma coleção do tipo Mapa
Após criar o seu Map, podemos adicionar um elemento usando o método put() da Classe
HashMap da seguinte forma:
objeto_chave: valor do objeto que será a chave de acesso para os valores do mapa;
objeto_valor: valor do objeto que será guardado no mapa;
Exemplo:
Vamos criar um Map para guardar estados e suas respectivas capitais. Os estados serão as
chaves e as capitais serão os valores guardados no Mapa, ambos serão do tipo String.
Agora vamos adicionar os valores ao nosso mapa usando o método put,  da seguinte
forma:
Vamos usar o método toString() para visualizar como estão os dados dentro do nosso
mapa, da seguinte forma:
Saída do Programa:
93
Curso de Java SE - UTD
10.5.3. Removendo elementos em uma coleção do tipo Mapa
Para remover elementos de uma coleção do tipo Mapa usando os métodos da Classe
HashMap usamos o método remove().
objeto_chave: chave de acesso do elemento a ser removido do mapa;
O método remove() retorna uma String com o valor removido do mapa ou retorna o
valor null   se não for achado nenhum valor associado a chave passada no argumento do
método.
Exemplo:
Vamos remover uma capital do mapa cidadeEstado criado anteriormente. O código irá
ficar dessa maneira:
Saída do programa:
94
Curso de Java SE - UTD
10.5.4. Selecionando/Pesquisando elementos em uma coleção do tipo Mapa
O método   de   seleção  get()  da   classe  HashMap   é   o  mesmo  método   usado   para   se
pesquisar um valor dentro de um mapa. Esse  método funciona da seguinte forma:
objeto_chave: chave de acesso do elemento a ser selecionado/pesquisado do mapa;
Exemplo:
Saída do programa:
10.5.5. Número de elementos em uma coleção do tipo Mapa
Para sabermos o número de elementos contido em um mapa podemos utilizar o método
size(),  esse método pode ser usado de maneira semelhante com coleções do tipo Lista
usando a classe ArrayList.
O método size() funciona da seguinte forma:
A  chamada  ao  método   size()    nos   retorna  um valor   inteiro  que   é   a  quantidade  de
elementos de um mapa.
95
Curso de Java SE - UTD
Exemplo:
Saída do programa:
Anotações
96
Curso de Java SE - UTD
Capitulo 11. Interface Gráfica com Usuário –
GUI
11.1.Interface Gráfica com usuário ­ GUI
A   Interface  Gráfica   com  o  Usuário,   também conhecido   como  GUI   ­  Graphical   User
Interface, em Java, é feita através de bibliotecas de classes, sendo que a primeira a surgir
foi  a  AWT(Abstract  Window Toolkit).  A  AWT surgiu   já   na  versão  1.0,  mas   se   tornou
confiável  a partir  da versão 1.1. A maneira como as classes dessa biblioteca trabalham
garante   a   criação   dos   elementos   da   interface   de   usuário   seguindo   o   comportamento
destinado às ferramentas GUI nativas de cada plataforma (Windows, Mac, Solaris, ...).
Alguns exemplos destes elementos são: botões,   listas,  menus, componentes de textos,
contêineres (janelas e barras de menus), caixas de diálogo para abrir ou salvar arquivos,
além de elementos para manipulação de imagens, fontes e cores.
A portabilidade de plataforma funcionava bem em aplicações simples, mas aplicações que
envolviam elementos  mais  complexos,  como menus  e  barras  de  rolagem,  por  exemplo,
apresentavam diferenças de comportamento conforme a plataforma. O que aconteceu foi
que   as   aplicações   visuais   feitas   em   Java   não   se   pareciam,   e   nem   tinham  as  mesmas
funcionalidades, com as aplicações convencionais de cada plataforma.
97
Vamos trabalhar agora a interface 
gráfica do seu programa em Java!
Curso de Java SE - UTD
A partir da versão 2 do Java, a JFC (Java Foundation Classes) apresentou novos recursos
para   a   construção   da   GUI   das   aplicações,   o   que   melhorou   muito   os   problemas   de
portabilidade. São eles:
• Java 2D: novas funções para desenhos e gráficos.
• Drag & Drop: clicar, arrastar, copiar e colar.
• Swing:   biblioteca   de   classes   extensão   da   AWT,   onde   são   apresentados   novos
componentes   de   interface   e   o   que   é   conhecido   por   look   and   feel,   que   é   uma
adaptação perfeita daGUI ao sistema operacional específico de desenvolvimento.
É bom salientar que o Swing não substitui o AWT, mas é o kit de ferramentas GUI mais
utilizado para desenvolvimento de aplicações visuais. O AWT continua existindo, mantendo
a mesma arquitetura criada para o Java versão 1.1.
O Swing possui muito mais recursos, além de garantir maior portabilidade e, em boa
parte dos casos, é mais fácil de usar. Isso não significa que ou se utiliza AWT ou se utiliza
Swing, normalmente o que acontece é que elementos das duas bibliotecas são utilizados
conjuntamente nas aplicações.
11.2.Bibliotecas AWT e SWING
São as fontes das classes que utilizaremos a partir daqui. Nelas moram os componentes
gráficos para Java, e por isso devemos importá­las no início de nossas classes gerenciadoras
de telas:
• import javax.swing.*;
• import java.awt.*;
11.3.JFrame
Pode parecer estranho para quem vem de outras linguagens, como o Delphi ou o VB, mas
em Java, cada tipo de componente gráfico é uma classe com atributos e métodos próprios.
E para utilizá­las, devemos instanciá­las.
11.3.1. Camadas JFrame
Antes que possamos criar nossa primeira janela precisamos conhecer como funciona a 
hierarquia dos elementos que são responsáveis visualização gráfica. 
98
Frame
RootPane
LayeredPane
ContentPane
GlassPane
Curso de Java SE - UTD
Onde:
1. RootPane – Representa uma camada que irá gerenciar todas as camadas internas.
2. LayeredPane – Contém uma região para Barra de Menu e o ContentPane
3. ContentPane – Contém todos os Componentes como um campo de texto,campo de
seleção de opções, etc.
4. GlassPane – Camada que por padrão é invisível, porém pode ser usado para mostrar
algum componente por cima das demais, como uma imagem.
Agora que sabemos como como funciona um Jframe iremos criar nossa primeira janela
em java.
11.3.2. Nossa primeira Janela com JFrame
A primeira e mais simples chama­se JFrame, e cria telas retangulares sem nada dentro,
um espaço onde trabalharemos logo depois.
O método SetBounds trabalha com a localização e tamanho da tela, sendo a seguinte
ordem: distância do canto esquerdo da tela, distância do topo da tela, largura e altura.
tela.getContentPane().setBackground(Color.RED);
Aqui, invocamos o método que verifica qual é o campo de Content do JFrame, ou seja, a
região onde não está  o menu nem as bordas,  e  muda sua cor  a  partir  do método set
Background. Eu usei uma biblioteca de cores, a Color, e defini a janela como vermelha;
Poderia ter usado azul, cinza, verde, etc.
tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Aqui, eu determino qual a ação a executar quando este JFrame for fechado. No caso, ele
fecha o programa todo, num efeito de BREAK. A instrução DISPOSE_ON_CLOSE apenas
levará o JFrame a fechar sem derrubar o programa todo.
tela.setLayout(null);
Aqui,   escolhi  um Layout  para  o  meu JFrame.  Ou melhor,  escolhi  que  seja  nenhum.
Existem Layouts prontos para JFrames, onde os botões ficam dispostos em forma de fileira,
ou nos cantos, ou expandidos. A maioria tem um resultado grotesco. Se quisermos desenhar
nossa tela com liberdade para fazê­la bonita, temos que escolher o NULL;
tela.setVisible(true);
Depois de preparado, o JFrame pode já ficar visível. Este passo vem no final de toda a sua
montagem.
99
Curso de Java SE - UTD
Agora vamos ver como ficou nossa janela.
11.4. Criando uma classe com propriedades JFrame
No tópico anterior aprendemos como construir uma Janela usando as propriedades do 
JFRAME diretamente. Para a nossa janela criada, o método main tinha a responsabilidade 
direta  de criar uma janela. Para essa situação, se quiséssemos criar uma nova janela 
tínhamos que chamar novamente a Classe JFrame e atribuir todas as características 
novamente linha a linha. Podemos construir uma janela de uma forma melhor criando um 
próprio modelo com métodos, encapsulamento, herança e os demais recursos aprendidos 
sobre orientação a objetos. Para criar o nosso modelo de JFrame precisamos primeiro criar 
uma classe e herdá­la de JFRAME dessa forma:
Assim nossa classe chamada “MinhaJanela” herda todas as propriedades de JFrame 
através da classe Pai.
Podemos definir um padrão para qualquer janela criada partindo de “MinhaJanela”, 
vamos agora definir que toda janela nossa terá obrigatoriamente um título. Basta 
inserirmos um construtor e redirecionar esse valor para classe que tem a responsabilidade 
de receber o título de uma Janela.
No construtor
podemos também
definir qualquer outra propriedade na sua chamada, como coordenadas, cor do plano de 
fundo, procedimento utilizado quando for fechado a janela,layout, visibilidade, etc. Veja o 
Exemplo abaixo ainda no mesmo construtor :
100
Curso de Java SE - UTD
Agora indicamos que qualquer  instancia de “MinhaJanela” terá as mesmas propriedades,
sendo diferenciadas apenas pelo seu Título.
Vamos instanciar no método main a classe que acabamos de definir:
Temos então o mesmo resultado do tópico anterior, perceba que se quisermos criar uma 
2 janela por exemplo, não precisamos definir  todas as propriedades novamente, basta 
instanciar uma nova “MinhaJanela” definindo um segundo título, assim teremos uma nova 
janela.
Usando herança, podemos através da nossa classe definida acessar os elementos do 
Jframe baseado no seu nível de encapsulamento. No Exemplo abaixo usaremos o método 
setLocation()  para alterar a localização da nosssa janela. Esse método não foi criado por 
nós, mas foi definido pelas classes Pai nas definições de herança da Classe Jframe.
Temos então o seguinte resultado final:
Iremos usar o exemplo da Classe Minha Janela para criar os componentes nos próximos 
tópicos.
101
Curso de Java SE - UTD
11.5. JLabel
É   um  pequeno   componente   com o  qual   colocamos  pedaços  de   texto   sem  nenhuma
função, a não ser a de indicar para quê servem os campos de uma tela qualquer.
O   código   acima   não   apresenta   grandes   novidades.   Apenas   instanciamos   o   Jlabel,
dando­lhe um texto qualquer  para exibir.  Depois,  demos o mesmo setBounds nele,  em
seguida fizemos a ação realmente revolucionária:
super.getContentPane().add(texto);
Adicionamos   o   objeto   “texto”  na   tela   usando   super.getContentPane().   Note   que   o
setBounds do “texto” passa a usar como bordas as bordas do JFrame. E fica contido nele. 
O   JLabel   pode   ter   desenhos   por   dentro,   mas   veremos   isso   mais   adiante,   quando
tratarmos do Icon, outro tipo de objeto Java.
O resultado de nossa janela é esse:
102
Curso de Java SE - UTD
11.6. JButton
O JButton é, finalmente, o botão. Colocamos ele nas telas com inúmeras funções. Estas
funções   serão   tratadas  mais   adiante,   quando   chegarmos   às   aulas   sobre   Eventos.   Por
enquanto, basta­nos desenhar os botões.
O JButton poderá ser instanciado de três formas diferentes:
1. JButton() – aqui, teremos depois que rodar um método setText(“algum texto”) para
dar­lhe um conteúdo(um conteúdo que aparece para o usuário).
2. JButton(String) – aqui, escrevemos algum texto para aparecer no botão e o usuário
saber do que se trata.
3. JButton(icon)  –  neste  caso,  adicionamos uma figura ao botão para dar­lhe uma
aparência personalizada.
Veja este código:
No exemplo acima, usamos praticamente a mesma tela criada antes, porém adicionamos
as rotinas de criação de um botão. Primeiro, instanciamos  a classe  JButton  e usamos  os
métodos já conhecidos setBounds para definir suas coordenadas.
103
Curso de Java SE - UTD
A nossa janela ficará assim:
11.7. JTextField
O JTextField é uma caixa utilizada para que o usuário possa escrever um texto de uma
linha só.  Trata­se  de um componente bastante simples, que tem basicamente as mesmas
especificações do que acabamos de ver nos componentes anteriores.Enriquecendo o código anterior, adicionando um JTextField:
104
Curso de Java SE - UTD
O tratamento do texto de um JTextField dar­se­á  por meio de dois métodos bastante
simples:
getText() – servirá para capturar o quê o usuário digitou no campo.
setText() – servirá para determinarmos que texto deve ir no campo. Muito útil quando se
abre um registro de um banco de dados e o campo JTextField deve receber um campo de
registro para alteração.
A nossa janela ficará assim após acrescentar o JTextField:
11.8. Icon
A classe Icon tem um uso bastante simples, mas muito importante. Com ela, podemos
carregar uma imagem (devidamente criada em um arquivo JPG ou PNG), para dentro do
programa, utilizando esta imagem como quisermos. 
Primeiro temos que inserir uma imagem no seu projeto, crie uma pasta dentro do seu
projeto chamada “img” e nela coloque qualquer imagem, em seguida insera uma imagem
chamada “logo.png”;
Em sua Janela faça o seguinte código
105
Curso de Java SE - UTD
No   exemplo   acima   carregamos   as   informações   da
Imagem   que   importamos,   em   seguida   pastindo   da
construição   de   uma   ImageIcon   passando   como
argumento   url   indicada,     capturamos   apenas   as
informações   de   Icon   para   ser   utilizada   nos   nossos
compontens,  alguns  componentes  aceitam Icon como
argumento no contrutor, como Jbutton,  Jpanel, etc... 
11.9. Editando fonte com o setFont()
Podemos formatar as fontes de nossos botões  e rótulos...
Vamos usar o método setFont dessa forma:
Nossa janela ficará assim:
11.10. JMenuBar, JMenu e JMenuItem
Estas classes são utilizadas sempre em conjunto, para criar um menu na parte superior do
JFrame, e deixar seu software com aquela facilidade de uso que os usuários modernos
exigem.
Aqui,  começamos a  trabalhar  uma modalidade de programação que costumo chamar
informalmente   de   “empilhamento   de   objetos”,   pois   os   objetos   só   funcionam   quando
colocamos um dentro do outro em uma espécie de pirâmide.
O objeto que serve de base é o JMenuBar, adicionado diretamente ao JFrame, e sobre ele
vão todas as coisas. Ele é a barra clara no alto do JFrame, dentro da qual os menus ficarão. 
Depois,  temos os JMenu, que ficam dentro da MenuBar e podem, inclusive, ficar um
dentro do outro. Dentro dos JMenu,  ficam os JMenuItem, que têm uma função cada um.
Para ativar suas funções, utilizaremos os Listeners, mais adiante. Deixemos isso para outro
capítulo.
Criando uma janela, um JMenuBar(container de menus), Menus(JMenu) e por fim itens
de menus(JMenuItem).
106
Curso de Java SE - UTD
Agora vamos adicionar o JMenuBar dentro da janela, depois adicionar os JMenus dentro
do JmenuBar, e por fim adicionar dentro do JMenu itens de menus(JMenuItem) .
A ultima linha de código representa um método que será responsável pelas configurações
da janela Principal, veja a baixo a sua implementação.
107
Curso de Java SE - UTD
Agora vamos ver como ficou nossa
nossa janela :
11.11. JCheckBox
Uma JCheckBox é um daqueles componentes em que vemos uma caixinha quadrada com
uma frase ao lado, e podemos marcar ou desmarcar a caixinha quadrada. 
As  CheckBoxes   não   são  usadas   para   fazer   escolhas   com  apenas   uma   opção   válida,
podendo ser todas marcadas ou todas desmarcadas livremente, desde que o programador
não coloque restrições no próprio código.
Veja como trabalhar com  JCheckBox no exemplo de código abaixo:
Depois,  para   termos  um  retorno  do   valor   de   cada   JCheckBox,  utilizamos  o  método
isSelected(), que retorna um valor boolean. 
108
Curso de Java SE - UTD
Assim:
boolean x = cbPizza.isSelected();
Ou ainda:
if (cbPizza .isSelected()) {
­ Funções a serem executadas.
}
Veja como ficou nossa janela:
11.12. JRadioButton
O JRadioButton funciona apenas quando pensamos nele inserido em um grupo. Eu posso
colocar  quantas opções quiser,   formando um menu,  e   se   todos os  meus  JRadioButtons
estiverem no mesmo grupo, o usuário só poderá marcar um deles. Ao marcar um, os outros
perdem a marcação. Para isso, temos que adicionar também um ButtonGroup.
109
Curso de Java SE - UTD
Veja o código abaixo e saiba como trabalhar com JRadioButton.
Veja como ficou nossa janela:
11.13. JComboBox
A JComboBox desenha uma caixinha parecida com a JTextField,  só  que ao  invés  de
termos   um   texto   a   escrever,   temos   uma   seta   com   a   qual   abrimos   uma   fileira   de
possibilidades de preenchimento para a caixa.
Veja  como trabalhar  como trabalhar  com JcomboBox,  observando o exemplo abaixo:
110
Curso de Java SE - UTD
Para obter o retorno das informações, temos uma série de métodos que nos dizem o que,
afinal, o usuário escolheu. Os mais usados são os seguintes:
comb.getSelectedItem()
Este retorna o texto que está na caixa do Combo. Poderá ser usado especialmente para
quando colocamos o setEditable em TRUE, ou seja, quando o usuário pode escrever na
caixa. O retorno deste método é uma String, com o texto da caixa.
comb.getSelectedIndex();
Este método retorna o índice do item selecionado (como se as opções fossem um vetor). 
Veja abaixo o resultado:
11.14. Mais Componentes Swing
Existem mais componentes Swing, além dos mostrados até  aqui.  Foram mostrados os
principais componentes. Caso você  precise ou deseje conhecer mais componentes Swing
acesse: 
http://docs.oracle.com/javase/7/docs/api/ 
Anotações
111
Curso de Java SE - UTD
Capitulo 12. Gerenciadores de Layout
12.1. Gerenciadores de Layout
Gerenciamento de layout ( Layout Management ) é o processo de determinar o tamanho
e  a  posição  dos   componentes  na   janela  gráfica  do  programa.  É   ele  o   responsável  por
determinar  onde  o   componente   irá   ficar,   como   irá   ficar,   qual  o   comportamento  a   ser
tomado na hora de redimensionar a tela. 
Por padrão o Java vem com cinco gerenciadores de layout: BorderLayout, BoxLayout,
FlowLayout,   GridBagLayout,   GridLayout   e   um   adicional   chamado  CardLayout.   São   os
gerenciadores de layout que determinam como os componentes irão ficar em seu programa,
portanto um bom conhecimento sobre o funcionamento dos mesmos faz­se necessário para
ter domínio de programação gráfica em Java. 
Geralmente, quando chamamos o método "add" para adicionar um componente na tela,
ele será posicionado de acordo com o gerenciador de layout previamente configurado. A
maior parte simplesmente vai adicionando os componentes com base na ordem em que
foram programados,  porém alguns  outros,   como  o  BorderLayout,  necessitam que   você
informe a posição relativa no container. 
A escolha do gerenciador de layout depende muito das necessidades do programa. Por
padrão todos objetos  Containers  são configurados para usar o FlowLayout, enquanto um
JFrame e JDialog já usam o BorderLayout como padrão. 
Em ambos  os   casos  é   usado  o  método   "setLayout"   para   especificar  um novo   layout
manager, sendo necessário passar para este método o tipo que desejamos. Abaixo há um
exemplo para cada tipo de gerenciador de layout, ficando assim fácil para vermos como
cada um se comporta. 
112
Curso de Java SE - UTD
12.2. BorderLayout
BorderLayout trabalha como algumas coordenadas predefinidas , como norte, sul , leste , 
oeste e centro. Para poder usar esse recurso temos que antes usar o método setLayout que 
antes era definido como “null”  para uma nova instancia de BorderLayout.
Veja o Exemplo abaixo.
Veja como ficou nossa janela:
113
Curso de Java SE - UTD
12.3.BoxLayout
Um BoxLayout coloca os componentes em uma única linha ou coluna, permitindo ainda 
que você especifique o alinhamento deles. Para que um BoxLayout possa existir temos que 
passar como argumento no seu construtor o container que será aplicadoe um alinhamento 
que poderá ser horizontal ou vertical, representado pelas constantes estáticas da classe 
BoxLayout : X_AXIS (para alinhamento horizontal dos meus componentes) e Y_AXIS (para 
alinhamento horizontal)
Nossa janela ficará dessa forma:
114
Curso de Java SE - UTD
12.4.FlowLayout
Como dito anteriormente, um FlowLayout é o gerenciador padrão de todo Container, 
caso não seja especificado outro. FlowLayout posiciona os componentes lado a lado. Ela se 
diferencia de um BoxLyout pois seus componentes podem se alinha horizontalmente e 
verticalmente baseando­se nas dimensões do container. Veja o exemplo de sua aplicação.
Veja como ficou nossa janela:
115
Curso de Java SE - UTD
12.5.GridLayout
Um GridLayout atua como uma grade de uma planilha de cálculo, colocando os 
componentes em linhas e colunas pré­determinadas e deixando os componentes com o 
mesmo tamanho, para isso precisamos definir um limite de linhas e colunas para esse 
layout. Veja isso no exemplo abaixo
Veja como ficou nossa janela:
116
Curso de Java SE - UTD
12.6.GridBabLayout
O mais flexível gerenciador de layout é o GridBagLayout. Ele permite colocar 
componentes em grades de colunas, sendo possível um componente ocupar mais de uma 
coluna ao mesmo tempo. As linhas também não precisam necessariamente ter os mesmos 
tamanhos, ou seja, você pode configurar diferentes larguras e alturas de acordo com a 
necessidade. Eis o exemplo abaixo.
Veja como ficou nossa janela:
Logicamente é possível fazer muito mais com os gerenciadores
de layout, há várias maneiras de configurar e utilizar. Para obter
mais informações sobre os métodos disponíveis para cada um
consulte a API, disponível em:
http://docs.oracle.com/javase/7/docs/api/
117
Curso de Java SE - UTD
Capitulo 13. Eventos (Listeners)
Eventos em Java nada mais é que métodos especiais que são realizados baseado em 
alguma ação de um usuário, seja ele, um clique, um digitar de uma tecla, ao passar o 
mouse, etc.. Iremos ver nos próximos tópicos como como utilizar esses métodos especiais 
em nossos projetos.
13.1.ActionListener
O ActionListener. Trata­se de uma classe que detecta se houve uma ação em uma 
referencia a que ela está associada (um botão, por exemplo) e que, dependendo da ação, 
executará uma função. ActionListener é representado por uma interface, então para que a 
minha classe possa realizar tratamento de eventos, a primeira implementação que iremos 
fazer é dar um “implements” na classe que queremos ter essa funcionalidade , vejamos o 
exemplo abaixo:
Iremos também criar uma caixa de texto e um botão para utilizar um evento que irá 
capturar o que foi digitado e imprimir na tela.
A Implementação  ActionListener irá obrigar a minha classe a conter um método 
chamado , actionPerformed, com um parâmetro do tipo “ActionEvent”.  Veja a 
implementação abaixo.
Agora iremos construir nosso layout:
Os métodos que iremos utilizar para criar o evento são, addActionLIstener e 
setActionCommand, eles serão responsáveis por redirecionar e enviar um comando para o 
método que nós criamos actionPerformed.
118
Curso de Java SE - UTD
• addActionListener : Método que irá receber uma classe que irá conter uma 
implementação actionListener, no nosso caso, nossa própria classe terá esse método, 
o motivo do argumento “this” no exemplo anterior.
• SetActionCommand : Método que irá enviar uma instrução para o método 
actionPerformed, com esse recurso, podemos por exemplo criar outros outros botões 
enviando outros comandos para o mesmo método realizando assim outras funções 
em uma mesma janela. No exemplo acima utilizamos um comando que definimos 
como “OK”.
Iremos agora ver como irá iremos implementar o método actionPerformed: O processo é 
bem simples, caso o ActionCommand do evento “e” seja igual a “OK” (comando que 
definimos usando setActionCommand), uma caixa com uma mensagem aparecerá na tela 
informando o nome digitado.
Se para modificar um comando utilizamos o método setActionCommando, para que 
possamos resgatar o que foi modificado usaremos os método getActionCommando e 
compararemos com o comando que queremos acionar.
Agora iremos capturar o que foi digitado na caixa de texto, o exemplo acima mostra que 
chamamos o atributo txtNome que foi definindo com JtextField e utilizar o método 
getText() que tem como retorno uma String, essa String será capturada impressa na tela no
momento do clique do botão. Vejamos o resultado dessa operação:
Importante: Antes de passa para o próximo tópico, tenha certeza que entendeu todos os 
processos envolvido, pois os próximo eventos serão implementações semelhantes.
119
Curso de Java SE - UTD
13.2.FocusListener
O FocusListener se parece com o ActionListener em seu modo de construção, mas serve 
para detectar quando o foco (ou seja, o cursor, a seleção, não o ponteiro do mouse) está 
sobre um objeto ou não.
Ele possui dois métodos que precisam ser implementados: o focusGained e o focusLost, 
um para quando o objeto ganha foco e outro para quando perde.
Para ativar o método, usamos addFocusListener. Usando esse recurso iremos mostrar um 
exemplo de alteração da cor de uma plano de fundo baseado em um foco em uma caixa de 
texto. Veja o exemplo abaixo:
O resultado Final :
120
Curso de Java SE - UTD
13.3.KeyListener
O KeyListener é uma interface  que serve para que possamos coordenar as ações do 
usuário com o teclado quando ele está escrevendo em algum espaço ou utilizando alguma 
função. Posso atribuir KeyListener a qualquer objeto gráfico do Java  e detectar quando e o 
que o  usuário está teclando.
A implementação KeyListener obriga a ter 3 métodos :
• keyTyped:  Será ativado ao pressionar um botão caractere ou numérico do teclado.
• keyPressed: Será ativado ao segurar um botão, como SHIFT, CTRL, ALT etc.
• KeyReleased : Será ativo ao deixar de pressionar o botão.
Para ativar o método, usamos addKeyListener. No exemplo abaixo alteramos a cor de 
plano de fundo da caixa de texto para cada uma das ações realizadas pelo usuário. 
NOTA: Pode­se detectar qual o botão apertado pelo usuário explorando a variável 
“KeyEvent e”, que retornará o código da tecla apertada com o método : getKeyChar()
121
Curso de Java SE - UTD
13.4.MouseListener
O MouseListener, como seu nome obviamente revela, serve para tratarmos eventos 
relacionados ao uso do mouse.
A implementação MouseListener obriga a ter 5 métodos :
• mouseClicked: Será ativado no clique simples do mouse.
• mousePressed: Será ativado ao segurar o clique no mouse.
• mouseReleased: Será ativado ao deixar o clique do mouse.
• mouseEntered : Será ativado ao entrar na região do componente pelo mouse.
• mouseExited: Será ativa ao deixar a região do componente pelo mouse.
Para ativar o método, usamos addMouseListener. O código abaixo mostra como alterar o 
plano de fundo do Container usando eventos do mouse Veja a implementações dos 
métodos abaixo :
Dica: Nós podemos 
saber qual é a localização
do ponteiro do mouse 
utilizando dois métodos:
getX() – retorna a 
posição do mouse no 
eixo X (horizontal) 
dentro do objeto a que 
estamos atribuindo o 
MouseListener.
getY() – Faz o mesmo,
só que com a posição do 
eixo Y (vertical).
122
Curso de Java SE - UTD
Bibliografia
• http://www.guj.com.br/
• http://pt.wikipedia.org/wiki
• http://jedi.wv.com.br/
• http://docs.oracle.com/javase/7/docs/api/ 
• http://jacques.dsc.ufcg.edu.br/cursos/p2/html/ed/colecoes.htm
• http://www.xti.com.br/carreira/universidade­xti.htm 
• http://pt.scribd.com/doc/86301078/Apostila­Java 
123
	Introdução
	Capitulo 1. O que é a linguagem java.
	1.1. - Histórico da linguagem.
	1.2. Uso da linguagem no mercado atualmente(especificação das tecnologias).
	1.3. Principais características da linguagem deprogramação java
	1.4. Ambientes e ferramentas de desenvolvimento com java.
	1.4.1. Instalação do JDK ou SDK e JRE e suas configurações.
	1.5. Meu primeiro programa em java
	1.5.1. Comentários em Java:
	1.5.2. Compilando meu primeiro programa em Java
	1.5.3. Dicas para resolução de problemas em programas java
	1.6. Erros comum em programas java
	1.6.1. Erros em java:
	1.6.2. Erro em tempo de compilação :
	1.6.3. Erro em tempo de execução:
	1.7. Netbeans
	1.8. Visão de outras IDEs para o desenvolvimento com java
	1.8.1. IDE Eclipse
	1.8.2. A IDE Bluej
	1.8.3. A IDE Gel
	1.8.4. A IDE Jdeveloper
	1.9. Identificadores e palavras-chaves.
	1.10. Tipos primitivos:
	1.10.1. Uso de valores literais de todos os tipos de dados existentes.
	1.10.1.1. Literais Inteiros:
	1.10.1.2. Literais decimal:
	1.10.1.3. Literais octal:
	1.10.1.4. Literais hexadecimal:
	1.10.1.5. Literais de ponto flutuante:
	1.10.1.6. Literais booleanos:
	1.10.1.7. Literais de caracteres:
	1.10.1.8. Literais para String:
	1.11. Operadores em Java:
	1.11.1. Operadores de atribuição composto.
	1.11.2. Operadores de comparação.
	1.11.3. Igualdade de tipos primitivos :
	1.11.4. Igualdade de variáveis de referências:
	1.11.5. Operador Instanceof:
	1.11.6. Operador concatenação de strings:
	1.12. Operadores aritméticos.
	1.12.1. Operador resto (%) :
	1.12.2. Operadores de Incremento e Decremento:
	1.12.6. OBS: A diferença que nesse caso podemos visualizar os resultados, 5,4 e 3;
	1.12.7. Exercício resolvido
	1.12.8. Operadores relacionais:
	1.12.9. Operadores lógicos.
	1.12.10. Os operadores Bitwise :
	1.12.11. Operadores lógicos de abreviação:
	1.12.12. Operadores lógicos ^ e !:
	1.12.13. Operadores condicionais.
	1.12.14. Operador Ternário
	1.12.15. Precedência de Operadores
	Capitulo 2. Controle de fluxo em java.
	2.1. Utilizar código que use instruções if
	2.1.1. Expressões válidas para instruções if
	2.1.2. Expressões válidas para instruções if-else
	2.1.3. Expressões válidas para instruções if-else-if.
	2.2. Expressões válidas para instruções switch e case.
	2.3. Loops e iteradores (usando os loops for, while e do while).
	2.3.1. Loop do while:
	2.3.2. Loop for:
	2.4. Loop for aprimorado (para arrays).
	2.5. Uso de break, continue e return.
	2.5.1. Break:
	2.5.2. Continue:
	2.5.3. Return:
	Capitulo 3. Tipos de Variáveis, Constantes e Casting.
	3.1. O que é uma variável :
	3.1.1. Tipos de Variáveis:
	3.2. Variáveis estáticas:
	3.3. Constantes
	3.4. Conversão ou Cast (explícita e implícita das variáveis de tipos primitivos).
	3.5. Atribuindo uma variável de referência a outra.
	3.5.1. Escopo de variáveis.
	3.5.2. Variáveis de instâncias de tipos primitivos.
	Capitulo 4. POO com Java
	4.1. Introdução
	4.2. Classe, Atributos e Métodos.
	4.3. Construindo uma Classe.
	4.4. Encapsulamento.
	4.5. Retorno
	4.6. Construtores, métodos seteres e geteres.
	4.6.1. Construtores
	4.6.2. Métodos seteres e geteres
	4.7. Estanciando (Construindo um Objeto)
	4.8. Variáveis Estáticas
	Concluímos então que as variáveis estáticas não pertencem especificamente a nenhuma instancia de objeto e sim uma referencia da classe. O que explica a substituição do termo “this” para o nome da classe que que contém a variável estática, no exemplo acima alteramos o termo “this” no método setOndeVivo pelo nome da classe que contém a variável estática (Pessoa).
	4.9. Métodos Estáticos
	Capitulo 5. Herança e Interface.
	5.1. Introdução
	5.2. Herança
	5.3. Object: A superclasse cósmica do java
	5.3.1. Construtores da subclasse
	5.3.2. Classe Abstrata
	5.4. Interface
	Capitulo 6. Herança (Polimorfismo )
	6.1. Introdução
	6.2. Sobrecarga.
	6.3. SobreEscrita
	6.4. Polimorfismo
	Capitulo 7. Tratamento de Exceções
	7.1. Capturando uma exceção usando o bloco (try e catch).
	7.1.1. Finally
	7.1.2. Lançado uma exceção com o throws.
	7.1.3. Criando uma exceção com throw.
	Capitulo 8. UML
	8.1. Introdução
	8.1.1. Diagrama de Atividade:
	8.1.2. Diagrama de Sequencia
	8.1.3. Diagrama de Caso de Uso
	8.1.4. Diagrama de Classe
	8.2. Abrindo o Projeto
	Capitulo 9. Fila e Pilha
	9.1. Fila
	9.1.1. Implementando Fila em Java
	9.2. Pilha
	9.2.1. Implementando Pilha em Java
	Capitulo 10. Coleções: List e Map
	10.1. Introdução a Coleções/Collections
	10.2. Collection List ou Coleção Lista
	10.3. ArrayList
	10.3.1. Criando uma Lista em Java usando a Classe ArrayList
	10.3.2. Adicionando elementos em uma Lista
	10.3.3. Removendo elementos de uma Lista
	10.3.4. Acessando elementos da Lista
	10.3.5. Pesquisando elementos na Lista
	10.4. Collection Map ou Coleção Mapa
	10.5. HashMap
	10.5.1. Criando uma coleção do tipo Mapa usando a Classe HashMap
	10.5.2. Adicionando elementos em uma coleção do tipo Mapa
	10.5.3. Removendo elementos em uma coleção do tipo Mapa
	10.5.4. Selecionando/Pesquisando elementos em uma coleção do tipo Mapa
	10.5.5. Número de elementos em uma coleção do tipo Mapa
	Capitulo 11. Interface Gráfica com Usuário – GUI
	11.1. Interface Gráfica com usuário - GUI
	11.2. Bibliotecas AWT e SWING
	11.3. JFrame
	11.3.1. Camadas JFrame
	11.3.2. Nossa primeira Janela com JFrame
	11.4. Criando uma classe com propriedades JFrame
	11.5. JLabel
	11.6. JButton
	11.7. JTextField
	11.8. Icon
	11.9. Editando fonte com o setFont()
	11.10. JMenuBar, JMenu e JMenuItem
	11.11. JCheckBox
	11.12. JRadioButton
	11.13. JComboBox
	11.14. Mais Componentes Swing
	Capitulo 12. Gerenciadores de Layout
	12.1. Gerenciadores de Layout
	12.2. BorderLayout
	12.3. BoxLayout
	12.4. FlowLayout
	12.5. GridLayout
	12.6. GridBabLayout
	Capitulo 13. Eventos (Listeners)
	13.1. ActionListener
	13.2. FocusListener
	13.3. KeyListener
	13.4. MouseListener
	Bibliografia