Java SE em Portugues Excelente Apostila Curso Completo de Introdução A Java SE

Java Fundamentals
Java Fundamentals

I

Sumrio Sumrio Sumrio Sumrio
1. 1. 1. 1. A tecnologia Java e configurao do ambie A tecnologia Java e configurao do ambie A tecnologia Java e configurao do ambie A tecnologia Java e configurao do ambiente nte nte nte.............. .............. .............. .............. 1 11 1- -- -1 11 1
Objetivos .......................................................................................................................1-2
O que Java? .............................................................................................................1-3
Simples e orientada a objetos...................................................................................1-5
Uma linguagem robusta.............................................................................................1-7
Multiplataforma e interpretada ................................................................................1-9
A Java Virtual Machine - JVM.................................................................................1-11
Uma Linguagem Segura e Dinmica.....................................................................1-14
Aspectos de segurana...........................................................................................1-16
O Just in Time Compiler - JIT.....................................................................................1-18
O Java Standard Development Kit J2SDK..........................................................1-19
Configurando o ambiente.......................................................................................1-22
APIs da linguagem...................................................................................................1-23
2. 2. 2. 2. Tipos e O Tipos e O Tipos e O Tipos e Operadores peradores peradores peradores ................................ ................................ ................................ .................................................... .................... .................... .................... 2 22 2- -- -1 11 1
Objetivos .......................................................................................................................2-2
Variveis ........................................................................................................................2-3
Tipos primitivos e tipos compostos ............................................................................2-4
Tipos Primitivos ..............................................................................................................2-6
Declarando um tipo primitivo..................................................................................2-10
Tipo caracter char ..................................................................................................2-12
Tipo booleano boolean.........................................................................................2-14
Tipos inteiros - byte, short, int e long .......................................................................2-15
Tipos de ponto flutuante - float e double..............................................................2-17
Tipo composto String..............................................................................................2-19
Converses de tipos casting.................................................................................2-20
Tipos de referncia....................................................................................................2-22
Expresses e operadores..........................................................................................2-23
Sumrio de operadores............................................................................................2-25
Precedncia...............................................................................................................2-27
Associatividade..........................................................................................................2-28
Tipos de operadores: unrios e binrios ................................................................2-29
3. 3. 3. 3. Criando classes e objetos Criando classes e objetos Criando classes e objetos Criando classes e objetos ................................ ................................ ................................ ........................................... ........... ........... ........... 3 33 3- -- -1 11 1
Objetivos .......................................................................................................................3-2
Classes e Objetos.........................................................................................................3-3
Criando uma classe ....................................................................................................3-4
Padres..........................................................................................................................3-6
Java Fundamentals
II
Criando e importando pacotes................................................................................3-9
Static import................................................................................................................3-11
Criando objetos .........................................................................................................3-12
O que a referncia null?.......................................................................................3-13
Atribuindo referncias...............................................................................................3-15
Visibilidade aplicada a classes ...............................................................................3-16
Definindo operaes ................................................................................................3-18
Comando return........................................................................................................3-21
Visibilidade para operaes ...................................................................................3-22
Definindo atributos ....................................................................................................3-25
Visibilidade aplicada a atributos ............................................................................3-26
Acessando atributos .................................................................................................3-32
Comentrios no cdigo fonte.................................................................................3-33
Escopo das variveis.................................................................................................3-36
Passando Tipos Primitivos para Mtodos ...............................................................3-39
Passando Referncias para Mtodos ....................................................................3-40
Exerccios.....................................................................................................................3-42
4. 4. 4. 4. Comandos da Linguagem Comandos da Linguagem Comandos da Linguagem Comandos da Linguagem ................................ ................................ ................................ ........................................... ........... ........... ........... 4 44 4- -- -1 11 1
Objetivos .......................................................................................................................4-2
Comandos ....................................................................................................................4-3
Comando if / else / else if ..........................................................................................4-4
Seqncia de Clusulas else if ..................................................................................4-7
Operador ternrio .......................................................................................................4-9
Comando switch .......................................................................................................4-10
Comando while.........................................................................................................4-13
Comando do .............................................................................................................4-14
Comando for..............................................................................................................4-15
Comando for-each ...............................................................................................4-18
Comando break........................................................................................................4-19
Comando continue ..................................................................................................4-21
Exerccios.....................................................................................................................4-24
5. 5. 5. 5. Aprofundando o estudo sobre Classes Aprofundando o estudo sobre Classes Aprofundando o estudo sobre Classes Aprofundando o estudo sobre Classes......................... ......................... ......................... ......................... 5 55 5- -- -1 11 1
Objetivos .......................................................................................................................5-2
Viso Geral ...................................................................................................................5-3
Overloading sobrecarga de operao ...............................................................5-4
Mtodos construtores .................................................................................................5-6
Referncia this..............................................................................................................5-9
Compartilhando cdigo entre Construtores ........................................................5-11
Mtodo destrutor finalize() ....................................................................................5-12
Variveis de instncia...............................................................................................5-13
Mtodos de instncia...............................................................................................5-15
Variveis de classe....................................................................................................5-16
Inicializando Variveis de Classe............................................................................5-19
Mtodos de classe ....................................................................................................5-20
Java Fundamentals
III
Exemplos de variveis e mtodos estticos .........................................................5-22
O mecanismo de herana entre classes ..............................................................5-23
Herdando estrutura e comportamento.................................................................5-24
Especificando herana em Java...........................................................................5-25
Objetos de subclasses...............................................................................................5-26
Chamando construtores da superclasse...............................................................5-27
Overloading e Overriding de mtodos..................................................................5-29
Redefinindo mtodos overriding..........................................................................5-30
Referncia super........................................................................................................5-33
Invocando mtodos da superclasse......................................................................5-35
Visibilidade protected ..............................................................................................5-36
Varargs ........................................................................................................................5-37
Polimorfismo................................................................................................................5-39
Modificador final........................................................................................................5-41
Enums...........................................................................................................................5-43
Exerccios.....................................................................................................................5-46
6. 6. 6. 6. Colees, Arrays, Strings, e Wrapper Classes Colees, Arrays, Strings, e Wrapper Classes Colees, Arrays, Strings, e Wrapper Classes Colees, Arrays, Strings, e Wrapper Classes ............... ............... ............... ............... 6 66 6- -- -1 11 1
Objetivos .......................................................................................................................6-2
Strings .............................................................................................................................6-3
Criando Strings .............................................................................................................6-4
Concatenando Strings................................................................................................6-5
Executando operaes em objetos String..............................................................6-6
Comparando duas Strings .........................................................................................6-8
Obtendo strings a partir de objetos..........................................................................6-9
Convertendo tipos primitivos em strings ................................................................6-10
Wrapper Classes ........................................................................................................6-11
Converses com Wrapper Classes .........................................................................6-12
StringBuffer e StringBuilder ........................................................................................6-13
Arrays ...........................................................................................................................6-14
Arrays de tipos primitivos ..........................................................................................6-15
Declarando arrays de tipos primitivos....................................................................6-16
Criando arrays............................................................................................................6-17
Inicializando arrays ....................................................................................................6-18
Arrays de objetos .......................................................................................................6-20
Declarando arrays de objetos ................................................................................6-21
Inicializando arrays de objetos................................................................................6-22
Utilizando arrays de objetos .....................................................................................6-23
Arrays e Excees......................................................................................................6-24
Arrays multidimensionais...........................................................................................6-25
O mtodo main(String[] args)........................................................................6-26
API Colletion ...............................................................................................................6-27
A interface Iterator ....................................................................................................6-28
A interface Enumeration ..........................................................................................6-29
Interfaces do framework ..........................................................................................6-30
A classe ArrayList........................................................................................................6-31
A classe Vector ..........................................................................................................6-32
Java Fundamentals
IV
A classe Hashtable....................................................................................................6-34
A classe LinkedList......................................................................................................6-35
Generics ......................................................................................................................6-36
Autoboxing.................................................................................................................6-39
Exerccios.....................................................................................................................6-43
7. 7. 7. 7. Tratamento de Excees Tratamento de Excees Tratamento de Excees Tratamento de Excees................................ ................................ ................................ ............................................. ............. ............. ............. 7 77 7- -- -1 11 1
Objetivos .......................................................................................................................7-2
Introduo....................................................................................................................7-3
1
a
Vantagem: Separao de Cdigo.....................................................................7-4
2
a
Vantagem: Propagao de Erros........................................................................7-6
3
a
Vantagem: Agrupar Tipos de Erros ......................................................................7-8
4
a
Vantagem: Excees no so Ignoradas........................................................7-10
Manipulando Excees............................................................................................7-11
Tratando Excees....................................................................................................7-13
Manipulando Excees............................................................................................7-14
Manipulando Excees: Exemplo Prtico.............................................................7-16
Propagando Excees.............................................................................................7-17
Lanando Excees .................................................................................................7-18
Criando Excees .....................................................................................................7-19
Capturando Excees e Levantando Excees Diferentes..............................7-20
Exerccios.....................................................................................................................7-22
8. 8. 8. 8. Classes abstratas e Interfaces Classes abstratas e Interfaces Classes abstratas e Interfaces Classes abstratas e Interfaces ................................ ................................ ................................ ..................................... ..... ..... ..... 8 88 8- -- -1 11 1
Objetivos .......................................................................................................................8-2
Abstrao .....................................................................................................................8-3
Definindo classes abstratas........................................................................................8-4
Mtodos Abstratos.......................................................................................................8-6
Definindo mtodos abstratos ....................................................................................8-7
Interfaces ......................................................................................................................8-8
Exemplos de interfaces...............................................................................................8-9
Definindo Interfaces ..................................................................................................8-10
Implementando Interfaces ......................................................................................8-11
Exerccios.....................................................................................................................8-13
Java Fundamentals

1-1
1
1
.
.
A
A
t
t
e
e
c
c
n
n
o
o
l
l
o
o
g
g
i
i
a
a
J
J
a
a
v
v
a
a
e
e

c
c
o
o
n
n
f
f
i
i
g
g
u
u
r
r
a
a
o
o
d
d
o
o
a
a
m
m
b
b
i
i
e
e
n
n
t
t
e
e

A tecnologia java e configurao do ambiente
1-2
Objetivos
Compreender os fundamentos da tecnologia Java
Discutir vantagens da tecnologia
Entender o funcionamento da JVM (Java Virtual Machine)
Configurar o ambiente de desenvolvimento para o programador

1-3
O que Java?

Linguagem orientada a objetos, simples, portvel, interpretada,
distribuda, robusta, segura, dinmica, de alto desempenho, multi-thread e
independente de plataforma
Projetada pela Sun Microsystems inicialmente para dispositivos eletrnicos
Utilizada posteriormente em navegadores web, para permitir que uma
aplicao pudesse ser desenvolvida e executada na web. Aqui o
nascimento da tecnologia applet
Uma linguagem muito utilizada atualmente para desenvolvimento de
sistemas que precisam rodar na web bem como sistemas desktop

Breve Histrico

Java comeou em 1991, quando um grupo de analistas da Sun, liderados
por Patrick Naughton e James Gosling, procurou desenvolver uma linguagem de
computador que fosse usada em equipamentos domsticos, tais como
comutadores de canais para TV a cabo, videocassetes e outros.
Como estes equipamentos no dispem de muita memria ou velocidade,
a linguagem tinha de ser reduzida e gerar cdigo eficiente. Alm disto, como
diferentes fabricantes poderiam escolher diferentes CPUs, tal linguagem no
poderia se restringir a uma nica arquitetura.
O projeto ficou conhecido como Green Project.

DUKE, um dos smbolos do Java

Visando satisfazer todas estas exigncias, a equipe de analistas optou por
uma linguagem que gerasse cdigo intermedirio (os famosos bytecodes Java),
e que a interpretao deste cdigo no fosse feita diretamente pelo hardware e
sim por uma mquina virtual disposta sobre ele (conhecida hoje como JVM
Java Virtual Machine).
Esta linguagem foi batizada inicialmente com o nome Oak (que, em
portugus significa carvalho). Possivelmente o nome escolhido por Gosling se
deve a um carvalho que existia em frente a sua janela na Sun MicroSystems.
1-4
Posteriormente se descobriu que Oak j era o nome de uma outra
linguagem, e o nome foi ento trocado para Java.
Java no obteve muito sucesso como linguagem de controle de
eletrodomsticos (e isto ns podemos muito bem atestar :-). Em vo, a equipe do
Green Project tentou vender a idia para fabricantes de tais dispositivos.
Dissolvida a equipe, por absoluta falta de xito econmico, alguns dos antigos
componentes perceberam que uma das possveis utilidades para tal linguagem
seria embuti-la em navegadores, como os encontrados no mercado.
Tais aplicativos exigiam justamente uma linguagem independente de
plataforma, confivel, segura e em tempo real: todas as caractersticas
estranhas que Java possua.
1-5
Simples e orientada a objetos

Uma linguagem simples e orientada a objetos
Baseada em Smalltalk e C++
A tecnologia de objetos para esta linguagem foi baseada em Smalltalk
Reaproveitou grande parte da sintaxe utilizada pelo C e C++
Eliminou construes de C++ consideradas complexas ou desnecessrias
Reduzido conjunto de palavras reservadas e um grande poder de
expresso

Uma Linguagem Orientada a Objetos

Problemas surgidos na rea de engenharia de software, tais como aumento
explosivo da complexidade dos sistemas, dificuldades na manuteno e
evoluo dos softwares existentes, fraca robustez apresentada pelos aplicativos e
outros, fizeram com que os paradigmas de anlise e desenvolvimento de
software fossem alterados.
Java surge junto com o boom da orientao por objetos, ampla
aceitao deste paradigma pelos tcnicos de informtica como o mais
adequado a enfrentar os problemas encontrados.
A cultura dos tcnicos da equipe de desenvolvimento da Sun Microsystems
fez com que, entre as linguagens orientadas por objetos conhecidas,
escolhessem C++ como modelo para o desenvolvimento de Java. C++ era ento
uma das mais difundidas linguagens de programao orientada por objetos em
voga no mundo UNIX.
Mas C++ era complexa demais. Vrias construes em C++ eram de
questionvel utilidade e de difcil implementao por parte dos construtores de
compiladores.
Herana mltipla e sobrecarga de operadores, por exemplo, eram
construes que demandavam grande esforo por parte dos implementadores e
que no fazem parte do ncleo mnimo exigido pelo paradigma. Desta forma
alguns recursos ficaram de fora e decidiu-se manter inicialmente uma gama
menor de recursos para viabilizar o projeto e manter o mesmo mais somples.
Atualmente alguns recuros mais sofisticados como Generics foram includos. Os
recursos bsicos que foram atendidos na poca so:
Abstrao
1-6
Encapsulamento
Herana
Polimorfismo
Decidiram ento simplificar:
A linguagem no seria compilada para uma plataforma nativa e sim
para uma mquina virtual. Esta tcnica que d ao java a possibilidade
de rodar em mltiplas plataformas foi baseada no Smalltalk
No haveria programao genrica (na poca, mas a partir da verso
1.5 este recurso j suportado)
No haveria sobrecarga de operadores
Herana mltipla seria substituda pelo mecanismo de interfaces, mais
simples e com poder de expresso equivalente
A velha sintaxe, tomada de emprstimo da linguagem C, seria
enxugada, de modo a conter somente as palavras reservadas
necessrias

Destas idias iniciais surge ento a tecnologia Java. Claro que h muito mais
coisas presentes no java do que as listadas acima. Atualmente o java uma
tecnologia to completa que permite voc desenvolver aplicaes para rodar
na Web, em mquinas cliente, Celulares, Palm Tops e muito mais.
1-7
Uma linguagem robusta

Java uma linguagem fortemente tipada
Ampla verificao de erros e checagem de tipos em tempo de
compilao
No existem apontadores na linguagem
Linguagem multiplataforma
Gerncia automtica da memria (garbage collection)

Erro de Ponteiro?

Um dos principais objetivos dos projetistas da linguagem era conseguir
conciliar a flexibilidade e o poder da orientao por objetos com a segurana e
a robustez da checagem de tipos e erros em tempo de compilao.
Java uma linguagem fortemente tipada.
E o que queremos dizer com isto?
Que, em tempo de compilao, so checados todos os problemas
referentes passagem de parmetros e atribuies de variveis no que diz
respeito compatibilidade de tipos entre a varivel que recebe o valor e a
varivel atribuda.
Outra importante caracterstica da linguagem Java fato de no possuir
apontadores, com o sentido que tal termo possui em C ou em C++.
Em C ou C++ perfeitamente possvel navegarmos despreocupadamente
pela memria do processo: basta, para tal, declararmos um apontador para
uma regio de memria e sairmos a increment-lo ou decrement-lo.
Toda a aritmtica com apontadores no s permitida pela linguagem,
como tambm incentivada.
Em Java no h apontadores explcitos, nem tampouco aritmtica de
apontadores, mas sim referncias feitas a objetos criados.
Objetos so criados atravs do operador new e o espao de memria que
ocupam automaticamente gerenciado por um sistema de coleta de lixo
(garbage collection) , que o libera to logo no haja mais referncias a um
objeto.
1-8
Com isto, no existem em Java os erros de ponteiro (dangling pointers,
memory leak e outros) to conhecidos de linguagens como C e C++.
1-9
Multiplataforma e interpretada

Ao contrrio das outras tecnologias onde os programas so compilados
para um sistema operacional especfico, os fontes Java so compilados para
uma mquina virtual. Isto significa que aps a compilao os mesmos, so
executados por uma mquina virtual (JVM) e no diretamente pelo sistema
operacional. Abaixo veja a forma tradicional de compilao dos programas e
mais abaixo a forma como funciona o Java.

Figura 1-1: Compilao em C++.
Em linguagens tradicionais como C, C++ ou pascal, o cdigo fonte
convertido para um conjunto de instrues de mquina da plataforma de
hardware onde a compilao teve lugar. Este programa executado
diretamente pela CPU da mquina e est vinculado plataforma em que foi
compilado: s poder ser executado por CPUs que compartilhem o mesmo
conjunto de instrues, o que geralmente significa ficar limitado a um
determinado fabricante de hardware ou a uma famlia de produtos.

Figura 1-2: Compilao em Java.
1-10
Java adota uma filosofia diferente. Os fontes Java no so convertidos
diretamente para instrues de mquina. Ao contrrio, a partir da compilao
dos fontes so gerados arquivos contendo cdigo intermedirio que independe
de plataforma.
O cdigo intermedirio Java, conhecido como bytecode Java, foi
projetado para uma mquina hipottica. Contm instrues similares a de uma
mquina real (operaes aritmticas, controle de fluxo, etc.), mas no tem em
vista, e nem se limita, a uma determinada arquitetura de computador.
Em vez de ser executado diretamente pelo hardware, este cdigo
interpretado por uma JVM (Mquina Virtual Java Java Virtual Machine). Desta
forma, em qualquer arquitetura onde exista uma JVM ser possvel executar um
programa Java sem a necessidade de se re-compilar os fontes.
Os binrios Java (cdigo intermedirio ou Java bytecode) so
independentes de plataforma ou, dito de outra maneira, neutros quanto
arquitetura da mquina.
Os fontes Java so armazenados em arquivos com a extenso .java. A
compilao dos arquivos .java trar como resultado arquivos com a extenso
.class.
Arquivos com a extenso .class contm somente Java bytecodes e so
tambm conhecidos como binrios Java. Cabe novamente ressaltar que os
binrios Java (arquivos .class) no so executados diretamente pelo hardware
e sim interpretados pela JVM.
Sem a JVM no h como executar nenhum programa Java.

1-11
A Java Virtual Machine - JVM

Camada intermediria e isolante entre o sistema operacional e as
aplicaes Java.
Elimina a dependncia do cdigo quanto arquitetura e quanto s
facilidades do SO.
Responsvel pela interpretao dos bytecodes Java.
Traduz os bytecodes em instrues de mquina e em chamadas de
sistema (API do SO).
Pode ser implementada atravs de um programa avulso ou estar
embutida em um navegador (Browser).
A mquina virtual Java (ou, como comumente chamada, JVM, Java
Virtual Machine) integra o ambiente de programao e execuo Java. Ela
responsvel por interpretar os bytecodes Java e traduzi-los em instrues reais de
mquina e em chamadas de sistema (syscalls).

Figura 1-3: Esquema de independncia da JVM.
Desta forma, as requisies feitas por um programa Java a recursos do
sistema so mapeadas pela JVM em requisies feita ao SO sobre o qual a JVM
executa. O SO responde a tais requisies e estas respostas so encaminhadas
ao cdigo Java em execuo.
Uma vez compilado um programa Java, os binrios (bytecodes Java)
podem ser executados em toda a plataforma para a qual j a JVM j tenha sido
portada. Atualmente, a grande maioria dos sistemas operacionais conhecidos
possui uma implementao da JVM (Solaris, Windows98, WindowsNT, Linux,
MacOS, HP-UX, AIX, etc.).
1-12
A JVM pode ser implementada atravs de um programa avulso, pode estar
embutida em um navegador, fazer parte do ncleo de um banco de dados, ou
mesmo integrar o kernel de um SO.
A nica exigncia que se faz execuo de um aplicativo Java a
existncia da JVM para aquele ambiente.
Como executam os programas java

A linguagem Java orientada a objetos, com linhas de execuo (threads)
dinmicas e muitos outros recursos. Mas o que faz a diferena o modo como os
programas Java so executados. Eles rodam dentro de mquinas virtuais (virtual
machines), que ficam dentro do computador. Por isso, um programa Java no
tem contato com o computador real, ele conhece apenas a mquina virtual.
Logo, os programas Java so independentes de plataforma. Se voc j precisou
desenvolver programas para vrios sistemas operacionais, sabe que isso uma
grande vantagem.
Quando voc escreve um programa Java e o compila, ele est pronto para
ser executado em qualquer PC que contenha a mquina virtual Java. De certa
forma, voc est escrevendo para apenas uma plataforma: a mquina virtual.
A virtual machine determina o que os programas Java podem ou no fazer.
Os programas escritos em linguagens compiladas, como C ou C++, so
executados diretamente pelo sistema operacional. Assim sendo, eles tm acesso
direto a todos os recursos do sistema, incluindo memria e sistema de arquivos.
Como os programas Java so executados de dentro da mquina virtual, as
pessoas (programadores e desenvolvedores) que criam a mquina virtual podem
decidir o que um programa pode ou no fazer no computador. O ambiente
criado para os programas Java chama-se ambiente de runtime. A mquina
virtual age como um firewall (barreira) entre o computador e o programa Java.
Um programa nunca acessa os dispositivos de entrada e sada, o sistema de
arquivos ou mesmo a memria do seu computador. Em vez disso, ele pede que a
mquina virtual faa isso.
Quando rodamos as applets, elas so descarregadas para uma mquina
virtual que probe o acesso ao sistema de arquivos. Assim, ela s permite acesso
indireto aos recursos do sistema.
Por ser uma linguagem interpretada, isso explica a independncia de
plataforma Java.
1-13

Por que interpretada?
Porque o compilador Java gera o bytecode (cdigo especial Java), que
ser executado por uma mquina virtual implementada em software, chamada
de JVM Java Virtual Machine (Mquina Virtual Java).
A diferena entre o Java que uma linguagem interpretada, comparada
com uma linguagem compilada, como o caso do C ou C++ que enquanto
nessas linguagens tradicionais, para cada plataforma precisamos que o
compilador gere um cdigo especifico, como por exemplo, para um PC. Se
quisermos que o mesmo programa rode em um Macintosh, precisaremos
compil-lo para rodar em Macintosh e assim por diante. J com o Java isso no
aconteceria, pois para rodarmos um programa feito em Java, usamos o
interpretador Java (contido na JVM) para executar o bytecode resultante da
compilao. Como o bytecode Java independente de plataforma, os
programas Java podem rodar em qualquer plataforma para a qual a JVM tenha
sido portada. A JVM inclui o interpretador mais o sistema de runtime.
Em um ambiente interpretado, a fase de linkagem que existem no
desenvolvimento de programas tradicionais compilados praticamente
desaparece. O equivalente em Java fase de linkagem consiste apenas do
processo de carregar novas classes no ambiente de execuo da JVM.
Esse um processo leve e incremental, que ocorre em tempo de execuo.
Isso diferente do ciclo compilar-linkar-rodar, mais trabalhoso, comum em
linguagens como C e C++. O resultado uma reduo no tempo de
desenvolvimento dos programas.
Agora, depois dessa explicao, fica claro o que eles quiseram dizer com a
frase "Write once, Compile once and Run anywhere" ("Escreva uma vez, compile
uma vez e rode em qualquer lugar"), frase esta que se tornou uma das marcas
registradas de Java.

1-14
Uma Linguagem Segura e Dinmica

Os bytecodes de Java so constantemente policiados pela JVM
Instrues no autorizadas levantam excees de segurana
A carga das classes feita de maneira dinmica
Uma classe pode ser carregada atravs da rede ou do disco local da
mquina
Figura 1-4: Fluxo de compilao e execuo de uma classe Java
Durante a execuo de um programa Java, a JVM pode importar cdigo
de qualquer lugar. A fim de tornar, a linguagem segura, necessrio ou nos
certificarmos de que o local de onde o cdigo se origina seguro, ou policiarmos
constantemente o cdigo inseguro contra eventuais violaes de segurana.
A primeira opo implementada atravs de sistemas de assinatura digital
de cdigo.
A segunda opo, por sua vez, de responsabilidade do sistema de
runtime. Cabe a este policiar a execuo dos bytecodes Java, verificando se
no h, entre eles, nenhuma instruo no autorizada, que viole as regras de
segurana estabelecidas pela linguagem.
1-15
O carregador de classes do sistema de runtime assegura que classes com
origem em uma fonte local (classes Built-in) e classes provenientes da rede sejam
armazenadas separadamente.
Durante a execuo, o sistema de runtime sempre procura resolver primeiro
uma referncia nas classes locais. Isto garante que classes locais no sejam
substitudas por classes carregadas a partir da rede (fonte insegura).
Elimina a possibilidade de sobrescrita de classes seguras (spoofing) por
classes no confiveis. O acesso ao sistema de arquivos locais e aos recursos de
rede controlado por classes da linguagem (Built-in classes). Estas classes so
restritivas por default. Se cdigo importado e classificado como inseguro tenta
acessar o sistema de arquivos, os mecanismos de segurana avisam
imediatamente ao usurio.
1-16
Aspectos de segurana

Talvez pelo fato de Java estar fortemente associado Internet, um dos
aspectos mais divulgados da linguagem sua segurana. Isso natural: sem a
certeza da segurana, provavelmente ningum iria querer baixar cdigo de um
site desconhecido na Internet e deixar que ele rodasse em seu computador.E no
entanto, isso j est sendo feito todos os dias com os applets Java.
Java foi projetado com a segurana em mente. Por isso, oferece vrias
camadas de controles de segurana que protegem contra cdigo malicioso,
permitindo que os usurios rodem tranqilamente programas de origem
desconhecida, como os applets.
No nvel mais baixo, a segurana uma conseqncia da robustez de Java.
Como j vimos, os programas Java no podem forjar ponteiros para a memria,
nem estourar arrays, nem ler memria que esteja fora das fronteiras de um array
ou string. Esses recursos so uma das principais defesas de Java contra cdigo
malicioso. Ao impedir totalmente qualquer acesso direto memria, toda uma
enorme classe de ataques segurana evitada.
A segunda barreira contra cdigo malicioso o processo de verificao do
bytecode que executado pelo interpretador Java sobre qualquer cdigo de
origem desconhecida que carregado. Essa verificao assegura que o cdigo
seja bem formado isto , que ele no avance na memria que fica acima ou
abaixo dos limites da pilha (stack overflow ou underflow), nem implemente
bytecode ilegal. Se esse passo de verificao do bytecode no existisse, cdigo
corrompido por incompetncia ou m f poderia tirar partido de pontos fracos
na implementao de um interpretador Java.
Outra camada de proteo para segurana comumente chamada de
modelo de caixa de areia (sandbox): o cdigo de origem desconhecida pode
rodar, mas mantido isolado dentro de uma caixa de areia, onde pode rodar
em segurana sem causar qualquer dano ao "mundo real", que o ambiente
Java como um todo.
Quando um applet, ou outro cdigo de origem desconhecida est rodando
dentro da caixa de areia, ele fica submetido a diversas restries sobre o que
pode fazer. A mais bvia dessas restries que ele no tem acesso de nenhum
tipo ao sistema de arquivos local. Existem ainda vrias outras restries caixa de
areia. Na verdade, existe uma classe, chamada SecurityManager, especialmente
para cuidar da implementao dessas restries. Para assegurar o
funcionamento do modelo de segurana, todas as classes do ncleo Java que
executam operaes de risco, como acesso ao sistema de arquivos, primeiro
pedem permisso ao SecurityManager atualmente instalado. Se a chamada est
sendo feita, direta ou indiretamente, por cdigo de origem desconhecida, o
gerenciador de segurana lana uma exceo, impedindo a operao.
1-17
A verso Java 1.1, implementa um recurso adicional questo da
segurana: a assinatura digital. Anexando uma assinatura digital ao cdigo Java,
a origem desse cdigo pode ser estabelecida de uma forma criptograficamente
segura e impossvel de falsificar.
Desta forma, o usurio pode definir que uma determinada pessoa ou
organizao merece sua confiana. A partir da, o cdigo que traz a assinatura
digital dessa entidade merece confiana mesmo que seja carregado atravs da
rede, podendo rodar sem as restries do modelo de caixa de areia.
Porm, quando se trata de segurana, preciso ser realista. Da mesma
forma que nunca se pode garantir que um programa seja 100% livre de bugs,
nenhuma linguagem ou ambiente pode ter a garantia de ser 100% seguro.
Dentro desses limites, Java com certeza oferece um bom nvel de segurana
para a maioria das aplicaes prticas. Java antecipa e se defende contra a
maioria das tcnicas que tm sido usadas para fazer com que software tenha
comportamento malicioso.
A segurana de Java foi intensamente testada por experts em segurana e
tambm por hackers. Desta forma, foi possvel sanar alguns furos de segurana
encontrados nas primeiras verses de Java. igualmente razovel esperar que
quaisquer furos que venham a ser descobertos no futuro sejam sanados com a
mesma rapidez.

1-18
O Just in Time Compiler - JIT

Traduzem bytecodes Java para instrues nativas da mquina.
Evitam a reinterpretao de blocos de cdigo Java.
teis se o mesmo bloco de cdigo executado mais de uma vez.
Otimizam a execuo de blocos de cdigo repetitivos, como laos
(for/while).

A JVM transforma os bytecodes Java em instrues nativa de mquina. Se
um bloco de cdigo executado diversas vezes, a JVM tem o trabalho
reinterpretar este mesmo bloco de cdigo toda vez que o fluxo de execuo o
atingir.
Mas porque interpretar um bloco de cdigo que no muda e j foi uma vez
interpretado?
Uma nova tcnica, conhecida como compilao sob demanda (Just-in-
Time Compilation ou JIT Compilation), foi ento desenvolvida para contornar este
tipo de situao. Compiladores JIT, quando encontram um bloco de bytecodes
Java pela primeira vez, o traduzem de maneira definitiva para instrues nativas
de mquina.
Se o mesmo bloco executado novamente, no h porque novamente
interpret-lo: as instrues nativas de mquina resultado da compilao Just-in-
Time assumem o controle da execuo, dispensando a necessidade de
interpretao. Compiladores JIT aumentam o desempenho de programas Java,
fazendo-os rodar mais rapidamente, uma vez que dispensam a necessidade de
tradues sucessivas e inteis de um mesmo bloco de bytecodes Java.
Os ganhos de desempenho so mais significativos quando da otimizao de
laos e funes recursivas, em que um mesmo bloco de cdigo
exaustivamente repetido.
1-19
O Java Standard Development Kit J2SDK

Abaixo temos uma figura que mostra toda a plataforma java de
desenvolvimento. Observe que existem muitas tecnologias presentes nesta
plataforma. Voc no precisa saber todas elas para trabalhar com java.
Colocamos esta figura de forma que voc possa ver algumas importantes, as
quais listamos abaixo:

[ javac ] Compilador Java, traduz programas Java para bytecodes
[ java ] Interpretador de bytecodes, para executar programas java
[ appletviewer ] Visualizador de applets, l uma pgina HTML, carrega o
applet referenciado pela pgina e o executa, mostrando em sua prpria
tela a entrada e sada do applet
[ javadoc ] Gerador de documentao, ferramenta que gera
automaticamente documentao em HTML a partir dos comentrios do
cdigo fonte Java
[ jar ] Empacotador de aplicaes java, para a gerao e manuteno
de archives (jar). O formato de arquivos JAR possibilita o agrupamento de
mltiplos arquivos em um nico, que recebe o nome de Java Archive (ou
.jar). Desta forma, um nico arquivo .jar tipicamente contm vrios
binrios Java (arquivos .class) e arquivos auxiliares de recursos utilizados
pelo applet ou application Java
[ javap ] Disassembler, ferramenta recebe como entrada um binrio
Java (arquivo .class) e fornece como sada uma lista de comandos
assembly da mquina virtual Java referentes ao binrio analisado, ou uma
lista de prottipos de classes encontradas no binrio
[ Swing ] Framework para criao de interfaces drficas
[ Java Web Start ] Tecnologia para distribuio de software
[ JDBC ] Framework para conexo com banco de dados

1-20

Arquitetura da tecnologia java

Na figura abaixo voc tem listadas as tecnologias que fazem parte da
verso 5.0 do Java. Estas tecnologias so parte do JRE (Java Runtime
Environment) e do JDK ( Java Development Kit).

Figura 1-5: Estrutura do JDK e JRE

1-21

Figura 1-6: Relao dos grupos de tecnologias

1-22
Configurando o ambiente

Para trabalhar com a linguagem java na sua mquina preciso configurar
algumas coisas antes de escrever o promeiro programa. Estas configuraes no
so necessrias na mquina do usurio que ir rodar a sua aplicao, sendo
configuraes somente para a mquina do desenvolvedor.

Voc precisar adicionar as seguintes variveis de ambiente ao sistema
operacional que estiver utilizando:

1) JAVA_HOME - local onde foi instalado o java na sua mquina. Esta
varivel utilizada por programas para localizar a mquina virtual java
e o compilador

