Apostilade POOe Java

Centro de Cincias Exatas,
Ambientais e de Tecnologias
Faculdade de Engenharia de Computao
Curso de Engenharia de Computao
Paradigmas de
Programao
1
o
Semestre de 2013

Prof. Andr Lus dos R.G. de Carvalho

ndice
NDICE .................................................................................................................................................................. 2
CAPTULO I: O PARADIGMA DE ORIENTAO A OBJETOS ................................................................ 6
INTRODUO ..................................................................................................................................................... 7
MOTIVAO ....................................................................................................................................................... 7
INSTNCIAS ........................................................................................................................................................ 8
CLASSES ............................................................................................................................................................... 9
OBJETOS .............................................................................................................................................................. 9
MEMBROS DE CLASSE E DE INSTNCIA ................................................................................................... 9
ENCAPSULAMENTO ....................................................................................................................................... 10
HERANA .......................................................................................................................................................... 10
POLIMORFISMO .............................................................................................................................................. 11
SOBRECARGA .................................................................................................................................................. 11
ASSINATURA ..................................................................................................................................................... 12
HERANA MLTIPLA .................................................................................................................................... 12
CLASSES ABSTRATAS .................................................................................................................................... 13
CONCLUSO ..................................................................................................................................................... 13
REFERNCIAS .................................................................................................................................................. 14
BIBLIOGRAFIA ................................................................................................................................................. 15
CAPTULO II: ORIENTAO A OBJETOS NA LINGUAGEM DE PROGRAMAO JAVA ............ 16
INTRODUO ................................................................................................................................................... 17
CARACTERSTICAS ENQUANTO LINGUAGEM DE PROGRAMAO .............................................. 17
O JAVA DEVELOPMENT KIT (JDK) ............................................................................................................ 20
IDENTIFICADORES ......................................................................................................................................... 21
CONVENES .................................................................................................................................................... 21
PALAVRAS RESERVADAS ............................................................................................................................. 22
OPERADORES ................................................................................................................................................... 22
OUTROS SEPARADORES ............................................................................................................................... 22

COMENTRIOS ................................................................................................................................................ 22
SADA DE DADOS ............................................................................................................................................. 23
CLASSES ............................................................................................................................................................. 23
COMPILAO E EXECUO ....................................................................................................................... 24
TIPOS BSICOS ................................................................................................................................................ 24
CLASSES WRAPPER ........................................................................................................................................ 25
A CLASSE NUMBER ........................................................................................................................................... 25
A CLASSE INTEGER ........................................................................................................................................... 26
A CLASSE LONG ................................................................................................................................................ 26
A CLASSE FLOAT .............................................................................................................................................. 26
A CLASSE DOUBLE ............................................................................................................................................ 26
A CLASSE BOOLEAN .......................................................................................................................................... 26
A CLASSE CHARACTER ...................................................................................................................................... 27
CONSTANTES .................................................................................................................................................... 27
CONSTANTES LITERAIS...................................................................................................................................... 27
CONSTANTES SIMBLICAS ................................................................................................................................ 29
CADEIAS DE CARACTERES .......................................................................................................................... 29
A CLASSE STRING ............................................................................................................................................. 29
A CLASSE STRINGBUFFER ................................................................................................................................. 29
A CLASSE STRINGTOKENIZER ........................................................................................................................... 30
FUNES OU MTODOS ............................................................................................................................... 30
VARIVEIS OU ATRIBUTOS ......................................................................................................................... 31
VARIVEIS LOCAIS E GLOBAIS ................................................................................................................. 32
ACESSIBILIDADE DE MEMBROS ................................................................................................................ 32
ENTRADA DE DADOS...................................................................................................................................... 33
A CLASSE MATH .............................................................................................................................................. 37
EXPRESSES ..................................................................................................................................................... 37
OPERADORES ARITMTICOS CONVENCIONAIS ................................................................................................... 38
OPERADORES DE INCREMENTO E DECREMENTO ............................................................................................... 38
OPERADORES RELACIONAIS .............................................................................................................................. 39
OPERADORES LGICOS ..................................................................................................................................... 40
OPERADORES DE BIT ......................................................................................................................................... 40
A Classe BitSet ............................................................................................................................................ 41
CONVERSES DE TIPO ....................................................................................................................................... 41
OPERADORES COMBINADOS COM ATRIBUIO ................................................................................................. 42
EXPRESSES CONDICIONAIS .............................................................................................................................. 42
COMANDOS ....................................................................................................................................................... 44
O COMANDO DE ATRIBUIO ........................................................................................................................... 44
BLOCOS DE COMANDO ................................................................................................................................. 44
O COMANDO IF ................................................................................................................................................ 45

O COMANDO SWITCH ......................................................................................................................................... 46
O COMANDO WHILE .......................................................................................................................................... 49
O COMANDO DO-WHILE .................................................................................................................................... 49
O COMANDO FOR ............................................................................................................................................... 50
O COMANDO CONTINUE .................................................................................................................................... 52
O COMANDO BREAK .......................................................................................................................................... 53
MEMBROS DE CLASSE E DE INSTNCIA ................................................................................................. 56
CONSTRUTORES DE CLASSE ....................................................................................................................... 57
EXCEES ......................................................................................................................................................... 57
GETTERS E SETTERS ..................................................................................................................................... 59
CRIAO DE INSTNCIAS ............................................................................................................................ 63
CONSTRUTORES DE INSTNCIA ................................................................................................................ 64
MTODOS ESPECIAIS ................................................................................................................................ 64
TOSTRING .......................................................................................................................................................... 64
EQUALS .............................................................................................................................................................. 64
HASHCODE .......................................................................................................................................................... 65
COMPARETO ........................................................................................................................................................ 67
ORGANIZAO DE PROGRAMA ................................................................................................................. 74
MODULARIZAO ............................................................................................................................................. 74
PACOTES ........................................................................................................................................................... 81
Classes Pblicas .......................................................................................................................................... 81
Membros Default (ou de Pacote) ................................................................................................................. 81
JAVADOC ........................................................................................................................................................... 88
JARS ................................................................................................................................................................. 92
SOBRECARGA ................................................................................................................................................ 102
CRIAO E DESTRUIO........................................................................................................................... 102
VETORES.......................................................................................................................................................... 112
CONSTANTES VETOR ....................................................................................................................................... 112
TAMANHO DAS DIMENSES DE UM VETOR ..................................................................................................... 112
HERANA ........................................................................................................................................................ 119
MAIS SOBRE CONVERSES DE TIPO ................................................................................................................. 120
VERIFICAO DE TIPO EM JAVA ...................................................................................................................... 121
MEMBROS PROTEGIDOS .................................................................................................................................. 121
CLASSES MEMBRO ....................................................................................................................................... 130
A CLASSE VECTOR ....................................................................................................................................... 130
A CLASSE HASHTABLE ................................................................................................................................ 131
INTERFACES ................................................................................................................................................... 132
HERANA MLTIPLA ....................................................................................................................................... 147
A CLASSE JAVA.LANG.OBJECT ................................................................................................................ 148

CLASSES ABSTRATAS .................................................................................................................................. 148
CLASSES GENRICAS (TEMPLATES) ...................................................................................................... 153
RECURSO ...................................................................................................................................................... 158
EXERCCIOS ................................................................................................................................................... 164
I. CLASSES E OBJETOS ................................................................................................................................ 164
II. PACOTES ..................................................................................................................................................... 172
III. HERANA .................................................................................................................................................. 172
III. CLASSES GENRICAS (TEMPLATES) ................................................................................................ 177
BIBLIOGRAFIA ............................................................................................................................................... 178

Captulo I:
O Paradigma de
Orientao a Objetos
O Paradigma de Orientao a Objetos Pgina 7

Introduo
Apesar de ser um paradigma relativamente novo, o paradigma de orientao a objetos j pode
ser considerado um clssico.
Seu uso vem aceleradamente aumentando com o tempo, tendo se firmado praticamente como
um modismo dos dias atuais. Parece a concretizao da previso anunciada em
[Takahashi88], que dizia que a orientao a objetos viria a ser nos anos 80 e 90 aquilo que
programao estruturada foi nos anos 70.
Como praticamente todos os paradigmas de programao, o paradigma de orientao a objetos
tambm surgiu juntamente com o desenvolvimento de uma linguagem de programao.
A primeira linguagem a implementar conceitos de orientao a objetos foi a linguagem
Smula, proposta por Dahl e Nygaard em 1966. Posteriormente o conceito foi refinado e
desenvolvido na linguagem SmallTalk, proposta por Alan Kay em 1972.
A linguagem SmallTalk no somente norteou o desenvolvimento do paradigma, mas, ainda
hoje, considerada a linguagem que suporta de forma mais completa e pura os seus conceitos.
Motivao
Podemos dizer que um programa de computador implementa uma soluo computacional para
um problema do mundo real.
Assim sendo, construir um programa de computador envolve vrios processos de abstrao e
concretizao entre dois mundos, o real (onde existe o problema, a soluo, e o procedimento
para se chegar do problema soluo) e o virtual (onde existe uma abstrao do problema,
uma abstrao da soluo, e um procedimento abstrato para chegar de uma na outra).
Naturalmente, existe uma distncia conceitual inevitvel entre este dois mundos. Diminuir
esta distncia justamente uma das principais propostas deste paradigma.
Para tanto, o paradigma parte da premissa de que o mundo real no composto nem por dados
(como pretendem os paradigmas orientados a dados), nem por processos (como pretendem os

paradigmas orientados a processos), e sim por entidades semi-autnomas que trabalham e
interagem cooperativamente.
Tais entidades so os elementos constituintes fundamentais do paradigma e recebem o nome
de objeto.
Instncias
Todo instncia possui um estado interno para registrar e se lembrar do efeito de sua operao.
O estado interno de uma instncia representado por uma rea de memria local ao instncia,
que inacessvel e indevassvel.
Todo instncia possui ainda um comportamento, que representado por um repertrio de
operaes que o instncia dispe para responder a mensagens externas ou mesmo internas
prpria instncia.
O resultado da operao de uma instncia depende no s da mensagem que ele recebeu, mas
tambm de seu estado interno.
Mensagens so enviadas de uma instncia a outro com a finalidade de que a instncia
receptora produza algum resultado desejado.
A natureza das operaes que a instncia receptora executa para produzi-lo ela quem
determina, e poder provocar alteraes em seu estado interno, o envio de novas mensagens
para outras instncias e mesmo para si prpria, e at a criao de novas instncias.
Parmetros podem acompanhar as mensagens dirigidas a uma instncia. Tais parmetros, por
sua vez, tambm so instncias, e podero ter algum efeito sobre as operaes que a instncia
receptora executar quando receber a mensagem que elas acompanham.
A descrio das operaes que uma instncia executa quando recebe uma mensagem
chamada mtodo. O conceito de mtodo muito parecido com o conceito de procedimento.
A relao que existe entre mensagens e mtodos em uma instncia sempre biunvoca, i.e.,
uma mesma mensagem somente poderia resultar em mtodos diferentes quando enviada para
instncias diferentes.

A associao entre mensagens e mtodos sempre pr-definida e esttica, i.e., no pode ser
alterada em tempo de execuo.
Classes
Uma classe um modelo de instncia, i.e., consiste de descries de estado, mtodos, e
associaes entre mensagens e mtodos, que todas as instncias pertencentes quela classe
iro possuir.
O conceito de classe muito parecido com o conceito de tipo abstrato de dados, na medida
que uma classe define uma estrutura interna e um conjunto de operaes que todas as
instncias daquela classe iro possuir.
Classes tambm podem receber mensagens, ter mtodos e ter um estado interno.
Objetos
Todo objeto tem uma classe e serve ao propsito de armazenar instncias da classe qual
pertence.
Instncias podem ser criadas a partir de uma classe e, no ato de sua criao, ser solicitadas
atravs de uma mensagem a prestar algum servio, o que ser feito pelas execuo do mtodo
associado quela mensagem.
Instncias somente podem ser solicitadas atravs de uma mensagem a prestar algum servio,
em um momento posterior quele de sua criao, quando estiver armazenada em um objeto,
que lhe prov, com seu nome, uma forma de ser referenciada.
Assim sendo, se no estiverem armazenadas em um objeto, as instncias tem uma sobrevida
breve, j que perdem a utilidade logo aps sua criao.
Membros de Classe e de Instncia
Todos os dados e mtodos definidos em uma classe podem ser ditos membros daquela classe.
Podemos classificar os membros de uma classe em (1) dados e mtodos de classe; e (2) dados
e mtodos de instncia.

Entendemos que membros de classe, sejam eles dados ou mtodos, so membros relativos
uma classe como um todo e no a nenhum instncia individual da classe. Membros de classe
expressam propriedades e aes aplicveis a toda uma classe de instncias e no a uma
instncia especfica.
Entendemos que membros de instncia de classe, sejam eles dados ou mtodos, so membros
relativos instncias individuais e no classe como um todo. Membros de instncia
expressam propriedades e aes que so aplicveis s instncias de uma classe
individualmente e no classe de modo geral.
Encapsulamento
O conceito de encapsulamento de certa forma resume tudo o que foi dito at agora sobre o
modelo de computao proposto pelo paradigma.
Ele determina que uma instncia pode ser vista como o encapsulamento de seu estado interno
e de seu comportamento. O mesmo ocorre com uma classe.
Herana
O conceito de herana se baseia em uma estrutura hierrquica de classes. Em tal estrutura de
classes, cada classe pode ter zero ou mais subclasses e zero ou mais superclasses.
Uma dada subclasse herda todos os componentes (representao de estado interno e
comportamento) de suas superclasses. A classe, em adio s propriedades que herda, pode
definir componentes prprios, alm de poder redefinir componentes que recebeu por herana.
Vale observar que os componentes de uma subclasse recebidos por herana que no forem
redefinidos, comportar-se-o exatamente como componentes definidos na prpria classe, e
isto sem a necessidade de nenhuma definio ou indicao especial.
Esta propriedade encoraja a definio de novas classes, sem no entanto, requerer uma
extensiva duplicao de cdigo [Dershem90].

No paradigma imperativo, o conceito mais prximo de herana o de subtipos. Da mesma
forma que uma subclasse herda as propriedades de suas superclasses, um subtipo herda as de
seu supertipo.
O conceito de subtipo, no entanto, muito mais limitado do que o conceito de herana,
porque aplicvel somente a um conjunto limitado de tipos bsicos, em geral, aos tipos
escalares.
O paradigma imperativo no generaliza esta definio para contemplar tipos abstratos de
dados, o que faz do conceito de herana uma grande contribuio do paradigma de orientao
a instncias.
Polimorfismo
Polimorfismo a propriedade que possibilita que se envie uma mesma mensagem a diferentes
instncias, provocando em cada uma delas uma operao diferente.
Isto acontece porque cada uma das diversas instncias receptoras potenciais de uma
determinada mensagem possui um mtodo prprio para responder chegada daquela
mensagem, dependendo da classe qual ela pertence.
importante ressaltar que, ao se enviar uma mensagem, no h a necessidade de se saber nem
a classe da instncia receptora, nem a forma que esta utilizar para responder mesma.
No paradigma imperativo, o conceito mais prximo de polimorfismo o de sobrecarga de
operadores e de procedimento.
O conceito de polimorfismo estabelece que a determinao do mtodo a ser invocado, quando
da recepo de uma mensagem por uma instncia, feita com base na classe qual a instncia
receptora pertence.
Sobrecarga
O conceito de sobrecarga estabelece a possibilidade de se definir 2 ou mais funes com o
mesmo nome de forma que, quando ocorrer a chamada de uma funo, dentre as diversas

funes de mesmo nome, vai-se determinar aquele que ser executado pelo nmero, tipo e
ordem dos parmetros reais fornecidos por ocasio de sua chamada.
A diferena entre este conceito e o conceito de polimorfismo reside no tempo em que feita a
associao do procedimento a ser executado com a chamada de procedimento.
No polimorfismo, a associao ocorre dinamicamente, uma vez que a classe qual um
instncia pertence no conhecida seno em tempo de execuo. Na sobrecarga, tudo se passa
como se o nmero e o tipo dos parmetros constitussem uma extenso do nome do
procedimento, e a associao pode ser esttica.
Assinatura
O nome de um mtodo, juntamente com o conjunto ordenados dos tipos dos parmetros que
ele recebe, costuma ser chamado de assinatura .
Herana Mltipla
Herana Mltipla um recurso previsto pelo paradgma de orientao a objetos cuja
finalidade permitir que classe herde caractersticas no de uma, mas de vrias outras classes.
Embora no seja um recurso do qual se precise lanar mo com tanta freqncia, trata-se de
um recurso que pode por vezes ser muito til.
Por exemplo: mesmo dispondo de um conjunto amplo de classes base desenvolvidas, pode ser
que, num dado momento, nos vejamos confrontados com a necessidade de um novo tipo de
objeto.
Pode ser ainda que este novo tipo de objeto guarde muita semelhana, no com uma, mas com
muitas das classes que j temos. Trata-se de um caso tpico a ser resolvido com herana
mltipla.
Quando uma classe derivada de mais de uma classe, ela pode ser usada em todos os lugares
onde for esperada uma de suas classes base. Trata-se de uma extenso do conceito de
polimorfismo.

Classes Abstratas
Numa situao convencional de herana, tem-se que classes bases compartilham com suas
classes derivadas, tanto a seu comportamento, quanto sua implementao.
Entretanto, podem haver situaes nas quais quase no exista, de fato, o compartilhamento de
implementao, embora haja um efetivo compartilhamento de comportamento.
Geralmente no possvel escrever cdigo para muitos dos mtodos dessas classes, que,
apesar de declarados, no so de fato definidos, existindo sem um corpo onde ocorra sua
implementao.
Chamamos este tipo de mtodo de Mtodos Abstratos e classes que contem um ou mais
mtodos abstratos so chamadas de Classes Abstratas.
No permitido criar instncias de classes abstratas, mas, apesar disso, elas podem ser muito
teis por propiciarem o polimorfismo.
Concluso
As linguagens orientadas a objetos nos apresentam uma nova forma de organizar e estruturar
programas e isto leva necessidade de desenvolver uma nova forma de pensar em resoluo
computacional de problemas.
O Paradigma de Orientao a Objetos conduz naturalmente implementao de mdulos
fortemente coesos e fracamente acoplados. Isto torna os programas orientados a objetos mais
manutenveis e suas partes mais reusveis, facilitando o que em Engenharia de Software
chamamos de Pea de Software.
Por tudo isso, cada vez mais encontramos o Paradigma de Orientao a Objetos incorporado
nos mais diversos ambientes de computao de uso contemporneo.

Anexo I

Referncias
Dershem, H.L.; and Jipping, M.J., Programming Languages: Structures and Models,
Wadsworth, Inc., 1990.
Takahashi, T., Introduo Programao Orientada a Objetos, III EBAI - Escola
Brasileiro-Argentina de Informtica, 1988.

Anexo II
Bibliografia

Sebesta, R.W., Concepts of Programming Languages, The Benjamin/Cummings Publishing
Company, Inc., 1989.
Ghezzi, Java., Jazayeri, M., Programming Languages Concepts, John Wiley & Sons, Inc.,
1982.
Dershem, H.L.; and Jipping, M.J., Programming Languages: Structures and Models,
Wadsworth, Inc., 1990.
Pratt, T.W., Programming Languages: Design and Implementation.
Takahashi T.; e Liesemberg, H.K.; "Programao Orientada a Objetos"
Entsminger, G.; "The TAO of Objects: A Beginner's Guide to Object Oriented Programming"
Cox, B.J., Programao Orientada para Instncia.Morrison, M.; December, John; et alii, Java
Unleashed, Sams.net Publishing, 1996.
Richardson, J.E.; Schulz, R.C.; e Berard, E.V.; "A Complete Object Oriented Design
Example"

Orientao a Objetos na Linguagem de Programao Java Pgina 16

Captulo II:
Orientao a Objetos na
Linguagem de
Programao Java

Introduo
Em meados dos anos 90 a WWW transformava o mundo online. Com um sistema de
hipertexto, usurios da WWW se tornaram capazes de selecionar e visualizar informaes
de toda parte do mundo.
Apesar permitir a seus usurios um alto nvel de seletividade de informao, a WWW se
limitava a distribuir arquivos de texto, imagem e som, no lhes fornecendo condies para
interagir adequadamente com a informao recebida.
Em outras palavras, faltava interatividade verdadeira, em tempo real, dinmica e visual
entre usurios e aplicaes WWW.
Java vem suprir esta lacuna, tornando possvel a distribuio de aplicaes ativas atravs da
WWW, aplicaes que podem interagir continuamente com os usurios atravs do mouse e
do teclado e dar-lhes respostas imediatas.
Caractersticas enquanto
Linguagem de Programao
sabido que linguagens de programao que encorajam o desenvolvimento de programas
robustos, habitualmente, impem ao programador boa dose de disciplina na escrita de
cdigo fonte. A lingaugem C notoriamente falha neste sentido.
A linguagem C++, que deriva da linguagem C, foi projetada para ser menos permissiva que
sua predecessora (e de fato ) mas ainda guarda uma influncia excessiva desta linguagem.
Isso um problema e, neste sentido, a linguagem Java mais rigorosa.
Sabe-se ainda que C++ uma poderosa linguagem de programao orientada a objetos e,
como acontece com a maioria das linguagens projetadas para serem poderosas, ela
apresenta uma srie de caractersticas que propiciam condies favorveis para o
programador desatento cometer erros de programao.

