-
ndice1 Introduo ao
Java.........................................................................................................................................1
1.1 Histrico do
Java...............................................................................................................................11.1.1
O Java
Hoje.............................................................................................................................1
1.2 Vantagens e Caractersticas da
Linguagem......................................................................................11.2.1
Simples....................................................................................................................................11.2.2
Orientada a
Objetos.................................................................................................................21.2.3
Distribuda...............................................................................................................................21.2.4
Robusta....................................................................................................................................21.2.5
Segura......................................................................................................................................21.2.6
Neutra em Relao
Arquitetura............................................................................................31.2.7
Portvel....................................................................................................................................31.2.8
Interpretada..............................................................................................................................31.2.9
Alto
Desempenho....................................................................................................................31.2.10
Mltiplas Linhas de Execuo
(Multithreading)...................................................................41.2.11
Dinmica...............................................................................................................................4
1.3 Java e a
Internet................................................................................................................................41.3.1
Programas Autnomos (Standalone) X
Applets.....................................................................5
1.4 Um Primeiro Programa em
Java.......................................................................................................51.5
Compilando e Executando o Primeiro Aplicativo em
Java..............................................................51.6
Um Ambiente Java
Tpico................................................................................................................6
1.6.1
Edio......................................................................................................................................61.6.2
Compilao..............................................................................................................................61.6.3
Carga.......................................................................................................................................61.6.4
Verificao..............................................................................................................................61.6.5
Execuo
(Interpretao).........................................................................................................6
1.7 Diferenas entre J2SE, J2EE,
J2ME.................................................................................................71.8
Links
Indicados.................................................................................................................................7
2 Estruturas Fundamentais de Programao em
Java..................................................................................82.1
Comentrios......................................................................................................................................82.2
Tipos de
Dados.................................................................................................................................8
2.2.1
Inteiros.....................................................................................................................................82.2.2
Tipos de Ponto
Flutuante.........................................................................................................92.2.3
O Tipo Caractere
(char)...........................................................................................................92.2.4
O Tipo
Boolean.....................................................................................................................10
2.3
Variveis.........................................................................................................................................102.3.1
Atribuies e
Inicializaes...................................................................................................102.3.2
Converses entre Tipos
Numricos.......................................................................................112.3.3
Constantes.............................................................................................................................11
2.4
Operadores......................................................................................................................................122.4.1
Exponenciao.......................................................................................................................122.4.2
Operadores de Incremento e
Decremento.............................................................................122.4.3
Operadores Relacionais e
Lgicos........................................................................................132.4.4
Operadores
bitabit.............................................................................................................132.4.5
Hierarquia de Operadores e
Parnteses.................................................................................13
2.5
Strings.............................................................................................................................................142.5.1
Concatenao.........................................................................................................................142.5.2
Substrings..............................................................................................................................142.5.3
Edio de
Strings...................................................................................................................152.5.4
Teste de Igualdade de
Strings................................................................................................15
2.6 Comandos de Entrada e
Sada.........................................................................................................152.7
Estruturas de
Controle.....................................................................................................................16
2.7.1 Instrues Condicionais Comando
if/else..........................................................................162.7.2
Laos Indeterminados Comandos while e
do/while...........................................................17
i
-
ndice2 Estruturas Fundamentais de Programao em Java
2.7.3 Laos Determinados Comando
for.....................................................................................192.7.4
Selees Mltiplas A Instruo
switch..............................................................................192.7.5
Arrays....................................................................................................................................202.7.6
Cpia de
Arrays.....................................................................................................................212.7.7
Arrays
Multidimensionais.....................................................................................................22
2.8 Exerccios de
Reviso.....................................................................................................................22
3 Classes e
Objetos...........................................................................................................................................243.1
Introduo Programao Orientada a
Objetos.............................................................................24
3.1.1 Java e a Orientao a
Objetos................................................................................................243.1.2
Cdigo versus
Dados.............................................................................................................243.1.3
Abstrao...............................................................................................................................243.1.4
Os trs princpios da orientao a
objetos.............................................................................253.1.5
Encapsulamento.....................................................................................................................253.1.6
Herana..................................................................................................................................273.1.7
Polimorfismo.........................................................................................................................27
3.2 Classes em
Java...............................................................................................................................283.2.1
A classe
Caixa.......................................................................................................................29
3.3 Variveis de
instncia.....................................................................................................................303.4
Criando
objetos...............................................................................................................................31
3.4.1 Detalhes sobre
new................................................................................................................323.4.2
Entendendo as
referncias.....................................................................................................333.4.3
Entendendo os
mtodos.........................................................................................................333.4.4
Acrescentando um mtodo classe
Caixa............................................................................343.4.5
Valor retornado por um
mtodo............................................................................................363.4.6
Mtodos com
parmetros......................................................................................................373.4.7
Construtores...........................................................................................................................393.4.8
Construtores
Parametrizados.................................................................................................413.4.9
A palavrachave
this.............................................................................................................423.4.10
A classe
Pilha......................................................................................................................433.4.11
Sobrecarga de
Mtodos.......................................................................................................463.4.12
Sobrecarga de
Construtores.................................................................................................49
3.5 O controle de acesso em
Java.........................................................................................................513.6
public e
private................................................................................................................................52
3.6.1 A nova classe
Pilha................................................................................................................533.6.2
A palavrachave
static..........................................................................................................553.6.3
final: constantes em
Java.......................................................................................................57
3.7 Pacotes
Java....................................................................................................................................573.7.1
Criando uma classe
reutilizvel.............................................................................................573.7.2
Nome dos
Pacotes.................................................................................................................583.7.3
Incluso da classe no
pacote..................................................................................................59
3.8 Revendo a
herana..........................................................................................................................593.8.1
A herana e o acesso aos
membros.......................................................................................613.8.2
Outro exemplo de
herana.....................................................................................................623.8.3
A palavrachave
super..........................................................................................................633.8.4
Chamando o construtor da
superclasse.................................................................................643.8.5
Chamando membros com
super............................................................................................673.8.6
Construtores: ordem de
chamada..........................................................................................68
3.9 Superposio de mtodos
(Polimorfismo)......................................................................................693.9.1
Classes
abstratas....................................................................................................................713.9.2
final e a
herana.....................................................................................................................743.9.3
A classe
Object......................................................................................................................75
3.10
Interfaces.......................................................................................................................................75
ii
-
ndice3 Classes e Objetos
3.10.1 Estendendo
interfaces..........................................................................................................773.11
Exreccios de
Reviso...................................................................................................................78
4 Diferena entre String e
StringBuffer.........................................................................................................804.1
Imutabilidade da classe
String........................................................................................................804.2
Transformao implcita de String para
StringBuffer....................................................................804.3
Otimizao do
cdigo.....................................................................................................................814.4
Mtodos length, capacity, setLength e ensureCapacity de
StringBuffer........................................814.5 Mtodos
charAt, setCharAt, getChars e reverse de
StringBuffer...................................................814.6
Links
indicados:..............................................................................................................................824.7
Sugestes so
bemvindas:............................................................................................................82
5 Tratamento de
Erros....................................................................................................................................835.1
Viso
Geral.....................................................................................................................................83
5.1.1 Requerimentos
Java...............................................................................................................845.1.2
Captura..................................................................................................................................845.1.3
Especificao.........................................................................................................................845.1.4
Excees
conferidas..............................................................................................................845.1.5
Excees que podem ser lanadas dentro do escopo do
mtodo..........................................84
5.2 Capturando e Tratando
Excees....................................................................................................855.2.1
O bloco
try.............................................................................................................................855.2.2
O bloco
catch.........................................................................................................................855.2.3
O bloco
finally.......................................................................................................................875.2.4
Reunindo
tudo.......................................................................................................................885.2.5
Tratador de
exceo...............................................................................................................885.2.6
Especificando as Excees Lanadas por um
mtodo..........................................................89
5.3 Como Lanar
Excees...................................................................................................................905.3.1
O comando
Throw.................................................................................................................905.3.2
A Clusula
throws.................................................................................................................915.3.3
A Classe Throwable e Suas
Subclasses.................................................................................915.3.4
Excees de
Runtime............................................................................................................925.3.5
Diviso por
zero....................................................................................................................925.3.6
Criando Suas Prprias Classes de
Exceo...........................................................................935.3.7
Escolhendo o Tipo de Exceo para se
Lanar.....................................................................935.3.8
Escolhendo um
Superclasse..................................................................................................945.3.9
Conveno de
nomes.............................................................................................................94
5.4
Assertions........................................................................................................................................945.4.1
Introduo..............................................................................................................................945.4.2
Habilitar
assertions................................................................................................................965.4.3
A Classe
AssertionError........................................................................................................965.4.4
Introduzindo assertions no
cdigo.........................................................................................985.4.5
Invariantes
internas................................................................................................................985.4.6
Invariantes de controle de
fluxo..........................................................................................1005.4.7
Invariantes de Classe, Condies prvias, Condies
posteriores......................................1005.4.8
Invariantes de
classe............................................................................................................1005.4.9
Condies
prvias................................................................................................................1015.4.10
Condies prvias de estado de fechamento (Lock
status)...............................................1025.4.11
Condies
posteriores........................................................................................................1025.4.12
Outras
situaes.................................................................................................................1035.4.13
Compilando arquivos que utilizam
assertions...................................................................1045.4.14
Habilitando e Desabilitando
assertions.............................................................................104
5.5 Exerccios de
Reviso...................................................................................................................105
iii
-
ndice6 Classes
Aninhadas.......................................................................................................................................106
6.1 Classe
Aninhada............................................................................................................................1066.2
Classe aninhada dentro de outra classe
aninhada.........................................................................1076.3
Classes aninhadas
estticas...........................................................................................................107
6.3.1 Classe aninhada esttica de
teste.........................................................................................1086.4
Classes internas
locais...................................................................................................................1096.5
Classes internas
annimas.............................................................................................................1096.6
Modificadores de
acesso...............................................................................................................1106.7
Termos
utilizados..........................................................................................................................1126.8
Links
indicados.............................................................................................................................1126.9
Exerccios......................................................................................................................................112
7 Introduo ao
AWT....................................................................................................................................1137.1
Exemplo
simples...........................................................................................................................1137.2
Tratamento de
eventos..................................................................................................................113
8 Tratamento de Eventos e
AWT.................................................................................................................1178.1
Viso Geral do
AWT....................................................................................................................117
8.1.1 Estrutura do
AWT...............................................................................................................1178.2
Tratamento de
Eventos.................................................................................................................117
8.2.1
ActionListener.....................................................................................................................1208.2.2
ItemListener.........................................................................................................................1218.2.3
TextListener.........................................................................................................................1218.2.4
KeyEvent.............................................................................................................................1218.2.5
MouseListener e
MouseMotionListener.............................................................................1228.2.6
FocusListener......................................................................................................................1228.2.7
AdjustmentListener.............................................................................................................122
8.3 Utilizando Componentes e
Containers..........................................................................................1228.3.1
Instanciao dos
componentes............................................................................................1238.3.2
Adio do componente
interface......................................................................................1238.3.3
Registro dos mtodos de tratamento de
eventos.................................................................1238.3.4
Containers e
Componentes..................................................................................................123
8.4 Componentes
Bsicos...................................................................................................................1268.4.1
Frame...................................................................................................................................1268.4.2
Label....................................................................................................................................1278.4.3
Button..................................................................................................................................1288.4.4
TextField.............................................................................................................................1298.4.5
Panel....................................................................................................................................1318.4.6
TextArea..............................................................................................................................1328.4.7
List.......................................................................................................................................1348.4.8
Choice..................................................................................................................................1378.4.9
Checkbox.............................................................................................................................1398.4.10
CheckboxGroup.................................................................................................................140
9 Aplicaes Grficas com
Swing.................................................................................................................1439.1
Viso
Geral...................................................................................................................................1439.2
Arquitetura ModeloVisoControlador (MVC
ModelViewController)............................1459.3 Exemplo
prtico
MVC..................................................................................................................146
9.3.1 Criando o Modelo
(Observable)..........................................................................................1469.3.2
Criando a Viso
(Observer).................................................................................................1479.3.3
Testando o padro
Observable/Observer............................................................................1489.3.4
Criando o controlador (Concluindo o padro
MVC)..........................................................149
9.4 Substituindo componentes AWT por
Swing................................................................................1529.4.1
MVC no
Swing....................................................................................................................153
iv
-
ndice9 Aplicaes Grficas com Swing
9.4.2 Alterando o LookandFeel
...........................................................................................1549.4.3
Gerenciadores de
Layout.....................................................................................................1549.4.4
FlowLayout.........................................................................................................................1549.4.5
GridLayout..........................................................................................................................1559.4.6
BorderLayout.......................................................................................................................1569.4.7
CardLayout..........................................................................................................................1579.4.8
GridBagLayout....................................................................................................................1589.4.9
Conhecendo os parametros do
GridBagConstraints............................................................159
9.4.9.1 gridx,
gridy.................................................................................................................1599.4.9.2
weightx e
weighty......................................................................................................1609.4.9.3
fill...............................................................................................................................1609.4.9.4
anchor.........................................................................................................................1619.4.9.5
gridwidth,
gridheight.................................................................................................1619.4.9.6
insets..........................................................................................................................161
9.4.10
BoxLayout.........................................................................................................................1629.4.11
Usando a classe
Box..........................................................................................................163
9.4.11.1 Rigid
Area................................................................................................................1639.4.11.2
Glue..........................................................................................................................1639.4.11.3
Horizontal................................................................................................................1639.4.11.4
Vertical.....................................................................................................................164
9.5 Componentes Bsicos
Swing........................................................................................................1649.5.1
Janelas.................................................................................................................................1649.5.2
Frames.................................................................................................................................165
9.5.2.1 Frames Internos
(JInternalFrame)..............................................................................1669.5.3
JLabel..................................................................................................................................169
9.5.3.1 JLabel com
atalhos.....................................................................................................1699.5.3.2
JLabel com
Imagens..................................................................................................171
9.5.4
Botes..................................................................................................................................1729.5.4.1
JButton.......................................................................................................................1729.5.4.2
JButtom com Imagens e
atalho..................................................................................1739.5.4.3
Eventos.......................................................................................................................1739.5.4.4
JCheckBox.................................................................................................................1749.5.4.5
JRadioButton.............................................................................................................1759.5.4.6
JToggleButton............................................................................................................176
9.5.5 Componentes de
texto.........................................................................................................1779.5.5.1
Text
Controls.............................................................................................................1779.5.5.2
JTextField..................................................................................................................1789.5.5.3
JPasswordField..........................................................................................................1789.5.5.4
Validando o contedo de um
JTextField...................................................................178
9.5.5.4.1
ActionValidated.............................................................................................1789.5.6
Pain Text
Controls...............................................................................................................180
9.5.6.1
JTextArea...................................................................................................................1809.5.7
Listas...................................................................................................................................181
9.5.7.1 Tipos de
seleo.........................................................................................................1829.5.7.2
Eventos.......................................................................................................................1829.5.7.3
Eventos do
Mouse......................................................................................................1839.5.7.4
Observando as alteraes na
lista..............................................................................184
9.5.8
JComboBox.........................................................................................................................1859.6
Exerccios de
Reviso...................................................................................................................186
10
Applets.......................................................................................................................................................18710.1
Viso
Geral.................................................................................................................................18710.2
Criando e executando uma applet
simples..................................................................................187
v
-
ndice10 Applets
10.3 Como funciona uma
applet?.......................................................................................................19110.4
Segurana....................................................................................................................................19210.5
Passando parmetros para
applets...............................................................................................19310.6
Janelas e
Applets.........................................................................................................................19410.7
Links
indicados...........................................................................................................................19610.8
Exerccios de
reviso..................................................................................................................196
vi
-
1 Introduo ao Java1.1 Histrico do JavaA principal contribuio do
surgimento e da revoluo dos microprocessadores para a atualidade,
foi apossibilidade do desenvolvimento de computadores pessoais,
usados, hoje, por milhes de pessoas no mundotodo. Os computadores
pessoais tiveram um profundo impacto sobre as pessosas e a maneira
como asorganizaes conduzem e gerenciam seus negcios. Muitos
acreditam que a prxima rea importante em queos microprocessadores
tero impacto sero os dispositivos eletrnicos inteligentes
destinados ao consumidorfinal.
Com base nisso, a Sun Microsystems financiou uma pesquisa
corporativa interna, com o codinome Green, em1991. O projeto
resultou no desenvolvimento de uma linguagem baseada em C e C++,
que seu criador, JamesGosling, chamou de Oak, em homenagem a uma
rvore que dava para a janela do seu escritrio na Sun.Descobriuse,
mais tarde, que j havia uma linguagem de computador chamada Oak.
Quando uma equipe daSun visitou uma cafeteria local, o nome Java
(cidade de origem de um tipo de caf importado) foi sugerido
eadotado.
A linguagem Java devia obedecer os seguintes requisitos: alto
poder de processamento; pouco consumo dememria; neutralidade em
relao arquitetura (portabilidade).
No entanto, o projeto Green atravessava algumas dificuldades. O
mercado para dispositivos eletrnicosinteligentes destinados ao
consumidor final no estava se desenvolvendo to rapidamente como a
Sun tinhaprevisto. Alm disso, um contrato importante pelo qual a
Sun competia fora concedido a outra empresa.Conseqentemente, o
projeto quase se deu por cancelado. Por pura sorte, a World Wide
Web explodiu empopularidade em 1993 e a equipe da Sun viu o
imediato potencial de se utilizar Java para a criao de pginasda Web
com contedo dinmico. Isso deu nova vida ao projeto.
Em maio de 1995, a Sun anunciou Java oficialmente em uma
conferncia mundial. Normalmente, um eventocomo esse no teria gerado
muita ateno. Entretanto, Java gerou interesse imediato na
comunidade comercialpor causa do grande interesse pela World Wide
Web.
1.1.1 O Java HojeAtualmente, Java utilizada para criar pgnias da
Web com contedo interativo e dinmico, para desenvolveraplicativos
corporativos de grande porte, para aprimorar a funcionalidade de
servidores da World Wide Web(os computadores que fornecem o contedo
que vemos em nossos navegadores da Web), fornecer aplicativospara
dispositivos destinados ao consumidor final (como telefones
celulares, pagers, handelds, palm's) e paramuitas outras
finalidades.
1.2 Vantagens e Caractersticas da LinguagemAs principais
caractersticas e vantagens da linguagem Java so as seguintes:
1.2.1 Simples
A sintaxe da linguagem Java uma verso bastante parecida com a
sintaxe da linguagem C++. No entanto,Java no possui alguns recursos
demasiadamente complicados de C++, recursos estes que induzem
oprogramador C++ a uma grande quantidade de erros.
Em Java, no existe a alocao e liberao manuais de memria. A
memria tem coleta de lixo automtica.Alm disso, foram eliminados:
utilizao de ponteiros, herana mltipla, arquivos de cabealhos
(headers),
1 Introduo ao Java 1
-
estruturas, unies, sobrecarga de operadores, classes de base
virtuais, etc. Java tambm no suporta o uso dooperador goto.
1.2.2 Orientada a ObjetosJava totalmente orientada a objetos, o
que significa que tem um enfoque diferente das
linguagenstradicionalmente procedurais. Em programao procedural,
modelamos a realidade atravs de funesque manipulam dados. Na
programao orientada a objetos (POO), a modelagem da realidade
realizadaatravs de abstraes denominadas objetos.
Os recursos de programao orientada a objetos da linguagem Java
so oriundos, essencialmente, dalinguagem C++. No entanto, em Java
eliminouse a herana mltipla, introduzindo o conceito de
interface.
A programao orientada a objetos se concentra nos objetos e na
comunicao entre eles (interface).
1.2.3 Distribuda
Java foi projetada para suportar aplicaes em rede. A linguagem
Java tem uma extensa biblioteca de rotinaspara lidar com protocolos
TCP/IP, como HTTP e FTP. Desta forma, aplicaes Java podem acessar
arquivos eobjetos atravs da rede (Internet) com a mesma facilidade
que se acessa um arquivo no sistema local.
1.2.4 Robusta
Java permite a escrita de programas confiveis, dando nfase
verificao antecipada de possveis problemas(em tempo de compilao),
verificao dinmica posterior (em tempo de execuo) e eliminao
desituaes sujeitas a erro.
Os principais pontos que conferem robustez linguagem Java so a
eliminao do uso de ponteiros, ogerenciamento automtico de memria e
o tratamento de excees.
Java dispensa o uso de ponteiros, mas cria outras estruturas de
dados semelhantes, que desempenham amesma funo, porm com maior
facilidade e preservando completa segurana.
O gerenciamento automtico de memria feito atravs de um coletor
automtico de lixo, que responsvelpela eliminao dos objetos que no
possuem mais referncias. Esse coletor de lixo executado na forma
deum thread de baixa prioridade, em segundo plano, quando o
programa no estiver utilizando muitos ciclos doprocessador, ou
quando houver uma necessidade imediata de mais memria.
O tratamento de excees outra caracterstica em Java que contribui
para programas mais robustos. Umaexceo um sinal proveniente de
alguma condio excepcional, tal como um erro que tenha ocorrido.
1.2.5 Segura
Segurana um assunto importante, uma vez que Java foi projetada
para ser usada em ambientes de rede. Semnenhuma certeza de
segurana, ningum bem informado gostaria de carregar um applet
(programa Java queroda em browsers, tais como Netscape ou Internet
Explorer) de um site da Internet e deixlo rodando em seucomputador.
Java imlementa vrios mecanismos de segurana para proteger contra um
cdigo que poderiatentar criar um vrus ou invadir o sistema de
arquivos.
Segurana anda de mos dadas com robustez. O modelo de alocao de
memria de Java uma de suasprincipais defesas contra cdigo
malicioso. Como j foi visto, Java no implementa ponteiros.
Portanto, umprogramador no pode forjar ponteiros indevidos para a
memria. Mais importante, o compilador Java nodetermina decises de
layout de memria. Portanto, um programador no pode inferir o layout
de memria
$LOGOIMAGE 1 Introduo ao Java
1.2.2 Orientada a Objetos 2
-
verdadeiro de uma classe examinando somente sua declarao.
Referncias de memria no cdigo de Javacompilado so transformadas em
endereos de memria real em tempo de execuo pelo interpretador
Java.
Muitas das defesas de Java foram projetadas para proteger de
applets no confiveis. O sistema de tempo deexecuo Java usa um
processo de verificao de cdigos de bytes (bytecodes) para assegurar
que o cdigocarregado pela rede no viola nenhuma restrio da
linguagem. Outra medida de segurana adotada a de quenenhum applet
pode ler ou escrever em arquivos locais.
1.2.6 Neutra em Relao ArquiteturaO compilador Java gera um
formato de arquivo de objeto neutro em relo arquitetura o cdigo
compilado executvel em muitos processadores, dada a presena do
sistema Java de tempo de execuo (JVM JavaVirtual Machine ou Mquina
Virtual Java). O compilador Java faz isso gerando instrues em
bytecodes quenada tm a ver com uma arquitetura particular de um
computador especfico. Em vez disso, elas soprojetadas para serem
fceis de interpretar em qualquer mquina e convertidas facilmente
para o cdigonativo da mquina em tempo real.
1.2.7 Portvel
A linguagem de programao Java possibilita a portabilidade de
vrias formas. Duas delas so:
A linguagem Java interpretada. Isso significa que cada
computador que pretenda utilizla devepossuir um programa que
converta os cdigos em Java para o cdigo nativo da mquina.
A linguagem Java no permite que equipamentos particulares
implementem tamanhos diferentes paratipos fundamentais como integer
(inteiros) ou bytes.
1.2.8 Interpretada
O interpretador Java pode executar bytecodes Java diretamente em
qualquer mquina na qual o interpretadortenha sido escrito.
Com a execuo ocorrendo em um ambiente interpretado, o cdigo em
Java no precisa estar de acordo comas exigncias de plataformas de
hardware individuais. O compilador Java que cria os programas
executveis apartir do cdigofonte gera a compilao para um
equipamento que no existe a Java Virtual Machine(Mquina Virtual
Java). A Java Virtual Machine uma especificao para um processador
hipottico capaz deexecutar cdigos em Java.
O problema tradicional relacionado aos interpretadores sempre
foi o baixo desempenho. A linguagem Javatenta contornar essa
dificuldade gerando a compilao para um estgio intermedirio,
convertendo ocdigofonte em cdigo de bytes (bytecodes) o qual, por
sua vez, pode ser convertido de forma eficiente emcdigo nativo para
um processador particular.
1.2.9 Alto Desempenho
Tipicamente, o custo de tais caractersticas de portabilidade,
segurana e robustez se manifestaria na reduode desempenho. No seria
razovel supor que cdigos interpretados pudessem ser executados com
velociadeequivalente aos cdigos nativos.
Embora o desempenho dos bytecodes interpretados seja geralmente
mais do que adequado, h situaes emque necessrio um desempenho
superior. Os bytecodes podem ser convertidos em tempo real para o
cdigode mquina da CPU particular onde o aplicativo est
executando.
$LOGOIMAGE 1 Introduo ao Java
1.2.6 Neutra em Relao Arquitetura 3
-
Alm disso, Java utiliza alguns truques que reduzem de forma
significativa a quantidade de processamentoadicional:
Multithreading incorporado Cdigo de bytes eficientes Compilao
justintime Habilidade de linkeditar em mtodos nativos em C
Uma das formas utilizadas por Java para superar os problemas de
desempenho associados aos interpretadorestradicionais envolve a
incluso de uma capacidade interna de multithreading. No fato comum
que osprogramas utilizem de forma constante os ciclos da CPU. Em
vez disso, os programas devem aguardarentradas de dados feitas por
usurios, bem como acessos a arquivos e redes. Essas aes deixam o
processadorem situaes de inatividade quando utilizadas aplicaes de
thread nico. Como alternavtiva, Java utilizaesses perodos de
inatividade para executar as tarefas necessrias de coleta de lixo e
outras manutenesgerais de sistema, as quais so responsveis pela
reduo da velociade de execuo de muitas aplicaes emsistemas
interpretados.
Alm disso, os cdigos de byte compilados de Java so muito prximos
aos cdigos de mquina. Portanto, aimplementao em plataformas
especficas pode ser bastante eficiente. Nos casos onde o
interpretador noseria suficiente, o programador possui duas opes:
compilar o cdigo no momento da execuo para ocdigo nativo, ou a
linkedio de cdigo nativo em C. A linkedio de cdigo nativo em C
constitui aalternativa mais veloz, mas gera um esforo adicional
sobre o programador e reduz a portabilidade. Acompilao no momento
de execuo significa que o cdigo ainda se mantm porttil, mas ocorre
umademora inicial durante a compilao deste cdigo.
1.2.10 Mltiplas Linhas de Execuo (Multithreading)No Java, ao
invs de termos vrios processos em execuo podemos ter um processo
com vrios fluxos/linhasde execuo, compartilhando um mesmo espao de
endereamento. Isso chamdo de Multithreading.
Os benefcios das mltiplas linhas de execuo so melhor capacidade
de resposta interativa e melhorcomportamento em tempo real de
execuo.
As linhas de execuo (threads) em Java tambm tm a capacidade de
aproveitar sistemas com vriosprocessadores se o sistema operacional
base souber fazlo.
Por outro lado, as implementaes de linhas de execuo nas
plataformas principais diferem largamente e oJava no faz nenhuma
tentativa de ser independente da plataforma a esse respeito.
Somente o cdigo parachamar mltiplas linhas de execuo permanece o
mesmo nas vrias mquinas; a linguagem Java passa aimplementao de
mltiplas linhas de execuo para o sistema operacional
subjacente.
1.2.11 Dinmica
Java uma linguagem mais dinmica que C ou C++. Ela foi projetada
para se adaptar a um ambiente emevoluo. As bibliotecas podem
adicionar livremente novos mtodos e variveis de momento sem
causarnenhum efeito em seus clientes. Na linguagem Java, obter
informaes em tempo de execuo imediato.Este um recurso importante,
por exemplo, nas situaes em que algum cdigo precisa ser adicionado
a umprograma que est sendo executado.
1.3 Java e a InternetA idia bsica de utilizar Java na Internet
bastante simples: Usurios descarregam (fazem download)bytecodes
Java pela Internet e os executam em suas prprias mquinas.
$LOGOIMAGE 1 Introduo ao Java
1.2.10 Mltiplas Linhas de Execuo (Multithreading) 4
-
Os programas Java que funcionam em pginas Web so chamados
applets. Para usar um applet, necessrio um browser Web com
interpretador Java embutido.
As vantagens de se utilizar applets na Web so:
Java possibilita produzir pginas Web mais interativas. Como um
applet roda na mquina do cliente, paraqualquer entrada que o usurio
executar, o applet imediateamente ir reagir.
Applets podem usar interfaces grficas de usurio (GUI) modernas,
como botes, caixas de dilogo, caixas detexto, etc. Java tambm
possibilita capturar eventos de usurio, tais como acionamento de
teclas, movimentose cliques de mouse, entre outros.
1.3.1 Programas Autnomos (Standalone) X AppletsEnquanto applets
so programas executados a partir de um navegador Web, standalones
so aplicativosexecutados de forma autnoma (por si s).
1.4 Um Primeiro Programa em JavaSeguindo o ritual dos cursos de
Linguagem de Programao, mostramos, abaixo, o programa mais
simplespossvel (AloMundo) em Java. O programa apenas imprime uma
linha de texto com a mensagemAloMundo!.
public class AloMundo {public static void main( String args[] )
{
System.out.println ( Alo Mundo! ); }}
Este programa, assim como todo programa em Java, possui uma
definio de classe pblica: a classeAloMundo.
A linha com a declarao do mtodo main faz parte de todo
aplicativo Java. Os aplicativos Java semprecomeam a execuo por
main.
O mtodo System.out.println realiza a seguinte ao: imprime uma
linha de texto (com a string AlMundo!) na janela de comando.
1.5 Compilando e Executando o Primeiro Aplicativo emJavaPara
testarmos esse programa, primeiro precisamos salvlo. O programa
deve ser salvo em um arquivo como mesmo nome da clase pblica, com
extenso .java. Logo, o arquivofonte ser AloMundo.java.
Agora, estamos prontos para compilar e executar o programa. Para
compilar o programa, abrimos uma janelade comando, mudamos para o
diretrio onde o programa armazenado e digitamos:
javac AloMundo.java
Este comando criar, no diretrio corrente, um novo arquivo
chamado AloMundo.class, contendo osbytecodes de Java que
representam o aplicativo.
Para executar o programa, devemos usar o interpretador Java,
digitando o seguinte comando:
$LOGOIMAGE 1 Introduo ao Java
1.3.1 Programas Autnomos (Standalone) X Applets 5
-
java AloMundo
Note que quando voc invoca o interpretador, no h necessidade de
colocar a extenso .class para oarquivo que voc deseja executar.
1.6 Um Ambiente Java TpicoOs sistemas Java geralmente consistem
em vrias partes: um ambiente, a linguagem, a interface de
programasaplicativos (API Application Programming Interface) Java e
vrias bibliotecas de classe.
A API Java consiste em um conjunto de bibliotecas de classe das
quais tiramos proveito para odesenvolvimento de nossas aplicaes,
uma vez que essas classes so testadas e fundamentadas,
sendo,portanto, confiveis para a utilizao.
Os programas Java normalmente passam por cinco fases para serem
executados. Essas fases so as seguintes:
1.6.1 EdioO programa criado em um editor qualquer e armazenado
em disco.
1.6.2 CompilaoO programador emite o comando javac para compilar
o programa. O compilador Java traduz o programaJava para bytecodes
a linguagem entendida pelo interpretador e o armazena em disco.
1.6.3 Carga
O carregador de classe pega o arquivo .class que contm os
bytecodes e o transfere para a memria.
1.6.4 VerificaoO verificador de bytecodes confirma que todos os
bytecodes so vlidos e no violam restries de seguranade Java.
1.6.5 Execuo (Interpretao)O interpretador l os bytecodes (um por
vez) e os traduz para uma linguagem que o computador podeentender,
possivelmente armazenando valores dos dados enquanto executa o
programa.
$LOGOIMAGE 1 Introduo ao Java
1.6 Um Ambiente Java Tpico 6
-
1.7 Diferenas entre J2SE, J2EE, J2MEEles no so diferentes
compiladores, mas diferentes usos de Java, todos baseados no
J2SE.
J2SE Java2 Standard Edition: verso desktop, usada desde applets
a aplicaes completas standalone.
J2EE Java2 Enterprise Edition: verso de servidores web, extenes
do J2SE. Usada para servlets,aplicaes que retornam dados de um
servidor para um cliente, mais comumente HTTPServlet, que
retornampginas web, mas tambm usado para outros servidores de
aplicao, como email. Tambm incluifuncionalidades extras,
direcionadas a servidores, como os extras de banco de dados.
J2ME Java2 Mobile Edition: uma verso reduzida de J2SE para
dispositivos mveis (telefones celulares,PDAs) e para dispositivos
como TVs, microondas, carros. No inclui classes como AWT,
CollectionsFramework, RMI. Mas inclui classes direcionadas, como a
LCD User Interface, para telefones.
1.8 Links IndicadosPgina da Sun que contm tutoriais bsicos sobre
a linguagem Java e o estilo de programaoorientado a objetos:
http://java.sun.com/docs/books/tutorial/java
$LOGOIMAGE 1 Introduo ao Java
1.7 Diferenas entre J2SE, J2EE, J2ME 7
-
2 Estruturas Fundamentais de Programao emJava2.1 ComentriosA
linguagem Java tem trs formas de identificar comentrios.
O mtodo mais comum usar um par de //. Usase esta forma para um
comentrio que ir at o final de umalinha. Exemplo:
// Comenta apenas uma linha.
Quando so necessrios comentrios mais extensos, podese usar a
combinao /* e */ que permite definir umbloco usado somente para
comentrios. Exemplo:
/* Este um comentrio que usa vrias linhas. */
Um ltimo tipo de comentrio pode ser usado para gerar documentao
automaticamente. Esse comentriousa um /** para comear e um */ para
terminar.
2.2 Tipos de DadosA linguagem Java uma linguagem fortemente
tipada. Isso significa que cada varivel precisa ter um
tipodeclarado.
H oito tipos primitivos de dados em Java:
seis tipos numricos (quatro inteiros e dois de ponto flutuante);
um tipo char, usado para caracteres; um tipo lgico chamado boolean,
para valores de verdadeiro ou falso.
2.2.1 Inteiros
Os tipos inteiros so destinados a nmeros sem parte fracionria,
podendo assumir valores positivos enegativos. Java suporta os
quatro tipos inteiros mostrados na tabela a seguir:
Tipo Quantidade de memria Intervaloint 4 bytes 2.147.483.648 a
2.147.483.648short 2 bytes 32.768 a 32.767long 8 bytes
9.223.372.036.854.775.808L a 9.223.372.036.854.775.807Lbyte 1 byte
128 a 127
Na maior parte das situaes, o tipo int o mais prtico. No
entanto, se voc quiser representar a dvidaexterna brasileira em
reais, voc provavelmente ir necessitar de usar o long.
Os tipos byte e short so destinados, principalmente, para
aplicaes especializadas, tais como tratamentoem baixo nvel de
arquivos, ou em grandes arrays em que o espao de armazenamento
importante. Umponto importante a ser observado que, em Java, os
intervalos possveis dos tipos inteiros no dependem damquina na qual
o cdigo Java est sendo executado, o que uma grande vantagem para o
programdor quequiser passar o software de uma plataforma para
outra, ou mesmo entre sistemas operacionais na mesma
2 Estruturas Fundamentais de Programao em Java 8
-
plataforma. Por exemplo, em C e em C++, int denota um tipo
inteiro que depende da mquina. Em umprocessador de 16 bits, como o
8086, os inteiros tm 2 bytes. Em um processador de 32 bits, como o
SPARCda Sun, eles usam 4 bytes. Conseqentemente, um programa em C
que executa corretamente em um SPARC,pode exibir estouro de inteiro
no Windows 3.1. J em Java este problema no existe, pois os
programas Javaprecisam executar com os mesmos resultados em todas
as mquinas como definio de projeto e, por isso, osintervalos
possveis dos vrios tipos so fixos.
Os nmeros inteiros do tipo long tm um sufixo L (por exemplo,
4000000000L). Os nmeros hexadecimaistm um prefixo 0x (por exemplo,
0xCAFE).
2.2.2 Tipos de Ponto Flutuante
Os tipos de ponto flutuante denotam nmeros com partes
fracionrias. H dois tipos de ponto flutuante,mostrados na tabela a
seguir:
Tipo Quantidade dememria Intervalo
float 4 bytes Aproximadamente + 3.40282347E+3F (67 dgitos
decimais significativos)double 8 bytes Aproximadamente +
1.79769313486231570E+308 (15 dgitos decimais
significativos)
O nome double referese ao fato de que esses nmeros tm duas vezes
a preciso do tipo float. O tipousado na maioria das aplicaes o
double. A preciso limitada do tipo float insuficiente na maior
partedas situaes. A nica razo para usar float em situaes raras nas
quais o processamento um pouco maisrpido de nmeros de ponto
flutuante importante, ou quando voc necessita armazenar um grande
nmerode dados.
Os nmeros do tipo float tm um sufixo F (por exemplo, 3.402F). Os
nmeros de pnto flutuante sem umsufixo F (como 3.402) sero sempre
considerados do tipo double. Podese, opcionalmente, usar o sufixo
Dpara nmeros do tipo double, como, por exemplo, 3.402D.
2.2.3 O Tipo Caractere (char)Primeiramente, o tipo char usa
apstrofo, ou aspas simples. Por exemplo, 'X' um caractere e X
umastring contendo um nico caractere. Segundo, o tipo char denota
caracteres seguindo o esquema derepresentao Unicode. Talvez voc no
esteja familiarizado com o Unicode, e, felizmente, no necessriose
preocupar muito com isso se voc no quiser programar aplicativos
internacionais.
Devido ao fato do Unicode ter sido projetado para manipular,
essencialmente, todos os caracteres em todos osidiomas escritos no
mundo, ele tem um cdigo de 2 bytes. Isto permite codificar 65.536
caracteres (dos quaisatualmente cerca de 35.000 esto sendo usados),
diferentemente do cdigo ASCII, o qual um cdigo de 1byte, que
permite codificar apenas 256 caracteres. O cdigo familiar ASCII que
estamos acostumados a usar, na verdade, um subconjunto do Unicode.
Mais precisamente, ele constitui os primeiros 255 caracteres
doesquema de condificao Unicode. Desta forma, caracteres como 'a',
'1' e ']' so caracteres Unicode vlidos.Os caracteres Unicode so,
freqentemente, expressos em termos de um esquema de codificao
hexadecimalque vai de '\u0000' a '\uFFFF' (com '\u0000' a '\u00FF'
sendo os caractes ASCII comuns). O prefixo \u indicaum valor
Unicode e os quatro dgitos hexadecimais informam o caractere
Unicode.
Alm do caractere de controle \u que indica um caractere Unicode,
a linguagem Java permite usar seqnciasde caracteres de controle
para os caracteres especiais da tabela a seguir:
Seqncia de controle Nome Valor Unicode\b backspace (volta um
espao) \u0008
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.2.2 Tipos de Ponto Flutuante 9
-
\t tab (tabulao) \u0009\n linefeed (alimentao de linha) \u000a\r
carriage return (retorno de carro) \u000d\ aspas (duplas) \u0022\'
apstrofe (aspas simples) \u0027\\ barra invertida (barra)
\u005c
2.2.4 O Tipo Boolean
O tipo lgico boolean tem dois valores possveis: falso (false) e
verdadeiro (true). Ele empregado emtestes lgicos usando operadores
relacionais que a linguagem Java suporta, assim como qualquer
linguagemde programao.
Notase, neste caso, uma direrena entre Java e C/C++. No caso de
C/C++, no existe o tipo boolean, senodque o tipo falso o valor 0 e
os demais valores so do tipo verdadeiro.
2.3 VariveisEm Java, necessrio que voc declare o tipo de uma
varivel. Declarase uma varivel colocando o tipoprimeiro, seguido
pelo nome da varivel. Veja alguns exemplos: byte b; int
umaVariavelInteira; long umaVariavelLonga; char ch;
Note o pontoevrgula no final de cada declarao. O pontoevrgula
necessrio, pois uma declarao uma instruo completa em Java.
Um nome de varivel deve comear com uma letra ou com os
caracteres $ ou _, seguida de uma seqncia deletras e/ou dgitos
(incluindo nmeros). Caracteres especiais (como '+', '@', '?', etc.)
no so vlidos, comexceo dos caracterese _ e $. Alm disso, no se pode
usar uma palavra reservada Java para um nome devarivel.
Voc pode, tambm, declarar mais de uma varivel (do mesmo tipo) em
uma nica linha, como, por exemplo:
int i, j;
2.3.1 Atribuies e InicializaesDepois que voc tenha declarado uma
varivel, voc dever inicializla explicitamente por meio de
umaatribuio de um valor. Nunca se deve ter variveis no
inicializadas.
Uma atribuio a uma varivel feita usando o nome da varivel
esquerda, seguido de um sinal de igual (=)e de uma expresso Java
que tenha um valor apropriado direita. Por exemplo:
int a, b, c; a = 5; b = 3; c = a + b; int d = 4, e = 7; double f
= 1.58, g;
char ch; ch = 'S' // exemplo de uma inicializao de um char
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.2.4 O Tipo Boolean 10
-
char capitalA; capitalA = '\u0041'; /* exemplo de uma
inicializao com Unicode de um char com o A maisculo */
Em Java, possvel tanto declarar como inicializar uma varivel na
mesma linha. Por exemplo:
int i = 10;
Alm disso, em Java podemse colocar declaraes em qualquer lugar
do cdigo. No entanto, uma varivel spode ser declarada uma vez em
qualquer bloco de um mtodo.
2.3.2 Converses entre Tipos Numricos
Na linguagem Java, quaisquer operaes binrias em varieis numricas
de tipos diferentes so aceitveis etratadas da seguinte forma:
O resultado de uma expresso sempre tratado como um valor do tipo
do operando de maior intervalo daexpresso. Por exemplo, se qualquer
um dos operandos for do tipo double, ento o outro ser tratado
comoum double para o escopo da operao. De outra forma, se qualquer
um dos operandos for do tipo float, ooutro ser tratado como um
float. O mesmo raciocnio vale entre os tipos inteiros long, int,
shortebyte. Assim, temos a seguinte ordem de tratamento:
byte > short > int > long > float > double
Por exemplo, na operao seguinte, temos:
int i, i1; short s; double d, d1; float f; byte b;
d = (i + s) + (d + i1) * (f + b);
Em i + s temos a soma de um inteiro com um short; portanto s ser
tratado como um inteiro e teremos umresultado como um inteiro. Da
mesma forma, d + i1 tem como sesultado um double e f + b tem
comoresultado um float. A multiplicao (d + i1) * (f + b) tem como
resultado um double e finalmente o resultadototal da expresso de um
inteiro com um double, resultando em um double. Por outro lado, h
casos em quese quer considerar um double como integer. Essas
converses numricas, de um tipo para outro commenor intervalo, so
possveis em Java, mas alguma informao pode ser perdida. As
converses em que possvel a perda de informao so feitas por meio de
converses explcitas de tipo (casts). A sintaxe deum casting dada
pelo tipo resultante em parnteses, seguido pelo nome da varivel.
Por exemplo:
double x = 9.997; int nx = (int) x;
Com isso, a varivel nx ter o valor 9, pois a converso de um
valor de ponto flutuante para um inteirodescarta a parte
fracionria.
2.3.3 Constantes
Em Java, usase a palavrachave final para denotar uma constante.
Por exemplo:
final int ABC = 2; final double POLEGADA = 2.54;
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.3.2 Converses entre Tipos Numricos 11
-
A palavrachave final indica que voc pode atribuir um valor
varivel uma vez, e o valor fica definido deuma vez para sempre. um
padro dar nomes totalmente em maisculas a constantes.
2.4 OperadoresOs operadores aritmticos usuais + * / so usados
para adio, subtrao, multiplicao e diviso,respectivamente. O
operador / denota diviso inteira se os dois argumentos forem
intieros e diviso de pontoflutuante caso contrrio. O resto inteiro
(tambm conhecido como a funo mod) denotado por %. Porexemplo, 15/4
resulta 3, 15%2 resulta 1, 11.0/4 resulta 2.75. Podemse usar os
peradores aritmticos,tambm, na inicializao de variveis. Por
exemplo:
int n = 5; int a = 2 * n; // a 10
Existe uma forma reduzida de se usar os operadores aritmticos
binrios numa abribuio. Em geral,colocase o operador esquerda do
sinal de igual =, como em += ou = ou *= ou /= ou %=. Por
exemplo:
x += 4;
que equivale a
x = x + 4;
2.4.1 ExponenciaoEm Java, para elevar uma quantidade a uma
potncia, necessrio usar o mtodo pow, que faz parte daclasse Math de
java.lang. Uma forma usual de se fazer exponenciao atravs da
declarao: double y = Math.pow(x, a);
que faz y igual a x elevado potncia a (xa). O mtodo pow utiliza
argumentos que so do tipo double eretorna um double tambm.
2.4.2 Operadores de Incremento e Decremento
Uma das operaes mais comuns com uma varivel numrica adicionar ou
subtrair 1. Para facilitar essaoperao, a linguagem Java tem os
operadores de incremento e de decremento: x++ adiciona 1 ao valor
atualda varivel x e x subtai 1. Por exemplo:
int n = 12; n++; // n agora vale 13
Como esses operadores mudam o valor de uma varivel, eles no
podem ser aplicados a nmeros diretamente.Por exemplo, 5++ no uma
instruo vlida.
Existem duas formas de se usar esses operadores: uma forma
psfixada (a forma aps a varivel, n++) euma forma prfixada (a forma
antes da varivel, ++n). Ambas alteram o valor da varivel de 1.
Adiferena entre as duas somente aparece quando so usadas dentro de
expresses. A forma prfixada faz aadio primeiro; a psfixada avalia o
valor antigo da varivel, antes de atualizla. Por exemplo:
int m = 7; int n = 7; int a = 2 * ++m; // agora a 16, m 8 int b
= 2 * n++; // agora b 14, n 8
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.4 Operadores 12
-
A utilizao de ++ (ou ) dentro de expresses no recomendada, pois
pode tornar o cdigo difcil de seentender e uma causa freqente de
erros difceis de descobrir.
2.4.3 Operadores Relacionais e Lgicos
Java tem um conjunto completo de operadores relacionais. Para
testar a igualdade usase um sinal de igualduplo (==). Por exemplo,
o valor de
(3 == 7)
falso. Usase = para desigualdes. Por exemplo, o valor de
(3 != 7)
verdadeiro.
Java tambm possui os habituais operadores < (menor que), >
(maior que), = (maiorou igual a). Alm disso, Java usa &&
para o operador lgico and e || para o operador lgico or.
2.4.4 Operadores bitabit
Ao trabalhar com qualquer um dos tipos inteiros, temse
operadores que podem operar e trabalhardiretamente com os bits que
fazem parte desses inteiros. Isso significa que podese usar tcnicas
demascaramento para obter bits individuais de um nmero. Os
operadores de bits so: & (E lgico), | (OUlgico), ^ (OU
Exclusivo Lgico), ~ (Negao lgica).
Por exemplo, se x uma varivel inteira, ento
int quartoBitAPartirDaDireita = (x & 8) / 8;
resulta em 1 se o quarto bit a partir da direita na representao
binria de x for 1 e zero caso contrrio.
H tambm os operadores >> e >, que preenche todos os
bits mais significativos com zeros, enquanto >> estende o
bitde sinal nos bits mais significativos. No existe o operador >
da esquerda para a direita< >= instanceof da esquerda para a
direita= da esquerda para a direita
& da esquerda para a direitada esquerda para a direita
| da esquerda para a direita
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.4.3 Operadores Relacionais e Lgicos 13
-
&& da esquerda para a direita|| da esquerda para a
direita? : da esquerda para a direita= += = *= /= %= &= | = ^=
= >>>= da direita para a esquerda
2.5 StringsStrings so seqncias de caracteres, tais como ol. Java
no tem um tipo string nativo. No entanto, abiblioteca padro do Java
contm uma clase predefinida chamada de String. Cada string entre
aspas umainstncia da classe String. Exemplo:
String e= ; // uma string vazia String saudacao = ol;
2.5.1 ConcatenaoA linguagem Java permite que se use o sinal +
para unir (concatenar) duas strings. Por exemplo:
String s1 = Linguagem; String s2 = Java; String mensagem = s1 +
s2;
O cdigo acima faz com que a varivel string mensagem tenha o
valor LinguagemJava.
Ao concatenar uma string com um valor que no string, este ltimo
convertido para uma string. Porexemplo:
String radiacao = cesio + 137;
faz com que a varivel radiacao tenha o valor cesio137. Esse
recurso muito usado nas instrues de sada.Por exemplo:
System.out.println( O elemento de radiacao : + radiacao);
ir imprimir, na tela: O elemento de radiacao cesio137
2.5.2 Substrings
Podese extrair uma substring de uma string maior atravs do mtodo
substring da classe String. Porexemplo:
String saudacao = Bom Dia; String s1 = saudacao.substring(0,
3);
cria uma string consistindo nos caracteres Bom. Em Java, o
primeiro caractere de uma string fica na posio0. Por exemplo, o
caractere 'B' est na posio 0 da string Bom Dia e o caractere 'D'
est na posio 4.
O primeiro argumento do mtodo substring a primeira posio a ser
copiada. O segundo argumento altima posio a ser copiada, exclusive.
No exemplo acima, desejase copiar os caracteres das posies 0, 1 e2.
O exemplo abaixo:
String s2 = saudacao.substring(4, 7);
cria uma string consistindo nos caracteres Dia.
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.5 Strings 14
-
2.5.3 Edio de StringsPara obter o tamanho de uma string, usase o
mtodo length. Por exemplo:
String saudacao = Bom Dia; int n = saudacao.length(); // n
recebe 7
Assim como char denota um caractere Unicode, String denota uma
seqncia de caracteres Unicode. possvel obter os caracteres
individuais de uma string. Por exemplo, s.charAt(n) retorna o
caractere Unicodeda posio n, onde n est entre 0 e s.length()1. Por
exemplo:
char c = saudacao.charAt(2); // c recebe 'm'
2.5.4 Teste de Igualdade de Strings
Para testar se duas strings so iguais ou no, usase o mtodo
equals ou "compareTo". Por exemplo, aexpresso
s.equals(t)
retorna true se as strings s e t forem iguais e false caso
contrrio. Para este mtodo, s e t podem servariveis ou constantes
string. Por exemplo, o trecho de cdigo abaixo perfeitamente
vlido:
Bom Dia.equals(saudacao)
H tambm o mtodo 'compareTo', que retorna 0 caso as strings sejam
iguais e um nmero diferente de zerocaso eles seja diferentes. Bom
Dia.compareTo(saudacao)
Para testar se duas strings so idnticas, sem levar em conta
diferenciao entre maisculas e minsculas,usase o mtodo
equalsIgnoreCase. Por exemplo, o trecho abaixo retorna true:
Bom Dia.equalsIgnoreCase(bom dia);
Uma observao importante que no se deve ser usado o operador ==
para verificar se duas strings soiguais. Isto somente determina se
as strings esto armazenas na mesma posio de memria.
2.6 Comandos de Entrada e SadaA maioria dos aplicativos em Java
que exibem alguma mensagem para o usurio, utilizam janelas ou
caixasde dilogo para exibir a mensagem. Em geral, as caixas de
dilogo so janelas nas quais os programasexibem mensagens
importantes para o usurio do programa. A classe de Java JOptionPane
oferece caixas dedilogo predefinidas que permitem aos programas
exibir mensagens para os usurios.
Veja o exemplo abaixo, que um aplicativo que l dois inteiros
digitados pelo usurio no teclado, calcula asoma desses valores e
exibe o resultado:
import javax.swing.JOptionPane;public class Adicao {
public static void main( String args[] ) {String primeiroNumero,
segundoNumero;int numero1, numero2, soma;
primeiroNumero = JOptionPane.showInputDialog( Digite o primeiro
nmero ); segundoNumero = JOptionPane.showInputDialog( Digite o
segundo nmero ); numero1 = Integer.parseInt( primeiroNumero );
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.5.3 Edio de Strings 15
-
numero2 = Integer.parseInt( segundoNumero ); soma = numero1 +
numero2; JOptionPane.showMessageDialog( null, A soma : + soma );
System.exit(0); } // fim do mtodo main} // fim da classe Adicao
A instruo import utilizada pelo compilador para identificar e
carregar classes usadas em um programaJava. Quando voc utiliza
classes da Java API, o compilador tenta assegurar que voc as
utiliza corretamente.As instrues import ajudam o compilador a
localizar as classes que voc pretende utilizar. A classeJOptionPane
est definida no pacote javax.swing.
O mtodo showInputDialog da classe JOptionPane l uma string
fornecida pelo usurio. O argumentopara esse mtodo uma mensagem
(prompt) que avisa o usurio para realizar uma ao especfica. Quando
omtodo executado, o usurio digita caracteres no campo de texto (que
ser exibido) e, a seguir, clica noboto OK ou pressiona a tecla
Enter para devolver a string para o programa.
O mtodo parseInt da classe Integer converte seu argumento String
em um inteiro. A classe Integerest definida no pacote java.lang, o
qual no precisa ser importado, pois um pacote default (j
importadoautomaticamente) de todo programa Java.
O mtodo showMessageDialog da classe JOptionPane exige dois
argumentos, os quais so separados porvrgula. O primeiro argumento
determina o frame a ser utilizado, quando palavrachave null, um
framepadro utilizado. O segundo argumento a string a ser exibida.
Este mtodo apresenta uma caixa de dilogona tela, com a string
passada no segundo argumento como a mensagem a ser exibida.
O mtodo exit da classe System termina o aplicativo. Em qualquer
aplicativo Java que exibe umainterface grfica com o usurio, esta
linha necessria para terminar o aplicativo.
Ao invs da caixa de dilogo, a sada poderia ter sido exibida
atravs de uma linha na janela de comando. Porexemplo:
System.out.print( A soma : + soma ); // ou System.out.println( A
soma : + soma );
A diferena entre println e print que, depois de exibir seu
argumento, print no posiciona o cursor desada no incio da prxima
linha na janela de comando; o prximo caractere que o programa exibe
na janelade comando aparecer imediatamente aps o ltimo caractere
que print exibe.
O mtodo showMessageDialog, ainda aceita uma diferente sintaxe
que adiciona o ttulo janela e modifica afigura esquerda:
JOptionPane.showMessageDialog(null, "A soma : " + soma,
"Resultado", JOptionPane.PLAIN_MESSAGE);
Teste no ltimo campo aps o "JOptionPane.": QUESTION_MESSAGE,
WARNING_MESSAGE,ERROR_MESSAGE, INFORMATION_MESSAGE.
2.7 Estruturas de Controle2.7.1 Instrues Condicionais Comando
if/elseA instruo condicional mais simples em Java tem a forma:
if (condicao) instrucao;
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.7 Estruturas de Controle 16
-
Por exemplo:
if (media >= 7) resultado = Aprovado;
No entanto, em Java, como na maioria das lingugens de programao,
freqentemente se quer executar vriasinstrues quando uma condio
verdadeira. Neste caso, a instruo condicional toma a forma:
if (condicao) { bloco }
A condio precisa ficar entre parnteses e bloco (como indicado)
significa qualquer nmero de instruesrodeadas por um par de chaves
{...}. Por exemplo:
if (media >= 7) { resultado = Aprovado; System.out.println(
Parabns! Voc foi Aprovado! );}
A condio mais completa em Java construda da seguinte forma:
if (condicao) instrucao1 else instrucao2;
ou:
if (condicao) {bloco1} else {bloco2}
Por exemplo:
if (media >= 7) { resultado = Aprovado; System.out.println(
Parabns! Voc foi Aprovado! );}else { resultado = Reprovado;
System.out.println( Voc foi reprovado! );}
2.7.2 Laos Indeterminados Comandos while e do/whileEm Java, como
em todas as linguagens de programao, h estruturas de controle que
permitem repetirinstrues. H duas formas de laos de repetio que so
mais adequadas quando no se sabe quantas vezesum lao deve ser
processado. Estes so os chamados laos indeterminados.
Primeiro, h o lao while, que executa o corpo do lao somente
enquanto uma condio for verdadeira(true). Sua sintaxe a
seguinte:
while (condicao) { bloco }
Por exemplo:
import javax.swing.JOptionPane;import
java.text.DecimalFormat;public class Media {
public static void main( String args[] ) {int contadorNota,
valorNota, total;double media;String strValorNota;
total = 0; contadorNota = 0;
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.7.2 Laos Indeterminados Comandos while e do/while 17
-
strValorNota = JOptionPane.showInputDialog ( Entre com uma nota
inteira, ou 1 para sair); valorNota = Integer.parseInt(
strValorNota );
while ( valorNota != 1 ) { total = total + valorNota;
contadorNota = contadorNota + 1; strValorNota =
JOptionPane.showInputDialog ( Entre com uma nota inteira, ou 1 para
sair ); valorNota = Integer.parseInt( strValorNota ); }
DecimalFormat doisDigitos = new DecimalFormat ("0.00");
if ( contadorNota != 0 ) { media = (double) total /
contadorNota; JOptionPane.showMessageDialog( null, A mdia da turma
: + doisDigitos.format(media) ); }
else JOptionPane.showMessageDialog( null, Nenhuma nota foi
inserida! ); System.exit(0); } // fim do mtodo main} // fim da
classe Media
O programa acima recebe as notas de uma turma enquanto houver
notas. Esse processo somente serfinalizado quando o usurio digitar
1, o que significa que no existem mais notas. As notas so somadas e
amdia calculada de acordo com a quantidade de notas.
A linha :
DecimalFormat doisDigitos = new DecimalFormat("0.00")
declara doisDigitos como uma referncia para um objeto da classe
DecimalFormat (pacote java.text). Estaclasse utilizada para
formatar nmeros. Neste caso, queremos que o nmero formatado por
doisDigitostenha no mnimo um dgito esquerda da casa decimal e
exatamente dois dgitos direita. Comentaremossobre objetos mais
adiante nesta obra.
Um lao while faz o teste no incio. Assim, o cdigo no bloco pode
nunca ser executado. Se voc quiser tercerteza de que um bloco seja
executado pelo menos uma vez, ter de passar o teste para o final do
bloco. Isso feito usandose a verso do de um lao while. Sua sintaxe
a seguinte:
do { bloco } while (condicao);
Isso primeiro executa o bloco e somente depois testa a condio.
Ele ento repete o bloco, refaz o teste dacondio e fica nesse lao.
Por exemplo:
import javax.swing.JOptionPane;public class TestaDoWhile {
public static void main (String args[]) {int item;String
strItem;do {
strItem = JOptionPane.showInputDialog( Tecle 0 para continuar
executando + \nTecle qualquer outra tecla para sair ); item =
Integer.parseInt( strItem ); } while (item == 0); System.exit(0); }
// fim do mtodo main} // fim da classe TestaDoWhile?
No programa acima, o lao ser executado no mnimo uma vez. Somente
aps a primeira iterao, o usurioter liberdade para escolher se o lao
deve continuar sendo executado ou no.
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.7.2 Laos Indeterminados Comandos while e do/while 18
-
2.7.3 Laos Determinados Comando forOs chamados laos determinados
so repeties controladas por contador. Uma repetio controlada
porcontador exige o seguinte:
o nome de uma varivel de controle (ou contador de lao);1. o
valor inicial da varivel de controle;2. o incremento (ou o
decremento) pelo qual a varivel de controle modificada a cada
passagempelo lao;
3.
a condio que testa o valor final da varivel de controle (isto ,
se o lao deve continuar).4.
A estrutura de repetio for cuida de todos os detalhes da repetio
controlada por contador. Sua sintaxe :
for (instrucao1; expressao1; expressao2) { bloco }
Por exemplo:
import javax.swing.JOptionPane;public class Soma {
public static void main( String args[] ) {int soma = 0;int
quantidade = 0;for (int numero = 2; numero
-
O comando "switch" funciona da seguinte forma: o valor de
expresso comparado com os valores literais decada um dos comandos
"case". Se os valores forem iguais, a seqncia de cdigo que se segue
ao comando"case" correspondente executada. Se nenhuma das
constantes for igual ao valor de expresso, o comando"default"
executado. Contudo, o comando "default" opcional. Se nenhum "case"
for igual ao valor daexpresso e no houver um comando "default",
nenhuma ao ser executada.
O comando "break" usado dentro de um switch para terminar uma
seqncia de comandos. Quando umcomando "break" encontrado, a execuo
salta para a primeira linha de cdigo que vem depois do
comando"switch". Ou seja, "break" tem o efeito de provocar um salto
para fora do comando "switch". Se no usarmoso comando "break", a
execuo continuar para o "case" seguinte.
Por exemplo:
// Uma verso do programa das estaes do ano usando switch.public
class SwitchDemo {
public static void main(String args[]) {int mes = 7;String
estacao;switch(mes) {
case 12:case 1:case 2:
estacao = "Vero";break;case 3:case 4:case 5:
estacao = "Outono";break;case 6:case 7:case 8:
estacao = "Inverno";break;case 9:case 10:case 11:
estacao = "Primavera";break;default:
estacao = "Invalido"; } // fim de switch System.out.println( "Ms
= " + mes + "; Estao = " + estacao ); } // fim do mtodo main} //
fim da classe SwitchDemo2?
A sada para a verso do programa acima ser:
Ms = 7; Estao = Inverno
2.7.5 Arrays
Um array um grupo de posies contguas na memria que possuem o
mesmo nome e o mesmo tipo. Parareferirse a uma localizao ou
elemento particular no "array", especificamos o nome do "array" e o
nmeroda posio (ou ndice) do elemento particular no "array".
Uma vez criado um array, no se pode mudar seu tamanho facilmente
(embora se possa, evidentemente,mudar um elemento individual do
array).
A criao de um array feita, geralmente, usando o operador new.
Por exemplo:
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.7.5 Arrays 20
-
int[] arrayDeInts = new int[100];
define um array que pode conter 100 inteiros. Os elementos do
array so numerados de 0 a 99 (e no de 1 a100). Se voc tentar
acessar o elemento 101 de um array declarado como tendo 100
elementos, ocdigofonte vai compilar sem erros ou advertncia e voc
poder executar o programa. Porm, este vai pararquando tentar
acessar um elemento de um array fora dos limites declarados.
O array do exemplo anterior tambm pode ser declarado da seguinte
forma:
int arrayDeInts[] = new int[100];
No existe nenhuma diferena entre essas duas formas de
declarao.
Java tem uma forma abreviada de criar um objeto array e fornecer
valores iniciais ao mesmo tempo. Veja umexemplo:
int[] numerosPrimos = {2, 3, 5, 7, 11, 13};
Essa expresso reserva um novo array e o preenche com os valores
entre as chaves. Ele conta o nmero inicialde valores e define o
tamanho do array de acordo com essa contagem.
2.7.6 Cpia de Arrays
Podese copiar uma varivel de array em outra, o que faz com que
as duas variveis faam referncia aomesmo array. Por exemplo:
int[] numerosSortudos = numerosPrimos; numerosSortudos[5] = 12;
// agora numerosPrimos[5] tambm 12
Se voc realmente quiser copiar todos os valores de um array em
outro, ter de usar o mtodo arraycopy daclasse System. A sintaxe
:
System.arraycopy( de, indiceDe, para, indicePara, contagem
);
Por exemplo, o programa a seguir define dois arrays e depois
copia os quatro ltimos elementos do primeiroarray para o segundo. A
cpia comea na posio 2 do array de origem e copia 4 elementos,
comeando naposio 3 do array de destino.
public class ExemploArray {public static void main (String
args[]) {
int[] numerosPrimos = {2, 3, 5, 7, 11, 13};int[] numerosSortudos
= {1001, 1002, 1003, 1004, 1005, 1006, 1007};
System.arraycopy( numerosPrimos, 2, numerosSortudos, 3, 4 );for
(int i = 0; i < numerosSortudos.length; i++) {
System.out.println( O elemento + i + aps a cpia +
numerosSortudos[i] ); } } // fim do mtodo main} // fim da classe
ExemploArray?
A sada desse programa :
O elemento 0 aps a cpia 1001 O elemento 1 aps a cpia 1002 O
elemento 2 aps a cpia 1003 O elemento 3 aps a cpia 5 O elemento 4
aps a cpia 7 O elemento 5 aps a cpia 11 O elemento 6 aps a cpia
13
$LOGOIMAGE 2 Estruturas Fundamentais de Programao em Java
2.7.6 Cpia de Arrays 21
-
Aps o trmino do programa, os arrays ficaro da seguinte
forma:
numerosPrimos 2 3 5 7 11 13
numerosSortudos 1001 1002 1003 5 7 11 13
2.7.7 Arrays Multidimensionais
Os arrays multidimensionais com dois ndices so utilizados
freqentemente para representar tabelas devalores que consistem em
informaes organizadas em linhas e colunas. Para identificar um
elementoespecfico da tabela, devemos especificar os dois ndices por
conveno, o primeiro identifica a linha doelemento e o segundo
identifica a coluna do elemento. Os arrays que exigem dois ndices
para identificar umelemento especfico so chamados de arrays
bidimensionais. Os arrays multidimensionais podem ter maisde dois
ndices. Veja um exemplo de declarao de um array bidimensional de 5
linhas e 6 colunas: double[][] tabela = new double[5][6];
A linguagem Java no implementa arrays multidimensionais
realmente, mas apenas arrays de uma dimenso.Os arrays
multidimensionais so montados como arrays de arrays.
Por exemplo, o array tabela do exemplo anterior , na verdade, um
array que contm cinco elementos, cadaqual sendo um array de seis
nmeros de ponto flutuante. A expresso tabela[i] referese ao
isimosubarray, ou seja, isima linha da tabela. Ela , por si, um
array, e tabela[i][j] referese ao jsimoelemento desse array.
Como as linhas dos arrays so acessveis individualmente, podese
at troclas. Por exemplo:
double[] aux = tabela[i]; tabela[i] = tabela[i+1]; tabela[i+1] =
aux;
Outra conseqncia dos arrays multidimensionais serem arrays de
arrays est em que se pode usar a notaoreduzida de inicializao de
arrays multidimensionais sem precisar usar o operador new, como no
exemplo:
int[][] vendasUltimosDoisAnos = { {1997, 1998}, {100000, 200000}
};
Tambm fcil fazer arrays irregulares, ou seja, arrays em que
linhas diferentes tm comprimentosdiferentes. Por exemplo, a
declarao:
int b[][] = { {1, 2}, {3, 4, 5} };
cria o array de inteiros b com a linha 0 contendo dois elementos
(1 e 2) e a linha 1 contendo trs elementos(3, 4 e 5).
Um array multidimensional em que cada linha tem um nmero
diferente de colunas pode ser alocadodinamicamente como segue:
int c[][] = new int[2][]; c[0] = new int[5]; c[1] = new
int[3];
2.8 Exerccios de Reviso1 Escreva um aplicativo que l 5 inteiros
e determina e imprime o maior e o menor inteiro do grupo.Devese
utilizar apenas as instrues if