2) CLASSPATH esta varivel contm o caminho onde esto as
classes/bibliotecas java que o programa ir utilizar. Se voc baixar
algum pacote jar da internet com classes que desejar utilizar, ser
necessrio colocar o caminho deste pacote nesta varivel para que as
classes do mesmo sejam localizadas no momento da compilao

3) PATH esta varivel importante estar configurada para poder rodar os
programas que esto localizados dentro do diretrio bin da sua
instalao do java

Verso para windows:

JAVA_HOME=C:\jdk1.5
CLASSPATH=%JAVA_HOME%\lib\tools.jar
PATH=%JAVA_HOME%\BIN;%PATH%
Codigo 1-1: Configurao das variveis de ambiente para windows

Verso para linux:

JAVA_HOME=/jdk1.5
CLASSPATH=$JAVA_HOME/lib/tools.jar
PATH=$JAVA_HOME/bin;$PATH
Codigo 1-2: Configurao das variveis de ambiente para linux

1-23
APIs da linguagem

Java possui um conjuntomuito grande classes para serem utilizadas no
desenvolvimento de palicaes. Estas classes esto organizadas em pacotes que
fazem parte do JDK. Abaixo voc tem alguns dos principais pacotes que sero
utilizados para o desenvolviemtno de aplicaes. Para ter uma viso do todo
basta acessar a documentao do JDK atravs de um browser. Siga o seguinte
link para isto:

http://java.sun.com/j2se/1.5.0/docs/api/

java.applet Fornece as classes necessrias para a criao de um applet e
para a comunicao que posteriormente se estabelece entre
o applet e o contexto em que executa.

java.awt Contm todas as classes para a criao de interfaces grficas
do usurio e controle de imagens.

java.beans Contm as classes relacionadas aos desenvolvimento de Java
Beans.

java.io Permite entrada e sada atravs de data streams, serialization e
sistema de arquivos.

java.lang Classes relacionadas ao prprio projeto da linguagem Java,
referindo-se manipulao e converso de tipos, strings,
threads e ambiente de execuo.

java.math Classes utilizadas para aritmtica de inteiros de preciso
arbitrria (BigInteger) e para a aritmtica de decimais de
preciso arbitrria (BigDecimal)

java.net Classes contendo facilidades de comunicao em rede
(manipulao sockets, resoluo de nomes, estabelecimento
de canais de comunicao).

java.security Classes e interfaces relacionadas s questes de segurana.

java.sql Classes que permitem interface com o banco de dados (JDBC)

java.text Classes e interfaces para manipulao de texto, datas,
nmeros e mensagens.

java.util Miscelnea de classes auxiliares: tratamento do tempo, gerador
de nmeros aleatrios, vetores de bits, internacionalizao do
aplicativo, manipulao de archives Java, etc.

javax.swing Conjunto de componentes visuais peso leve que, com o
mximo grau de compatibilidade possvel, funcionam da
1-24
mesma maneira em todas as plataformas.

Tabela 1-1: Pacotes mais comuns da API J2SDK
1-25
Espao para anotaes
Java Fundamentals

2-1
2
2
.
.
T
T
i
i
p
p
o
o
s
s
e
e
O
O
p
p
e
e
r
r
a
a
d
d
o
o
r
r
e
e
s
s

Tipos e operadores
2-2
Objetivos
Compreender as seguintes estruturas:
o Variveis
o Tipos Primitivos
o Literais
Compreender os tipos de dados primitivos:
o char
o boolean
o byte, short, int, long
o float, double
Compreender os tipos de dados compostos
Apreender converses de tipos
Conceituar expresses e operadores
Definir precedncia e associatividade entre estruturas
Tipos e operadores
2-3
Variveis

Java uma linguagem fortemente tipada.
Isto significa que a utilizao de qualquer varivel deve ser compatvel com
a sua prvia definio.
Compete ao compilador da linguagem verificar, antes mesmo da execuo
do programa (isto , de maneira esttica), se h a referida compatibilidade entre
definio e uso de uma varivel.
Os contextos em que uma varivel pode ser validamente empregada so
determinados pelo seu tipo. O tipo determina a utilizao: restringe as operaes
aplicveis e concede sentido ao resultado de uma operao vlida (semntica
da operao). Seria contra-senso somarmos um tipo booleano com outro tipo
booleano ou, ainda pior, multiplicarmos um booleano por um nmero fracionrio.
Qual a resposta esperada para estas operaes?
No h resposta, porque a operao frente aos tipos carece de coerncia.
Ao definirmos um inteiro (ou um nmero real, ou um booleano, etc.), estamos a
dizer quais operaes so vlidas quando aplicadas a este inteiro (real,
booleano, etc.) e quais simplesmente carecem de sentido.
Decorrem do fato de Java ser fortemente tipada:
Todas as variveis em Java devem ter um tipo associado (a fim de que se
possa avaliar futuramente se os empregos dados a esta varivel so ou
no corretos)
A utilizao de uma varivel deve ser posterior sua definio
As converses foradas de tipo (casts) devem ser rigidamente controladas
pela linguagem, tanto sob o aspecto esttico (no se permitindo
converses entre tipos distintos, e autorizando to somente a converso
entre tipos derivados), quanto sob o aspecto dinmico (controle em
tempo de execuo das converses de tipo efetuadas).
No se permitem converses implcitas de tipo. Todas as converses de
tipo devem ocorrer de maneira expressa.
Tipos e operadores
2-4
Tipos primitivos e tipos compostos

Tipos primitivos so aqueles tipos j embutidos na linguagem java e
estudados no captulo anterior, enquanto tipos compostos so todas as classes
da linguagem java ou classes que voc venha a criar.
Variveis de tipos primitivos so tratadas de uma maneira bem diferente de
variveis de referncias para objetos ( variveis de tipos compostos). bastante
importante saber quais so estas diferenas e porque Java foi projetada desta
forma.

Variveis de tipos primitivos

Quando voc declara uma varivel de um tipo primitivo, Java aloca um
pedao de memria que grande o suficiente para guardar valores do tipo
primitivo declarado. Se voc define uma varivel de tipo primitivo como uma
varivel de instncia, a varivel inicializada para 0 se for inteira, para false se
for booleana e para '\0' se for caractere.
Variveis de tipos primitivos armazenam o seu valor diretamente. Se voc,
por exemplo, declara uma varivel do tipo int e atribui um valor 3 para esta
varivel, o valor armazenado diretamente nos quatro bytes reservados para a
varivel.

Variveis de referncias para objetos (tipos compostos)

Quando voc declara uma varivel de referncia, voc tambm recebe
um pedao de memria, mas esta memria grande o suficiente para
armazenar apenas uma referncia para o objeto. Talvez seja til pensar em uma
referncia como um apontador para o objeto.
Como mencionado antes, declarar uma varivel de referncia no cria um
objeto do tipo especificado. Conseqentemente, uma varivel de instncia
inicializada para null a fim de indicar que ainda no recebeu referncia para
nenhum objeto ainda.
Tipos e operadores
2-5
Use o operador de atribuio para fazer com que uma varivel de
referncia se refira a uma instncia de uma classe. A atribuio pode ser para
um objeto existente ou para um objeto recm criado atravs do operador new.
Tipos e operadores
2-6
Tipos Primitivos

Tipos primitivos so aqueles fornecidos diretamente pela linguagem, ou seja,
tipos j embutidos na linguagem. So tipos atmicos, indivisveis e sobre os quais
a linguagem, de ante mo, j oferece operaes pr-definidas. Exemplos de
tipos primitivos so inteiros e booleanos. Para us-los, basta associ-los a uma
varivel. A maior parte das linguagens permite ao programador criar tipos
compostos. Tipos compostos procuram representar de maneira conjunta e
unificada os vrios atributos de uma entidade modelada. Um catlogo telefnico
pode ser representado dentro de um programa como uma lista de Strings
contendo nomes, outra contendo os endereos e, por fim, uma outra contendo
os telefones.
Todas as informaes necessrias pesquisa ou manipulao do
catlogo esto presentes em tais listas. Mas esta definitivamente no a melhor
maneira de se representar um catlogo telefnico. Se perguntarmos a algum o
que um catlogo, dificilmente ouviremos como resposta uma lista de nomes,
endereos e telefones.
A resposta mais provvel uma lista de assinantes. Um assinante, por sua
vez, identificado pelo nome que possui ou endereo onde reside. Ao
procurarmos descobrir o telefone de um assinante, pesquisaremos pelas chaves
que o identificam: nome ou endereo. A representao estruturada da
informao , em si, informao relevante. Ao modelarmos um catlogo como
uma lista de assinantes e identificarmos um assinante pelo seu nome ou
endereo, estamos trazendo para dentro do programa no apenas informao
contida em um catlogo, mas tambm a prpria estrutura de um catlogo:
informao sobre como a informao organizada.
Os tipos compostos no so apenas armazns de dados. A sua funo
principal no conter o dado, pois para isto j temos tipos primitivos. O seu
objetivo principal organizar a informao. Aproximar a estrutura empregada na
confeco do modelo da estrutura existente no mundo real modelado. Tornar a
tarefa de programar mais intuitiva, permitindo uma relao direta entre o modelo
e o objeto modelado. A representao do dado dentro do programa facilita a
compreenso do prprio programa como modelo. No basta fazer um programa
(modelo) que funcione. necessria tanto uma compreenso do mundo real
atravs do programa, quanto uma compreenso do prprio programa como
modelo do mundo real.
Tipos compostos so construdos tendo como blocos construtores tipos
primitivos ou, de maneira recursiva, outros tipos compostos. Em ltima anlise, os
tipos primitivos so os nicos responsveis pela construo dos tipos compostos.
Um tipo composto nada mais que um conjunto organizado de tipos primitivos.
Tipos compostos sero vistos em captulos posteriores.
Tipos e operadores
2-7
Java possui oito tipos primitivos: boolean, char, byte, short, int, long,
float e double. Cada um destes tipos ser estudado de maneira mais
detalhada nas sees seguintes. A tabela abaixo apresenta um resumo dos tipos
primitivos encontrados na linguagem Java.
Cumpre observar que o tamanho do tipo em bytes e a sinalizao fazem
parte da especificao da linguagem.
Ou seja, um char em Java ocupar sempre 16 bits, um int 32 bits, um long
64 bits, e assim por diante, independente da plataforma em que o programa
esteja sendo executado.
Tipos e operadores
2-8
Tabela 2-1: Tipos primitivos e suas caractersticas.
Ao contrrio do que acontece com outras linguagens de programao, as
caractersticas dos tipos de dados listados acima idependem da plataforma em
que o programa dever ser executado.
Dessa forma, os tipos de dados primitivos so realmente nicos e garantem a
capacidade de intercmbio de informaes entre diversos tipos de
Tipo Contm Default Tamanho Faixa de valores
boolean
true ou false
false
1 bit
Pode assumir o valor true ou o
valor false
char
caracter Unicode
\u0000
16 bits
Serve para a armazenagem de
dados alfanumricos. Tambm
pode ser usado como um dado
inteiro com valores na faixa
entre:
0 e 65535 (\u0000 a \uFFFF)
byte
inteiro com sinal
0
8 bits
Inteiro de 8 bits em notao de
complemento de dois. Pode
assumir valores entre:
-2
7
a 2
7
-1
short
inteiro com sinal
0
16 bits
Inteiro de 16 bits em notao
de complemento de dois. Os
valores possvels cobrem a
faixa entre:
-2
15
a 2
15
-1
int
inteiro com sinal
0
32 bits
de complemento de dois. Pode
-2
31
a 2
31
-1
long
inteiro com sinal
0
64 bits
de complemento de dois. Pode
-2
63
a 2
63
-1
float
ponto flutuante
0.0
32 bits
Representa nmeros em notao
de ponto flutuante. A sua
representao exponencial,
sendo alguns bits utilizados
para base e outros para o
expoente.
double
ponto flutuante
0.0
64 bits
Representa nmeros em notao
de ponto flutuante. A sua
representao exponencial,
sendo alguns bits utilizados
para base e outros para o
expoente.
Tipos e operadores
2-9
computadores, aliviando o programador da preocupao e da rdua tarefa de
converter dados em formatos apropriados para a portagem.
Tipos e operadores
2-10
Declarando um tipo primitivo

So oito os tipos primitivos de Java: boolean, char, byte, short, int, long,
float e double. Quarenta e quatro so os operadores que podem ser utilizados
na manipulao destes tipos primitivos.
Declarar e inicializar uma varivel de um tipo primitivo extremamente fcil.
Basta, a exemplo da seguinte linha de cdigo, associar ao identificador escolhido
pelo usurio para a varivel um dos tipos acima, atribuindo, logo em seguida, um
literal para esta varivel.
Cdigo 2-1: Literais primitivos.

O que uma literal?

Uma resposta simples seria: constantes para cada um dos tipos primitivos de
uma linguagem. Na verdade, literais so construes sintticas fornecidas pela
linguagem para exprimir valores constantes para cada um dos tipos primitivos.
Tais construes determinam como devem ser escritos um caractere, um inteiro,
um valor booleano, etc.
A maior parte das linguagens permite que haja mais de uma forma de se
escrever um valor inteiro, ora transcrevendo o valor inteiro em uma base de
numerao Octal, ora transcrevendo-o em uma base Decimal, ora em uma base
Hexadecimal.
O mesmo ocorre para os nmeros em ponto flutuantes: a maior parte das
linguagens permite que ora sejam escritos em notao convencional (parte
inteira + caractere separador + parte fracionria), ora em notao cientfica
(nmero fracionrio + expoente em potncia decimal).

Conjunto de Caracteres Unicode

Tipos e operadores
2-11
Os programas Java so escritos usando o conjunto de caracteres Unicode.
Ao contrrio da codificao de 7 bits ASCII, que til somente para a lngua
inglesa, e codificaes de 8 bits, tais como ISO Latin-1, que til somente para a
maior parte das lnguas da Europa Ocidental, a codificao Unicode, de 16 bits,
consegue representar praticamente todas as linguagens de uso freqente no
planeta. Entretanto, poucos editores de texto suportam caracteres Unicode, e na
prtica, a maior parte dos programas so escritos em ASCII.
Os caracteres Unicode, de 16 bits, so usualmente escritos em arquivos
usando uma codificao conhecida como UTF-8, que converte os caracteres de
16 bits em uma seqncia de bytes. O formato projetado de forma que um
texto escrito em ASCII ou em ISO Latin-1 so seqncias de bytes UTF-8 vlidas.
Desta forma, voc pode simplesmente escrever programas em ASCII e eles
se comportaro, graas s caractersticas de projeto da codificao UTF-8, como
textos Unicode vlidos.
Se voc quiser inserir um caracter Unicode dentro de um programa Java
escrito em ASCII, basta usar a seqncia de escape especial para caracteres
Unicode \uxxxx. Isto , uma contrabarra mais a letra u em minscula seguida de
quatro caracteres hexadecimais.
A seqncia de escape \u0020 representa caracter de espao, e a
seqncia \u3c00 o caracter . Voc pode usar caracteres Unicode em
qualquer lugar em um programa Java, incluindo comentrios e nome de
variveis.
Podemos encontrar a tabela unicode no seguinte endereo:
http://www.unicode.org
Tipos e operadores
2-12
Tipo caracter char

O tipo char representa caracteres Unicode. motivo de surpresa para
experientes programadores descobrir que valores char em Java possuem 16 bits
de extenso.
Na prtica, no entanto, isto fica completamente transparente.Um literal
caracter em Java sempre vem entre aspas simples.
Cdigo 2-2: Declarando um tipo char

Voc pode, claro, usar qualquer caracter Unicode como um literal
caracter, sendo necessrio to somente o emprego de seqncias de escape
\uxxxx Unicode.
Java suporta tambm vrias outras seqncias de escape que facilitam a
representao de caracteres ASCII no visveis, tais como nova linha ou
backspace, e permitem o escape na construo de literais contendo caracteres
de pontuao com significado especial, tais como aspas duplas ( ) e aspas
simples ( ).
Por exemplo:
Cdigo 2-3: Exemplos de char especiais

char a = A, espaco = ;

char tab = \t, apostrofe = \, nulo = ;
char unicode = \u05D0;

Tipos e operadores
2-13
A tabela abaixo mostra os caracteres de escape que podem ser utilizados
na construo de um literal caracter.

Seqncia de
escape
Valor do caracter
\b backspace
\t tabulao horizontal
\n nova linha
\f alimentao de formulrio
\r retorno de carro
\ aspas duplas
\ aspas simples
\\ contrabarra
\uxxxx Caracter Unicode com codificao xxxx, onde xxxx so quatro dgitos
hexadecimais.
Tabela 2-2: Caracteres de escape do tipo char

Estas seqncias de escape podem tambm ser usadas em literais para
Strings.
Valores do tipo char no podem ser convertidos para e a partir de tipos
inteiros. Ao contrrio de byte, short, int e long, o tipo char um tipo no
sinalizado (unsigned).
A classe Character vrios mtodos estticos (static methods) para trabalhar
com caracteres, incluindo isLowerCase() e toUpperCase().
Tipos e operadores
2-14
Tipo booleano boolean

O tipo boolean procura representar predicados. H somente dois valores
possveis para este tipo, representando os dois estados booleanos: ligado ou
desligado, sim ou no, verdadeiro ou falso.
Java reserva as palavras true e false para representar estes dois valores
booleanos.
Programadores C e C++ devem ter notar que Java bem restritiva quanto
utilizao do tipo booleano: valores booleanos no podem ser diretamente
convertidos para outros tipos de dados, nem estes podem ser convertidos para
booleanos.
Em especial, o valor booleano no um tipo inteiro (onde false
representado por 0 e true por qualquer valor diferente de 0), e valores inteiros
no podem ser usados no lugar de um valor booleano.
Os exemplos abaixo mostram a utilizao incorreta de valores booleanos. No
primeiro exemplo, um booleano esperado e um inteiro fornecido.

Errado Correto
int i = 10;
while(i) {
...
i--;
}
int i = 10;
while(i!=0) {
...
i--;
}
Tabela 2-3: Utilizao do tipo boolean em C++ e Java

No h (como ocorre com C e C++) converso, implcita ou forada, entre
booleanos e inteiros (ou outro tipo primitivo qualquer).

Tipos e operadores
2-15
Tipos inteiros - byte, short, int e long

Os tipos inteiros em Java so byte, short, int e long. Os tipos inteiros
diferem exclusivamente no nmero de bits usados para a representao do
nmero e, portanto, na extenso da faixa de nmeros que conseguem
representar. Todos os tipos inteiros so sinalizados.
No existe em Java nada equivalente especificao unsigned de C ou
C++.
Literais inteiros para cada um destes tipos so construdos da maneira
esperada: uma seqncia de nmeros decimais. Qualquer literal inteiro pode ser
precedido por um operador unrio menos, a fim de indicar um nmero negativo.
Alguns literais inteiros:
Cdigo 2-4: Literais inteiros int

Literais inteiros podem ser expressos tambm em notao octal ou
hexadecimal. Um literal que comea com 0x ou 0X interpretado como um
nmero hexadecimal, valendo-se das letras A a F (ou a a f) para os dgitos
restantes requeridos em nmeros de base 16.
Literais inteiros que tm um dgito 0 em seu incio so interpretados como
nmeros octais (base 8) e, portanto, entre os dgitos subseqentes no podem
figurar os algarismos 8 e 9. Java no permite que literais inteiros sejam expressos
em notao binria (base 2). Literais inteiros octais e decimais vlidos:
Cdigo 2-5: Literais inteiros int em hexa e octal

Literais inteiros exprimem valores de 32 bits, a menos que terminem com o
caracter L ou l, indicando, neste caso, serem tais literais valores de 64 bits.
0
1
-123
-4200
0xff // decimal 255 expresso em hexa
0377 // mesmo nmero expresso em octa
1234 // um valor int
1234L // um valor long
0xffL // outro valor long
Tipos e operadores
2-16
Cdigo 2-6: Literais inteiros int e long
A aritmtica inteira em Java modular. No h transbordo ou estouro na
manipulao de nmeros inteiros.
Ao contrrio, ao exceder a faixa de um determinado tipo inteiro, em uma
das extremidades, o resultado da operao avana de maneira circular sobre a
extremidade oposta.
Por exemplo:
Cdigo 2-7: Exemplo de expresso byte com aritmtica circular

Nem o compilador Java, nem a JVM avisar quando ocorrer transbordo em
aritmtica inteira. Desta maneira, ao manipular inteiros, voc deve ter certeza
que o tipo que est usando grande o suficiente para os propsitos que tem em
mente. Que a faixa de nmeros oferecida pelo tipo larga o suficiente para as
operaes pretendidas.
Divises inteiras por zero e operaes mdulo zero no so aceitas e lanam
a exceo ArithmeticException.
Cada tipo inteiro tem uma classe invlucro correspondente (wrapper
classes): Byte, Short, Integer e Long. Cada uma dessas classes define as
constantes MIN_VALUE e MAX_VALUE que descrevem as extremidades da faixa de
nmeros suportada pelo tipo.
Estas classes tambm definem vrios mtodos estticos extremamente teis,
tais como Byte.parseByte() e Integer.parseInt(), empregados na
converso de strings para inteiros.
byte b1 = 127, b2 = 1;
byte sum = b1 + b2;
// sum = -128, que o menor byte

Tipos e operadores
2-17
Tipos de ponto flutuante - float e double

Nmeros reais so representados em Java com os tipos float e double.
Como mostrado anteriormente, o tipo float representa um valor de ponto
flutuante, de 32 bits, de preciso simples, enquanto o tipo double representa um
valor de ponto flutuante de 64 bits, de preciso dupla. Ambos os tipos seguem o
padro IEEE 754-1985, que especifica tanto o formato dos nmeros quanto o
comportamento da aritmtica com estes nmeros.
Literais de ponto flutuante podem ser representados em Java como uma
seqncia opcional de dgitos decimais seguido por um ponto e outra seqncia
de dgitos decimais.
Alguns exemplos:
Cdigo 2-8: Literais float e double

Literais de ponto flutuante tambm podem ser representados atravs de
notao cientfica, na qual um nmero seguido pela letra e ou E (assinalando o
expoente) e por um outro nmero. Este segundo nmero representa a potncia
de dez pela qual o primeiro nmero multiplicado.
Por exemplo:
Cdigo 2-9: Literais float em notao cientfica

Nmeros de ponto flutuante so double por default. Para representar um
literal de ponto flutuante float em um programa, basta acrescentar o caracter
f ou F no final do nmero.
Cdigo 2-10: Literais float e double em notao cientfica

Literais de ponto flutuante no podem ser representados em notao
hexadecimal ou octal. A maior parte dos nmeros reais, pela sua natureza, no
123.45f // float
0.0 // double
.02 // double
1.2345E02 // 1.2345 x 10
2
ou 123.45
1e-6 // 1 x 10
-6
ou 0.000001
6.02e23 // No. de Avogrado 6.02 x 10
23

double d = 6.02e23;
float f = 6.02e23f;
Tipos e operadores
2-18
pode ser representada exatamente em um nmero finito de bits. Portanto,
importante se lembrar que os valores double e float so apenas aproximaes
dos nmeros que eles procuram efetivamente representar.
Um float uma aproximao de 32 bits, o que resulta em pelo menos 6
dgitos decimais significativos, e o double uma aproximao de 64 bits, o que,
por sua vez, resulta em pelo menos 15 dgitos decimais significativos. Na prtica,
estes tipos so suficientes para a maior parte das computaes de ponto
flutuante.
Tipos e operadores
2-19
Tipo composto String

Alm dos tipos primitivos caracter, booleano, inteiro e real, Java tambm
possui um tipo de dado prprio para trabalhar com seqncias de texto (Strings).
O tipo String, no entanto, no um tipo primitivo da linguagem. Devido
ao uso extremamente freqente de Strings em um programa, Java permite uma
sintaxe especial para a representao de literais Strings. Um literal String consiste
de uma poro arbitrria de texto delimitada por aspas duplas.
Por exemplo:
Cdigo 2-11: Literias Strings

Literais Strings podem conter qualquer uma das seqncias de escapes
permitidas para um valor char. Utilize a seqncia \" para incluir aspas duplas
dentro de um literal String. String e literais Strings sero discutidos com mais
detalhes a seguir.
"Hello, World"
"Isto uma string \n"
Tipos e operadores
2-20
Converses de tipos casting

Java permite converso entre valores inteiros e valores reais. Alm disto, por
corresponder todo caracter a um nmero na codificao Unicode, o tipo char
pode ser convertido para e a partir de um tipo inteiro ou de ponto flutuante. De
fato, o tipo boolean o nico tipo que no pode ser convertido para ou a partir
de um outro tipo primitivo em Java. H dois tipos de converso.
Uma converso de ampliao (widening conversion) ocorre quando um
valor de um tipo convertido para outro tipo mais amplo um tipo que possui
mais bits de representao e, portanto, uma faixa mais ampla de valores
representados.
Uma converso de reduo (narrowing conversion) ocorre quando um valor
convertido para outro que possui menos bits de representao. Java
automaticamente se encarrega das converses de ampliao quando, por
exemplo, uma varivel double recebe um valor int, ou um literal char
atribudo a uma varivel int.
Converses de reduo so um problema a parte, e nem sempre so
seguras. razovel, por exemplo, converter o valor inteiro (int) 13 para um byte,
mas no o fazer a mesma converso para o valor 13000, pois o tipo byte
suporta somente valores entre 128 e 127. A informao pode ser perdida em
converses de reduo e o compilador Java sempre reclama quando h uma
tentativa de efetuar uma converso de reduo, ainda que o valor sendo
convertido se situe entre os valores aceitos pela faixa mais estreita do novo tipo.
Cdigo 2-12: Atribuio de valor inteiro int no permitida para byte

A nica exceo a esta regra que voc pode atribuir um literal inteiro
(portanto, um valor int) para uma varivel byte e short, se o literal pertencer
faixa de representao desta varivel. Se voc precisa de converses de
reduo e est confiante que o pode fazer sem perda de informao ou
preciso, voc pode forar Java a executar a converso usando uma
construo da linguagem conhecida como cast (converso explcita).
A converso explcita feita colocando-se o nome do tipo pretendido entre
parnteses antes da varivel a ser convertida.
Por exemplo:
int i = 13;
byte b = i; // Erro em tempo de compilao.
int i = 13;
byte b = (byte) i;
i = (int) 13.456;
Tipos e operadores
2-21
Cdigo 2-13: Converso forada de tipos primitivos
Casting de tipos primitivos so mais freqentes em converses de nmeros
reais para inteiros. Quando isto ocorre, a parte fracional do nmero real
simplesmente truncada (o valor de ponto flutuante arredondado para zero e
no para o inteiro mais prximo). Os mtodos Math.round(), Math.floor() e
Math.ceil() permitem outros tipos de arredondamento.
Cdigo 2-14: Atribuio de valores implcitos e expressos

O tipo char funciona como um tipo inteiro a maior parte das vezes,
podendo, portanto, ser usado em qualquer lugar em que se espere um int ou
long.
Lembre-se, no entanto, que o tipo char no sinalizado e se comporta de
maneira diferente do tipo short, embora ambos possuam 16 bits.
short s = (short) 0xffff;
char c = '\uffff';

int i1 = s;
int i2 = c;
Tipos e operadores
2-22
Tipos de referncia

Alm dos oito tipos primitivos, Java define duas outras categorias de tipos:
classes e vetores. Programas em Java so construdos atravs de definies de
classes; cada classe define um novo tipo de dado que pode ser manipulado por
programas Java.
Um programa pode, por exemplo, definir uma classe chamada Ponto e us-
la para armazenar coordenadas (x,y) de um sistema cartesiano de coordenadas.
Com isto, Ponto passa a ser um novo tipo de dado em um programa.
Um tipo vetor representa uma lista de valores de um determinado tipo. int
um tipo de dado, e um vetor de valores do tipo int outro tipo de dado, escrito
em Java como int[]. Um vetor de objetos do tipo Ponto tambm um tipo,
escrito como Ponto[]. E um vetor de vetores de Ponto tambm um outro tipo,
escrito em Java como Ponto[][].
Como voc pode ver, h um nmero infinito de tipos de dados de classes e
vetores possveis. Basta o programador defini-los. Estes tipos so conhecidos
coletivamente como tipos de referncia.
A razo para este nome ficar clara logo a seguir. Por enquanto,
importante compreender apenas que classes e vetores so tipos de dados
diferentes dos tipos primitivos. Tipos de dados de classes e vetores so conhecidos
como tipos compostos. Um tipo de dado primitivo guarda somente um nico
valor.
Classes e vetores so tipos agregados que contm vrios valores. O tipo
Ponto, por exemplo, armazena dois valores double representando as
coordenadas x e y do ponto. Classes e vetores sero retomados logo adiante.
Cdigo 2-15: Tipos de referncias: arrays e Strings

int[] vet = {1,2,3};
String str = new String(Java);

Tipos e operadores
2-23
Expresses e operadores
At o presente momento, aprendemos sobre os tipos primitivos que os
programas Java so capazes de manipular e vimos como construir literais para
cada um destes tipos. Utilizamos tambm variveis, nomes simblicos que
representam e armazenam um valor.
Literais e variveis so importantes tokens com os quais programas so
construdos em Java.
Expresses so o prximo nvel de estrutura de um programa Java. O
interpretador Java (JVM) avalia uma expresso para determinar o seu resultado.
As expresses mais simples so chamadas expresses primrias e consistem de
apenas um literal ou uma varivel.
So exemplos de expresses primrias:
Cdigo 2-16: Expresses primrias

Quando o interpretador Java avalia uma expresso literal, o resultado da
avaliao o prprio literal. Quando o interpretador avalia uma expresso
contendo uma varivel, o resultado da avaliao o resultado armazenado
nesta varivel.
Expresses primrias no so muito interessantes. Expresses mais complexas
so construdas utilizando operadores para combinar expresses primrias. Por
exemplo, a seguinte expresso usa o operador de atribuio ( = ) para combinar
duas expresses primrias uma varivel e um literal de ponto flutuante em
uma expresso de atribuio.
Cdigo 2-17: Expresso de atribuio

Mas operadores no so usados apenas com expresses primrias; eles
tambm podem ser usados com expresses de qualquer nvel de complexidade.
As seguintes construes so, portanto, expresses vlidas.
1.7
'A'
true
sum
sum = 1.7
sum = 1 + 2 + 3 * 1.2 + (4 + 8) / 3.0;
sum = (sum / Math.sqrt(3.0 * 1.234) );
sum = (int) (sum + 33);
Tipos e operadores
2-24
Cdigo 2-18: Expresses vlidas e combinadas
Tipos e operadores
2-25
Sumrio de operadores
Os tipos de expresses que voc pode escrever em uma linguagem de
programao dependem completamente do conjunto de operadores que a
linguagem disponibiliza. A tabela abaixo apresenta sntese dos operadores
disponveis em Java. A colunas P e A desta tabela indicam, respectivamente, a
precedncia e a associatividade de cada grupo de operadores correlatos. Neste
curso veremos alguns operadores listados na tabela abaixo, os demais sero
vistos a medida do estudo da linguagem.