Apesar de se basear na linguagem C++, a Java uma linguagem de programao
estruturalmente bastante mais simples que sua predecessora, j que de seu projeto foram
elimidadas caractersticas que em C++ eram raramente usadas (ou mal usadas) e que
podiam levar o programador a incorrer em erros de programao.
Especificamente, Java difere de C++ nos seguintes pontos:
1. Java no suporta structs, unions e ponteiros;
2. Java no suporta typedef nem #define;
3. Java apresenta diferenas em certos operadores e no suporta sobrecarga de operadores;
4. Java no suporta herana mltipla;
5. Java lida com parmetros da linha de comando de forma diversa daquela utilizada por C
ou por C++;
6. Java tem strings como parte do pacote Java.lang, o que difere dos vetores terminados
com null das linguagens C e C++;
7. Java tem um sistema automtico para alocar e liberar memria (coleta de lixo), o que
torna desnecessrio o uso de funes de alocao e desalocao de memria como
preciso em C e C++.
A linguagem Java suporta multithreading, i.e., oferece facilidades para o programador
implementar aplicaes que apresentam diversas linhas de execuo (aplicaes nas quais
podem ser encontradas diversas tarefas em processo de execuo num mesmo instante).
Diferentemente das linguagens C e C++, a linguagem Java foi especificamente projetada
para trabalhar em ambiente de rede, possuindo uma vasta biblioteca de classes para
comunicao atravs de protocolos para Internet da famlia TCP/IP (HTTP, FTP, etc).
Por esta razo, Java capaz de manipular recursos via URLs com to facilmente quanto
linguagens como C ou C++ acessam um sistema de arquivos local.
importante ressaltar que, ao mesmo tempo que essas caractersticas representam
facilidades para a programao de sistemas distribudos, representam tambm uma intensa

preocupao com a questo da segurana computacional no sentido mais amplo da
expresso.
Java uma linguagem de arquitetura neutra e implementada atravs de uma tcnica que
leva o nome de interpretao impura.
Tal tcnica de implementao de linguagens de programao se caracteriza, principalmente,
por lanar mo de um compilador e de um interpretador articulados da seguite forma: o
compilador compila o programa fonte mas, em vez de gerar cdigo executvel por uma
mquina real, ele gera cdigo apra uma mquina virtual implementada em software, ou
seja, pelo interpretador.
Em outras palavras, para poder ser executado, o cdigo gerado pelo compilador dever ser
interpretado por um interpretador que implementa a mquina virtual para a qual o
compilador gerou cdigo.
Assim, o cdigo compilado pode rodar em qualquer mquina real, naturalmente, desde que
haja para tal mquina um interpretador que implemente nela a mquina virtual da
linguagem Java.
A linguagem intermediria, na qual o compilador escreve o programa a ser interpretado,
chama-se ByteCode. E virtude do processo de interpretao, um programa em Java nem
sempre tem o mesmo desempenho que um programa equivalente compilado para uma
particular plataforma de hardware.
Por isso, Java prev a possibilidade de traduzir ByteCodes para a linguagem de mquinas
reais, ensejando assim condies para se alcanar a mesma eficincia de um processo de
compilao tradicional.
importante ressaltar que, dizer que uma linguagem de arquitetura neutra, muito mais
forte e contundente do que dizer que uma linguagem portavel.
Sabemos que possvel acontecer de linguagens como C e C++ (reconhecidamente
portveis) gerarem programas que rodem de maneira ligeiramente diferente em plataformas
de hardware diferentes.

Tal se deve, principalmente, diferena de tamanho da palavra de memria nas diferentes
arquiteturas de mquina, o que leva variveis de um mesmo tipo, em diferentes plataformas,
terem capacidades diferentes de representao de valores.
Em Java isso no acontece. Internamente, os dados so representados sempre da mesma
forma, no importando a plataforma de hardware. Isso faz com que seja possvel ter a
certeza de que programas Java produzem sempre o mesmo resultado, no importando a
plataforma na qual executem.
O Java Development Kit (JDK)
Distribudo pela SUN Microsystems, o JDK engloba, entre outras ferramentas:
1. Um compilador Java (javac);
2. Um interpretador de ByteCode que interpreta aplicaes para console (java);
3. Um interpretador de ByteCode que interpreta aplicaes para ambiente de janelas
(javaw);
4. Um interpretador de ByteCode que interpreta aplicaes integradas em uma pgina da
WEB (appletviewer);
5. Um depurador (jdb);
6. Um compactador (jar);
7. Um utilitrio para extrair informaes sobre dados e funes, pblicos ou no, de um
arquivo de ByteCode (javap);
8. Um utilitrio gerador de header files (.h) para integrar ByteCodes em aplicaes feitas
em linguagem C ou C++ (javah);
9. Um gerador de documentao (javadoc).

Identificadores
Identificadores introduzem nomes no programa. Em Java podem ser uma seqncia
arbitrariamente longa de letras, dgitos, sublinhados (_) e cifres ($). O primeiro caractere
de um identificador deve necessariamente ser uma letra, sublinhado (_) ou cifro ($).
importante ressaltar que, diferentemente de outras linguagens de programao, a
linguagem Java diferencia letras maisculas de letras minsculas. Em Java, identificadores
que so lidos da mesma forma, mas que foram escritos de forma diferente no que tange ao
emprego de letras maisculas e minsculas, so considerados identificadores diferentes.
Convenes
Para manter em nveis aceitveis a exigncia cognitiva feita aos desenvolvedores, os
identificadores, em Java, so nomeados de acordo com regras convencionadas.
Naturalmente, importante conhece-las e tambm segu-las. So elas:
1. Identificadores de constantes devem ser grafados exclusivamente com letras maisculas
e, no caso de serem compostos por mais de uma palavra, as mesmas devero ser
separadas por um sublinhado (_);
2. Identificadores de variveis, mtodos e parmetros devem ser grafados com letras
minsculas e, no caso de serem compostos por mais de uma palavra, as mesmas devero
ser justapostas e as palavras que sucederem a primeira devero ser grafadas com inicial
maiscula;
3. Identificadores de classes e interfaces devem ser grafados com inicial maiscula e
demais letras minsculas e, no caso de serem compostos por mais de uma palavra, as
mesmas devero ser justapostas e seguirem a mesma regra de grafia; e
4. Identificadores de pacotes devem ser grafados exclusivamente com letras minsculas e,
no caso de serem compostos por mais de uma palavra, as mesmas devero ser
justapostas.

Palavras Reservadas
Estas palavras so identificadores predefinidos e reservados pela linguagem Java para
propsitos especficos.
abstract boolean break byte
case catch char class
const continue default do
double else extends final
finally float for goto
if implements import instanceof
int interface long native
new null package private
protected public return short
static super switch synchronized
this throw throws transient
try void volatile while
Operadores
Os caracteres e as combinaes de caracteres abaixo so reservados para uso como
operadores e no podem ser utilizados com outra finalidade. Cada um deles deve ser
considerado como um nico smbolo.
+ - * / % & |
^ ~ && || ! < >
<= >= << >> >>> = ?
++ -- == += -= *= /=
%= &= |= ^= != <<= >>=
>>>= . [ ] ( )
Outros Separadores
Os caracteres abaixo so reservados para uso como sinais de pontuao e no podem ser
utilizados com outra finalidade.
{ } ; , :
Comentrios
Em Java existem trs formas de escrever comentrios:

Iniciando o comentrio com os caracteres /* e terminando com os caracteres */
Iniciando o comentrio com os caracteres // e terminando no final da linha
Iniciando o comentrio com os caracteres /** e terminando com os caracteres */
Sada de Dados
Para escrever na sada padro, basta o envio da mensagem System.out.print (para escrever
sem pular de linha) ou System.out.println (para escrever e em seguida pular para a prxima
linha). Essas mensagens aceitam um nico parmetro (aquilo que desejamos escrever).
Para escrever na sada padro de erros, basta o envio da mensagem System.err.print (para
escrever sem pular de linha) ou System.err.println (para escrever e em seguida pular para a
prxima linha). Essas mensagens aceitam um nico parmetro (aquilo que desejamos
escrever).
Cadeias de caracteres podem ser escritas delimitadas por aspas (). Se desejarmos escrever
vrios tens com o envio de uma nica mensagem, basta separ-los por um sinal de mais
(+).
Classes
Classes so definidas mencionando a palavra chave class, seguida pelo identificador da
classe, seguido por uma srie de definies de variveis (que servem ao propsito de definir
a estrutura necessria para representar o estado interno da classe e de suas instncias) e
funes (que servem ao propsito de definir as aes de que dispem a classe e suas
instncias para responder mensagens que lhes sejam enviadas) delimitados por um par de
chaves ({}). Chamamos essas variveis e funes de membros da classe.
Toda classe que deve ser capaz de ser executada deve possuir uma funo de nome main
que representa o local de incio da execuo do programa. Esta funo dever receber um
vetor de objetos da classe String de tamanho indefinido (cada objeto do vetor representa um
parmetro fornecidos ao programa na linha de comando) e no dever possuir retorno.

[C:\ExplsJava\Expl_01\Primeiro.java]

class BoasVindas
{
public static void main(String args [])
{
System.out.println ();
System.out.println ("Bem vindos ao estudo de JAVA!");
}
}

Compilao e Execuo
O programa acima, para poder ser executado, dever primeiro ser compilado atravs do
seguinte comando:
C:\ExplsJava\Expl_01> javac *.java
O compilador Java gera, para cada classe presente no arquivo compilado, um arquivo com
os ByteCodes resultantes de sua compilao. Tais arquivos recebem sempre o mesmo nome
da classe qual se referem e tm extenso .class.
Assim, aps ter sido dado o comando acima, ter sido gerado em disco um arquivo de nome
BoasVindas.class. Para executar seu programa, basta dar o seguinte comando:
C:\ExplsJava\Expl_01> java BoasVindas
Isso produzir no console a seguinte sada:
Bem vindos ao estudo de JAVA!
Tipos Bsicos
1. Inteiros:
Os tipos inteiros permitem a declarao de variveis capazes de armazenar nmeros
inteiros. Existem em quatro tamanhos, a saber:
byte: 8 bits (de -128 a 127);

short: 16 bits (de -32768 a 32767);
int: 32 bits (de -2147483648 a 2147483647);
long 64 bits (de -9223372036854775808 a 9223372036854775807).
2. Reais:
Os tipos reais permitem a declarao de variveis capazes de armazenar nmeros reais.
Existem em dois tamanhos, a saber:
float: 32 bits (de 3,4 x 10
-38
a 3,4 x 10
+38
);
double: 64 bits (de 1,7 x 10
-308
a 1,7 x 10
+308
).
3. char:
O tipo char permite a declarao de variveis que ocupam 16 bits e que so capazes de
armazenar um nico caractere. Java no emprega o conjunto ASCII, mas sim o conjunto
de caracteres UNICODE, no qual existem 65536 caracteres diferentes.
4. boolean:
O tipo boolean permite a declarao de variveis booleanas (ou lgicas). Variveis
desse tipo so capazes de armazenar valores que expressam a verdade ou a falsidade.
5. void:
O tipo void especifica um conjunto vazio de valores. Ele usado como tipo de retorno
para funes que no retornam nenhum valor. No faz sentido declarar variveis do tipo
void.
Classes Wrapper
A Classe Number
A classe Number uma classe que oferece uma interface com todos os tipos escalares
padro: int, long, float e double. Possui mtodos que retornam o valor potencialmente

arredondados do objeto em cada um desses tipos escalares. Veja na documentao da
linguagem a interface que a classe especifica para ser compartilhada por todas aquelas
classe que dela derivarem.
A Classe Integer
Derivada da classe Number, a classe Integer possui tambm outros membros alm daqueles
herdados de sua classe base. Veja na documentao da linguagem a interface que a classe
especifica para comunicao com ela prpria e com suas instncias.
A Classe Long
A Classe Float
A Classe Double
A classe Boolean
Veja na documentao da linguagem a interface que a classe especifica para comunicao
com ela prpria e com suas instncias.

A classe Character
Constantes
Constantes so instncias de tipos das linguagens. Temos duas variedades de constantes, a
saber, constantes literais e constantes simblicas.
Constantes Literais
Constantes literais so aquelas que especificam literalmente uma instncia de um tipo da
linguagem. A seguir apresentaremos as constantes literais existentes na linguagem Java.
1. Constantes Literais do Tipo Inteiro
Uma constante inteira constituda por uma seqncia de dgitos (eventualmente
precedida por um hfen indicando sinal negativo).
Se terminar com letra l (ou L) ser considerada do tipo long, caso contrrio, ser
considerada do tipo int.
Se no comear com um dgito 0, ser considerada decimal.
Se for precedida por 0x (ou 0X) ser considerada hexadecimal. Neste caso, alm dos
dgitos, tambm as letras de a (ou A) at f (ou F) podem ser empregadas.
Se for precedida por 0, ser considerada octal. Neste caso os dgitos 8 e 9 no podem ser
empregados, j que no so dgitos octais vlidos.
2. Constantes Literais do Tipo Real
Uma constante real constituda por uma constante inteira (indicando a parte inteira da
constante real), seguido pelo caractere ponto (indicando o ponto decimal), seguido por
outra constante inteira (indicando a parte fracionria da constante real), seguido pelo

caractere e (ou E) e por outra constante inteira (indicando a multiplicao por uma
potncia de 10).
Se terminar com letra f (ou F) ser considerada do tipo float, caso contrrio, ser
considerada do tipo double. Tambm ser considerada do tipo double se terminar com a
letra d (ou D).
Tanto a parte inteira como a parte fracionria podem ser omitidas (mas no ambas).
Tanto o ponto decimal seguida da parte fracionria como o e (ou E) e o expoente
podem ser omitidos (mas no ambos). O sufixo de tipo tambm pode ser omitido.
3. Constantes Literais do Tipo char
Uma constantes caractere constituda por um nico caracteres delimitado por
apostrofes (c). Constantes caractere so do tipo char.
Certos caracteres no visveis, o apstrofe (), as aspas () e a barra invertida (\) podem
ser representados de acordo com a seguinte tabela de seqncias de caracteres:
\b retrocesso (backspace)
\t tabulao (tab)
\n nova linha (new line)
\f avano de formulrio (form feed)
\r retorno do carro (carriage return)
\ apstrofe (single quote)
\ aspas (double quote)
\\ barra invertida (backslash)
\uHHHH caractre unicode (HHHH em hexa)
Uma seqncia como estas, apesar de constitudas por mais de um caractere,
representam um nico caractere.
4. Constantes do Tipo boolean

Existem somente duas constantes booleanas, a saber: true e false.
5. Constantes do Tipo String
Toda constante literal da classe String constituda por uma seqncia de zero ou mais
caracteres delimitados por aspas ().
Constantes Simblicas
Constantes simblicas so aquelas que associam um nome a uma constante literal, de forma
que as referenciamos no programa pelo nome, e no pela meno de seu valor literal.
Somente podem ser definidas diretamente dentro de uma classe, ou, em outras palavras, no
podem ser definidas localmente a um bloco de comandos subordinado a um mtodo.
Sendo Tipo um tipo, Const
i
nomes de identificadores e Expr
i
expresses que resultam em
valores do tipo Tipo, temos que a forma geral de uma declarao de constantes simblicas
como segue:
final Tipo Const
1
= Expr
1
, Const
2
= Expr
2
,, Const
n
= Expr
n
;
Cadeias de Caracteres
A Classe String
Esta classe implementa objetos que representam cadeias de caracteres. Tais objetos so
inalterveis uma vez criados. Veja na documentao da linguagem a interface que a classe
A Classe StringBuffer
Esta classe implementa objetos que representam cadeias de caracteres alterveis aps terem
sido criadas. Veja na documentao da linguagem a interface que a classe especifica para
comunicao com ela prpria e com suas instncias.

A Classe StringTokenizer
Esta classe implementa mtodos capazes de quebrar um string em tokens. O delimitador
pode ser especificado quando da instanciao da classe ou a cada token. Tem-se que o
delimitador default o caractere espao em branco.
Classes que fazem uso desta classe em sua implementao, devem ter logo no incio do
arquivo onde forem definidas a seguinte diretiva:
import java.util.StringTokenizer;
ou
import java.util.*;
Funes ou Mtodos
Convencionalmente entendemos que funes so abstraes de processo, i.e., pelo nome de
uma funo identificamos e ativamos o processo que ela abstrai, e atravs de seu retorno e
de seus eventuais efeitos colaterais obtemos os resultados de seu processamento.
Num programa orientado a objetos, no entanto, entendemos que as funes representam a
descrio das aes que uma classe ou um objeto dispes a fim de responder mensagens
que lhes so dirigidas.
Por isso entendemos que toda funo est vinculada uma classe ou a um objeto, i.e., no
faz sentido imaginar uma funo avulsa como temos em um programa convencional e, no
contexto da programao orientada a objetos, so costumeiramente chamadas de mtodos.
Alm disso, entendemos que a chamada de um mtodo representa o envio de uma
mensagem classe ou ao objeto ao qual ela se vincula, e que seu retorno representa a
resposta quela mensagem.

Por isso no faz sentido simplesmente chamar uma funo como fazemos numa linguagem
convencional. J que entendemos chamadas de mtodos como o envio de uma mensagem,
preciso mencionar o destinatrio dessa mensagem, i.e., a classe ou o objeto que dever
receb-la.
Mtodos so definidos mencionando o tipo do retorno do mtodo, seguido pelo
identificador do mtodo, seguido por um par de parnteses (()) contendo, opcionalmente, a
lista dos parmetros formais do mtodo, seguido por um bloco de comandos representando
o corpo do mtodo.
Uma lista de parmetros formais nada mais do que uma srie de definies de parmetros
formais separadas por vrgulas (,). A definio de um parmetro formal feita mencionando
o nome do tipo do parmetro e em seguida o identificador do parmetro formal.
importante ressaltar que, em Java, a nica mecanismo de passagem de parmetro a
passagem por valor.
No existe em Java o conceito de procedimento, muito embora possamos definir funes
que no retornam valor nenhum, o que d no mesmo. Isto pode ser feito dizendo que o tipo
do retorno da funo void.
O comando return seguido pela expresso cujo valor se de deseja retornar empregado
para fazer o retorno do resultado do mtodo a seu chamante.
Variveis ou Atributos
Convencionalmente entendemos que variveis so clulas de memria capazes de
armazenarem valores para serem futuramente recuperados.
Num programa orientado a objetos, no entanto, o principal papel das variveis o de
representar os atributos de uma classe ou objeto ou, em outras palavras, representar o estado
interno de uma classe ou de um objeto.

Variveis so definidas quando mencionamos o nome de um tipo, e em seguida uma srie
de identificadores separados por vrgulas (,) e tendo no final um ponto-e-vrgula (;). Cada
um dos identificadores ser uma varivel do tipo que encabeou a definio.
Sendo Tipo um tipo e Var
i
nomes de identificadores, temos que a forma geral de uma
declarao de variveis como segue:
Tipo Var
1
, Var
2
,, Var
n
;
Variveis podem ser iniciadas no ato de sua definio, i.e., podem ser definidas e receber
um valor inicial. Isto pode ser feito acrescentando um sinal de igual (=) e o valor inicial
desejado imediatamente aps o identificador da varivel que desejamos iniciar.
Sendo Tipo um tipo, Var
i
nomes de identificadores e Expr
i
expresses que resultam em
valores do tipo Tipo, temos que a forma geral de uma declarao de variveis iniciadas
como segue:
Tipo Var
1
= Expr
1
, Var
2
= Expr
2
,, Var
n
= Expr
n
;
Variveis locais e globais
Em Java poderemos ainda encontrar variveis locais servindo a propsitos temporrios.
No existem variveis globais em Java.
Acessibilidade de Membros
Atributos e mtodos podem ser coletivamente chamados de membros. Podemos estabelecer
trs nveis de acessibilidade de membros, o que feito pelo uso de qualificadores
especficos. Nesta seo estudaremos dois desses modificadores: o modificador public e
o modificador private.
Membros qualificados com public so acessveis a qualquer mtodo, seja ele tambm
membro da classe ou no. Membros qualificados como private so acessveis somente aos
mtodos escritos na prpria classe.

Um programador disciplinado evita qualificar dados variveis membro com public, j que o
principal papel destes descrever o estado interno de classes e objetos (e como o prprio
nome diz, o estado interno deve ser interno).
O mesmo no diramos com respeito aos dados constantes (qualificados com final), que
podem perfeitamente serem qualificados com public sem qualquer prejuzo.
Um programador disciplinado tambm evita qualificar indiscriminadamente funes
membro com public. Apenas as funes que descrevem as aes que servem para
responder a mensagens externas classe devem ser pblicas.
Entrada de Dados
Existem algumas alternativas para fazer entrada de dados:
1. A primeira delas, que passaremos, ora, a abordar, exige que se importe, antes de mais
nada, da biblioteca de entrada e sada, as classes necessrias. Para tanto, os comandos
abaixo devem ser includos no ncio do arquivo no qual acontecero operaes de
entrada:
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
ou
import java.io.*;
Mais adiante, neste texto, teremos a oportunidade de compreender melhor as razes da
exigncia que ora ser feita, bem como de conhecer alternativas que permitiriam
descumpr-la. No momento, diremos que preciso que toda funo que realiza operaes de
entrada, assim como toda funo que a ativar direta ou indiretamente uma funo que
realize operaes de entrada, tenham acrescentado no final do seu cabealho a expresso:
throws IOException

