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.