Operadores Tipo de
operando
Operao executada
.
objeto, membro acesso a membro do objeto
[]
vetor, inteiro acesso a elemento do vetor
( args )
mtodo, lista de
args
invocao do mtodo
++, --
varivel ps incremento, ps decremento
++, --
varivel pr incremento, pr decremento
+, -
nmero mais unrio, menos unrio
~
inteiro complemento (NOT bit a bit)
!
booleano NOT booleano
new
classe, lista de args criao de objetos
(type)
tipo, qualquer
coisa
cast (converso explcita de tipo)
*, /, %
nmero, nmero multiplicao, diviso e resto
+, -
nmero, nmero adio e subtrao
+
string, qqr coisa concatenao de strings
<, <=
nmero, nmero menor que, menor que ou igual
>, >=
nmero, nmero maior que, maior que ou igual
instanceof
referncia, tipo comparao de tipos
==
primitivo, primitivo igual (o mesmo valor)
!=
primitivo, primitivo no igual (valores diferentes)
Tipos e operadores
2-26
==
referncia,
referncia
igual (o mesmo objeto)
!=
referncia,
referncia
no igual (objetos diferentes)
&
inteiro, inteiro AND bit a bit
&
booleano,
booleano
AND booleano
^
inteiro, inteiro XOR bit a bit
^
booleano,
booleano
XOR booleano
|
inteiro, inteiro OR bit a bit
|
booleano,
booleano
OR booleano
&&
booleano,
booleano
AND booleano com curto circuito
||
booleano,
booleano
OR booleano com curto circuito
? :
booleano, qqr
coisa, qqr coisa
operador ternrio condicional
=
varivel, qqr coisa atribuio
*=, /=, %=, +=,
-=, <<=, >>=,
>>>=, &=, ^=,
|=
varivel, qqr coisa atribuio geminada com operao
Tabela 2-4:Sumrio de Operadores
Tipos e operadores
2-27
Precedncia

A precedncia indica a ordem na qual as operaes so executadas.
Considere a seguinte expresso:
Cdigo 2-19: Expresso com precedncia

O operador de multiplicao tem prioridade mais alta que o operador de
adio, logo a somado ao resultado da multiplicao de b e c.
A precedncia de um operador pode ser pensada como uma medida de
quo firmemente est ligado o operador aos seus operandos.
Quanto maior a precedncia de um operador, mais firmemente ele est
ligado aos seus operandos.
A precedncia default de um operador pode ser afastada atravs do uso
de parntesis, de forma a explicitar a ordem exata das operaes. A expresso
anterior pode ser rescrita como se segue, determinando explicitamente que a
adio deve ocorrer aqui antes da multiplicao.

Cdigo 2-20: Expresso utilizando parntesis

A precedncia default dos operadores de Java foi escolhida procurando
torn-la compatvel com C. Os projetistas de C, ao determinar a precedncia
default de cada um dos operadores, tiveram em mente a maneira mais fcil e
direta de se escrever expresses sem a necessidade do uso de parntesis.
H apenas algumas expresses em Java em que se faz necessria a
presena de parntesis.
a + b * c
(a + b) * c
Tipos e operadores
2-28
Associatividade
Quando uma expresso contm vrios operadores que tm a mesma
precedncia, a associatividade dos operadores indicaro a ordem na qual as
operaes sero executadas. A maior parte dos operadores tem associatividade
da esquerda para direita, o que significa que as operaes so feitas da
esquerda para a direita. Operadores unrios e de atribuio possuem,
entretanto, associatividade da direita para esquerda.
Os operadores aditivos possuem associatividade da esquerda para direita,
sendo a expresso a+b-c avaliada da esquerda para direita: (a+b)-c.
Operadores unrios e de atribuio so avaliados da direita para a esquerda.
Considere a seguinte expresso:
Cdigo 2-21: Associatividade com incremento

O valor das variveis seria:
Cdigo 2-22: Resultado depois da execuo do cdigo acima

A associatividade, assim como a precedncia, estabelece a ordem default
de avaliao para uma expresso. Esta ordem default pode ser afetada com o
uso de parnteses. Entretanto, a escolha da precedncia e da associatividade
conduz a uma sintaxe mais natural, e raramente voc precisar alter-la.
int a = 5;
int b = 4;
int c = a++ + b++
a = 6
b = 5
c = 9

Tipos e operadores
2-29
Tipos de operadores: unrios e binrios
A quarta coluna da tabela acima especifica o nmero e o tipo dos
operandos esperados para cada operador. Alguns operadores atuam somente
sobre um nico operando; so chamados operadores unrios.
A maior parte dos operadores, no entanto, so operadores binrios e atuam
sobre dois operandos.

Exemplo operador unrio: i++ igual a i = i + 1
Exemplo operador binrio: res = x + y

Tipos e operadores
2-30
Espao para anotaes
Tipos e operadores
2-31
Java Fundamentals

3-1
3
3
.
.
C
C
r
r
i
i
a
a
n
n
d
d
o
o
c
c
l
l
a
a
s
s
s
s
e
e
s
s
e
e
o
o
b
b
j
j
e
e
t
t
o
o
s
s

Criando classes e objetos
3-2
Objetivos

Definir classes, atributos e operaes
Trabalhar com pacotes
Conhecer padres para codificao
Aplicar visibilidade a classes, atributos e operaes
Comentar os cdigos fonte
Gerar documentao do cdigo fonte
Estudar o escopo das variveis
3-3
Classes e Objetos

Uma classe um gabarito utilizado para criar mltiplos objetos. Uma classe
encapsula todos os dados e comportamentos que definem um objeto. Quando
voc pede ao interpretador Java para criar ou instanciar um objeto, Java usa a
definio de classes como gabarito para a criao de novos objetos.
Uma classe pode conter atributos que so atribudos a todos os novos
objetos desta classe. Atributos so informaes ou dados que descrevem,
categorizam ou quantificam um objeto. Cada novo objeto de uma dada classe
ter seu prprio conjunto de atributos de classe. Um objeto da classe Cliente, por
exemplo, ter um nome, um endereo e um nmero telefnico como atributos.
Dados armazenados em um objeto podem ser tanto primitivos, tais como
inteiros ou caracteres, ou referncias para outros objetos.
Uma classe pode conter tambm mtodos ou funes que especifiquem o
comportamento ou aes que a classe consegue realizar. A classe Cliente, por
exemplo, pode alugar um carro, efetuar um pagamento ou alterar o seu
endereo.
Java utiliza pacotes para agrupar classes que esto logicamente
relacionadas. Pacotes consistem de classes fisicamente localizadas em um
mesmo diretrio. Pacotes tambm so usados para controlar o acesso de classes
definidas fora do pacote.
3-4
Criando uma classe

O bloco contendo a definio de uma classe comea pela palavra
reservada class. No cdigo abaixo temos a criao de uma classe para
reprensentar um Produto.
Cdigo 3-1: Declarao da classe Produto

Uma classe o bloco de construo bsico para uma linguagem orientada
a objetos uma coleo de dados e de mtodos que manipulam estes dados.
A classe um modelo abstrato, a partir do qual sero criadas instncias desta
classe, contendo os dados e os mtodos nela definidos.
Observe que a definio da classe acima muito simples e a mesma feita
atravs da palavra reservada class. O par de chaves utilizado serve para
delimitar o corpo da classe, ou seja, onde iremos colocar as operaes e
atributos da mesma. Veremos mais adiante como colocar os atributos e
operaes
Os dados referentes a uma classe so armazenados em variveis e as
operaes efetuadas sobre estes dados so implementadas atravs de mtodos.
Seguindo os passos contidos nesta lio voc conseguir criar e executar
sua primeira Java Application. Para isto vamos adicionar um mtodo especial
nesta classe que nos permitir executar a mquina virtual e executar algum
cdigo.
Tomaremos como exemplo, para a primeira Java Application, o consagrado
Hello World. Este programa, bastante simples, imprime na tela do computador a
mensagem Hello World. Usando um editor de texto, crie um arquivo de nome
HelloWorld.java contendo as seguintes linhas.
Cdigo 3-2: Exemplo de HelloWorld Java
class Produto {

}
class HelloWorld {

public static void main( String[] args ) {
System.out.println( "Hello World!" );
}

}
3-5

O arquivo fonte pode ser compilado atravs de seu IDE ou usando o
compilador javac atravs de linha de comando como mostrado abaixo
Cdigo 3-3: Compilando uma classe Java
Obtendo xito na compilao, o arquivo HelloWorld.class, contendo os
bytecodes Java, ser criado pelo compilador no mesmo diretrio em que se
encontra o arquivo fonte.
Caso o compilador tenha reportado alguma falha, verifique se no digitou
algo incorretamente, prestando ateno para o uso de maisculas e minsculas.
Certifique-se tambm de ter dado ao arquivo o nome correto. Execute a
aplicao Java usando a mquina virtual fornecida pelo JDK (java):
Cdigo 3-4: Executando uma classe Java sem pacote

Voc ver a mensagem Hello World! escrita na tela de seu computador.

C:\> javac HelloWorld.java

C:\>java HelloWorld
Hello World!
3-6
Padres

A linguagem java segue padres para escrita de cdigo especificados
pela Sun, empresa criadora da linguagem java. Desenvolvedores devem
procurar seguir estes padres, uma vez que todo cdigo de APIs que existem
seguem este padro para facilitar o endendimento dos mesmos bem como a
leitura destes cdigos.

O compilador Java (javac), bem como todas as demais ferramentas do JDK,
diferenciam maisculas de minsculas. Este recurso chamado de case-sensitive.
Portanto, bastante cuidado ao grafar o nome de classes, mtodos, variveis e
pacotes. Erros comuns decorrem muitas das vezes de problemas envolvendo
grafia, em que um nome, por exemplo, definido em maisculas, e depois, logo
adiante, utilizado em minsculas. O compilador simplesmente alegar que tal
varivel, mtodo, classe ou pacote no foi definido. Abaixo so apresentados
alguns padres:

Nomes de arquivos

Arquivos contendo os fontes Java terminam com a extenso .java. Todo
arquivo fonte Java deve ter no mximo uma nica classe public. Pode haver
mais de uma classe por arquivo, porm somente uma pblica. O nome do
arquivo fonte java case-sensitive, ou seja, deve respeitar letras maisculas e
minsculas, devendo tambm ter o mesmo nome da classe publica declarada
dentro do mesmo.

Exemplo: Produto.java

Nomes de classes

Escolha nomes significativos, de tal forma que a simples leitura do nome j
crie uma expectativa acerca do que se pode esperar da classe. Use para isto um
ou mais substantivos. O primeiro caractere de cada palavra utilizada para o
nome da classe deve ser maisculo. Quando o nome de uma classe tiver mais de
uma palavra as mesmas devem estar concatenadas.

Exemplo: NotaFiscal, Cliente, Item
3-7
Nomes de operaes

Conselho similar pode ser dado escolha dos nomes dos mtodos: use
nomes significativos. Use verbos ou estruturas verbais que captem a ao
principal contida no mtodo. O nome deve representar a real utilidade
desempenhada pelo mtodo. A primeira letra do nome de uma operao deve
ser em minscula e a primeira letra de todas as demais palavras que compem o
nome da operao, caso existam, em maisculo.

Exemplo: getDescricao(), setPrecoFinal(), imprimirRelatorio()

Nomes de atributos/variveis

Use nomes curtos, mas que no sejam crticos. A primeira letra do nome da
varivel deve ser em minscula e a primeira letra de todas as demais palavras
presente no nome deve ser maiscula. Evite usar nomes de variveis com uma
nica letra. O que voc esperaria de uma varivel de nome r ou x? O nome
deve ser representativo e a simples leitura do mesmo leva compreenso do
papel desempenhado pela varivel no aplicativo. A nica exceo aceitvel
para contadores em laos, ou variveis temporrias de uso restrito.

Exemplo: nome, descricao, precoFinal, idade, dataNascimento

Nomes de constantes

O nome de constantes definido de uma forma um tanto diferente. Toda
constante tem o seu nome escrito sempre com todos os caracteres em
maisculo, e se o nome for composto por mais de uma palavra, as mesmas
devem ser separadas pelo caractere _. Veja abaixo um exemplo:

Exemplo: TAMANHO_MAXIMO_VETOR = 100, BORDA = 4

Caracteres especiais

Nmeros, sublinhado e dlar podem ser usados em nomes. A nica
restrio que o nome deve sempre comear por um caractere que seja
diferente de um nmero. Mas evite o mau uso de tais caracteres especiais.

3-8
Nome de pacotes

Pacotes devem possuir nomes significativos e no devem ter seus nomes
separados por caracteres como _. Seus nomes devem ser escritos sempre com
todas as letras em minsculo e os nomes de pacotes seprados pelo caractere
ponto (.). Veja o exemplo abaixo:

Exemplo: com.targettrust.database

Observe que o nome do pacote foi iniciado com a palvra com e em
seguida com a palavra targettrust. Normalmente comeamos o nome de um
pacote com o inverso do domnio da empresa. Isto explica o porque utilizar
com.targettrust no incio do nome do pacote.

3-9
Criando e importando pacotes

Java fornece o mecanismo de pacote como uma maneira de agrupar as
classes relacionadas.

A declarao de pacote, caso exista, deve estar no incio do arquivo de
origem. Ela pode ser precedida apenas de espaos em branco e comentrios.
Somente uma declarao de pacote permitida e influencia todo o arquivo de
origem.

Os nomes de pacote so hierrquicos e separados por pontos.

Convencionalmente, os elementos do nome de pacote esto
normalmente em letras minsculas. O nome de classe, entretanto, geralmente
comea com letra maiscula e pode usar maisculas para separar as palavras
do nome.

Veja o exemplo a seguir:
Cdigo 3-5: Definindo um pacote para uma classe

Compilando e executando:
Cdigo 3-6: Compilando um classe com pacote e realizando sua execuo. A opo d indica o
deretrio de destino para o byte-code

Cdigo 3-7: Sintaxe para importar pacotes
package com.targettrust.java;

class HelloWorld {
public static void main( String[] args ) {
}
}

C:\> javac d . HelloWorld.java
C:\> java com.targettrust.java.HelloWorld
Hello World!
package com.targettrut.java;

import java.sql.*;
import java.io.*;
import java.net.*;
import javax.swing.JFrame;
3-10

3-11
Static import

Este recurso presente a partir da verso 1.5 do java extremamente til
para simplificar e facilitar a escrita de cdigo. Permite utilizarmos os membros
(atributos ou mtodos) static sem que tenhamos que prefixar os membros com o
nome da classe. Veja o exemplo abaixo:

System.out.println( Math.random() );
System.out.println( ( raio * raio) * Math.PI );
Cdigo 3-8: Uso de operaes static sem a importao dos membros static

Este cdigo utilizando o static import ficaria assim:

import static java.lang.Math.*;
import static java.lang.System.*;
...
out.println( random() );
out.println( ( raio * raio) * PI );
Cdigo 3-9: Importanto os membros static da classe Math

Veja que o cdigo acima fica mais claro e fcil de ser escrito. Esta
facilidade de escrita do cdigo deve ser utilizada mas com cuidado para no ser
abusada, pois pode prejudidar a legibilidade do cdigo das suas aplicaes.
Sempre que muitos membros static de uma classe forem ser utilizados til este
recurso, mas se somente um ou dois membros forem ser utilizados o uso deste
recurso no aconselhvel.

A importao dos membros static pode ser feito de forma genrica ou
especfica como mostra o cdigo abaixo:

1 import static java.lang.Math.PI;
2 import static java.awt.BorderLayout.*;
Cdigo 3-10: Importando a estrutura estatica de uma classe

Com o static import da linha 2 possvel se utilizar todas as constantes da
classe BorderLayout. Isto evita termos que escrever portanto o nome da classe
cada vez que uma constante for utilizada.
3-12
Criando objetos

Neste momento do seu aprendizado iremos mostrar como pode ser criao
um objeto de uma determinada classe para que voc possa aproveitar melhor
os passos seguintes do curso. No iremos ainda aqui nos aprofundar neste
assunto, visto que a criao de objeto algo que merece um tempo maior de
estudo. Veremos ento como pode ser criado um objeto.

...

Produto prod;
prod = new Produto();

...
Cdigo 3-11: Criando um objeto da classe Produto

Observe no cdigo acima a criao de um objeto que ser referenciado
por prod. Na primeira linha estamos fazendo a declarao de uma referncia
para um futuro objeto da classe produto. Esta referncia ir receber um objeto
que est sendo criado na linha segunte. A palavra reservada new a
responsvel por alocar memria e construir o objeto da classe Produto. Logo
depois de construdo este objeto o endereo do mesmo ;e atribudo para a
referncia prod.

Para criar um objeto precisamos da classe e no momento de criao do
mesmo veja que logo depois deste nome de classe colocamos os sinais de
parnteses.

Esta criao tambm pode ser feita em uma nica linha de cdigo para
simplificar o processo, como mostrado abaixo:

...

Produto prod = new Produto();

...
Cdigo 3-12: Criand objeto da classe Produto em uma nica linha

Agora em uma nica linha voc esta declarando uma referncia para o
objeto, criando o objeto e atribuindo o endereo de memria do mesmo para
esta referncia.

3-13
O que a referncia null?

Sempre que declararmos uma referncia e esta no receber valor teremos
um valor null dentro da mesma. Desta forma importante estudarmos um
pouco este valor null, pois muito erros em tempo de execuo na linguagem java
ocorrem em funo desta palavra.

Considere o seguinte comando:
Cdigo 3-13: Atribuindo null para a referncia de Produto

Ele declara uma varivel/referncia prod e a inicializa com null. Isto indica
que a varivel de referncia prod no se refere a nenhum objeto ainda, em
outras palavras, ela somente foi delarada.
null uma palavra reservada na linguagem Java. Voc pode us-la com o
operador de igualdade para verificar se uma varivel de referncia j recebeu
uma referncia vlida a um objeto ou mesmo para saber se duas referncias
apontam para o mesmo objeto

Cdigo 3-14: Teste entre uma referncia e a palavra reservada null

Quando voc tiver terminado de usar um objeto, voc pode atribuir o valor
null para a varivel que o referencia. Isto indica que a varivel no mais se
refere ao objeto. Quando nenhuma referncia houver para um objeto, o objeto
ser marcado como inacessvel e ser considerado pelo coletor de lixo (garbage
collector). Iremos estudar com mais detalhes o coletor de lixo nos prximos
captulos.
Na prtica, somente em casos muito especiais voc precisa atribuir null
para uma varivel. A JVM automaticamente decrementa o nmero de
referncias ativas para um objeto sempre que a varivel que o referencia recebe
Produto prod = null;

if( prod == null ) {
...
...
}

...

prod == prodRef

...
3-14
o valor null, sai de fora de escopo ou ento recebe o valor de uma referncia
para outro objeto.
3-15
Atribuindo referncias
Como mencionamos antes, quando voc declara uma varivel de
referncia para um objeto, esta varivel tem o seu valor inicializado para null.
Antes que voc possa usar esta varivel (ou seja, acessar o objeto a que ela
referencia), voc tem de inicializ-la. Todos os atributos de uma classe que forem
de tipos compostos (Classes) sero inicializados automaticamente pela JVM no
momento da criao de um objeto da classe para o valor null.
Quandor declaramos uma referncia para um objeto e na mesma linha j
criamos este objeto, estamos inicializado a referncia com um valor diferente de
null, ou seja, o endereo do objeto criado.V eja cdigo abaixo:
Cdigo 3-15: Criao do produto prod

Podemos tambm fazer atribuio de referncia, para isto basta utiliza o
operador de atribuio. Neste caso as duas referncias iro apontar para o
mesmo objeto. Veja o cdigo abaixo:
Cdigo 3-16: Atribuio da referncia prod1 para prod2

Esta sintaxe est perfeitamente correta, mas vale frisar que h apenas um
objeto Produto criado. Quando voc atribui uma referncia para um objeto
para outra referncia, voc termina com duas referncias para o mesmo objeto,
e no uma cpia do objeto.
Voc pode acessar o mesmo objeto atravs de ambas as referncias,
entretanto, h apenas um nico objeto. Este objeto conhecido como objeto de
referncia.
importante se lembrar disto, principalmente ao passar uma referncia para
uma operao . Isto ser visto em maiores detalhes adiante.
Voc pode alterar uma referncia (mudando o valor da varivel de
referncia), sem que isto afete a outra referncia (o valor da outra varivel de
referncia).
Caso voc precise de um outro objeto, ao invs de ter mltiplas referncias
para o mesmo objeto, voc ter de criar este novo objeto.


Produto prod1 = prod2;

3-16
Visibilidade aplicada a classes

Encapsulamento uma das palavras-chave para a orientao a objetos.
Uma classe bem defina deve separar completamente a sua interface pblica da
implementao interna. Neste momento do estudo iremos mostrar quais so so
tipos de encapsulamentos que uma classe pode receber. Certos de que a esta
altura dos estudos voc j conhece os tipos de encapsulamentos existentes
vamos agora aplicar os mesmos para classe. A palavra visibilidade tambm pode
ser aplicada para este assunto, uma vez que de acordo com o modificador que
utilizaremos iremos tormar mais ou menos visvel uma classe.
pacote/default

Esta visibilidade a visibiliade padro quando no se especifica nenhuma
visibilidade. Ao contrtio de ontras linguagen onde a visibilidade padro public
java define a visibilidade pacote/default. Se uma classe possuir esta visibilidade
isto significa que a mesma pode ser utilizada somente por outras classes que
estiverem dentro do mesmo pacote. Classes que estiverem em pacotes
diferentes do pacote onde esta classe estiver no sabero que a mesma existe.
No exemplo abaixo a classe email poder ser utilizada somente por classes do
pacote com.targettrust.comunicacao e nenhum outro pacote mais

package com.targettrust.comunicacao;
class Email {
...
...
}
Cdigo 3-17: Visibilidade de package aplicada a classes

3-17
public

Uma classe normalmente declara como sendo pblica, isto deixa a
classe visvel, ou seja, capaz de ser utilizada por qualquer outra classe do sistema,
idependente do pacote onde a mesma se encontra. Recomenda-se que a
classe sempre seja pblica a no ser que voc queira restringir o acesso de uso a
esta classe. Quando em um arquivo fonte for delcarado mais de uma classe o
nome do arquivo fonte deve levar o mesmo nome da classe pblica que foi
declarado neste. Lembre-se que no possvel declarar mais de uma clase
pblica em cada arquivo fonte. Veja o exemplo abaixo de uma classe pblica:

public class Email {
...
...
}

class Produto {
...
...
}
Cdigo 3-18: Duas classes declaradas no mesmo arquivo fonte

3-18
Definindo operaes

Quando voc define uma classe necessrio definir tambm as operaes
que faro parte desta classe. As operaes so definidas dentro das chaves das
classes. Cada operao ter uma implementao especfica que conhecida
como mtodo. Um mtodo, portanto, a implementao de uma operao.
Um mtodo em Java equivalente a uma funo, procedimento ou sub-
rotina em outras linguagens, com a diferena que ele deve ser definido dentro
da declarao da classe. Em outras palavras, no existe em Java mtodos
globais (completamente desvinculados de uma classe). Todo mtodo deve ser
definido dentro de uma classe.
Anteriormente quando criamos uma classe, definimos uma operao
chamada main, agora iremos estudar a anatomia das operaes bem como
definir outras operaes em uma classe.
Anatomia de uma operao:

Abaixo temos uma operao definda dentro da classe Produto. Observe os
elementos que fazem parte desta operao:

public class Produto {
public void foo(String arg, int cod) {

}
}
Cdigo 3-19: Declarao da operao

Os elementos integrantes de uma operao so:

Modificador de acesso: utilizados para restringirem o acesso as operaes.
Pode ser public, default, protected ou private.


}
Cdigo 3-20: Visibilidade da operao

3-19
Tipo de retorno: pode ser um tipo primitivo (como int ou char tipos
primitivos sero estudados mais adiante), ou um tipo composto (um objeto
String ou Produto, por exemplo), ou mesmo no haver retorno algum.
Neste caso dever constar void como tipo de retorno. Em resumo: toda
operao em java deve indicar o tipo de retorno.


}

public String getDescricao() {

}
Cdigo 3-21: Tipo de retorno das operaes

Nome da operao: O nome da operao deve expressar o que a
operao faz. Normalmente este nome deve ser um verbo ou estar no
imperativo dando a idia de uma ao.


}
Cdigo 3-22: Nome da operao

Parmetros: representam os valores que podemos passar para a operao.
Toda operao pode receber parmetros, sendo assim a operao pode definir
logo aps o seu nome um ou uma lista de parmetros. Se o mtodo recebe
vrios parmetros, cada um deles deve ser separado dos demais por vrgula.
Uma operao tambm pode no receber parmetros. Havendo ou no
parmetros, os mesmos devem ser representados entre parnteses.


}


}
Cdigo 3-23: Parmetros da operao

3-20
Corpo da operao: o local onde fica a implementao da mesma.
Este cdigo deve ficar entre chaves, que representam o incio e fim do
bloco.

System.out.println( arg );
System.out.println( cod );
}
Cdigo 3-24: Corpo da operao. Impresso dos valores passados como parmetros
3-21
Comando return
O comando return utilziado na linguagem java para que as operaes
possam retornar valores.
Um comando return aceita um valor simples ou uma expresso que deve
ser compatvel com o tipo de retorno do mtodo em que este comando est
inserido.
Cdigo 3-25: Comando return para retorno de mtodo com ou sem valor de retorno.

Quando um comando de return encontrado, o fluxo de execuo
abandona o mtodo imediatamente, ignorando quaisquer comandos que
existam entre o comando de return e o final do mtodo (o fecha chaves do
corpo do mtodo).
Esta alterao do fluxo de execuo pode ser usada mesmo em mtodos
que no retornam nenhum valor (mtodos cujo tipo de retorno void), com a
finalidade de abandonar o mtodo imediatamente.
Neste caso especial, o comando return no aceitar nenhum valor de
retorno ou expresso (afinal o mtodo void).

return "Nome: " + nome + " Preo: R$ " + preco;
}

public void setNome( String n ) {
nome = n;
return;
}

}
3-22
Visibilidade para operaes

Operaes assim como os atributos e as classes podem ter visibilidades.
Para as operaes so aplicados os seguintes tipos de visibilidades: private,
public, protected e pacote/default. O uso destas visibilidades freqente para
as operaes uma vez que pode ser utilizada paa restringir o acesso a um objeto.

public

Esta visibilidade expe as operaes para serem chamadas de outros
objetos. Acima quando criamos as operaes voc pode observar que as
mesmas foram definidas como sendo pblicas. Uma operao definida
sempre, por padro, como sendo pblica, veja o cdigo abaixo:



public void foo() {

}

}

Cdigo 3-26: Visibilidade pblica

A operao foo() mostrada acima pode ser chamada a partir de qualquer
outra classe independende do pacote onde se encontrar esta classe. Veja o
cdigo abaixo onde criamos um objeto para poder chamar esta operao:

package com.targettrust.vendas;
import com.targettrust.java.*;

public class CriaObjetos {

public static void main(String[] args) {
prod.foo();
}

}
Cdigo 3-27: Criando um objeto de uma classe e chamando a iperao pblica

3-23
private

A visibilidade private restringe o acesso a esta operao ao prprio objeto
que a contm. Uma operao privada portanto no pode ser acessada por
outro objeto a no ser aquela que a definiu. Operaes privadas no so
comuns e se existirei representam um servio interno do prprio objeto.

Veja abaixo como pode ser definida uma operao privada:


private void foo() {

}

}
Cdigo 3-28: Visibilidade provada

Esta operao foo() uma operao que pode ser chamada somente
atravs de outras operaes da prpria classe, veja abaixo:


private void foo() {

}

public void salvar() {
foo();
}

}
Cdigo 3-29: Chamando operao com visibiliade privada

3-24
O cdigo abaixo no permitido, pois veja que agora a operao foo() esta
definida com sendo privada.

public class CriaObjetos {



prod.foo();

}

}
Cdigo 3-30: Chamada de operao privada fora da classe

protected

O uso desta visibilidade, assim como para os atributos est ligada ao uso de
herana, desta forma iremos deixar este tipo de visibilidade para ser
demonstrado mais adiante quando estudarmos o mecanismo de herana.

Uma operao protegida uma operao visvel para objetos de classes
que esto no mesmo pacote daquela classe que define a operao ou para
uma classe filha desta classe que contm a operao protegida.

package/defalut

Uma operao com visibilidade de pacote/default uma operao que
tem comportamento de pblica dento do pacote que a contm. Normalmente
uma operao no definida como package, mas sim como public ou private.

Para definir uma operao com esa visibilidade no se deve especificar
nenhum modificador de acesso, isto a tornar default/package.

Veja abaixo na classe Produto como ficaria a operao com esta
visibilidade:


void foo() {

}

}
Cdigo 3-31: Visibilidade default
3-25
Definindo atributos

Os atributos de uma classe definem a estrutura dos objetos. Estes atributos
so declarados dentro do bloco que define a classe. Veja no exemplo abaixo a
declarao de alguns atributos para a classe produto:

String descricao;
float preco;
boolean emVenda;
}
Cdigo 3-32: Atributos da classe produto

Observe que na declarao acima os atributos ficam dentro do bloco de cdigo
da claase. Estes atributos so atributos com visibilidade default. Logo
estudaremos os tipos de visibilidade que podem ser aplicadas aos atributos.

Estes atributos especificados acima so conhecidos como atrubutos de
intncia e para serem acessados precisam que um objeto da classe que os
contm seja criado.

Um atributo pode ser inicializado com valores j no momento da sua
declarao como mostrado no cdigo abaixo. Isto far com que quando um
objeto da classe que o contm for criado o mesmo j possua um determinado
valor. O atributo emVenda ir possuir o valor true, neste caso, para todos os
objetos criados

String descricao;
float preco;
boolean emVenda = true;
}
Cdigo 3-33: Inicializao do atributo

3-26
Visibilidade aplicada a atributos

Os atributos so elementos que podem conter os quatro tipos de
visibilidades definidos pela orientao a objetos. Vejamos agora o significado
destes tipos de visibilidade aplicadas aos atributos.

public

Esta visibiliade ir tornar o acesso ao atributo disponvel para qualquer
outra classe que estiver em qualquer outro pacote. Isto significa que objetos
gerados a partir desta classe que define o atributo pblico podero ter os valores
destes atributos modificados por qualquer outro objeto. Este tipo de
encapsulamento/visibilidade no o recomendado para atributos. Veja o
exemplo abaixo com os atributos para a classe Produto sendo pblicos:

public String descricao;
public float preco;
public boolean emVenda;
}
Cdigo 3-34: Visibilidade pblica para os atributos

Veja agora como seria o acesso a estes atributos em um pseudo-cdigo.
Observe que a palavra prod utilizada para referenciar um objeto da classe
Produto criado.

public class Consulta {

prod.descricao = Notebook;
prod.preco = 3500.0f;
prod.emVenda = false;
}

}
Cdigo 3-35: Acessando atributos com visibiliade pblica

3-27

3-28
private

A visibilidade provate a visibilidade recomendada pela orientao a
objetos para os atributos de uma classe. Voc estudou estes tipos de visibilidade
e a importncia do uso das mesmas nos cursos anteriores, ento vejamos agora
como ficaria esta visibilidade aplicada aos atributos.

private String descricao;
private float preco;
private boolean emVenda;
}
Cdigo 3-36: Definindo atributos provados

O acesso agora aos atributos no poderia mais ser feito de forma direta
como na visibilidade pblica. Veja o cdigo abaixo e observe que nas linhas
onde tentamos acessar os atributos teramos um erro sendo reportado pelo
compilador dizendo que o atributo privado e no pode ser acessado desta
forma.




}

}
Cdigo 3-37: Acessando atributos privados

Como ento deve ser feito o acesso a atributos privados. O acesso a
atributos com visibilidade privada deve ser feito atravs de operaes pblicas
que sero especificadas na classe. J vimos como definir operaes, ento veja
agora como ficaria o acesso a estes atributos.

Primeiramente teramos que modificar a classe Produto adicionando
mtodos pblicos para fazer este acesso. Veja abaixo:

3-29

private boolean emVenda;

public void setDescricao(String novaDescricao) {
descricao = novaDescricao;
}

return descricao;
}

...
}
Cdigo 3-38: Definindo operaes para acesso aos atributos

Logo depois de modificarmos a classe Produto podemos fazer acesso a
seus atributos atravs das operaes. Veja abaixo:



prod.setDescricao(Notebook);
prod.setPreco(3500.0f);
prod.setEmVenda(false);

}

}
Cdigo 3-39: Utilizando as operaes para acesso aos atributos

3-30
package/default

Um atributo com visibilidade de pacote/default um atributo que pode ser
acessado diretamente como se fosse pblico por classes que estiverem no memo
pacote. Para definir um atributo com esta visibilidade no necessrio colocar
modificador antes do mesmo. Este o modificador padro para visibilidades
quando as mesmas no forem definidas.

Abaixo veja a nova verso da classe Produto:


String descricao;
float preco;
boolean emVenda;
}
Cdigo 3-40: Visibilidade default