Deve-se ento declarar um objeto da classe BufferedReader que atuar como um prestador
de servios de entrada de dados. Isto pode ser feito como segue:
BufferedReader leitor = new BufferedReader (new InputStreamReader (System.in));
Objetos da classe BufferedReader, como o caso do objeto Entrada, somente podem ser
usados para ler cadeias de caracteres. A solicitao deste servio pode ser feita como no
comando abaixo:
String linha = leitor.readline ();
Cadeias de caracteres que contm somente caracteres que conformam constantes literais dos
tipos primitivos da linguagem Java, podem ser convertidas nesses mesmos tipos conforme
segue:
Converso de String para char:
char C = linha.charAt (0);
Converso de String para byte:
byte b = Byte.parseByte (linha);
ou, se preferirmos,
byte b = new Byte (linha).byteValue ();
ou, se preferirmos,
byte b = Byte.valueOf (linha).byteValue ();
Converso de String para short:
short s = Short.parseShort (linha);
ou, se preferirmos,
short s = new Short (linha).shortValue ();
ou, se preferirmos,
short s = Short.valueOf (linha).shortValue ();
Converso de String para int:
int i = Integer.parseInt (linha);
ou, se preferirmos,

int i = new Integer (linha).intValue ();
ou, se preferirmos,
int i = Integer.valueOf (linha).intValue ();
Converso de String para long:
long l = Long.parseLong (linha);
ou, se preferirmos,
long l = new Long (linha).longValue ();
ou, se preferirmos,
long l = Long.valueOf (linha).longValue ();
Converso de String para float:
float f = Float.parseFloat (linha);
ou, se preferirmos,
float f = new Float (linha).floatValue ();
ou, se preferirmos,
float f = Float.valueOf (linha).floatValue ();
Converso de String para double:
double d = Double.parseDouble (linha);
ou, se preferirmos,
double d = new Double (linha).doubleValue ();
ou, se preferirmos,
double d = Double.valueOf (linha).doubleValue ();
Converso de String para boolean:
boolean b = Boolean.parseBoolean (linha);
ou, se preferirmos,
boolean b = new Boolean (linha).booleanValue ();
ou, se preferirmos,
boolean b = Boolean.valueOf (linha).booleanValue ().
[C:\ExplsJava\Expl_02\BoasVindas.java]


class BoasVindas
{
public static void main (String args []) throws IOException
{
BufferedReader leitor = new BufferedReader (
new InputStreamReader (
System.in));


System.out.print ("Qual o seu nome? ");
String nome = leitor.readline ();

System.out.println ("Bem vindo(a) ao estudo de JAVA, " +
nome +
"!");


System.out.print ("Com que nota voce pretende passar? ");

float nota = Float.parseFloat (leitor.readline ());
/*
ou
float nota = Float.valueOf (leitor.readline ()).intValue ();
ou
float nota = new Float (leitor.readline ()).intValue ();
*/


System.out.println (nome +
", desejo sucesso a voce;");

System.out.println ("que voce passe com " +
nota +
" ou mais!");

}
}

Para compilar e executar este programa, daremos os seguintes comandos:
C:\ExplsJava\Expl_02> java BoasVindas
Isto poderia produzir no console a seguinte interao:

Qual o seu nome? Jose
Bem vindo ao estudo de JAVA, Jose!

Com que nota voce pretende passar? 7.0
Jose, desejo sucesso a voce;
que voce passe com 7.0 ou mais!
2. A segunda delas, que passaremos, ora, a abordar, exige que se importe, antes de mais
nada, da biblioteca de entrada e sada, as classes necessrias. Para tanto, os comandos
abaixo devem ser includos no ncio do arquivo no qual acontecero operaes de
entrada:
A Classe Math
A classe Math contm muitas funes matemticas teis, bem como muitas constantes
tambm teis. A classe Math no deve ser instanciada e, como trata-se de uma classe final,
no pode ser usada como base para derivao de outra classe.
com ela prpria.
Expresses
Uma expresso uma seqncia de operadores e operandos que especifica um computao
e resulta um valor.
A ordem de avaliao de subexpressses determinada pela precedncia e pelo
agrupamento dos operadores. As regras matemticas usuais para associatividade e
comutatividade de operadores podem ser aplicadas somente nos casos em que os
operadores sejam realmente associativos e comutativos.
A ordem de avaliao dos operandos de operadores individuais indefinida. Em particular,
se um valor modificado duas vezes numa expresso, o resultado da expresso
indefinido, exceto no caso dos operadores envolvidos garantirem alguma ordem.

Operadores Aritmticos Convencionais
Os operadores aritmticos da linguagem Java so, em sua maioria, aqueles que usualmente
encontramos nas linguagens de programao imperativas. Todos eles operam sobre
nmeros e resultam nmeros. So eles:
1. + (soma);
2. - (subtrao);
3. * (multiplicao);
4. / (diviso);
5. % (resto da diviso inteira); e
6. - (menos unrio).
No existe em Java um operador que realize a diviso inteira, ou, em outras palavras, em
Java uma diviso sempre resulta um nmero real. Para resolver o problema, podemos
empregar um converso de tipo para forar o resultado da diviso a ser um inteiro. Neste
caso, o real resultante ter truncada a sua parte fracionria, se transformando em um inteiro.
O operador % (resto da diviso inteira) opera sobre dois valores integrais. Seu resultado
tambm ser um valor integral. Ele resulta o resto da diviso inteira de seu primeiro
operando por seu segundo operando.
O operador - (menos unrio) opera sobre um nico operando, e resulta o nmero que se
obtm trocando o sinal de seu operando.
Operadores de Incremento e Decremento
Os operadores de incremento e decremento da linguagem Java no so usualmente
encontrados em outras linguagens de programao. Todos eles so operadores unrios e
operam sobre variveis inteiras e resultam nmeros inteiros. So eles:
1. ++ (prfixo);

2. -- (prfixo);
3. ++ (psfixo);
4. -- (psfixo).
O operador ++ (prfixo) incrementa seu operando e produz como resultado seu valor (j
incrementado).
O operador -- (prfixo) decrementa seu operando e produz como resultado seu valor (j
decrementado).
O operador ++ (psfixo) incrementa seu operando e produz como resultado seu valor
original (antes do incremento).
O operador -- (psfixo) decrementa seu operando e produz como resultado seu valor
original (antes do decremento).
Observe, abaixo, uma ilustrao do uso destes operadores:
...
int a=7, b=13, c;
System.out.println (a+" "+b); // 7 13

a--; b++;

--a; ++b;

c = a++ + ++b;
System.out.println (a+" "+b+" "+c); // 6 16 21
...
Operadores Relacionais
Os operadores relacionais da linguagem Java so, em sua maioria, aqueles que usualmente
encontramos nas linguagens de programao imperativas. Todos eles operam sobre
nmeros e resultam valores lgicos. So eles:
1. == (igualdade);
2. != (desigualdade);

3. < (inferioridade);
4. <= (inferioridade ou igualdade);
5. > (superioridade); e
6. >= (superioridade ou igualdade).
Operadores Lgicos
Os operadores lgicos da linguagem Java so, em sua maioria, aqueles que usualmente
encontramos nas linguagens de programao imperativas. Todos eles operam sobre valores
lgicos e resultam valores lgicos. So eles:
1. && (conjuno ou and);
2. || (disjuno ou or); e
3. ! (negao ou not).
Operadores de Bit
Os operadores de bit da linguagem Java so, em sua maioria, aqueles que usualmente
encontramos nas linguagens de programao imperativas. Todos eles operam sobre valores
integrais e resultam valores integrais. So eles:
1. & (and bit a bit);
2. | (or bit a bit);
3. ^ (xor bit a bit);
4. ~ (not bit a bit);
5. << (shift left bit a bit); e
6. >> (shift right bit a bit).

...
short a,
b=0x7C3A, // 0111 1100 0011 1010
c=0x1B3F; // 0001 1011 0011 1111

a = b & c; // 0001 1000 0011 1010
a = b | c; // 0111 1111 0011 1111
a = b ^ c; // 0110 0111 0000 0101
a = ~b; // 1000 0011 1100 0101
a = b << 3; // 1110 0001 1101 0000
a = c >> 5; // 0000 0000 1101 1001
...
A Classe BitSet
Esta classe implementa um tipo de dados que representa uma coleo de bits. A coleo
crescer dinamicamente a medida que mais bits forem necessrios. Bits especficos so
identificados por um inteiro no negativo. O primeiro bit sempre o de ordem zero.
import java.util.BitSet;
ou
import java.util.*;
Converses de Tipo
Expresses podem ser foradas a resultar um certo tipo se precedidas pelo tipo desejado
entre parnteses.
Sendo Tipo um tipo e Expr uma expresso que resulta um valor que no do tipo Tipo,
temos que:
(Tipo) Expr
resulta a expresso Expresso convertida para o tipo Tipo.
Observe, abaixo, uma ilustrao do uso deste operador:

...
int a = 65;
char c = (char)a;

System.out.println (c); // A
...
Operadores combinados com Atribuio
Os operadores aritmticos e de bit podem ser combinados com o operador de atribuio
para formar um operador de atribuio com operao embutida.
Sendo Var uma varivel, Opr um operador aritmtico ou de bit e Expr uma expresso,
temos que:
Var Opr= Expr;
equivalente a
Var = Var Opr (Expr);
...
short a, b, c, d, e;

a = a + (3 * b); // a += 3*b;
b = b / (a - Math.sin (a)); // b /= a-Math.sin(a);
c = c << d; // c <<= d;
d = d & (a + b); // d &= a+b;
e = e >> (d + 3); // e >>= d+3;
...
Expresses Condicionais
Expresses condicionais representam uma forma compacta de escrever comandos a escolha
de um dentre uma srie possivelmente grande de valores. Substituem uma seqncia de ifs.
Sendo Cond uma condio booleana e Expr
i
expresses, temos que:
Condio? Expr
1
: Expr
2

resulta Expr
1
no caso de Cond ser satisfeita, e Expr
2
, caso contrrio.
Observe, abaixo, uma ilustrao do uso deste operador:

...
int a, b;
...
System.out.println (a>b?a:b);
...
equivale a
...
int a, b;
...
int maior;

if (a>b)
maior = a;
else
maior = b;

System.out.println (maior);
...
[C:\ExplsJava\Expl_03\RaizEquacao.java]


class RaizEquacao
{
{
BufferedReader leitor = new BufferedReader
(new InputStreamReader
(System.in));

System.out.print ("PROGRAMA PARA CALCULAR RAIZ");
System.out.print (" DE EQUACAO DE 1o GRAU");

System.out.print ("Coeficiente a: ");
double a = Double.parseDouble (leitor.readLine ());

System.out.print ("Coeficiente b: ");
double b = Double.parseDouble (leitor.readLine ());

double raiz = -b/a;

System.out.println ("Raiz: " + raiz);
}
}


C:\ExplsJava\Expl_03> java RaizEquasao
PROGRAMA PARA CALCULAR RAIZ DE EQUACAO DE 1
o
GRAU

Coeficiente a: 2
Coeficiente b: -10

Raiz: 5
Comandos
Comandos so a unidade bsica de processamento. Em Java no existe um repertrio muito
vasto de comandos. Muitos comandos que em outras linguagens existem, em Java so
encontrados em bibliotecas de classe.
Comandos em Java, salvo raras excees, so terminados por um ponto-e-vrgula (;).
O Comando de Atribuio
O comando de atribuio tem a seguinte forma bsica: em primeiro lugar vem o
identificador da varivel receptora da atribuio, em seguida vem o operador de atribuio
(=), em seguida vem a expresso a ser atribuda, em seguida vem um ponto-e-vrgula (;).
Sendo Var o identificador de uma varivel e Expr uma expresso, temos abaixo a forma
geral do comando de atribuio:
Var = Expr;
Blocos de Comando
J conhecemos o conceito de bloco de comandos, que nada mais do que uma srie de
comandos delimitada por um par de chaves ({}).

Blocos de comando determinam um escopo de declaraes e nunca so terminados por
ponto-e-vrgula (;).
Blocos de comando so muito teis para proporcionar a execuo de uma srie de
subcomandos de comandos que aceitam apenas um subcomando.
O Comando if
O comando if tem a seguinte forma bsica: em primeiro lugar vem a palavra-chave if,
em seguida vem, entre parnteses, a condio a ser avaliada, em seguida vem o comando a
ser executado no caso da referida condio se provar verdadeira.
Sendo Cond uma condio booleana e Cmd um comando, temos abaixo a forma geral do
comando if (sem else):
if (Cond)
Cmd;
O comando if pode tambm executar um comando, no caso de sua condio se provar
falsa. Para tanto, tudo o que temos que fazer continuar o comando if que j conhecemos,
lhe acrescentando a palavra chave else, e em seguida o comando a ser executado, no caso
da referida condio se provar falsa.
Sendo Cond uma condio booleana e Cmd
i
dois comandos, temos abaixo forma geral do
comando if com else:
if (Cond)
Cmd
1
;
else
Cmd
2
;
Observe que, tanto no caso da condio de um comando if se provar verdadeira, quanto no
caso dela se provar falsa, o comando if somente pode executar um comando. Isso nem
sempre, ou melhor, quase nunca satisfatrio; comum desejarmos a execuo de mais de
um comando.

Por isso, nos lugares onde se espera a especificao de um comando, podemos especificar
um bloco de comandos.
O Comando switch
O comando switch tem a seguinte forma: em primeiro lugar vem a palavra-chave
switch, em seguida vem, entre parnteses, uma expresso integral a ser avaliada, em
seguida vem, entre chaves ({}), uma srie de casos.
Um caso tem a seguinte forma bsica: em primeiro lugar vem a palavra-chave case, em
seguida vem uma constante integral especificando o caso, em seguida vem o caractere dois
pontos (:), em seguida vem uma srie de comandos a serem executados no caso.
Sendo Expr uma expresso, Const
I
constantes literais do mesmo tipo que Expr e Cmd
IJ

comandos, temos abaixo uma das formas gerais do comando switch:
switch (Expr)
{
case Const
1
: Cmd
1a
;
Cmd
1b
;

case Const
2
: Cmd
2a
;
Cmd
2b
;

case Const
3
: Cmd
3a
;
Cmd
3b
;

}
Se, em alguma circunstncia, desejarmos executar uma mesma srie de comandos em mais
de um caso, tudo o que temos a fazer especificar em seqncia os casos em questo,
deixando para indicar somente no ltimo deles a referida seqncia de comandos.
I,J
IJ

switch (Expr)
{
case Const
1,1
:

case Const
1,2
:
Cmd
1a
;
Cmd
1b
;

case Const
2,1
:
case Const
2,2
:
Cmd
2a
;
Cmd
2b
;

case Const
3,1
:
case Const
3,2
:
Cmd
3a
;
Cmd
3b
;

}
Se, em alguma circunstncia, desejarmos executar uma srie de comandos qualquer que
seja o caso, tudo o que temos a fazer especificar um caso da forma: em primeiro lugar
vem a palavra-chave default, em seguida vem o caractere dois pontos (:), em seguida
vem uma srie de comandos a serem executados qualquer que seja o caso.
I,J
IJ

switch (Expr)
{
case Const
1,1
:
case Const
1,2
:
Cmd
1a
;
Cmd
1b
;

case Const
2,1
:
case Const
2,2
:
Cmd
2a
;
Cmd
2b
;

default: Cmd
Da
;
Cmd
Db
;

}

importante ficar claro que o comando switch no se encerra aps a execuo da seqncia
de comandos associada a um caso; em vez disso, todas as seqncias de comandos,
associadas aos casos subseqentes, sero tambm executadas.
Se isso no for o desejado, basta terminar cada seqncia (exceto a ltima), com um
comando break.
I,J
IJ

comandos, temos abaixo uma das formas gerais do comando switch com breaks:
switch (Expr)
{
case Const
1,1
:
case Const
1,2
:
Cmd
1a
;
Cmd
1b
;

break;
case Const
2,1
:
case Const
2,2
:
Cmd
2a
;
Cmd
2b
;

break;

default: Cmd
Da
;
Cmd
Db
;

}
Observe, abaixo, uma ilustrao do uso deste comando:
...
int a, b, c;
char operacao;
...
switch (operacao)
{
case +: a = b + c;
break;

case -: a = b - c;
break;

case *: a = b * c;

break;

case /: a = b / c;
}

System.out.println (a);
...
O Comando while
O comando while tem a seguinte forma bsica: em primeiro lugar vem a palavra-chave
while, em seguida vem, entre parnteses, a condio de iterao, em seguida vem o
comando a ser iterado. A iterao se processa enquanto a condio de iterao se provar
verdadeira.
comando while:
while (Cond)
Cmd;
Observe que, conforme especificado acima, o comando while itera somente um comando.
Isso nem sempre, ou melhor, quase nunca satisfatrio; comum desejarmos a iterao de
um conjunto no unitrio de comandos.
Por isso, em lugar de especificar o comando a ser iterado, podemos especificar um bloco de
comandos. Assim conseguiremos o efeito desejado.
O Comando do-while
O comando do-while tem a seguinte forma bsica: em primeiro lugar vem a
palavra-chave do, em seguida vem o comando a ser iterado, em seguida vem a palavra-
chave while, em seguida vem, entre parnteses, a condio de iterao. A iterao se
processa enquanto a condio de iterao se provar verdadeira.
A diferena que este comando tem com relao ao comando while que este comando
sempre executa o comando a ser iterado pelo menos uma vez, j que somente testa a
condio de iterao aps t-lo executado. J o comando while testa a condio de

iterao antes de executar o comando a ser iterado, e por isso pode parar antes de execut-lo
pela primeira vez.
comando do-while:
do
Cmd;
while (Cond);
Observe que, conforme especificado acima, o comando do-while itera somente um
comando. Isso nem sempre, ou melhor, quase nunca satisfatrio; comum desejarmos a
iterao de um conjunto no unitrio de comandos.
Por isso, em lugar de especificar o comando a ser iterado, podemos especificar um bloco de
comandos. Assim, conseguiremos o efeito desejado.
O Comando for
O comando for tem a seguinte forma bsica: em primeiro lugar vem a palavra-chave for,
em seguida vem, entre parnteses e separadas por pontos-e-vrgulas (;), a sesso de
iniciao, a condio de iterao, e a sesso de reiniciao. Em seguida vem o comando a
ser iterado. A iterao se processa enquanto a condio de iterao se provar verdadeira.
No caso de haver mais de um comando na sesso de iniciao ou na sesso de reiniciao,
estes devem ser separados por virgulas (,).
Sendo Cmd
I,i
, Cmd
R,i
e Cmd comandos, e Cond uma condio booleana, temos abaixo a
forma geral do comando for (os nmeros indicam a ordem de execuo das partes do
comando for):

for (Cmd
I,1
, Cmd
I,2
,... ; Cond; Cmd
R,1
, Cmd
R,2
,...) Cmd;
1 2 3
5 4 6
8 7 9
11 10 12
... ...

n n-1
Observe que, conforme especificado acima, o comando for itera somente um comando.
Isso nem sempre, ou melhor, quase nunca satisfatrio; comum desejarmos a iterao de
um conjunto no unitrio de comandos.
Por isso, no lugar onde se espera a especificao de um comando, podemos especificar um
bloco de comandos. Assim, conseguiremos o efeito desejado.
Observe, abaixo, uma ilustrao do uso deste comando, que escreve na tela 10 vezes a frase
Java e demais!:
...
for (int i=1; i<=10; i++)
System.out.println ("Java e demais!");
...
equivale a
...
int i;

for (i=1; i<=10; i++)
...
equivale a
...
int i=1;

for (; i<=10; i++)
...
equivale a
...
int i=1;

for (; i<=10;)
{
i++;
}
...
equivale a

...
int i=1;

for (;;)
{
i++;
if (i>10) break;
}
...
Observe, abaixo, outra ilustrao do uso deste comando, que inverte um vetor v de 100
elementos:
...
for (int i=0, j=99; i<j; i++, j--)
{
int temp = v[i];
v[i] = v[j];
v[j] = temp;
}
...
O Comando continue
O comando continue fora o reinicio de uma nova iterao nos comandos while, do-while e
for. Existem duas variaes deste comando: a primeira, simplesmente
continue;
provoca o reincio imediato de uma nova iterao do comando iterativo, dentro do qual se
encontra encaixado mais diretamente; e a segunda,
continue Rotulo;
provoca o reincio imediato de uma nova iterao do comando iterativo rotulado com
Rotulo (para rotular um comando, basta preceder-lhe com o identificador do rotulo seguido
pelo caractere dois-pontos).
Observe, abaixo, uma ilustrao do uso deste comando, que escreve na tela os nmeros de 1
a 7, inclusive, seguidos pelos nmeros de 17 a 20, inclusive:
...
int i = 0;

while (i<20)
{

i++;
if (i>7 && i<17) continue;
System.out.println (i);
}
...
Observe, abaixo, outra ilustrao do uso deste comando:
...
loop_de_fora: while (cond1)
{
...
while (cond2)
{
...
if (cond3) continue loop_de_fora;
...
}
...
}
...
O Comando break
O comando break fora a sada imediata dos comandos while, do-while, for e switch (veja
abaixo os comandos while, do-while e for). Existem duas variaes deste comando: a
primeira, simplesmente
break;
provoca a sada imediata do comando while, do-while, for ou switch, dentro do qual se
encontra encaixado mais diretamente; e a segunda,
break Rotulo;
provoca a sada imediata do comando while, do-while, for ou switch rotulado com Rotulo
(para rotular um comando, basta preceder-lhe com o identificador do rotulo seguido pelo
caractere dois-pontos).
Observe, abaixo, uma ilustrao do uso deste comando, que escreve na tela os nmeros de 1
a 7, inclusive:
...
int i = 0;

