Liv Ro Java Total 27 Jan 2006

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.


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.


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:


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.


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


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


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;


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


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


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.


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 );


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;


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;


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.


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:


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


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

Documents

Liv Ro Java Total 27 Jan 2006