Observe que a classe acima est dentro de um pacote chamado
com.targettrust.java e que a mesma ser utilizada por outra classe que est no
mesmo pacote.





}

}
Cdigo 3-41: Acesso a visibilidade defalut

3-31
Agora se movermos a classe Consulta para outro pacote e fizermos a
importao do pacote com.targettrust.java para tentar acessar os atributos na
teremos sucesso.

package com.targettrust.exemplo;

import com.targettrust.java.*;




}

}
Cdigo 3-42: Acessando atributo default fora do pacote

O cdigo que temos para acessar os atributos o mesmo que temos
quando a classe pblica, mas agora como a classe Consulta est em pacote
diferente, e os atributos de Produto tem a visibilidade de pacote/default o acesso
no pode mais ser feito de forma direta. Neste caso se tivssemos interesse em
acessar os atributos a partir de outra classe fora do pacote teramos que fornecer
mtodos pblicos para isto.

protected

Esta visibiliade para ser entendida necessita o estudo do mecanismo de
herana entre classes. Vamos deixar para mais tarde quando mostrarmos aqui
este mecanismo para ento dar exemplos de cdigos com protected.

Um atributo protegido um atributo que ter visibilidade de pacote, mas
tambm ir permitir o acesso direto a ele para classes que estiverem em pacotes
diferentes daquele pacote onde est a classe que o define, desde que a classe
fora do pacote seja filha da que contm o atributo.
3-32
Acessando atributos

O acesso a atributos de uma classe deve ser feito somente por operaes
definidas na mesma classe que contm este atributo. Desta forma devemos
tornar os atributos de uma classe por padro privados e as operaes que iro
acess-los pblicas.

Cada atributo ir possuir um par de mtodos que chamamos de mtodos
de leitura e escrita ou getter e setter. Veja abaixo como ficaria a classe produto:


private int codigo;

public void setCodigo(int novoCodigo) {
codigo = novoCodigo;
}

public int getCodigo() {
return codigo;
}

public void setDescricao(String novaDescricao) {
descricao = novaDescricao;
}

return descricao;
}

public void setPreco(float novoPreco) {
preco = novoPreco;
}

public float getPreco() {
return preco;
}

}
Cdigo 3-43: Definio da classe Produto

3-33
Comentrios no cdigo fonte

Os comentrios de cdigo fonte esto presentem em todas as linguagens
de programao, e como java no poderia ficar de fora o mesmo possui 3 tipos
de comentrios. Os comentrios so importantes pois so um mecanismo para o
programador explicar dentro do fonte com as suas prprias palavras o que
significa ou faz os elementos que o mesmo est escrevendo.
Java possui um tipo de cometrio que pode ser utilizado por um gerador de
documentao a fim do mesmo criar um conjunto de pginas HTML com
informaes sobre a classe. O programador interessado em utilizar aquela clase
no precise olhar o fonte da mesma para saber do que ele dispe, mas sim basta
olhar em qualquer browser esta documentao em formato HTML.
Na linguagem java existem os seguintes tipos de comentrios:
1 Comentrio de linha
2 Comentrio de mltiplas linhas
3 Comentrio de documentao

Comentrio de linha

O comentrio de linha um comentrio bastante prtico e muito utilizado.
Seve para podermos colocar em qualquer ponto do cdigo uma
documentao. No entanto esta documentao feita somente em uma linha,
no podendo haver mltiplas linhas como no anterior. Veja o exemplo abaixo:


public float calcularPreco() {
// para calcular o preo deve ser descontado o desconto
preco = preco desconto;
...
}
}
Cdigo 3-44: Comentrio de linha

3-34
Comentrio de mltiplas linhas

O comentrio de mltiplas linhas pode ser utilizado em qualquer ponto do
cdigo. Este tipo de comentrio no far parte da documentao gerado pelo
javadoc. O programador pode escrever mais de uma linha documentando o
cdigo. Os caracteres /* e */ representam o incio e fim deste tipo de comentrio.


public void imprimir() {
/* Mostra os dados do produto.
Estes dados mostrados so: nome, descrio e preo
*/
System.out.println(Dados do produto:);
...
}
}
Cdigo 3-45: Comentrio de mltiplas linhas

Comentrio de documentao

Este tipo de cometrio deve ser colocado antes do elemento que se quer
documentar, ou seja antes da definio de uma classe ou operao. As
marcaes /** e */ indicam o incio e fim de um comentrio de documentao.
Todo o contedo colocado dentro destas marcaes ser capturado pelo
utilitrio javadoc para montar a documentao da classe em formato HTML.
/**
Classe para representar um produto da loja.
Um produto deve conter sempre um cdigo e uma descrio
Criada dia 05-05-2005
*/

/**
Mtodo para mostrar os dados de um produto
*/
public void imprimir() {

}
}
Cdigo 3-46: Comentrio de documentao para classe e operao

3-35
Os comentrios de documentao podem ter algumas marcaes
especiais para serem capturadas pelo javadoc e adicionadas na
documentao HTML da classe. Estas marcao so as seguintes:

@return Representa o tipo de retorno de uma operao. Pode conter texto
para explicar o que o tipo de retorno
@param Representa o parmetro de uma operao. Deve conter uma
descrio do que significa este parmetro.
Tabela 3-1: macros para documentao

Veja cdigo de exemplo abaixo:


/**
Calcula o custo de um produto.
@param arg um argumento a ser utilizado para calcular o custo
@param cod cdigo do produto a ser utilizado no calculo
@return float indicando o custo do produto
*/
public float calcularCusto(String arg, int cod) {

}

}
Cdigo 3-47: Comentrio de documentao para a classe Produto

3-36
Escopo das variveis

Este um assunto muitas vezes no abordado em materiais sobre java,
porm de extrema importncia. Nesta linguagem as variveis quando forem
declaradas iro estar visveis dentro de um determinado escopo de cdigo. Este
escopo delimitado por chaves que representam blocos de cdigos. Isto
significa que uma varivel declarada dentro de um bloco de cdigo visvel
somente aquele bloco de cdigo bem como a outros blocos que estiverem
dentro deste.
Normalmente existe um bloco de cdigo delimitado por chaves para
representar o corpo de cdigo de uma classe (veja na figura abaixo o escopo de
classe) e de uma operao (veja abaixo escopo de mtodo). Isto significa que
se declararmos uma varivel dentro do bloco da classe a mesma ser visvel a
cdigos que se encontrarem dentro daquele escopo de classe (no estamos
aqui levando em considerao os tipos de encapsulamento). Dentro de um
corpo de cdigo para classes podemos ter operaes definidas e estas
operaes possuem tambm seus blocos de cdigos (escopo de mtodo). Isto
significa que se dentro do bloco de cdigo de uma classe definirmos uma
varivel, esta varivel poder ser acessada normalmente dentro de qualquer
bloco de cdigo de uma operao que foi definido dentro do bloco da classe.
Isto tudo pode ser resumido da seguinte maneira: uma operao pode chamar
qualquer outra operao da classe ou mesmo acessar uma varivel desta classe.
Podemos tambm definir dentro do escopo de um mtodo outros blocos de
cdigo. Isto pode ser feito atravs do uso de chaves. No normal definirmos
blocos de cdigo desta maneira, mas esta mesma idia pode ser utilizada para
os comandos que possuem blocos de cdigos como o if, for, while, etc...
Veja abaixo na figura a representao dos escopos.
Figura 3-1: Escopos de implementao.

3-37



preco = novoPreco;
}

}
Cdigo 3-48: Acessando a varivel preco

Observe no cdigo acima o escopo onde foi definido o preo. Esta
varivel (podemos tambm chamar de atributo) foi definido dentro do escopo
da classe, ou seja, dentro das chaves da classe. Pode, portanto, ser acessado por
qualquer operao que estiver tambm definda dentro do escopo de classe,
como a operao setPreco(...).
Veja agora o cdigo abaixo ao qual adicionamos mais variveis e outro
escopo.



preco = novoPreco;
x = 34; // Erro
}

public void foo(int y) {
int x = 10;
if ( x > y) {
int res = x + y;
}
System.out.println( res ); // Erro
}

}
Cdigo 3-49: Acessando variveis fora de escopo

No cdigo acima temos a declara de uma varivel inteira x dentro do
bloco de cdigo da operao foo(...). Isto significa que esta varivel somente
poder ser acessada por outros cdigos que estiverem dentro desta mesma
operao. Este tipo de varivel conhecida como varivel local. Observe que
na linha onde atribudo o valor 34 ao x teremos um erro.
3-38
Neste mesmo cdigo mostrado acima podemos observar que foi
declarado um comando condicional if dentro da operao e que dentro deste
comando declaramos uma varivel res. Esta varivel uma varivel local ao
comando condicional, ou seja, vlida somente dentro deste comando, no
podendo ser acessada fora do mesmo. Veja a linha onde tentamos imprimir o
contedo da varivel res, nesta linha teremos um erro de acesso.
Podemos definir x e res como sendo variveis locais, enquanto preo
pode ser definido como sendo uma varivel de instncia. Par6ametros de
mtodos tambm so considerados como sendo variveis locais.

3-39
Passando Tipos Primitivos para Mtodos

Quando um valor de tipo primitivo (int, char, etc.) passado para o
mtodo, uma cpia deste valor preencher o respectivo parmetro do mtodo.
Se o mtodo alterar o valor de seus parmetros, esta alterao ter um efeito
local: alterar apenas a cpia (o parmetro formal ou argumento), mas o valor
original permanecer o mesmo.
Quando o mtodo termina, todos os seus parmetros so descartados e as
variveis originais presentes na chamada permanecem inalteradas.
O exemplo abaixo ilustra a maneira com que tipos primitivos so passados
por valor para os mtodos.
Cdigo 5-20: Escopo de execuo da varivel preco.

Cdigo 3-50: Escopo de execuo da varivel arg

O cdigo esquerda declara uma varivel int chamada preco e atribui o
valor 150 a esta varivel. Quando preco passada para foo(), uma cpia de
seu valor corrente preencher o parmetro arg, que ter o valor inicial de 100.
Dentro de foo(), arg recebe o valor 55. Quando foo() termina, o
parmetro arg descartado e o fluxo de execuo retorna ao chamador.
A varivel preco, definida no contexto do chamador, no foi afetada e tem
ainda o valor de 100.
A sada do programa ser, portanto, a seguinte:

int preco = 100;
obj.foo(preco);
System.out.println("preo = " + preco);

public void foo(int arg) {
if(arg > 0 && arg < 2000)
arg = 55;
System.out.println("arg = " + arg);
}
arg = 55
preco = 100

preco
100
arg
100
3-40
Passando Referncias para Mtodos

Quando voc passa um objeto para um mtodo, a referncia para o objeto
original passada como argumento, e no uma cpia do objeto. Qualquer
alterao que o mtodo fizer valendo-se da referncia recebida, alterar o
objeto original. Quando o mtodo terminar, todas as alteraes feitas pelo
mtodo no objeto permanecero.
O exemplo abaixo ilustra a maneira pela qual referncias para objetos so
passadas para mtodos.
O cdigo esquerda cria um objeto Produto e armazena a referncia para
este objeto na varivel p1. Neste exato instante, o ttulo de p1 "DVD e o cdigo
"1".
Quando p1 passada para foo(), o mtodo recebe a referncia para o
objeto Produto original. Dentro de foo(), atravs da varivel de referncia ref,
o nome e o cdigo so alterados. Quando foo() termina, o objeto Produto
original referenciado por prod tem o ttulo "CD" e o cdigo "2".

Cdigo 3-51: Escopo de execuo do objeto prod

Cdigo 3-52: Escopo de execuo do objeto prod pela referncia
ref.
Produto prod = new Produto( CD );

prod.setCodigo( 1 );
obj.foo( prod );
public void food(Produto ref) {
ref.setCodigo( 2 );
ref.setNome( "CD" );
}
prod

nome:"CD"
codigo: 2

ref
3-41
Espao para anotaes
3-42
Exerccios

1. Neste exerccio voc ir criar uma classe para representar um Produto com
a estrutura (atributos) descrita abaixo. Esta classe estar associada com
outra classe, a ItemPedido. Item pedido possui o produto e a sua
quantidade. No final voc ir criar uma classe com mtodo main para
testar sua aplicao. Siga os passos abaixo para realizar o exerccio.

Passo 1: Crie uma classe chamada Produto dentro de seu projeto. Esta
classe dever pertencer ao pacote com.targettrust.java.

Passo 2: Defina nesta classe os seguintes atributos privados:

private String codigo
private String descricao
private float preco
private boolean emVenda
private float desconto

Passo 3: Crie operaes pblicas para acessar estes atributos permitindo
que os mesmos possam ser lidos e modificados.

Passo 4: Documente o cdigo escrito por voc. Use comentrio de
documentao para mostrar o que as operaes realizam bem como seus
parmetros e tipo de retorno.

Passo 5: Crie uma outra classe pblica com o nome ItemPedido. Esta
classe deve pertencer ao pacote com.targettrust.venda.

Passo 6: Para esta classe declare os seguintes atributos privados:

private int quantidade
private Produto produto

Passo 7: Crie operaes pblicas para acessar estes atributos de forma
que seja possvel modificar e ler os seus valores.

Passo 8: Crie uma nova classe chamada Aplicao no pacote
com.targettrust.java. Dentro desta classe declare o mtodo main mostrado
anteriormente na apostila. O mtodo main aquele que permite executar a
classe.

3-43

Passo 9: Dentro do mtodo main crie objetos da classe ItemPedido e
Produto e em seguinda associe estes objetos. Lembre-se que um ItemPedido
possui uma referncia para um Produto. Defina valores para os outros atributos
dos objetos.

Passo 10: Crie na classe Aplicacao uma operao que seja capaz de
receber como parmetro um ItemPedido e faa a impresso das informaes do
objeto que esta operao receber.

Passo 11: Gere a documentao utilizando o javadoc para as classes
criadas no exerccio.
Java Fundamentals

4-1
4
4
.
.
C
C
o
o
m
m
a
a
n
n
d
d
o
o
s
s
d
d
a
a
L
L
i
i
n
n
g
g
u
u
a
a
g
g
e
e
m
m

Comandos da Linguagem
4-2
Objetivos

Conhecer os comandos da linguagem java
Compeender os comandos e saber o contexto no qual podem ser
utilizados
So estudados os seguintes comandos:
switch
while
do
for
for-each
break
continue
if
else if
Operador ternrio
4-3
Comandos

Os comandos da linguagem so comandos comuns a maioria das
linguagens de programao. O objetivo deste captulo adaptar o aluno a
sintaxe destes comandos na linguagem java. Para isto abxaixo aprensentamos os
comandos:: switch, while, do, for, for-each, break, continue,
return, if e else if.

4-4
Comando if / else / else if

O comando if o principal comando de controle de fluxo. Ele possibilita
ao programador Java tomar decises ou, mais precisamente, executar um
comando somente quando uma determinada condio for verdadeira.
O comando if sempre vem sempre acompanhado de uma expresso
(que a condio que pende sobre a execuo do comando) e um comando
(que somente ser executado se a expresso anterior for avaliada para
verdadeiro). Se a expresso for verdadeira o comando executado. Se a
expresso for falsa, o comando saltado.
Por exemplo:
Cdigo 4-1: Comando if simples.

Embora parea um pouco estranho, os parntesis que envolvem a
expresso so exigidos pela sintaxe do comando. Como j foi mencionado, um
bloco de comandos delimitados por chave (comando composto) comporta-se
como um comando simples, e pode ser sempre colocado onde um comando
simples esperado. Desta forma, o comando if tambm pode ser escrito assim:

Cdigo 4-2: Comando if com expresso lgica e bloco de comandos.

Um comando if pode opcionalmente incluir a palavra reservada else
seguida de um comando (simples ou composto). Neste caso, a expresso
condicional avaliada e, se for verdadeira, o comando que segue a palavra
reservada if executado e o comando que segue a palavra else pulado.
Se a expresso for falsa o contrrio ocorrer: o comando que segue a
palavra reservada if pulado e o comando que segue a palavra reservada
else executado.

if(usuario == null) {
usuario = "admin";
}
if( (endereco == null) || (endereco.equals("") ) ) {
endereco = "[desc.]";
System.out.println("Endereo no encontrado");
}

4-5
Cdigo 4-3: Comando if/else simples.

Quando h vrios comandos if/else aninhados necessrio alguma
precauo para garantir que a clusula else se refere ao comando if correto.
Considere as seguintes linhas:

Cdigo 4-4: Comando if mal identado.

Infelizmente no est claro com qual if a clusula else faz par. A
identao sugere ser o primeiro if o par da clusula else. E sugere
erradamente, levando o programador a uma situao de erro.
A regra para o casamento dos pares if/else bem simples. A clusula
else sempre faz par com o comando if mais prximo. Corrigindo a identao,
para que represente corretamente os pares if/else, teremos:
Cdigo 4-5: Comando if mal identado.

if(usuario != null) {
System.out.println("Ol! " + usuario);
}else {
usuario = getNomeUsuario();
System.out.println("Ol! " + usuario + "Esta sua primeira sesso" );
}

if(i == j)
if(j == k)
System.out.println("i igual a k");
else
System.out.println("i no igual a j"); // ERRADO
if(i == j)
if(j == k)
else
System.out.println("i no igual a j"); // ERRADO
4-6
Muito cuidado deve ser tomado, pois no h erro de sintaxe nos dois
exemplos acima. So construes perfeitamente legal. S no ocorre o que o
programador deseja. Ao trabalhar com comandos ifs aninhados use chaves a
fim de tornar o cdigo mais legvel.
Cdigo 4-6: Comando if identado corretamente.
if(i == j) {
if(j == k) {
}
}else {
System.out.println("i no igual a j"); // CORRETO
}
4-7
Seqncia de Clusulas else if
O comando if/else til para testar uma condio e escolher qual
comando ou bloco de comandos executar. Mas, e se devemos escolher no um
bloco entre dois, mas sim um entre vrios? Para resolver este tipo de problema
comum usarmos uma seqncia de clusulas else if.
Clusulas else if no so uma novo comando da linguagem Java, ou
mesmo uma sintaxe alternativa de um comando existente. Estas clusulas so
apenas o emprego inteligente do conhecido comando if/else associado a
uma identao que facilite o entendimento.
Veja o exemplo abaixo:
Cdigo 4-7: Comando if em sequncia identado a esquerda.

No h nada de especial no cdigo acima. apenas uma seqncia de
comandos ifs, onde cada if parte da clusula else do comando anterior.
No entanto, escrito desta forma o cdigo fica bem mais legvel e claro do que se
fosse escrito com sucessivos aninhamentos (basta dar uma olhada no exemplo
abaixo).
if(n == 1) {
// executa bloco de cdigo 1
}else if(n == 2) {
}else if(n == 3) {
}else {
// se todas as condies acima falham, ento
}

if(n == 1) {
}
else {
if(n == 2) {
}
else {
if(n == 3) {
}
else {
}
}
}

4-8
Cdigo 4-8: Comando if em sequncia identado em relao a blocos de cdigo.

4-9
Operador ternrio

Java tambm define um operador ternrio, chamado freqentemente de
operador condicional. Funciona como um comando if dentro de uma
expresso. Seus trs operandos so separados por um ponto de interrogao ?
e por dois pontos :. O segundo e o terceiro operando devem ser do mesmo
tipo.
Veja o cdigo abaixo:
int x, y;
...
String res = ;
if ( x > y ) {
res = X maior que Y;
}else {
res = Y maior que X;
}
...
System.out.println( res );

Cdigo 4-9: Comando if else a ser transformado em operador ternrio

Agora vamos ver o mesmo cdigo fazendo usto do operador ternrio:

int x, y;
...
String res = (x > y)?X maior que Y:Y maior que X;
...
System.out.println( res );
Cdigo 4-10: Expresso com operador ternrio

Observe que o cdigo bem mais enxuto para este caso de if..else
4-10
Comando switch
O comando if provoca um desvio no fluxo de execuo de um programa.
Voc pode usar mltiplos comandos ifs, como mostrado na seo anterior, para
executar desvios mltiplos de execuo. Entretanto, esta nem sempre a melhor
soluo especialmente quando todos os desvios dependem do valor de uma
nica varivel.
Neste caso ineficiente conferir repetidas vezes o valor de uma mesma
varivel em mltiplos comandos ifs.
Uma soluo melhor usar o comando switch. Embora a sintaxe deste
comando no possua a mesma elegncia apresentada por outros comandos da
linguagem, a praticidade deste tipo de construo o torna extremamente til. Se
voc no est familiar com este comando, talvez j conhea, no entanto, a
idia que est por detrs dele.
O comando switch possui uma expresso inteira e um corpo que contm
vrios pontos de entrada numerados. A expresso avaliada e o fluxo de
execuo salta para o ponto de entrada especificado com o valor avaliado. O
comando switch seguinte equivalente ao uso repetido de comandos if e
else/if, como mostrado na seo anterior.
Cdigo 4-11: Comando switch padro de inteiros utilizando break

Como voc pode ver a partir deste exemplo, os vrios pontos de entrada
do comando switch so rotulados ou com a palavra reservada case seguida de
um valor inteiro e dois pontos, ou ento da palavra reservada default seguida
de dois pontos.
switch(n) {
case 1:
// comea aqui se n == 1
break; // para aqui

case 2:
break; // para aqui

case 3:
case 4:
break; // para aqui

default:
break; // para aqui
}
4-11
Quando o comando switch executado, o interpretador Java calcula o
valor da expresso entre parntesis e ento procura pelo rtulo case que tenha
especificado este valor.
Se ele consegue encontrar tal rtulo, o fluxo de execuo transferido
para o bloco de cdigo que tem incio no primeiro comando aps o rtulo.
Se ele no encontra um rtulo com o valor da expresso avaliada, o fluxo
de execuo salta para o primeiro comando aps o rtulo especial default. Ou,
caso um rtulo default no tenha sido definido, o fluxo de execuo salta
totalmente para fora do comando switch.
Observe o uso da palavra reservada break ao final de cada rtulo case no
exemplo anterior. O comando break ser descrito mais adiante, mas, neste caso,
ele faz com que o fluxo de execuo salte para fora do corpo do comando
switch.
Os rtulos case em um comando switch especificam somente o ponto de
entrada para o bloco de cdigo a ser executado. Os rtulos cases no so
blocos independentes de cdigo, e no possuem um ponto de trmino implcito.
Portanto, voc deve especificar o fim de cada rtulo com um comando break
ou equivalente.
Na ausncia de um comando break, a expresso avaliada e o fluxo de
execuo salta para o bloco de cdigo que tem seu incio logo aps o rtulo
que define a expresso avaliada, e a execuo continua at o final do
comando switch.
Em raras ocasies se revela til escrever cdigo em que a execuo
atravessa mais de um rtulo. Em 99% dos casos, depois de encontrado o rtulo e
executado o bloco de cdigo associado a este, a execuo deve deixar o
comando switch por fora de um comando break. Lembre-se, portanto, de
sempre verificar se h um comando break aps cada rtulo, garantindo a sada
correta do comando e impedindo que o fluxo de execuo passe por todos os
rtulos do comando.
Um comando switch pode ter mais de uma clusula case rotulando um
mesmo comando.
Considere o seguinte mtodo:
boolean respostaSimOuNao( char resposta ) {
switch( resposta ) {
case 's':
case 'S': return true;

case 'n':
case 'N': return false;

default: return false; //por default a resposta ser false
}
}

4-12
Cdigo 4-12: Comando switch de char sem utilizao de break e com comando return.

H algumas importantes restries sobre o comando switch e os rtulos
cases. A expresso associada com o comando switch deve ter um tipo byte,
char, short ou int. Valores booleanos ou reais no so suportados, nem o tipo
long, apesar de ser um tipo inteiro.
Os valores associados com cada rtulo case devem ser ou constantes, ou
expresses constantes avaliveis em tempo de compilao. Um rtulo case no
pode conter expresses avaliveis em tempo de execuo, tais como variveis
ou chamadas de mtodos.
Os valores presentes nos rtulos cases devem estar compreendidos na faixa
de valores do tipo usado na expresso do comando. Por fim, dois rtulos cases
no podem ter o mesmo valor, nem um comando switch pode ter mais de uma
clusula default.
4-13
Comando while

Assim como o comando if o principal comando de controle de fluxo,
permitindo ao programador tomar uma entre vrias decises, o comando while
o principal comando de iterao da linguagem Java e permite ao
programador executar um bloco de cdigo reiteradas vezes.
Ele possui a seguinte sintaxe:
Cdigo 4-13: Estrutura do comando while.

O comando while comea por avaliar a expresso entre parntesis. Se
esta expresso avaliada para falso, o fluxo de execuo pula o corpo do
comando while e passa a executar o prximo comando definido no programa.
Se, no entanto, a expresso verdadeira, o corpo do lao while executado e
a expresso entre parntesis reavaliada. Este ciclo continua enquanto a
avaliao da expresso resultar verdadeiro.
Quando a expresso se tornar falsa, a execuo do comando while
termina e o fluxo de execuo passa para o prximo comando. Voc pode criar
um lao infinito com a sintaxe while(true) (pois a expresso sempre
verdadeira).
Um exemplo de um lao que imprime os nmeros de 0 a 9:
Cdigo 4-14: Comando while com teste lgico para impresso de inteiros entre 0 e 9.

Como voc pode ver, a varivel cont comea em 0, neste exemplo, e
incrementada cada vez que o corpo do lao executado. Aps o lao ter sido
executado 10 vezes, a expresso do comando while se torna falsa (i assume o
valor 10), o comando while termina, e o fluxo de execuo passa para o
prximo comando do programa.
A maior parte dos laos tem uma varivel contadora, como i. Os nomes
de variveis: i, j e k so usados, na maioria das vezes, para tais variveis
contadoras, embora voc possa escolher um nome mais claro.
while(expressao) {
comandos
}
int i = 0;
while(i < 10) {
System.out.println(i);
i++;
}

4-14
Comando do

O comando do bastante similar ao comando while. A diferena que,
no comando do, o teste da expresso feito no final do lao.
Isto significa que o corpo do lao executado pelo menos uma vez.
Eis a sintaxe do comando:
Cdigo 4-15: Estrutura do comnado do/while.

H algumas diferenas a se observar entre o lao presente no comando do
e o lao presente no comando while. O lao do comando do requer tanto a
palavra reservada do para marcar seu incio, quanto a palavra reservada while
para marcar o seu trmino e introduzir a expresso condicional do lao.
Ao contrrio do lao do comando while, o lao do comando do sempre
termina com um ponto e vrgula. Isto obviamente ocorre pelo fato de a
expresso condicional ser colocada no final do comando.
O lao abaixo gera a mesma sada que o cdigo apresentado para o
comando while:
Cdigo 4-16: Comando do/while com teste lgico no final para impresso de inteiros entre 0 e 9.

Observe que o comando do bem menos usado que o comando while.
Isto acontece porque, na prtica, incomum encontrarmos situaes em que se
deseje que o corpo do lao seja executado pelo menos uma nica vez.
do {
comandos
}
while(expressao);
int i = 0;
do {
System.out.println( i );
i++;
} while( cont < 10 );

4-15
Comando for

O comando for fornece uma construo de iterao que , na maioria
das vezes, mais conveniente que os laos while e do. O comando for tira
vantagem de haver um padro de iterao bastante freqente. A maior parte
dos laos possui um contador, ou algum tipo de varivel de estado, que
inicializado antes da execuo do lao e incrementado, ou de alguma forma
alterado, aps o trmino da execuo do corpo do lao e antes da reavaliao
da expresso condicional associada ao lao.
Os passos de inicializao, teste e atualizao constituem as principais
manipulaes feitas sobre as variveis do lao e integram a sintaxe do comando
for.

Cdigo 4-17: Estrutura do comando for

Colocar as expresses de inicializao, teste e atualizao no incio do
lao algo que facilita a compreenso do que est ocorrendo no corpo do
lao, e evita erros tais como esquecer de inicializar as variveis do lao.
O interpretador Java descarta os valores das expresses de inicializao e
atualizao, logo, para que estas expresses sejam teis, elas devem ter efeitos
colaterais.
A expresso de inicializao tipicamente uma expresso de atribuio,
enquanto a expresso de atualizao usualmente uma expresso de
incremento, decremento ou atribuio.
O seguinte lao imprime os nmeros de 0 a 9, como os exemplos
anteriormente colocados para os comandos while e do:
Cdigo 4-18: Comando for com teste lgico e incremento para impresso de inteiros entre 0 e 9.

Observe como esta sintaxe coloca todas as informaes importantes sobre
a varivel do lao em uma nica linha, facilitando a compreenso do que
ocorre no corpo do lao.
for( declarao e inicializao; teste; atualizao ) {

}

for( int i = 0; i < 10; i++ ) {
Sytem.out.println( i );
}
4-16
Colocar a expresso de atualizao da varivel do lao na sintaxe do
prprio comando for simplifica tambm o corpo do lao, permitindo que este
possa ser expresso, muita das vezes, atravs de um nico comando simples, sem
a necessidade do uso de um bloco de cdigo entre chaves.
O comando for suporta sintaxes alternativas que ajudam ainda mais
facilitar o seu uso. Pelo fato da maioria dos laos usar as variveis de lao apenas
dentro do corpo do lao, o comando for permite que a expresso de
inicializao contenha uma declarao completa de variveis.
O escopo das variveis declaradas na expresso de inicializao de um
comando for se restringe ao corpo do lao e tais variveis no mais podem ser
acessadas fora do comando.

Cdigo 4-19: Comando for com escopo de varivel local (i).

Alm do mais, a sintaxe do comando no restringe a utilizao do
comando a laos com apenas uma varivel. Tanto a expresso de inicializao
quanto a de atualizao podem conter, em verdade, a inicializao e
atualizao de mais de uma varivel, desde tais variveis venham separadas por
vrgulas.
Por exemplo:
Cdigo 4-20: Comando for com expresso utilizando o ndice e variveis locais.

Muito embora todos os exemplos de utilizao do comando apresentem
contadores numricos, os laos construdos com o comando for no se
restringem apenas utilizao de contadores.
As expresses de inicializao, teste e atualizao do comando for so
todas elas opcionais. O caractere de ponto e vrgula que separa tais expresses
, no entanto, obrigatrio. Se a expresso de teste omitida, presume-se que ela
sempre verdadeira.
Com isto, um lao infinito pode ser escrito desta forma:
Cdigo 4-21: Comando for com loo infinito.
for( int i = 0; i < 10; i++ ) {
Sytem.out.println( i );
}

for( int i = 0, j = 10; i < 10; i++, j-- ) {
sum += i * j;
}

for( ;; ) // for infinito

4-17

4-18
Comando for-each

O novo for um lao de repetio mais fcil e bonito de escrever. Este
substitui o lao for atual de uma forma mais elegante para iterar sobre colees.
Observe o cdigo abaixo que nos permite iterar uma coleo de alunos atravs
do lao for tradicional:

Collection<Aluno> c = new ArrayList<Aluno>();
...
for (Iterator<Aluno> i = c.iterator(); i.hasNext(); ) {
System.out.println( i.next().getNome() );
}
Cdigo 4-22: Comando for a ser transformado em for-each

Veja que uma simples tarefa de iterar uma coleo demanda um volume
considervel de cdigo. Agora observe a mesma verso deste cdigo utilizando
o lao for-each juntamente com o novo import static:

Collection<Aluno> c = new ArrayList<Aluno>();
...
for ( Aluno a : c ) {
out.println( a.getNome() );
}
Cdigo 4-23: Comando for-each, mais simples que for

O sinal de : lido com em. Desta forma o cdigo acima pode ser lido
da seguinte forma: Para cada aluno a em c.

For-each tambm pode ser aplicado a arrays. Neste caso voc pode iterar
um array da seguinte forma:

int[] notas = {2, 5, 7, 9, 4, 18};
int total = 0;
for( int n : notas) {
total += n;
}
out.println( total );
Cdigo 4-24: For-each para somar notas

4-19
Comando break
O comando break utilizado para transferir o controle para fora do corpo
do comando de lao ou switch mais prximo, transferindo imediatamente o
controle para o primeiro comando aps o corpo do lao ou switch. usado,
assim, para prematuramente sair de qualquer tipo de lao.
Este comando muito til para abortar um lao quando algum evento
ocorre durante a execuo do corpo deste lao.
Cdigo 4-25: Estrutura do comando break

O seguinte trecho de cdigo utiliza o comando break junto ao comando
while. Ele imprime nmeros que juntos somam um valor menor que 200, iniciando
em 0.
Cdigo 4-26: Comando break finalizando um loo while

O comando break tambm utilizado junto ao comando switch, para sair
do corpo do comando. O trecho a seguir demonstra este uso.
Cdigo 4-27: Comando break finalizando um comando switch