while (i<20)
{

i++;
if (i>7 && i<17) break;
System.out.println (i);
}
...
Observe, abaixo, outra ilustrao do uso deste comando:
...
loop_de_fora: while (cond1)
{
...
while (cond2)
{
...
if (cond3) break loop_de_fora;
...
}
...
}
...
[C:\ExplsJava\Expl_04\Fatorial.java]


class Fatorial
{
{
(System.in));
int numero;

System.out.println ("PROGRAMA PARA CALCULAR FATORIAL");

for (;;)
{
System.out.print ("Digite um numero natural: ");
double numeroDigitado = Double.parseDouble
(leitor.readLine ());

if (numeroDigitado < 0.0)
{
System.err.print ("Numeros naturais nao ");
System.err.println ("podem ser negativos!");
System.err.println ("Tente novamente...");
}
else

{
numero = (int)numeroDigitado;

if (numero != numeroDigitado)
{
System.err.print ("Numeros naturais nao podem");
System.err.println ("ter parte fracionaria!");
System.err.println ("Tente novamente...");
}
else
break;
}
}

int fatorial=1;

while (numero > 1)
{
fatorial = fatorial*numero;
numero--;
}

System.out.println ("Resultado: " + fatorial);
}
}

C:\ExplsJava\Expl_04> java Fatorial
PROGRAMA PARA CALCULAR FATORIAL

Digite um numero natural: -2
Nmeros naturais nao podem ser negativos!
Tente novamente...

Digite um numero natural: -5.7
Nmeros naturais nao podem ter parte fracionaria!
Tente novamente...

Digite um numero natural: 5
Resultado: 120

Membros de Classe e de Instncia
Diferenciamos os membros de classe dos membros de instncia atravs de um qualificador.
Membros sero de classe se forem precedidos pelo qualificador static, e sero de
instncias caso contrrio.
Existem 3 formas para acessar membros, a saber:
1. Acesso Simples:
Chamamos de acesso simples aqueles acesso nos quais, para acessar um membro,
simplesmente mencionamos o nome do membro. So simples os seguintes acessos:
Funes de uma classe acessando membros de classe de sua prpria classe (neste
caso o acesso tambm pode ser feito mencionando o nome de sua classe, seguido
pelo caractere ponto, seguido pelo nome do membro que se deseja acessar);
Funes de uma instncia de classe acessando membros de classe sua prpria classe
(neste caso o acesso tambm pode ser feito mencionando o nome de sua classe,
seguido pelo caractere ponto, seguido pelo nome do membro que se deseja acessar);
Funes membro de uma instncia de classe acessando membros de instncia de
classe de sua prpria instncia de classe (neste caso o acesso tambm pode ser feito
mencionando a palavra chave this, seguida pelo caractere ponto, seguido pelo nome
do membro que se deseja acessar).
2. Acesso com Nome de Classe:
Todo acesso no simples a um membro de classe se faz mencionando o nome da classe
eu questo, seguido do caractere ponto (.), seguido do nome do membro que se deseja
acessar.
3. Acesso com Nome de Instncia de Classe:
Todo acesso no simples a um membro de uma instncia de classe se faz mencionando
o nome do objeto questo, seguido do caractere ponto (.), seguido do nome do membro
que se deseja acessar.

Construtores de Classe
O autor de uma classe pode controlar como devem ser iniciados os atributos de classe de
uma classe.
Apesar da maioria dos atributos poderem ser iniciados no ato de sua declarao, conforme
explicado anteriormente, certos atributos necessitam de comandos para a realizao de sua
iniciao.
Nestes casos, sendo os atributos que necessitam de comandos para sua iniciao atributos
de classe, deve-se um mtodo construtor de classe (que se vincular classe, ou seja, em
cujo cabealho o qualificador static estar presente). Este tipo de mtodo no produz jamais
retorno (apesar de void no ser usado), no possui um nome, no recebe jamais
parmetros e nem mesmo os parnteses que costumeiramente envolvem os parmetros
formais dos mtodos indicada neste tipo de mtodo.
Excees
O autor de uma biblioteca pode detectar erros com os quais no consegue lidar. O usurio
de uma biblioteca pode querer tratar adequadamente erros que no capaz de detectar. O
conceito de exceo vem para prover meios para resolver este tipo de situao.
A idia fundamental que uma funo que detecta um problema que no capaz de tratar
lana uma exceo que pode ser pega por uma funo que quer tratar o problema mas que
no capaz de detectar.
Uma exceo um objeto que uma instncia da classe Throwable (ou de uma de suas
subclasses).
Mtodos que podem lanar excees devem deixar este fato claro atravs do acrscimo ao
final de seu cabealho da palavra chave throws seguida pelos nomes de todas as excees
possveis de serem lanadas pelo mtodo separadas por virgulas (,).
Quando um mtodo chama outro que, por sua vez pode lanar uma exceo, o primeiro
deve:

1. Tratar a referida exceo; ou
2. Avisar atravs da palavra chave throws o possvel lanamento da referida exceo.
Excees da classe Error ou RunTimeException (e derivadas) no precisam ser
mencionados em um throws porque podem ocorrer em qualquer momento, em qualquer
ponto do programa, por qualquer razo.
Sendo, respectivamente Excecao o identificador de uma exceo e p
i
os identificadores dos
parmetros para o contrutor de Excecao , veja abaixo a forma geral do comando que lana
uma exceo.
throw new Excecao (p
1
, p
2
,, p
n
);
Mtodos que fazem uso de mtodos que lanam excees, podem ser implementados de
duas maneiras:
1. NO detectando, capturando ou tratando as excees dos mtodos chamados:
A chamada dos mtodos que lanam excees deve ocorrer da maneira usual, ou seja,
da mesma forma que usamos para chamar qualquer outro mtodo. Neste caso, o mtodo
chamante dever deixar o fato de que no detecta, captura ou trata excees dos
mtodos chamados atravs do acrscimo ao final de seu cabealho da palavra chave
throws seguida pelos nomes de todas as excees possveis de serem lanadas pelos
mtodos chamados separadas por virgulas (,).
2. DETECTANDO, CAPTURANDO e TRATANDO as excees dos mtodos chamados:
Neste caso, nada acrescentado ao cabealho do mtodo chamante.
J a chamada dos mtodos que lanam excees deve ocorrer da seguinte maneira:
primeiro deve vir a palavra chave try; em seguida deve vir, entre chaves ({}) as
chamadas dos mtodos que podem causar o lanamento de excees.
O processo de lanar e pegar excees envolve uma busca retrgrada por um tratador na
cadeia de ativaes a partir do ponto onde a exceo foi lanada.

A partir do momento que um tratador pega uma exceo j considera-se a exceo
tratada, e qualquer outro tratador que possa ser posteriormente encontrado se torna
neutralizado.
Excees so pegas pelo comando catch. Um try pode ser sucedido por um nmero
arbitrariamente grande de catches, cada qual com o objetivo de tratar uma das vrias
excees que podem ser lanadas dentro do try.
O comando catch tem a seguinte forma geral: primeiro vem a palavra chave catch e, em
seguida, entre parnteses (()), o nome da exceo que deve ser tratada. Logo aps deve
vir, entre chaves ({}), o cdigo que trata a referida exceo.
Aps todos os catches pode vir um finally. O comando finally tem a seguinte forma
geral: primeiro vem a palavra chave finally e, em seguida, vem, entre chaves, o cdigo a
ser executado, em qualquer caso, no final do tratamento das excees
(independentemente do fato de em algum tratamento que o antecedesse executar
comandos que quebram o fluxo de controle, e.g., return, break ou continue).
Uma classe pode lanar vrias excees, e as funes usurias podem ou no peg-las a
todas. Excees no pegas em um certo nvel podem ser pegas em um nvel mais alto.
Tratadores de exceo podem pegar uma exceo mas no conseguir trat-la
completamente.
Neste caso pode ser necessrio um novo lanamento de exceo para provocar um
tratamento complementar em um nvel mais alto.
Getters e Setters
J que os atributos de uma classe, por razes de segurana, devem ser sempre privativos, no
caso de ser necessrio recuperar o valor de um deles, ser necessria a escrita de um mtodo
com esta especfica finalidade. Mtodos cujo propsito consista em recuperar o valor de um
atributo so chamados de getters e seus nomes, por conveno, devem comear com a

palavra get (ou is, caso o atributo a ser recuperado for do tipo boolean), seguido pelo
nome do atributo a ser recuperado.
Ainda levando em conta o fato de que os atributos de uma classe, por razes de segurana,
como j mencionamos acima, devem ser sempre privativos, no caso de ser necessrio
ajustar o valor de um deles, ser necessria a escrita de um mtodo com esta especfica
finalidade. J mtodos cujo propsito consista em ajustar o valor de um atributo,
naturalmente fazendo as devidas consistncias e lanando as devidas excees, so
chamados de setters e seus nomes, por conveno, devem comear com a palavra set,
seguido pelo nome do atributo que ter o valor ajustado pelo mtodo.
[C:\ExplsJava\Expl_05\Fracao.java]

class Fracao
{
private static long numerador, denominador;

static
{
Fracao.numerador = 0;
Fracao.denominador = 1;
}

private static void simplifiqueSe ()
{
long menor = Math.min (Math.abs (Fracao.numerador),
Math.abs (Fracao.denominador));

if (Fracao.numerador %menor == 0 &&
Fracao.denominador%menor == 0)
{
Fracao.numerador = fracao.numerador /menor;
Fracao.denominador = Fracao.denominador/menor;
}
else
for (int i=2; i<=menor/2; i++)
while (Fracao.numerador %i == 0 &&
Fracao.denominador%i == 0)
{
Fracao.numerador = Fracao.numerador /i;
Fracao.denominador = Fracao.denominador/i;
}
}

public static long getNumerador ()
{
return Fracao.numerador;

}

public static long getDenominador ()
{
return Fracao.denominador;
}

public static void setNumerador (long numerador)
{
Fracao.numerador = numerador;
Fracao.simplifiqueSe ();
}

public static void setDenominador (long denominador) throws Exception
{
if (denominador==0)
throw new Exception ("Denominador zero");

Fracao.denominador = denominador;
Fracao.simplifiqueSe ();
}

public static void someSeCom (long numero)
{
Fracao.numerador = Fracao.numerador +
Fracao.denominador * numero;

}

public static void subtraiaDeSi (long numero)
{
Fracao.numerador = Fracao.numerador -
Fracao.denominador * numero;
}

public static void multipliqueSePor (long numero)
{
Fracao.numerador = Fracao.numerador * numero;
}

public static void dividaSePor (long numero) throws Exception
{
if (numero == 0)
throw new Exception ("Divisao por zero");

Fracao.denominador = Fracao.denominador * numero;

if (Fracao.denominador < 0)
{
Fracao.numerador = -Fracao.numerador;
Fracao.denominador = -Fracao.denominador;
}
}
}

class TesteDeFracao