O comando break pode ser utilizado tambm seguido por um label que
especifica um comando presente no mtodo. Com o uso do comando break
break;
int i = 0;
int total = 0;
while( i < 100 ) {
total += i; // total = total + i;
if( total >= 200 ) {
break;
}
i++;
}
switch( resposta ) {
case 's':
case 'S': System.out.println("Resposta SIM.");
break;

case 'n':
case 'N': System.out.println("Resposta NO.");
break;

default: System.out.println("Resposta no reconhecida.");
}
4-20
associado a um label, possvel interromper qualquer lao dentro da definio
do mtodo, e no somente o lao mais prximo.
Para utilizar o comando break com label, o label deve ser inserido antes do
comando que se deseja interromper. O label pode ser qualquer identificador
vlido, seguido por :.
Um comando break especificando este label causar um pulo para o
primeiro comando aps o fim do corpo do comando com este label.
Cdigo 4-28: Estrutura de comando break para quebra de laos nomeados

O trecho de cdigo a seguir exemplifica este uso. Aps o mltiplo dos inteiros
i e j atingir um valor maior que 200, o comando for associado ao label
comandoFor interrompido (comando for mais externo) e a linha indicando que
o mltiplo foi atingido ser impressa.
Cdigo 4-29: Comando break para quebra de lao for externo comandoFor.

O comando break com label muito utilizado para interromper laos
aninhados. Contudo, embora este seja um mecanismo vlido, ele pode levar a
um cdigo que no claro e de difcil manuteno, sendo melhor evit-los
repensando a lgica do lao.
label:
comando {
...
break label;
...
}
comandoFor:
for( int i = 0; i < 100; i++ ) {

for( int j = 0; j < 100; j++ ) {
System.out.println(i*j);
if (i * j >= 200) {
break comandoFor;
}
}
}
System.out.println( "Fim do Comando FOR" );
4-21
Comando continue

O comando continue usado para transferir o controle para o fim do
corpo do lao, antes da re-avaliao da expresso de teste. Causa, assim, a
interrupo da interao do lao corrente e o pulo para a prxima interao do
lao.
Cdigo 4-30: Estrutura do comando continue.

O trecho a seguir exemplifica o seu uso. Neste exemplo, o comando
continue utilizado para interromper a execuo do resto do corpo do
comando for em todos os nmeros pares.
Ao final, a soma de todos os nmeros mpares positivos menores que 10
apresentada.
Cdigo 4-31: Comando continue reiniciando o lao for na prxima iterao de i

O comando continue deve ser utilizado com cuidado, pois o algoritmo
resultante se torna pouco estruturado e de difcil manuteno.
O comando continue pode, assim como o break, ser utilizado com um
label. Um comando continue com label causar a interrupo da interao
corrente e o pulo para a prxima interao do lao associado ao label.

continue;
int total = 0;
for( int i=0; i < 10; i++ ) {
if( i % 2 == 0 ) {
continue;
}
total = total + i;
}
System.out.println( total );
forExterno:
for( int i = 0; i < 100; i++ ) {

for( int j = 0; j < 100; j++ ) {
System.out.println( i*j );
if( i * j >= 200 ) {
continue forExterno;
}
}
}
System.out.println( "Fim do FOR Externo" );
4-22
Cdigo 4-32: Comando continue para reincio de lao for externo forExterno no prximo ndice
de i

4-23
Espao para anotaes
4-24
Exerccios

1. Este exerccio far com que voc altere as classes criadas no captulo
anterior adicionando algumas validaes as suas operaes.
Passo 1: Na classe Produto faa uma validao do parmetro passado
para operao que altera o preo do Produto. No permita preos negativos.
Valide tambm o cdigo do Produto. Este deve possuir no mximo 6 caracteres.
Passo 2: Na classe ItemPedido, no permita atribuir atravs do mtodo
set um item do pedido ao produto se este no estiver em vendas. Faa o
objeto item pedido recusar (no realizar a atribuio) o produto.
Passo 3: Agora faa uma alterao na classe Aplicacao para que a
mesma ao imprimir os atributos booleanos imprima as palavras Sim e No ao
invs de true/false. Para isto utilize o operador ternrio. Compile e teste a
aplicao.
Passo 4: Altere um dos objetos produto que voc criou para que o
mesmo no esteja mais em vendas. Rode novamente a sua aplicao e verifique
que para o pedido com o qual voc tentou associar um produto que no estava
em venda no sair dados do produto. Nesta execuo a JVM lancar tambm
uma exception (NullPointerException).
Passo 5: Altere o cdigo agora que faz a impresso das informaes de
um ItemPedido na classe Aplicacao para que quando um ItemPedido no tenha
um produto seja impresso uma string mostrando isto.

2. Crie uma classe com o nome GeradorSenhas para que nesta seja
possvel gerar senhas atravs de um lao de repetio.
Passo 1: Crie uma classe pblica chamada GeradorSenhas no pacote
com.targettrust.java e nesta classe declare o mtodo main para que a mesma
possa ser executada.
Passo 2: Utilizando um lao de repetio a sua escolha (for, while, ..) faa
a gerao de 10 senhas randmicas com no mximo 8 dditos.

Dica para gerar nmeros randomicamente:
Utilize a classe Math do pacote java.lang. Esta possui um mtodo
chamado random() que gera nmeros aleatrios entre zero e um, excluindo o
inteiro um. Veja a documentao JAVADOC para mais detalhes.
4-25

4-26
Java Fundamentals

5-1
5
5
.
.
A
A
p
p
r
r
o
o
f
f
u
u
n
n
d
d
a
a
n
n
d
d
o
o
o
o
e
e
s
s
t
t
u
u
d
d
o
o
s
s
o
o
b
b
r
r
e
e

C
C
l
l
a
a
s
s
s
s
e
e
s
s

Aprofundando o estudo sobre classes
5-2
Objetivos

Estudar overloading e overriding
Como utulizar mtodos construtores
Compreender a referncia this
Estudar o mtodo destrutor finalize
Criar operaes com escopo de classe e instncia
Compreender o mecanismo de herana
Utilizar o recurso de varargs
Aplicar o polimorfismo
Compreender o modificador final
Estudar as enumerations
5-3
Viso Geral

Mtodos de instncia so o fundamento para o encapsulamento de classes
e peas chaves para fornecer uma interface consistente. Classes definidas
atravs de tcnicas adequadas de encapsulamento fornecem mtodos de
instncias como o nico meio de se acessar e alterar o estado de um objeto.
Permitir o acesso direto s variveis de instncia de uma classe, sem que seja
necessrio invocar mtodos para tal, uma tcnica de programao perigosa,
pois no garante um estado sempre consistente para o objeto (o usurio no fica
restrito s regras de negcios definidas na manipulao do objeto).
A sobrecarga permite que uma chamada a um mtodo possua diferentes
comportamentos de acordo com os parmetros passados. Suponha, por
exemplo, a classe Cliente.
O mtodo comprar() desta classe pode ter comportamentos distintos
dependendo dos parmetros recebidos.
Se a chamada for comprar(dinheiro), o comportamento invocado ser
provavelmente um pagamento vista, enquanto se for comprar(cheque), outro
ser o comportamento invocado, fazendo com que o dbito de pagamento
possa ser realizado em um dia posterior.
Sobrecarga uma tcnica poderosa, ao permitir que a classe tenha uma
aparncia uniforme para o mundo externo.
Construtores garantem que, a despeito de quem cria o objeto, o objeto ter
as caractersticas esperadas para a classe.
Ao se criar um objeto, o mtodo construtor implicitamente chamado,
oferecendo um local adequado para as rotinas de inicializao. Isto ponto
chave para programao orientada por objetos, j que impossvel saber quem
criar novos objetos das classes que voc definiu.
5-4
Overloading sobrecarga de operao

Dois ou mais mtodos em uma classe podem ter o mesmo nome, desde que
tenham assinaturas diferentes. A assinatura de um mtodo formada por seu
nome, juntamente com o nmero, tipo e ordem dos parmetros. O tipo de
retorno do mtodo no considerado como parte da assinatura.
A definio de dois ou mais mtodos com o mesmo nome, mas com
assinaturas diferentes conhecida como sobrecarga de mtodos (method
overloading). Esta tcnica til, pois oferece uma interface unificada da classe
para o mundo externo.
O mtodo exato a ser chamado determinado pelos parmetros presentes
na chamada, ou seja pela assinatura. Sem a tcnica de sobrecarga, cada
mtodo exigiria um nome nico, tornando mais difcil a codificao. Se voc
quisesse, por exemplo, recuperar informaes sobre um cliente usando como
chave de pesquisa o ID do cliente ou o nome, teria de escrever mtodos com
nomes distintos: getClientePorNome(nome) e getClientePorID(id).
Usando sobrecarga, os dois mtodos podem ter o mesmo nome
getCliente(), um esperando o parmetro id e o outro esperando o parmetro
nome, como mostrador abaixo:
public class ClienteDB {

public Cliente getCliente(String nome) {
...
}

public Cliente getCliente(int id) {
...
}
}
Cdigo 5-1 : Overloading da operao getCliente()

Quando o usurio de uma classe chamar um mtodo sobrecarregado, o
compilador escolher o mtodo correto a ser chamado analisando os
parmetros passados na chamada e comparando tais parmetros com os
esperados por cada um dos mtodos com aquele nome na definio da classe.
Se o compilador no conseguir um casamento compatvel, mesmo aps
efetuar as converses implcitas permitidas pela linguagem, um cdigo de erro
ser retornado. Do contrrio, se mais de um casamento possvel, o compilador
reclamar e assinalar erro de ambigidade na definio do mtodo.
Mtodos sobrecarregados no podem ser diferenciados exclusivamente
pelo tipo de retorno. Se a nica diferena entre a declarao de dois mtodos
5-5
for o tipo de retorno, o compilador retornar um erro e no aceitar a
construo.
A distino entre mtodos sobrecarregados deve sempre ter por base o
nmero e os tipos de parmetros esperados.
Cdigo 5-2: Sobrecarga de mtodos.

...
}

public float getPreco( float desconto ) {
...
}
}
sobrecarga de
mtodo
5-6
Mtodos construtores

Mtodos construtores so chamados quando um objeto da classe estiver
sendo criado. Podem ser utilizados para realizar algo no momento de criao do
objeto, como por exemplo, inicializar atributos do mesmo para determinados
valores.
O construtor um mtodo especial chamado automaticamente pelo
ambiente de execuo Java quando um objeto criado. Um construtor sempre
tem o mesmo nome que a classe. Ele pode esperar nenhum, um ou vrios
parmetros, mas no pode ter nenhum tipo de retorno. Veja no cdigo abaixo a
declarao de um construtor:


Produto( ) {
...
}

}
Cdigo 5-3: Definindo construtores

O construtor acima conhecido como construtor default. O que acontece
se um construtor no fornecido? Caso nenhum construtor seja fornecido, Java
supre esta ausncia com um construtor default. Este construtor no recebe
nenhum parmetro e no executa nenhuma tarefa de inicializao.
possvel colocar dentro deste construtor um cdigo a ser executado no
momento de criao do objeto. Assim quando o objeto da classe produto for
criado utilizando o construtor acima este cdigo ser executado. Veja como
pode ser criado um objeto utilizando o construtor acima:

public class CriaObjeto {
}
}
Cdigo 5-4 : Criando um objeto e chamando o construtor

Observe que o cdigo acima j havia sido utilizado anteriormente, mas
agora voc pode perceber que estamos chamando o construtor default no
momento da criao do objeto.
5-7
Se voc desejar, poder fornecer mais construtores na mesma classe. Desta
maneira se fornecer algum construtor o compilador no mais ir;a gerar o
construtor default.
Entretanto, na maioria das vezes, ser necessrio declarar um ou mais
construtores para a classe, a fim de permitir diferentes formas de criao do
objeto, como mostrado no cdigo abaixo a criao de quatro objetos da classe
produto de quatro formas diferentes:

Cdigo 5-5: Sobrecarga de construtores de Produto

Para permitir que o usurio crie objetos desta maneira, ser necessrio
fornecer os contrutores na classe Produto e que inicialize o estado do objeto
Produto com as opes fornecidas.
Construtores geralmente so declarados como public, salvo quando se
deseja restringir quem pode criar objetos da classe. Veja abaixo um exemplo de
construtor para a primeira e a segunda inicializao acima:


private int codigo;

public Produto(int c, String d, float p ) {
codigo = c;
descricao = d;
preco = p;
}

public Produto(int c, String d) {
codigo = c;
descricao = d;
}
}
Cdigo 5-6 : Construtores da classe Produto

Observe o cdigo acima e veja que alm de termos definido construtores
na classe Produto para dentro dos mesmos fazer a inicializao de um produto,
tambm temos overloading de construtores.
Produto prod1 = new Produto( 1, "CD", 45.50f );
Produto prod2 = new Produto( 2, "DVD" );
Produto prod3 = new Produto( "VHS" );
Produto prod4 = new Produto();
5-8

5-9
Referncia this

Esta referncia representa um objeto da prpria classe. O this referencia o
objeto corrente. Todos os objetos possuem o this.
Todos os mtodos de instncia recebem um parmetro implcito chamado
this, que pode ser usado dentro do mtodo de instncia para se referir ao
objeto corrente. O objeto corrente aquele cujo mtodo foi invocado. O
parmetro this uma referncia implcita para objeto chamado e, como tal,
no necessrio na maioria dos casos.

Cdigo 5-7: Referncia implcita this do objeto invocado.

Dentro de um mtodo de instncia, todas as referncias no qualificadas
para variveis de instncia ou mtodos de instncia esto implicitamente
associadas com a referncia this. Os dois comandos dentro do mtodo
setNome(), apresentados abaixo, so equivalentes:

Cdigo 5-8: Referncia implcita this para representar variveis de instncia.

public void setNome(String nome) {
this.nome = nome;
}
}

public void metodo() {
Produto p1 = new Produto();

p1.setNome( "CD" );
p2.setNome( "DVD" );
}

public void setNome( String nome ) {
nome = nome; // ERRO!
this.nome = nome; // Forma correta
}
p1
nome:"CD"

p2
nome:"DVD"

this
5-10
H duas situaes em que voc deve usar explicitamente a referncia this:

O nome de uma varivel de instncia escondido por uma parmetro
formal, de mesmo nome, do mtodo de instncia. Suponha, por exemplo,
uma classe que tenha uma varivel de instncia nome, e um mtodo de
instncia que recebe uma varivel tambm chamada nome. O parmetro
formal nome deste mtodo esconde a varivel de instncia nome.
Qualquer referncia para nome, dentro deste mtodo, acessar o
parmetro formal, no varivel de instncia. Para acessar a varivel de
instncia, voc deve usar this.nome.

Quando voc precisa passar uma referncia para o objeto corrente
como parmetro de um outro mtodo
5-11
Compartilhando cdigo entre Construtores

Um construtor pode chamar outro construtor da mesma classe usando a
sintaxe this().
Cdigo 5-9: Referncia this invocando o construtor da prpria classe de acordo com os tipos de
parmetros.

O primeiro construtor chama o segundo construtor passando vazio como
parmetro. O segundo construtor copia a referncia para o objeto String na
varivel nome. Esta tcnica garante que o nome default para todos os objetos
Produto seja uma string vazia sem a necessidade de se duplicar cdigo em
mltiplos construtores.
A sintaxe this() minimiza a necessidade de se duplicar cdigo nos
construtores. Esta tcnica especialmente til se a rotina de inicializao
complexa. Toda a complexidade vai em um construtor que chamado pelos
demais.
Ao usar a sintaxe this() algumas regras de sintaxe devem ser observadas:
A chamada para this() deve ser o primeiro comando do construtor
Os parmetros de this() devem casar com os parmetros esperados por
um construtor que no seja o chamador.
private String nome;

public Produto() {
this( );
}

public Produto(String nome) {
this.setNome( nome );
}
}
Um construtor pode
chamar outro construtor
usando a sintaxe this()
5-12
Mtodo destrutor finalize()

Em algumas linguagens como C++, uma classe pode fornecer um destrutor.
Um destrutor similar a um construtor, sendo chamado automaticamente logo
antes de o objeto ser destrudo.
Um destrutor normalmente empregado para liberar recursos mantidos pelo
objeto, tais como memria secundria alocada, arquivos abertos, etc.
Java gerencia automaticamente a memria, logo um objeto no precisa
explicitamente liberar memria que tenha alocado. Conseqentemente, Java
no suporta destrutores. A fim de permitir que um objeto libere outro recurso que
no memria (pois esta j automaticamente gerenciada), tais como arquivos
abertos, Java permite que uma classe fornea um mtodo finalize().
O mtodo finalize() chamado automaticamente quando um objeto
coletado pelo sistema coletor de lixo. Infelizmente, como vimos antes, no h
como saber quando isto ocorrer, ou mesmo que ocorrer antes de o programa
terminar.
A falta de previsibilidade de quando o mtodo finalize() ser chamado
inaceitvel se os recursos so escassos.
A nica soluo gerenciar tais recursos manualmente. A fim de assumir o
controle do processo, voc pode definir um mtodo pblico dispose() em sua
classe, que os usurios da classe tero de chamar quando tiverem terminado de
usar um objeto desta classe.
Voc pode ainda manter o mtodo finalize() se quiser, como um ltimo
esforo de liberar os recursos.
Cdigo 5-10: Mtodo finalize para liberao de recursos alocados pela objeto.

public void finalize() {
// Libera todos os recursos alocados pela classe
System.out.println( "Instncia sendo coletada pelo GC!" );
}
}
5-13
Variveis de instncia

Variveis de instncia so definidas dentro do bloco de cdigo da classe.
As variveis de instncia so variveis que iro guardar valores especficos para
cada instncia da classe. Normalmente definimos variveis/atributos como sendo
de instncia. Pode-se chamar os atributos que declaramos at o momento como
variveis de instncia. O padro quando declaramos atributos que os mesmos
sejam de instncia.

Veja o exemplo abaixo:

public class Cliente {

/* Variveis/atributos de instncia */
private String codigo;
private char plano;

/* Varivel de classe */
public static float desconto;
}
Cdigo 5-11 : Declarando vaiveis de instncia

Uma varivel/atributo de instncia pode ser acessado por um mtodo de
instncia somente, ou pelo construtor da classe.

Observe que no cdigo acima termos trs variveis de instncia e uma de
classe declaradas no fonte. Cada varivel de instncia ter um valor especfico
para o atributo. Veja a figura abaixo:

codigo = 98 codigo = 100
nome = Rafael nome = Walter
plano = A plano = B

obj01 obj02

Figura 5-1 : Objetos com variveis de instncia

5-14

O cdigo que cria estes objetos o seguinte:

public class CriaCliente {
Cliente obj01 = new Cliente();
obj01.setCodigo(98)
obj01.setNome(Rafael);
obj01.setPlano(A);

obj02.setCodigo(100)
obj02.setNome(Walter);
obj02.setPlano(B);

}
}
Cdigo 5-12 : Criando objetos Cliente

5-15
Mtodos de instncia

De maneira anloga s variveis de instncias, voc utiliza o operador
ponto para chamar um mtodo de instncia de um objeto. A sintaxe a
seguinte:

Cdigo 5-13: Estrutura de chamada de um mtodo de instncia com parmetros.

Se o mtodo no espera nenhum argumento, voc deve se lembrar apenas
de colocar os parntesis (uma lista vazia de parmetros):

Cdigo 5-14: Estrutura de chamada de um mtodo de instncia sem parmetros.

No exemplo abaixo temos declaros na classe trs mtodos de instncia.
Observe estes e veja que os mesmos acessam os atributos de instncia da classe.


private char plano;

/* Mtodos de instncia */
public void setCodigo(String codigo) {
this.codigo = codigo
}

public String getCodigo() {
return this.codigo;
}

public boolean validar() {
...
}
}

Cdigo 5-15: Definindo mtodos de instncia

referenciaObjeto.nomeMetodo(parmetros ...);

referenciaObjeto.nomeMetodo();

5-16
Variveis de classe

Variveis de classe so variveis comparadas as variveis globais. Estas ao
serem definidas iro possuir o mesmo valor para todos os objetos da classe.
Uma varivel de classe, tambm chamada varivel esttica (varivel
static), aquela que pertence classe e comum a todas as instncias desta
classe. Em outras palavras, h somente uma instncia de uma varivel de classe,
no importa quantas instncias da classe existam.
Observe o cdigo que declaramos na sesso anterior quando estvamos
estudando variveis de instncia. Havia uma varivel/atributo de classe. O
cdigo o seguinte:


private char plano;

/* Varivel de classe */
public static float desconto;
}
Cdigo 5-16 : Varivel de classe definida

Agora veja como seria o desconto para os objetos da classe:

codigo = 98 codigo = 100
nome = Rafael nome = Walter
plano = A plano = B

desconto = ...
obj01 obj02

Figura 5-2 : Objetos compartilhando varivel de classe

5-17

O desconte seria o mesmo para ambos os objetos. Em outras palavras
podemos dizer que um atributo/varivel de classe compartilhado por todos os
objetos da classe. Veja como ficaria o cdigo para acesso a este
atributo/varivel:

public class CriaCliente {
Cliente.desconto = 5.4f;

obj01.setCodigo(98)
obj01.setNome(Rafael);
obj01.setPlano(A);

obj02.setCodigo(100)
obj02.setNome(Walter);
obj02.setPlano(B);

}
}
Cdigo 5-17: Acessando varivel de classe

Quando formos nos referencia a um atributo/varivel de classe devemos
utilizar o nome da classe para tal e no o nome do objeto. Neste exemplo
estamos acessando diretamente o atributo, porm iremos mostrar mais adiante
como deve ser feito o acesso a ele via uma operao.
Em Java variveis de classe so declaradas usando a palavra reservada
static. No exemplo abaixo, ns declaramos a varivel de classe precoMinimo
porque, obviamente, o preo mnimo se aplica a todas as instncias da classe
Produto.
Observe que precoMinimo foi declarada private, porque ela precisa ser
acessada apenas pelos mtodos da classe Filme. Neste exemplo, a varivel
precoMinimo compartilhada por todos objetos, ou seja, igual para todas as
instncias de Filme, muito embora cada instncia possua sua prpria descrio
e cdigo.
Cdigo 5-18: Variveis de classe


private static double precoMinimo; // var. de classe
private String descricao; // var. de instncia
private int codigo; // var. de instncia

}
5-18
Figura 5-3: Variveis de classe e variveis de instncia.

5-19
Inicializando Variveis de Classe

Variveis de classe so inicializadas quando a classe carregada. Como
construtores so utilizados para construir instncias (e, portanto, invocados toda
vez que uma nova instncia criada), voc no pode utilizar construtores para
inicializar variveis de classe.
Variveis de classe possuem os mesmos valores de inicializao default que
as variveis de instncia (na verdade qualquer varivel definida e no
inicializada recebe um valor de inicializao default): inteiros recebem o valor 0,
reais o valor 0.0, booleanos o valor false, caracteres o valor '\u0000' e
referncias o valor null.
Assim como as variveis de instncia, as variveis de classe tambm podem
ser inicializadas com valores diferentes do valor default. Basta, para isto, utilizar
inicializadores.
Cdigo 5-19: Declarao de variveis de classe

Rotinas complexas de inicializao de variveis de classe devem ser
colocadas no bloco de inicializao esttico (tambm conhecido como
inicializador esttico).
Um inicializador esttico no possui nome, nem valor de retorno e comea
com a palavra reservada static seguida por um bloco de cdigo delimitado
por chaves (static {...}).
Funciona de maneira similar a um construtor, com a diferena de que
executado apenas uma nica vez e no depende das variveis de instncia de
uma classe (no pode sequer referenci-las).
Cdigo 5-20: Bloco static para inicializao de estruturas da classe

private static double precoMinimo = 30.50;
private String nome = "CD";
private int codigo = 1234;
...
}
private static double precoMinimo;
static {
Date dataAtual = new Date();
precoMinimo = getPrecoMinimoDia( dataAtual );
}
}
5-20
Mtodos de classe
Um mtodo de classe, tambm conhecido como esttico (mtodo static)
, um mtodo que pertence classe e compartilhado por todas as instncia
desta classe. Ao contrrio de um mtodo de instncia, uma mtodo de classe
no atua sobre um nico objeto. Estes mtodos no recebem, portanto, a
referncia implcita this.
Um mtodo de classe pode acessar somente variveis de classe e invocar
mtodos de classe.
Mtodos de classe so ideais para acessar variveis de classe. De fato, eles
so a nica maneira, caso no exista nenhuma instncia da classe (lembre-se:
mesmo no existindo nenhuma instncia de uma classe, as variveis de classe j
existem e tm um valor associado, pois so criadas quando a classe carregada
pelo ambiente de execuo.
No necessrio ter uma instncia da classe criada para poder acessar
variveis de classe) No exemplo abaixo, o valor do preo mnimo alterado
para todos os produtos, mesmo que nenhum objeto produto tenha sido criado
ainda.
Cdigo 5-21: Declarao de mtodo de classe

Veja o cdigo que usaria esta classe definida acima:

public class TestaStatic {
Produto.setPrecoMinimo( 17.5 );
// ou
p1.setPrecoMinimo( 19.23 ); // No recomendnado!
}
}
Cdigo 5-22 : Acessando mtodos de classe

Objetos de classe so chamados com a seguinte sintaxe:
Cdigo 5-23: Estrutura de chamada de mtodos de classe

private static double precoMinimo;
public static void setPrecoMinimo( float precoMinimo ) {
Produto.precoMinimo = precoMinimo;
}
}
NomeClasse.nomeMetodo(parametros);
5-21
Voc pode chamar mtodos de classe usando uma referncia para um
objeto e o operador ponto (da mesma maneira usada para mtodos de
instncia), mas ainda assim, o mtodo de classe s poder acessar as variveis
de classe.
5-22
Exemplos de variveis e mtodos estticos
Quando voc executa uma aplicao Java, a JVM localiza e chama o
mtodo main() desta classe. Muito embora tudo em um programa Java deva
estar definido dentro de uma classe, voc no precisa criar uma instncia da
classe principal se main() chama apenas mtodos de classe e manipula apenas
variveis de classe.

Cdigo 5-24: Exemplos de mtodos estticos.

Se, no entanto, main() acessa variveis ou mtodos de instncia da prpria
classe em que se encontra definido, necessrio, antes de mais que ele crie
instncias desta classe.
A classe Math fornece mtodos de classe para o clculo de muitas funes
matemticas, tais como funes trigonomtricas e logaritmos.
Fornece tambm vrias constantes de classe tais como e (2.71828) e
(3.1415926).
A classe System fornece vrios mtodos de classe que representam o
estado de todo o sistema (ambiente computacional). System.out uma
varivel de classe que se refere ao objeto PrintStream.
Esta varivel de classe representa a sada padro de dados. println()
um mtodo de instncia de PrintStream.

public class ApenasMetodosEstaticos {

public static void main( String args[] ) {
double num, raiz;
// ...
raiz = Math.sqrt( num ); // Usando uma biblioteca
System.out.println("A raiz de " + num + " " + raiz);
}
5-23
O mecanismo de herana entre classes

Herana define uma relao entre classes, onde uma classe (subclasse)
toma de emprstimo as estruturas de dados e os comportamentos de outra
classe (superclasse).
Herana uma valiosa tcnica porque estimula e possibilita a reutilizao
de software ao permitir criar uma nova classe baseada nas propriedades de uma
classe existente. Como resultado, o desenvolvedor capaz de alcanar grande
produtividade que, de outra forma, seria impossvel.
Construtores so blocos de cdigo executados quando um objeto de uma
classe criado. J vimos isto anteriormente. Ao usar o modelo de herana, cada
subclasse tem acesso ao construtor da superclasse. Qualquer cdigo comum
relativo a inicializao do objeto, pode ser colocado na superclasse e invocado
pela subclasse.
Esta tcnica minimiza a necessidade de se duplicar cdigo e garante
consistncia na criao de objetos.
Polimorfismo descreve a capacidade de Java executar um mtodo
especfico com base na referncia a um objeto utilizada na chamada. Usando
esta tcnica, voc pode definir um mtodo na superclasse e sobrescrev-lo na
subclasse apropriada.
Voc pode invocar os mtodos da superclasse e, caso o mtodo tenha
sido sobrescrito na subclasse, Java automaticamente chamar o mtodo
apropriado. Isto uma construo muito poderosa que possibilita definir mtodos
na superclasse sem mesmo conhecer detalhes de qualquer subclasse especfica.
Somente use herana para modelar uma genuna relao um tipo de.
Em outras palavras, no use herana seno quando todos os mtodos herdados
se aplicam subclasse.
Se voc no pode substituir um objeto da superclasse por um objeto da
subclasse, ento voc no tem uma genuna relao um tipo de. Neste caso,
as classes podem se relacionar, mas no hierarquicamente.
Se voc realmente usa herana, deve explorar a natureza polimrfica dos
mtodos de instncia na hierarquia de classes. Por exemplo, se voc acha que
deve testar o tipo de um objeto na rvore de herana, use polimorfismo para
evitar ter de escrever cdigo separado para tratar objetos de cada classe. Isto
maximiza a reutilizao de seu cdigo, e o torna mais fcil de manter no futuro.
Vamos agora ver como estes conceitos mostrados acima so aplicados em
java
5-24
Herdando estrutura e comportamento

Uma relao de herana faz com que a classe filha herde toda a estrutura
e comportamento dos pais.

A classe Produto define os atributos e mtodos que so relevantes para
todos os itens de inventrio. Entre os atributos e mtodos provveis:
Atributos tais como data de aquisio, custo de aquisio, e condio.
Mtodos tais como clculo de quantia a ser paga pelo item, mudana
de condies, e definio de preo.
Dependendo do que quiser fazer no programa, voc precisar definir um
tipo especfico de Produto. Voc pode usar herana para definir uma subclasse
de itens de inventrio para cada tipo distinto de item.
Voc poderia definir, por exemplo, as seguintes subclasses: CD, DVD e VHS.
Cada uma destas subclasses automaticamente herdaria todos os atributos
e mtodos de Produto e atributos e mtodos adicionais poderiam ser fornecidos
se necessrios.
A classe CD, por exemplo, poderia definir os seguintes atributos e mtodos
adicionais:
Atributos tais como ttulo, produtor, durao.
Mtodos tais como play, stop, etc.
Subclasses podem tambm sobrescrever mtodos da superclasse se
desejarem fornecer um comportamento mais especializado para o mtodo.

Figura 5-4: Herana entre Produto e CD.

5-25
Especificando herana em Java

Quando voc define uma subclasse, voc precisa somente fornecer
cdigo para as facilidades da subclasse que diferem das existentes na
superclasse. Efetivamente, a subclasse apenas estende a superclasse.
A sintaxe para especificar herana em Java faz uso da palavra reservada
extends.
Por exemplo:

Cdigo 5-25: Especificando herana em Java.

Se voc tem experincia com outras linguagens OO (orientada por
objetos) tais como C++, observe que Java permite somente herana simples.
Em outras palavras, uma classe pode especificar somente uma nica
superclasse da qual herda.
Lembre-se tambm que todas as classes em Java herdam
automaticamente de uma classe raiz conhecida como Object, que se situa
sempre no topo da rvore de herana.
Se uma classe no especifica explicitamente uma superclasse, como no
caso de Produto, ento esta classe forada a herdar diretamente de Object,
sendo sua definio (implcita) equivalente seguinte definio explcita:
Cdigo 5-26: Utilizando a clusula extends.
public class Produto extends Object {
// Definio da classe Produto
}

public class CD extends Produto {
// Mtodos e atributos adicionais para distingui-la
// dos outros tipos de itens de produto
}
public class Produto extends Object {
// Definio da classe Produto
}
5-26
Objetos de subclasses

A superclasse define as variveis que so relevantes para todos os tipos de
Produto, tais como nome e codigo. A subclasse CD herda estas variveis sem ter
de fazer qualquer esforo, e precisa somente especificar as variveis que lhe so
especficas, tais como durao.
Suponha as seguintes classes:
Figura 5-5: Herana entre as classes CD e Produto.

Se voc cria um objeto Produto, ele apenas contm as variveis definidas
para Produto:
Cdigo 5-27: Criando um novo Produto.

Entretanto, se voc cria um objeto CD, ele conter cinco variveis de
instncia: as trs herdadas de Produto mais as duas que ele prprio CD definiu.

Cdigo 5-28: Criando um novo CD

Variveis de instncia devem normalmente ser declaradas private, o que
significa que instncias de subclasses herdam os valores, mas no podem acess-
los diretamente.
Como visto anteriormente, voc deve definir, mtodos para acessar
variveis privadas. Voc pode definir mtodos na subclasse ou herd-los da
superclasse.
Produto produto = new Produto();
CD cd = new CD();
5-27
Chamando construtores da superclasse

A superclasse e a subclasse geralmente tero construtores que esperam
parmetros. Suponha, por exemplo, que Produto tenha um construtor que
espera como parmetros os valores iniciais de preco, nome e codigo.
Da mesma forma, a classe CD tem um construtor que espera parmetros
suficientes para inicializar seus atributos. As coisas aqui comeam a ficar
interessantes.Um objeto CD tem cinco atributos: preco, nome e codigo herdados
de Produto, e produtor e duracao definidos na prpria classe CD.
O construtor de CD ter, portanto, cinco argumentos:
Cdigo 5-29: Utilizando o contrutor de CD com parmetros.

Ao invs de inicializar preco, nome e codigo explicitamente, tudo o que o
construtor de CD deve fazer chamar o construtor de sua superclasse. Isto pode
ser feito usando a palavra reservada super. A chamada super(...) deve ser o
primeiro comando do construtor.
Cdigo 5-30: Invocando o construtor da superclasse a partir da referncia super.

Se voc no chamar explicitamente super(...) o compilador chamar
automaticamente o construtor sem parmetros. Se a superclasse no tiver um
construtor sem parmetros, o compilador acusar um erro.
public CD(float preco, String nome, int codigo, String produtor, int duracao)

public CD(float preco, String nome, int codigo, String produtor, int duracao) {
super( preco, nome, codigo );
setProdutor( produtor );
seDuracao( duracao );
}
public Produto(float preco, String nome, int codigo) {
setPreco( preco );
setNome( nome );
setCodigo( codigo );
}
public CD(float preco, String nome, int codigo, String produtor,
int duracao) {
super( preco, nome, codigo );
setProdutor( produtor );
seDuracao( duracao );
}
5-28
Cdigo 5-31: Referenciando o construtor da superclasse.
5-29
Overloading e Overriding de mtodos

Overloading e overriding so freqentes na programao orientada a
objetos. Overloading conhecido como sobrecarga enquanto overriding
conhecido como sobreescrita. Vejamos abaixo a definio destes dois conceitos:

Sobrecarga de mtodos quando voc define mltiplos mtodos com
mesmo nome e diferentes assinaturas. Mtodos sobrecarregados so
resolvidos em tempo de compilao (resolver um mtodo descobrir
qual verso do mtodo deve ser chamada com base nas informaes
dadas pelo programador), com base no nmero e tipo dos parmetros
fornecidos.

Sobrescrita de mtodos quando voc fornece um mtodo com
exatamente o mesmo nome e assinatura que este mtodo possui em
uma superclasse. Mtodos sobrescritos so resolvidos em tempo de
execuo. Esta tcnica conhecida como polimorfismo e ser discutida
mais adiante.
5-30
Redefinindo mtodos overriding

Quando uma classe herda operaes de outra classe, estas operaes
passam a fazer parte da estrutura da classe filha. Nem sempre desejamos manter
a mesma implementao para a operao nos filhos, desta forma podemos
redefinir tal operao.

Vejamos os cdigos de exemplo abaixo:

Cdigo 5-32: Especificando mtodos adicionais na
subclasse.

O exemplo acima mostra alguns dos mtodos declarados pela subclasse e
pela superclasse.
A superclasse define mtodos que so relevantes para todos os tipos de
Produto.
A subclasse CD herda estes mtodos da superclasse, e tem de adicionar
apenas os mtodos que lhe so especficos (relevantes para todos os objetos CD),
tais como recuperao do produtor do CD e durao.
Quando voc cria um objeto, voc pode chamar qualquer um dos seus
mtodos pblicos (public), bem como qualquer mtodo declarado pblico em
uma de suas superclasses.
Se voc, por exemplo, cria um objeto Produto, voc pode chamar os
mtodos pblicos definidos em Produto, bem como quaisquer mtodos pblicos
de sua superclasse Object:
Cdigo 5-33: Criando um Produto e acessando mtodos herdados.

public float getPreco();
public String getNome();

}
public int getDuracao();
public String getProdutor();
}
Produto produto = new Produto();
float preco = produto.getPreco(); // mtodo public de Produto
Class classe = produto.getClass(); // mtodo public de Object
5-31