{
public static void main (String args [])
{
try
{

System.out.println ("Fracao vale, inicialmente, " +
Fracao.getNumerador () +
"/" +
Fracao.getDenominador ());

Fracao.setNumerador (1);
Fracao.setDenominador (2);


System.out.print (Fracao.getNumerador () +
"/" +

Fracao.someSeCom (7);

System.out.println (" + 7 = " +
"/" +

"/" +

Fracao.subtraiaDeSi (7);

System.out.println (" - 7 = " +
"/" +

"/" +

Fracao.multipliqueSePor (7);

System.out.println (" * 7 = " +
"/" +

"/" +

Fracao.dividaSePor (7);


System.out.println (" / 7 = " +
"/" +
}
catch (Exception e)
{
System.err.println (e.getMessage ());
}
}
}

C:\ExplsJava\Expl_05> java TesteDeFracao
Isto produziria no console a seguinte interao:
Fracao vale, inicialmente, 0/1

1/2 + 7 = 15/2
15/2 - 7 = 1/2
1/2 * 7 = 7/2
7/2 / 7 = 7/14
Criao de Instncias
A declarao de uma varivel de uma classe (objeto) no faz com que, automaticamente,
seja criada uma instncia da classe para ser armazenada no objeto declarado. Isso somente
conseguido com o operador new.
O operador new e um operador que opera sobre uma classe, criando uma instncia da
mesma. Sendo Classe o identificador de uma classe, temos que a forma geral de uma
expresso de criao de uma instncia a seguinte:
new Classe ()
A expresso de criao de uma instncia pode ser usada em qualquer lugar onde um objeto
da classe Classe esperado.

Construtores de Instncia
O autor de uma classe pode controlar o que deve acontecer por ocasio da criao e da
destruio de instncias da classe escrevendo construtores que servem, basicamente, para
iniciar os membros da instncia que est sendo criada.
Construtores devem ter mesmo nome da classe qual se referem, no produzem retorno
(apesar de void no ser usado) e, quando existem, so ativados automaticamente logo aps
o operador new promover a criao de uma instncia; o operador new aloca memria para a
instncia e o construtor invocado para realizar as iniciaes programadas.
No h problema algum em construtores receberem parmetros e, j que so ativados
atomticamente, os parmetros reais so passados entre os parnteses que normalmente so
encontrados na sintaxe do operador new.
Mtodos especiais
toString
Trata-se de um mtodo padro que se destina a produzir uma verso da instncia qual for
aplicado o mtodo em uma instncia da classe String. A invocao deste mtodo pode
ficar subentendida; o mtodo toString chamado sempre que uma instncia for
concatenada com uma instncia da classe String ou ento for usada num local onde se
espera uma instncia da classe String.
equals
Trata-se de um mtodo padro que deve resultar verdadeiro, sempre que a instncia qual
for aplicado puder ser considerada igual instncia da classe Object (que pode,
efetivamente, ser uma instncia de qualquer classe, j que instncias de qualquer classe
podem ser consideradas instncias da classe Object) fornecida como parmetro, ou falso,
caso contrrio.

Naturalmente, para que possam ser consideradas iguais a instncia qual o mtodo for
aplicado e a instncia fornecida como parmetro, ambas devero ser instncias da mesma
classe e isto dever ser testado atravs do operador instanceof, antes de fazer uma
converso de tipo da instncia da classe Object fornecida como parmetro para a classe
qual o mtodo for aplicado, de forma a poder testar a igualdade, agora levando em conta os
atributos das duas instncias que, por serem da mesma classe, sero os mesmos.
hashCode
Resulta um cdigo de espalhamento (de hash) que ser um nmero inteiro e que ser
utilizado em benefcio de tabelas de espalhamento (tabelas de hash ou, simplesmente, hash
tables). O referido cdigo de espalhamento funcionar como um identificador da instncia
qual o mtodo for aplicado.
Este mtodo dever resultar cdigos de espalhamento numericamente idnticos, sempre que
for invocado para instncias que puderem ser consideradas iguais pelo mtodo equals.
No se exige que sejam numericamente os mesmos em duas execues diferentes da mesma
aplicao, embora, em geral, o sejam.
Em outras palavras, se duas instncias puderem ser consideradas iguais pela aplicao do
mtodo equals, ento este mtodo aplicado a elas dever necessariamente produzir o
mesmo inteiro como resultado.
No necessrio que este mtodo resulte inteiros numericamente diferentes quando
aplicado a duas instncias que no so consideradas iguais pelo mtodo equals. No
entanto deve-se estar conciente de que a produo de valores inteiros distintos para
instncias que so consideradas distintas pelo mtodo equals, causa impactos positivos
ao desempenho de tabelas de espalhamento.
Segue uma receita simples para calcular o cdigo de espalhamento de uma instncia:
1. Armazene um valor constante no nulo, digamos 1, em uma varivel inteira qualquer,
digamos chamada resultado;

2. Para cada atributo significativo atr da instncia (cada atributo levado em conta pelo
mtodo equals), faa o seguinte:
a) Calcule o cdigo de espalhamento ce do atributo:
i. Se o atributo for um boolean, calcule (atr ? 0 : 1).
ii. Se o atributo for um byte, um char, um short, ou um int, calcule (int)atr.
iii. Se o atributo for um long, calcule (int)(atr^(atr>>>32)).
iv. Se o atributo for um float calcule Float.floatToIntBits(atr).
v. Se o atributo for um double, calcule
Double.doubleToLongBits(atr), e ento proceda, para o resultado,
conforme especificado no passo iii.
vi. Se o atributo for um objeto de uma classe cujo mtodo equals o compara
invocando recursivamente seu mtodo equals, ento recursivamente
invoque tambm o mtodo hashcode do objeto. Se uma comparao mais
complexa se fizer necessria, produza uma representao cannica do objeto,
invocando ento seu mtodo hashcode. Se o objeto for null, utilize 0 (ou
alguma outra constante, mas 0 mais tradicional).
vii. Se o atributo for um vetor, trate cada uma de suas posies significativas
como se fossem atributos separados, ou seja, calcule um cdigo de
espalhamento para cada elemento significativo aplicando estas mesmas
regras recursivamente e os combine como descrito no passo b abaixo.
b) Combine o cdigo de espalhamento ce calculado no passo a, somando-o ao
resultado acumulado multiplicado por um nmero primo, digamos, 31. Em outras
palavras, faa:
resultado = 31*resultado + ce;
3. Retorne resultado.

4. Tendo terminado de escrever o mtodo hashcode, faa testes para verificar se ele
retorna o mesmo valor para instncias consideradas iguais pelo mtodo equals,
realizando correes no mtodo se necessrio.
compareTo
Sempre que uma classe C representar algo para o qual exista uma relao de ordem ou, em
outras palavra, sempre que uma classe produzir instncias que puderem ser comparadas
entre si, no apenas para verificar se so iguais ou no (misso do mtodo equals), mas
tambm para verificar se uma delas menor do que a outra ou se maior, deve-se fazer
com que a referida classe implemente Comparable<C>, indicando que instncias da
classe C podem ser comparadas outras instncias, tambm da classe C.
Para tanto, sendo C o nome da classe em questo, quando a estivermos implementando, ao
escrevermos class C, basta acrescentarmos implements Comparable<C>, alm de
implementar um mtodo chamado compareTo que, compara a instncia qual o mtodo for
aplicado e a instncia que dever ser fornecida como parmetro, resultando um nmero
inteiro negativo, caso a primeira seja menor do que a segunda, zero, caso ambas sejam
iguais, ou um nmero inteiro positivo, caso a primeira seja maior que a segunda.

class Fracao implements Comparable<Fracao>
{
private long numerador, denominador;

private void simplifiqueSe ()
{
long menor = Math.min (Math.abs (this.numerador),
Math.abs (this.denominador));

if (this.numerador %menor == 0 &&
this.denominador%menor == 0)
{
this.numerador = this.numerador /menor;
this.denominador = this.denominador/menor;
}
else
while (this.numerador %i == 0 &&
this.denominador%i == 0)

{
this.numerador = this.numerador /i;
this.denominador = this.denominador/i;
}
}

public Fracao (long numerador,
long denominador)
throws Exception
{
if (denominador == 0)

if (denominador < 0)
{
this.numerador = -numerador;
this.denominador = -denominador;
}
else
{
this.numerador = numerador;
this.denominador = denominador;
}

this.simplifiqueSe ();
}

public long getNumerador ()
{
return this.numerador;
}

public long getDenominador ()
{
return this.denominador;
}

public void setNumerador (long numerador)
{
}

public void setDenominador (long denominador) throws Exception
{
if (denominador==0)

}

public Fracao mais (Fracao fracao) throws Exception
{
if (fracao == null)
throw new Exception ("Falta de operando em soma");

long numerador = this.numerador * fracao.denominador +
this.denominador * fracao.numerador,

denominador = this.denominador * fracao.denominador;

Fracao resultado = new Fracao (numerador,denominador);

resultado.simplifiqueSe ();
return resultado;
}

public Fracao menos (Fracao fracao) throws Exception
{
if (fracao == null)

long numerador = this.numerador * fracao.denominador -



return resultado;
}

public Fracao vezes (Fracao fracao) throws Exception
{
if (fracao == null)
throw new Exception ("Falta de operando em multiplicacao");

long numerador = this.numerador * fracao.numerador,


return resultado;
}

public Fracao divididoPor (Fracao fracao) throws Exception
{
if (fracao == null)
throw new Exception ("Falta de operando em divisao");

if (fracao.numerador == 0)

long numerador = this.numerador * fracao.denominador,
denominador = this.denominador * fracao.numerador;

{
numerador = -numerador;

denominador = -denominador;
}


return resultado;
}

public double valorReal ()
{
return (double)numerador /
(double)denominador;
}

public String toString ()
{
if (this.numerador == this.denominador)
return "1";

if (this.numerador + this.denominador == 0)
return "-1";

if (this.numerador == 0 || this.denominador == 1)
return "" + this.numerador;

return this.numerador + "/" + this.denominador;
}

public boolean equals (Object obj)
{
if (this == obj)
return true;

if (obj == null)
return false;

if (this.getClass() != obj.getClass())
return false;

Fracao fracao = (Fracao)obj;

if (this.valorReal() != fracao.valorReal())
return false;

return true;
}

public int hashCode ()
{
final int PRIMO = 31;
int resultado = 1;

resultado = PRIMO*resultado +
(int) (this.numerador ^ (this.numerador >>> 32));


(int) (this.denominador ^ (this.denominador >>> 32));

return resultado;
}

public int compareTo (Fracao fracao)
{
double vrThis = this .valorReal(),
vrFracao = fracao.valorReal();

if (vrThis < vrFracao)
return -1;
else
if (vrThis == vrFracao)
return 0;
else
return 1;
}
}

class TesteDeFracao
{
public static void main (String arg [])
{
Fracao f1, f2, f3, f4;

try
{
f2 = new Fracao (5,7);

System.out.println ("Numerador de " + f2 + " = " +
f2.getNumerador());

System.out.println ("Denominador de " + f2 + " = " +
f2.getDenominador());


System.out.println ("Alterando numerador e denominador, ");
System.out.println ("respectivamente para 1 e 2, ");
System.out.print (f2 + " torna-se ");

f2.setNumerador (1);
f2.setDenominador (2);

System.out.println (f2);


f1 = f2.mais(f3);
System.out.println (f1 + " = " + f2 + " + " + f3);


f1 = f2.menos(f3);
System.out.println (f1 + " = " + f2 + " - " + f3);

f1 = f2.vezes(f3);
System.out.println (f1 + " = " + f2 + " * " + f3);

f1 = f2.divididoPor(f3);
System.out.println (f1 + " = " + f2 + " / " + f3);


System.out.println (f2 + " == " + f2.valorReal());


if (f2.equals(f3))
System.out.println (f2 + " == " + f3 + " (pelo equals)");
else
System.out.println (f2 + " != " + f3 + " (pelo equals)");

if (f3.equals(f4))
else


int comp = f2.compareTo(f3);
if (comp < 0)
System.out.println (f2 + " < " + f3 + " (pelo
compareTo)");
else
if (comp == 0)
System.out.println (f2 + " == " + f3 +
" (pelo compareTo)");
else
System.out.println (f2 + " > " + f3 +

comp = f3.compareTo(f4);
if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else

if (comp == 0)
else


System.out.println ("O codigo de espalhamento de " +
"uma instancia valendo " + f2 +
" vale " + f2.hashCode());


"outra instancia valendo " + f4 +
}
catch (Exception e)
{
}
}
}

Numerador de 5/7 = 5
Denominador de 5/7 = 7

Alterando numerador e denominador,
respectivamente para 1 e 2,
5/7 torna-se 1/2

11/10 = 1/2 + 3/5
-1/10 = 1/2 - 3/5
3/10 = 1/2 * 3/5
5/6 = 1/2 / 3/5

1/2 == 0.5

1/2 != 3/5 (pelo equals)

3/5 == 3/5 (pelo equals)

1/2 < 3/5 (pelo compareTo)
3/5 == 3/5 (pelo compareTo)
3/5 > 1/2 (pelo compareTo)

O codigo de espalhamento de uma instancia valendo 1/2 vale 994
O codigo de espalhamento de outra instancia valendo 3/5 vale 1059
Organizao de Programa
Modularizao
Embora no seja obrigatrio particionar os programas em mdulos, recomenda-se
fortemente que isso seja feito, especialmente programas de um porte maior. Isso far com
que o programa se torne mais manutenvel, aumenta as possibilidade de reuso, alm de
minimizar a perda de tempo com compilaes, j que mdulos so unidades de compilao
separada.
Em Java, mdulos so arquivos com uma coleo de classes. Recomenda-se colocar em um
mesmo mdulo somente classes afins. importante ressaltar que, se diversas classes forem
escritas em um mesmo arquivo fonte, somente poder ser utilizada por outras classes aquela
que tiver o mesmo nome do arquivo fonte, se houver uma classe nessas condies, e
retirada a extenso .java, naturalmente. As demais podero apenas serem utilizadas por suas
companheiras com quem compartilha o arquivo fonte.

{

{


{
}
else
{
}
}

long denominador)
throws Exception
{

{
}
else
{
}

}

{
}

{
}

{
}

{
if (denominador==0)


}

{
if (fracao == null)




return resultado;
}

{
if (fracao == null)




return resultado;
}

{
if (fracao == null)



return resultado;
}

{
if (fracao == null)




{
}


return resultado;
}

{
}

{
return "1";

return "-1";


}

{
if (this == obj)
return true;

if (obj == null)
return false;

return false;


return false;

return true;
}


{
int resultado = 1;



return resultado;
}

{

return -1;
else
return 0;
else
return 1;
}
}

[C:\ExplsJava\Expl_07\TesteDeFracao.java]

class TesteDeFracao
{
{

try
{


f1 = f2.mais(f3);

f1 = f2.menos(f3);

f1 = f2.vezes(f3);



if (f2.equals(f3))
else

if (f3.equals(f4))
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else




}
catch (Exception e)
{
}
}
}

Numerador de 5/7 = 5
Denominador de 5/7 = 7

Alterando numerador e denominador,
respectivamente para 1 e 2,
5/7 torna-se 1/2

11/10 = 1/2 + 3/5
-1/10 = 1/2 - 3/5
3/10 = 1/2 * 3/5
5/6 = 1/2 / 3/5

1/2 == 0.5




Pacotes
Como vimos, um programa em Java pode se compor de diversos arquivos. Podem tambm
usar arquivos de dados, imagens, sons, etc. Projetos maiores podem de fato ficar muito
desorganizados se todos estes arquivos residirem juntos em um mesmo diretrio.
Para resolver este problema, introduzimos o conceito de pacote. Pacotes definem uma
hierarquia de espaos onde as classes podem ser armazenadas. Todo pacote pode Ter zero
ou mais subpacotes, todo subpacote pode ter zero ou mais subsubpacotes, e assim por
diante. O compilador Java usa diretrios do sistema de arquivos para armazenar pacotes.
importante ressaltar o fato de que deve existir uma correrspondncia biunvoca entre a
hierarquia de pacotes e a hierarquia de diretrios que fica abaixo do diretrio raiz do
diretrio onde est armazenado o programa.
preciso tambm chamar a ateno para o fato de ques as letras minsculas e maisculas
que constituem os nomes dos diretrios devem corresponder exatamente s letras que
constituem o nome dos patotes.
Arquivos fonte de classes que residem em um pacote devem comear pelo comando:
package NomPac1[.NomPac2[...]];
onde NomPac1 o nome do pacote onde reside a classe em questo, NomPac2 o nome do
subpacotete do pacote NomPac1 onde ela reside, e assim sucessivamente.
Classes Pblicas
Classes que residem dentro de um mesmo n da hierarquia de pacotes podem empregar-se
mutuamente em suas implementaes, ao passo que classes que residem em um
determinado n da hierarquia de pacotes somente podem fazer uso de classes que residem
em um outro n da hierarquia de pacotes se estas ltimas forem qualificas com o
qualificador public.
Membros Default (ou de Pacote)
Conforme sabemos, existem 2 tipos de membros que podem ser definidos em uma classe, a
saber: os membros pblicos (que so acessveis para qualquer mtodo que tenha acesso

classe em que foram definidos) e os membros privativos (que so acessveis somente nos
mtodos definidos em sua classe).
Ficaremos sabendo agora da existncia de um terceiro tipo de membro, os membros default
(ou de pacote). Esse tipo de membro declarado sem nenhuma qualificao, i.e., sem serem
precedidos pela palavra public, pela palavra private, ou por qualquer outra palavra
especialmente definida para qualifica-los.
Membros default (ou de pacote) so acessveis para todas os mtodos definidos nas classes
que integram o pacote onde foi definida sua classe.
Convem ressaltar que, quando no dividimos classes em pacotes, Java coloca todas as
classes que definimos em um nico pacote.
[C:\ExplsJava\Expl_08\matematica\Fracao.java]

package matematica;

public class Fracao implements Comparable<Fracao>
{

{

{
}
else
{
}
}

long denominador)
throws Exception
{


{
}
else
{
}

}

{
}

{
}

{
}

{
if (denominador==0)

}

{
if (fracao == null)




return resultado;

}

{
if (fracao == null)




return resultado;
}

{
if (fracao == null)



return resultado;
}

{
if (fracao == null)



{
}


return resultado;
}


{
}

{
return "1";

return "-1";


}

{
if (this == obj)
return true;

if (obj == null)
return false;

return false;


return false;

return true;
}

{
int resultado = 1;



return resultado;
}

{

return -1;
else
return 0;
else
return 1;
}
}


import matematica.*;

class TesteDeFracao
{
{

try
{


f1 = f2.mais(f3);

f1 = f2.menos(f3);

f1 = f2.vezes(f3);



if (f2.equals(f3))
else

if (f3.equals(f4))
else


if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else



}
catch (Exception e)
{
}
}
}


1/2 + 7 = 15/2
3/5 - 7 = 32/5
1/2 * 7 = 7/2
3/5 / 7 = 3/35
javadoc
A ferramenta javadoc extrai certo tipo de comentrios que escrevemos ao programar e gera
pginas HTML de documentao. Presta-se a gerar documentao de pacotes inteiros,
classes individuais ou ambos.
Os comentrios em questo devem ser delimitados com os caracteres /** e */, so
escritos em HTML e devem preceder pacotes, classes, interfaces, constantes ou mtodos.
Classes e interfaces com este tipo de comentrios para devem, necessariamente ser gravadas
individualmente em arquivos separados e a palavra public dever ser colocada antes da
palavra class ou interface que d incio a sua definio.
Tais comentrios so constitudos por:
1. Uma linha contendo unicamente /** (marcao de incio de comentrio para javadoc);
2. Linhas contendo um pargrafo constitudo por um perodo nico e corretamente
pontuado que representa uma breve descrio daquilo que se deseja documentar;
3. Linhas contendo pargrafos constitudos por qualquer nmero de perodos corretamente
pontuados com informaes complementares a respeito daquilo que se deseja
documentar;
4. Uma linha em branco;

5. Linhas contendo pargrafos constitudos por qualquer nmero de perodos corretamente
pontuados com informaes a respeito de itens introduzidos por marcaes iniciadas
pelo caractere arroba (@);
6. Uma linha contendo unicamente */ (marcao de fim de comentrio para javadoc).
As possveis marcaes iniciadas pelo caractere arroba (@) so as listadas abaixo e devem
ocorrer (quando ocorrerem) na ordem em que so abordadas a serguir:
1. @param
Presta-se documentao de parmetros; deve se seguir de um nome de parmetro e de
uma descrio do mesmo (caso hajam vrios parmetros, devemos usar vrias
marcaes deste tipo, uma para cada parmetro, na ordem em que foram declarados);
2. @return
Presta-se documentao de retorno; deve se seguir da descrio daquilo que
retornado, especificando as situaes em que cada possvel retorno ocorre;
3. @throws
Presta-se documentao de excees lanadas; originalmente @exception, deve se
seguir de um nome de uma exceo e de uma descrio da situao em que a mesma
lanada (caso hajam vrias excees possivelmente lanadas, devemos usar vrias
marcaes deste tipo, uma para cada exceo, na ordem em que foram especificadas);
4. @author
Presta-se especificao do autor daquilo que est sendo documentado; deve se seguir
do nome do autor daquilo que est sendo documentado (caso hajam vrios autores,
devemos usar vrias marcaes deste tipo, uma para cada autor); autores no so
includos na documentao gerada;
5. @version

Presta-se especificao da verso (e de sua data de liberao) daquilo que est sendo
documentado; deve se seguir do nmero da verso e da data de sua liberao; quando
usamos o SCCS, deve valer %I%, %G%, o que acaba sendo convertido em nmero da
verso, seguida pela data de sua liberao, quando da extrao do SCCS;
6. @see
Presta-se recomendar o exame de itens correlatos que, quando compreendidos,
melhorariam o entendimento daquilo que est sendo documentado; deve se seguir do
nome daquilo cujo exame est sendo recomendado; quando aquilo cujo exame est
sendo recomendado for:
a. Uma constante, construtor ou mtodo:
o Da prpria classe que est sendo documentada, precederemos o nome daquilo
cujo exame est sendo recomendado por um #;
o De uma classe diferente daquela que est sendo documentada, porm do mesmo
pacote, precederemos o nome daquilo cujo exame est sendo recomendado pelo
nome da classe e em seguida por um #;
o De uma classe de outro pacote, precederemos o nome daquilo cujo exame est
sendo recomendado pelo nome do pacote, seguido por um ponto, seguido pelo
nome da classe e em seguida por um #;
b. Uma classe:
o Do mesmo pacote daquilo que est sendo documentado, utilizaremos
simplesmente seu nome;
o De outro pacote, precederemos seu nome pelo nome do pacote seguido por um
ponto;
c. Um pacote:
Utilizaremos simplesmente seu nome,

Caso hajam vrios itens cujo exame deseja-se recomendar, devemos usar vrias
marcaes deste tipo, uma para cada item;
7. @since
Presta-se especificao da verso a partir da qual aquilo que est sendo documentado
foi includo no produto documentado; deve se seguir do nmero desta verso;
8. @literal
Presta-se a fazer com que o texto que deve segui-lo seja mostrado literalmente como ,
no interpretando-o (como comandos HTML, por exemplo); deve estar, bem como o
texto que o segue, entre chaves;
9. @code
Como @literal, exceto pelo fato de que tem o efeito adicional de fazer com que o texto
que o segue seja mostrado com fonte prpria para mostrar cdigo.
10. @link
Deve seguir-se de uma referncia a uma constante, construtor, mtodo, classe ou pacote
elaborada conforme o fazemos em @see e de um texto, prestando-se a fazer constar na
documentao o texto fornecido (formatado como cdigo), fazendo-o funcionar como
um link que conduz documentao daquilo que foi referenciado; deve estar, bem
como o texto que o segue, entre chaves;
11. @linkplain
Como @link, exceto pelo fato de que tem o texto fornecido no ser formatado como
cdigo.
12. @docRoot
Representa o caminho relativo para a pasta na qual sero armazenados os arquivos e
subpastas realativos a uma documentao gerada pelo javadoc; til na elaborao de
links que precisem fazer referncia quela pasta; deve estar, bem como o texto que o
segue, entre chaves;

13. @value
Pode ser usada na documentao de uma constante, caso em que representar o valor da
constante em questo; pode ser usada em outros contextos seguida uma expecificao
de constante feita conforme o fazemos em @see, caso em que representar o valor
daquela constante; deve estar, bem como o texto que o segue, entre chaves;
14. @inheritDoc
Representa documentao do item que est sendo documentado na classe ou interface
base (numa situao de herana); somente vlido em descries de mtodos e em
@param, @return ou @trows; deve estar, bem como o texto que o segue, entre chaves;
15. @deprecated
Presta-se fazer constar em documentao a depreciao de um item previamente
marcado por preceder o mesmo com um @Deprecated. Deve seguir-se de um texto que
explique desde quando ocorreu a depreciao (verso e data), alm de explicar a forma
ora vigente.
16. @serial, @serialfield e @serialdata
Para toda classe que implementa Serializable gerada uma pgina especial com
informaes a respeito de suas constentes e mtodos de serializao. Esta informao
de interesse de reimplementadores, no de desenvolvedores que utilizem a classe. Tem-
se acesso a esta pgina clicando no link Serializable Form na seo See also do
comentrio da classse. Veja como utilizar estes recursos na documentao na
documentao do javadoc.
J ARs
JARs, ou Java Archives, so repositrios com formato independente de plataforma, onde
jazem divesos arquivos, por vezes diversos diretrios contendo diversos arquivos.

Alm de serem teis para a distribuio de aplicaes Java, os JARs podem ser tambm
empregados para construir pacotes de software contendo muitas applets, bem como todos
os eventuais arquivos necessrios a elas.
Tais pacotes podem ser baixados por um browser em uma nica transao HTTP,
melhorando significativamente a velocidade de carga de uma pgina. Alm disso, o formato
JAR tambm suporta compresso de dados, o que reduz tambm o tamanho do arquivo, o
que faz cair ainda mais o tempo gasto na transao.
Alm disso, o autor das applets pode assinar digitalmente cada entrada em um JAR para de
forma a autenticar sua origem.

/**
A classe Fracao representa fraes, conforme as conhecemos da matemtica.

Em outras palavras, a classe Fracao representa o conjunto matemtico dos
nmeros racionais. Nela encontraremos diversos mtodos para operar com
fraes.
@author Andr Lus dos Reis Gomes de Carvalho
@since 2000
*/
public class Fracao implements Comparable<Fracao>
{

{

{
}
else
{
}
}

/**
Constroi uma nova instncia da classe Fracao.
Para tanto, devem ser fornecidos dois inteiros que sero utilizados
respectivamente, como numerador e como denominador da instncia recm
criada.
@param numerador o nmero inteiro a ser utilizado como numerador
@param denominador o nmero inteiro a ser utilizado como denominador
@throws Exception se o denominador for igual a zero
*/
long denominador)
throws Exception
{

{
}
else
{
}

}

/**
Obtem o numerador de uma frao.
Resulta o numerador da instncia qual este mtodo for aplicado.
@return o numerador da frao chamante do mtodo
*/
{
}

/**
Obtem o denominador de uma frao.
Resulta o denominador da instncia qual este mtodo for aplicado.
@return o denominador da frao chamante do mtodo
*/
{
}

/**
Ajusta o numerador de uma frao.
Ajusta o numerador da instncia qual este mtodo for aplicado.
@param numerador o numerador que a frao chamante do mtodo
deve pasar a ter

*/
{
}

/**
Ajusta o denominador de uma frao.
Ajusta o denominador da instncia qual este mtodo for aplicado.
@param denominador o denominador que a frao chamante do mtodo
deve pasar a ter
@throws Exception se o denominador for igual a zero
*/
{
if (denominador==0)

}

/**
Realiza a operao de soma para duas fraes.
Soma a instncia qual este mtodo for aplicado com aquela que lhe
for fornecida como parmetro.
@param fracao a frao que deve ser somada chamante do mtodo
@return a frao chamante do mtodo somada frao fornecida
@throws Exception se for fornecido null como parmetro
*/
{
if (fracao == null)




return resultado;
}

/**
Realiza a operao de subtrao para duas fraes.
Subtrai da instncia qual este mtodo for aplicado aquela que lhe
@param fracao a frao que deve ser subtraida da chamante do mtodo
@return a frao chamante do mtodo menos a frao fornecida
*/

{
if (fracao == null)




return resultado;
}

/**
Realiza a operao de multiplicao para duas fraes.
Multiplica a instncia qual este mtodo for aplicado por aquela que
lhe
@param fracao a frao que deve ser multiplicada pela chamante do
mtodo
@return a frao chamante do mtodo multiplicada pela frao
fornecida
*/
{
if (fracao == null)



return resultado;
}

/**
Realiza a operao de diviso para duas fraes.
Divide a instncia qual este mtodo for aplicado por aquela que lhe
@param fracao a frao pela qual deve ser dividida a chamante do
mtodo
@return a frao chamante do mtodo dividida pela frao fornecida
*/
{
if (fracao == null)



{
}


return resultado;
}

/**
Converte uma frao em um nmero real.
Calcula e resulta o nmero real equivalente instncia qual este
mtodo for aplicado.
@return o nmero real equivalente frao chamante do mtodo
*/
{
}

/**
Converte uma frao em um String.
Produz e resulta uma instncia da classe String que representa a
instncia qual este mtodo for aplicado.
@return o String que representa a frao chamante do mtodo
*/
{
return "1";

return "-1";


}

/**
Verifica a igualdade entre duas fraes.
Verifica se o Object fornecido como parmetro representa uma
frao numericamente equivalente quela representada pela instncia
qual este mtodo for aplicado, resultando true em caso afirmativo,
ou false, caso contrrio.
@return true, caso o Object fornecido ao mtodo e a instncia
chamante do

mtodo representarem fraes numericamente equivalentes, ou
false,
caso contrrio
*/
{
if (this == obj)
return true;

if (obj == null)
return false;

return false;


return false;

return true;
}

/**
Calcula o cdigo de espalhamento (ou cdigo de hash) de uma frao.
Calcula e resulta o cdigo de espalhamento (ou cdigo de hash, ou
ainda o
hashcode) da frao representada pela instncia qual o mtodo for
aplicado.
@return o cdigo de espalhamento da frao chamante do mtodo
*/
{
int resultado = 1;



return resultado;
}

/**
Compara duas fraes.
Compara as fraes representadas respectivamente pela instncia
qual
o mtodo for aplicado e pela instncia fornecida como parmetro,
resultando
um nmero negativo, caso a primeira seja numericamente menor que a
segunda,
zero, caso as duas sejam numericamente iguais, ou
um nmero positivo, caso a primeira seja numericamente maior que a
segunda.

@return um nmero negativo, caso a primeira seja numericamente menor
que a
segunda, zero, caso as duas sejam numericamente iguais, ou um
nmero positivo, caso a primeira seja numericamente maior que
a
segunda.

*/
{

return -1;
else
return 0;
else
return 1;
}
}

class TesteDeFracao
{
{

try
{


f1 = f2.mais(f3);

f1 = f2.menos(f3);

f1 = f2.vezes(f3);



if (f2.equals(f3))

else

if (f3.equals(f4))
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else




}
catch (Exception e)
{
}
}
}

[C:\ExplsJava\Expl_09\FcaoPrin.MF]

Main-Class: TesteDeFracao

Podemos observar que o exemplo acima apresenta um arquivo de nome FcaoPrin.MF. Este
arquivo ser empregado no momento de criar o JAR e tem por funo indicar qual a
classe principal do JAR, i.e., a classe a partir da qual a execuo ter incio.
Para compilar este programa, procederemos como temos procedido com todos os
programas compilados anterirormente, ou seja, daremos o seguinte comando:
C:\ExplsJava\Expl_09> javac TesteDeFracao.java
Para criar o JAR, basta dar o seguinte comando:
C:\ExplsJava\Expl_09> jar fmc Fracao.jar FcaoPrin.MF Fracao.class TesteDeFracao.class
Poderemos observar que foi criado o arquivo Fracao.jar. Para execut-lo, basta dar o
seguinte comando:
C:\ExplsJava\Expl_09> java -jar Fracao.jar
11/10 = 1/2 + 3/5
-1/10 = 1/2 - 3/5
3/10 = 1/2 * 3/5
5/6 = 1/2 / 3/5
1/2 == 0.5

Sobrecarga
Java permite sobrecarga de nomes de funo, i.e., um nico nome para diversas funes
diferentes.
Cada operao deve ter tipos de parmetros diferentes. Java seleciona uma operao com
base nos tipos dos argumentos fornecidos.
O conceito de sobrecarga, alm de possibilitar nomes de funo mais significativos, ainda
possibilita a escrita de cdigo polimrfico.
Criao e Destruio
O autor de uma classe pode controlar o que deve acontecer por ocasio da criao e da
destruio de instncias da classe escrevendo funes construtoras e destrutoras.
Construtores servem basicamente para iniciar os membros da instncia que est sendo
criada. Quanto aos destrutores, como Java tem um mecanismo automtico de coleta de lixo,
no preciso, como em outras linguagens, se preocupar com liberao de memria. Por esta
razo, muito raro ser preciso utilizar um destrutor em Java. Mas se a destruio de um
objeto tiver implicaes outras que a liberao de memria, neste caso empregar um
destrutor pode ser interessante.
Quando uma instncia criada, aloca-se memria para a instncia e em seguida chamado
o construtor da classe (se houver um). Quando uma instncia destruda, o destrutor
chamado (se houver um) e em seguida libera-se a memria alocada para a instncia.
Construtores so batizados com o nome da classe a que se referem e destrutores so
batizados com o nome de finalize .

Como os construtores e os destrutores so chamados automaticamente, no faz sentido que
eles tenham retorno. No indicamos o tipo retornado por um construtor (nem mesmo void).
O tipo de retorno de um destrutores sempre void.
Destrutores no podem ter parmetros, o que significa que toda classe ter no mximo um
destrutor. No possvel precisar o momento da execuo de um destrutor, j que no se
sabe em que momento o mecanismo de coleta de lixo vai liberar a memria associada aos
objetos e vetores inutilizados.
Construtores podem ter parmetros, o que significa que podemos ter vrios deles em uma
mesma classe (sobrecarga de construtores), cada qual realizando a iniciao do objeto em
processo de criao de uma maneira diferente.
No caso de uma classe ter vrios construtores, se na implementao de um deles for
desejvel chamar um outro, poderemos faz-lo atravs da palavra chave this (em vez de
usar o nome da classe). Este comando sempre dever ser o PRIMEIRO comando de um
construtor, e ser construdo como segue: a palavra this eventualmente seguida dos
argumentos separados por virgulas (,) e entre parnteses (()) a serem passados ao construtor
a ser chamado.

import java.util.*;

{

{

{
}
else

{
}
}

private void assumaValor (long numerador,
long denominador)
throws Exception
{

{
}
else
{
}

}

long denominador)
throws Exception
{
this.assumaValor (numerador, denominador);
}

public Fracao (String fracao) throws Exception
{
if (fracao == null)
throw new Exception ("Tentativa de criar fracao a partir do
nada");

if (fracao.length () == 0)
throw new Exception ("Tentativa de criar fracao a partir do
nada");

StringTokenizer separador = new StringTokenizer (fracao,"/");

long numerador;

try
{
numerador = Integer.parseInt (separador.nextToken());
}
catch (NumberFormatException e)
{

throw new Exception ("Caracteres invalidos para fracao");
}

int denominador = 1;

if (separador.hasMoreTokens ())
try
{
denominador = Integer.parseInt (separador.nextToken());
}
{
throw new Exception ("Caracteres invalidos para fracao");
}

if (separador.hasMoreTokens ())
throw new Exception ("Excesso de caracteres");

this.assumaValor (numerador, denominador);
}

{
if (fracao == null)




return resultado;
}

public Fracao mais (long numero)
{
long numerador = this.denominador * numero +
this.numerador,

denominador = this.denominador;

Fracao resultado = null;

try
{
resultado = new Fracao (numerador, denominador);
}
catch (Exception e)
{}

return resultado;
}

{
if (fracao == null)




return resultado;
}

public Fracao menos (long numero)
{
long numerador = this.denominador * numero -
this.numerador,



try
{
}
catch (Exception e)
{}

return resultado;
}

{
if (fracao == null)



return resultado;
}

public Fracao vezes (long numero)
{
long numerador = this.numerador * numero,



try
{
}
catch (Exception e)
{}

return resultado;
}

{
if (fracao == null)



{
}


return resultado;
}

public Fracao divididoPor (long numero) throws Exception
{
if (numero == 0)

long numerador = this.numerador,
denominador = this.denominador * numero;

{
}


try
{
}

catch (Exception e)
{}

return resultado;
}

{
}

{
return "1";

return "-1";


}

{
if (this == obj)
return true;

if (obj == null)
return false;

return false;


if (numerador != fracao.numerador)
return false;

if (this.denominador != fracao.denominador)
return false;

return true;
}

{
int resultado = 1;



return resultado;
}

{

return -1;
else
return 0;
else
return 1;
}
}


class TesteDeFracao
{
{

try
{
f4 = new Fracao ("3/5");


f1 = f2.mais(f3);

f1 = f2.mais(7);
System.out.println (f1 + " = " + f2 + " + " + 7);

f1 = f2.menos(f3);

f1 = f2.menos(7);
System.out.println (f1 + " = " + f2 + " - " + 7);

f1 = f2.vezes(f3);

f1 = f2.vezes(7);

System.out.println (f1 + " = " + f2 + " * " + 7);


f1 = f2.divididoPor(7);
System.out.println (f1 + " = " + f2 + " / " + 7);


if (f2.equals(f3))
else

if (f3.equals(f4))
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else

if (comp < 0)
compareTo)");
else
if (comp == 0)
else




}
catch (Exception e)
{
}
}
}

C:\ExplsJava\Expl_10> javac TesteDeFracao.java
11/10 = 1/2 + 3/5
15/2 = 1/2 + 7
-1/10 = 1/2 - 3/5
13/2 = 1/2 - 7
3/10 = 1/2 * 3/5
7/2 = 1/2 * 7
5/6 = 1/2 / 3/5
1/14 = 1/2 / 7
1/2 == 0.5

Vetores
Um vetor uma coleo de informaes de mesma natureza. Vetores podem ter um nmero
arbitrariamente grande de subscritos. Subscritos identificam de forma nica um elemento
dentro da coleo. Os subscritos em Java so sempre nmeros naturais, sendo zero o
primeiro deles.
A declarao de um vetor tem a seguinte forma: primeiramente vem o tipo dos elementos
do vetor, em seguida vem o identificador do vetor, em seguida vem uma srie pares de
colchetes ([]), um para cada dimenso do vetor. Sendo Tipo um tipo e Vetor o identificador
do vetor a ser declarado, temos abaixo a declarao de um vetor de elementos do tipo Tipo:
Tipo Vetor [ ][ ][ ]...[ ] ou Tipo [ ][ ][ ]...[ ] Vetor
Como acontece com os objetos, os vetores antes de serem usados precisam ser instanciados.
Faz-se isso com o operador new. Sendo Vetor o identificador de um vetor do tipo Tipo
previamente declarado com k dimenses e Ni nmeros naturais, temos:
Vetor = new Tipo [N
1
][N
2
]...[N
k
];
Para acessar um elemento de um vetor, basta mencionar o seu nome e, entre colchetes o
subscrito desejado.
Constantes Vetor
Uma constante vetor consiste dos valores dos seus elementos separados por vrgulas (,) e
delimitados por chaves ({}). Podem somente ser usadas para inici-lo (no se pode atribuir
uma constante vetor a um vetor).
Tamanho das Dimenses de um Vetor
O tamanho de cada uma das dimenses de um vetor pode ser obtido atravs da propriedade
length. Assim, sendo Vetor o identificador de um vetor e i, j e k seus subscritos, temos que:
1. Vetor.length D o tamanho da primeira dimenso do vetor;
2. Vetor[ i ].length D o tamanho da segunda dimenso do vetor;

3. Vetor[ i ][ j ].length D o tamanho da terceira dimenso do vetor;
4. Vetor[ i ][ j ][ k ].length D o tamanho da quarta dimenso do vetor;
5. Etc.
[C:\ExplsJava\Expl_11\Agenda.java]

public class Agenda
{
private int qtdContatos=0;

private String nome [],
telefone [];

private int ondeEsta (String nom)
{
int inicio = 0,
fim = this.qtdContatos - 1,
meio = 0,
comparacao = -1;

while (inicio <= fim)
{
meio = (inicio + fim) / 2;
comparacao = nom.compareTo (this.nome [meio]);

if (comparacao == 0)
return meio+1;
else
if (comparacao < 0)
fim = meio-1;
else
inicio = meio+1;
}

return -((comparacao<0?meio:meio+1)+1);
}

public Agenda (int cap) throws Exception
{
if (cap <= 0)
throw new Exception ("Capacidade invalida");

this.nome = new String [cap];
this.telefone = new String [cap];
}

public int getCapacidade ()
{
return this.nome.length;
}

public int getQtdContatos ()
{
return this.qtdContatos;
}

public boolean haRegistroDoContato (String nom)
{
return this.ondeEsta(nom)>0;
}

public void registreContato (String nom, String tel) throws Exception
{
if (this.qtdContatos == this.nome.length)
throw new Exception ("Agenda cheia");

int posicao = this.ondeEsta (nom);

if (posicao > 0)
throw new Exception ("Nome ja registrado");

posicao = (-posicao)-1;

for (int pos=this.qtdContatos-1; pos>=posicao; pos--)
{
this.nome [pos+1] = this.nome [pos];
this.telefone [pos+1] = this.telefone [pos];
}

this.nome [posicao] = nom;
this.telefone [posicao] = tel;

this.qtdContatos++;
}

public String getTelefone (String nom) throws Exception
{
if (this.qtdContatos == 0)
throw new Exception ("Agenda vazia");


if (posicao < 0)
throw new Exception ("Nome inexistente");

posicao--;

return this.telefone [posicao];
}

public void descarteContato (String nom) throws Exception
{


if (posicao < 0)

posicao--;

int pos;

for (pos = posicao; pos < this.qtdContatos - 1; pos++)
{
this.nome [pos] = this.nome [pos+1];
this.telefone [pos] = this.telefone [pos+1];
}

this.nome [pos] = null;
this.telefone [pos] = null;

this.qtdContatos--;
}
}

[C:\ExplsJava\Expl_11\TesteDeAgenda.java]


class TesteDeAgenda
{
{
BufferedReader entrada = new BufferedReader
(System.in));

Agenda agenda = null;

for (;;)
{

System.out.print ("Capacidade desejada para a Agenda: ");
try
{
int cap = Integer.parseInt (entrada.readLine ());
agenda = new Agenda (cap);
}
catch (IOException e)
{}
{
System.err.println ("Nao foi digitado um numero
inteiro");

System.err.println ();
continue;
}
catch (Exception e)
{
System.err.println (e.getMessage());
continue;
}

break;
}


String nome = null, telefone = null;

char opcao = ' ';

do
{

System.out.print ("Digite sua Opcao (" +
"I=Incluir/" +
"C=Consultar/" +
"E=Excluir/" +
"S=Sair)" +
": ");

try
{
opcao = (entrada.readLine ()).charAt (0);
}
{}

opcoes: switch (opcao)
{
case 'i':
case 'I':
try
{
System.out.print ("Nome....: ");
nome = entrada.readLine ();
}
{}

try
{
System.out.print ("Telefone: ");
telefone = entrada.readLine ();
}
{}

try
{
agenda.registreContato (nome, telefone);
}
catch (Exception e)
{
}

break;

case 'c':
case 'C':
try
{
}
{}

try
{
telefone = agenda.getTelefone (nome);
}
catch (Exception e)
{
break;
}

System.out.println ("Telefone: " + telefone);
break;

case 'e':
case 'E':
try
{
}
{}

try
{
agenda.descarteContato (nome);
}
catch (Exception e)
{

}

break;

case 's':
case 'S':
break;

default :
System.err.println ("Opcao invalida");
}
}
while ((opcao != 's') && (opcao != 'S'));
}
}

C:\ExplsJava\Expl_11> javac *.java.java
C:\ExplsJava\Expl_11> java TesteDeAgenda

Capacidade desejada para a Agenda: -10
Capacidade invalida

Capacidade desejada para a Agenda: 0
Capacidade invalida


Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): i
Nome....: Jose
Telefone: 3241.4466

Nome....: Jose
Nome j registrado

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): c
Nome....: Jose
Telefone: 3241.4466

Nome....: Joao
Telefone: 3252.9955

Nome....: Joao
Telefone: 3252.9955

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): e
Nome....: Joao

Nome....: Joao
Nome inexistente

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): a
Opcao invalida

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): s
Herana
Um programa pode muitas vezes conter grupos de classes relacionadas (semelhantes, mas
no idnticas). Com o conceito de herana, grupos de classes relacionadas podem ser
criados de maneira simples, flexvel, eficiente e elegante.
Caractersticas comuns so agrupadas em uma classe (classe base). Desta classe poderamos
derivar outras classes (classes derivadas), e destas ainda outras classes, e assim por diante.
Classes derivadas herdam todos os membros da classe base. Elas podem acrescentar novos
membros queles herdados, bem como redefinir aqueles membros.

Posto que classes derivadas herdam as caractersticas de sua classe base, a descrio de uma
classe derivada deve se concentrar nas diferenas que esta apresenta com relao a classe
base, adicionando ou modificando caractersticas.
As funes acrescentadas por uma classe derivada somente podem ser usadas a partir de
objetos da classe derivada. As funes definidas numa classe base podem ser usadas em
objetos da classe base ou em objetos de qualquer de suas classes derivadas.
Para redefinir uma funo membro de sua classe base, a classe derivada deve implementar
uma funo membro de mesmo nome e com parmetros do mesmo tipo. A redefinio no
ser possvel se a funo membro da classe base estiver qualificada pelo modificador final.
No caso de uma classe precisar chamar um construtor de sua classe base na redefinio de
seu construtor, ela poder faz-lo atravs da palavra chave super. Em vez ser utilizado o
nome da classe para chamar o construtor, seria utilizada a palavra super eventualmente
seguida dos argumentos a serem passados ao construtor separados por virgulas (,) e entre
parnteses (()).
Classes qualificadas como final no podem ser usadas como base para a derivao de outra
classe.
Mais sobre Converses de Tipo
Converses de tipo que transformam um objeto de uma dada subclasse em uma de suas
superclasses podem acontecer implcita ou explicitamente e so completamente confiveis.
Converses de tipo que transformam um objeto de uma dada superclasse em uma de suas
subclasses no so completamente confiveis e somente podem ocorrer explicitamente.
Converses de tipo transformam um objeto de uma dada classe em outra classe que no est
em linha direta de ascendncia ou descendncia em uma mesma hierarquia de classes no
so permitidas.

Verificao de Tipo em J ava
Em Java, sempre que um objeto de um certo tipo esperado, possvel usar um objeto
daquele mesmo tipo, ou ento, em seu lugar, um objeto de qualquer classe derivada daquele
tipo.
Esta caracterstica da linguagem permite a criao de cdigo polimrfico, o que permite a
programao adequada tanto funes que precisam trabalhar especificamente com uma
certa classe derivada, quanto funes que precisam trabalhar genericamente com qualquer
classe da hierarquia.
A funo a ser executada quando de uma chamada determinada com base no tipo do
objeto ao qual a chamada foi vinculada, no nome usado na chamada e nos tipos dos
parmetros fornecidos.
Se o tipo do objeto declarado no bate com o tipo do objeto fornecido, ento, em tempo de
execuo, o objeto fornecido ser examinado de modo a determinar qual funo deve ser
executada. Chamamos a isto Binding Dinmico.
Membros Protegidos
Conforme sabemos, existem 3 tipos de membros que podem ser definidos em uma classe, a
saber: os membros pblicos (que so acessveis para qualquer mtodo que tenha acesso
classe em que foram definidos), os membros privativos (que so acessveis somente nos
mtodos definidos em sua classe) e os membros default (ou de pacote, que so acessveis
para todas os mtodos definidos nas classes que integram o pacote onde foi definida sua
classe).
Ficaremos sabendo agora da existncia de um quarto e ltimo tipo de membro, os membros
protegidos. Para declarar um membro protegido, basta preceder a declarao do membro
com a palavra protected (em vez de usar a palavra public ou a palavra private).
Membros protegidos, alm de serem, como os membros default (ou de pacote), acessveis
para todas os mtodos definidos nas classes que integram o pacote onde foi definida sua

classe, so tambm acessveis para mtodos definidos em uma classe derivada da classe
onde foram definidos.
Convm ressaltar que, no caso da classe base e da classe derivada residirem em pacotes
diferentes, a classe derivada somente ter acesso aos membros protegidos de sua classe e de
instncias de sua prpria classe, no tendo acesso aos membros protegidos de sua classe
base ou de instncias de sua classe base.

public class Agenda
{
protected int qtdContatos=0;

protected String nome [],
telefone [];

protected int ondeEsta (String nom)
{
int inicio = 0,
meio = 0,
comparacao = -1;

{

return meio+1;
else
if (comparacao < 0)
fim = meio-1;
else
inicio = meio+1;
}

}

public Agenda (int cap) throws Exception
{
if (cap <= 0)

}

{
}

{
}

{
}

{


if (posicao > 0)


{
}


this.qtdContatos++;
}

{


if (posicao < 0)

posicao--;

}


{


if (posicao < 0)

posicao--;

int pos;

{
}


this.qtdContatos--;
}
}

[C:\ExplsJava\Expl_12\AgendaListavel.java]

public class AgendaListavel extends Agenda
{
public AgendaListavel (int cap) throws Exception
{
super (cap);
}

public String getNome (int pos) throws Exception
{

if (pos < 0 || pos >= this.qtdContatos)
throw new Exception ("Nome fora dos limites");

return this.nome [pos];
}

public String getTelefone (int pos) throws Exception
{

throw new Exception ("Telefone fora dos limites");

return this.telefone [pos];
}
}



class TesteDeAgenda
{
{
(System.in));

AgendaListavel agenda = null;

for (;;)
{

System.out.print ("Capacidade desejada para a Agenda: ");
try
{
int cap = Integer.parseInt (entrada.readLine ());
agenda = new AgendaListavel (cap);
}
{}
{
System.err.println ("Nao foi digitado um numero
inteiro");
continue;
}
catch (Exception e)
{
continue;
}

break;
}



char opcao = ' ';

do
{

"I=Incluir/" +
"C=Consultar/" +
"L=Listar/" +
"E=Excluir/" +
"S=Sair)" +
": ");

try
{
opcao = (entrada.readLine ()).charAt (0);
}
{}

{
case 'i':
case 'I':
try
{
}
{}

try
{
telefone = entrada.readLine ();
}
{}

try
{
}
catch (Exception e)
{
}

break;

case 'c':

case 'C':
try
{
}
{}

try
{
}
catch (Exception e)
{
break;
}

break;

case 'l':
case 'L':
String tecla;

exibicao: for (int i=0;; i++)
{
try
{
System.out.println ("Nome: " +
agenda.getNome (i) +
" - Telefone: " +
agenda.getTelefone (i));
}
catch (Exception e)
{
if (e.getMessage().equals ("Agenda vazia"))
{
break opcoes;
}
else // (e.getMessage().equals ("Nome fora
dos limites"))
break exibicao;
}

if (i%23 == 22 && i<agenda.getQtdContatos()-1)
{
System.out.print ("Tecle ENTER... ");


try
{
tecla = entrada.readLine ();
}
catch (IOException E)
{}

}
}

break;

case 'e':
case 'E':
try
{
}
{}

try
{
}
catch (Exception e)
{
}

break;

case 's':
case 'S':
break;

default :
}
}
}
}



Capacidade desejada para a Agenda: -10
Capacidade invalida

Capacidade invalida


Digite sua Opcao (I=Incluir/C=Consultar/L=Listar/E=Excluir/S=Sair): i
Nome....: Jose
Telefone: 3241.4466

Nome....: Jose
Nome j registrado

Digite sua Opcao (I=Incluir/C=Consultar/L=Listar/E=Excluir/S=Sair): c
Nome....: Jose
Telefone: 3241.4466

Nome....: Joao
Telefone: 3252.9955

Digite sua Opcao (I=Incluir/C=Consultar/L=Listar/E=Excluir/S=Sair): l
Nome: Joao - Telefone: 3252.9955
Nome: Jose - Telefone: 3241.4466

Nome....: Joao
Telefone: 3252.9955

Digite sua Opcao (I=Incluir/C=Consultar/L=Listar/E=Excluir/S=Sair): e
Nome....: Joao

Nome....: Joao
Nome inexistente

Digite sua Opcao (I=Incluir/C=Consultar/L=Listar/E=Excluir/S=Sair): a
Opcao invalida