Se voc cria um objeto CD, voc pode chamar mtodos pblicos definidos
em CD, Produto e Object.
Cdigo 5-34: Criando um CD e acessando mtodos herdados

Sobrescrevendo mtodos da superclasse

Uma subclasse herda todos os mtodos de sua superclasse. Uma subclasse
pode modificar o comportamento de um mtodo de sua superclasse
sobrescrevendo-o, como mostra o exemplo abaixo:
Cdigo 5-35: Sobreescrevendo o mtodo getPreco()

Para sobrescrever um mtodo de uma superclasse, a subclasse define o
mtodo exatamente com a mesma assinatura e tipo de retorno que o mtodo
possui quando declarado na superclasse.
O mtodo da subclasse efetivamente esconde o mtodo declarado na
superclasse. importante ter certeza de que o mtodo na subclasse mantm a
mesma semntica que o mtodo que est sendo sobrescrito.
Qual mtodo chamado? No exemplo acima, a classe Produto fornece
um mtodo getPreco() e a classe CD sobrescreve este mtodo com uma verso
mais especializada.
Se voc criar um objeto Produto e chamar getPreco(), o mtodo
chamado ser a verso definida em Produto.
CD cd = new CD();
int duracao = cd.getDuracao() // mtodo public de CD
float preco = cd.getPreco(); // mtodo public de Produto
Class classe = cd.getClass(); // mtodo public de Object
return preco;
}
}
float x = getCustoCD() + calculaImpostos();
return x;
}
}
5-32
Se voc criar um objeto CD e chamar getPreco(), o mtodo chamado
ser a verso especializada definida em CD.
5-33
Referncia super

A referncia super til quando a classe possui um ancestral. Uma
subclasse herda todos os mtodos e variveis de sua superclasse, bem como
define ela prpria. Mtodos da superclasse podem ser sobrescritos na subclasse,
bastando a subclasse declar-los novamente e redefinir o seu comportamento
(declarar novamente significa manter a assinatura do mtodo tal qual se
encontra na superclasse alterando apenas o corpo do mtodo).
A palavra reservada super permite que voc acesse mtodos da
superclasse sobrescritos pela subclasse.
Um dos usos mais comuns de super chamar os construtores da classe pai.
Quando a superclasse foi projetada, um construtor provavelmente foi declarado
para garantir a inicializao correta de qualquer novo objeto. Como a subclasse
herda todas as variveis da superclasse, tais variveis precisaro ser inicializadas
para objetos da subclasse tambm. A palavra reservada super permite que
voc use o cdigo do construtor definido na superclasse sem ter que duplicar o
cdigo em cada subclasse.
Adicione a referncia super no construtor da subclasse a fim de acessar o
construtor da superclasse:
Cdigo 5-36: Estrutura de chamada explcita do construtor da superclasse

A regra de sintaxe que a palavra reservada super deve ser, neste caso, a
primeira linha do construtor da subclasse. A palavra reservada super pode ser
usada tambm para acessar os mtodos da superclasse.
Exemplo de uso da referncia super:

class SubClasse extends SuperClasse {
...
public SubClasse(int param) {
super(param);
/* coloque aqui o cdigo especfico do construtor da subclasse */
}
}
public Produto( String nome ) {
super();
this.nome = nome;
}
}
5-34

public class Filme extends Produto {
private int ano;
public Filme( String nome, int ano ) {
super( nome );
this.ano = ano;
}
Cdigo 5-37: Referncia super invocando o construtor da superclasse

No exemplo acima, h rotinas de inicializao que devem ocorrer para
todos os objetos Produto. Estas rotinas so colocadas nos construtores de
Produto. Tais rotinas devem sempre ser usadas, no interessando o tipo do
Produto sendo construdo, seja ele um CD, um Filme ou um Livro (subclasses de
Produto).
H tambm construtores em cada uma das subclasses encarregados de
rotinas de inicializao especficas destas subclasses.
O construtor de Filme reutiliza o construtor de Produto ao referenci-lo com
a palavra reservada super. Este comando o primeiro comando do construtor
de Filme e pode ser seguido por quaisquer comandos que se fizerem necessrios
para uma adequada inicializao de objetos Filme.
5-35
Invocando mtodos da superclasse

Como mencionado anteriormente, quando uma subclasse sobrescreve um
mtodo de sua superclasse, ela esconde o mtodo da superclasse.

Cdigo 5-38: Sobreescrevendo e invocando o mtodo getPreco()

Se, por exemplo, o programa criar um objeto CD e chamar o mtodo
getPreco(), ele sempre estar executando a verso de getpreco() definida
em CD.
Cdigo 5-39: Executando o mtodo getPreco()

Dentro do mtodo getPreco() definido na classe CD pode-se invocar o
mtodo escondido de mesmo nome e assinatura, definido na superclasse
Produto, atravs da palavra reservada super.
A palavra reservada super similar a this, salvo que atua como
referncia para o objeto corrente como uma instncia da superclasse.
Chamar um mtodo escondido da superclasse usando super evitamos
duplicar o cdigo contido no mtodo escondido. Ao reduzir o volume de cdigo
duplicado, facilita-se a tarefa de manuteno do software.

return preco;
}

}

return super.getPreco() + calculaImpostos();
}

}
CD cd = new CD(); // Cria objeto CD
float v = cd.getPreco(); // Executa verso getPreco() de CD
5-36
Visibilidade protected

A visibilidade protected no foi demonstrada anteriormente pois o uso da
mesma envolve o processo de herana. Agora que j vimos este recurso estamos
aptos a estudar esta visibilidade.

Vejamos o cdigo abaixo:

public class Funcionario {
protected float salario;
...
}
Cdigo 5-40: Visiblidade protected aplicada a atributos

O cdigo acima define uma classe Funcionrio, a qual possui na sua
estrutura um nome e um salrio. Perceba que o nome privado enquanto o
salrio protected. O atributo nome poder ser acessado somente por
operaes definidas dentro da classe, porm o atributo salrio poder ser
acessado diretamente por outras classes que forem filhas de Funcionario. Isto
poder ser feito mesmo com a classe filha em outro pacote diferente do pacote
onde estiver o Funcionrio. Veja exemplo abaixo:

package com.targettrust.rh;
public class Vendedor extends Funcionario {
private float comisssao;
...
public void calcularSalario() {
...
float total = salario + comissao;
}
}
Cdigo 5-41: Acessando um atributo protected

Veja que o acesso ao atributo acessado na classe filha como se fosse
declarado na mesma classe. J o atributo privado no pode ser acessado.

Esta visibilidade tambm pode ser aplicada a operaes da classe, porm
o uso dela nestes casos no comum.
5-37
Varargs

Varargs um recurso popular em algumas linguagens como C, C++ e
linguagens derivadas. Este recurso permite passar um nmero varivel de
parmetros a um mtodo sem a necessidade de encapsul-los manualmente
em um array. Junto com varargs ser utilizado o recurso de autoboxing. Veja o
exemplo abaixo utilizando este recurso:

public class Varargs {


foo("Java", "Oracle", "Linux");
foo("Porto Alegre", "Ijui", "So Leopoldo", "Cruz Alta");

}

public static void foo(String... args) {
for (int i=0; i<args.length; i++) {
System.out.println(args[i]);
}
}
}
Cdigo 5-42: Usando varargs para receber mais de um parmetro

A declarao acima String... args equivale a String[] args, mas se
utilizado este recurso deve ser o ltimo parmetro do mtodo. Quando este
mtodo for chamado na chamada podem ser passados vrios parmetros
separados por vrgula desde que os tipos sejam sempre Strings. O enpasulamento
dos parmetros String em um vetor ser feito de forma automtica pelo
compilador. Se o tipo de parmetro um Object, ento os parmetros se forem
tipos primitivos sero transformados em objetos com o recurso de autoboxing.
Para evitar este overhead da transformao de tipos primitivos nos objetos
correspondentes utilizando o recurso de autoboxing, voc pode utilizar, por
exemplo int... args.

Se voc tentar passar parmetros com tipo incorretos, portanto no
esperados pelo mtodo, o compilador ir perceber e avisar. Veja exemplo
abaixo:

public class Varargs {

foo("Java", "Oracle", "Linux", 88); // Erro nesta linha!
}

public static void foo(String... args) {
for (int i=0; i<args.length; i++) {
System.out.println(args[i]);
}
}
}
5-38
Cdigo 5-43: Erro pois esta pasando inteiro e no String

5-39
Polimorfismo
Usando a tcnica de polimorfismo visualize a seguinte hierarquia de classes.
Figura 5-6: Hierarquia de classes representando herana e polimorfismo do mtodo getPreco().

Ao projetar a aplicao de venda, no era sabido todo o tipo de produtos
que seriam vendidos em longo prazo. Em programao no orientada por
objetos, isto criaria um problema, que seria resolvido alterando o cdigo sempre
que um novo tipo de item fosse adicionado. Em Java, ns podemos usar
polimorfismo para resolver este problema. Eis como:
O mtodo getPreco() da classe Produto sobrescrito pelas classes CD e
DVD, cada qual fornecendo uma verso especializada do mtodo.
A classe CarrinhoCompras possui um mtodo addItem(Produto
produto) que chama o mtodo getPreco() atravs da referncia recebida a
um objeto Produto.
Em tempo de execuo Java interroga o parmetro de addItem() para
descobrir o tipo real do objeto e se o objeto possui alguma funo sobrescrita. Se
sim, Java usa o mtodo sobrescrito pela subclasse (CD ou DVD), ao invs de usar o
mtodo definido pela superclasse (Produto).
5-40
Por exemplo, se a varivel cd do tipo CD e dvd do tipo DVD forem
adicionadas:
Cdigo 5-44: Adicionando CD e DVD ao mtodo que espera Produtos.

O mais importante que as classes CarrinhoCompras e Produto no
precisam ser modificadas quando novos tipos de itens de inventrios forem sendo
adicionados ao negcio.

addItem(cd); // O mtodo addItem chamar a verso de getPreco
// definida em CD e no em Produto

addItem(dvd); // O mtodo addItem chamar a verso de getPreco
// definida em DVD e no em Produto
5-41
Modificador final

Por default todas as variveis e mtodos podem ser sobrescritos. Especificar
uma varivel como final evita que seu valor seja alterado. Isto til para
garantir que um determinado valor seja consistente entre todos os usurios de
uma classe.
Voc pode tambm declarar uma classe como final. Uma classe final
no pode ser superclasse de nenhuma outra classe. Em outras palavras, no se
pode herdar de uma classe final.
Ao declarar uma classe como final voc est tomando uma importante
deciso de projeto, pois est dizendo que tal classe completa o suficiente para
atender todas as expectativas presentes e futuras de seus usurios, e que,
portanto, nunca ser necessrio estend-la para fornecer alguma funcionalidade
adicional.
Um mtodo final no pode ser sobrescrito por nenhuma subclasse. Em outras
palavras, se o programador herda de uma classe, no ser permitido que ele
fornea uma verso alternativa de um mtodo declarado como final na
superclasse.
Esta uma tcnica til para evitar que programadores inadvertidamente ou
maliciosamente redefinam mtodos essenciais que devem funcionar de uma
maneira esperada.
Resumindo:
Uma varivel final uma constante
Uma varivel final no pode ser modificada
Uma varivel final deve ser inicializada
Uma varivel final geralmente pblica (public), permitindo o acesso
externo

Cdigo 5-45: Variveis final

Mtodos e classes so declarados final por suas razes principais:
segurana e otimizao.
public final class Color {
public final static Color BLACK = new Color(0,0,0);
// ...
}
5-42
Se um mtodo executa alguma operao vital, tal como validao de
identidade ou verificao de autorizao, ele deve ser declarado final, a fim
de evitar que seja sobrescrito por um mtodo mal-intencionado que esteja
procurando se esquivar das verificaes de segurana.
Muitos dos mtodos definidos nas classes do pacote java.net so
declaradas final.
Se voc declara uma classe como final, ela no poder nunca mais ser
estendida por nenhuma outra classe. Esta uma deciso de projeto importante,
pois afirma que a classe atende a todas as necessidades presentes e futuras de
seus usurios. Esta implicao clara: voc no precisa.
Cdigo 5-46: Definindo uma Classe e um mtodo final.

public final class Criptografia{
private String senha;

public final void getSenha(String senha) {
getCriptografia(senha, 128) // Chama Criptografia de 128 bits
}
}
5-43
Enums

Enums uma forma mais fcil e segura para representar um conjunto de
valores que so conhecidos em tempo de compilao e que no mudam com o
passar do tempo. Estes valores so muitas vezes conhecidos como constantes de
classe. A partir da nova verso do java, a verso 1.5, foi includo este novo tipo
que trs algumas vantagens listadas abaixo. Veja inicialmente o padro que se
costuma utilizar para representar constantes e guardar estaes do ano:

public static final int ESTACAO_INVERNO = 0;
public static final int ESTACAO_PRIMAVERA = 1;
public static final int ESTACAO_VERAO = 2;
public static final int ESTACAO_OUTONO = 3;
Cdigo 5-47: Constantes de classe

Este padro tem os seguintes problemas:
No seguro Uma vez que uma estao um int, voc pode passar
qualqeur outro valor diferente dos especificados nas constantes acima, ou
mesmo somar estas constantes, o que no faria sentido.
Prefixar constantes Voc precisa prefixar as constantes com strings para
evitar colises de nomes semelhantes. Este caso foram prefixadas com a
palavra ESTACAO.
Os valores impressos no so informativos Por serem constantes do tipo
int estas constantes quando impressas no tem significado claro. Ao
imprimi-la teremos um int e no um nome.

Com enums o mesmo cdigo acima ficaria da seguinte maneira:
enum Estacao { INVERNO, PRIMAVERA, VERAO, OUTONO }
Cdigo 5-48: Definindo uma enumeration

Tipos enum so cosiderados como objetos, acima temos a definio de um tipo
Estacao. Uma enumeration herda da classe java.lang.Enum possuindo desta
forma vrios mtodos para se poder manipular a estrutura. Mtodos de Object
tambm esto presentes em uma Enum. Comparable e Serializable so interfaces
implementadas pelas enumerations, permitindo que as mesmas portanto possam
ser comparadas e serializadas.
5-44
Veja abaixo uma verso completa de um cdigo que utiliza enumerations:
enum Estacao { INVERNO, PRIMAVERA, VERAO, OUTONO }

foo( Estacao.INVERNO );
}

public static void foo(Estacao x) {
out.println( x.ordinal() +" "+ x.name() ); // 0 INVERNO
}
Cdigo 5-49: Usando uma enumeration

Neste cdigo acima observe que definimos um tipo Estacao e o mesmo
utilizado mais abaixo para passar valores ao mtodo foo. Quando desejarmos
imprimir o nome da estao passada como parmetro atravs de enum
podemos utilizar o mtodo name(), a ordem dos valores adicionada de forma
automtica e comea em 0.

possvel pegar de uma enumeration todos os seus valores atravs de um
mtodo esttico values(). Este mtodo facilita bastante a impresso dos valores
quando desejarmos. Veja o cdigo abaixo:

for(Estacao s : Estacao.values() ) {
out.println( s.name() + " " +s.ordinal() );
}
Cdigo 5-50: Percorrendo uma enumeration

5-45
Espao para anotaes
5-46
Exerccios

1. Neste exerccio voc deve criar uma classe para representar um Curso.
Esta classe ter mtodos sobrecarregados (overloading) e redefinidos
(overriding), bem como ser uma classe filha da classe Produto e ter
construtores para que seja possvel criar objetos da mesma j passando
informaes na hora da criao.

Passo 1: Crie uma classe pblica Curso no pacode com.targettrust.venda e
faa com que esta classe extenda (herde) a classe Produto. Na classe Curso
defina os seguines atributos e constante privados:

private int cargaHoraria;
private char turno;
private final float VALOR_HORA = 100f;

Passo 2: Defina na classe Curso um mtodo para calcular o preo do curso
( public float getPreco() {...} ). Observe que este tem o mesmo nome do
mtodo que est sendo herdado da classe Produto. Na assinatura deste faa
com que o mesmo possa receber um valor hora ( public float getPreco(float
valorHora) {...} ) a ser levado em considerao no clculo do preo do curso.
O preo do curso deve ser calculado multiplicando-se a carga horria pelo valor
hora passado como parmetro no mtodo.

Passo 3: Crie outro mtodo na classe Curso que seja capaz de redefinir o
comportamento (overriding) do mtodo public float getPreco() herdado da
classe Produto. Esta operao deve retornar o preo levando em considerao
o valor hora e a carga horria do curso, para isto utilize o valor hora da
constante.

Passo 4: Na classe Produto, bem como na classe Curso, defina um
construtor que permita criar um objeto destas classes passando valores para
todos os seus atributos. Isto ir fazer com que o construtor default no seja
adicionado pelo compilador java. Desta forma adicione tambm ele a estas
classes.

Passo 5: No construtor da classe Curso faa com que o mesmo repasse os
parmetros que este receber e que devem ser atribudos para os atributos da
classe Produto para o construtor da classe Produto. Use para isto a referncia
super(...).

Passo 6: Agora voc ir modificar as classes que criou at o momento para
que as operaes sets da classe Produto, ItemPedido e Curso possam receber
parmetros com o mesmo nome dos atributos. Use a referncia this nestas classes
para referenciar o atributo na hora da atribuio e defina o nome do parmetro
5-47
com o mesmo nome do atributo. Gere novamente a documentao para estas
classes e verifique as alteraes.

Passo 7: Na classe Curso defina o mtodo destrutor finalize() e dentro deste
faa a impresso de uma string sinalizando que o mesmo est sendo executado.

public void finalize() { ... }

Passo 8: Crie agora uma classe pblica TestaCurso no pacote
com.targettrust.venda, declare nesta classe o mtodo main e dentro deste
mtodo crie um objeto da classe Curso. Atribua informaes para este objeto
atravs do mtodo construtor. Logo em seguida mostre os dados do objeto
atravs dos seus mtodos de leitura, os gets.

Passo 9: Atribua null para a referncia criada que representa o curso e logo
em seguida chame o mtodo System.gc() para ativar o coletor de lixo e
constatar a execuo do mtodo destrutor.

Passo 10: Na classe Curso crie um bloco esttico de cdigo para sinalizar
quando a classe est sendo carregada pela JVM. Neste bloco esttico imprima
uma mensagem.
Java Fundamentals

6-1
6
6
.
.
C
C
o
o
l
l
e
e
e
e
s
s
,
,
A
A
r
r
r
r
a
a
y
y
s
s
,
,
S
S
t
t
r
r
i
i
n
n
g
g
s
s
,
,
e
e

W
W
r
r
a
a
p
p
p
p
e
e
r
r
C
C
l
l
a
a
s
s
s
s
e
e
s
s
Colees, Arrays, String e Wrapper Classes
6-2
Objetivos

Estudar a API Collection
Utilizar classes StringBuffer e StringBuilder
Converter e encapsular dados com Wrapper Classes
Utilizar arrays
Compreender o mecanismo de autoboxing
Utilizar generics
6-3
Strings
Assim como na maioria das linguagens de programao, strings so usadas
intensivamente em Java. Desta forma, a API Java fornece uma classe String
para ajud-lo a manipular seqncias de caracteres.
Literais de string so transformados pelo compilador Java em objetos
String. Eles podem ento ser usados diretamente, passados como argumentos
para mtodos ou atribudos a variveis do tipo String.

Cdigo 6-1: Manipulao de Strings.

A classe String representa uma string imutvel.
Isto significa que, uma vez criado um objeto String, voc no poder mais
alter-lo. Se voc quiser modificar o contedo de uma string, voc dever usar a
classe StringBuffer. Esta classe ser estudada logo adiante.
String str = "Matrix";
6-4
Criando Strings

A maneira mais fcil de se criar uma string a partir de uma constante
colocada entre aspas duplas, como mostra o exemplo abaixo:
Cdigo 6-2: Atribuio de valor String.

Voc pode usar o operador mais (+) para concatenar dois objetos String.
Isto explicado em maiores detalhes adiante. Veja um exemplo do uso do
operador mais (+) quando aplicado a objetos String:
Cdigo 6-3: Concatenao de Strings entre variveis e String fixa.

A classe String fornece vrios construtores. Eis aqui alguns dos construtores
mais teis:
String() cria uma string vazia, com o valor ""
String(String str) cria uma cpia do objeto String referenciado por
str
String(char[] arr) cria uma string a partir dos caracteres presentes no
vetor arr

Cdigo 6-4: Criao de String utilizando o construtor da classe String.

Voc encontrar uma lista de construtores na documentao do JDK para
a classe String. A classe String parte do pacote java.lang.
java.lang um pacote automaticamente importado por todas as classes
Java. No preciso, portanto, declarar um comando explcito de import para
poder usar a classe String em seu cdigo.
String produto = "Caneta";
String nomeEmp = primeiroNome + " " + ultimoNome;
// uso de construtores
String nomeEmp = new String( "Maria Isabel" );
6-5
Concatenando Strings

Java usa o operador + para concatenao de strings. O mtodo concat()
de String outra forma de se concatenar strings.
O seguinte cdigo produz strings equivalentes:

Cdigo 6-5: Exemplos de concatenao de Strings.

O exemplo abaixo mostra um tipo primitivo (no caso um int) sendo
concatenado com uma String.
O tipo primitivo convertido implicitamente para String:
Cdigo 6-6: Converso de tipos primitivos para String.

Literais de string no podem se estender por mais de uma linha, mas voc
pode concaten-los e produzir o mesmo efeito:

Cdigo 6-7: Concatenao de Strings utilizando caracteres de escape.
// Concatenao
String nome = "Carlos Silva";
nome = "Carlos " + "Silva";
nome = "Carlos ".concat("Silva");
int codigo = getCodigo();
System.out.println("Cdigo: " + getCodigo() + ".");
String soneto = "De tudo ao meu amor serei atento\n" +
"Antes e com tal zelo, e sempre, e tanto\n" +
"Que mesmo em face de maior encanto\n" +
"Dele se encante mais meu pensamento.";
6-6
Executando operaes em objetos String

O mtodo length() retorna o nmero de caracteres de uma string:
Cdigo 6-8: Tamanho de uma String.

O mtodo charAt() retorna o caractere especificado pelo ndice passado
como argumento para o mtodo (os ndices sempre comeam em 0).
Cdigo 6-9: Recebendo um caracter a partir de uma String.

O mtodo substring() retorna uma substring especfica (dois argumentos
so fornecidos a este mtodo: o ndice do primeiro caractere da substring e o
ndice do caractere aps o ltimo caractere da substring desejada).
Cdigo 6-10: Produzindo substrings.

O mtodo toUpperCase() retorna uma nova string contendo uma verso
da anterior com todos os caracteres convertidos para a forma maiscula. O
mtodo toLowerCase() retorna uma nova string contendo uma verso da
anterior com todos os caracteres convertidos para a forma minscula.
Cdigo 6-11: Transformando uma String para maisculo e minsculo.

O mtodo trim() retorna uma nova string contendo uma cpia da string
original com espaos em branco removidos tanto no incio quanto no final.
Cdigo 6-12: Truncando espaos de uma String.
String s = "Maria";
int tam = s.length(); // tam = 5
// 01234
String s = "Maria";
char c = s.charAt(2); // c = 'r'
// 01234
String s = "Maria";
String sub = s.substring(2,4); // sub = "ri"
String sub = s.substring(2); // sub = "ria"
String s = "Maria";
String M = s.toUpperCase(); // M = "MARIA"
String m = s.toLowerCase(); // m = "maria"
String s = " Cadastro de Clientes ";
String t = s.trim(); // t = "Cadastro de Clientes"
6-7
O mtodo indexOf() retorna o ndice de uma determinada substring. O
mtodo lastIndexOf() retorna o ndice da ltima ocorrncia de uma string
determinada.

Cdigo 6-13: Busca ndices de ocorrncias de substring dentro de uma String.

H vrias verses para cada um destes mtodos. D uma olhada na
documentao da classe String para maiores detalhes sobre cada uma delas.
// 0 1 2
// 012345678901234567890
String s = "fbrica de brinquedos";
int iof = s.indexOf("bri"); // iof = 2
int liof = s.lastIndexOf("bri"); // liof = 11
6-8
Comparando duas Strings

O mtodo equals() retorna true se as strings especificadas contm o
mesmo texto. Caso a string passada como parmetro seja null, equals()
retorna false.
Importante: o mtodo equals() diferencia maisculas de minsculas!

Cdigo 6-14: Comparao de Strings case sensitive.

O mtodo equalsIgnoreCase() similar a equals(), exceto que ignora
diferena entre maisculas e minsculas.
Cdigo 6-15: Comparao de Strings case insensitive.

No use o operador == para comparar objetos String! O operador == retorna
true dependendo da JVM quando ambas as variveis referenciarem o mesmo
objeto.
String senha = getSenha();
if(senha.equals("brasil2010"))
String cat = getCategoria();
if(cat.equalsIgnoreCase("Drama"))
6-9
Obtendo strings a partir de objetos

Se sua classe tem um mtodo toString(), voc pode incluir o seu objeto
em expresses de concatenao de strings. E voc pode imprimir seu objeto
como se este fosse uma string. O mtodo toString() invocado
automaticamente sempre que voc usa um objeto em uma expresso de
concatenao de strings ou passa este objeto para System.out.println().
No exemplo abaixo, a classe Produto fornece uma implementao de
toString() que imprime o nome e o cdigo do produto.
Cdigo 6-16: Produzindo String a partir de uma referncia.

O que acontece quando a classe no fornece o mtodo toString()? Se a
classe no fornece o mtodo toString(), ela herda um da classe Object.
A string produzida por Object.toString() no muito amigvel. Consiste
do nome da classe da qual o objeto uma instncia e um nmero hexadecimal
representando uma entrada hash.
public String toString() {
return getCodigo() + " - " + getNome();
}
}
...
Produto p1 = new Produto( 1, "DVD" );
System.out.println( "Produto: " + p1 ); // "1 DVD"
6-10
Convertendo tipos primitivos em strings
A classe String fornece um mtodo esttico valueOf() que retorna uma
string representando o tipo primitivo. H uma verso de valueOf() para cada
tipo primitivo.
O exemplo abaixo usa duas verses:

Cdigo 6-17: Convertendo tipos primitivos em String.

Quando um tipo primitivo concatenado com uma string, ele
automaticamente convertido para String atravs de String.valueOf().
Quando um tipo primitivo passado para System.out.println(), a verso
apropriada de System.out.println() chamada. H uma verso para cada
tipo primitivo.

Na verso do J2SDK 1.5 permitido a seguinte codificao:
Cdigo 6-18: Convertendo tipos primitivos em String utilizando printf no J2DSK 1.5.

As expresses %s e %d formatam as sadas de James Gosling e 53.
String sete = String.valueOf(7); // chama valueOf(int) "7"
String umPontoZero = String.valueOf(1.0f); // chama valueOf(float) "1.0"

System.out.printf("Nome: ");
String user = "James Gosling";
int total = 53;
System.out.printf("%s possui %d anos.\n", user, total);
6-11
Wrapper Classes
Para cada tipo primitivo, Java fornece uma classe invlucro (wrapper class)
correspondente. Estas classes permitem que um tipo primitivo seja manipulado
como se fosse um objeto.
Cada classe invlucro fornece um mtodo esttico para converter uma
string para o tipo primitivo correspondente.
Outros usos para Wrapper Classes
Wrapper Classes so teis quando voc precisa tratar um tipo primitivo
como um objeto. Java, por exemplo, define uma classe Vector, que
implementa um vetor dinmico de objetos (o tamanho do vetor pode
ser alterado dinamicamente). Voc no pode armazenar tipos primitivos
em Vector. Neste caso, voc precisar usar uma classe invlucro. Para
armazenar, por exemplo, variveis do tipo int em um Vector, voc
precisar criar um Integer para cada int: a classe Integer possui um
construtor que faz isto.
Wrapper Classes fornecem um local adequado para mtodos de
converso relacionados ao tipo. A classe Integer, por exemplo, possui
vrios mtodos, incluindo a Integer.parseInt() para converter um
tipo int em outro tipo.
Wrapper Classes fornecem um local adequado para variveis
relacionadas ao tipo. Em Integer, por exemplo, Integer.MAX_VALUE
representa o maior valor que um inteiro pode alcanar.

Tabela 6-1: Tipos primitivos e Wrapper Classes de apoio.
Tipo
Primitivo
Classe invlucro
correspondente
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
double Double
float Float
6-12
Converses com Wrapper Classes

O exemplo abaixo mostra como usar os mtodos de converso para
processar os campos de um formulrio. Todos os campos textos guardam valores
do tipo String. Temos, ento, que ler os valores dos campos em variveis do tipo
String. No exemplo, esperado um valor inteiro no primeiro campo e um valor
real no segundo.
Mtodos de converso so necessrios para converter um valor String
para int e float respectivamente.
Observe que os mtodos de converso so chamados sem a necessidade
de se instanciar um objeto Integer ou Float. As classes invlucros so um local
adequado para mtodos de converso e no precisam ser instanciadas quando
tais mtodos so usados.

Cdigo 6-19: Convertendo String para o tipo primitivo correspondente de acordo com a Wrraper
Class.