Digite sua Opcao (I=Incluir/C=Consultar/L=Listar/E=Excluir/S=Sair): s
Classes Membro
J estamos acostumados a ver, dentro da definio de classes, a definio de dados e
funes membros de instncia ou de classe; mas no so apenas os dados e as funes que
podem ser membros, classes tambm podem.
Classes membro nunca so qualificadas com a palavra static, mas, mesmo assim, sempre
so consideradas membros de classe.
Classes membro podem ser qualificadas com as palavras public, private ou protected de
forma a indicar um nvel de acessibilidade diferente do default, exatamente como qualquer
membro. O mais usual, no entanto, que as qualifiquemos como private ou protected.
A Classe Vector
Esta classe implementa um repositrio de instncias de uma dada classe. Tais instncias
podem ser identificadas posicionalmente, sendo zero a posio da primeira delas.
Tal repositrio cresce dinamicamente a medida que mais instncias vo sendo armazenadas
nele. Para otimizar o processo de crescimento, o repositrio cresce sempre de vrias
unidades de armazenamento, e no apenas de uma. Ajustar a capacidade do repositrio

antes de inserir nele uma grande quantidade de objetos uma boa ideia para minimizar o
tempo gasto com realocaes incrementais.
import java.util.Vector;
ou
import java.util.*;
A Classe Hashtable
Esta classe implementa um repositrio de instncias de uma dada classe. Tais instncias
podem ser identificadas de forma direta a partir de uma instncia que funciona como chave
de identificao.
Tal repositrio cresce dinamicamente a medida que mais instncias vo sendo armazenadas
nele. Para otimizar o processo de crescimento, o repositrio cresce sempre de vrias
unidades de armazenamento, e no apenas de uma. Ajustar a capacidade do repositrio
antes de inserir nele uma grande quantidade de objetos uma boa ideia para minimizar o
tempo gasto com realocaes incrementais.
import java.util.Hashtable;
ou
import java.util.*;

Interfaces
Interfaces so, em certo sentido, muito parecidas com classes.Podemos pensar que
interfaces sejam to simplesmente classes totalmente abstratas, ou seja, classes cujos
mtodos, em sua totalidade, so abstratos e, em Java, devem ser qualificados com as
palavras chave public e abstract.
Em vez de serem introduzidas pela palavra chave class, interfaces so introduzidas pela
palavra chave interface.
Os dados de uma interface, se existirem, devero ser todos qualificados com os
modificadores static final; em outras palavras, os dados de uma interface, se existirem,
devero ser constantes de classe.

interface Agenda
{
public int getQtdContatos ();
public boolean haRegistroDoContato (String nom);
public void registreContato (String nom, String tel) throws
Exception;
public String getTelefone (String nom) throws Exception;
public void descarteContato (String nom) throws Exception;
}

[C:\ExplsJava\Expl_12\Agenda1.java]

public class Agenda1 implements Agenda
{
protected int qtdContatos=0;

protected String nome [],
telefone [];

{
int inicio = 0,

meio = 0,
comparacao = -1;

{

return meio+1;
else
if (comparacao < 0)
fim = meio-1;
else
inicio = meio+1;
}

}

public Agenda1 (int cap) throws Exception
{
if (cap <= 0)

}

{
}

{
}

{
}

{


if (posicao > 0)


{
}


this.qtdContatos++;
}

{


if (posicao < 0)

posicao--;

}

{


if (posicao < 0)

posicao--;

int pos;

{
}


this.qtdContatos--;
}

{



return this.nome [pos];
}

{


return this.telefone [pos];
}
}


public class Agenda2 implements Agenda
{
private class Contato
{
private String nome,
telefone;

public Contato (String nom, String tel)
{
this.nome = nom;
this.telefone = tel;
}

public String getNome ()
{
return this.nome;
}

public String getTelefone ()
{
return this.telefone;
}

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

public void setTelefone (String tel)
{

}
}

private int qtdContatos=0;
private Contato contato [];

{
int inicio = 0,
meio = 0,
comparacao = -1;

{
comparacao = nom.compareTo (this.contato[meio].getNome());

return meio+1;
else
if (comparacao < 0)
fim = meio-1;
else
inicio = meio+1;
}

}

public Agenda2 (int cap) throws Exception
{
if (cap <= 0)

this.contato = new Contato [cap];
}

{
return this.contato.length;
}

{
}

{
}

{

if (this.qtdContatos == this.contato.length)


if (posicao > 0)


this.contato [pos+1] = this.contato [pos];

this.contato [posicao] = new Contato (nom,tel);

this.qtdContatos++;
}

{


if (posicao < 0)

posicao--;

return this.contato[posicao].getTelefone();
}

{


if (posicao < 0)

posicao--;

int pos;

this.contato [pos] = this.contato [pos+1];

this.contato [pos] = null;

this.qtdContatos--;
}


{


return this.contato[pos].getNome();
}

{


return this.contato[pos].getTelefone();
}
}


import java.util.Vector;

class Agenda3 implements Agenda
{
private class Contato
{
private String nome,
telefone;

public Contato (String nom, String tel)
{
this.nome = nom;
}

public String getNome ()
{
return this.nome;
}

public String getTelefone ()
{
return this.telefone;
}

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

public void setTelefone (String tel)
{
}

{
if (obj==null)
return false;

if (this.getClass()!=obj.getClass())
return false;

Contato contato = (Contato)obj;

if (!this.nome.equals(obj.nome))
return false;

if (!this.telefone.equals(obj.telefone))
return false;

return true;
}

public int hashcode ()
{
int resultado = 1;

resultado = PRIMO*this.resultado +
this.nome.hashcode();

this.telefone.hashcode();

return resultado;
}
}

private Vector<Contato> contatos = new Vector<Contato> ();

{
int inicio = 0,
fim = this.contatos.size() - 1,
meio = 0,
comparacao = -1;

{
comparacao = nom.compareTo
(this.contatos.elementAt(meio).getNome());


return meio+1;
else
if (comparacao < 0)
fim = meio-1;
else
inicio = meio+1;
}

}

{
return this.contatos.size();
}

{
}

{

if (posicao > 0)


this.contatos.insertElementAt (new Contato (nom,tel), posicao);
}

{
if (this.contatos.size() == 0)


if (posicao < 0)

posicao--;

return this.contatos.elementAt(posicao).getTelefone();
}

{


if (posicao < 0)


posicao--;

this.contatos.removeElementAt (posicao);
}

{

if (pos < 0 || pos >= this.contatos.size())

return this.contatos.elementAt(pos).getNome();
}

{

if (pos < 0 || pos >= this.contatos.size())

return this.contatos.elementAt(pos).getTelefone();
}
}


import java.util.Hashtable;

class Agenda4 implements Agenda
{
private Hashtable<String,String> contatos = new
Hashtable<String,String> ();

{
return this.contatos.size ();
}

{
return this.contatos.containsKey (nom);
}

{
if (this.contatos.containsKey (nom))

this.contatos.put (nom, tel);
}

{
if (this.contatos.size () == 0)

if (!this.contatos.containsKey (nom))

return this.contatos.get (nom);
}

{
if (this.contatos.size () == 0)

if (!this.contatos.containsKey (nom))

this.contatos.remove (nom);
}
}



class TesteDeAgenda
{
public static void main (String Args []) throws IOException
{
Agenda agenda = null;

(System.in));
char opcao;

do
{

System.out.print ("Digite sua opcao (" +
"1=2vetores/" +
"2=1vetor/" +
"3=vector/" +
"4=hashtable)" +

": ");

opcao = (leitor.readline ()).charAt (0);

switch (opcao)
{
case '1':
case '2':
for (;;)
{

System.out.print ("Capacidade desejada para a
Agenda: ");
try
{
int cap = Integer.parseInt (leitor.readline
());

if (opcao=='1')
agenda = new Agenda1 (cap);
else
agenda = new Agenda2 (cap);
}
{}
{
System.err.println ("Nao foi digitado um
numero inteiro");
continue;
}
catch (Exception e)
{
continue;
}

break;
}

break;

case '3':
agenda = new Agenda3 ();
break;

case '4':
agenda = new Agenda4 ();
break;


default :
System.err.println ("Opcao invalida!");
}

}
while ((opcao<'1') || (opcao>'4'));


do
{

"I=Incluir/" +
"C=Consultar/" +
"E=Excluir/" +
"S=Sair)" +
": ");

try
{
opcao = (leitor.readline ()).charAt (0);
}
{}

{
case 'i':
case 'I':
try
{
nome = leitor.readline ();
}
{}

try
{
telefone = leitor.readline ();
}
{}

try
{
}
catch (Exception e)
{

}

break;

case 'c':
case 'C':
try
{
}
{}

try
{
}
catch (Exception e)
{
break;
}

break;

case 'e':
case 'E':
try
{
}
{}

try
{
}
catch (Exception e)
{
}

break;

case 's':

case 'S':
break;

default :
}
}
}
}

C:\ExplsJava\Expl_13> javac TesteDeAgenda.java
Digite sua opcao (1=2vetores/2=1vetor/3=vector/4=hashtable): 7
Opcao invalida!

Digite sua opcao (1=2vetores/2=1vetor/3=vector/4=hashtable): 3

Nome....: Jose
Telefone: 3241.4466

Nome....: Jose
Esse nome ja consta na agenda!

Nome....: Jose
Telefone: 3241.4466

Nome....: Joao
Telefone: 3252.9955


Nome....: Joao
Telefone: 3252.9955

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): e
Nome....: Joao

Nome....: Joao
Nao consta na agenda!

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): a
Opcao invalida!

Digite sua Opcao (I=Incluir/C=Consultar/E=Excluir/S=Sair): s
Herana Mltipla
A linguagem Java no implementa o recurso de herana mltipla de forma to abrangente
quanto fazem outras linguagens, e.g., C++. Veja abaixo as restries que Java impe
herana mltipla:
1. Interfaces no podem derivar de classes;
2. Interfaces podem derivar de mltiplas interfaces (sendo IB
i
e ID nomes de interfaces,
veja abaixo a forma geral do cabealho de uma interface que deriva de outras interfaces:
interface ID extends IB1, IB2,..., IBn);
3. Classes podem derivar de apenas uma outra classe, mas podem derivar de mltiplas
interfaces (sendo CB e CD nomes de classes, e IB
i
nomes de interfaces, veja abaixo a
forma geral do cabealho de uma classe que deriva de uma outra classe e de diversas
interfaces: class CD extends CB implements IB
1
, IB
2
,..., IB
n
).

A Classe java.lang.Object
Esta classe a raiz da hierarquia de classes da linguagem Java, i.e., toda classe a tem como
superclasse. Todos as classes (sejam elas pr-definidas na linguagem ou pelo programador
definidas), incluindo os vetores, herdam as caractersticas desta classe.
So particularmente teis para servirem de base para a implementao genrica de classes
container, i.e., classes armazns.
Isto porque, se fizermos tais classes serem capazes de armazenar instncias desta classe,
torna-las-emos capazes de armazenar instncias de qualquer classe, j que todas as classes
so derivadas desta classe.
Naturalmente, nesta situao, as instncias armazenadas, em certo sentido, perdem sua
identidade e passam coletivamente a serem consideradas instncias de Object.
Assim, ao serem extradas, para que as instncias possam recuperar sua idetidade e, por
conseguinte, ser usadas como instncias das classes usadas em sua criao, as mesmas
devero passar por um processo de converso de tipo, que, neste caso, funcionar mais
como um processo de reposio de tipo do que, propriamente, de converso de tipo.
Classes Abstratas
Conforme sabemos, a herana convencional representa a possibilidade de incorporar e
extender as caractersticas (comportamento e implementao) de uma classe j existente.
Tambm sabemos da existncia de interfaces, que definem comportamentos, sem
implement-los, que podem ser herdados por outras interfaces, bem como implementados
por classes.

Classes abstratas nos oferecem um meio termo, i.e., a possibilidade de herdar alguns
comportamentos implementados, outros por implementar. Os comportamentos no
implementados so representados por mtodos abstratos.
[C:\ExplsJava\Expl_14\Deposito.java]

abstract class Deposito
{
protected Object elem [];
protected int deOndeTirar = 0,
qtosElems = 0;

public Deposito (int cap) throws Exception
{
if (cap <= 0)

this.elem = new Object [cap];
}

public Deposito () throws Exception
{
this (25);
}

public boolean semEspaco ()
{
return this.qtosElems == this.elem.length;
}

public boolean semElementos ()
{
return this.qtosElems == 0;
}

abstract public void guarde (Object elm) throws Exception;
abstract public Object retireElemento () throws Exception;
}

[C:\ExplsJava\Expl_14\Pilha.java]

class Pilha extends Deposito
{
public Pilha (int cap) throws Exception
{
super (cap);
}


public Pilha () throws Exception
{
this (50);
}

public void guarde (Object elm) throws Exception
{
if (this.semEspaco ())
throw new Exception ("Pilha cheia");

this.elem [this.deOndeTirar++] = elm;
this.qtosElems++;
}

public Object retireElemento () throws Exception
{
if (this.semElementos ())
throw new Exception ("Pilha vazia");

Object elm = this.elem [--this.deOndeTirar];

this.qtosElems--;

return elm;
}
}

[C:\ExplsJava\Expl_14\Fila.java]

class Fila extends Deposito
{
private int ondeGuardar = 0;

public Fila (int cap) throws Exception
{
super (cap);
}

public Fila () throws Exception
{
this (100);
}

public void guarde (Object elm) throws Exception
{
if (this.semEspaco ())
throw new Exception ("Fila cheia");

this.elem [this.ondeGuardar] = elm;

this.ondeGuardar = (this.ondeGuardar + 1) % this.elem.length;
this.qtosElems++;
}

public Object retireElemento () throws Exception
{
if (this.semElementos ())
throw new Exception ("Fila vazia");

Object elm = this.elem [this.deOndeTirar];

this.deOndeTirar = (this.deOndeTirar + 1) % this.elem.length;
this.qtosElems--;

return elm;
}
}

[C:\ExplsJava\Expl_14\TesteDeDeposito.java]

class TesteDeDeposito
{
public static void main (String Args [])
{
Deposito deposito = null;


System.out.println ("Teste de Pilha ->");

try
{
deposito = new Pilha ();
}
catch (Exception e)
{}

System.out.println ("Empilhamos, nesta ordem, o seguinte:");

for (float f = 0.0f; f <= 9.0f; f++)
{
try
{
deposito.guarde (new Float (f));
}
catch (Exception e)
{
}
System.out.print (f + " ");
}



System.out.println ("Desempilhamos, nesta ordem, o seguinte:");

while (!deposito.semElementos ())
try
{
System.out.print (deposito.retireElemento () + " ");
}
catch (Exception e)
{
}


System.out.println ("Teste de Fila ->");

try
{
deposito = new Fila ();
}
catch (Exception e)
{}

System.out.println ("Enfileiramos, nesta ordem, o seguinte:");

for (float f = 0.0f; f <= 9.0f; f++)
{
try
{
deposito.guarde (new Float (f));
}
catch (Exception e)
{
}
System.out.print (f + " ");
}


System.out.println ("Desenfileiramos, nesta ordem, o seguinte:");

while (!deposito.semElementos ())
try
{
System.out.print (deposito.retireElemento () + " ");
}
catch (Exception e)
{
}

}
}

C:\ExplsJava\Expl_14> javac TesteDeDeposito.java
C:\ExplsJava\Expl_14> Java TesteDeDeposito
Teste de Pilha ->

Empilhamos, nesta ordem, o seguinte:
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

Desempilhamos, nesta ordem, o seguinte:
9.0 8.0 7.0 6.0 5.0 4.0 3.0 2.0 1.0 0.0

Teste de Fila ->

Enfileiramos, nesta ordem, o seguinte:
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

Desenfileiramos, nesta ordem, o seguinte:
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
Classes Genricas (templates)
Trata-se de um conceito avanado de programao que permite a definio de classes
parametrizadas com tipos que podem ser usados para declarar variveis, parmetros ou
retornos de mtodo.
So especialmente teis para a implementao de classes que atuam como depsito de
informaes, tais como pilhas, filas, listas, entre outras.
Veja o exemplo abaixo:

[C:\ExplsJava\Expl_15\Lista.java]

public class Lista <X extends Comparable<X>>
{
private class No <X extends Comparable<X>>
{
private X info;
private No<X> prox;

public No (X inf, No<X> prx)
{
this.info = inf;
this.prox = prx;
}

public X getInfo ()
{
return this.info;
}

public No<X> getProx ()
{
return this.prox;
}

public void setInfo (X inf)
{
this.info = inf;
}

public void setProx (No<X> prx)
{
this.prox = prx;
}
}

private No<X> prim = null;

public boolean vazia ()
{
return this.prim == null;
}

public void incorpore (X inf) throws Exception
{
if (this.vazia ())
{
this.prim = new No<X> (inf, null);
return;
}

int comp = inf.compareTo (this.prim.getInfo ());

if (comp == 0)

throw new Exception ("Tentativa de incorporar informacao ja
existente");

if (comp < 0)
{
this.prim = new No<X> (inf, this.prim);
return;
}

No<X> ant, atu;

for (ant = this.prim, atu = this.prim.getProx ();
;
ant = atu, atu = atu.getProx ())
{
if (atu == null)
break;

comp = inf.compareTo (atu.getInfo ());

if (comp == 0)
throw new Exception ("Tentativa de incorporar informacao
ja existente");

if (comp < 0)
break;
}

ant.setProx (new No<X> (inf, atu));
}

public boolean possui (X inf)
{
for (No<X> no = this.prim; no != null; no = no.getProx ())
{
int comp = inf.compareTo (no.getInfo ());

if (comp == 0)
return true;

if (comp < 0)
return false;
}

return false;
}

public void descarte (X inf) throws Exception
{
No<X> ant, atu;

for (ant = null, atu = this.prim;
;
ant = atu, atu = atu.getProx ())
{
if (atu == null)

break;

if (inf.compareTo (atu.getInfo()) == 0)
break;
}

if (atu == null)
throw new Exception ("Tentativa de descartar informacao nao
existente");

if (ant == null)
this.prim = atu.getProx ();
else
ant.setProx (atu.getProx ());
}

{
String res = "{";

for (No<X> no = this.prim; no != null; no = no.getProx ())
res = res + no.getInfo () + (no.getProx () == null? "": ", ");

res = res + "}";

return res;
}
}

[C:\ExplsJava\Expl_15\TesteDeLista.java]


class TesteDeLista
{
public static void main (String args []) throws Exception
{
(System.in));

Lista<Float> l1 = new Lista<Float> ();

Float f;


System.out.print ("Teste de Lista em Lista -> ");
System.out.println ("Entre com 10 valores reais: ");

for (int i = 1; i <= 10; i++)
{

f = new Float (entrada.readLine ());
l1.incorpore (f);
}


System.out.println ("Em ordem, os numeros digitados sao: " );
System.out.println (l1);


System.out.print ("Entre com um valor real para ser excluido: ");

try
{
l1.descarte (f);

System.out.println ("Em ordem, apos excluir, a lista ficou:
");
}
catch (Exception e)
{
System.err.println ("O valor real dado nao consta na
lista!");
}


System.out.print ("Entre com dois valores reais ");
System.out.println ("para ver se pertencem a lista: ");


if (l1.possui (f))
System.out.println ("O valor real dado pertence a lista");
else
System.out.println ("O valor real dado nao pertence a
lista");


if (l1.possui (f))
else
lista");

}
}


C:\ExplsJava\Expl_15> java TesteDeLista
Isto poder produzir no console a seguinte sada:
Teste de Lista em Lista -> Entre com 10 valores reais:
9
5
1
3
7
8
2
4
6
0

Em ordem, os numeros digitados sao:
{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}

Entre com um valor real para ser excluido: 7

Em ordem, apos excluir, a lista ficou:
{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 9.0}

Entre com dois valores reais para ver se pertencem a lista:
3
O valor real dado pertence a lista
7
O valor real dado nao pertence a lista

Recurso
Sabemos que o conceito de recurso se encontra entre os mais poderosos recursos de
programao de que se dispe e a linguagem Java, sendo uma linguagem completa, no
poderia deixar de suport-lo.
Trata-se da possibilidade de escrever funes que ativam outras instncias de execuo de
si prprias na implementao de suas funcionalidades

Como pressupomos um bom conhecimento de programao em alguma linguagem
estruturada completa (como Pascal, por exemplo), entendemos que o estudo minucioso
desta tcnica de programao foge ao escopo deste texto e, por isso, limitar-nos-emos a
mencionar sua existncia a assumir que o leitor saiba como empreg-la.
Veja a seguir uma nova verso do exemplo anterior, desta feita implementado de forma
recursiva:
[C:\ExplsJava\Expl_16\Lista.java]

public class Lista <X extends Comparable<X>>
{
private class No <X extends Comparable<X>>
{
private X info;
private No<X> prox;

public No (X inf, No<X> prx)
{
this.info = inf;
this.prox = prx;
}

public X getInfo ()
{
return this.info;
}

public No<X> getProx ()
{
return this.prox;
}

public void setInfo (X inf)
{
this.info = inf;
}

public void setProx (No<X> prx)
{
this.prox = prx;
}
}

private No<X> prim = null;

public boolean vazia ()
{

return this.prim == null;
}

public void incorpore (X inf) throws Exception
{
this.prim = this.insercao (this.prim, inf);
}

private No<X> insercao (No<X> prm, X inf) throws Exception
{
if (prm == null)
return new No<X> (inf, null);

int comp = inf.compareTo (prm.getInfo ());

if (comp == 0)
throw new Exception ("Tentativa de incorporar informacao ja
existente");

if (comp < 0)
return new No<X> (inf, prm);

prm.setProx (this.insercao (prm.getProx (), inf));
return prm;
}

public boolean possui (X inf)
{
return this.tem (this.prim, inf);
}

private boolean tem (No<X> prm, X inf)
{
if (prm == null)
return false;

if (inf.compareTo (prm.getInfo ()) == 0)
return true;

return this.tem (prm.getProx (), inf);
}

public void descarte (X inf) throws Exception
{
this.prim = this.remocao (this.prim, inf);
}

private No<X> remocao (No<X> prm, X inf) throws Exception
{
if (prm == null)
throw new Exception ("Tentativa de descartar informacao nao
existente");

if (inf.compareTo (prm.getInfo ()) == 0)
return prm.getProx ();


prm.setProx (remocao (prm.getProx (), inf));
return prm;
}

{
return "{" + this.numString (this.prim) + "}";
}

private String numString (No<X> prm)
{
if (prm == null)
return "";

String resto = this.numString (prm.getProx ());

if (!resto.equals(""))
resto = ", " + resto;

return prm.getInfo () + resto;
}
}

[C:\ExplsJava\Expl_16\TesteDeLista.java]


class TesteDeLista
{
public static void main (String args []) throws Exception
{
(System.in));

Lista<Float> l1 = new Lista<Float> ();

Float f;


System.out.print ("Teste de Lista em Lista -> ");
System.out.println ("Entre com 10 valores reais: ");

for (int i = 1; i <= 10; i++)
{
l1.incorpore (f);
}



System.out.println ("Em ordem, os numeros digitados sao: " );


System.out.print ("Entre com um valor real para ser excluido: ");

try
{
l1.descarte (f);

System.out.println ("Em ordem, apos excluir, a lista ficou:
");
}
catch (Exception e)
{
System.err.println ("O valor real dado nao consta na
lista!");
}


System.out.print ("Entre com dois valores reais ");
System.out.println ("para ver se pertencem a lista: ");


if (l1.possui (f))
else
lista");


if (l1.possui (f))
else
lista");

}
}

C:\ExplsJava\Expl_16> java TesteDeLista
Isto poder produzir no console a seguinte sada:

Teste de Lista em Lista -> Entre com 10 valores reais:
9
5
1
3
7
8
2
4
6
0

Em ordem, os numeros digitados sao:
{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}

Entre com um valor real para ser excluido: 7

Em ordem, apos excluir, a lista ficou:
{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 9.0}

Entre com dois valores reais para ver se pertencem a lista:
3
O valor real dado pertence a lista
7
O valor real dado nao pertence a lista

Anexo I
Exerccios

I. Classes e Objetos
1. Responda verdadeiro ou falso e justifique: a definio de uma classe reserva espao
de memria para conter todos os dados presentem em sua definio.
2. A finalidade de definir classes :
a) Reservar uma quantidade de memria;
b) Indicar que o programa orientado a objetos;
c) Agrupar dados e funes protegendo-os do compilador;
d) Descrever novos tipos abstratos de dados antes desconhecidos do compilador.
3. A relao entre classes, objetos e instncias a mesma existente entre:
a) Tipos bsicos, variveis e valores desses tipos;
b) Variveis, funes e procedimentos;
c) Constantes, variveis e valores;
d) Constantes, variveis e tipos bsicos.
4. Os membros de classe designados como privativos na definio de uma classe:
a) So acessveis por qualquer funo do programa;
b) So acessveis por qualquer funo de sua classe;
c) So acessveis apenas para a funes de classe de sua classe;

d) So acessveis apenas para a funes de instncia de sua classe.
5. Os membros de instncia designados como privativos na definio de uma classe:
a) So acessveis por qualquer funo do programa;
b) So acessveis por qualquer funo de sua classe;
c) So acessveis apenas para a funes de classe de sua classe;
d) So acessveis apenas para a funes de instncia de sua classe.
6. Responda verdadeiro ou falso: membros privativos definem a atividade interna da
classe e de suas instncias, enquanto os membros pblicos definem o padro de
comunicao da classe e de suas instncias com o mundo exterior a elas.
7. Para acessar um membro de classe presente na definio de uma classe, o operador
ponto conecta:
a) O nome da classe e o nome do membro;
b) O nome do membro e o nome de um objeto da classe;
c) O nome de um objeto da classe e o nome do membro;
d) O nome da classe e o nome de um objeto da classe.
8. Para acessar um membro de instncia presente na definio de uma classe, o
operador ponto conecta:
a) O nome da classe e o nome do membro;
b) O nome do membro e o nome de um objeto da classe;
c) Uma instncia da classe, necessariamente em um objeto da classe, e o nome do
membro.
d) Uma instncia da classe, eventualmente em um objeto da classe, e o nome do
membro.
9. Mtodos so:

a) Classes;
b) Dados-membro;
c) Funes-membro;
d) Chamadas a funes-membro.
10. Mensagens so:
a) Classes;
b) Dados-membro;
c) Funes-membro;
d) Chamadas a funes-membro.
11. Construtores so funes:
a) Que constroem classes;
b) Executadas automaticamente quando uma instncia criada;
c) Executadas automaticamente quando um objeto declarado;
d) Executadas automaticamente quando uma instncia destruda.
12. O nome de um construtor sempre _____________________________________.
13. Responda verdadeiro ou falso: numa classe, possivel haver mais de um construtor
de mesmo nome.
14. Responda verdadeiro ou falso: um construtor do tipo retornado por meio do
comando return.
15. Responda verdadeiro ou falso: um construtor no pode ter argumentos.
16. Destrutores so funes:
a) Que destroem classes;

b) Executadas automaticamente quando uma instncia criada;
c) Executadas automaticamente quando um objeto declarado;
d) Executadas automaticamente quando uma instncia destruida.
17. Assuma que C1, C2 e C3 sejam objetos de uma mesma classe. Quais das seguintes
instrues so vlidas?
a) C1 = C2;
b) C1 = C2 + C3;
c) C1 = C2 = C3;
d) C1 = C2 + 7;
18. Uma funo-membro de classe pode apenas acessar os dados:
a) Da instncia qual est associada;
b) Da classe onde foi definida;
c) Da classe e de qualquer instncia da classe onde foi definida;
d) Da parte pblica da classe onde foi definida.
19. Uma funo-membro de instncia pode apenas acessar os dados:
a) Da instncia qual est associada;
b) Da classe onde foi definida;
c) Da classe e de qualquer instncia da classe onde foi definida;
d) Da parte pblica da classe onde foi definida.
20. Suponha que cinco instncias de uma classe sejam criadas. Quantas cpias dos
dados-membro de classe de sua classe sero armazenadas na memria? Quantas
cpias dos dados-membro de instncia de sua classe sero armazenadas na
memria? Quantas cpias de suas funes-membro de classe de sua classe sero

armazenadas na memria? Quantas cpias de suas funes-membro de instncia de
sua classe sero armazenadas na memria?
21. Escreva uma classe chamada Horario com 3 membros de instncia inteiros
chamados Horas, Minutos e Segundos.
Inclua um construtor que, recebendo como parmetros 3 valores inteiros, inicie
os dados internos da instncia qual se refere;
Crie uma funo-membro de instncia chamada toString que, sem receber
parmetros, retorne uma cadeia de caracteres no formato HH:MM:SS que
represente a instncia qual se refere;
Crie uma funo-membro chamada soma que, recebendo uma instncia da classe
Horario, some-a com a instncia qual se refere, retornando uma instncia da
classe Horario que represente o resultado;
Crie uma funo-membro camada subtracao que, recebendo uma instncia da
classe Horario, o subtraia da instncia qual se refere, retornando uma instncia
da classe Horario que represente o resultado
22. Escreva uma classe chamada Angulo. Suas instncias devero ser capazes de
armazenar um valor angular expresso em graus.
Escreva um construtor que, recebendo um valor angular expresso em graus, o
armazena internamente;
Escreva funes-membro de instncia chamadas valorEmGraus, valorEmGrados
e valorEmRadianos que, sem receber parmetros, retornam, respectivamente, o
valor angular do objeto expresso em graus, grados e radianos.
23. Escreva uma classe chamada Circulo. Suas instncias devero ser capazes de
armazenar as coordenadas do centro, bem como o valor do raio de um crculo.

Escreva um construtor que, recebendo nmeros reais expressando as
coordenadas e o valor do raio de um crculo, armazena essas informaes
internamente;
Escreva uma funo-membro chamada comprimento que, recebendo um objeto
da classe Angulo, retorna o comprimento do arco do crculo com aquela
varredura angular;
Escreva uma funo-membro chamada rea que, recebendo um objeto da classe
Angulo, retorna a rea do setor do crculo com aquela varredura angular.
24. Escreva uma classe chamada Conjunto cujas instncias descrevam conjuntos de
nmeros inteiros. Os valores pertencentes a um Conjunto devero ser armazenados
em uma instncia da classe Lista que dever existir em seu interior.
Escreva um construtor que, sem receber parmetros, inicia a instncia qual se
refere com o conjunto vazio.
Escreva um construtor que, recebendo uma instncia da classe Conjunto, inicia a
instncia qual se refere com os mesmos elementos da instncia recebida.
Escreva uma funo-membro de instncia chamada inclua que, recebendo um
valor inteiro, promove a incluso deste na instncia qual se refere.
Escreva uma funo-membro de instncia chamada elimine que, recebendo um
valor inteiro, o remove da instncia qual se refere.
Escreva uma funo-membro de instncia chamada intersecao que, recebendo
uma instncia da classe Conjunto, produz e retorna uma instncia da classe
conjunto que representa a interseo da instncia qual se refere com a instncia
recebida.
Escreva uma funo-membro de instncia chamada uniao que, recebendo uma
instncia da classe Conjunto, produz e retorna uma instncia da classe conjunto
que representa a unio da instncia qual se refere com a instncia recebida.

Escreva uma funo-membro de instncia chamada pertence que, recebendo
como parmetro um valor inteiro, verifica se o mesmo pertence instncia
qual se refere, retornando o valor lgico verdadeiro, em caso afirmativo, ou o
valor lgico falso, caso contrrio.
Implemente uma funo-membro de instncia chamado toString que, sem
receber nenhum parmetro, produz e retorna um String que representa
textualmente a instncia qual se refere.
25. Suponha a existncia uma classe Sensor que implementa funes de instncia
capazes de controlar um sensor e que dispe de (1) um construtor que, recebendo
um inteiro que representa o nmero de seu identificador, inicia apropriadamente a
instncia qual se refere; e (2) um mtodo de instncia chamado Ativado sem
parmetros que retorna valor lgico que indica a deteco ou no de algo se
movendo em seu campo de viso.
Suponha a existncia uma classe Porta que dispe de (1) um construtor que,
recebendo um inteiro que representa o nmero de seu identificador, inicia
apropriadamente a instncia qual se refere; (2) uma funo (de nome AbraSe) sem
parmetros e sem retorno que, quando executada, faz com que a porta se abra; (3)
uma funo (de nome FecheSe) sem parmetros e sem retorno que, quando
executada, faz com que a porta feche; e (4) uma funo (de nome aberta) sem
parmetros e que retorna true, caso a porta esteja aberta, ou false, caso contrrio.
Valendo-se dessas duas classes, crie a classe PortaAuto para representar uma porta
automtica como as que costumamos encontrar em aeroportos. Pede-se:
Implemente um construtor para inicializar apropriadamente as instncias das
classes Sensor e Porta que existem no interior da instncia qual se refere;
Implemente um mtodo chamado entreEmOperacao que, sem receber
parmetros e nem produzir retornos, faz com que a porta automtica entre em
operao ininterrupta.

ATENO: a porta nunca deve ser aberta, quando j se encontra aberta, e nem
fechada, quando j se encontra fechada.
26. Suponha a existncia uma classe Sensor que implementa funes de instncia
capazes de controlar um sensor de ficha e que dispe de (1) um construtor que,
apropriadamente a instncia qual se refere; e (2) um mtodo de instncia chamado
Ativado sem parmetros que retorna um valor lgico que, se for verdadeiro, indica
que o sensor detectou o depsito de uma ficha, e, se for falso, indica que o sensor
no detectou o depsito de uma ficha (essa funo retorna verdadeiro apenas uma
vez por ficha depositada).
Suponha a existncia uma classe Cancela que implementa funes capazes de
controlar uma cancela eletrnica e que dispe de (1) um construtor que, recebendo
um inteiro que representa o nmero de seu identificador, inicia apropriadamente a
instncia qual se refere; e (2) um mtodo de instncia chamado AbraSe, sem
parmetros e sem retorno, que, quando executada, faz com que a cancela se abra
para a passagem de um veculo, fechando-se automaticamente aps a passagem
deste.
O objetivo deste exerccio , valendo-se dessas duas classes, implementar, DE
FORMA COMPLETA E ADEQUADA, a classe EstacaoDePedagio que
implementa funes capazes de controlar uma estao automtica de cobrana de
pedgio. Pede-se:
Declarar objetos privativos da classe Sensor e Cancela;
Implementar um construtor que, recebendo 2 inteiros (um deles para o construtor
de Sensor e o outro para o construtor de Cancela), inicia apropriadamente a
instncia qual se refere; e
Implementar um mtodo chamado funcione que, sem receber parmetros e sem
produzir retornos, faz com que a estao automtica de cobrana de pedgio
passe a funcionar de forma ininterrupta.

II. Pacotes
1. Assuma que as classes C1 e C2 estejam definidas em pacotes diferentes. Para que
C1 possa ser empregada na definio de C2, necessrio que C1 seja ___________.
2. Para que membros definidos em uma classe possam ser acessados em funes da
definidas em uma classe que se encontra no mesmo pacote, eles devem ter sido
declarados como:
a) public ou private;
b) protected ou private;
c) public ou protected;
d) Nenhuma das anteriores.
3. Para que membros definidos em uma classe publica possam ser acessados em
funes da definidas em uma classe que se encontra em outro pacote, eles devem ter
sido declarados como:
a) public;
b) protected;
c) private;
d) Todas as anteriores.
III. Herana
1. Herana um proceso que permite:
a) A incluso de um objeto dentro de outro;
b) Transformar classes genricas em classes mais especficas;
c) Implementar uma classe semelhante a uma classe existente sem a necessidade de
copi-la ou reescrev-la

d) Relacionar objetos por meio de seus argumentos.
2. As vantagens do uso de herana incluem:
a) Aproveitamento de classes existentes na elaborao de novas classes;
b) Uso de bibliotecas;
c) Concepo top-down de algortmos;
d) Melhor uso da memria.
3. Para derivar uma classe de outra j existente, deve-se:
a) Alterar a classe existente;
b) Reescrever a classe existente;
c) Indicar que a nova classe incorpora as caractersticas da classe existente,
acrescentando nova classe novas caractersticas ou redefinindo na nova classe
caractersticas herdadas;
d) Nenhuma das anteriores.
4. Se em uma classe-base foi definida uma funo de instncia chamada F e em uma
classe dela derivada no foi definida nenhuma funo com este nome, responda: em
que situao a referida funo chamada F poder ser aplicada a uma instncia da
classe derivada?
5. Responda verdadeiro ou falso: suponha que em uma classe-base foi definida uma
funo chamada F e em uma classe dela derivada tambm foi definida uma funo
chamada F, com os mesmos parmetros e retorno. Uma outra funo definida na
classe-derivada pode empregar a funo herdada apesar da redefinio.
6. Responda verdadeiro ou falso: suponha que em uma classe-base foi definida uma
funo chamada F e em uma classe dela derivada tambm foi definida uma funo
chamada F, com os mesmos parmetros e retorno. Uma outra funo definida fora
da classe-derivada pode empregar a funo herdada apesar da redefinio.

7. Classes derivadas incorporam:
a) Todos os membros da classe-base;
b) Somente os membros pblicos da classe-base;
c) Somente os membros protegidos da classe-base;
d) O segundo e o terceiro item so verdadeiros.
8. Responda verdadeiro ou falso: se nenhum construtor existir na classe derivada,
objetos desta classe usaro o construtor sem argumentos da classe-base.
9. Responda verdadeiro ou falso: se nenhum construtor existir na classe derivada,
objetos desta classe podero iniciar os dados herdados de sua classe-base usando o
construtor com argumentos da classe-base.
10. Uma classe dita abstrata quando:
a) Nenhum objeto dela declarado;
b) representada apenas mentalmente;
c) S pode ser usada como base para outras classes;
d) definida de forma obscura.
11. A converso de tipos implcita usada para:
a) Armazenar instncias de uma classe-derivada em objetos de sua classe-base;
b) Armazenar instncias de uma classe-base em objetos de uma classe dela
derivada;
c) Armazenar instncias de uma classe-derivada em objetos de sua classe-base e
vice-versa;
d) Nao pode ser usada para converso de objetos.
12. Responda verdadeiro ou falso: uma classe derivada no pode servir de base para
outra classe.

13. Responda verdadeiro ou falso: um objeto de uma classe pode ser membro de outra
classe.
14. Suponha implementada uma classe chamada Pto para representar um ponto no plano
cartesiano. As estruturas internas desta classe supostamente so desconhecidas e
seus mtodos pblicos devem ser considerados como sendo os seguintes:
Um construtor que, recebendo um par de nmeros reais, respectivamente as
coordenadas de um ponto no plano cartesiano, inicie apropriadamente a
instncia qual se refere;
Um mtodo de instncia chamado X que retorna a coordenada X da instncia
qual se refere e um mtodo de instncia chamado Y que retorna a coordenada Y
da instncia qual se refere.
O objetivo desta questo implementar uma classe chamada Ponto, derivada da
classe Pto, para representar, de forma mais completa, um ponto no plano cartesiano.
Sabendo que:
A distncia entre os pontos P
1
= (x
1
, y
1
) e P
2
= (x
2
, y
2
) dada pela seguinte
expresso:
A inclinao da reta que passa pelos pontos P
1
= (x
1
, y
1
) e P
2
= (x
2
, y
2
) dada
pela seguinte expresso:
Pede-se:
Declare a classe Ponto e as estruturas internas que a definem;
Implemente um mtodo de instncia chamado Distancia que, recebendo como
parmetro uma instncia da classe Ponto, retorna a distncia do ponto
2
1 2
2
1 2
) ( ) ( y y x x
) (
) (
1 2
1 2
x x
y y

representado pela instncia qual se refere at o ponto representado pela
instncia recebida como parmetro;
Implemente um mtodo de instancia chamado Inclinacao que retorna a
inclinao da reta imaginria que une o ponto representado pela instancia qual
se refere origem do sistema cartesiano.
15. Suponha a existncia uma classe Sensor que dispe de (1) um construtor que,
apropriadamente a instncia qual se refere; e (2) uma funo (de nome
Velocidade) sem parmetros que retorna um real que indica a velocidade do objeto
detectado (indicar sempre zero no caso de nada estar sendo detectado).
Suponha a existncia uma classe Camera que dispe de (1) um construtor que,
apropriadamente a instncia qual se refere; (2) uma funo (de nome Fotografe)
que recebe um parmetro real e sem retorno que, quando executada, faz com que a
cmera bata uma foto na qual aparecer no canto inferior direito o horrio em que a
foto foi batida (a cmera tem um relgio interno) e String que vem a esta funo
como parmetro.
Pede-se:
Derivada da classe Sensor e valendo-se da classe Camera, crie a classe Radar
para representar um radar como estes que encontramos instalados nas principais
ruas e avenidas das grandes cidades;
Implemente um construtor que recebe como parmetro 2 nmeros inteiros (um
deles para o construtor de Sensor e o outro para o construtor de Camera) e um
nmero real que representa a velocidade mxima da via na qual o radar vai ser
instalado, iniciando apropriadamente a instncia qual se refere;
Implemente uma funo de instncia pblica, chamada entreEmAcao, que
coloca em operao de forma ininterrupta uma instncia da classe Radar.

III. Classes Genricas (templates)
1. Implemente uma classe chamada Arvore que represente uma rvore binria de
busca:
Implemente um mtodo chamado incorpore que, sem produzir retorno e
recebendo como parmetro a informao que se deseja incluir na rvore,
promove sua incorporao;
Implemente um mtodo chamado descarte que, sem produzir retorno e
recebendo como parmetro a informao que se deseja descartar da rvore,
promove seu descarte;
Implemente um mtodo chamado possui que, recebendo como parmetro a
informao que se deseja procurar na rvore, promove sua busca, retornando
true ou false, conforme a informao procurada exista ou no na rvore;
Implemente um mtodo chamado balanceieSe que, sem receber parmetros e
sem produzir retorno, balanceia a rvore (implemente e use quantos mtodos
privativos auxiliares precisar).

Anexo II
Bibliografia

SUN Microsystems, "The Java Tutorial", (http://java.sun.com/docs/books/tutorial/).
SUN Microsystems, "The Java Language Specification",
(http://java.sun.com/docs/books/jls/index.html).
SUN Microsystems, "The Java API Specification",
(http://java.sun.com/products/jdk/1.2/docs/api/index.html).
SUN Microsystems, "The Java VM Specification",
(http://java.sun.com/docs/books/vmspec/index.html).
Naughton, Patrick, "Dominando o Java", Makron Books, 1997.
Morrison, M.; "Java Unleashed", December, J.; et alii; SAMS Publishing.
Naughton, P.; "Dominando o Java"; Makron Books.
Linden, P.; "Just Java"; Makron Books.
Fraizer, C.; e Bond, J.; "API Java: Manual de Referncia"; Makron Books.
Thomas, M.D.; Patel, P.r.; et alii; "Programando em Java para a Internet"; Makron Books.
Ritchey, T.; "Programando Java e JavaScript"; Quark Editora.

Apostilade POOe Java

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apostilade POOe Java

Transféré par

Droits d'auteur :

Formats disponibles

Centro de Cincias Exatas,

Orientao a Objetos na Linguagem de Programao Java Pgina 176

Vous aimerez peut-être aussi