O que acontece se o usurio entra com um valor no inteiro no primeiro
campo?
Caso isto acontea, parseInt() ir falhar e levantar uma exceo. Para
tratar esta situao, seria necessrio colocar cdigo adicional para capturar e
tratar a exceo levantada, tanto por parseInt(), quanto por parseFloat().
Excees sero estudadas mais adiante. O cdigo acima poderia ser feito da
seguinte forma:
Cdigo 6-20: Convertendo String para o tipo primitivo correspondente de acordo com a Wrraper
Class.

String qtdVal = qtdCampo.getText();
String prcVal = prcCampo.getText();
int qtd = Integer.parseInt(qtdVal);
float prc = Float.parseFloat(prcVal);
int qtd = Integer.parseInt(qtdCampo.getText());
float prc = Float.parseFloat(prcCampo.getText());
// Suprimimos a declarao de variveis
Quantidad
Preo:
17
425.00
qtdCamp
prcCampo
6-13
StringBuffer e StringBuilder

StringBuffer e StringBuilder representam strings que podem ser
modificadas e estendidas em tempo de execuo. A primeira deve ser utilizada
quando mais de uma thread estiver utilizando o objeto j a segunda quando
somente uma thread estiver o utilizando pois o acesso a a mesma mais rpida.
Estas estruturas permitem voc adicionar dados a um objeto sem que o mesmo
precise ser recriado como o caso da String. Estas estruturas so estruturas
mutveis ao contrrio da String que imutvel.
O seguinte exemplo cria trs novos objetos String e copia todos os
caracteres cada vez que um novo objeto String criado. Isto gera um
overhead grande e deixa muitos objetos na memria para que o garbage
collector os recolha.

Cdigo 6-21: Concatenando Strings com o operador +.

mais eficiente usar um objeto StringBuffer e seu mtodo append():
Cdigo 6-22: Concatenando Strings utilizando um StringBuffer

StringBuffer tambm fornece um comportamento semelhante a
StringBuilder porm esta uma estrutura que possui os seus mtodos
sincronizados, o que deixa o acesso aos mesmos mais lento quando temos
somente uma thread acessando o objeto.
Voc deve procurar utilizar StringBuilder em vez de StringBuffer. Veja abaixo
um exemplo de StringBuilder e observe que a forma de uso dos mesmos igual.

StringBuilder sb = new StringBuilder();

sb.append("Java J2EE\n");
sb.append("Oracle\n");
sb.append("PostgreSQL\n");

System.out.println(sb);
Cdigo 6-23: Utilizando StringBuilder
String texto = "O texto comea com uma linha\n";
texto = texto + "E ganha outra linha\n";
texto = texto + "E mais uma...\n";
StringBuffer texto = new StringBuffer( "O texto comea com uma linha\n" );
texto.append( "E ganha outra linha\n" );
texto.append( "E mais uma...\n" );
6-14
Arrays
Um vetor uma coleo de variveis do mesmo tipo. Cada elemento
pode armazenar um nico item. Os itens de um vetor podem ser de tipos
primitivos ou referncias para objetos.
O comprimento de um vetor fixo, quando criado.
Vetores so teis quando voc deseja um grupo de objetos que possam ser
manipulados como um todo. Caso voc, por exemplo, escreva um programa
para permitir a pesquisa por um filme, voc provavelmente armazenar a lista de
categorias em um vetor.

Figura 6-2: Estrutura de um vetor de Strings.

6-15
Arrays de tipos primitivos
1. Declarao: Declare uma varivel de referncia para o vetor
2. Criao: Crie um vetor de objetos do tipo e tamanho desejados, e
armazene a referncia para este vetor na varivel de referncia (do
passo 1)
3. Inicializao: Atribua os valores desejados para os elementos do vetor. Isto
opcional para um vetor de tipos primitivos porque os elementos
recebem valores default quando o objeto vetor criado.

De maneira esquemtica, temos:
1. Declare a varivel de referncia que ir receber a referncia para o
objeto vetor
Figura 6-3: Referncia inicial do vetor.

2. Cria o vetor (alocao de memria e inicializao default dos elementos
do vetor)
Figura 6-4: Referncia com vetor padro int.

3. Atribuio de valores iniciais aos elementos do vetor
Figura 6-5: Referncia com vetor padro int inicializado.
6-16
Declarando arrays de tipos primitivos
H duas maneiras de se declarar um vetor: (tanto faz!!!)

Tabela 6-2: Declarao de vetores.

A maioria dos programadores Java usa o primeiro estilo porque ele separa o
tipo da varivel (no exemplo acima int) do nome da varivel, tornando o
cdigo mais legvel.
Quando voc declara uma varivel de referncia para vetor, ela
inicialmente recebe o valor null, at que o vetor seja efetivamente criado
usando new.
Figura 6-6: Declarao do vetor nums.
Sintaxe Exemplo
tipo[] nome; int[] nums;
tipo nome[] int nums[];
6-17
Criando arrays
Vetores devem ser criados usando o operador new. O tamanho do vetor
deve ser especificado entre colchetes.O tamanho deve ser um inteiro, mas no
precisa ser necessariamente uma constante. Pode ser uma expresso avalivel
somente em tempo de execuo. Uma vez que um vetor criado, o seu
tamanho permanece o mesmo por toda a existncia do vetor.

Figura 6-7: Referncia com vetor padro int.

Todos os elementos de um novo vetor de tipos primitivos recebem
automaticamente o valor default para o tipo:
Elementos char recebem '\u0000';
Elementos byte, short, int e long recebem 0;
Elementos float e double recebem 0.0;
Elementos boolean recebem false.
Cdigo 6-24: Contrues vlidas de vetores.

Cdigo 6-25: Contrues invlidas de vetores.
// CONSTRUES VLIDAS

// exemplo 1: tamanho uma constante
final int TAM = 4;
int[] nums = new int[TAM];

// exemplo 2: tamanho conhecido apenas em tempo de execuo
int[] notasExame;
int n = getTotalAlunos();
notasExame = new int[n];
// CONSTRUES INVLIDAS

// exemplo 1: o tamanho no faz parte da declarao do vetor
int nums[4];

// exemplo 2: n no foi devidamente inicializada
int n;
int[] nums = new int[n];
6-18
Inicializando arrays
Primeiro Mtodo: Atribua um valor para cada elemento
Para se referir a um elemento do vetor use um ndice entre colchetes como
mostrado no exemplo abaixo.
Os elementos de um vetor so indexados de 0 a n-1, onde n o nmero de
elementos do vetor. Em outras palavras, o ndice do primeiro elemento de um
vetor sempre 0 e no 1.

Figura 6-8: Atribuio de valor int para o vetor
Segundo Mtodo: Inicializadores de vetor
Como mostrado no exemplo abaixo, h uma construo simplificada para a
criao e inicializao de vetores de tipos primitivos. Aqui no h necessidade
de usar o operador new e o comprimento do vetor automaticamente
detectado.
Observe o uso de chaves e lembre-se de colocar o ponto e vrgula no final.
Figura 6-9: Declarao, criao e inicializao de vetor a partir de lista de valores int.

Inicializadores de vetor so muito teis para criar tabelas de pesquisa, como
mostrado no seguinte exemplo:
Cdigo 6-26: Declarao, criao e inicializao de vetor a partir de lista de valores String.

int [] diasMes = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
6-19
Este mtodo til quando o valor de cada elemento conhecido quando
o vetor criado.
6-20
Arrays de objetos
Os passos para criar um vetor de referncias so os mesmos que para criar
um vetor de tipos primitivos, com uma nica exceo: voc deve sempre
inicializar os elementos do vetor porque isto no feito automaticamente.

1. Declarao: A sintaxe a mesma para vetores de tipos primitivos. Por
exemplo:
Cdigo 6-27: Declarao de vetor String.

2. Criao: A sintaxe a mesma para vetores de tipos primitivos. Por
exemplo:
Cdigo 6-28: Criao do vetor String com tamanho 3

A linha acima cria um objeto vetor do tipo String e de tamanho 3. Todos os
elementos, no incio, recebem o valor null.
3. Inicializao: Inicialize os elementos do vetor para o valor que desejar. Isto
ser visto com mais detalhes logo adiante.

String [] nomes;

nomes = new String [3];
6-21
Declarando arrays de objetos
De maneira esquemtica, temos:
1. Declare a varivel de referncia que ir receber a referncia para o
objeto vetor
Figura 6-9: Referncia de vetor null.

2. Cria o vetor (alocao de memria e inicializao default dos elementos
do vetor)
Figura 6-10: Criao do vetor de instncias com tamanho 4 e
valores null.

3. Atribuio de valores iniciais aos elementos do vetor
Figura 6-11: Inicializao do vetor com Strings.
6-22
Inicializando arrays de objetos
Assim como para vetores de tipos primitivos, h duas maneiras de se
inicializar um vetor de referncias para objetos.
Voc pode inicializ-lo, atribuindo um valor para cada elemento do vetor,
ou declarando um inicializador ao cri-lo.

Cdigo 6-29: Cdigo para inicializao de vetor.

Cdigo 6-30: Criando vetor de String a partir de uma lista de Strings.

A Propriedade length
Cada vetor tem um atributo length que contm o nmero de elementos do
vetor. Ao usar length, voc evita ter de armazenar o tamanho do vetor em outra
parte de seu cdigo.
A classe System fornece um mtodo til para copiar todo ou parte de um
vetor para outro vetor. Para maiores informaes, consulte System.arrayCopy()
na documentao do J2SDK.
// Inicializa elemento por elemento
// Cria um vetor de 4 Strings vazias
String[] array = new String[4];
for(int i=0; i<array.length; i++) {
arr[i] = new String();
}
// Inicializadores
String[] produtos = {"CD", "DVD", "VHS", "MP3"}
6-23
Utilizando arrays de objetos
Um vetor se comporta como objetos. Sendo assim, quando um vetor
passado para um mtodo, na verdade, uma referncia para este vetor
passada. Portanto, se o mtodo altera o contedo do vetor, estas mudanas
alteraro o vetor original (e no uma cpia).
Qualquer elemento de um vetor pode receber um objeto do tipo correto, e
tambm ser atribudo a uma varivel de tipo compatvel. Cada elemento de um
vetor pode ser tratado como um objeto individual.
Um elemento de vetor pode ser passado para um mtodo, e neste caso, por
ser um objeto, a referncia para o objeto que ser passada.
Cdigo 6-31: Vetor de referncia para objetos String.
String[] produtos = new String[4];
// ...
String produto = produtos[0];
produtos[1] = "Caneta";

System.out.println("Length: " + produtos[0].length());
6-24
Arrays e Excees
Excees so levantadas dependendo de como vetores so manipulados.
Caso voc tente acessar uma posio invlida de um vetor, o programa ser
interrompido pela exceo ArrayIndexOutOfBoundsException.
Caso tente acessar um elemento de um vetor que no tenha sido
inicializado, a exceo NullPointerException ser levantada.

Cdigo 6-32: Excees comuns a partir de vetores.
// Exceo ArrayIndexOutOfBoundsException
String[] lista = new String[4];
System.out.println(lista[5]);

// Exceo NullPointerException
Produto[] listaProdutos = new Produto[3];
String nomeProduto = listaProdutos[0].getNome();
6-25
Arrays multidimensionais
Java suporta vetores multidimensionais, isto , vetor de vetores.
Cdigo 6-33: Declarando e criando uma matriz.

A linha acima declara e cria uma matriz bidimensional: a matriz contm
cinco linhas e cada uma das linhas possui quatro colunas. Elementos individuais
podem ser acessados da seguinte maneira:
Cdigo 6-34: Esquema de acesso a uma matriz.

O seguinte exemplo cria um vetor multidimensional com dez linhas, mas o
nmero de colunas por linha diferente. A primeira linha possui apenas um
elemento, a segunda dois, a terceira trs e assim por diante.
Cdigo 6-35: Criao de matriz com nmero de colunas diferentes.

Exemplo de um vetor multidimensional:
Figura 6-12: Viso geral de estrutura e implementao de matrizes.

int[][] matriz = new int[4][2];
matriz[indiceLinha][indiceColuna] = valor;
int[][] a = new int[10][];
for(int i=0; i<a.length; i++) {
a[i] = new int[i+1];
}
6-26
O mtodo main(String[] args)
Uma referncia para um vetor pode ser passada para qualquer mtodo. Um
bom exemplo sito o mtodo main() usado nas aplicaes Java. Quando voc
inicia uma aplicao Java, o sistema localiza e chama o mtodo main() para
esta classe.
O mtodo main() recebe um nico parmetro, que uma referncia para
um vetor de objetos String. Cada objeto String guarda um parmetro da linha
de comando.
O primeiro elemento do vetor contm o primeiro parmetro da linha de
comando, e no o nome do programa, como ocorre em C ou C++.
importante notar que os parmetros da linha de comando so sempre
representados por objetos String. Dentro do mtodo main(), voc pode
converter os parmetros para tipos primitivos.
Se um dos parmetros, por exemplo, representar um nmero, voc dever
convert-lo para um int para que possa realizar operaes aritmticas com ele.
Mtodos de converses foram vistos anteriormente.
Na verso do J2SDK 1.5 temos a seguinte possibilidade de receber o vetor de
Strings:
Cdigo 6-36: Recepo de parmetros utilizando J2SDK 1.5.

Utilizamos a expresso ... para representar uma String dinmica.
public class Test {
public static void main(String... args) {
System.out.println(args.length + " argumentos");
}
}
6-27
API Colletion

Em Java a API Collection referenciada como um framework. Este
framework fornece um conjunto bem defindo de interfaces e classes para
armazenar e manipular grupos de dados, conhecidos como colees. Este
framework fornece uma conveniente API para muitos dos tipos de dados
abstratos das estruturas: Map, Set, List, Tree, Array, Hashtable e outras colees.
Este frameword est dentro do pacote java.util, desta forma este pacote
deve ser sempre importado quando se desejar trabalhar com colees.
Uma simples collection no coloca nenhuma restrio sobre os tipos de
elemento, ordem dos elementos, ou repetio dos elementos dentro da
collection.
Em java,a interface java.util.Collection define a collection bsica de
framework para todos tipos de collections. A Interface Collection possui mtodos
que permitem voc adicionar itens, remover itens, pesquisar, e contar o nmero
de elementos na collection.

Principais mtodos:

- boolean add(Object element)
- boolean remove(Object element)
- void clear()
- int size()
- boolean isEmpty()
- Object[] toArray()

6-28
A interface Iterator

Um Iterator um objeto que pode ser utilizado para percorrer colees.
Com os mtodos da interface Iterator, voc pode percorrer uma collection do
incio ao fim e de forma segura remover os elementos da Collection. O iterator
geralmente usa operaes de busca.

Mtodos:
- remove()
- hasNext()
- next()

Veja abaixo o cdigo exemplo para percorrer uma coleo do tipo
ArrayList utilizando a interface iterator

ArrayList lista = new ArrayList();
...
Iterator it = lista.iterator();
while ( it.hasNext() ) {
String s = (String)it.next();
...
}
Cdigo 6-37: Iterator
6-29
A interface Enumeration

A interface Enumeration permite voc percorrer todos os elementos de
uma collection. Percorrer uma collection com uma Enumeration semelhante a
percorrer com um Iterator. Emumeration no oferece suporte para remover
elementos, coisa esta que voc pode fazer com um Iterator.

Mtodos:
- boolean hasMoreElements();
- Object nextElement();
Veja abaixo um exemplo de cdigo para percorrer uma Enumeration:

Hashtable tabela = new Hashtable();
...
Enumeration elementos = tabela.elements();
while ( elementos.hasMoreElements() ) {
Produto p = (Produto)elementos.nextElement();
...
}
Cdigo 6-38 Enumeration

6-30
Interfaces do framework

Neste framework existem vrias interfaces que podem ser utilizadas, estas
interfaces so estruturas que permitem armazenar objetos de formas especficas.
Vamos ver algumas delas abaixo.

Interface Set
No conceito matemtico, um conjunto justamente um grupo de itens
nicos, sem elementos duplicados.
A interface Set estende a interface Collection. Set no permite duplicatas
dentro da collection. Na implementao Set, null uma entrada vlida, mas
permitida somente um por vez.

Interface List

Como o prprio nome j nos diz, representa uma lista que permite
duplicatas. A interface List estende a interface Collection. Existem duas List
implementations disponveis na Collections Framework: ArrayList e LinkedList.

A Interface Map
Um map um tipo especial de grupo sem duplicatas. Dentro da Collections
API, java.util.Map define esta interface. Ele mapeia os valores chaves para os
objetos armazenadao. O valores chaves so usados para procurar, ou indexar os
dados armazenados.
A interface Map no uma extenso da interface Collection , ele possui
sua prpria hierarquia. Map no permite duplicatas dentro da collection. Na
implemantao Map , null uma entrada vlida, mas s permitido uma vez.
Vamos estudar aqui uma implementao desta interface: Hashtable

6-31
A classe ArrayList

Implementa a interface java.util.List e usa array para armazenamento. Um
armazenamento de array geralmente mais rpido, mas possui limitaes como,
no poder inserir, e apagar entradas no meio da lista. Para realizar este tipo de
adio e excluso precisamos de um novo array, e isto gera portanto um
overhead muito grande. Voc pode acessar qualquer elemento
aleatoricamente.
Esta estrutura no sincronizada, devendo ser utilizada quando o acesso a
um objeto desta classe tiver uma nica thread.

Cdigo 6-39: Exemplo de ArrayList

package com.targettrust.exemplos;

import java.util.*;

/**
* - Elementos no ordenados
* - Permite duplicados
* - null permitido
* - Semelhante a classe Vector
* - Acesso aleatrio
*/

public class ArrayListExemplo {
List lista = new ArrayList();
lista.add("Java J2EE");
lista.add("Microsoft Net");
lista.add("Linux");
lista.add("Oracle");
lista.add("Web Designer");
lista.add(null);

System.out.println( lista.get(0)+", "+lista.get(4) );
// [Java J2EE, Web Designer]
}
}
6-32
A classe Vector
Uma vez que o tamanho do array definido voc no pode mudar o
tamanho do array. Mas em java isso possivel utilizando o mecanismo de
refleo do Java que foi introduzido no Java 1.1, mas ele possui suas prprias
limitaes.
Esta classe possui os seus mtodos sincronizados desta forma deve ser
utilizada quando o acesso ao objeto for concorrente. J se o acesso no tiver
esta caracterstica ento deve ser utilizada a classe ArrayList que no
sicronizada e , portanto, mais rpida.
Para lidar com este tipo de situao em Java utilize Vector, ele cresce e
reduz seu prprio tamanho automticamente. Isso permite somente objetos que
no so primitivos. Para enviar primitivas, converta as primitivas um objeto e
envie elas para o vector.
O vector realoca e redefine o tamanho automticamente . Veja o exempo
seguinte.
Vector vt = new Vector(3, 10);
As linha acima representam a capacidade inicial de trs, e cresce em
aumento de 10 em cada realocao quando se tenta adicionar o quarto
elemento. Depois de realocado a capacidade do vector se torna a capacidade
inicial + a capacidade aumentada (capacity Increment).

Construtores:
- Vector(int initialCapacity);
- Vector(int initialCapacity, int capacitIncrement);
- Vector()

Mtodos:
- void addElement(Object obj);
- int size();
- void setSize(int n);
- void trimToSize();

6-33
Vejamos agora abaixo um exemplo com a classe Vector:

Cdigo 6-40: Exemplo de Vector.
import java.util.*;
/**
* - null permitido
* - Acesso aleatrio
*/
public class VectorExemplo {
Vector lista = new Vector();
lista.add("Linux");
lista.add(null);

System.out.println( lista.get(0) );
System.out.println( lista );
// [Java J2EE]
// [Java J2EE, Microsoft Net, Linux, Oracle, Web Designer, Java J2EE,
null]
}
}
6-34
A classe Hashtable

Hashtable uma estrutura que possui os elementos armazenados
internamente baseados em chave. Todo objeto guardado dentro desta estrutura
ficar associado a uma chave para posterior recuperao do mesmo.

Esta estrutura uma das mais rpidas quando o assunto pesquisa, uma
vez que o acesso ao objeto armazenado direto atravs de chaves.

Veja um exemplo abaixo:

import java.util.*;
/**
* - NO permite duplicados
* - null NO permitido
* - Acesso baseado em chave
*/
public class HashtableExemplo {
Hashtable lista = new Hashtable();
lista.put(new Integer(1), "Java J2EE");
lista.put(new Integer(2), "Microsoft Net");
lista.put(new Integer(3), "Linux");
lista.put(new Integer(4), "Oracle");
lista.put(new Integer(5), "Web Designer");
lista.put(new Integer(6), "Java J2EE");

System.out.println( lista.get(new Integer(1)) );
System.out.println( lista.get(new Integer(4)) );
// [Java J2EE]
// [Oracle]
}
}
Cdigo 6-41: Hashtable

6-35
A classe LinkedList

Implementa a interface java.util.List e usa linked list para armazenamento.
Uma linked list permite que elementos sejam adicionados, removidos da
collection em qualquer posio dentro do container. Com esta implementao
voc somente pode acessar os elementos sequencialmente.
Veja abaixo um exemplo de uso desta estrutura:

Cdigo 6-42: Exemplo de LinkedList.


import java.util.*;

/**
* - null permitido
*/

public class LinkedListExemplo {
List lista = new LinkedList();
lista.add("Linux");
lista.add(null);

System.out.println( lista );
// [Java J2EE, Microsoft Net, Linux, Oracle, Web Designer, Java J2EE,
// null]
}
}
6-36
Generics

Os tipos genricos representam uma das maiores modificaes na
linguagem java j feitas at os dias de hoje. Tipos genricos trazem a facilidade
de parametrizar o tipo de classes, variveis ou mtodos. Na API do JDK 5.0 todas
as collection, por exemplo, foram parametrizadas. Esta parametrizao tornou
classes como, por exemplo, ArrayList capazes de armazenar elementos de um
tipo E e no mais Object. A declarao de ArrayList, por exemplo, agora pode
ser feita da seguinte forma:

1 ArrayList<Aluno> alunos = new ArrayList<Aluno>();
2
3 Aluno a = new Aluno("Rafael");
4 alunos.add( a );
5
6 Aluno x = alunos.get( 0 );
7 System.out.println("Nome: "+ x.getNome() );
Cdigo 6-43: Generics

Observe o cdigo acima e perceba que na linha 6 no foi preciso realizar
um casting para converter o objeto retirado da coleo. O mesmo havia sido
armazenado internamente como um objeto Aluno e no como sendo do tipo
Object.

Alm de simplificar a codificao, os tipos genricos tambm so uma
grande melhoria de robustez, evitando a possibilidade de typecasts errados e,
portanto a ocorrncia de ClassCastException. Isto tambm, claro, aumenta a
produtividade, pois perde-se menos tempo com depurao e testes se o
cdigo compila, porque vai funcionar, pelo menos no que diz respeito a tipos.

Com os tipos genricos, o programador pode formalizar restries
adicionais dos tipos que constri, por exemplo, determinar que determinada lista
s possa conter instncias de Produto, e no objetos quaisquer. Violaes dessas
regras de tipagem no so crticas para a linguagem (pois no possibilitam perda
de dados nem corrupo de memria), mas so crticas para o desenvolvedor,
pois podero ocultar erros de lgica. O resultado pode ser uma
ClassCastException, ou ainda pior o bug pode ficar oculto por muito tempo,
pois o valor opaco (Object) convertido para o tipo que deveria ter.

import static java.lang.System.*;
...
...
Aluno a = new Aluno("Joo", "(51) 3325-2596" );
Map<String, Aluno> hash = new HashMap<String, Aluno>();

// Adiciona um aluno na Hash
hash.put(a.getNome(), a);

// Recupera o Aluno
Aluno x = hash.get( a.getNome() );
6-37

// Mostra dados
out.printf( "Dados: %s %s", x.getNome(), x.getTelefone() );
Cdigo 6-44: Usando generics

Acima voc tem um cdigo onde criamos uma HashMap para adicionar
objetos do tipo Aluno associados a chaves do tipo String. Na declarao de
HashMap especificamos que a chave ser do tipo String bem como os objetos a
serem armazenados sero Alunos, isto evita qualquer necessidade de casting
posterior para recuperar os dados da estrutura, bem como fortalece o sistema de
tipos proibindo que sejam utilizados tipos diferentes dos especificados na
declarao. A linha abaixo no compilaria pois o tipo da chave esta sendo
violada.

hash.put(new Integer(1), a); //ERRO ao compilar!
Cdigo 6-45: Adicionando inteiro como chave

Podemos tambm cria uma classe com tipos parametrizados. A classe
abaixo representa um grupo no qual podemos guardar objetos. Os objetos a
serem armazenados neste grupo so sempre do tipo especificado no parmetro
T da classe Grupo. Veja o cdigo da classe:

public class Grupo<T> {

private ArrayList elementos;

public Grupo() {
elementos = new ArrayList();
}

public void add(T obj) {
elementos.add( obj );
}

public void remove(T obj ) {
elementos.remove( obj );
}
}
Cdigo 6-46: Criando uma classe de um determinado tipo

Podemos criar um objeto da classe grupo da seguinte forma:

Grupo<String> g = new Grupo<String>();
g.add( "Java J2ME" );
g.add( "Java J2EE" );
g.add( new Integer(3) ); // ERRO!
Cdigo 6-47: Criando grupo de Strings

Observe que na linha onde tentamos adicionar um inteiro teremos
problemas, pois o grupo foi criado como sendo capaz de armazenar somente
Strings. O tipo do grupo pode ser trocado conforme o cdigo abaixo:

Grupo<Aluno> g = new Grupo<Aluno>();
6-38
Aluno a = new Aluno("Joo", "(51) 3325-2596" );
g.add( a );
g.add( "Java J2EE" ); // ERRO!
g.add( new Integer(3) ); // ERRO!
Cdigo 6-48: Violando acesso ao grupo

O cdigo acima foi alterado para receber objetos aluno e armazenar
dentro do grupo. Veja que a linha onde adicionamos agora uma String ou um
Integer ir sinalizar erro.
Neste exemplo acima os parmetros do mtodo add(...) bem como do
remove(...) esto parametrizados. Teramos outra opo para no utilizar os
parmetros genricos, bastaria definir o tipo dos mtodos como Object. Desta
forma poderia ser criado um grupo e passado qualquer tipo de objeto para ele,
mas isto permitiria que o grupo pudesse armazenar tipos diferentes de objetos.
Para evitar isto voc tambm poderia tornar os tipos dos parmetros doa
mtodos fixos (String, por exemplo), mas desta forma voc teria somente um
grupo de strings e no poderia criar grupos de outros objetos. Observe que neste
caso o objetivo justamente permitir que se possa criar um grupo de tipos
variveis, mas uma vez definido um grupo como sendo de um tipo, o mesmo no
poder receber elementos de outros tipos.

6-39
Autoboxing

Autoboxing diz respeito a uma converso automtica que feita entre os
tipos primitivos da linguagem java (int, float, long, byte, etc...) e suas wrapper
classes (Integer, Float, Long, Byte, Character, etc...). O programador no precisa
mais se preocupar com estas converses ficando a cargo agora da linguagem.
Este recurso interessante e simplifica a escrita de cdigos porm introduz alguns
efeitos colaterais listados mais abaixo. Deve desta forma ser utilizado de forma
controlada.

Integer i = 10;
Cdigo 6-49: Autoboxing

O cdigo acima atribui um valor primitive (10) a um objeto do tipo Integer.
Logo em seguida o objeto integer impresso.
Um exemplo:

Quando trabalhamos com Collections sabemos que uma coleo pode
ser adicionado somente objetos, no sendo possvel portanto adicionar um tipo
primitivo a esta. Para isto o tipo primitivo deve ser encapsulado em uma wrapper
class e ento o objeto desta wrapper adicionado a Collection. Veja cdigo
abaixo:

ArrayList lista = new ArrayList();

// Criando os objetos
Integer um = new Integer(1);
Integer dois = new Integer(2);
Integer tres = new Integer(3);

// Adicionando os objetos a Collection
lista.add ( um );
lista.add ( dois );
lista.add ( tres );
Cdigo 6-50: Adicionando dados em uma coleo

A mesma dificuldade de manipulao ocorre quando temos que retirara o
valor da coleo, pois se precisarmos manipular o valor como um tipo primitivo
isto exigir, alm de um casting, uma chamada a um mtodo do objeto retirado
para o transformar novamente em um tipo primitivo. Todo este processo de
encapsular e desencapsular conhecido como: boxing e unboxing. Isto deixa o
cdigo maior e mais complicado de ser escrito.

6-40
Veja abaixo a verso do mesmo agora para retirar os elementos:

// Retira os objetos da coleo
Integer x = (Integer)lista.get(0);
Integer y = (Integer)lista.get(1);
Integer z = (Integer)lista.get(2);

// Mostrar os valores em formato int
System.out.println( x.intValue() );
System.out.println( y.intValue() );
System.out.println( z.intValue() );
Cdigo 6-51: Mostrando dados da coleo sem autoboxing

Podemos utilizar autoboxing para resolver e simplificar a escrita deste
cdigo. Veja abaixo a verso do cdigo que adiciona os trs valores dentro da
collection. Observe que utilizamos para isto um tipo de collection que comporta
somente Integer. Esta forma de representao de collection faz uso de Generics.

ArrayList<Integer> lista = new ArrayList<Integer>();

// Adicionando dados a Collection
lista.add ( 1 );
lista.add ( 2 );
lista.add ( 3 );

// Retira os dados da collection
int x = lista.get(0);
int y = lista.get(1);
int z = lista.get(2);

// Mostra os dados da collection
System.out.println( x );
System.out.println( y );
System.out.println( z );
Cdigo 6-52: Utilizando autoboxing para mostrar dados

Comparando valores encapsulados:

Ao compararmos valores que foram encapsulados atravs do recurso de
autoboxing, temos que tomar muito cuidado. Veja o cdigo abaixo e os tipos de
retorno.

int i = 2;
int j = 2;

ArrayList <Integer> lista = new ArrayList<Integer>();

lista.add(i);
lista.add(j);

System.out.println( (i==j) );
System.out.println( lista.get(0)==lista.get(1) );
6-41
System.out.println( lista.get(0).equals( lista.get(1) ) );
Cdigo 6-53: Comparando dado s de uma coleo

As sadas para o cdigo acima so as seguintes:

true
true
true

A primeira comparao esta comparando tipos primitivos e como j
sabemos a sada deveria ser true. J no segundo caso so comparados os
valores que foram enpasulados (autoboxed), retornando tambm true. No
terceiro caso so comparados os valores dos objetos criados atravs de
autoboxing.

Se o valor das variveis inteiras forem alteradas para um valor superior a
127, o retorno para a comparao lista.get(0)==lista.get(1) ser false! Note
que estamos neste caso comparando os valores enpasulados como objetos e
no os valores primitivos diretamente. Para as demais comparaes o retorno
continua sendo true. Abaixo a sada para os valores alterados e superiores a 127:

true
false
true
6-42
Espao para anotaes
6-43
Exerccios

1. Neste exerccio voc ir criar uma classe nova para representar um
pacote de cursos. Um pacote de cursos contm vrios cursos. Teremos que saber
quantos h neste pacote, bem como o valor total do pacote. Este valor ser a
soma do preo de todos os cursos. Veja abaixo os passos para isto:

Passo 1: Crie uma classe pblica chamada PacoteCurso no pacote
com.targettrust.java e defina os seguintes atributos:

private ArrayList<Curso> cursos
private Date dataCriacao
6-44
Observe no atributo acima o uso de generics para definir o tipo de objetos
da coleo
Passo 2: Crie no mtodo construtor o ArrayList.
Passo 3: Defina nesta classe uma operao que possa receber objetos da
classe curso e os adiciona a coleo cursos. Quando esta coleo atingir um
nmero de 10 cursos deve ser impresso um aviso.
Passo 4: Crie nesta classe uma operao capaz de calcular o valor total do
pacote. Para fazer este clculo voc dever percorrer a coleo e obter o
preo de cada curso adicionado a ela. Use for-each para percorrer o ArrayList.
Passo 5: Crie uma operao na classe PacoteCurso para que a mesma
retorne uma StringBuilder contendo o nome de todos os curos que fazem parte
do pacote.

2. Agora voc ir praticar o mecanismo de autoboxing do java. Vamos criar
um ArrayList com nmeros inteiros e percorrer o mesmo somando estes valores.

Passo 1: Crie uma classe chamada ExemploAutoboxing no pacote
com.targettrust.java e declare nesta classe o mtodo main.
Passo 2: Na classe declare um atributo privado, chamado lista, esttico, do
tipo ArrayList. Utilize Generics na declarao do atributo ( ArrayList<Integer> ) No
mtodo main crie este objeto que representa a lista e adicione no mesmo 5
nmeros do tipo int.
Passo 3: Percorra a lista com um for-each e some todos os nmeros da lista
mostrando o total ao trmino do lao. Observe que no haver casting para a
soma dos nmeros!
Java Fundamentals

7-1
7
7
.
.
T
T
r
r
a
a
t
t
a
a
m
m
e
e
n
n
t
t
o
o
d
d
e
e
E
E
x
x
c
c
e
e
e
e
s
s

Tratamento de Excees
7-2
Objetivos
Compreender as Vantagens do tratamento de Excees em Java;
Manipular, Tratar, Propagar, Capturar e Criar Excees.

7-3
Introduo
Uma exceo um evento que ocorre durante a execuo de um
programa que interrompe o fluxo normal das instrues. Muitos tipos de erros
podem causar excees, tais como tentar acessar um elemento de um vetor
fora dos limites ou tentar dividir um nmero por zero.
Quando uma exceo ocorre dentro de um mtodo Java, o mtodo cria
um objeto Exception e deixa que o ambiente de execuo (runtime system) se
encarregue do assunto. Na terminologia Java, este processo chamado levantar
uma exceo (throwing an exception).
O objeto Exception criado contm informaes sobre a exceo, tais
como seu tipo e o estado do programa quando o erro ocorreu.
Aps o mtodo levantar uma exceo, o ambiente de execuo ento
responsvel por encontrar um cdigo que manipule o erro. Para isso, o ambiente
de execuo entra em ao procurando o cdigo de tratamento para o erro no
conjunto de mtodos da pilha de chamada do mtodo em que o erro ocorreu.
O ambiente de execuo procura de trs para frente na pilha de chamada,
comeando com o mtodo onde o erro ocorreu, at encontrar um mtodo que
contenha a manipulao apropriada da exceo.
Uma manipulao de exceo considerada apropriada se o tipo de
exceo levantada o mesmo tipo de exceo manipulada pelo manipulador
(pelo cdigo de tratamento da exceo).
Assim, a exceo cruza a pilha de chamadas at que uma manipulao
apropriada encontrada e um dos mtodos chamados trata a exceo. Na
terminologia Java, se diz que o manipulador escolhido para tratar a exceo
capturou (catch the exception) a exceo.
Se o ambiente de execuo procura exaustivamente em todos os mtodos
da pilha de chamadas sem descobrir um manipulador de excees apropriado,
o ambiente de execuo (e conseqentemente, o programa Java) termina.
A utilizao de excees para manipular erros tem as seguintes vantagens
sobre as tcnicas de gerenciamento de erros tradicionais:
1. Separa o cdigo para manipular erros do cdigo regular (do fluxo
normal) do programa
2. Propaga erros na pilha de chamadas
3. Agrupa tipos de erros e os diferencia
4. No podem ser ignoradas
7-4
1
a
Vantagem: Separao de Cdigo
Na programao tradicional, a deteco e manipulao de erros tornam o
cdigo freqentemente mais difcil de compreender. Como exemplo, suponha
que se tenha uma funo que leia a primeira linha de um arquivo.
Um esquema do cdigo para esta funo seria:
Cdigo 7-1: Exemplo de cdigo estruturado para tratamento de arquivos.

Esta funo poderia ter diversos erros potenciais, tais como erro na abertura
do arquivo, erro na leitura da primeira linha, erro no fechamento do arquivo.
No modo de programao tradicional para detectar os potenciais erros
para esta funo, cada erro deve ser testado e atribudo para um cdigo de
erro. Isto leva a uma grande quantidade de cdigo adicional para a deteco e
manipulao dos possveis erros.
Por exemplo, a funo anterior se tornaria uma funo tal como:

Cdigo 7-2: Exemplo de cdigo condicional para tratamento de arquivos com retorno de valor.

Na linguagem Java, o problema de tratamento de erros realizado a partir
excees.
As excees permitem que o programador escreva o cdigo do fluxo
principal e manipule os casos excepcionais em outro local.
int leituraArquivo {
abre o arquivo;
le o arquivo;
fecha o arquivo;
}
int leituraArquivo {
int codigoErro = 0;
abre o arquivo;
if (erroAberturaArquivo)
codigoErro = -1;
else {
le o arquivo;
if (erroLeituraArquivo) codigoErro = -2;
fecha o arquivo;
if (erroFechamentoArquivo) codigoErro = -3;
}
return codigoErro;
}

7-5

A funo exemplo anterior se tornaria uma funo tal como:
Cdigo 7-3: Exemplo de cdigo estruturado para tratamento de arquivos utilizando Java.

Como pode ser visto, as excees no dispensam a deteco e
manipulao dos erros.
O que elas fornecem so meios de separar da lgica principal todos os
detalhes do que fazer quando algum evento fora do normal ocorre. Com isso, o
cdigo se torna mais claro e menos propenso a erros.
leituraArquivo {
try {
abre o arquivo;
le o arquivo;
fecha o arquivo;
}
catch (erroAberturaArquivo) {
manipula erro
}
catch (erroLeituraArquivo) {
manipula erro
}
catch (erroFechamentoArquivo) {
manipula erro
}
}
7-6
2
a
Vantagem: Propagao de Erros
A segunda vantagem do uso de excees a habilidade de propagar a
informao do erro atravs dos mtodos da pilha de chamadas.
Uma exceo em Java enviada imediatamente para o manipulador
apropriado, sem a necessidade do comando if em cada nvel para transmitir o
erro acima na pilha de chamadas.
Suponha que o mtodo do exemplo anterior, leituraArquivo, o quarto
mtodo em uma srie de chamadas de mtodos aninhados feitas pelo
programa principal: metodo1 chama o metodo2, que chama o metodo3, que
chama leituraArquivo.
O metodo1 o nico mtodo interessado nos erros que ocorrem dentro do
mtodo leituraArquivo, e o mtodo que manipula estes erros. Na tcnica de
programao tradicional, o metodo2 e o metodo3 teriam que propagar os
cdigos de erros retornados por leituraArquivo adiante na pilha de
chamadas at que os cdigos de erros finalmente atingissem metodo1, o nico
mtodo interessado nestes erros.
Assim, na programao tradicional, seria necessrio:
1. leituraArquivo tenta executar sua funo e retorna um cdigo de
erro para metodo3
2. metodo3 verifica a existncia de erros e transmite o cdigo de erro para
metodo2
3. metodo2 verifica a existncia de erros e transmite o cdigo de erro para
metodo1
4. metodo1 verifica a existncia de erros e trata os erros ocorridos.
Na manipulao de excees em Java, contudo, o ambiente de execuo
procura de trs para frente na pilha de chamadas, procurando descobrir algum
mtodo que est interessado em manipular uma exceo em particular.
Um mtodo Java pode levantar qualquer exceo dentro dele, permitindo
assim que um mtodo adiante na pilha de chamadas possa capturar esta
exceo. Com isso, apenas os mtodos interessados devem se preocupar em
detectar erros.
Deste modo, manipulando excees, necessrio:
1. leituraArquivo levanta uma exceo
2. metodo1 captura a exceo
7-7
Alm disso, as excees que podem ser levantadas dentro de um mtodo
so parte da interface de programao pblica do mtodo e devem ser
especificadas na clusula throws do mtodo.
Com isso, o mtodo informa aos seus chamadores sobre as excees que
ele pode levantar e estes mtodos podem decidir de modo inteligente o que
fazer com tais excees.
O trecho a seguir demonstra como ficariam os mtodos metodo1, metodo2 e
metodo3 manipulando excees. Como pode ser visto, este cdigo mais
compacto que na programao tradicional.

Cdigo 7-4: Propagao de excees utilizando a clusula throws.
public void metodo1() {
try { chamada de metodo2; }
catch (exception) { trata erro; }
}

public void metodo2() throws exception {
chamada de metodo3;
}

public void metodo3() throws exception {
chamada de lePrimeiraLinhaArquivo;
}

7-8
3
a
Vantagem: Agrupar Tipos de Erros
As excees freqentemente se enquadram em categorias ou grupos. Por
exemplo, os erros que podem ocorrer na manipulao de um vetor (tais como
ndice fora do intervalo do tamanho do vetor e insero de elemento de um tipo
errado) podem ser facilmente imaginados como um grupo de excees, cada
exceo representando um dos tipos de erro.
Do mesmo modo, os erros que podem ocorrer em operaes de E/S (tais
como tentar abrir um arquivo com nome invlido e interrupo da operao de
E/S) so facilmente imaginados como um grupo de excees.
Alm disso, fcil imaginar que alguns mtodos queiram fazer o tratamento
das excees que se enquadrem numa categoria (por exemplo, todas as
excees referentes a vetores), e outros mtodos queiram manipular apenas
excees especficas (por exemplo, apenas a insero de um elemento de tipo
errado no vetor).
Todas as excees que so levantadas dentro de um programa Java so
objetos first-class. Deste modo, o agrupamento de excees um resultado
natural da hierarquia de classes. As excees em Java devem ser instncias de
Throwable, ou qualquer descendente de Throwable.
Assim como em outras classes, subclasses da classe Throwable podem ser
criadas. Cada classe sem subclasses (folha) representa um tipo especfico de
exceo e cada classe com uma ou mais subclasses (nodo) representa um
grupo de excees.
No esquema abaixo, IOException uma subclasse de Exception (uma
subclasse de Throwable) e possui duas subclasses:
FileNotFoundException
InterruptedIOException.
A classe IOException uma classe geral de excees produzidas por falha
ou interrupo de operaes de E/S. As suas duas subclasses representam dois
tipos de erro especficos que podem ocorrer em operaes de E/S.

7-9
Figura 7-1: Hierarquia de classes para tratamento de arquivos.

Um exemplo de manipulador de exceo que trata somente excees
geradas ao tentar abrir um arquivo com nome invlido
(FileNotFoundException) :

Cdigo 7-5: Bloco catch para tratamento de exceo especfica.

Um mtodo pode tambm capturar uma exceo baseada em seu grupo
ou tipo geral. Isto feito especificando qualquer uma das superclasses de
excees no comando catch. Para capturar todas as excees de E/S,
independente do seu tipo, a manipulao de excees poderia especificar o
argumento IOException, como no exemplo abaixo.
Esta manipulao iria capturar todas as excees deste grupo. Para
descobrir exatamente que tipo de exceo ocorreu, o parmetro e poderia ser
usado.
Cdigo 7-6: Bloco catch para tratamento de exceo de grupo (IOException).

possvel tambm utilizar um manipulador de excees que trate qualquer
exceo:
Cdigo 7-7: Bloco catch para tratamento de qualquer exceo.

Manipuladores de excees que so muito genricos, como o mostrado
acima, podem tornar o cdigo mais propenso a erros por capturar e tratar
excees que no foram previstas e que, portanto, no sero corretamente
tratadas dentro do manipulador.
Deste modo, manipuladores de excees gerais no devem ser utilizados
como uma regra.
catch (FileNotFoundException e) {
tratamento da exceo
}
catch (IOException e) {
tratamento
}
catch (Exception e) {
tratamento
}
7-10
4
a
Vantagem: Excees no so Ignoradas
Aps um mtodo levantar uma exceo, ela no pode ser ignorada: ela
precisa ser capturada e manipulada em algum local.
7-11
Manipulando Excees
A classe Throwable a superclasse de todos os erros e excees na
linguagem Java, possuindo duas subclasses: Error e Exception.
Figura 7-2: Hierarquia de erros Java.

Subclasse Error
Erros so extenses da classe Error, subclasse de Throwable. Subclasses de
Error, diferente das subclasses de Exception, geralmente no devem ser
capturadas, e geralmente causaro o trmino do programa.
Exemplos deste tipo de erro so falta de memria durante a execuo ou
no estar apto a carregar uma classe.
Excees no verificadas (Unchecked Exceptions)
Excees no verificadas (excees de execuo) so extenses da classe
RuntimeException. Estas excees so aquelas que ocorrem dentro do
ambiente de execuo Java (JVM). Possveis exemplos so excees aritmticas
(tal como diviso por zero), excees de ponteiro (tal como tentar acessar um
objeto utilizando uma referncia nula) e excees de indexao (tal como tentar
acessar um elemento de um vetor utilizando um ndice muito grande).
As excees de execuo podem ocorrer em qualquer local do programa
e o custo para testar se elas realmente ocorrero freqentemente maior que o
benefcio de captur-las. Assim, o compilador no requer que o programador
capture estas excees, embora isso seja possvel.
Porm, embora estas excees no precisem ser capturadas, elas no
podem ser ignoradas. Se uma exceo de execuo ocorre e o cdigo no as
7-12
manipula, a mquina virtual ir terminar o programa e imprimir o nome da
exceo e um rastro da pilha.
Excees Verificadas (Checked exceptions)
Excees verificadas so extenses da classe Exception. Estas excees
no so excees de execuo e so verificadas pelo compilador, que se
certifica de que tais excees sero capturadas e manipuladas em algum outro
local no programa. Excees criadas pelo programador devem estender a classe
Exception.
7-13
Tratando Excees
Quando um mtodo utilizado pelo programa levantar uma exceo, o
programador possui trs opes:
- Capturar a exceo e trat-la;
- Capturar a exceo e levantar uma exceo diferente, que ser
manipulada em outro local;
- Deixar a exceo passar atravs do mtodo; algum manipulador deve
ento captur-la em outro local.
Para identificar se um mtodo em particular de uma classe padro do Java
pode levantar uma exceo, a documentao do JDK pode ser utilizada. Todas
as classes padro do Java so documentadas e uma parte da documentao
de cada mtodo a lista das excees que este mtodo pode levantar.
Por exemplo, na classe Integer, para o mtodo parseInt (que transforma
um argumento String em um nmero decimal com sinal):
public static int parseInt(String s) throws NumberFormatException

7-14
Manipulando Excees
O mecanismo para manipulao de excees em Java formado pelos
comandos try/catch/finally.
Para manipular uma exceo, o cdigo deve ser organizado nos seguintes
blocos:
- Incluir as chamadas dos mtodos que podem levantar excees em um
bloco try;
- Inserir um ou mais blocos catch, onde cada um ir capturar uma
exceo em particular;
- Adicionar um bloco finally se desejado. O bloco finally
executado sempre, mesmo que nenhuma exceo tenha sido
levantada.
O exemplo a seguir demonstra a sintaxe para manipular trs excees
(excecaoTipo1, excecaoTipo2 e excecaoTipo3) que poderiam ser levantadas
por mtodo chamado.

Cdigo 7-8: Tratamento de excees utilizando os blocos try/catch/finally.

try {
...
chamada do mtodo que pode levantar exceo
...
}catch (excecaoTipo1){
trata excecaoTipo1
trata excecaoTipo2
trata excecaoTipo3
}finally {
...
}
7-15
O Bloco try
O comando try delimita o bloco de cdigo que contem as chamadas para
os mtodos que podem levantar excees. Se uma exceo ocorre dentro de
um bloco try, esta exceo capturada pelo manipulador de excees
apropriado associado a este bloco try.
O Bloco catch
Um bloco try pode ser seguido por zero ou mais blocos catch, que
especificam como tratar os vrios tipos de excees. Cada clusula catch
declarada com um argumento, que deve ser do tipo Throwable ou uma
subclasse deste.
Quando uma exceo ocorre, o primeiro catch que possui o argumento do
tipo apropriado ativado. Este argumento deve ser o tipo da exceo do objeto
ou uma superclasse da exceo, e valido somente dentro do bloco catch.
No necessrio que haja um bloco catch para todas as excees
possveis. Em alguns casos, o tratamento correto permitir que a exceo seja
propagada acima e possa ser capturada por outro mtodo que esteja na pilha.
O Bloco finally
O bloco finally contm o cdigo responsvel pela finalizao do mtodo
(tais como fechamento dos arquivos, liberao dos recursos) antes que o
controle seja transferido para outra parte do programa.
O cdigo dentro deste bloco sempre executado se uma poro do bloco
try executada, independente de como o cdigo no bloco try completado.
Em um fluxo normal, o controle atinge o final do bloco try e passa ento ao
bloco finally que executa a finalizao necessria.
Se o controle deixa o bloco try pelo uso de um comando return ou break,
o contedo do bloco finally executado antes do controle ser transferido
para o novo destino.
Se uma exceo ocorre no bloco try e h um bloco catch local para
manipular esta exceo, o controle transferido para o bloco catch e
posteriormente para o bloco finally. Se a exceo ocorre e no h um bloco
catch para manipular a exceo, o controle transferido para o bloco finally
e ento propagado para a clusula catch mais prxima que manipula esta
exceo.
possvel existir um bloco finally sem um ou mais blocos catch anteriores.
Contudo, um bloco try deve sempre existir antes do bloco finally.
7-16
Manipulando Excees: Exemplo Prtico
O cdigo a seguir apresenta um exemplo de uma classe, converteNumero,
onde so capturadas duas excees: ArrayIndexOutOfBoundsException e
NumberFormatException. Esta classe converte o argumento lido no formato
String para um inteiro.
Cdigo 7-9: Exemplo de mtodo utilizando tratamento de excees.

Observe o cdigo acima e descreva o que impresso na tela nas seguintes
situaes:
1. A classe chamada utilizando: C:\java ConverteNumero 38
2. A classe chamada utilizando: C:\java ConverteNumero palavra
3. A classe chamada utilizando: C:\java ConverteNumero

Imagine agora o exemplo acima sem o bloco catch que trata a exceo
ArrayIndexOutOfBoundsException. O que aconteceria se a classe fosse
chamada utilizando apenas converteNumero?

public class ConverteNumero {
public static void main(String argv[]) {
int num;
try {
System.out.println("String lida: " + argv[0]);
num = Integer.parseInt(argv[0]);
System.out.println("Numero: " + num);
}catch (ArrayIndexOutOfBoundsException e) {
System.out.println("No foi fornecido argumento.");
return;
}catch (NumberFormatException e) {
System.out.println("No foi possvel converter a string" +
"para inteiro. Verifique a string fornecida.");
}finally {
System.out.println("Bloco finally.");
}
System.out.println("Encerrando mtodo");
}
}
7-17
Propagando Excees
Quando uma exceo no pode ser tratada localmente ou se deseja que
ela seja tratada em outro local, ela pode ser propagada para o cdigo que
chamou o mtodo.
Para propagar uma exceo para o mtodo acima, a exceo deve ser
indicada na declarao do mtodo chamado. Isto feito utilizando o comando
throws.
Cdigo 7-10: Propagao de excees utilizando a clusula throws.

Observe o exemplo abaixo. O mtodo converteStringParaNumero no
trata a exceo NumberFormatException localmente. Ao invs disso, a exceo
passa automaticamente para o mtodo que chamou
converteStringParaNumero.
O mtodo que chamou converteStringParaNumero pode capturar a
exceo NumberFormatException ou propagar a exceo para um mtodo
acima. Caso ele deseje propagar a exceo, ele deve tambm conter throws
NumberFormatException em sua declarao.

Cdigo 7-11: Tratamento de excees utilizando a clusula throws para o contexto anterior.

tipo metodo(parametros) throws excecaoTipo1 {
...
}
private void converteStringNumero(String str) throws NumberFormatException {
int num;
try {
System.out.println("String lida: " + str);
num = Integer.parseInt(str);
System.out.println("Numero: " + num);
}finally {
System.out.println("Bloco finally mtodo converteStringNumero.");
}
System.out.println("Encerrando mtodo converteStringNumero");
}
7-18
Lanando Excees
O programador pode lanar excees em seu cdigo para indicar alguma
condio anormal. Estas excees podem ser excees padres do sistema ou
excees criadas pelo programador.
Ao levantar uma exceo, o que est sendo feito na realidade a criao
de um objeto e a transmisso deste para um mtodo superior. Assim, o objeto
exceo deve ser criado usando o operador new.
O exemplo a seguir apresenta um mtodo que lana uma exceo do tipo
ArrayIndexOutOfBoundsException se verificar que o ndice no vlido.

Cdigo 7-12: Antecipando uma exceo e criando a exceo correspondente.

private void testaArgumento(int indice, String vetor[]) throws
ArrayIndexOutOfBoundsException {
if (indice >= vetor.length) {
throw new ArrayIndexOutOfBoundsException();
}
}
7-19
Criando Excees
Para criar as suas prprias excees, o programador deve estender a classe
Exception. A classe RuntimeException no deve ser estendida, pois esta classe
utilizada para excees comuns que no precisam ser verificadas.
O exemplo a seguir cria uma exceo chamada
ExcecaoArgumentoInvalido. Esta exceo possui um nico construtor que
apenas chama o construtor da superclasse.
Cdigo 7-13: Criando uma classe do tipo Exception.

public class ExcecaoArgumentoInvalido extends Exception {
public ExcecaoArgumentoInvalido (String message) {
super(message);
}
}
7-20
Capturando Excees e Levantando Excees
Diferentes
Quando uma exceo levantada, o mtodo pode captur-la e levantar
uma exceo diferente para outros mtodos.
O trecho a seguir exemplifica esta situao.
Neste mtodo, a exceo ArrayIndexOutOfBounds capturada e uma
nova exceo do tipo ExcecaoArgumentoInvalido criada.
Cdigo 7-14: Capturando excees e lanando uma exceo diferente (exceo particular).
public void testaArgumento(int indice, String strvet[]) throws
ExcecaoArgumentoInvalido {
try {
String str = strvet[indice];
}
catch (ArrayIndexOutOfBoundsException e) {
throw new ExcecaoArgumentoInvalido("# elementos incorretos!");
}
}
7-21
Espao para anotaes
7-22
Exerccios

1. Neste exerccio voc ir criar uma exceo personalizada para tratar
erros de validao que podem ser ento lanados quando estiver
executando a aplicao e um valor incorreto for passado, por exemplo,
para o mtodo que atribui valores a um produto.

Passo 1: Crie uma classe pblica chamada ValidacaoException, esta
classe deve ser criada em um arquivo fonte novo e deve extender a
classe RuntimeException.

Passo 2: Defina um mtodo construtor nesta classe que possa receber
uma String como parmetro e repasse esta string para a classe pai.

Passo 3: Nas operaes de modificao do atributo preco da classe
Produto bem como na operao que atribui um produto a um
ItemPedido faa uso desta classe para se a validao der algum erro
voc lanar uma exceo com uma mensagem personalizada para
quem chamou esta operao.

Java Fundamentals

T@rgetTrust Treinamento e Tecnologia 8-1
8
8
.
.
C
C
l
l
a
a
s
s
s
s
e
e
s
s
a
a
b
b
s
s
t
t
r
r
a
a
t
t
a
a
s
s
e
e
I
I
n
n
t
t
e
e
r
r
f
f
a
a
c
c
e
e
s
s

Classes abstratas e interfaces
8-2
Objetivos

Criar classes abstratas
Definir interfaces
8-3
Abstrao
Em Java voc pode definir classes que representem, na definio de um
projeto, um nvel mais alto de abstrao. Ao usar estas classes o projetista ter
uma viso melhor de como as subclasses devem se parecer e mesmo quais
mtodos so obrigatrios em todas as subclasses.
Figura 8-1: Definindo a classe Produto como abstrata para no ser instanciada.

Classes Abstratas
Uma classe abstrata simplesmente uma classe que no pode ser
instanciada. Somente suas subclasses podem ser instanciadas. Por exemplo,
Produto no contm detalhes suficientes para fornecer algo til para o negcio.
Um item deve ser um CD ou um DVD. Produto serve, no entanto, como uma
coleo de dados e comportamentos que so comuns a todos os itens
disponveis para alugar.
Mtodos Abstratos
Mtodos abstratos vo um passo alm da herana padro. Um mtodo
abstrato definido dentro de uma classe abstrata deve ser implementado pelas
subclasses destas. Esta tcnica permite que o projetista de classes decida
exatamente quais comportamentos as subclasses devem ter.
O projetista de uma classe abstrata no consegue determinar como estes
comportamentos sero implementados, mas somente que eles sero
implementados.
Interfaces
Interface a especificao de um conjunto de mtodos, similares a uma
classe abstrata. Alm do que uma classe abstrata pode oferecer, uma interface
pode efetivamente permitir herana mltipla.
Uma classe pode implementar um nmero ilimitado de interfaces, mas pode
estender somente uma nica superclasse.
8-4
Definindo classes abstratas
Java fornece a palavra reservada abstract que indica que uma classe
abstrata. Por exemplo, a classe Produto no exemplo abaixo foi declarada como
sendo abstrata:
Figura 8-2: Definies das classes Produto, DVD e CD. Herana e Abstrao da classe Produto.

Produto declarado como uma classe abstrata porque no possui
informao ou comportamento suficientes para representar um objeto
autnomo.
O usurio no deveria ser capaz de criar objetos Produto, porque Produto
apenas uma classe parcial e intermediria. Produto existe somente para que
possa ser estendida por classes mais especializadas, tais como CD ou DVD.
O que acontece se voc tentar instanciar uma classe abstrata?

Cdigo 8-1: Erro de compilao na criao de uma instncia de uma classe abstrata.

Se voc tentar criar um objeto Produto em seu programa, o compilador
acusar um erro. O usurio pode criar somente objetos de subclasses concretas:
Cdigo 8-2: Criao com sucesso de instncias especializadas.

O modificador abstract pode ser aplicado somente a classes e mtodos.
Classes abstratas provem um modo de adiar a implementao de mtodos para
Produto produto = new Produto(); // Erro de compilao
CD cd = new CD(); // Herdando Produto
DVD dvd = new DVD(); // Herdando Produto
8-5
subclasses. Uma classe abstrata no pode ser instanciada, ou seja, no podemos
chamar seus construtores.
8-6
Mtodos Abstratos
Ao projetar uma hierarquia de classes, h provavelmente algumas
operaes que todas as classes devero ter, cada qual de sua prpria maneira.
Por exemplo, em um negcio de aluguel de fitas, o vendendo deve saber se um
item pode ser alugado ou no.
Cada tipo de item, entretanto, determina se pode ser alugado de uma
maneira especfica.
Para representar este conceito em Java, o mtodo este item pode ser
importado definido na classe Produto. Entretanto, no h uma
implementao sensata para este mtodo em Produto, porque cada tipo de
item tem suas prprias exigncias.
Uma abordagem, seria deixar o mtodo vazio na classe Produto:
Cdigo 8-4: Definindo mtodos concretaos em classes abstratas.

Esta abordagem no boa o suficiente porque no fora cada uma das
subclasses concretas a sobrescrever o mtodo. Suponha, por exemplo, que a
classe DVD se esquea de sobrescrever o mtodo isImportado(), o que
aconteceria se o usurio chamasse este mtodo a partir de uma referncia para
DVD?
O mtodo isImportado() definido em Produto seria chamado e retornaria
true. Este no o resultado desejado. A soluo declarar o mtodo como
abstrato, como mostrado logo a seguir.
public abstract class Produto {
public boolean isImportado() {
return true;
}
}
8-7
Definindo mtodos abstratos
Para declarar um mtodo abstrato em Java, voc deve colocar antes do
nome do mtodo a palavra reservada abstract. Veja o exemplo:
Cdigo 8-5: Definindo mtodos abstratos em classes abstratas.

Ao declarar um mtodo abstrato, voc deve fornecer somente a assinatura
do mtodo, que compreende: o nome do mtodo, a lista de parmetros
esperados e o tipo de retorno. Voc no fornece um corpo para o mtodo.
Cada subclasse concreta dever sobrescrever este mtodo e fornecer o seu
prprio corpo.
Agora que o mtodo declarado abstrato, todas as subclasses devem
fornecer uma implementao para ele.
Subclasses abstratas podem conter mtodos que no so declarados
abstratos. Estes mtodos podem ser sobrescritos pelas subclasses, mas isto no p
necessariamente obrigatrio.
public abstract class Produto {
public abstract boolean isImportado();
}
8-8
Interfaces
Uma interface similar a uma classe abstrata, exceto que ela no possui
nenhum mtodo concreto ou variveis de instncia. apenas uma coleo de
declaraes de mtodos abstratos e constantes isto , variveis declaradas
como static public final.
Uma interface como um contrato que a subclasse deve obedecer.
Qualquer classe que implemente uma interface deve implementar todos os
mtodos especificados na interface. Uma classe pode implementar muitas
interfaces, mas pode estender apenas uma nica classe. Java no suporta
herana mltipla, mas permite a implementao de mltiplas interfaces.
Como j foi dito anteriormente, CD herda todos os atributos e
comportamentos de Produto. Alm disto, deve fornecer implementao para
cada um dos mtodos definidos em cada interface que implementar.
Estes mtodos podem ser usados por outras classes para implementar
comportamentos especficos como, por exemplo, uma rotina de ordenamento.
8-9
Exemplos de interfaces
Interfaces descrevem um aspecto de comportamento que muitas classes
possuem. O nome de uma interface geralmente um comportamento como:
Compra, Venda, etc. Difere, portanto, do nome de uma classe, que usualmente
um substantivo, como cliente ou produto.
A interface java.sql.Connection possui os mtodos a seguir:
- void commit()
- void rollback()
- void close()
- void clearWarnings()
- Statement createStatement()
- void setAutoCommit(boolean)
- boolean isClosed()

Qualquer classe que precise trabalhar com conexo de bando de dados
pode implementar a interface Connection.
As classes que implementam uma interface podem ser completamente
distintas e no ter uma nada a ver com as demais.
A nica coisa que devem ter necessariamente em comum a necessidade
de todas serem mveis.
8-10
Definindo Interfaces

Voc pode definir uma interface usando a palavra reservada interface.
Todos os mtodos especificados em uma interface so implicitamente pblicos e
abstratos (public e abstract). Quaisquer variveis definidas em uma interface
so implicitamente pblicas, estticas e constantes (public, static e final).
Cdigo 8-6: A interface Conncetion do pacote java.sql.

Portanto, a definio acima equivaleria seguinte definio:
Cdigo 8-7: A interface Conncetion do pacote java.sql equivalente.

Porque os mtodos de interface so implicitamente pblicos e abstratos
prtica geralmente aceita no especificar estes modificadores de acesso. O
mesmo verdade para variveis.
Como so implicitamente pblicas, estticas e finais, geralmente estes
modificadores no so especificados. Cada interface pode ser representada em
um arquivo Java separado com o nome da interface. (neste caso poderamos
criar um arquivo chamado Connection.java do pacote java.sql)
public interface Connection {
public void commit();
public void rollback();
public void close();
public void clearWarnings();
public Statement createStatement();
public void setAutoCommit(boolean b);
public boolean isClosed();

// entre outros mtodos ...
}
public interface Connection {
public abstract void commit();
public abstract void rollback();
public abstract void close();
public abstract void clearWarnings();
public abstract Statement createStatement();
public abstract void setAutoCommit(boolean b);
public abstract boolean isClosed();

// entre outros mtodos ...
}
8-11
Implementando Interfaces
O exemplo abaixo mostra o exemplo da classe OracleConn que implementa
a interface Conncetion. OracleConn deve implementar todos os mtodos de
todas as interfaces que ele declare implementar (interfaces presentes na clusula
implements).
Neste caso, OracleConn deve implementar os mtodos contidos na
interface Connection.
Cdigo 8-8: A classe OracleConn deve implementar TODOS os mtodos da interface Conncetion.

Uma classe pode implementar mais de uma interface se ela desejar,
bastando para tal especificar uma lista de interfaces separadas por vrgula.
Considere o seguinte exemplo:
Cdigo 8-9: A classe Aplicacao pode implementar mais de uma interface.

Aqui, Aplicacao implementa duas interfaces: InterfaceI e InterfaceII.
Isto significa que a classe Aplicacao deve implementar todos os mtodos
declarados em InterfaceI e InterfaceII. A classe Aplicacao ter o
comportamento definido nas duas interfaces.
public class OracleConn implements Connection {

public void commit() {
//... cdigo
}

public void rollback() {
//... cdigo
}

}
public class Aplicacao extends JFrame implements InterfaceI, InterfaceII {

}
8-12
Espao para anotaes
8-13
Exerccios

1. Crie uma interface para representar uma fila de impresso

Passo 1: Declare uma interface em um arquivo novo com os seguintes
comportamentos:

boolean imprimir()
void parar()
boolean remover(Documento doc)
void refresh()
void pausa()

Passo 2: Crie uma classe para implementar esta fila de impresso e
codifique as operaes nela

2. Trabalhando com classes abstratas

Passo 1: Torne a classe Produto abstrata adicionando a palavra reservada
abstract na assinatura da classe.

Passo 2: Tente criar um objeto desta classe agora. possvel?

Passo 3: Transforme a operao que retorna o preo abstrata uma vez que
a forma de calcular o preo ir depender de cada uma das subclasses.

Java SE em Portugues Excelente Apostila Curso Completo de Introdução A Java SE

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Java SE em Portugues Excelente Apostila Curso Completo de Introdução A Java SE

Enviado por

Direitos autorais:

Formatos disponíveis

Java Fundamentals

Você também pode gostar