Apostila de java na pratica
Upcoming SlideShare
Loading in...5
×
 

Apostila de java na pratica

on

  • 9,618 views

Teste apresentacao

Teste apresentacao

Statistics

Views

Total Views
9,618
Views on SlideShare
9,618
Embed Views
0

Actions

Likes
0
Downloads
124
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Apostila de java na pratica Apostila de java na pratica Document Transcript

  • UNIVERSIDADE FEDERAL DE VIÇOSADEPARTAMENTO DE INFORMÁTICA JAVA NA PRÁTICA Alcione de Paiva Oliveira Vinícius Valente Maciel 2002
  • Java na Prática 1 SumárioCapítulo I - Introdução ....................................... 6 CONVENÇÕES ........................................................................................................................... 10Capítulo II - Programação Orientada a Objetos .................. 11 CLASSES E OBJETOS E LINGUAGENS DE PROGRAMAÇÃO ......................................................... 12 Ocultando de Informação................................................................................................... 16 Especialização e Herança .................................................................................................. 17 Sobrescrita, Sobrecarga e Polimorfismo............................................................................ 18 INTRODUÇÃO À DIAGRAMA DE CLASSES ................................................................................. 20 Diagrama de Classes.......................................................................................................... 20Capítulo III - Introdução à Linguagem Java ..................... 27 PALAVRAS RESERVADAS ......................................................................................................... 30 LITERAIS .................................................................................................................................. 31 SEPARADORES.......................................................................................................................... 34 TIPOS DE DADOS....................................................................................................................... 35 Tipos de dados simples....................................................................................................... 35 Tipos de dados compostos .................................................................................................. 37 CONVERSÃO DE TIPOS.............................................................................................................. 41 OPERADORES ........................................................................................................................... 42 Expressões e Precedência entre Operadores ..................................................................... 50 COMENTÁRIOS ......................................................................................................................... 51 BLOCOS E ESCOPO ................................................................................................................... 52 ESTRUTURAS DE CONTROLE .................................................................................................... 53 Seleção ............................................................................................................................... 53 Repetição............................................................................................................................ 57 break e continue ......................................................................................................... 60 ARGUMENTOS DA LINHA DE COMANDO .................................................................................... 61 ASSERT (ASSERTIVAS) ............................................................................................................. 63 Sintaxe e semântica ............................................................................................................ 63 Habilitando e Desabilitando Assertivas ............................................................................. 64Capítulo IV Classes, Packages e Interfaces ................... 66 CLASSES .................................................................................................................................. 66 Construtores ....................................................................................................................... 68 Valor de Retorno ................................................................................................................ 68 OBJETOS .................................................................................................................................. 69 MODIFICADORES DE ACESSO .................................................................................................... 72 Outros Modificadores......................................................................................................... 74 REFERÊNCIAS COMPARTILHADAS ............................................................................................ 78 COPIANDO OBJETOS ................................................................................................................. 81 O objeto this ................................................................................................................... 81 PACKAGES ............................................................................................................................... 83 Usando Packages ............................................................................................................... 83 Criando Packages .............................................................................................................. 84 O Mecanismo de Extensão ................................................................................................. 86 DERIVANDO CLASSES ............................................................................................................... 88 super ................................................................................................................................... 90 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 2 A classe Object ............................................................................................................... 91 Sobrescrita e Polimorfismo ................................................................................................ 92 CLASSES E MÉTODOS ABSTRATOS ........................................................................................... 95 INTERFACES ............................................................................................................................. 96 CLASSES INTERNAS .................................................................................................................. 99 Classes Internas Anônimas............................................................................................... 101 CONVERSÃO........................................................................................................................... 103 EXCEÇÕES.............................................................................................................................. 103 A hierarquia de Exceções................................................................................................. 105 Capturando mais de uma exceção.................................................................................... 106 Lançando exceções........................................................................................................... 107 Comportamento do Sistema diante das Exceções ............................................................ 109 Criando suas próprias exceções....................................................................................... 110 A cláusula finally ....................................................................................................... 111 DOCUMENTANDO O CÓDIGO................................................................................................... 112 Rótulos.............................................................................................................................. 113 HTML embutida ............................................................................................................... 115 AGENDA ELETRÔNICA VERSÃO CONSOLE 1.0 ........................................................................ 115Capítulo V – Entrada e Saída (java.io) ...................... 122 ACESSO SEQUENCIAL............................................................................................................. 122 ACESSO DIRETO ..................................................................................................................... 127Capítulo VI – java.util ..................................... 131 LIDANDO COM COLEÇÕES ...................................................................................................... 131 As Interfaces Iterator e Enumeration ................................................................... 131 Vector ........................................................................................................................... 133 Stack.............................................................................................................................. 136 Hashtable .................................................................................................................... 138 MISCELÂNEA DE CLASSES DO PACOTE JAVA.UTIL................................................................. 141 Arrays ........................................................................................................................... 141 Date ................................................................................................................................ 144 Observable .................................................................................................................. 146 StringTokenizer ...................................................................................................... 150 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.0 ........................................................................ 152Capítulo VII - Serialização e Persistência .................... 159 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.1 ........................................................................ 161Capítulo VIII – AWT (Abstract Window Toolkit) ............... 164 A HIERARQUIA DE COMPONENTES ......................................................................................... 164 OLÁ MUNDO AWT ................................................................................................................ 166 TRATAMENTO DE EVENTOS ................................................................................................... 167 Modelo de Eventos 1.1 ..................................................................................................... 167 Tratamento de Eventos com classes Internas................................................................... 171 EXEMPLO BÁSICO .................................................................................................................. 176 ACRESCENTANDO CORES ....................................................................................................... 180 GERENCIANDO O LAYOUT...................................................................................................... 181 Exemplo com BorderLayout....................................................................................... 182 Exemplo com FlowLayout ........................................................................................... 183 Exemplo com CardLayout ........................................................................................... 184 Exemplo com GridLayout ........................................................................................... 186 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 3 Exemplo com GridBagLayout .................................................................................... 187 UTILIZANDO LISTAS............................................................................................................... 189 TRABALHANDO COM MENUS E DIÁLOGOS ............................................................................. 192 CAPTURANDO EVENTOS DO TECLADO ................................................................................... 196 PRINCIPAIS CLASSES .............................................................................................................. 196 Color.............................................................................................................................. 196 Component .................................................................................................................... 198 Button ........................................................................................................................... 200 Label.............................................................................................................................. 201 List ................................................................................................................................ 202 TextField .................................................................................................................... 203 TextArea....................................................................................................................... 204 CONTAINERS .......................................................................................................................... 205 Panel.............................................................................................................................. 207 Frame.............................................................................................................................. 208 AGENDA ELETRÔNICA VERSÃO GRÁFICA 1.0......................................................................... 211Capítulo IX - Applets ....................................... 217 DESCRIÇÃO DO CÓDIGO HTML ............................................................................................. 221 MÉTODOS DA CLASSE APPLET ............................................................................................... 222 EXIBINDO UMA IMAGEM ........................................................................................................ 226 ÁUDIO .................................................................................................................................... 229 OBTENDO PARÂMETROS ......................................................................................................... 230 EXECUTANDO UM APPLET COMO APLICAÇÃO ........................................................................ 232 PREPARANDO APPLETS PARA PRODUÇÃO E ARQUIVOS JARS ................................................. 232 CRIANDO OS PRÓPRIOS ARQUIVOS MANIFEST ......................................................................... 235 AGENDA ELETRÔNICA VERSÃO APPLET 1.0 ........................................................................... 236Capítulo X JavaBean ......................................... 237 O QUE É UM JAVABEAN? ....................................................................................................... 237 JAVABEANS E FERRAMENTAS RAD ....................................................................................... 237 PROPRIEDADES ...................................................................................................................... 238 Simples ............................................................................................................................. 238 Indexada ........................................................................................................................... 239 Ligada (Bound)................................................................................................................. 240 Restringidas(Constrained) ............................................................................................... 241 EVENTOS................................................................................................................................ 243 DESENVOLVIMENTO DO EXEMPLO ......................................................................................... 244 TimerEventListener .......................................................................................................... 244 TimerEvent ....................................................................................................................... 245 TimerBean ........................................................................................................................ 245 INSTALANDO O BEANS DEVELOPMENT KIT (BDK)................................................................ 249 TESTANDO EXEMPLO NO BDK ............................................................................................... 249Capítulo XI - Concorrência .................................... 255 CRIANDO THREADS EM JAVA ................................................................................................. 257 Criando threads por meio da interface Runnable ........................................................ 259 A CLASSE THREAD ................................................................................................................. 259 Hierarquia ........................................................................................................................ 259 Construtores ..................................................................................................................... 259 Métodos ............................................................................................................................ 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 4 Variáveis públicas ............................................................................................................ 259 CICLO DE VIDA DOS THREADS ............................................................................................... 259 sleep(), yield(), join(), destroy(), stop(), suspend() e resume(). .............. 259 DAEMON THREADS ................................................................................................................ 259 INFLUÊNCIA DO SISTEMA OPERACIONAL NO COMPORTAMENTO DOS THREADS..................... 259 Forma de escalonamento de threads................................................................................ 259 Relacionamento entre os níveis de prioridades definidas na linguagem Java e os níveis de prioridades definidas nos Sistemas Operacionais............................................................ 259 COMPARTILHAMENTO DE MEMÓRIA E SINCRONIZAÇÃO ........................................................ 259 Atomicidade de Instruções e Sincronização do Acesso à Sessões Críticas ...................... 259 Comunicação entre Threads: wait() e notify() ................................................................. 259Capítulo XII - Animação ....................................... 259Capítulo XIII - Programação em rede ......................... 259 CONCEITOS SOBRE PROTOCOLOS USADOS NA INTERNET....................................................... 259 TCP................................................................................................................................... 259 UDP.................................................................................................................................. 259 IDENTIFICAÇÃO DE HOSTS (Número IP).................................................................... 259 Identificação de Processos (Portas)................................................................................. 259 PROGRAMAÇÃO EM REDE COM JAVA ..................................................................................... 259 Comunicação Básica Entre Aplicações............................................................................ 259 Comunicação Sem Conexão (UDP) ................................................................................. 259 Comunicação por meio de URL ....................................................................................... 259Capítulo XIV – Computação Distribuída (RMI) ................. 259 CRIANDO NOSSA AGENDA DISTRIBUÍDA ................................................................................. 259 Implementar interface do objeto remoto .......................................................................... 259Capítulo XV - Acesso a Banco de Dados ....................... 259 MODELOS DE ACESSO A SERVIDORES .................................................................................... 259 TIPOS DE DRIVERS JDBC....................................................................................................... 259 Obtendo os Drivers JDBC................................................................................................ 259 PREPARANDO UM BANCO DE DADOS ..................................................................................... 259 Configurando o ODBC..................................................................................................... 259 EXEMPLO INICIAL .................................................................................................................. 259 Carregando o Driver........................................................................................................ 259 Estabelecendo a conexão ................................................................................................. 259 Criando e Executando Comandos .................................................................................... 259 RECUPERANDO VALORES....................................................................................................... 259 TRANSAÇÕES E NÍVEL DE ISOLAMENTO ................................................................................. 259 Transação......................................................................................................................... 259 Níveis de isolamento......................................................................................................... 259 PREPARED STATEMENTS ........................................................................................................ 259 PROCEDIMENTOS ARMAZENADOS (STORED PROCEDURES).................................................... 259 AGENDA ELETRÔNICA VERSÃO JDBC ................................................................................... 259Capítulo XVI Servlets e JSP ................................. 259 SERVLETS .............................................................................................................................. 259 Applets X Servlets............................................................................................................. 259 CGI X Servlets .................................................................................................................. 259 A API SERVLET ..................................................................................................................... 259 Exemplo de Servlet ........................................................................................................... 259 COMPILANDO O SERVLET....................................................................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 5 Instalando o Tomcat......................................................................................................... 259 PREPARANDO PARA EXECUTAR O SERVLET ............................................................................ 259 Compilando o Servlet ....................................................................................................... 259 Criando uma aplicação no Tomcat .................................................................................. 259 EXECUTANDO O SERVLET ...................................................................................................... 259 Invocando diretamente pelo Navegador........................................................................... 259 Invocando em uma página HTML .................................................................................... 259 Diferenças entre as requisições GET e POST .................................................................. 259 CONCORRÊNCIA ..................................................................................................................... 259 OBTENDO INFORMAÇÕES SOBRE A REQUISIÇÃO .................................................................... 259 LIDANDO COM FORMULÁRIOS................................................................................................ 259 LIDANDO COM COOKIES......................................................................................................... 259 LIDANDO COM SESSÕES ......................................................................................................... 259 JSP......................................................................................................................................... 259 PHP X JSP ....................................................................................................................... 259 ASP X JSP ........................................................................................................................ 259 Primeiro exemplo em JSP ................................................................................................ 259 Executando o arquivo JSP................................................................................................ 259 Objetos implícitos............................................................................................................. 259 Tags JSP........................................................................................................................... 259 Comentários ..................................................................................................................... 259 Diretivas ........................................................................................................................... 259 Extraindo Valores de Formulários................................................................................... 259 Criando e Modificando Cookies....................................................................................... 259 Lidando com sessões ........................................................................................................ 259 O Uso de JavaBeans......................................................................................................... 259 REENCAMINHANDO OU REDIRECIONANDO REQUISIÇÕES ....................................................... 259 UMA ARQUITETURA PARA COMÉRCIO ELETRÔNICO ............................................................... 259 Tipos de aplicações na WEB ............................................................................................ 259 Arquitetura MVC para a Web .......................................................................................... 259 Agenda Web: Um Exemplo de uma aplicação Web usando a arquitetura MVC.............. 259Capítulo XVII Perguntas Frequentes .......................... 259Bibliografia ................................................ 259Links ....................................................... 259Índice ...................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 6Capítulo I - Introdução Java é uma linguagem de programação desenvolvida pela SunMicrosystems e lançada em versão beta em 1995. O seu desenvolvimento foiiniciado em 1991 pela equipe liderada por James Gosling visando o mercado debens eletrônicos de consumo. Por isso foi projetada desde o início para serindependente de hardware, uma vez que as características dos equipamentosvariam amplamente neste nicho de desenvolvimento. Outro objetivoestabelecido desde sua concepção foi o de ser uma linguagem segura. Seguratanto no sentido de evitar algumas falhas comuns que os programadorescostumam cometer durante o desenvolvimento, como no sentido de evitarataques externos. Isto é importante no mercado de bens eletrônicos de consumopor que ninguém gostaria de adquirir um produto que necessitasse desligar ereligar para que voltasse a funcionar corretamente. Estas característicasdespertaram o interesse para utilização de Java em outro ambiente que tambémnecessitava de uma linguagem com este perfil: a Internet. A Internet também éum ambiente constituído por equipamentos de diferentes arquiteturas e necessitamuito de uma linguagem que permita a construção de aplicativos seguros.Muitas pessoas argumentarão que estas características podem ser encontradasem outras linguagens e portanto isto não explica o súbito sucesso da linguagem.Podemos arriscar alguns palpites apesar de este ser um terreno um poucopantanoso para se aventurar, até por que as linguagens de programação tendemassumir um caráter quase religioso. Uma das razões que na nossa opiniãofavoreceram a rápida adoção da linguagem foi a sintaxe. Java é sintaticamentemuito semelhante à linguagem C/C++, apesar de existirem diferençasfundamentais na filosofia de implementação entre as duas linguagens. Istofacilitou a migração de uma legião imensa de programadores C/C++ para a novalinguagem. Outra razão que não pode ser desprezada é o momento atual onde osdesenvolvedores estão ansiosos para se libertarem de sistemas proprietários.Portanto, apesar de não serem novas as idéias embutidas na linguagem Java, areunião delas em uma só linguagem, juntamente com a facilidade migração dosprogramadores e o momento atual, contribuíram para o rápido sucesso dalinguagem. Hoje, segundo a International Data Corp. (IDC), existem mais de 2milhões de programadores Java no mundo e a estimativa é que o número dedesenvolvedores ultrapasse os 5 milhões em 2004. O número de programadoresJava deve ultrapassar o de programadores C++ ainda este ano (2002), segundo aconsultoria americana Evans Data. Os profissionais que dominam a linguagem Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 7estão entre os mais bem pagos da área de Tecnologia da Informação (TI), comsalários variando de 3 a 10 mil reais, podendo em alguns casos chegar à 16 milreais, segundo a revista Info Exame (dezembro de 2001). A lista abaixo apresenta as principais características de Java de modo queo leitor tenha uma visão geral da linguagem:• Orientação a objetos. Java não é uma linguagem totalmente orientada a objetos como Smalltalk, onde tudo é objeto ou métodos de objetos. Por questões de eficiência foram mantidos alguns tipos primitivos e suas operações. No entanto, Java possui um grau de orientação a objetos bem maior que C/C++, o que a torna bem mais harmoniosa e fácil de assimilar, uma vez que o programador tenha compreendido esta forma de desenvolvimento.• Compilação do código fonte para código de uma máquina virtual (Bytecodes). Esta característica visa tornar a linguagem independente de plataforma de Hardware e Sistema Operacional. Obviamente é necessário que exista um programa capaz de interpretar o código em Bytecodes para cada Sistema Operacional, denominado de Máquina Virtual. No entanto, nada impede que o código fonte seja traduzido diretamente para o código executável na máquina de destino. Já existem ambientes de desenvolvimento que apresentam este tipo de opção. Alternativamente, é possível projetar equipamentos que processem em hardware os Bytecodes. A Sun desenvolveu um processador que executa operações em Bytecodes, denominado de JavaChip. O diagrama abaixo ilustra as etapas envolvidas na execução de um código Java. Figura I-1. Fases para execução de um programa fonte em Java• Ausência de manipulação explícita de ponteiros. Em linguagens como C/C++ e Pascal existe o tipo ponteiro como tipo primitivo da linguagem. A especificação original de Pascal é restritiva no uso de ponteiros, permitindo que sejam usados apenas para referenciar memória obtida na área de alocação dinâmica (heap) e não permite que o programador examine o valor Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 8 da variável do tipo ponteiro, nem que realize operações aritméticas com ponteiros. Já a linguagem C/C++ permite que o valor armazenado na variável do tipo ponteiro faça referência a qualquer área de memória, inclusive à área estática e automática (pilha), além de permitir aritmética de ponteiros e o exame direto do valor armazenado. A manipulação do tipo ponteiro exige uma grande dose de atenção por parte do programador e mesmo programadores experientes frequentemente cometem erros no seu uso. Além disso, o uso de ponteiros é uma fonte de insegurança na linguagem, uma vez que permite que o usuário faça acesso a memória que pode pertencer a outros processos, abrindo a possibilidade para desenvolvimento de programas hostis ao sistema. A linguagem Java não possui o tipo ponteiro. Isto não que dizer que não seja possível realizar alocação dinâmica de memória. Todo objeto criado é alocado na área de heap, mas o usuário não pode manipular a referência ao objeto explicitamente.• Recuperação automática de memória não utilizada (Coleta de Lixo – Garbage Collection). Nas linguagens onde existe alocação dinâmica de memória, o programador é responsável pela liberação de memória previamente obtida na área de alocação dinâmica e que não está sendo mais utilizada. Se houver falhas na execução desta responsabilidade ocorrerá o problema que é conhecido sob a denominação de “vazamento de memória”. Este problema faz com que a partir de certo ponto o programa não consiga obter memória para criação de novos objetos, apesar de existir área que não está sendo mais usada mas que não foi devolvida ao gerente de memória. Outro erro comum é a tentativa de acesso á áreas de memória já liberadas. Todos os programadores que trabalham com linguagens que permitem alocação dinâmica conhecem bem estes problemas e sabem o quanto é difícil implementar programas que não possuam estes tipos de erros. A maior parte dos erros que ocorrem no uso destas linguagens é devido a problemas na alocação/liberação de memória. Visando o desenvolvimento de aplicações robustas, livres deste tipo de falha, os projetistas de Java incorporaram um procedimento de coleta automática de lixo à máquina virtual. Deste modo, os objetos que não estão sendo mais usados são identificados pelo procedimento, que libera a memória para ser utilizada na criação de novos objetos.• Segurança. As pessoas costumam dizer que Java é uma linguagem segura. Mas o que é ser uma linguagem de programação segura? Segurança possui significados distintos para pessoas diferentes. No caso da linguagem Java na Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 9 versão 1.0 segurança significa impedir que programas hostis que possam causar danos ao ambiente computacional, ou que busquem informações sigilosas em computadores remotos para uso não autorizado. Na versão 1.1 foi adicionada a capacidade de permitir a verificação da identidade dos programas (autenticação) e na versão 1.2 os dados que os programas enviam e recebem podem ser criptografados por meio do uso de um pacote adicional. Na versão 1.4 o pacote de criptografia JCE (JavaTM Cryptography Extension) foi incorporado ao J2SDK.• Suporte à Concorrência. A construção de servidores, a criação de programas com interfaces gráficas, e programas semelhantes que tem em comum a necessidade de que o atendimento de uma solicitação não incapacite o sistema de responder a outras solicitações concorrentemente, demandam o uso de uma linguagem que facilite o desenvolvimento deste tipo de programa. As linguagens projetadas antes do surgimento destas necessidades, como C/C++, não previam facilidades para este tipo de programação, o que obrigou a incorporação destes recursos posteriormente, por meio de funções adicionais. Como a programação concorrente é uma forma de programação que difere bastante da programação sequencial convencional, a simples adição de novas funções para tentar adaptar a linguagem a esta forma de codificação, não cria um ajuste perfeito com a linguagem subjacente. Por outro lado, Java foi projetada visando facilitar a programação concorrente. Isto faz com que a criação linhas de execução (threads) seja bem mais natural dos que nas linguagens tradicionais.Programação em rede. Java possui em seu núcleo básico classes para comunicação em rede por meio dos protocolos pertencentes à pilha de protocolos TCP/IP. A pilha de protocolos TCP/IP é a utilizada pela Internet e tornou-se o padrão de fato para comunicação entre computadores em uma rede heterogênea. Isto torna Java particularmente atrativa para o desenvolvimento de aplicações na Internet. Além disso Java está incorpora um amplo de conjunto de soluções para computação distribuída, como CORBA (Common Object Request Broker Architecture), RMI (Remote Method Invocation) e Servlets/JSP (aplicações Java que são executadas por servidores Web). Após o lançamento da versão beta da linguagem em 1995, a Sun temliberado diversas evoluções da linguagem na forma de versões e releases de umconjunto de ferramentas denominado de Java Development Kit (JDK) até aversão 1.2, quando se passou a denominar Java 2 SDK (Standard DevelopmentKit). Isto ocorreu porque outros kits de desenvolvimento com propósitos Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 10específicos foram lançados, como o J2EE (Java 2 Enterprise Edition), voltadopara aplicações distribuídas escaláveis e o J2ME (Java 2 Micro Edition), voltadopara aplicações embutidas em dispositivos eletrônicos (Celulares, handheld,etc.). Durante a elaboração deste livro, a última versão estável do SDK era a denúmero 1.3.1 que pode ser obtida gratuitamente no site http://java.sun.com/.ConvençõesAs seguintes convenções são usadas neste livro.1. Fontes com larguras constantes são usadas em: • exemplos de código public class Ponto { private int x,y; } • nomes de métodos, classes e variáveis mencionadas no texto.2. Fontes com larguras constantes em negrito são usadas dentro de exemplos de códigos para destacar palavras chave.3. Fontes em itálico são usadas: • em termos estrangeiros; • na primeira vez que for usado um termo cujo significado não for conhecimento generalizado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 11Capítulo II - Programação Orientadaa Objetos O mundo pode ser visto como um conjunto de objetos que se relacionam.Por exemplo, uma pessoa, uma casa, uma cadeira da casa, etc. Os objetos nãosão necessariamente físicos. Podem possuir uma natureza abstrata, como umevento (uma partida de futebol) ou algo inexistente no mundo real (elefante cor-de-rosa). Na verdade, o conceito de objeto atua no nível lógico e não no real. Seiremos representar algo como objeto ou não depende apenas de uma decisão anível lógico que pode facilitar a simulação de determinado aspecto da realidade. Os objetos se agrupam em classes, segundo propriedades ou atributoscomuns. Por exemplo, a classe dos retângulos agrupa todas as formasgeométricas com a propriedade de possuir quatro lados formando ângulos de90o. A relação entre um objeto e uma classe é de pertinência. Dizemos que umobjeto pertence a uma classe ou, mais comumente, que é uma instância de umaclasse. O Figura abaixo ilustra exemplos de classes. Figura II-1. Classe dos (a) retângulos e dos (b) dos triângulos. As classes podem ser relacionar com outra classe no sentido que umaclasse pode conter outra. Por exemplo, a classe de retângulos está inserida emuma classe mais genérica, a classe dos polígonos. A classe mais genérica édenominada de Superclasse e as classes mais específicas são denominadas de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 12Subclasses. As subclasses herdam as propriedades das superclasses. No nossoexemplo, os polígonos possuem as propriedades de ter uma área, uma posição noplano, um número n de vértices e n-1 ângulos. Todas essas propriedades sãoherdadas tanto pela classe dos retângulos como pela classe do triângulos.Podemos desta forma organizar os objetos em uma hierarquia onde as classesmais específicas herdam as propriedades das classes mais genéricas. Figura II-2. Classe dos polígonos. Os objetos de uma classe possuem comportamentos que podem alterar ovalor de suas propriedades. Por exemplo, um carro pode sofrer uma aceleraçãoou ser freado e com isso alterar a sua velocidade. Um objeto qualquer pode serdeslocado, alterando assim as suas coordenadas no espaço.Classes e Objetos e Linguagens de Programação As linguagens de programação são utilizadas para construir simulaçõesde aspectos da realidade no computador. Quanto mais facilmente pudermosexpressar os conceitos capturados da realidade, mais facilmente construiremos asimulação. Seguindo este raciocínio podemos concluir que as linguagens quepossuem facilidades para representação de objetos permitem uma modelagemmais fácil dos conceitos do mundo real. No entanto, podemos utilizar umalinguagem de programação convencional para modelar as classes e objetosabstraídos da realidade. Por exemplo, podemos modelar a classe dos retângulospor meio de um registro (record) em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 13 type Classe_Retangulo = record X1,Y1,X2,Y2: integer; end; Exemplo II-1. Representação da Classe Retângulo em Pascal. No Exemplo II-1 o retângulo é definido por dois pontos, sendo X1 e Y1 oponto superior esquerdo e X2 e Y2 o ponto inferior direito. Os objetos podemser representados por meio de variáveis do tipo definido: type Classe_Retangulo = record X1,Y1,X2,Y2: integer; end; var Retangulo1 : Classe_Retangulo; Exemplo II-2. Criação de objetos em Pascal. procedure intRetangulo(XA,YA,XB,YB: integer; var R: Classe_Retangulo); begin R.X1 := XA; R.Y1 := YA; R.X2 := XB; R.Y2 := YB; end; procedure MudaPos(X,Y: integer; var R: Classe_Retangulo); begin R.X2 := X+(R.X2-R.X1); R.Y2 = Y+(R.Y2-R.Y1); R.X1 = X; R.Y1 = Y; end; Exemplo II-3. Definição das operações em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 14 As propriedades dos objetos podem ser manipuladas através de funções eprocedimentos. Por exemplo, podemos ter uma operação para inicializar osvalores da estrutura e outra para alterar a posição do retângulo. O Exemplo II-3mostra essas duas operações. Contudo, existem algumas limitações das linguagens convencionais que astornam inadequadas para a modelagem de objetos: • Não existem recursos para ocultar a estrutura de dados de procedimentos que não foram projetados para a sua manipulação. É muito importante que a linguagem forneça recursos para se implementar este tipo de isolamento. Se acessarmos uma estrutura apenas por meio dos procedimentos projetados para este fim, quando a estrutura for alterada apenas os procedimentos que manipulam a estrutura sofreriam modificações. No entanto, se não agirmos desta forma será necessário procurar em todo o programa os acessos diretos à estrutura. Claro que este comportamento pode ser adotado em qualquer linguagem, mas é mais seguro se a linguagem fornece meios para o programador forçar este tipo de comportamento. A capacidade de “esconder” a estrutura de dados de acessos diretos é chamada de ocultação de informação. • Não existem recursos para herança de propriedades entre classes e subclasses. Se precisarmos implementar uma estrutura que é uma especialização de outra já implementada, será preciso codificar novamente todas as propriedades, mesmo as comuns, e todos os procedimentos de acesso. Isto dificulta o reaproveitamento de código, o que, consequentemente aumenta o tempo de desenvolvimento e a possibilidade de erros. • Não existe uma forma de relacionar explicitamente as estruturas de dados com os procedimentos que as manipulam. O relacionamento entre os procedimentos que manipulam uma estrutura de dados e a estrutura é estabelecido implicitamente, por meio de alguma convenção definida pelo programador. É importante que a linguagem obrigue o programador relacionar explicitamente os procedimentos com a estrutura de dados, de modo que fique claro qual é a interface de acesso ao objeto. A adoção de uma linguagem programação orientada a objetos resolve todosesses problemas. Existem várias linguagens comerciais com esta característica:Smalltalk, Eiffel, C++, etc. Algumas com elementos não orientados a objetoscomo C++, outras puramente orientadas a objetos como Smalltalk, onde tudo é Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 15objeto. Java é uma linguagem orientada a objetos mais “pura” do que C++,fugindo desta orientação apenas em alguns pontos bem definidos, em nome daeficiência de execução. Em Java podemos representar diretamente as classes eobjetos. Por exemplo, a classe retângulo seria declarada da seguinte forma: class Retangulo { int X1,Y1,X2,Y2; public Retangulo(int XA, int YA, int XB, int YB) { X1 = XA; Y1 = YA; X2 = XB; Y2 = YB; } void MudaPos(int X, int Y) { X2 = X+(X2-X1); Y2 = Y+(Y2-Y1); X1 = X; Y1 = Y; }; } Exemplo II-4.Representação da Classe Retângulo em Java. No Exemplo II-4 mudamos o nome do procedimento iniRetangulo paraRetangulo, que é o mesmo nome da classe. No momento não é importanteentendermos a razão desta mudança, que será esclarecida no próximo capítulo.Note que os procedimentos são declarados dentro do corpo da classe, tornandoexplícito relacionamento entre a classe e os procedimento. As funçõesdeclaradas nas classes são chamadas de métodos e a partir de agora nosreferenciaremos a eles como tal. Note também que diferentemente do exemploem Pascal, não é preciso passar o objeto como parâmetro, uma vez que asvariáveis que estão sendo modificadas pertencem ao objeto corrente, ao qual estáassociado o método. É como se para cada objeto de uma classe fossem criadasversões de todos os métodos da classe, de modo que cada método só opera sobreas variáveis do objeto a quem pertencem. Para declarar uma variável do tipo daclasse basta preceder a variável com o nome da classe. Retangulo ret; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 16 Até esse momento nenhum objeto foi criado. Para criar um objeto(instância) é usado o operador new. ret = new Retangulo(10,10,20,30); Note que o operador new é seguido de uma chamada ao método com omesmo nome da classe. O métodos com esta característica são chamados deconstrutores e só podem ser invocados durante a criação de um objeto. Comoveremos mais tarde, uma classe pode ter mais de um construtor. Após a criaçãodo objeto é possível acessar os outros métodos do objeto através do operador “.”.Por exemplo, podemos mudar a posição do objeto por meio do método MudaPos. ret.MudaPos(40,40); Como já dissemos, não é preciso passar o objeto como argumento, já queé criada uma cópia do método para cada objeto. A grosso modo podemos dizerque cada instância da classe recebe uma cópia da variáveis e dos métodos daclasse.Ocultando de Informação O projetista cuidadoso deve ocultar a representação interna da classe,permitindo o acesso aos atributos da classe via métodos predefinidos. Destaforma a representação interna fica isolada do restante do programa e fica maisfácil alterá-la sem que seja preciso alterar outras partes do código. A ocultaçãode informação é obtida por meio de qualificadores, como o private, queimpede o acesso à variáveis via métodos definidos em outras classes. O nível deocultação depende do qualificador utilizado. Todos os qualificadores serãoabordados com detalhes no Capítulo IV. O exemplo II-5 mostra como impedirque as variáveis declaradas na classe Retangulo sejam acessadas diretamente. class Retangulo { private int X1,Y1,X2,Y2; public Retangulo(int XA, int YA, int XB, int YB) { X1 = XA; Y1 = YA; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 17 X2 = XB; Y2 = YB; } void MudaPos(int X, int Y) { X2 = X+(X2-X1); Y2 = Y+(Y2-Y1); X1 = X; Y1 = Y; }; } Exemplo II-5. Ocultando informação em Java.Especialização e Herança Para criar uma subclasse de uma classe pré-existente utilizamos ooperador extends. Por exemplo, podemos definir uma subclasse da classeRetangulo, chamada de RetanguloColorido, que possui, além das variáveis emétodos herdados da superclasse, uma variável para armazenar a cor doretângulo, juntamente com um método para alterar o valor. class RetanguloColorido extends Retangulo { private Color Cor; void AtribuiCor(Color C) { Cor = C; }; } Exemplo II-6. Declarando subclasses em Java. A princípio, subclasse pode acessar todos os métodos e variáveis dasuperclasse. No entanto, isto também pode ser alterado via qualificadores. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 18Sobrescrita, Sobrecarga e Polimorfismo Podemos definir mais de um método com o mesmo nome na mesmaclasse ou subclasses. Caso o método possua a mesma assinatura (número e tiposde argumentos e tipo de retorno) que outro método, então o método não podepertencer à mesma classe do anterior. Se ambos os métodos estiverem na mesmalinha hierárquica (classe/subclasse), dizemos que o método da subclassesobrescreve o método da superclasse. O método que será executado dependeráda classe do objeto. class Empregado { protected float salario; public float getSalario() {return salario;} } class Vendedor extends Empregado { protected float comissao; public float getSalario() {return salario+comissao;} } Exemplo II-7. Sobrescrita do método getSalario(). No exemplo II-7 o método getSalario() da classe Vendedorsobrescreve o método do mesmo nome da classe Empregado. Se a assinatura do método for diferente de outro método com o mesmonome definido anteriormente na mesma classe ou em outra classe da mesmalinha hierárquica, então estamos realizando uma sobrecarga sobre oidentificador do método. Quando for usado o identificador dentro do código deum programa o método invocado será determinado pela classe a que pertence oobjeto do método e pelo número e tipos dos argumentos passados para o método.O termo sobrecarga advém do fato de um mesmo identificador denotar mais demétodo. class Empregado { protected float salario; public void aumento() {salario= salario*10.0;} public void aumento(float porcent) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 19 { salario= salario*porcent; } } Exemplo II-8. Sobrecarga do método aumento(). No exemplo II-8 o identificador aumento pode referenciar dois métodosdistintos. Um aumenta o salário em 10% e no outro o aumento depende do valorda porcentagem passado como parâmetro. Note que as assinaturas do métodosdiferem entre si. Alguns autores chamam sobrecarga de polimorfismo, que é a habilidadede um determinado objeto se comportar ou ser visto de diferentes formas,quando na verdade a sobrecarga é um tipo particular de polimorfismo, chamadode polimorfismo ad hoc . Na sobrecarga um identificador representa váriosmétodos com computações distintas. Existe também o polimorfismoparamétrico, onde um método pode realizar a mesma computação sobre objetosde tipos distintos. Isso pode ser implementado em Java definindo um métodoque recebe e retorna objetos da classe Object. Como a classe Object é a “mãede todas as classes” o método pode operar da mesma forma independente daclasse a qual o objeto realmente pertence, desde que a computação sejaindependente da classe. class Poli { public Object identidade(Object objeto) { return Object; } } Exemplo II-9. Polimorfismo paramétrico. No Exemplo II-9 o método identidade() retorna o objeto passadocomo parâmetro. Este método realiza a mesma computação, independentementeda classe do objeto. Obviamente é um exemplo muito simples e sem utilidadeprática mas serve para ilustrar o conceito de polimorfismo paramétrico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 20Introdução à Diagrama de Classes É possível registrar diretamente em uma linguagem de programação osobjetos percebidos em uma determinada realidade. No entanto, é melhorutilizarmos uma notação gráfica intermediária para melhor visualizarmos osobjetos e as relações entre objetos, e ir alterando esta representação até estarmosseguros que possuímos um entendimento razoável do problema, e ai sim,partirmos para a codificação da solução. Muitas vezes é preciso recorrer a maisde uma notação gráfica, de modo a expressar várias facetas da realidade que estásendo modelada. Neste livro, recorreremos ao uso de notação gráfica em algunsexemplos para ilustrarmos a arquitetura dos programas antes de apresentarmos ocódigo. Acreditamos que desta forma o leitor compreenderá melhor osexemplos. A notação gráfica que adotamos mostra as relações estáticas entre classesde objetos. Ela faz parte do conjunto de notações da UML (Unified ModelingLanguage ou Linguagem de Modelagem Unificada) proposta por Grady Booch,James Rumbaugh e Ivar Jacobson em 1995. A UML é um conjunto de notaçõesque tem por objetivo modelar diversos aspectos de um sistema em diferentesníveis de abstração. Ou seja, pode ser utilizado para a captura de requisitos deum sistema assim como em projeto de programas. É voltada para análise eprojeto de sistemas orientados a objetos. A área de análise e projeto orientados aobjetos ainda não possui uma notação “vencedora” como existe para a análise eprojeto estruturado. Contudo, a UML vem se popularizando rapidamente, e éencontrada com facilidade em textos de programação, sobretudo em se tratandode Java. Portanto, um conhecimento sobre as principais notações que constituema UML é importante para qualquer um que deseja ingressar na área deprogramação orientada a objetos. Este livro utiliza uma das linguagens, oudiagramas, que compõem a UML: o diagrama de classes.Diagrama de Classes O Diagrama de Classes representa graficamente as classes do sistema e orelacionamento estático entre as classes, isto é, o relacionamento que não mudacom o tempo. Por exemplo, em um sistema acadêmico, um aluno cursa váriasdisciplinas. O número de disciplinas e a disciplina que efetivamente está sendocursada pode alterar, mas o vínculo aluno-cursa-displinas permanece. Parailustrar o nosso estudo dos diagramas da UML utilizaremos exemplos sobremodelagem de aspectos realidade acadêmica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 21 Uma classe é representada no diagrama de classes por meio de umretângulo, que pode ser dividido em até três seções horizontais, como mostradona figura abaixo: Figura II-3. Forma geral para representação de uma classe. A seção superior é usada para registrar o nome da classe. A seçãointermediária é reservada para registro das propriedades da classe, caso existam,e na seção inferior é registrado a assinatura dos métodos que pertencem à classe,caso existam. Por assinatura do método queremos dizer o nome do método,juntamente com seus argumentos e valor de retorno. A figura abaixo mostra umarepresentação da classe das disciplinas. Figura II-4. Representação da classe das disciplinas De modo geral, por razões de simplicidade, não se representam osmétodos que tratam da alteração dos atributos e construtores. Se Assumi quetoda classe possui estes métodos. Portanto, podemos simplificar a representaçãoacima, omitindo a seção do métodos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 22 Figura II-5. Representação simplificada da classe das disciplinas. Podemos indicar tanto nos atributos quanto nas classes a visibilidadedeles em relação a outras classes. As visibilidades possíveis, juntamente com ossímbolos adotados estão listados na tabela abaixo: Visibilidade Símbolo Descrição Pública + Sem restrição de acesso. Protegida # Pode ser acessado apenas na própria classe e por subclasses. Privada - Pode ser acessado apenas na própria classe. Tabela II-1. Visibilidades possíveis para atributos e métodos. A visibilidade é atribuída a um atributo ou método precedendo adeclaração do método com o símbolo adequado, como na figura abaixo: Figura II-6. Representação com visibilidade. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 23 As classes podem se relacionar de diversas formas: por associaçãocomum, por agregação e generalização. Abaixo é apresentada cada forma derelacionamento, juntamente com suas as notações. Associação comum A notação utilizada para associar duas classes é simplesmente uma linhaunindo as classes. A figura II.7 mostra a associação entre a classe dos alunos e aclasse das disciplinas. Figura II-7. Associação entre Aluno e Disciplina. A figura acima expressa que alunos se associam com disciplinas mas nãoindica se um aluno se relaciona com várias ou apenas uma disciplina. Estainformação é chamada de cardinalidade da relação e é expressa anotando-se ovalor da cardinalidade na associação junto à classe que está sendo relacionada.Assim, a figura II.8 expressa que um aluno se relaciona com várias disciplinas. Figura II-8. Associação de um Aluno com várias Disciplinas. Como uma disciplina se relaciona com vários alunos, o diagramacompleto é o representado na figura II-9. Figura II-9. Associação de vários Aluno com várias Disciplinas. A tabela II-2 mostra algumas representações de cardinalidade: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 24 Notação Descrição 1 Exatamente um * ou 0..* Zero ou mais 0..1 Opcional (zero ou um) n..m Máximo e mínimo Tabela II-2. Representações de cardinalidade. Até agora apresentamos apenas associações entre duas classes, mas nadaimpede que mais de duas classes participem de uma associação. Por exemplo, afigura II-10 ilustra uma associação ternária que representa o fato de um alunocursar uma disciplina em um período. Figura II-10. Associação entre aluno, disciplina e período. Uma associação pode ter atributos próprios. Ou seja, atributos que nãopertençam a nenhuma das classes envolvidas na associação mas sim à própriaassociação. Na associação entre alunos e disciplina o atributo nota, não pertencea aluno, tampouco à disciplina, uma vez que para saber uma nota é preciso saberquem é o aluno e qual é a disciplina. A representação de atributos da associaçãoé representada por meio de um retângulo ligado à associação por meio de umalinha tracejada. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 25 Figura II-11. Representação de atributos de associação. Agregação Alguns objetos são compostos por outros objetos. Por exemplo, um carroé composto por chassi, lataria, pneus e motor, que por sua vez é composto pelocarburador, pistões, bloco, etc. Este tipo de associação é representada por umalinha com um losango na ponta. Figura II-12. Agregação entre Curso e Disciplina. Generalização O último tipo de associação entre classes é o que o ocorre entresuperclasses e subclasses. Uma superclasse é uma generalização das suassubclasses, que herdam os atributos e métodos da primeira. A notação utilizadapara representar a generalização é uma linha com um triângulo na extremidadeda associação no lado da classe mais genérica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 26 Figura II-13. Representação da generalização. A figura II-14 procura representar todas associações discutidas em umúnico diagrama. Figura II-14. Associação entre as classes do domínio acadêmico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 27Capítulo III - Introdução àLinguagem Java Existe uma tradição entre os programadores que estabelece que ao secomeçar a aprender uma nova linguagem de programação, o primeiro programaa ser escrito deve ser um que imprima a frase “Olá mundo” em um dispositivode saída. Dizem que isto atrai a sorte e espanta os bugs. Independente da crençageral, existem algumas razões bastante justificáveis para se começar oaprendizado de uma linguagem executando logo um programa, mesmo sem termuita idéia do que se está fazendo. Primeiramente, existe o fator psicológico.Iniciar o aprendizado executando um programa sem erros, aumenta confiança doaluno e elimina temores de se estar aprendendo algo muito complexo. Existetambém o fato de que apesar de um programa muito simples dar uma visão umpouco limitada da linguagem, já é possível observar alguns elementosimportantes. Afinal trata-se de um programa completo. Portanto, para não fugir atradição, eis o programa OlaMundo em Java: public class OlaMundo { public void exibeOla() { System.out.println(“Ola, Mundo!”); } public static void main(String args[]) { OlaMundo obj = new OlaMundo(); Obj.exibeOla(); } } Exemplo III-1. Programa OlaMundo. O programa acima é composto por uma única classe que possui apenasdois métodos. Isto é importante, porque não é possível fazer um programa Javasem recorrer às classes, uma vez que os procedimentos são definidos comométodos de classes. Isto não é verdade em linguagens como C++, o que diminuio seu “grau” de orientação a objetos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 28 Os métodos com o nome main são métodos especiais e servem comoponto inicial para execução do programa. Ou seja, a execução do programa seráiniciada a partir da execução de um método main(). A assinatura do métodomain é sempre a mesma e a sua descrição em detalhes será vista na seçãoArgumentos da linha de comando. Podemos adiantar apenas que o qualificadorpublic estabelece que este método pode ser chamado por métodos ouprocedimentos externos à classe. O qualificador static significa que o métodopertence à classe e não às instâncias da classe, e deste modo pode ser invocadomesmo antes de ser criado algum objeto para a classe. void indica que o métodonão retornará valor algum. Já argumento String args[] é um array deStrings contendo os parâmetros passados na linha de comando. O corpo do método main() possui duas linhas. A primeira instrução criaum objeto da classe OlaMundo e o atribui à variável obj. A segunda linha invocao método exibeOla() do objeto recém criado. O método exibeOla() invoca ométodo println() do objeto out da classe System, que faz parte do pacote declasses fornecido com a linguagem. Este método exibe no dispositivo de saídapadrão a String que é passada como argumento. Se você olhar os programas “OlaMundo” mostrados em outros livrossobre Java irá notar que o programa apresentado aqui é um pouco maiscomplicado que o exibido nesses livros. Geralmente este programa inicial éapresentado apenas com um método: o método main(). A razão de termos usadouma abordagem diferente é que desejamos desenvolver um hábito saudável naprogramação em Java: procure usar o método main() apenas para criar osobjetos e deixe que os objetos executem a lógica do problema. Este programa deve ser salvo em um arquivo contendo O MESMONOME DA CLASSE e com as mesmas letras maiúsculas e minúsculas (éimportante frisar, uma vez que esquecer este detalhe é um erro muito comum), ecom a extensão “.java”. Portanto o arquivo contendo o programa acima deveráse chamar OlaMundo.java. Se você instalou o Java 2 development kit (SDK),que pode ser obtido gratuitamente no site http://java.sun.com/products/, entãopara compilar o programa basta digitar o comando: javac OlaMundo.java O código Java é traduzido (o termo mais comum é compilado) parainstruções de uma máquina virtual (bytecodes) para que possa ser executado deforma independente da plataforma (sistema operacional e hardware). O códigoem bytecodes é armazenado em um arquivo com o mesmo nome do original ecom a extensão “.class”. Assim após a execução do comando acima será Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 29gerado o arquivo OlaMundo.class. A invocação da máquina virtual paraexecutar o código em bytecodes é efetuada por meio do seguinte comando: java OlaMundo Neste ponto nota-se uma desagradável idiossincrasia do SDK. Paracompilar o programa para bytecode foi necessário explicitar a extensão doarquivo, porém, para executar o código é preciso omitir a extensão “.class”.Apesar de ser um detalhe que aparentemente não prejudica o uso do ambiente,confunde o usuário, principalmente o iniciante. Quando recebe um arquivo de bytecodes para a executar, a máquinavirtual procura o método main() em uma classe com o mesmo nome do arquivo.Uma vez encontrado o método a execução é iniciada com a execução do método.Isto significa que em nosso exemplo será procurado o método main() da classeOlaMundo para servir de ponto de entrada. Podem existir outros métodos main()em outras classes codificadas no mesmo arquivo de bytecodes, mas apenas ométodo main() da classe com o mesmo nome do arquivo servirá de ponto inicialde execução. Portanto, em nosso caso, o programa será executado produzindo asaída: Ola, Mundo!Agora que já cumprimos o ritual de iniciação na linguagem, podemos passar adescrever os detalhes da linguagem. Grande parte das descrições que seguemabaixo foram baseadas na especificação da linguagem registrada no livro TheJava Language Specification, segunda edição, por James Gosling e outros.Identificadores Todos os identificadores da linguagem devem iniciar com uma letra, ou ocaractere ´_`, ou o caractere ´$`. Deve-se evitar o uso do caractere ´$`, de modoque fique reservado para geração de código automático. Tratamos por letra todocaractere reconhecido pelo método Character.isJavaLetter. Isto inclui umaampla gama de caracteres do conjunto Unicode1, de modo que os programadorespodem usar identificadores adaptados a uma ampla gama de idiomas. Após o1 O conjunto de caracteres Unicode foi criado para substituir o conjunto ASCII. Ele usa 16 bitspara representar os caracteres, o que resulta em 65536 caracteres possíveis, em oposição aos 7bits do código ASCII (8 para o ASCII estendido), o que resulta em 128 caracteres possíveis (256para 8 bits). Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 30primeiro caractere, também podem ser usados os caracteres que vão de ´0` até´9`. A linguagem Java distingue as letras maiúsculas das minúsculas, portanto oidentificador Aluno é distinto do identificador aluno. A tabela III-1 mostraalguns identificadores válidos e inválidos. Válido Inválido Aluno10 Aluno#10 Num_Alunos Num Alunos _disciplina$ !disciplina Professor_10 10Professor αβγ &uuu Não Não? Tabela III-1. Identificadores válidos e inválidos em Java.Palavras Reservadas As seguintes sequências de caracteres são reservadas para o uso comopalavras chave e, portanto, não podem ser usadas como identificadores:abstract continue goto package synchronizedassert2 default if private thisboolean do implements protected throwbreak double import public throwsbyte else instanceof return transientcase extends int short trycatch final interface static voidchar finally long strictfp3 volatileclass float native super whileconst for new switch Tabela III-2. Palavras reservadas da linguagem Java. As palavras chave const e goto, apesar de serem reservadas, não estãosendo usadas correntemente na linguagem.2 Introduzida a partir da versão 1.4 do SDK.3 Introduzida a partir da versão 1.2 do SDK Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 31Literais Literais são elementos do código que representam um valor de tipoprimitivo, tipo String ou null. Os literais podem ser numéricos, booleanos,caracteres ou cadeias de caracteres (Strings). Literais numéricos inclueminteiros, ponto flutuante.Literais Inteiros Um literal inteiro é do tipo primitivo long (longo) se possui o sufixo ´L`ou ´l`, caso contrário é do tipo primitivo int (inteiro). Um numeral hexadecimalé prefixado pelos caracteres ´0x` ou ´0X` seguidos de um ou mais dígitoshexadecimais. Os dígitos hexadecimais com valores entre 10 e 15 sãorepresentados pela letras ´a` até ´f` ou ´A` até ´F`, nessa ordem. Um numeraloctal consiste de um dígito 0 seguido de um ou mais dígitos de 0 até 7. O maior literal decimal do tipo int é 2147483648. Os literais decimaisde 0 até 2147483647 podem aparecer em qualquer lugar que um literal inteiropode aparecer, mas o literal 2147483648 pode aparecer somente como operandode uma negação unária. Os maiores literais hexadecimal e octal positivos inteiros são 0x7fffffff e017777777777, respectivamente, que correspondem ao valor decimal2147483647. Os maiores literais hexadecimal e octal negativos inteiros são0x80000000 e 020000000000, respectivamente, que representam o valordecimal -2147483648 (). Os literais hexadecimal e octal 0xffffffff e037777777777, representam o valor decimal -1. Abaixo estão listados algunsexemplos de literais inteiros: 0 -12 0372 0xCafe 1999 0x00FF00FF O maior literal decimal do tipo longo é o 9223372036854775808L. Osliterais decimais de 0L até 9223372036854775807L podem aparecer emqualquer lugar que um literal inteiro longo pode aparecer, porém o literal9223372036854775808L pode aparecer somente como operando de umanegação unária. Os maiores literais hexadecimal e octal positivos inteiros longos são0x7fffffffffffffffL e 0777777777777777777777L, respectivamente, quecorrespondem ao valor decimal 9223372036854775807L.Os maiores literais Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 32hexadecimal e octal negativos inteiros longos são 0x8000000000000000L e01000000000000000000000L, respectivamente, que representam o valordecimal -9223372036854775808L. Os literais hexadecimal e octal0xffffffffffffffffL e 01777777777777777777777L, representam o valor decimal -1. Abaixo estão listados alguns exemplos de literais inteiros longos:0L 0777L 0xC0B0L 0xCafe 1999 0x100000000LLiterais de Ponto Flutuante Um literal de ponto flutuante é composto por uma parte inteira seguidade um ponto decimal, uma parte fracionária, um expoente e um sufixodeterminando o tipo. O expoente, se presente, é indicado pela letra ‘E’ ou ‘e’,seguido por um inteiro com sinal um opcional. Pelo menos um dígito na parteinteira ou fracionária e o ponto decimal ou o expoente ou o sufixo indicando otipo são exigidos. Todos os outros componentes são opcionais. Um tipo ponto flutuante é do tipo float se possuir o sufixo ‘F’ ou ‘f’,caso contrário é do tipo double. O tipo double possuir opcionalmente o sufixo‘D’ ou ‘d’. O tipo float e double de Java obedecem a especificação IEEE 754 parabinários de ponto flutuante de precisão simples (32-bit) e dupla (64-bit). O maior literal positivo do tipo float é 3.40282347e+38f. O menorliteral positivo do tipo float diferente de zero é 1.40239846e-45f. O maiorliteral positivo do tipo double é 1.79769313486231570e+308. O menor literalpositivo do tipo double diferente de zero é 4.94065645841246544e-324. Um programa em Java pode representar quantidades infinitas semproduzir erros de compilação por meio da utilização de expressões constantestais como 1f/0f e -1d/0d ou pela utilização das constantes predefinidasPOSITIVE_INFINITY e NEGATIVE_INFINITY das classes Float e Double.Exemplos de literais do tipo float: 1e1f 2.f .3f 0f 3.14f 6.022137e+23fExemplos de literais do tipo double:1e1 2. .3 0.0 3.14 1e-9d 1e137 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 33Literais Booleanos O tipo boolean possui dois valores, representados pelos literais true efalse.Literais de Caracteres Um literal do tipo char é expresso como um caractere ou uma sequênciade escape, envolvida por aspas simples. Os caracteres CR e LF nunca sãocaracteres de entrada, uma vez que são reconhecidos como terminadores delinha. Exemplos de literais do tipo char: Caractere Descrição a o caractere a. % o caractere % n line feed t Tab o caractere o caractere . u03a9 uFFFF 177 Tabela III-3. Exemplo de literais do tipo char.Literais de Cadeia de Caracteres (Strings) Um literal do tipo String consiste de zero ou mais caracteres envolvidospor aspas duplas. Cada caractere pode ser representado por uma sequência deescapes. O tipo String não é um tipo primitivo e sim uma classe denominadaString. Portanto, um literal é na verdade uma instância da classe String. Uma String longa pode ser particionada em cadeias menores unidaspelo operador de concatenação ´+’. Exemplos de literais do tipo String:Literal Descrição"" Cadeia vazia. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 34""" Uma cadeia com apenas o caractere "."esta é uma cadeia" Uma cadeia contendo 17 caracteres."esta é uma " Uma cadeia formada por dois literais do+"cadeia " tipo String. Tabela III-4. Exemplo de literais do tipo String.Sequências de escape Sequências de escape permitem a representação de alguns caracteres nãográficos, assim como as aspas simples e duplas e a barra invertida. Exemplos desequências de escape: Sequência Descrição b u0008: backspace BS t u0009: tab horizontal HT n u000a: linefeed LF f u000c: form feed FF r u000d: carriage return CR " u0022: aspas duplas " u0027: aspas simples u005c: barra invertida Tabela III-5. Exemplo sequências de escape.O Literal null O tipo null possui apenas um valor, representado pelo literal null.Separadores Java possui nove separadores (caracteres de pontuação), listados abaixo: ( ) { } [ ] ; , . Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 35Tipos de dados Os tipos de dados definem como devem ser interpretados os dadosarmazenados. São essenciais a toda linguagem de programação e devem sercuidadosamente selecionados para compor a linguagem, de modo a não limitar asua área de atuação. A maioria da linguagens modernas definem um conjunto detipos simples, um conjunto de tipos compostos, formados por tipos maisprimitivos e alguma forma de definição de novos tipos, de modo que possamodelar mais apropriadamente a realidade. A linguagem Java obedece estaregra, fornecendo um conjunto de tipos simples e um conjunto de tiposcompostos. O mecanismo para definição de novos tipos utilizado por Java ésimplesmente a definição de classes. Java é uma linguagem fortemente tipada. Isto significa que toda variávele expressão possui um tipo determinado em tempo de compilação. Os tiposprimitivos disponíveis em Java não são classes. Esta é uma das razões porqueJava não é uma linguagem 100% orientada a objetos. No entanto, para cada tipoprimitivo existe uma classe correspondente onde são declarados um conjunto demétodos para a manipulação dos valores primitivos, focalizando principalmentena conversão de tipos. Estas classes estão agrupadas no pacote java.lang. Porexemplo, o tipo primitivo int é usado para expressar valores inteiros. A classecorrespondente ao tipo int é a Integer. Nela estão declaradas variáveispúblicas contendo o valor máximo e mínimo que uma variável do tipo inteiropode armazenar e métodos para conversão para outros tipos.Tipos de dados simples Tipos de dados simples são aqueles que não podem ser divididos emtipos mais primitivos. Os tipos de dados simples de Java podem ser divididos eminteiros, ponto flutuante, booleano e caractere. Para se definir uma variável deum determinado tipo basta preceder o nome da variável com o nome do tipodesejado, como na forma abaixo: <nome do tipo> <nome da variável>; Assim, para se declarar uma variável var1 do tipo inteiro basta a linha decódigo abaixo: int var1; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 36 Podemos também declarar mais de uma variável em com o mesmo tipo,usando o caractere ‘,’ como separador. Portanto, a declaração int var1, var2;é equivalente às declarações int var1; int var2; Java também permite que as variáveis sejam inicializadas durante adeclaração. Assim, para inicializarmos a variável var1 com o valor 1 nadeclaração basta a linha de código abaixo: int var1=1; Segue abaixo as categorias de tipos de dados simples.Inteiros Nome Tamanho byte 8 bits short 16 bits int 32 bits long 64 bits Tabela III-6. Tipos inteiros.Ponto Flutuante Nome Tamanho float 32 bits double 64 bits Tabela III-7. Tipos de ponto flutuante.booleanosboolean {true,false} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 37Caracterechar 16 bitsTipos de dados compostos Os tipos de dados compostos são constituídos por tipos mais simples.Todos os tipos compostos em Java são Classes. Nesta seção trataremos duasclasses de objetos muito usadas em Java para criação de tipos compostos: osarrays (arranjos) e strings. Posteriormente abordaremos a declaração de objetosno caso geral e no Capítulo VI será apresentado o pacote de classes java.utilque contém várias classes para agrupamento de objetos.Arrays Um array é um objeto, e como tal herda todos os métodos da classeObject. Um array contém um certo número de variáveis chamadas decomponentes. Em Java todo objeto é acessado indiretamente, via uma referência.Ou seja, não se cria uma variável do tipo de um objeto e sim uma variável quepode referenciar um objeto. Estamos falando de ponteiros, o que pode parecercontraditório, uma vez que tínhamos mencionado que Java não possui ponteiros.Na verdade Java acessa as instâncias de objeto por meio de ponteiros mas elesnão estão disponíveis como tipo da linguagem e nem é possível que oprogramador os manipule diretamente. Pode parecer pouco importante para o programador saber que a variávelnão armazena o objeto diretamente e sim uma referência a um objeto, uma vezque ele não pode manipular ponteiros. No entanto, acreditamos que estainformação é importante para que o leitor possa entender as etapas para a criaçãode objetos. A primeira etapa é a declaração da variável para referenciar o objetoe a segunda etapa é a criação do objeto propriamente dito. Para se declarar umavariável para referenciar objetos do tipo array é usada a seguinte sintaxe:tipo identificador[];tipo[] identificador;Exemplosint numeros[];char[] letras; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 38long grade[][]; Note que não é definido o número de elementos do array. Isto faz partedo objeto. Note também que existem duas formas de declarações de referências aarrays. O número de “[]” indica o número de dimensões do array. A criação doobjeto é realizada por meio do operador new, seguido pelo tipo do array e pelonúmero de componentes de cada dimensão, como nos exemplos abaixo:numeros = new int[10];char alfabeto[] = new char[26];grade = new long[10][10]; Alternativamente podemos realizar as duas etapas acima e ainda definiros elementos do array em uma única declaração como no exemplo abaixo, ondeé criado um array de três inteiros, referenciados pela variável primos e onde oprimeiro elemento é 7, o segundo é 11 e o terceiro é 13.int primos = {7, 11, 13}; De agora em diante não faremos distinção entre referência a objeto dotipo array e o objeto array, a não ser que seja necessário explicitar esta distinção. O acesso aos elementos do array é realizado por meio do nome davariável seguida por um expressão inteira não negativa envolvida peloscaracteres ‘[’ e ‘]’. A expressão inteira é chamada de índice e os valoresadmissíveis para a expressão vai de 0 a n-1, onde n é número de elementos doarray. O índice do primeiro elemento é 0. Abaixo seguem alguns exemplos:alfabeto[0] = ‘a’;grade[0][5] = 10L;for(int i=0; i<10; i++) numeros[i] = i*2; É possível descobrir o tamanho de um array em tempo de execuçãoacessando a variável pública length do objeto, onde está armazenada acapacidade do array. Por exemplo:for(int i=0; i< numeros.length; i++) numeros[i] = i*2;Strings Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 39 O manipulação de cadeias de caracteres (strings) em Java é realizada poruma classe do pacote java.lang denominada String. Ou seja, não existe umtipo primitivo para tratar cadeias de caracteres. Para se declarar uma variável quefaz referencia a um objeto String usa-se a seguinte linha de comando:String nome; Para que a variável faça referência a um objeto basta criar um objeto pormeio do operador new ou atribuir a referência de um objeto preexistente.nome = new String(“Pedro”);String x, y;x= nome;y = “Pedro”; No primeiro caso a variável nome faz referencia a um objeto recém criadocontendo o valor “Pedro”. Já a variável x faz referencia ao mesmo objetoreferenciado pela variável nome. Ou seja, nenhum novo objeto String é criado,ocorrendo um compartilhamento de objetos. Já a variável y faz referência a umobjeto String contendo o valor “Pedro”, distinto do objeto referenciado por x enome. Podemos também inicializar a variável durante a declaração.String nome = “Pedro”; Os objetos do tipo String possuem um conjunto extenso de métodos econstrutores para a manipulação e criação de Strings. A tabela abaixo mostraalguns dos mais utilizados.Construtor DescriçãoString(byte[] bytes, int offset, Constrói uma nova String convertendo o subarray deint num) bytes especificadoString(StringBuffer buffer) Constrói uma nova String usando a sequência de caracteres contida no StringBuffer.String(byte[] bytes) Constrói uma nova String convertendo o array de bytes especificadoString(String valor) Constrói uma nova String com o mesmo conteúdo da String passada como argumento.String() Constrói uma nova String contendo zero caracteres.String(char[] valor) Constrói uma nova String convertendo o array de caracteres especificado.String(char[] valor, int offset, Constrói uma nova String convertendo o subarray deint num) caracteres especificado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 40 Tabela III-8. Principais construtores da classe String.Método DescriçãocharAt(int indice) Retorna o caractere localizado no índice especificado.compareTo(String Compara duas Strings lexicograficamente.outraString)equals(Object anObject) Verifica se dois objetos são iguais.getChars(int srcBegin, Copia os caracteres da String em um array deint srcEnd, char[] dst, caracteres.int dstBegin)indexOf(String str) Retorna o índice da primeira ocorrência do substring no string.indexOf(String str, int Retorna o índice da primeira ocorrência do substringfromIndex) no string a partir do índice especificado.indexOf(int ch, int Retorna o índice da primeira ocorrência do caracterefromIndex) no string a partir do índice especificado.indexOf(int ch) Retorna o índice da primeira ocorrência do caractere no string .length() Retorna o comprimento do string.replace(char oldChar, Retorna uma nova String onde todos os caractereschar newChar) oldChar foram substituídos pelos caracteres newChar.substring(int beginIndex) Retorna uma nova string que é substring da atual.substring(int beginIndex, Retorna uma nova string que é substring da atual.int endIndex)toLowerCase() Converte para minúsculas.toUpperCase() Converte para Maiúsculas.trim() Remove os espaços em branco do inicio e do fim do String.valueOf(Object obj) Retorna a representação em String do argumento Object.valueOf(char c) Retorna a representação em String do argumento char.valueOf(boolean b) Retorna a representação em String do argumento booleano.valueOf(long l) Retorna a representação em String do argumento long.valueOf(int i) Retorna a representação em String do argumento int..valueOf(char[] data) Retorna a representação em String do argumento array de caracteresvalueOf(float f) Retorna a representação em String do argumento float.valueOf(double d) Retorna a representação em String do argumento double. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 41 Tabela III-9. Principais métodos da classe String. Os literais de Strings são tratados como instâncias da classe String ecomo tal possuem os métodos de um objeto da classe String. Por exemplo,após a execução da expressão abaixo a variável x conterá o valor 5.int x = “Pedro”.length();Conversão de Tipos De forma geral as conversões entre tipos em Java devem serespecificadas explicitamente. A forma mais comum de se especificar umaconversão é por meio da notação abaixo: (<tipo destino>) <expressão> Por exemplo: int i = 10; char c = (char) i; Este tipo de conversão é chamada de casting. O programador deve ficarbastante atento no que diz respeito a conversões, uma vez que pode acontecerperda de informação quando convertemos um tipo para outro que ocupa umespaço menor na memória. A tabela abaixo mostra as conversões entre tiposprimitivos que podem causar perda de informação: do tipo para o tipo byte char short byte, char char byte, short int byte, short, char long byte, short, char, int float byte, short, char, int, long double byte, short, char, int, long, float Tabela III-10. Conversão de tipos que podem causar perda de informação. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 42 Outra forma de converter tipos é usando os métodos fornecidos pelasclasses associadas aos tipos. A tabela abaixo mostra a classe associada a cadatipo primitivo. Tipo Classe int Integer float Float double Double boolean Boolean byte Byte short Short long Long Tabela III-11. Classes associadas a cada tipo primitivo. As classes fornecem métodos para conversão mais sofisticados como dotipo primitivo para String e vice-versa. Por exemplo, a classe Integerfornece um método para converter String para int:int i = Integer.parseInt(“12”); Para se converter um inteiro para String podemos utilizar o métodotoString():String s = Integer.toString(12); Existem métodos semelhantes nas outras classes. Existe também um tipode conversão que somente se aplica aos operandos do operador binário ‘+’quando um dos operandos é um objeto da classe String. Caso o outro operandonão seja um objeto da classe String, então ele será convertido para String e oresultado da operação será a concatenação das duas cadeias. As Conversõesentre objetos de classes distintas serão tratadas no próximo Capítulo.Operadores Os operadores atuam sobre valores e variáveis de modo a gerar novosvalores ou modificar os valores das variáveis. Os símbolos abaixo representamos 37 operadores da linguagem Java: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 43= > < ! ~ ? :== <= >= != && || ++ --+ - * / & | ^ % << >> >>>+= -= *= /= &= |= ^= %= <<= >>= >>>=Os operadores podem ser divididos nas seguintes classes.Unários Descrição Símbolo Incremento ++ Decremento -- Negativo - Complemento de bit ~ Tabela III-12. Operadores unários. Os operadores de incremento e decremento (++ e --) aumentam edecrementam variáveis de tipo inteiro de uma unidade. Estes operadores podemser usados na forma prefixa ou pósfixa. Na forma prefixa o operador modifica ovalor da variável antes que o valor seja usado na expressão onde está a variável.Na forma pósfixa o operador modifica o valor da variável depois que o valor éusado na expressão onde está a variável. Por exemplo, o valor das variáveis x,y e w após a execução do trecho de código abaixoint x = 1, y, w;y = x++;w = --x;é 1. Isto ocorre porque y recebe o valor de x antes de ser incrementado e wrecebe o valor de x depois de ser decrementado. O operador de negação unário (-) é usado para mudar o sinal de um valorinteiro. O operador de Complemento de bit (~) inverte cada bit da representaçãobinária de um inteiro. O exemplo abaixo mostra efeito da aplicação desteoperador.byte x = 10; // valor em binário 00001010 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 44x = ~x; // valor em binário 11110101; valor em decimal 245. O programa abaixo mostra o uso de cada operador unário. public class Unarios { public static void main (String args[]) { int x = 10, y = 0; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("++x = " + ++x); System.out.println("y++ = " + y++); System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("-x = " + -x); System.out.println("~y = " + ~y); } } Saída: x = 10 y = 0 ++x = 11 y++ = 0 x = 11 y = 1 -x = -11 ~y = -2 Exemplo III-2. Uso dos operadores unários.Binários Descrição Símbolo Adição e concatenação de strings + Subtração - Multiplicação * Divisão / Módulo % E de bit & OU de bit | OU exclusivo de bit ^ deslocamento de bits a esquerda << Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 45 deslocamento de bits a direita >> des. a direita com preenchimento zero >>> Tabela III-13. Operadores binários. Acreditamos que os operadores binários para adição, subtração,multiplicação, divisão e concatenação de Strings não necessitam maioresexplicações. O operador de módulo (%) retorna o resto da divisão entre doisoperandos inteiros. Por exemplo, o valor da variável x após a execução do trechode código int x = 7 % 4;é 3. Os operadores &, | e ^ implementam operações orientada para bits, ouseja, operações que atuam sobre os bits individuais dos operandos. São úteisquando se usa valores como campos de bits. O operador & realiza a operaçãológica E entre cada bit individual dos operandos. Por exemplo, o valor davariável x após a execução do trecho de código byte y = 3; y 00000011 byte x = Y & 5; 4 00000101 & 1 00000001é 1. O operador | realiza a operação lógica OU entre cada bit individual dosoperandos. Por exemplo, o valor da variável x após a execução do trecho decódigo byte y = 3; byte x = Y | 5; y 00000011 4 00000101 | 7 00000111é 7. O operador ^ realiza a operação lógica XOU (ou exclusivo) entre cada bitindividual dos operandos. Por exemplo, o valor da variável x após a execução dotrecho de código byte y = 3; y 00000011 byte x = Y & 5; 4 00000101 ^ 1 00000110é 6. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 46 Os operadores <<, >> e >>> implementam operações de deslocamento debits. Os bits do operando à esquerda serão deslocados o número de posiçõesespecificadas pelo operando à direita. Os bits que saem dos limites do campo sãoperdidos e a variável é preenchida com zeros no lado oposto ao deslocamento. Ooperador << realiza a operação de deslocamento de bits a esquerda. Porexemplo, o valor da variável x após a execução do trecho de código byte x = 7 << 1;é 14. Note que o deslocamento de uma unidade para a esquerda tem o mesmoefeito da multiplicação por 2, desde que nenhum bit seja. Os operadores >> e>>> realizam a operação de deslocamento de bits a direita. A diferença entre ooperador >> e o >>> é que o primeiro não desloca o bit de mais alta ordemusado para indicar números negativos. O programa abaixo ilustra o uso dessesoperadores: public class Deslocamento { public static void main (String args[]) { int x = 7, y =–7; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("x << 1= " + (x<<1)); System.out.println("x >> 2= " + (x>>2)); System.out.println("y >> 2= " + (y>>2)); System.out.println("y >>> 31= " + (y>>>31)); } } Saída: x = 7 y = -7 x <<= 14 x >> 2= 1 y >> 2= -2 y >>> 30= 3 Exemplo III-3. Uso dos operadores de deslocamento de bits. Note que no caso do número positivo o deslocamento à direita teve oefeito de uma divisão inteira por dois. Já quando o número é negativo este efeito Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 47não ocorre, devido ao fato da representação de números inteiros ser feita emcomplemento a dois.Relacionais Descrição Símbolo Menor que < Maior que > Menor igual <= Maior igual >= Igual == Diferente != Tabela III-14. Operadores relacionais. Os operadores relacionais são usados para comparar valores. O resultadoda aplicação desses operadores é um valore boolano, ou seja :true ou false. Oprograma abaixo ilustra o uso desses operadores: public class Relacional { public static void main (String args[]) { int x = 7, y = 8; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("x < y = " + (x < y)); System.out.println("x > 10 = " + (x > 10)); System.out.println("y <= 8 = " + (y <= 8)); System.out.println("y == 5 = " + (y == 5)); System.out.println("x != y = " + (x != y)); } } Saída: x = 7 y = 8 x < y = true x > 10 = false y <= 8 = true y == 5 = false x != y = true Exemplo III-4. Uso dos operadores relacionais. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 48Booleanos Descrição Símbolo E & OU | OU Exclusivo ^ E Curto circuito && OU Curto circuito || Negação ! Igualdade == Condicional ?: Tabela III-15. Operadores booleanos. Os operadores booleanos atuam sobre valores booleanos e retornam umvalor booleano. A tabela abaixo resume o resultado da aplicação dos operadoresbooleanos, exceto o operador condicional (?:) e o de negação (!): Operando 1 Operando 2 & | ^ && || == true true true true false true true true true false false true true false true false false true false true true false true false false false false false false false false true Tabela III-16. Resumo dos operadores booleanos. O operador de negação muda o valor booleano como mostrado na tabelaabaixo: Operando ! true false false true Tabela III-17. Operador de negação. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 49 O operador condicional atua sobre três operandos: uma expressãocondicional e duas outras expressões quaisquer. A forma geral do operador é <condição> ? <expressão 1> : <expressão 2>. Se <condição> for avaliada como true, então o resultado da aplicaçãodo operador condicional será o retorno da avaliação da <expressão 1>. Casocontrário o resultado da avaliação da <expressão 2> será retornado. Oprograma abaixo ilustra o uso deste operador: public class Condicional { public static void main (String args[]) { int x = 5; boolean par = (x % 2 == 0) ? true : false; System.out.println("x = " + x); System.out.println("É par = " + par); } } Saída: x = 5 É par = false Exemplo III-5. Uso do operador condicional.Atribuição Descrição Símbolo Simples = Adição += Subtração -= Multiplicação *= Divisão /= Modulo %= AND &= OR |= XOR ^= Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 50 Tabela III-18. Operadores de atribuição. Os operadores de atribuição simplesmente atribuem um valor a umavariável. Exceto o operador de atribuição simples (=), todos os outros operadoresna forma <variável> <op>= <expressão>funcionam como uma maneira abreviada de se escrever <variável> = <variável> <op>(<expressão>) Por exemplo, a atribuição x += 2;tem o mesmo significado da atribuição x = x +2; Esta forma de escrever facilita a trabalho de digitação, porém torna ocódigo fonte menos legível.Expressões e Precedência entre Operadores Expressões são trechos de códigos que geram valores. Portanto, o trechode código 1+2 é uma expressão pois gera o valor 3. Literais também sãoexpressões pois geram o próprio valor que representam. Portanto, o literal 3.14 étambém uma expressão. As variáveis que ocorrem em uma expressão sãotambém expressões, pois representam o valor que armazenam. As expressões são combinadas por meio dos operadores para formarexpressões maiores. Assim, podemos combinar as expressões 3 e 5*6 por meiode um operador tipo + para formar a expressão 3+5*6 Uma pergunta que pode surgir é: como a expressão é avaliada? Ou seja,que operador é aplicado primeiro: o + ou o *? Dependendo da ordem deaplicação dos operadores o resultado da avaliação da expressão pode serdiferente, como no caso acima. A ordem de aplicação obedece uma prioridade Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 51definida pela precedência relativa entre os operadores. A tabela abaixo define aprecedência entre os operadores. A precedência decresce de cima para baixo. Emse tratando de operadores com a mesma precedência a avaliação em umaexpressão é feita da esquerda para a direita. . [] () ++ -- ! ~ * / % + - << >> >>> < > <= >= == != & ^ && || ?: = Tabela III-19. Precedência de operadores.Comentários Comentar o código fonte faz parte das regras que definem um bom estilode programação. Java possui três diferentes formas de se comentar o código,ilustradas abaixo: // comentário de linha /* comentário de bloco */ /** comentário de bloco c/ propósito de documentação */ As duas primeiras formas de comentário são familiares para osprogramadores de C++. Na primeira forma, todos os caracteres posicionadosapós “//” e antes do final da linha são ignorados pelo compilador. Na segundaforma todos os caracteres que ocorrem após “/*” são ignorados pelocompilador, até que seja encontrado a sequência “*/”. A terceira forma decomentário é semelhante a segunda, com a diferença de que é usada pelaferramenta de documentação javadoc para gerar uma documentação no formatoHTML (HyperText Markup Language). O uso dessa ferramenta será tratado no Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 52final do próximo capítulo. O exemplo III-6 repete o código do exemplo III-5com a adição de alguns comentários: public class Condicional { // classe para teste do operador ?: public static void main (String args[]) { int x = 5; // variável usada para o teste /* Será impresso true se x for par */ boolean par = (x % 2 == 0) ? true : false; System.out.println("x = " + x); System.out.println("É par = " + par); } } Exemplo III-6. Uso de comentários.Blocos e Escopo Na linguagem Java, assim como em C/C++ um bloco de comandos édelimitado pelos caracteres ‘{’ e ‘}’. Os blocos são utilizados para agruparcomandos que são relacionados. Um bloco também pode conter blocos,chamados de blocos internos. Todas as variáveis declaradas em um bloco podemser referenciadas apenas dentro do bloco e nos blocos internos ao bloco onde foidefinida, desde que não exista nenhuma variável no bloco mais interno com omesmo nome. As seções onde uma determinada variável pode ser acessadadefinem a escopo da variável. A figura III-1 ilustra a relação entre blocos eescopo. public class Visivel { public static void main (String args[]){ int x = 5; } { int y = 2; escopo do x externo ... escopo de y { ... int x =2; } escopo do x interno } } ... } } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 53 Figura III-1. Visibilidade de variáveis.Estruturas de Controle As estruturas de controle definem a sequência de execução dasinstruções. Não é possível implementar um algoritmo que não seja trivial emuma linguagem de programação que não tenha um conjunto mínimo deestruturas de controle. As estruturas de controle podem ser divididas em seleção,repetição e sequência. A sequência é simplesmente definida pela execuçãosequencial dos comandos, de cima para baixo. Falta abordarmos as estruturaspertencentes às outras duas classes.Seleção Na seleção o fluxo sequencial de execução é desviado segundo umacondição ou valor. Java apresenta duas formas seleção: o if e o switch.if O comando de seleção de if possui duas formas básicas: if (condição) if (condição) comando1 comando1 else comando2 (a) (b) Na forma (a) o comando1 é executado se condição for avaliada comotrue. Na forma (b) o comando1 é executado se condição for avaliada comotrue senão o comando2 é executado. if (x==0) y = 5; else y+=6; Exemplo III-7. Comando if. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 54 Se o comando a ser executado for na verdade um conjunto de comandosdevemos então usar os delimitadores de bloco ‘{’ e ‘}’ para agrupar oscomandos em um único bloco. if (x==0) y = 5; else { y+=6; x++; } Exemplo III-8. Comando if executando um bloco. Os comandos if podem combinar em forma aninhada como mostrado noexemplo III-9. if (x==0) if (y == 1) x= y; else y+=6; Exemplo III-9. ifs aninhados. O aninhamento como no exemplo III-9 deixa uma dúvida com que if oelse está relacionado? Com o mais interno ou o mais externo? A regra paraesses casos é: o else se relaciona com o if mais interno. Essa regra pode seralterada, utilizando os delimitadores ‘{’ e ‘}’ para definir os blocos decomandos, como mostrado no exemplo III-10. if (x==0) { if (y == 1) x= y; } else y+=6; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 55 Exemplo III-10. Uso de blocos para definir o par if-else.switch O comando switch é útil quando existem várias ações distintas queprecisam ser realizadas em função do resultado da avaliação de uma expressão.Não é nada que não poderia ser feito com um conjunto de if-else, no entanto ouso do switch facilita codificação e a legibilidade do programa. A forma geraldo comando está definida abaixo: switch(Expr) { case const1: com1; ... case constN: comN; default: comDef } O comando switch avalia a expressão Expr e compara o valor resultantecom todas as constantes colocadas após a palavra a chave case. A comparação éfeita na ordem de cima para baixo e a primeira constante que igualar com o valorresultante da expressão faz com que os comandos após o ‘:’ sejam executadosaté o fim ou até que seja encontrado o comando break. A palavra chavedefault é opcional e ela serve como ponto de entrada para os comandos queserão executados caso o valor da expressão não seja igual a nenhuma dasconstantes. O exemplo III-11 ilustra o uso do comando switch. switch(letra) { case ‘i’: System.out.println(“inserir”); break; case ‘a’: System.out.println(“alterar”); break; case ‘e’: System.out.println(“excluir”); break; default: System.out.println( “Ação ignorada: ”+letra); } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 56 Exemplo III-11. Uso do comando switch. O comando break é muito importante na composição do switch. Ele fazcom que a execução sequencial dos comandos seja interrompida para serretomada no primeiro comando após o comando switch. O exemplo III-12mostra as saídas de um programa com um comando switch que não faz uso docomando break. Note que todos os comandos são executados, uma vez que nãoexiste um comando break para interromper a execução. public class Switch { public static void main (String args[]) { char letra = ‘i’; switch(letra) { case ‘i’: System.out.println(“inserir”); case ‘a’: System.out.println(“alterar”); case ‘e’: System.out.println(“excluir”); default: System.out.println( “Ação ignorada: ”+letra); } } } Saída: inserir alterar excluir Ação ignorada:i Exemplo III-12. Uso do comando switch sem break. O leitor pode se estar perguntando porque a sequência de comandos nãoé interrompida automaticamente em vez de deixar para o programador a tarefade sinalizar isso por meio do comando break. A verdade é que a omissão docomando break pode ser útil para poupar digitação naqueles casos onde mais deuma opção precisa executar a mesma sequência de comandos. O exemplo III-13mostra um desses casos. switch (mês) { case 1: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 57 case 3: case 5: case 7: case 8: case 10: case 12: dias = 31; break; case 4: case 6: case 9: case 11: dias = 30; break; case 2: if (((ano % 4==0) && !(ano % 100 == 0)) || (ano % 400 == 0) ) dias = 29; else dias = 28; break; } Exemplo III-13. Uso útil da omissão do comando break.Repetição Os comandos de repetição, ou de iteração, executam um comando ou umbloco de comandos várias vezes. É uma das formas para executar repetidamenteum comando. A outra é a recursão que é a chamada direta ou indireta de ummétodo durante a execução do próprio método. Em Java existem três formas decomandos de repetição: o while; o do-while; e o for.while A forma geral do comando while é:while(condição) Comando; O comando while executa Comando enquanto condição for avaliadacomo true. Portanto, para encerrar a iteração é necessário que exista apossibilidade da execução de Comando alterar a avaliação de condição. Acondição é testada antes da execução do comando. O exemplo III-14 mostra asoma dos 100 primeiros números inteiros. int i = 1; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 58 int x = 0; while(i<=100) x +=i++; Exemplo III-14. Soma dos 100 primeiros números inteiros. Se for necessário executar mais de um comando deve-se agrupá-los pormeio de delimitadores de bloco, como mostrado no exemplo III-15. while(i<=100) { x *=y; i++; } Exemplo III-15. - Uso de while com bloco.do-while A forma geral do comando do-while é:do Comando;while(condição) O comando do-while executa Comando enquanto condição foravaliada como true. A diferença em relação ao comando while é que acondição é testada após a execução do comando. O exemplo III-16 mostra asoma dos 100 primeiros números inteiros. Os comandos também podem seragrupados em um bloco. int i = 1; int x = 0; do x +=i++; while(i<100); Exemplo III-16. Soma dos 100 primeiros números inteiros com do-while. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 59for A forma geral do comando for é:for(Cod.Inicialização;condição; Cod.passo) Comando; No comando for o Cod.Inicialização (código de inicialização) éexecutado uma vez, a condição é avaliada antes de cada iteração e oComando e o Cod.passo é executado a cada iteração. O Cod.passo éexecutado após o Comando. Todas as seções do comando for podem seromitidas. Enquanto condição for avaliada como true é executada mais umaiteração. Em geral, o Cod.Inicialização é utilizado para inicializar avariável que será testada na condição e o Cod.passo é utilizado para alteraro valor da mesma. O exemplo III-17 mostra a soma dos 100 primeiros númerosinteiros. x = 0; for(int i=1; i<=100; i++) x +=i; Exemplo III-17. Soma dos 100 primeiros números inteiros com for. Tanto o Cod.Inicialização como o Cod.passo podem sercompostos de vários comandos. Cada comando é separado por ‘,’. O exemploIII-18 ilustra esta forma de uso do comando for. for(int i=1, x = 0; i<=100; i++) x +=i; Exemplo III-18. Soma dos 100 primeiros números inteiros com for. Como já foi dito, todas as seções do comando for podem ser omitidas. Oexemplo III-19 mostra uma iteração infinita, definida pela omissão das seções docomando for. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 60 for(;;) System.out.println(“ola mundo”); Exemplo III-19. Iteração infinita.break e continue Já vimos o uso do comando break quando discutimos o comandoswitch. Ele servia para interromper a sequência de execução dos comando e sairdo comando switch. Isto não acontece apenas no comando switch. Toda vezque um break é encontrado, o fluxo de execução “salta” para fora do bloco ondeestá contido o break, sendo retomado no comando após o bloco. A figura III-2ilustra este comportamento. for (;;) { ... break; ... } fluxo retomado aqui ... Figura III-2. Uso do comando break. O uso mais comum do comando break ocorre em uma condição de testedentro de uma iteração. O exemplo III-20 é equivalente ao exemplo III-18. for(int i=1, x = 0;; i++) if (i==101) break; else x +=i;Exemplo III-20. Soma dos 100 primeiros números inteiros com for e break. Já o comando continue é usado dentro de uma iteração e faz com queocorra um desvio para a condição de teste da iteração. Ou seja, o comandocontinue força um salto para próxima iteração. A figura III-3 ilustra estecomportamento. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 61 while (Condição) { ... fluxo retomado aqui continue; ... } ... Figura III-3. Uso do comando continue. Como no comando break, o uso mais comum do comando continue éem uma condição de teste dentro de uma iteração.Argumentos da linha de comando Os argumentos digitados na linha de comando são passados para ométodo main() da classe invocada por meio de um vetor de Strings. Porexemplo, se executarmos a linha de comando abaixo java teste um dois trêso método main() da classe teste receberá o seguinte vetor de Strings: [0] um [1] dois [2] três Figura III-4. Vetor com os argumentos da linha de comando. Para quem está acostumado a programar na linguagem C note o primeiroelemento do vetor não é o nome do programa e sim o primeiro argumento dalinha de comando. O espaço serve como separador de argumentos. Sedesejarmos tratar uma cadeia de caracteres com espaço como um únicoargumento é necessário delimitá-la com aspas duplas. Por exemplo, o comandoabaixo Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 62 java teste um “dois três”resulta no seguinte vetor: [0] um [1] dois três Figura III-5. Vetor com os argumentos da linha de comando com aspas. O classe do exemplo III-21 mostra um programa que imprime osargumentos recebidos, um em cada linha do dispositivo de saída. public class ImpLinha { public static void main(String args[]) { int i; for (i=0;i<args.length;i++) System.out.println(args[i]); } } Exemplo III-21. Imprimindo a linha de comando. Todos os argumentos são tratados como Strings. Se houver necessidadede tratar os argumentos como pertencendo a um tipo diferente será precisorealizar as conversões necessárias. No exemplo III-22 os argumentos sãoconvertidos para números inteiros para serem somados. public class Soma { public static void main(String a[]){ int i,soma=0; for (i=0;i<a.length;i++) soma += Integer.parseInt(a[i]); System.out.println(“A soma é:”+soma); } } Exemplo III-22. Imprimindo a soma dos números. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 63Assert (Assertivas) Com o surgimento da versão 1.4 do SDK uma nova alteração nalinguagem Java foi introduzida, envolvendo a inclusão de uma nova palavrareservada: a palavra assert. O objetivo desta alteração é incluir na linguagemrecursos que permitam que o programador verifique se uma dada condição,chamada de assertiva, é verdadeira em um local específico do código. Istopossibilita o desenvolvimento de códigos mais confiáveis, sendo um recursoutilizado durante a etapa de desenvolvimento e desabilitado em tempo deexecução. Devido a inclusão de uma nova palavra chave, códigos fontespreexistentes que incluam a palavra assert como identificador gerarão erro decompilação ao serem compilados com a versão 1.4 do SDK. Este problema decompatibilidade é solucionado por meio de flags de compilação. A linguagem C++ possui recurso semelhante, com a diferença de serimplementado por meio de biblioteca e não a nível de linguagem. No caso deJava, a decisão de não utilizar uma biblioteca para implementação deste recursodeveu-se ao objetivo de se buscar uma implementação mais transparente, apesardo inconveniente da perda de compatibilidade. A inclusão de recursos de para verificação de condições estava presentena especificação original da linguagem, quando ainda era denominada oak, maisfoi retirada da primeira versão por se acreditar que não haveria tempo para sedesenvolver uma implementação adequada.Sintaxe e semânticaA formato geral de uma assertiva é:assert<expressão booleana1>;ouassert<expressão booleana1>:<expressão booleana2>; A avaliação de uma assertiva funciona da seguinte forma: a primeiraexpressão é avaliada. Caso o resultado seja false e não exista uma segundaexpressão então a exceção AssertionError é lançada. Caso o resultado sejafalse e exista uma segunda expressão então ela é avaliada e o resultado épassado para o construtor da exceção AssertionError antes de ser lançada.Caso o resultado seja da primeira expressão seja true então a segunda expressão,caso exista, não será avaliada. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 64 O exemplo III-23 mostra um exemplo do uso de assertivas para garantirque uma determinada condição seja verdadeira. ... assert b > 0; int x = a/b; ... Exemplo III-23. Uso de assertivas.Habilitando e Desabilitando Assertivas As assertivas podem ser habilitadas/desabilitadas por flags na linha decomando e chamadas a métodos durante a execução. A habilitação/desabilitaçãopode ter uma atuação que varia desde o envolvimento de uma única classe atéum pacote ou todo o programa. Por default as assertivas estão desabilitadas.Habilitação por flags A forma geral para a habilitação de assertivas é: java [-enableassertions | -ea] [:<nome package>“...” |:<nome classe>] O flag sem argumento habilita as assertivas para todas as classes. Se forseguindo por o nome de um pacote seguido por “...” as assertivas serãohabilitadas para o pacote especificado e todos os subpacotes. Se for seguidoapenas de “...”as assertivas serão habilitadas para o pacote do diretório corrente etodos os subpacotes. Se o argumento não terminar com “...”, então as assertivasserão habilitadas apenas para a classe especificada. Abaixo segue um exemplode habilitação de assertivas: java –ea:br.ufv.dpi.apo... Teste A desabilitação de assertivas segue a mesma lógica, mudando apenas oflag que passa ser –disableassertions ou –da. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 65Habilitação por métodos Os seguintes métodos da classe ClassLoader podem ser invocados parahabilitar/desabilitar as assertivas em tempo de execução:void setDefaultAssertionStatus(boolean status)– habilita/desabilita por default as assertivas.void setPackageAssertionStatus(String nomepack, boolean status)– habilita/desabilita as assertivas no pacote e subpacotes.void setClassAssertionStatus(String nomeclasse, boolean status)– habilita/desabilita as assertivas na classe.void clearAssertionStatus()– retorna ao default. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 66Capítulo IV Classes, Pac k ages eInterfaces A unidade fundamental de programação em Java é a Classe. Não épossível fazer um programa em Java que não tenha pelo menos uma classe. Issonão é verdade para todas as linguagens Orientadas a Objeto. Em C++, porexemplo, é possível fazer um programa que não use classe. Em Java todas asvariáveis e métodos de um programa Java devem ser definidos dentro de umaclasse. Um programa que não contenha classes não é um programa orientado aobjetos. No entanto, o fato de um programa conter classes também não o tornamerecedor do título de “orientado a objetos”. A programação orientada a objetosé mais um estilo de programação do que um conjunto de palavras-chavecolocadas em um programa. Porém, é obviamente melhor implementar esteestilo usando uma linguagem que oferece suporte a ele. Neste capítuloestudaremos o suporte oferecido por Java a este estilo de programação. Não só aimplementação de classes será vista, como também conceitos relacionados,como pacotes e interfaces.Classes No Capítulo II foram discutidas Classes e Objetos do ponto de vista demodelagem e de implementação. Nesta seção será detalhada a implementação declasses em Java. A definição de uma classe em Java obedece a seguinte formageral:[public] class <Identificador>{ <corpo da classe>} A palavra reservada public é opcional e indica que a classe pode serreferenciada por qualquer outra classe além do próprio pacote (conceito que serávisto mais adiante). Apenas uma classe por arquivo pode ser precedida pelapalavra reservada public e o nome do arquivo tem que ser idêntico ao nomedesta classe. Se a declaração da classe não for precedida de public, então ela sópoderá ser referenciada por outras classes do mesmo pacote. Os modificadores Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 67de acesso private e protected não podem ser aplicados às classes. O<Identificador> é usado para referenciar a classe. No <corpo da classe>são definidos os atributos e métodos da classe. Na comunidade deprogramadores Java existe a convenção de associar às classes identificadoresque iniciem com letra maiúscula, enquanto que os identificadores de variáveis emétodos devem iniciar com letra minúscula. No exemplo IV-1 é mostrada adefinição da classe de uma classe com o identificador Pessoa. Nele foi definidoum construtor para atribuir valores aos atributos e definido os métodos paraacesso aos atributos. Note que os métodos que atribuem valores às variáveis daclasse iniciam com a palavra set e os métodos que retornam os valoresarmazenados nas variáveis da classe iniciam com a palavra get. Este padrão denomeação de método foi adotado a partir da versão 1.1 da linguagem e é muitoimportante seguí-lo, principalmente se pretendemos implementar JavaBeans,como será visto no Capítulo X. public class Pessoa { String nome; String telefone; String endereço; public Pessoa(String n, String t, String e) { nome = n; telefone = t; endereço = e; } public void setNome(String n) { nome=n; } public void setTelefone(String t) { telefone = t; } public void setEndereço(String e) { endereço = e; } public String getNome() { return nome; } public String getTelefone() { return telefone; } public String getEndereço() { return endereço; } } Exemplo IV-1. Definição da classe Pessoa. Unidade de Compilação Cada arquivo fonte Java é uma unidade de compilação. Ao compilar o arquivo fonte ocompilador irá gerar um arquivo .class para cada classe constante no arquivo. O nome decada arquivo será o nome da cada classe. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 68 Os atributos ou variáveis declarados na classe são criados somentequando os objetos são criados. Ou seja, cada objeto da classe Pessoa terá a suavariável nome, telefone e endereço. Portanto, a variável pertence à instânciada classe e não à classe. Variáveis que pertencem ao objeto são chamadasvariáveis de instância. Com os métodos o raciocínio é o mesmo, ou seja, parapodermos usar o método getNome() é preciso criar um objeto da classe Pessoae usar o método getNome() deste objeto. Métodos que pertencem ao objeto sãochamados de métodos de instância. Como veremos mais adiante, podemos usar apalavra reservada static para declarar variáveis e métodos que pertencem àclasse (métodos e variáveis de classe). Os métodos definem operações sobre os atributos. Eles possuem a formageral: <modificador> <tipo> <identificador>(<parâmetros>) { <corpo do método> }onde <modificador> é um modificador de acesso, <tipo> é o tipo do valor deretorno do método, <identificador> é o identificador do método e<parâmetros> é uma lista de parâmetros. O corpo do método é composto decomandos, expressões e declarações de variáveis locais ao método. Os métodosdo exemplo IV.1 são muito simples. Eles apenas retornam um valor ou atribuemum valor aos atributos do objeto.Construtores Podemos observar no exemplo IV-1 que existe um método público com omesmo nome da classe e que não define um valor de retorno. Métodos comoesse são denominados de construtores e são chamados pelo operador new. Umaclasse pode não ter construtor ou ter vários, desde que tenham diferentes tipos deargumentos. O interpretador decidirá qual chamar a partir dos argumentospassados para o construtor. Se o programador não declarar nenhum construtorentão o compilador irá criar automaticamente um construtor default para aclasse.Valor de Retorno Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 69 Com exceção dos construtores todos os outros métodos precisam retornaralgum valor. Se programador não precisa que o método retorne algum valor,então ele deve especificar que o método irá retornar o valor void que é o valorvazio. Se o método não foi definido com valor de retorno void e não é umconstrutor então é preciso que no corpo do método seja indicado o valor deretorno. Esta indicação deve ser feita em toda ramificação de código que leve aofim da execução do método e é feita com a palavra chave return seguida deuma expressão: return <expressão> A expressão pode ser uma variável, um literal ou qualquer outraexpressão que gere um valor do tipo especificado para o retorno da função. Oexemplo IV-2 mostra um método que retorna um inteiro. Note que todaramificação de código que leve ao fim da execução do método necessita de umcomando return. public class ExemploIV2 { ... public int calc(int a) { if (a==0) return 1; else return a*a; } } Exemplo IV-2. Método que retorna um inteiro.Objetos Para se criar um objeto de uma classe (ou uma instância da classe) épreciso primeiro declarar uma variável que irá referenciar o objeto, para depoiscriar o objeto. A declaração de um referência a um objeto é feita obedecendo aseguinte forma geral: <nome da classe> <identificador>; Por exemplo, para declarar uma referência à um objeto da classe Pessoadevemos adicionar a seguinte linha ao código. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 70 Pessoa p1; Pode-se declarar mais de uma referência a objetos de uma classe em umaúnica declaração, separando os identificadores por vírgula. Pessoa p1, p2; Para criar um objeto usa-se o operador new conforme a forma geralabaixo: <identificador> = <nome da classe>(<argumentos>);onde <argumentos> é uma lista de argumentos que serão passados para ummétodo especial da classe, denominado de construtor. Por exemplo, para criarum objeto do tipo Pessoa podemos usar a declaração abaixo: P1 = new Pessoa(“Ana”,”432-6969”,”Rua 17 134”); Podemos também combinar a declaração da referência com a criação doobjeto em uma única linha de código. Pessoa P1 = new Pessoa(“Ana”,”432-6969”,”Rua 17 134”); Uma vez criado o objeto podemos acessar os elementos do objeto pormeio da referência ao objeto e do operador ‘.’. Por exemplo para acessar ométodo getNome() do objeto referenciado pela variável P1 devemos usar oseguinte código: P1.getNome(); Para acessar um atributo diretamente a sintaxe é mesma. Por exemplo,para acessar o atributo nome diretamente basta usar a seguinte linha de código. P1.nome; O exemplo IV-3 mostra a criação de um objeto do tipo Pessoa e o acessoa seus membros. Para que a classe seja executável diretamente pela máquinavirtual é preciso que ela possua um método main() que servirá como ponto deentrada para a execução. Podemos então, inserir código no método main() paracriar uma instância da classe para que, a partir de então, possamos a acessar os Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 71membros do objeto. O método main() existe antes da criação da instância, eportanto pode ser acessado pela máquina virtual, porque foi declarado com omodificador static. Isto significa que o método pertence à classe (método declasse) e não ao objeto (método de instância). public class Pessoa { ... // igual ao exemplo IV.1 ... public static void main(String args[]) { Pessoa p; p = new Pessoa(“Ana”,”432-6969”,”Rua 17 134”); // Acessa os dados via métodos System.out.println(“Nome:”+getNome()); System.out.println(“Telefone:”+ getTelefone()); System.out.println(“Endereço:”+ getEndereço()); // Altera o endereço setEndereço(”Rua 17 138”) // Acessa os atributos diretamente System.out.println(“Endereço:”+ endereço); } } Exemplo IV-3. Definição da classe Pessoa. As implementações da classe Pessoa mostradas nos exemplos IV-1 eIV-3 possuem alguns problemas que iremos abordar gradativamente. O primeiroproblema está relacionado com o acesso direto aos atributos. Em um programabem projetado o acesso aos atributos da classe a partir de métodos definidos emoutras classe é restringido de modo a diminuir a dependência em relação àrepresentação interna de uma classe. Quanto maior for esta independência maioré a facilidade para manutenção do programa. Para se restringir o acesso aosmembros da classe deve-se preceder a declaração dos membros com palavrasreservadas denominadas de modificadores de acesso que serão descritos a seguir. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 72Modificadores de acesso Os modificadores de acesso tem por objetivo definir a visibilidade de ummembro de uma classe (atributo ou método) em relação à outras classes. Atabela IV-1 mostra os modificadores de acesso disponíveis em Java. Modificador Descrição default Somente classes do mesmo package possuem acesso public Todos possuem acesso protected Apenas os membros da classe e subclasse private Apenas os membros da classe Tabela IV-1. Modificadores de acesso. Quando não é especificado nenhum modificador de acesso é assumido omodificador default, também chamado de friend. Ou seja, não existe umapalavra reservada default. O acesso default determina que todas as classesdentro do mesmo package (pacote) podem acessar os membros da classecorrente. O conceito de package será detalhado mais adiante, no entantopodemos adiantar que um package é um agrupamento de classes e interface(também será vista mais adiante). Toda classe e interface pertence a umpackage, mesmo que o programador não indique o package explicitamente. Se oprogramador não indicar o package então será assumido que a classe ouinterface pertence ao package default. O modificador public determina que todas as classes podem acessar omembro. Já o modificador protected limita o acesso ao membro apenas aosmembros da própria classe e aos membros das subclasses da classe. Finalmente,o modificador private limita o acesso ao membro apenas aos membros daprópria classe. O exemplo IV-4 é uma redefinição da classe Pessoa, explicitando osmodificadores de acesso dos atributos com objetivo de limitar a visibilidade dosmesmos. public class Pessoa { protected String nome; protected String telefone; protected String endereço; ... Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 73 // igual ao exemplo IV.1 ... } Exemplo IV-4. Definição da classe Pessoa com os atributos protegidos. O modificador de acesso usado para os atributos no exemplo IV-4 foi oprotected. Portanto, se for criada uma subclasse da classe Pessoa, esta poderáacessar diretamente os atributos da classe Pessoa. O exemplo IV-5 mostra adefinição da classe Funcionario como subclasse de Pessoa. Note que oatributo de instância salario da classe Funcionario é definido com omodificador de acesso private, impedindo, dessa forma, acessos diretos aoatributo a não ser por membros da própria classe. Note também que o construtorda classe Funcionario possui uma chamada a um método super. Esta chamadarepresenta, na verdade, uma chamada ao construtor da superclasse. Isto serávisto com maiores detalhes mais adiante. public class Funcionario extends Pessoa { private double salario; public Funcionario(String n, String t, String e, double s) { super(n,t,e); salario = s; } public void setSalario(double s) { salario = s; } public double getSalario() { return salario; } } Exemplo IV-5. Definição da classe Funcionario. Para utilizar a classe Funcionario pode-se criar uma terceira classe,como mostra o exemplo IV-6, com o um método main() que serve de ponto deentrada para o início da execução. Foi colocado propositadamente uma tentativade acesso ao atributo privado por um método externo à classe do atributo, demodo a ilustrar um acesso não permitido. public class TesteFun { public static void main(String a[]) { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 74 Funcionario f; f = new Funcionario(“Carlos”,”555-7777”, “Av Nova 32”,3000.0); System.out.println(“Nome:”+f.getNome()); // Acesso Ilegal. Use o método. System.out.println(“Salario:”+f.salario); } } Exemplo IV-6. Utilizando a classe Funcionario.Outros Modificadores Além dos modificadores de acesso existem outros modificadores queestabelecem significados distintos da visibilidade. A tabela IV-2 exibe osmodificadores adicionais. Modificador Descrição static A variável ou método é comum a todas as instâncias da classe. final O valor da variável não pode ser modificado. synchronized atribui o monitor do objeto ao thread corrente. native indica que se trata de um método nativos. Tabela IV.2– Modificadores de adicionais.O modificador static Um atributo declarado com o modificador static significa que é umatributo da classe e não de instância. Em outras palavras, existirá apenas umatributo, ocupando uma única posição de memória, em vez de um atributo paracada instância, cada um com sua própria posição de memória. Como resultado, oatributo existirá antes mesmo que qualquer objeto seja criado e, se for público,poderá ser acessado prefixando-o com o nome da classe e o operador “.”. Oexemplo V-7 mostra uma classe com um atributo static. Note que o não épreciso declarar uma instância da classe X para que o atributo exista e paraacessá-lo basta prefixá-lo como nome da classe. class X { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 75 static public int tot =0; } public class Main { public static void main(String a[]) { X.tot = 2; System.out.println(“Valor de tot:”+X.tot); } } Exemplo IV-7. Classe com atributo static. Outro efeito é que o atributo será compartilhado por todas as instânciasda classe. Desta forma, se um objeto alterar o conteúdo do atributo, a alteraçãoafetará todos os outros objetos da classe. O exemplo V-8 mostra a declaração dedois objetos da classe X. Um dos objetos altera o valor do atributo static e ooutro imprime o valor do atributo. Isto mostra que as alterações feitas por umobjeto no atributo é percebida por todos os outros objetos da classe. class X { static public int tot =0; public void inc() {tot++;} } public class Main { public static void main(String a[]) { X x1, x2; x1 = new X(); x2 = new X(); // x1 modifica o valor x1.inc(); System.out.println(“Valor de tot:”+x2.tot); } } Saída: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 76 Valor de tot:1 Exemplo IV-8. Objetos com atributo static. O modificador static também pode ser usado na declaração demétodos. Neste caso o método fica ligado à classe e não à instância, sendodenominado de método de classe. Como consequência o método pode seracessado antes de existir um objeto da classe. Vários exemplos mostrados nestelivro tem pelo menos um método static: o método main(). Ele serve comoponto de entrada para a execução da aplicação Java, uma vez que inicialmentenão existem objetos. Os métodos static não podem acessar atributos e outrosmétodos não estáticos da classe, a não ser que exista uma declaração de umobjeto da classe no corpo do método. Os métodos estáticos são muito usados emclasses utilitárias. Classes utilitárias são classes que servem para agruparmétodos que prestam algum tipo de serviço a outras classes. Por exemplo, ométodo exit() é um método estático da classe System. Ele serve para encerrara execução da máquina virtual corrente. Sendo um método estático não é precisocriar um objeto da classe System para acessá-lo. A classe System é uma classeutilitária, contendo vários métodos e atributos estáticos úteis para outras classes.O Modificador final O modificador final pode ser usado em atributos, métodos e classes. Omodificador final impede se modifique o que está sendo prefixado. Um atributoprefixado com final indica que uma vez definido seu valor ele não seráalterado. Ou seja, é uma constante. A definição do valor do atributo pode serfeito tanto na declaração como durante a execução do programa, sendo que estaúltima possibilidade não era permitida na versão 1.0 da linguagem Java. Oexemplo IV-9 mostra o uso do modificador final em atributos. class X { public int k =0; } public class Main1 { public final int i = 1; public final int j; public final X x = new X(); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 77 public Main1(){j = 2;} public static void main(String a[]) { Main1 m = new Main1(); m.x.k= 3; // Erro : o atriuto não pode ser modificado // m.j = 4; System.out.println("Valor de k:"+ m.x.k); System.out.println("Valor de j:"+ m.j); System.out.println("Valor de i:"+ m.i); } } Exemplo IV-9. Uso do modificador final em atributos. Note que no exemplo IV-9 o atributo j é inicializado no construtor e nãona declaração. No exemplo o atributo k do objeto referenciado pelo atributo x émodificado, mesmo sendo x um atributo final. Isto ocorre porque x é umareferencia a um objeto e não o próprio objeto, portanto, no caso de referencias aobjeto, o modificador final implica que o atributo não pode referenciar outroobjeto, mas não significa que o objeto referenciado não possa ser modificado. Um método declarado com o modificador com final não pode sersobrescrito em uma subclasse. Alguns compiladores podem aproveitar isso everificar se é possível definir as chamadas a esses métodos como inline. Naschamadas inline o compilador substitui a chamada ao método pelo o código dométodo, tornando mais eficiente a execução do programa. O exemplo IV-10mostra o uso do modificador final em um método. class X { public int k =0; public final void mostra() { System.out.println("Valor de k:"+ k); } } class SX extends X { // Erro: Sobrescrita ilegal public void mostra() { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 78 System.out.println("k:"+ k); } } Exemplo IV-10. Uso do modificador final em métodos. Uma classe declarada com o modificador com final impede que sejamcriadas subclasses desta classe. O programador pode decidir fazer isso porrazões de projeto ou de segurança, já que neste caso ele terá certeza que afuncionalidade da classe não será alterada. Outra razão pode ser eficiência, umavez que os métodos de uma classe final também são final, e portanto podemser otimizados para serem tratados como inline.Os Modificadores synchronized e native O modificador synchronized é para controlar o acesso a áreas críticasno processamento concorrente em Java. É usado em métodos e blocos decomandos, e seu uso será discutido em detalhes no Capítulo XI. O modificador native é usado em métodos para indicar que o métodofoi implementado em outra linguagem de programação. O programador deveapenas indicar a assinatura do método, como mostrado abaixo: native int meuMetodo(int a); O uso de chamadas nativas restringe a portabilidade do programa. Nomomento a linguagem Java só suporta chamadas nativas implementadas nalinguagem C/C++.Referências Compartilhadas Um outro problema das implementações da classe Pessoa mostradas nosexemplos IV-1 e IV-3 está relacionado com o compartilhamento de referências.No construtor, assim como nos métodos setXXX, o argumento é atribuídodiretamente às variáveis de instância. Como toda variável de objeto em Java é naverdade uma referência para o objeto então as variáveis de instância da classePessoa e os argumentos do construtor e dos métodos setXXX são referências aobjetos do tipo String. Portanto, ao atribuir diretamente o argumento àsvariáveis de instância geramos um compartilhamento de referências. Essasituação é melhor ilustrada graficamente, como pode ser visto na figura IV-1, Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 79onde é mostrado o compartilhamento entre o argumento n e a variável deinstância nome após a atribuição. O problema do compartilhamento de referências, é que ele permiteacesso aos objetos referenciados internamente pelos objetos. Com isso é possívelmodificar, com métodos externos ao objeto, o objeto referenciado. No entanto,no caso particular dos objetos da classe String, isso não chega a ser umproblema. Strings são constantes, ou seja, seus valores não podem ser alteradosapós a sua criação e, portanto, objetos Strings podem ser compartilhados semriscos. Toda alteração em um objeto do tipo String retorna um novo objetoString, deixando a original inalterada. Antes da atribuição n Objeto nome null Após a atribuição n Objeto nome Figura IV-1.Compartilhamento de referencias. Se o programador desejar alterar o valor de uma cadeia de caracteres semcriar um novo objeto, então ele deve optar por utilizar a classe StringBufferque implementa uma sequência mutável de caracteres. No entanto, é precisoestar alerta para o problema de compartilhamento de referências. O trecho decódigo do exemplo IV-11 mostra uma ocorrência de compartilhamento dereferência. No exemplo a classe Pessoa é definida usando a classeStringBuffer para armazenar as sequências de caracteres. Os objetos da classeX possuem uma referência a um objeto do tipo Pessoa. Na construção do objetoPessoa são passados como parâmetros as referências dos objetos StringBufferdo objeto da classe X, gerando um compartilhamento de referencias. Quando éinvocado o método m1() do objeto da classe X, este concatena a sequência “fim”ao StringBuffer referenciado por n. Como n compartilha o mesmo objeto coma variável de instância nome do objeto Pessoa, então a alteração também afeta oobjeto Pessoa, ocasionando um efeito colateral, provavelmente indesejável. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 80 Para se evitar esta situação é necessário que o objeto crie uma cópia doobjeto que está recebendo e retorne uma cópia do objeto que referencia. No casode objetos do tipo StringBuffer basta construir um novo objeto, passandocomo parâmetro a String correspondente ao StringBuffer anterior, comomostrado abaixo: nome = new StringBuffer(n.toString()); No entanto, no caso de objetos mais complexos é mais complicado criaruma cópia por meio do construtor. Neste caso é necessário criar uma cópiausando o método clone(). Este método será visto na próxima seção. class Pessoa { StringBuffer nome; StringBuffer telefone; StringBuffer endereço; public Pessoa(StringBuffer n, StringBuffer t, StringBuffer e) { nome = n; telefone = t; endereço = e; } // O restante da da classe é semelhante ao exemplo VI.1 // ... } public class X { StringBuffer n = new StringBuffer("Pedro"); StringBuffer t = new StringBuffer("324-6789"); StringBuffer e = new StringBuffer("Rua 17/148 Natal"); Pessoa p; public X() {p = new Pessoa(n,t,e);} public void m1() { n.append("fim");} public static void main(String a[]) { X x = new X(); x.m1(); System.out.println(x.p.nome); } } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 81 Exemplo IV-11. Exemplo de compartilhamento de referência.Copiando Objetos Como visto na seção anterior, a atribuição envolvendo duas referencias aobjetos acarreta um compartilhamento do objeto e não uma cópia do objetooriginal. No entanto, em algumas situações não queremos compartilhar umobjeto e sim criar uma cópia de um objeto que já existe, ou seja um clone.Existem dois tipos de modos de se clonar um objeto: 1- Cópia rasa (shallow copy) - neste caso os atributos do objeto resultante recebem os valores dos atributos correspondentes no objeto original. Os objetos referenciados pelo objeto original serão compartilhados pelo objeto resultante. A figura IV-2 ilustra este tipo de cópia. Note o compartilhamento das referencias. Figura IV-2.Cópia rasa entre os objetos A e D. 2- Cópia profunda (deep copy) - neste caso não só o objeto original é copiado como também todos os objetos por ele referenciados. Este tipo de cópia pode ser bastante ineficiente. A figura IV-3 ilustra este tipo de cópia. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 82 Figura IV-3.Cópia profunda entre os objetos A e D. Java oferece suporte para a cópia rasa. Para que a classe esteja apta a serclonada é preciso que ela implemente a interface Cloneable (interfaces serãodiscutidas mais adiante).O objeto this Em algumas situações é necessário referenciar o próprio objeto corrente.Por essa razão todo objeto possui uma variável especial identificada por thisque contém uma referência para o próprio objeto. O exemplo IV.xx mostra umuso típico do atributo this. Ele mostra um método cujo parâmetro formal possuio mesmo nome de um atributo de instância. Para distinguí-los é necessárioqualificar o atributo da instância com o atributo this. public class objetoGeo { protected Color cor; protected int x, y; public objetoGeo(Color cor, int x, int y) { this.cor = cor; this.x=x; this.y = y; } public Color retCor() {return cor}; } Exemplo IV-12. Exemplo de uso do atributo this. Outro uso típico e quando queremos passar a instância corrente comoargumento de um método. Como mostra o exemplo IV.xx. class X { ... Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 83 public void mx(Y y) { ...; } } class Y { X x; public void my() { x.mx(this); ... } } Exemplo IV-13. Exemplo de uso do atributo this como argumento. No exemplo IV.xx o objeto da classe Y passa ele próprio comoargumento do método mx() do objeto da classe X.Packages Pacotes (Packages) é a solução proposta por Java para agrupar Classes eInterfaces relacionadas para compor bibliotecas. As Interfaces serão vistas maisadiante. Organizando as classes em pacotes evita a colisão entre os nomes dasclasses. No caso dos métodos isso não é necessário, pois métodos como omesmo nome em classes diferentes são facilmente distinguidos uma vez que sãoqualificados pelos objetos das classes. No entanto como distinguir classes com omesmo nome? Esse problema é muito comum, principalmente quando setrabalha em equipe. Como impedir que um programador trabalhando no mesmoprojeto crie uma classe com o mesmo nome que outra criada por outroprogramador? Na hora de unir as classes os sistema não irá compilar devido aoproblema de redeclaração de classes. Sendo Java uma linguagem para atuar naInternet o problema é ainda mais grave: como impedir que uma classe que foibaixada de outra máquina não possua o mesmo nome de uma classe. Paracontornar todos estes problemas foi criado os Pacotes.Usando Packages Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 84 Toda classe pertence a um pacote. No caso de o programador não indicara que pacote pertence a classe, o compilador irá assumir que a classe pertence aopacote default. Para se usar uma classe definida em outro package é preciso usara palavra chave import seguida do nome da classe qualificada pelo nome dopacote como mostra a forma geral abaixo: import nome_Package.nomeClasse; Por exemplo para importar a classe Color do pacote java.awt oprogramador deverá usar a diretiva abaixo: import java.awt.Color; Se o programador quiser importar todas as classes do pacote java.awtbasta usar o caractere ´*` no lugar do nome da classe: import java.awt.*; É possível usar uma classe declarada em outro pacote sem usar a palavrachave import. Nesse caso é necessário qualificar o nome da classe com onome do pacote toda vez que a classe for referenciada. Por exemplo, no caso daclasse Color seria necessário qualificá-la da seguinte forma: java.awt.Color Existem dois pacotes que não precisam ser importados para que possamser usadas as suas classes sem a qualificação: o pacote default e o pacotejava.lang. O pacote default agrupa todas a classes que estão no diretóriocorrente e o pacote java.lang agrupa as classes do núcleo básico dalinguagem.Criando Packages Para incluir uma unidade compilação em um pacote basta que oprogramador inclua a seguinte declaração no arquivo. package nomepacote; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 85 Importante: a declaração acima precisa ser a primeira declaração noarquivo. O nome do pacote pode ser composto por vários nomes separados pelocaractere ‘.’, como no caso do pacote java.awt. As classes de um determinado pacote devem ser colocadas em umdiretório obedecendo a mesma estrutura do nome do pacote, a partir de algumdiretório constando na variável de ambiente classpath. A variável deambiente classpath indica os diretórios que servem como pontos de entradapara procura de classes pela máquina virtual. Por exemplo, suponha que eu resolva colocar as classes sobre objetosgeométricos em um determinado pacote, digamos br.com.alcione.geo.Para indicar que unidade de compilação pertence a esse pacote devemos colocara diretiva adequada no início do arquivo fonte, como mostrado no exemploIV.xx. package br.com.alcione.geo; public class objetoGeo { protected Color cor; protected int x, y; public objetoGeo(Color cor, int x, int y) { this.cor = cor; this.x=x; this.y = y; }; public Color retCor() {return cor}; } Exemplo IV-14. Indicando que uma classe pertence ao pacote br.com.alcione.geo. Para que a máquina virtual consiga achar o pacote devemos colocá-lo emdiretório com a mesma estrutura do nome do pacote e que tenha como raizalgum diretório constante na variável de ambiente classpath. Por exemplo,suponha que a variável classpath contenha os seguintes diretórios: CLASSPATH=.;C:JAVALIB;C:meujavalibentão o arquivo objetoGeo.class resultante da compilação do arquivoobjetoGeo.java pode ser colocado no diretório: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 86 C:meujavalibbrcomalcionegeo Note que a estrutura do diretório combina com a estrutura do nome dopacote. Para usar a classe em outra unidade de compilação basta incluir aseguinte diretiva no arquivo fonte: import br.com.alcione.geo.*; O formato do nome do pacote não foi escolhido por acaso. Se existe apretensão de usá-lo na Internet então deve-se adotar um nome que seja único narede. Para garantir esta unicidade utiliza-se o nome do domínio do criador dopacote com a ordem dos campos invertida, evitando assim a colisão de nome naInternet. Por exemplo, nome do pacote br.com.alcione.geo origina-se dainversão do nome do meu domínio (alcione.dpi.ufv.br) concatenado com onome geo. Por simplicidade. na maioria dos exemplos adotados neste livro,adotaremos o pacote default.O Mecanismo de Extensão A partir da versão 1.2 a linguagem Java apresentou um mecanismo paraadicionar classes ao núcleo básico da linguagem, dispensando deste modo o usoda variável de ambiente classpath. Este mecanismo é chamado deMecanismo de Extensão. O mecanismo de extensão também oferece suportepara envio de classes pela rede para uso em Applets. As extensões são agrupadasem arquivos JAR que são abordados no capítulo que trata dos Applets. Uma vezfeito isso, pode-se transformar as classes em extensões utilizando uma das duasformas: 1. Extensão Instalada – colocando o arquivo JAR em um local predeterminado na estrutura de diretórios do ambiente de tempo de execução de Java (Java Runtime Environment ou JRE). 2. Extensão de download –Extensão referenciando o arquivo JAR de uma forma específica, a partir do manifesto de outro arquivo JAR.Extensão Instalada Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 87 Para incluir uma nova classe ou pacote no núcleo básico da linguagembasta colocar o arquivo JAR onde que contém a classe no diretório /lib/extdo ambiente de tempo de execução. O diagrama mostrado na figura IV.xxmostra a localização deste diretório dentro da estrutura de diretórios do ambienteJava. Java 1.3 bin lib jre include bin lib audio cmm fonts ext images security Figura IV.xx- localização do diretório ext dentro da estrutura de diretórios Java. Por exemplo, suponha que desejamos acrescentar o pacote do exemploIX. às extensões da linguagem Java no ambiente local. Para isso devemos criarprimeiro o arquivo JAR. No ambiente DOS o comando seria o abaixo, executadono diretório acima do diretório /br: jar cvf geo.jar brcomalcionegeoobjetoGeo.class Após isso colocaríamos o arquivo geo.jar dentro do diretório /ext.Para usar a classe o procedimento é idêntico ao uso no caso do classpath, ouseja basta colocar a seguinte diretiva no arquivo fonte: import br.com.alcione.geo.*;Extensão de Download As extensões de download ocorrem quando arquivos JAR ou classes sãoindicados como extensões de outros arquivos JAR. Por exemplo, suponha que Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 88existem dois arquivos JAR, x.jar e y.jar, localizados no mesmo diretório.Para tornar o arquivo y.jar uma extensão do arquivo y.jar basta colocar aseguinte informação no manifesto do arquivo x.jar: Class-Path: y.jar Deste modo toda classe no arquivo x.jar pode referenciar as classes dopacote y.jar. Se os arquivos não estiverem no mesmo diretório seránecessário indicar o caminho relativo até o arquivo da extensão. É possívelindicar várias extensões, separando-as por espaço ou usando várias diretivasClass-Path. Para indicar um diretório como extensão basta adicionar osufixo ‘/’ no ao nome do diretório. Por exemplo: Class-Path: meudir/Derivando classes O reuso de componentes de programas tem sido uma das principais metasdos projetistas de linguagens de programação. A razão desta busca é que areutilização de componentes economiza esforços e acelera o processo dedesenvolvimento de sistemas de computadores. Essa meta pode ser atingida emparte por meio da criação de classes que são extensões de classes predefinidas.As extensões herdam todos os atributos da classe base ou superclasse. Porexemplo, suponha que alguém tenha definido uma classe para representar osdados de uma conta bancária: Conta -número:num -Saldo: float -CPF:Num Figura IV.2- Classe Conta. Suponha também que além da conta corrente básica mais dois tipos deconta devam ser criadas: poupança e conta especial. A poupança possui todos os Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 89atributos de uma corrente e mais um atributo contendo a data de abertura daconta que será usada para cálculo do valor dos juros e correção monetária queserá acrescentado ao saldo da conta. A conta especial possui todos os atributosde uma corrente e mais um atributo contendo o valor de limite de crédito. No exemplo descrito acima seria um desperdício de tempo e código seprecisássemos codificar todos os atributos e métodos relacionados da classeConta nessas duas novas classes. Para evitar esta duplicação de esforço bastadeclaramos essas duas novas classes como subclasses da classe Conta. Destaforma apenas os atributos que não estão declarados na superclasse e métodosassociados precisam ser codificados, uma vez que os membros da superclassesão herdados pelas subclasses. A figura IV.3 mostra o diagrama de classecontendo o relacionamento entre as classes e o exemplo IV.13 mostra o códigoJava correspondente. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 90 Conta -número:num -Saldo: float -CPF:Num CPoupança CEspecial -DataAber:Data -Limite: float Figura IV.3- Relação entre as classes.public class Conta{ long numero; long cpf; double saldo; public Conta(long n, long c, double s) { numero = n; cpf = c; saldo = s; } public long getNumero(){return numero;} public long getCpf(){return cpf;} public double getSaldo(){return saldo;} public void setSaldo(double s){saldo = s;} public void somaSaldo(double v){saldo += v;}}import java.util.*;public class CPoupanca extends Conta{ Date dataAber; public CPoupanca(long n, long c, double s, String d) { super(n,c,s); dataAber = new Date(d); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 91 } public String getData(){return dataAber.toString();} } public class CEspecial extends Conta { double limite; public CEspecial(long n, long c, double s, double l) { super(n,c,s); limite = l; } public double getLimite(){return limite;} public double getSaldo(){return saldo+limite;} public void setLimite(double l){ limite = l;} } Exemplo IV-15. Implementação das Classes. Podemos notar que para declarar uma classe como subclasse de outrabasta colocarmos a palavra-chave extends após o nome da classe e o nome dasuperclasse após a palavra-chave. Apenas o nome de uma superclasse épermitido, portanto Java não permite que uma classe seja subclasse de mais deuma classe (herança múltipla). Herança Múltipla A capacidade de possuir mais de uma superclasse é chamada de herança múltipla. Alinguagem C++ suporta a herança múltipla. No entanto, a implementação desta facilidade écomplexa e sua utilização tende a gerar erro. Além disso poucos são os casos que demandam ouso desta solução, e mesmo nestes casos é possível utilizar outras soluções. Por essas razões alinguagem Java não implementou a herança múltipla. Nos casos onde é necessário que um objetoadote o comportamento de mais de uma classe devemos utilizar as interfaces, como será vistomais adiante. Todos os membros declarados com os modificadores public eprotected podem ser acessados diretamente na subclasse. O membrosdeclarados com o modificador private não são visíveis dentro da subclasse.super Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 92 Podemos notar também que no construtor das subclasses do exemploIV.12 existe uma chamada a um método super(). Este método representa achamada ao construtor da superclasse. Se não for chamado explicitamente ocompilador irá gerar código para chamar o construtor default da superclasse. Noentanto, se desejamos chamar explicitamente um construtor com argumentosdevemos usar o método super().A classe Object É importante salientar que toda classe em Java, com exceção da classeObject é subclasse de alguma classe. Se o programador não declarar a classebase então a classe base será a classe Object. Desta forma a classe Object éa raiz da hierarquia de classes da linguagem Java. Sendo assim, todo objeto nalinguagem Java herda os seguintes métodos públicos e protegidos da classeObject.Métodos Públicos Descriçãopublic boolean equals(Object Verifica se dois objetos são iguais. Aobj) verificação é feita sobre o endereço do objeto .public final native Class Retorna a classe do objeto em tempo degetClass() execução.public native int hashCode() Retorna o valor do objeto.public final native void Notifica um thread que está esperando sobrenotify() um objeto.public final void notifyAll() Notifica todos os threads que está esperando sobre um objeto.public String toString() Retorna uma representação em String do objeto.public final void wait() Espera para ser notificado por outro thread.public final void wait(long Espera para ser notificado por outro thread.timeout)public final void wait(long Espera para ser notificado por outro thread.timeout, int nanos)Métodos Protegidos Descriçãoprotected native Object clone() Cria uma cópia do objeto corrente.protected void finalize() Chamado pelo coletor de lixo antes de liberar a área de memória. Tabela IV.xx- Métodos público e protegidos da classe Object. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 93Sobrescrita e Polimorfismo Outro ponto interessante que podemos observar no exemplo IV.12 é quea classe CEspecial possui um método com a mesma assinatura que ummétodo da superclasse. É o método getSaldo() que no caso da classeCEspecial deve incluir o limite de crédito como parte do saldo. Neste caso o método da subclasse está sobrescrevendo ou ocultando ométodo da superclasse. Toda vez que o método getSaldo() for invocadodentro de algum método da classe CEspecial ou for chamado por meio deum objeto da classe CEspecial o método chamado será uma instância dodeclarado na classe e não do declarado na superclasse. No entanto, é possívelinvocar uma instância do método declarado na superclasse de dentro de algummétodo da subclasse, bastando qualificar o método com a palavra chave supercomo mostrado abaixo: super.getSaldo(); Por exemplo, o método getSaldo() da classe CEspecial poderiaser rescrito da seguinte forma: public double getSaldo() { return super.getSaldo()+limite; } Suponha agora uma classe como mostrado no exemplo IV.13. O métodoimprimeSaldo() espera um objeto da classe Conta mas recebe um objeto daclasse CEspecial. Isto não causa nenhum problema porque todo objeto da classeCEspecial é também um objeto da classe Conta. No entanto fica a pergunta:que método getSaldo() é invocado dentro o método imprimeSaldo()? O daclasse Conta ou o da classe CEspecial? public class TestaConta { public void imprimeSaldo(Conta c) { System.out.println(“O Saldo e’:”+c.getSaldo()); } public static void main(String a[]) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 94 { TestaConta testa = new TestaConta(); CEspecial c= new CEspecial(1, 123456, 500.0, 100.0); testa.imprimeSaldo(c); } } Exemplo IV-16. Teste de polimorfismo. A resposta é: o método chamado pertence a instância da classeCespecial. Portanto a regra é a seguinte: sempre é chamado o método dadeclarado na classe a que o objeto pertence e não da classe superclasse. Paraque essa regra seja implementada é necessário que a associação da chamada dométodo com o código do método em casos como no exemplo IV.13 seja feito emtempo de execução. Isso ocorre porque somente em tempo de execução serápossível saber a classe do objeto que está sendo recebido como parâmetro. O momento em que ocorre a associação de um identificador com a objetoque identifica é chamado tempo de amarração. Se este momento ocorre emtempo de compilação a amarração é dita estática (static binding). Se associaçãoocorre em tempo de execução a amarração é dita dinâmica (dynamic binding).Assim, na linguagem Java, em se tratando da associação da chamada do métodoao código do método a amarração é dinâmica. A única exceção é se o método fordeclarado como final. Neste caso a amarração é estática porque não é possívelsobrescrever o método. A implementação da amarração dinâmica é claramente mais ineficienteque a estática, uma vez que o compilador precisa gerar código para determinar aclasse do objeto em tempo de execução. No entanto, existem vantagensconsideráveis na adoção da amarração dinâmica. Ela facilita o reuso e aextensão de programas. Por exemplo, se criarmos uma nova subclasse da classeConta que também sobrescrevesse o método imprimeSaldo(), nenhumamodificação precisaria ser feita em métodos como o imprimeSaldo() daclasse TestaConta, uma vez que o método correto sempre é chamado.Portanto, podemos ampliar a hierarquia de um conjunto de classes sem precisaralterar, na maioria das vezes, os métodos que fazem uso dessa hierarquia. A amarração dinâmica de métodos também acarreta um comportamentopolimórfico. Por exemplo, o objeto que é passado para o métodoimprimeSaldo() pode exibir comportamento diversos, dependendo da classea qual realmente o objeto pertence. Amarração Dinâmica em C++ Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 95 Apesar da amarração dinâmica entre os identificadores dos métodos e o corpo dosmétodos ser considerada uma característica importante para linguagens orientadas a objetos, nemtodas a linguagens deste estilo de programação adotam este comportamento como padrão. Porexemplo, a linguagem C++ adota a amarração estática como padrão. Se o programador desejarque os métodos possuam amarração dinâmica então o deve instruir o compilador explicitamenteprefixando os métodos com a palavra-chave virtual. A razão para esta decisão dos projetistas dalinguagem está na eficiência. A amarração dinâmica é bem mais ineficiente que a amarraçãoestática e a linguagem C++ se propõe a ser uma linguagem que é capaz de gerar código queexecuta eficientemente. O exemplo IV.14 procura esclarecer melhor a amarração dinâmica dosmétodos na linguagem Java. public class Animal { public void fala(){} } public class Cachorro extends Animal { public void fala(){System.out.println(“Au au!”);} } public class Gato extends Animal { public void fala(){System.out.println(“Miau!”);} } public class UsaAnimal { public void falaAnimal(Animal a){a.fala();} } Exemplo IV-17. Classes de vozes dos animais. No exemplo IV.14 o método falaAnimal() da classe UsaAnimalrecebe qualquer subclasse da classe Animal é invoca o método fala() dasubclasse. Para incluir mais um animal na hierarquia basta declarar mais umasubclasse: public class Pato extends Animal { public void fala(){System.out.println(“Quá Quá!”);} } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 96 Exemplo IV-18. Classe com a voz do pato. Nada precisa ser alterado nas outras classes. A nova classe pode serinclusive subclasse de outra subclasse que não haverá problema: public class GatoRonronando extends Gato { public void fala(){System.out.println(“Purr!”);} } Exemplo IV-19. Classe com a voz do pato. Podemos observar que a classe Animal propriamente dita não faz nadaa não ser servir de “cabide” para as outras classes. É pouco provável que ela sejainstanciada, já que o seu único método não faz nada. Classes como essafuncionam como um esquema para as subclasses e deveriam ser tratadasadequadamente pelo compilador. Este tópico é tratado adequadamente napróxima seção.Classes e Métodos Abstratos Classes abstratas são esquemas ou esqueletos de classes cujo únicopropósito e servir de “cabides” para “pendurar” classes. Uma classe abstrata nãopode ser instanciada e possui um ou mais métodos abstratos. Um métodoabstrato é um método sem corpo cuja a assinatura é precedida da palavra-chaveabstract. Na verdade o programador não é obrigado a declarar métodosabstratos em classes abstratos, porém raramente surgira uma situação em quenão isso não faça sentido. As subclasses precisam sobrescrever os métodosabstratos, caso contrário também não poderão ser instanciadas. A classe Animal do exemplo IV.14 é uma ótima candidata à classeabstrata. Para torná-la uma classe abstrata basta preceder a declaração da classecom a palavra chave abstract e declarar um ou mais de seus métodos comoabstratos, como mostra o exemplo IV.17. abstract public class Animal { abstract public void fala(); } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 97 Exemplo IV-20. Classe abstrata Animal. Além de não poder ser instanciada a classe abstrata possui outraslimitações. Uma classe abstrata não pode possuir métodos estáticos econstrutores. Outra limitação é que os métodos abstratos não podem serprivados, uma vez que as subclasses precisam sobrescrever os métodosabstratos.Interfaces As Interfaces podem ser encaradas como classes abstratas completamentenão implementadas. Ou seja, todos os métodos são abstratos e os atributos sópodem ser do tipo static final (constantes). A forma geral de uma Interfaceobedece o seguinte esquema:interface identificador{ corpo da interface} A classe que implementa uma interface precisa fornecer umaimplementação para todas os métodos definidos na Interface. Para que umadeterminada classe seja vista como uma implementação de uma interface épreciso indicar isto colocando a palavra chave implements na declaração daclasse e após a palavra chave a lista com o nome de todas as interfaces que sedeseja implementar, separados por vírgula. O esquema abaixo mostra a formageral do uso de Interfaces.class Identificador implements Interface1, Interface2,...{ corpo da classe} O leitor deve estar se perguntando: se a interface é apenas uma classeabstrata completamente não implementada então porque não criar simplesmenteuma classe abstrata? A resposta está relacionada com o tipo de herança queocorre entre as classes de Java. Como já mencionamos a linguagem Java nãopermite a herança múltipla, ou seja, uma classe só pode ser subclasse de apenasuma classe. No entanto, existem situações em que é necessário definir umaclasse que possa ser vista de modos distintos. É ai que entram as Interfaces. Ainterface define uma forma de ver uma classe, restando para a classe aimplementação desta visão e a linguagem Java permite que uma classe Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 98implemente tantas Interfaces quantas se desejar. Desta forma Java evita osprincipais problemas da herança múltipla (herdando múltiplas definições e nãomúltiplas implementações), sem abrir mão de criar classes que podem ser vistasde formas diferentes. Por exemplo, suponha que um método receba um objeto que representa ainterface de saída de um determinado programa. O objetivo deste método é usarum método do objeto de interface para escrever uma mensagem na tela. Oexemplo IV.xx mostra o código da classe que contém o método.public class EscreveMem{ public static void escreve(InterUsuario inter) { inter.exibeMensagem(“ola mundo!”); }} Exemplo IV-21. Classe que recebe um objeto de interface. Suponha também que desejamos que o programa tenha tanto umainterface com o usuário em modo gráfico e em modo texto. Usaremos de agoraem diante as iniciais IU para significar interface com o usuário para evitar aconfusão com o conceito de Interfaces que estamos introduzindo. Se desejamosque o método escreve() possa receber instâncias dos dois tipos de IU énecessário que ambas sejam do tipo InterUsuario. No entanto, como veremosmais adiante, as classes que implementam IU gráficas devem ser subclasses declasses predefinidas como por exemplo da classe java.awt.Frame. Portanto,temos agora um problema de herança múltipla. A classe que implementa a IUgráfica de herdar de uma classe como a Frame e da classe InterUsuario. Asolução é simples. Basta definir InterUsuario como uma interface comomostra o exemplo IV.xx.interface InterUsuario{ abstract public void exibeMensagem(String men);} Exemplo IV-22. Definição de como InterUsuario interface. Agora basta que cada classe que representa um tipo de IU implemente ainterface InterUsuario. O exemplo IV.xx mostra a implementação de uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 99IU gráfica simples e o exemplo IV.xx mostra a implementação de uma IU emmodo texto simples.import java.awt.*;import java.awt.event.*;public class Janela extends Frame implements InterUsuario{ private Label label1; public Janela() { addWindowListener (new WindowAdapter() { public void windowClosing(WindowEvent evt) { System.exit(0); } } ); setLayout (new BorderLayout()); label1 = new Label(); label1.setText ("Mensagem"); add (label1, "South"); setSize(200,100); } public void exibeMensagem(String men) { label1.setText(men); }} Exemplo IV-23. IU gráfica.public class Console implements InterUsuario{ public void exibeMensagem(String men) { System.out.println(men); }} Exemplo IV-24. IU em modo texto. O exemplo IV.xx mostra uma forma de uso das classes definidas nosexemplos de IV.xx a IV.xx. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 100 public class UsaIUs { public static void main(String args[]) { Console c = new Console(); Janela j = new Janela(); j.setVisible(true); EscreveMem. escreve(c); EscreveMem. escreve(j); } } Exemplo IV-25. Uso das IUs. As Interfaces também são úteis sob o aspecto de projeto. Em C++ osprogramadores estão acostumados separar a interface de uma classe de suaimplementação. Geralmente dentro das classes são declaradas apenas asinterfaces dos métodos sendo que a implementação dos mesmos pode ser feitaposteriormente. Isto permite que se possa dividir a etapa da especificação do usode uma classe (o que ela faz) de sua implementação (como ela faz). Isto reduz acomplexidade da tarefa de implementação e permite melhor divisão de tarefas.No entanto, na linguagem Java os métodos de uma classe são geralmenteimplementados dentro da classe. As Interfaces e Classes podem ser utilizadaspara permitir a separação entre a interface e a implementação a exemplo decomo e feito em C++.Classes Internas A partir da versão 1.1 da linguagem Java foi incluída a permissão paradeclarar uma classe dentro da declaração de outra classe. As classes declaradasdentro de outra classe são denominadas de Classes Internas. A figura IV.xxmostra um esquema contendo o posicionamento relativo de uma classe interna. public class Externa { ... class Interna { ... } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 101 } Figura IV.xx- Posicionamento relativo das classes Interna e Externa. Os atributos e métodos declarados na classe externa são visíveis pela classeinterna, mesmo os declarados como protected ou private. No entanto, ocontrário não é verdadeiro, ou seja, os atributos e métodos da instância da classeinterna só são visíveis pela classe interna se forem declarados como públicos. Como já foi dito as classes mais externas (nível topo) só podem serdeclaradas como públicas ou friendly (default). No entanto, as classes internaspodem também receber os qualificadores private e protected. O efeito destesqualificadores sobre a visibilidade da instância da classe é o mesmo obtido sobreum atributo qualquer. O exemplo IV.xx mostra o caso de uma classe contendouma classe interna privada. O exemplo tem por objetivo apenas ilustrar o uso declasses internas.public class Calc{ Incrementa inc1, inc5; public Calc () { inc1=new Incrementa(1); inc5=new Incrementa(5); } private class Incrementa { int i; public Incrementa(int ai){i=ai;} public int inc(int num){return i+num;} } public int calcula(int x){return inc1(x)+inc5(x);}} Exemplo IV-26. Uso de classes internas. A inclusão de classes internas foi uma modificação a nível de linguagem emJava e o leitor deve estar se perguntando o que motivou a uma modificação tãoprofunda em Java. A reposta está no novo modelo de eventos proposto pelaversão 1.1. No novo modelo, como poderá ser constatado no capítulo que tratasobre a AWT, as classes internas se adequam perfeitamente. Aliado a esta Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 102motivação existe o fato de que esta alteração na linguagem não acarretounenhuma modificação na máquina virtual, tratada pelo compilador. Desta modoesta facilidade não gerou qualquer impacto em termos desempenho dosprogramas. O exemplo IV.xx mostra o exemplo de uso de uma classe internapara capturar eventos. Este tipo de uso será tratada com maiores detalhes nocapítulo que trata sobre AWT.public class Janela extends Frame { public Janela (String Titulo){ super(Titulo); addWindowListener(new JanelaListener()); setSize(100,50); } private class JanelaListener implements WindowListener { public void windowOpened(WindowEvent we){} public void windowClosed(WindowEvent we){} public void windowIconified(WindowEvent we){} public void windowDeiconified (WindowEvent we){} public void windowActivated(WindowEvent we){} public void windowDeactivated(WindowEvent we){} public void windowClosing(WindowEvent we){ setVisible(false); dispose(); System.exit(0); } };}; Exemplo IV-27. Uso de classes internas para receber eventos.Classes Internas Anônimas Java permite que se crie um objeto de uma classe sem nome. As classes sãodeclaradas no momento do retorno de um método ou durante a passagem deparâmetros e o objeto é criado quando o argumento ou a expressão de retorno éavaliada. O exemplo IV.xx mostra o retorno de um objeto de uma classeanônima.public class TesteAnonima{ public Object retAnon() Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 103 { return new Object() { // Definição da classe anônima private int i=10; public int value(){return i;} }; }}; Exemplo IV-28. Retorno de um objeto de uma classe anônima. Pode parecer pelo exemplo IV.xx que o objeto retornado é uma instânciada classe Object, no entanto é na verdade uma instância de uma classeanônima que é subclasse da classe Object. A classe anônima possui atributos emétodos próprios que a diferenciam da classe Object e estão definidos nadeclaração da classe. Usamos a classe Object apenas para exemplificar comuma classe conhecida. Qualquer classe pode fazer o papel de superclasse. Oexemplo IV.xx mostra o uso de uma classe anônima na criação de um objetopara lidar com eventos sobre um botão.class BT{ Button bt; public BT() { bt = new Button(“OK); bt.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { dispose(); } }); }} Exemplo IV-29. Uso de uma classe anônima para tratamento de eventos. As classes anônimas são adequadas para situações onde necessitamos em umlocal específico de um objeto de uma classe ligeiramente diferente de outraclasse já declarada. Com a classe anônima evitamos ter que declarar uma novaclasse para atender apenas uma necessidade local. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 104Conversão Uma variável declarada como referencia para objetos de umadeterminada classe pode receber referencias de objetos de subclasses sem anecessidade de se usar qualquer operador de conversão. A conversão é feitaautomaticamente, uma vez que toda instância de uma subclasse é também umainstância da superclasse. Por exemplo:Object o;String s = “teste”;o = s; A atribuição acima é possível porque a classe Object é uma superclassede String (Na verdade é superclasse de todas as classes). Já a conversãoinversa só é possível se o objeto for realmente do tipo da subclasse, e mesmoassim é preciso utilizar um operador de conversão forçada (casting):Object o;String s = “teste”;String t = “teste”;o = s;t = (String) o;Exceções Quanto maior o número de situações de exceção que um determinadoprograma consegue lidar, mais robusto é este programa. Para construir umprograma robusto o programador deve prever, além das situações onde os dadosde entrada e os recursos se apresentam de forma adequada, as situações ondealgo pode impedir a computação normal. Existem três abordagens típicas paraesses casos: 1) Ignorar – neste caso a ação será a padrão do sistema, provavelmente a interrupção do programa, ou no mínimo do comando onde ocorreu o erro, e a exibição de uma mensagem ininteligível na saída padrão, gerada pelo sistema. Esta é abordagem mais simples, mas certamente não é a mais interessante, principalmente do ponto de vista do usuário final. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 105 2) Retornar o código de erro. No caso da linguagem Java este retorno só pode ser feito via valor de retorno da função. No entanto algumas vezes não existem valores disponíveis para indicar o erro. Por exemplo, quando um método retorna um valor inteiro costuma-se usar os valores 0 ou –1 para sinalizar uma condição de erro, mas como agir no caso desses e todos os outros valores de inteiros serem valores válidos em uma execução normal? Existe ainda o problema de que esta abordagem não resolve o problema de erros que ocorrem nos construtores. Como os construtores não retornam valores não é possível sinalizar erros dessa forma. Esta é uma abordagem muito comum entre os programadores de C e Pascal, e é ainda usada pelos programadores de C++. No entanto, as linguagens mais modernas como C++ e Java disponibilizam recursos que permitem um melhor tratamento de exceções, como veremos na terceira abordagem. 3) Declarar um ou mais tratadores de exceções. Um tratador de exceção é uma parte do código que tem por objetivo recuperar a execução do programa após a ocorrência da exceção, permitindo que o sistema se comporte “suavemente”, mesmo sob condições adversas. A sintaxe e semântica dos tratadores de exceção variam muito de linguagem para linguagem, mas tem tendido a uma certa uniformização nas linguagens mais modernas. A linguagem Java, por ter como objetivo ser uma linguagem segura, obriga que os programador capture todas as exceções, menos as derivadas da classe RuntimeException. Na linguagem Java a amarração do tratador à exceção é definida emtempo de compilação. Nela, o programador envolve os comandos passíveis degerar exceções em blocos try/catch com o formato geral mostrado abaixo: try { código que pode gerar exceções } catch(classe de exceção1 objeto) { tratamento da exceção1 } catch(classe de exceção2 objeto) { ... } catch(classe de exceçãoN objeto) { tratamento da exceçãoN } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 106 As exceções são representadas como objetos A porção catch do blocopossui um bloco com comandos para tratamento da exceção. O bloco que tratadas exceções não tem acesso às variáveis declaradas dentro do bloco try{},uma vez que o escopo destas variáveis está delimitado pelo bloco. Por exemplo,o método estático parseInt() da classe Integer lança como exceção umobjeto da classe NumberFormatException se receber como argumento umString que não pode traduzido para uma representação inteira. O código paracapturar este tipo de exceção poderia ser semelhante ao apresentado no exemploXX.XX.public class Excecao1{ public static void main(String a[]) { try { int i = Integer.parseInt(a[0]); System.out.println("A cadeia passada pode ser ”+ ”tranformada para número :“+i); } catch(NumberFormatException e) { System.out.println("A cadeia passada não pode ser ”+ ”tranformada para número :“+a[0]); } }} Exemplo IV.XX- Capturando a exceção NumberFormatException. Se o bloco catch não possuir nenhum comando de return ou algumachamada à função exit(), então o programa é reassumido após o último blococatch.A hierarquia de Exceções As exceções são objetos que pertencem a classes que estão organizadasem uma hierarquia e cuja classe que se encontra no topo da hierarquia é a classeThrowable. A classe Throwable possui duas subclasses: Exception eError. Exception e suas subclasses são usadas para indicar condições quepodem ser recuperadas. Error e suas subclasses indicam condições que em geralnão podem ser recuperadas, causando a terminação do programa. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 107 Todos os objetos da classes Exception devem ser capturados ouexplicitamente relançados para um nível acima na pilha de chamadas. Isto só nãoé válido para os objetos da classes RuntimeException. A RuntimeException ésuas subclasses fazem definem as exceções que podem ser lançadas durante aexecução normal da máquina virtual, como divisão por zero ou indexação forados limites do array. A exceção NumberFormatException mostrada no exemploé uma subclasse da RuntimeException. Como essas exceções podem serlançadas por um número muito grande de métodos, seria trabalhoso para oprogramador se ele fosse obrigado a incluir código para capturar todas essasexceções. Portanto, instâncias da classe RuntimeException e suas subclassesnão precisam ser capturadas. A figura IV.XX mostra uma parte da hierarquiaThrowable até o nível 3. O número de classes nesta hierarquia é muito grandecomo o leitor pode verificar no apêndice XX. O programador pode tambémadicionar classes a esta hierarquia como veremos mais adiante. Throwable Exception Error RuntimeException ... ThreadDeathError VirtualMachineError LinkageError Figura IV.XX- Hierarquia de exceções.Capturando mais de uma exceção Um determinado método pode lançar mais de uma exceção, assim comopode existir mais de um método dentro de um bloco try/catch com potencialde lançar exceções. Portanto, muitas vezes é preciso definir um blocotry/catch com capacidade de tratar mais de uma exceção. Isto é feito por meioda definição de mais de uma cláusula catch. Cada cláusula catch trata umaexceção. Como a busca pela cláusula catch que deve tratar uma determinadaexceção é feita de cima para baixo é preciso tomar o cuidado de posicionar as otratamento das exceções mais genéricas mais abaixo do que o tratamento dasexceções mais específicas. Caso contrário o tratamento das exceções mais Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 108especificas nunca será executado. O exemplo IV.xx mostra um trecho de códigocujo bloco try/catch é capaz de capturar as exceções IOException,NumberFormatException e Exception. Note que por ser uma exceção maisgenérica que as outras duas o tratamento da exceção Exception é posicionadoapós os outros. Como as exceções NumberFormatException e IOExceptionnão se encontram na mesma linha de herança, a posição de uma relativa a outranão tem significado. import java.io.*; class Excecao2 { public static void main(String a[]) { try { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Entre um número:"); int i = Integer.parseInt(in.readLine()); }catch(IOException e) {System.out.println(“Erro de leitura!”);} catch(NumberFormatException e) {System.out.println(“Não é um número!”);} catch(Exception e) {System.out.println(“ocorreu algum erro”);} } } Exemplo IV.XX- Capturando a várias exceções.Lançando exceções Até agora temos visto apenas como capturar as exceções lançadas. Estána hora de olharmos o outro lado da moeda, ou seja, como lançar as exceções.As exceções são lançadas utilizando-se o operador throw. A forma geral docomando é a seguinte: throw <objeto> Pode-se também criar o objeto no instante do lançamento, invocando oconstrutor. Neste caso a forma geral do comando seria a seguinte: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 109 throw new <classe>(<parâmetros>) Note que pode-se passar parâmetros para o construtor que podem ajudarna recuperação do problema pelo tratador de exceções. O método onde aexceção é lançada deve tratar a exceção ou passá-la para método que o invocou.Para passar a exceção para o método que o invocou a assinatura do métodocorrente deve conter uma cláusula throws após a lista de argumentos, comomostrado abaixo: <modificador><tipo retorno> <identificador>(<argumentos>) throws <exceção1>,<exceção2>,...,<exceçãon> { } Note que é possível indicar na assinatura do método o repasse de váriasexceções. O exemplo IV.xx mostra tanto o lançamento de um objeto da classeException caso os parâmetros para o construtor da classe não sejam corretos. import java.io.*; class NumPos{ private int num; public NumPos(int aNum) throws Exception { if (aNum < 1) throw new Exception(“Número não positivo”); num = aNum; } } public class Excecao3 { public static void main(String a[]) { try { NumPos np = new NumPos(Integer.parseInt(a[0])); }catch(Exception e) {System.out.println(e.getMessage());} } } Exemplo IV.XX- Lançando exceções. Na verdade o pode-se usar a cláusula throws na assinatura do métodopara repassar qualquer exceção que se desejar. O exemplo IV.xx , mostra o Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 110método m1 que repassa qualquer objeto da classe Exception que for lançado emseu corpo, mesmo os que não forem explicitamente lançado por meio docomando throw: public class Excecao4 { public void m1(int i) throws Exception { if (i == 0 ) throw new NumberFormatException(); System.out.println(2/i); } } Exemplo IV.XX- Repassando todas as exceções.Comportamento do Sistema diante das Exceções Agora que já vimos como tratar e como lançar exceções podemos discutircomo é o comportamento global do sistema diante das exceções. Ou seja, comoé a sequência de busca por um tratador após a ocorrência de uma exceção?Quando ocorre uma exceção em um método o sistema verifica se o comandoonde ocorreu a exceção está incluso em bloco try/catch com uma cláusulacatch associada à exceção. Neste caso o controle é transferido para o bloco detratamento da cláusula catch. Caso contrário, o sistema desempilha um nível napilha de chamada de métodos e verifica se a chamada ao método anterior estáinclusa em bloco try/catch com uma cláusula catch associada à exceção. Osistema prossegue desta forma até que um bloco tratador seja encontrado. Casoencontre o bloco tratador e este não possua nenhum comando de saída (returnou System.exit()), então o controle será retomado no nível de chamada ondefoi tratado após o último bloco catch. e não onde ocorreu a exceção. Caso nãoencontre nenhum bloco tratador, ao atingir o nível mais alto da pilha dechamadas o programa é abortado. A figura IV.xx procura ilustrar o comportamento do sistema diante deuma exceção, tratada em um nível da pilha de chamada diferente de ondeocorreu. Pilha de chamadas Código fonte public class Excecao5 m1 { public void m1(int i) { try { Alcione de P. Oliveira, Vinícius V. Maciel - UFV m2(i) }catch (Exception e){...}; m2 ... } public void m2(int i) throws Exception { m3(i); m3 }
  • Java na Prática 111 tratamento da exceção ocorrência da exceção Figura IV.XX- Propagação das exceções.Criando suas próprias exceções Se o programador concluir que nenhuma exceção pré-existente seencaixa no tipo de erro que pretende sinalizar, então criar uma classe nova pararepresentar essa exceção. A única condição é que a nova classe seja umaextensão da subclasse Throwable ou de uma de suas subclasses. Procureestender a classe Exception ou uma de suas subclasses, exceto o ramo daRuntimeException, uma vez que, como já foi dito, esta ramificação dahierarquia de exceções é utilizada para exceções do sistema. Por exemplo,podemos rescrever o exemplo IV.xx de modo que o método lance uma exceçãodefinida pelo programador. import java.io.*; class NumPosException extends Exception { public NumPosException(String m){super(m);} } class NumPos { private int num; public NumPos(int aNum) throws NumPosException { if (aNum < 1) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 112 throw new NumPosException (“Número não positivo”); num = aNum; } } public class Excecao6 { public static void main(String a[]) { try { NumPos np = new NumPos(Integer.parseInt(a[0])); }catch(NumPosException e) {System.out.println(e.getMessage());} } } Exemplo IV.XX- Lançando exceções.A cláusula finally Existe mais uma cláusula opcional do bloco try/catch. Esta é a cláusulafinally. A cláusula finally abriga uma trecho de código que deve serexecutado independente se ocorreu ou não uma exceção no bloco try/catch.Pode ser usada para realizar operações de finalizações, como por exemplofechamento de arquivos e canais de comunicação. O exemplo IV.xx ilustra o usoda cláusula finally. import java.io.*; class Excecao7 public static void main(String a[]) { try { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Entre um número:"); int i = Integer.parseInt(in.readLine()); }catch(IOException e) {System.out.println(“Erro de leitura!”);} catch(NumberFormatException e) {System.out.println(“Não é um número!”);} finally() {System.out.println(“Terminou.”);} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 113 } } Exemplo IV.XX- Usando a cláusula finally. No exemplo IV.xx se não ocorrer nenhuma exceção a cláusula finally éexecutada e a execução é reassumida após a cláusula finally. Caso ocorraalguma exceção no bloco try/catch e exista alguma cláusula catch associada àexceção então a cláusula finally é executada após o tratamento da exceção e aexecução é reassumida após a cláusula finally. Caso ocorra alguma exceção nobloco try/catch e não exista alguma cláusula catch associada à exceção entãoa cláusula finally é executa antes da transferência do controle para o métodochamador.Documentando o código Uma das maiores dificuldades no desenvolvimento de software éconseguir que os programadores produzam uma documentação relacionada comos programas que estão desenvolvendo. Eles não gostam de interromper odesenvolvimento para escrever paralelamente a documentação e após o términoda implementação não se animam a passar um grande período de tempodocumentando todo o código escrito. Pensando nisso os projetistas de Javadesenvolveram um meio do programador embutir a documentação no própriocódigo, de modo que, não precisasse interromper a implementação. A documentação é inserida como um comentário e usa uma sintaxeespecial que pode ser interpretada pelo programa javadoc para gerar umdocumento HTML. Todo comentário que deve ser interpretado pelo javadocdeve ser iniciado por “/**” e terminado por “*/”. O programador pode inserira documentação de duas formas: 1. rótulos (tags) iniciados pelo caractere ‘@’ e que denotam comandos de documentação; ou 2. por meio de código HTML embutido. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 114Rótulos O javadoc relaciona os comentários com a estrutura codificada após ocomentário. As estruturas relacionadas com os comentários são as classes,variáveis e métodos. A exceção do rótulo @see todos os rótulos estãorelacionados com a documentação de classes ou métodos.Rótulo @see O rótulo @see é usado para gerar links para documentação de outrasclasses. Os links não serão verificados pelo javadoc. Os formatos possíveissão os seguintes: @see <nome da classe> @see <nome da classe>#<nome do método>Rótulos para documentação de classes Os seguintes rótulos são usados na documentação de classes: Rótulo Descrição@version <versão> Usado para incluir informação sobre a versão.@author <autor> Usado para incluir informação sobre o autor. Tabela IV.xx- Rótulos para documentação de classes.Rótulos para documentação de métodos Os seguintes rótulos são usados na documentação de métodos: Rótulo Descrição@param <nome> <descrição> Usado para incluir informação sobre o parâmetro do método.@return <descrição> Usado para incluir informação sobre o valor de retorno do método.@exception <nome da classe> Usado para incluir informação sobre a <descrição> exceção que pode ser lançada pelo método. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 115@deprecated Incluído a partir da versão 1.1. Indica que o método pode não ser mantido nas próximas versões da linguagem. Tabela IV.xx- Rótulos para documentação de métodos.Exemplo de Documentação O exemplo IV.xx ilustra o uso dos rótulos para documentação do código./** Pessoa Mantem os dados pessoais de uma pessoa. @author Alcione de Paiva Oliveira @author alcione@dpi.ufv.br @version 1.0*/public class Pessoa{ private String Nome; private String Tel; private String End; // Construtor /** @param n String contendo o nome @param t String contendo o telefone @param e String contendo o endereço @return não retorna valor */ public Pessoa(String n, String t, String e) { Nome = n; Tel = t; End = e; } /** Retorna o nome da pessoa @return uma String contendo o nome */ public String getNome(){return Nome;} /** Retorna o telefone da pessoa @return uma String contendo o telefone */ public String getTel(){return Tel;} /** Retorna o endereço da pessoa Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 116 @return uma String contendo o endereço */ public String getEnd(){return End;}} Exemplo IV.XX- Exemplo de documentação.HTML embutida O programador pode incluir código HTML dentro dos comentários paradocumentação da mesma forma que faria em um documento da Web, comomostra o exemplo IV.xx. /** * <b>Pessoa<b> * Possui os seguintes objetivos * <ol> * <li> Objetivo1 * <li> Objetivo2 * </ol> */ public class Pessoa { ... } Exemplo IV.XX- Uso de HTML embutida para documentar código. O javadoc irá ignorar os caracteres ‘*’ no início de cada linha ao gerara documentação. Não use rótulos de títulos como <h1> ou <hr>, uma vez queo javadoc irá inserir rótulos de títulos automaticamente.Agenda Eletrônica versão Console 1.0 Iniciaremos agora a primeira versão de um programa que implementauma agenda eletrônica de endereços e telefones. Este programa evoluirá aolongo do livro, de acordo com os conhecimentos que serão apresentados. Em suaprimeira versão a agenda eletrônica terá uma interface baseada em linha decomando e não armazenará o seu conteúdo em algum dispositivo de memória Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 117permanente, o que não a torna muito útil em termos práticos. Nas versõesposteriores a agenda eletrônica armazenará o seu conteúdo em arquivos e Bancode Dados, ganhará interface gráfica, poderá ser utilizada em navegadores deWeb, terá uma arquitetura Cliente/Servidor, e outras facilidades. Esperamos comisso mostrar os vários aspectos da linguagem durante a evolução do programa.Outros exemplos serão apresentados de acordo com a necessidade, porém aagenda eletrônica permanecerá como exemplo principal. O diagrama de classes da figura III.xx mostra os objetos que compõe aversão console da agenda. Pessoa -String Nome Agenda -String Tel -String End +inserir(pessoa p) +pessoas getPessoas() 0..* +getNome() +Pessoa getPessoa(String Nome) +getTel() +getEnd() AgendaInt +obterPessoa() +exibirLista() +exibirPessoa() Figura III. – Diagrama de classes da versão console da agenda eletrônica. Os objetos da classe Pessoa armazenam os dados de uma pessoa. Elafornece os métodos para o acesso a esses dados. O objeto da classe Agenda é composto por vários dados de pessoa. Estefato está representado no diagrama pela associação de agregação. A classeAgenda possui os métodos necessários para inserção e recuperação dos dados. Ométodo inserir(), trata de inserir uma pessoa na lista de pessoas, o métodogetPessoas(), retorna uma lista contendo todos os objetos da classe Pessoa eo método getPessoa() retorna um objeto da classe Pessoa com o nomeespecificado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 118 A Classe AgendaInt é responsável por fornecer os métodos queimplementam a interface com o usuário. Ela foi criada por questões de projeto,uma vez que é importante manter separado o código das interfaces do sistema. Primeiramente apresentaremos o código da classe Pessoa./** Pessoa*/public class Pessoa{ private String Nome; private String Tel; private String End; // Construtor public Pessoa(String n, String t, String e) { Nome = n; Tel = t; End = e; } // Metodos public String getNome(){return Nome;} public String getTel(){return Tel;} public String getEnd(){return End;}} Por questões de simplicidade a classe pessoa possui apenas umconstrutor. As variáveis de instância são declaradas private para preveniracessos que não sejam por meio dos métodos da classe. Segue abaixo o códigoda classe Agenda:/** AGENDA Versão Console 1.0.*/public class Agenda{ Pessoa pessoas[]; // Construtor public Agenda() {pessoas = null;} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 119 // Metodos /** inserir */ public void inserir(Pessoa p) { if (pessoas == null) pessoas = new Pessoa[1]; else AumentaCapacidade(); pessoas[pessoas.length-1] = p; } /** Consultar */ public Pessoa getPessoa(String nome) { Pessoa aux = null; for (int i=0; i< pessoas.length; i++) if (pessoas[i].getNome().equals(nome)) aux = pessoas[i]; return aux; } /** listar */ public Pessoa[] getPessoas(){return pessoas;} /** AumentaCapacidade */ private void AumentaCapacidade () { Pessoa aux[] = new Pessoa[pessoas.length+1]; for (int i=0;i< pessoas.length;i++) aux[i] = pessoas[i]; pessoas = aux; }} De modo a manter o programa com poucas linhas não inserimos códigopara tratar erros para testar os valores que são passados para os métodos ouretornados por eles. O leitor deve ter isto em mente se por acaso pretende utilizartrechos deste programa para aplicações profissionais. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 120 Existem várias formas de representar a associação entre duas classes.Escolhemos representar a agregação por meio de um array de objetos da classePessoa. Um outra forma, mais fácil de se trabalhar, será apresentada na seção xx.A variável que referencia o array é inicializada com null. Toda vez que éinserido um novo objeto o array precisa ser redimensionado. Isto é feito pelométodo privado AumentaCapacidade(). Na verdade o método cria umnovo array maior em uma unidade que o anterior. Esta não é uma solução muitoeficiente. O melhor seria incrementar o array em várias unidades, de modo que oredimensionamento seria necessário em intervalos menores. Contudo, o códigonecessário para gerenciar a inserção seria bem mais complexo. O método getPessoa() retorna um objeto com o dado nome igual aopassado ao método. Se não existir tal objeto é retornado null. Já o métodogetPessoas() retorna uma referencia para array de objetos do tipo Pessoa./** AgendaInt Interface console da agenda.*/import java.io.*;public class AgendaInt{ Agenda ag; BufferedReader in; // Construtor public AgendaInt() { ag = new Agenda(); in = new BufferedReader(newInputStreamReader(System.in)); } // Metodos /** Exibirlista */ public void Exibirlista() { Pessoa p[]=ag.getPessoas(); for (int i= 0; i<p.length; i++) System.out.println("nNome:"+p[i].getNome()+"nTelef one:" +p[i].getTel()+"nEndereço:"+p[i].getEnd()+"n"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 121}/** exibirPessoa*/public void exibirPessoa(){ String nome=null; try { System.out.println("Entre com o nome:"); nome = in.readLine(); if (nome.length()<1) System.exit(-1); } catch(IOException e) {System.out.println(e.getMessage());System.exit(-1);} Pessoa p = ag.getPessoa(nome); if (p!=null) {System.out.println("nNome:"+p.getNome()+"nTelefone:" +p.getTel()+"nEndereço:"+p.getEnd()); }}/** obterPessoa*/public void obterPessoa(){ String nome; String tel; String end; try { System.out.println("Entre com o nome:"); nome = in.readLine(); if (nome.length()<1) System.exit(-1); System.out.println("nEntre com o Telefone:"); tel = in.readLine(); System.out.println("nEntre com o Endereço:"); end = in.readLine(); ag.inserir(new Pessoa(nome ,tel,end)); } catch(IOException e) {System.out.println(e.getMessage());System.exit(-1);}}// mainpublic static void main(String args[]){ Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 122 AgendaInt agInt = new AgendaInt(); String opcao=""; for(;;) { System.out.println( "nAgenda Tabajaran***********************n"); System.out.print( "Opcoes:n(i)nserirn(c)onsultarn(l)istarn(f)im=>"); try { opcao = agInt.in.readLine(); if (opcao.length()==0) continue; } catch(IOException e) {System.out.println(e.getMessage());System.exit(- 1);} switch(opcao.charAt(0)) { case f: System.exit(0); break; case i: agInt.obterPessoa(); break; case c: agInt.exibirPessoa(); break; case l: agInt.Exibirlista(); break; } } }} O método main da classe AgendaInt cria um objeto da própria classe,que por sua vez possui um objeto da classe Agenda. A partir de então oprograma entra em um laço, que aguarda e atende às solicitações do usuário.Todos os métodos da classe recebem e exibem dados por meio dos dispositivosde E/S padrão. Para ler os dados do dispositivo de entrada padrão, uma linha porvez, foi necessário encapsular o objeto System.in em objetos das classesBufferedReader e InputStreamReader . Não detalharemos aqui ouso destas classes, que será abordado no próximo capítulo. No momento bastaobservarmos que a entrada de dados será realizada por meio do métodoreadLine(), que retorna a linha digitada pelo usuário. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 123Capítulo V – Entrada e S aída(java.io)Acesso Sequencial As funções de entrada e saída são suportadas por classes agrupadas nopacote java.io. Todas se baseiam no conceito de stream de bytes (corrente ousequência), onde a entrada/saída é um duto onde se retira/coloca cada bytecomo em uma fila do tipo First in-first out. A figura V.1 ilustra este tipo deenfoque. Figura V.1 Stream de bytes. O produtor e o consumidor podem se selecionados de uma amplavariedade que vai desde arquivos e portas de protocolos TCP/IP até arranjos(arrays) de bytes e Strings. De modo a pode lidar com essa ampla variedade defontes/consumidores de dados e prover todo o tipo de facilidade de leitura opacote java.io possui um conjunto razoavelmente grande classes. Essasclasses são combinadas, formando camadas, onde as classes das camadasinferiores fornecem serviços básicos como leitura/escrita de um byte, enquantoque as classes superiores fornecem serviços de leitura/escrita mais sofisticados,como leitura de linha, leitura de um tipo float, etc. A figura V.2 mostra este tipode combinação. Camada n Camada 1 Nível dos Classe I/O serviços Básica Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 124 Figura V.2 Organização das classes de I/O. Para complicar um pouco mais a situação, a linguagem Java Possui doisconjuntos distintos de classes para I/O. Um originado da versão 1.0 e outrointroduzido na versão 1.1. A razão para isso é que as classes projetadas naversão 1.0 são orientadas para bytes e portanto não são adequadas para lidarcódigos Unicodes que utilizam dois bytes. A versão 1.2 não introduziu grandesmodificações, realizando apenas um aperfeiçoamento na java.io.File ealgumas mudanças na assinatura de alguns métodos . O leitor deve então estarpensando que basta então utilizar o novo conjunto de classes e esquecer doantigo, porém a coisa não é tão simples assim. Primeiramente, é importanteconhecer o conjunto antigo de classes uma vez que existe um grande número deprogramas escrito na versão 1.0 e o leitor pode se ver obrigado a ler ou darmanutenção no código destes programas. Em segundo lugar, algumas vezes serápreciso combinar as funções antigas com as novas para obter algum tipo defuncionalidade. E em terceiro lugar a Sun adicionou novas facilidades aoconjunto antigo na versão 1.1, dando sinais que não pretende simplesmenteabandoná-lo. Tudo isto faz com que o tratamento de entrada e saída em Java nãoseja algo muito simples de se dominar. As figuras V.3 e V.4 apresentamdiagramas que mostram algumas das camadas dos dois conjuntos de classes, demodo que o leitor possa ter uma idéia da sua equivalência, embora nem sempreuma classe de um conjunto possua uma classe correspondente em outroconjunto. floats etc. floats etc. String String ints ints FilterInputStream DataInputStream FilterReader BufferedInputStream BufferedReader LineNumberInputStream LineNumberReader bytes caractere StringBufferInputStream PipedReader ByteArrayInputStream CharArrayReader PipedInputStream StringReader FileInputStream FileReader InputStream Reader Figura V.3 Comparação entre as classes de entrada. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 125 floats etc. floats etc. ints Strings ints Strings FilterOutputStream PrintStream FilterWriter DataInputStream BufferedWriter BufferedOutputStream PrintWriter bytes caractere ByteArrayOutputStream PipedWriter PipedOutputStream CharArrayWriter FileOutputStream StringWriter OutputStream FileWriter Writer Figura V.4 Comparação entre as classes de saída. Note que não existe uma equivalência perfeita entre os dois conjuntos,nem entre o par entrada/saída em um mesmo conjunto. Por exemplo, a classeStringBufferedInputStream não possui uma classe equivalenteStringBufferedOutputStream nem a DataInputStream possui umaequivalente DataWriter. Esta é uma das razões para o uso combinado dos doisconjuntos. Para realizar a conversão entre os dois conjuntos são fornecidas asclasses InputStreamReader e OutputStreamWriter. As funções básicas são tratadas pelas classes abstratas básicasInputStream e OutputStream. Para as funções de entrada e saída com Bufferssão utilizadas as classes BufferedInputStream, BufferedOutputStream,BufferedReader e BufferedWriter. O tamanho padrão do buffer é de 2048bytes. A tradução entre InputStream, OutputStream e BufferedReader,BufferedWriter é feita por InputStreamReader e OutputStreamWriter. ParaIO em arquivos podem ser utilizadas classes de baixo nível: FileInputStream,FileOutputStream, FileReader e FileWriter. De modo a possibilitar a comparação e o entendimento do uso dos doisconjuntos os exemplos abaixo mostram a mesma função implementada comcada grupo de classes.a) Streams b) I/O 1.1import java.io.*; import java.io.*;class TesteIO101 class TesteIO111 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 126{ { public static void main(String a[]) public static void main(String a[]) { { try try { { DataInputStream in = BufferedReader in = new DataInputStream( new BufferedReader( new BufferedInputStream( new FileReader(a[0])); new FileInputStream(a[0]))); String str; String str; while((str = in.readLine())!= null) while((str = in.readLine())!= null) System.out.println(str); System.out.println(str); } catch(IOException e) } catch(IOException e) {System.out.println(e.getMessage());} { System.out.println(e.getMessage());} } } }} Exemplo V.1 – Leitura não formatada de arquivos. O exemplo V.1 mostra a leitura de um arquivo passado pela linha decomando feita (a) por meio de stream e (b) por meio de reader. Em ambos oscasos a leitura é utiliza buffers, de modo a otimizar os acessos a disco. No caso(b) basta utilizar um objeto da classe BufferedReader, uma vez que a leituraé não formatada, com o uso do método readLine(). Já no caso (a), é preciso“envolver” o objeto da classe BufferedInputStream em um objeto daclasse DataInputStream, apesar de não ser uma leitura formatada, uma vezque o método readLine() pertence à classe DataInputStream. Mesmoassim o programa receberá a mensagemThe method java.lang.String readLine() in classjava.io.DataInputStream has been deprecated.significando que o método readLine() está sendo descontinuado para a classeDataInputStream, tendendo a desaparecer nas próximas versões.a) Streams b) I/O 1.1import java.io.*; import java.io.*;class TesteIO102 class TesteIO112{ { public static void main(String a[]) public static void main(String a[]) { { try try { { PrintStream out = new PrintStream( PrintWriter out = new PrintWriter( new BufferedOutputStream( new BufferedWriter( new FileOutputStream("saida.out"))); new FileWriter("saida.out"))); out.println("Linha de teste 1"); out.println("Linha de teste 1"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 127 out.println("Linha de teste 2"); out.println("Linha de teste 2"); out.close(); out.close(); }catch(IOException e) { }catch(IOException e) { System.out.println(e.getMessage());} System.out.println(e.getMessage());} } }} } Exemplo V.2 – Escrita não formatada em arquivos. a) Streams import java.io.*; class TesteIO103 { public static void main(String a[]) { try { DataOutputStream out = new DataOutputStream( new BufferedOutputStream( new FileOutputStream("a.out"))); out.writeBytes("O valor de pi: n"); out.writeDouble(3.14159); out.close(); DataInputStream in = new DataInputStream( new FileInputStream("a.out")); System.out.println(in.readLine()); System.out.println(in.readDouble()); }catch(IOException e) {System.out.println(e.getMessage());} } } Exemplo V.3 – Escrita e leitura formatada em arquivos.. A leitura/escrita formatada utiliza as classes DataInputStream eDataOutputStream. Como não existem as correspondentes DataReadere DataWriter, somos obrigados a usar o conjunto antigo de classes pararealizar a leitura e escrita formatada. Os dispositivos de entrada e saída padrões (equivalentes na linguagemC++ a cin, cout e cerr), são mantidos pela por variáveis estáticas da classeSystem, referenciadas por System.in, System.out e System.error.Como essas variáveis referenciam a objetos das classes InputStream eOutputStream, se desejarmos manipular os dispositivos de E/S padrões como conjunto de classes novos devemos utilizar as classes tradutoras Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 128InputStreamReader e OutputStreamWriter, como mostrado noexemplo V.4. import java.io.*; class TesteIO114 { public static void main(String a[]) { try { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Entre uma linha:"); System.out.println(in.readLine()); }catch(IOException e) {System.out.println(e.getMessage());} } } Exemplo V.4 – Leitura e Escrita nos dispositivos de saída e entrada padrões.Acesso Direto Até agora lidamos com dispositivos de entrada e saída que tratamsequência de bytes ou caracteres (streams). No entanto, alguns dispositivoscomo disco rígido e CDs permitem o acesso direto à um byte sem a necessidadede ler todos os outros bytes posicionados antes. Este tipo de acesso é chamadode acesso direto e Java permite este tipo acesso a arquivos armazenados emdispositivos que suportam o acesso direto por meio da classeRandomAccessFile. Esta classes não pertence a nenhuma das hierarquiasapresentadas anteriormente uma vez que não acessa os dados na forma desequência. A única semelhança com as outras hierarquias é o fato deimplementar as interfaces InputStream e OutputStream. De fato, a classeRandomAccessFile torna muito conveniente o acesso a arquivos porimplementar simultaneamente as duas interfaces, permitindo desta forma tanto aleitura quanto a escrita no arquivo. Os construtores da classe são os seguintes: public RandomAccessFile(File file, String mode) throws IOException public RandomAccessFile(String name, String mode) throws IOException Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 129 O primeiro construtor recebe um objeto da classe File e um objeto daclasse String especificando o modo de acesso do arquivo. O acesso direto seráfeito sobre o objeto da classe Files. Os modos acesso possíveis são: modo deleitura, especificado pela String “r” e modo de leitura e escrita, especificadopela String “rw”. O segundo construtor recebe um objeto da classe Stringcontendo o nome do arquivo e outro objeto da classe String especificando omodo de acesso do arquivo. Ambos os construtores lançam a exceçãoIOException. A maioria dos métodos implementados por RandomAccessFile sãoimplementados pela classe FileInputStream ou pela classeFileOutputStream, uma vez que ela lida tanto com leitura como saída,porém, a classe RandomAccessFile possui alguns métodos adicionais quepermitem definir a posição corrente no arquivo e estabelecer onde serálido/escrito o próximo dado. A tabela V.1 mostra os métodos da classeRandomAccessFile.Método Descriçãoclose() Fecha o arquivo.getFD() Retorna o descritor arquivo objeto associado com este stream.getFilePointer() Retorna a posição corrente neste arquivo.length() Retorna o tamanho deste arquivo.read(byte[] b, int Lê até len bytes em um array de bytes.off, int len)read() Lê um byte.read(byte[] b) Lê até to b.length bytes em um array de bytes.readBoolean() Lê um boolean.readByte() Lê um um byte.readChar() Lê um caracter Unicode.readDouble() Lê um double.readFloat() Lê um float.readFully(byte[] b, Lê exatamente len bytes no array byte.int off, int len)readFully(byte[] b) Lê b.length bytes no array byte.readInt() Lê um inteiro de 32-bit com sinal.readLine() Lê a próxima linha de texto.readLong() Lê um inteiro com sinal de 64-bits. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 130readShort() Lê um inteiro com sinal de 16-bits.readUnsignedByte() Lê um inteiro sem sinal de 8-bits.readUnsignedShort() Lê um inteiro sem sinal de 16-bits.readUTF() Lê um String usando a codificação UTF-8.seek(long pos) Define pos como a posição em bytes no arquivo onde será feita a próxima leitura/escrita.skipBytes(int n) Salta exatamente n bytes.write(int b) Escreve um byte.write(byte[] b, int Escreve len bytes do array iniciando em off.off, int len)write(byte[] b) Escreve b.length bytes do array.writeBoolean(boolean Escreve um boolean como um valor 1-byte.v)writeByte(int v) Escreve um byte como um valor 1-byte.writeBytes(String s) Escreve uma String como uma sequência de bytes.writeChar(int v) Escreve um caractere como um valor 2-byte, byte alto primeiro.writeChars(String s) Escreve uma String como uma sequência de caracteres.writeDouble(double Escreve um double como um valor de 8-bytes.v)writeFloat(float v) Escreve um float como um valor de 4-bytes.writeInt(int v) Escreve um inteiro como quatro bytes.writeLong(long v) Escreve um long como oito bytes.writeShort(int v) Escreve um short como dois bytes.writeUTF(String str) Escreve uma String usando a codificação UTF-8. Tabela V.1 – Métodos públicos da classe RandomAccessFile. O Exemplo V.5 mostra o uso da classe RandomAccessFile paraacessar o byte no meio do arquivo.import java.io.*;class RandomTeste{ public static void main (String args[]) { if (args.length ==0) { System.err.println("Forneça o nome do arquivo!"); System.exit(0); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 131 } try { RandomAccessFile f = new RandomAccessFile(args[0], "r"); long tam = f.length(); if (tam==0) { System.out.println("Arquivo vazio!"); } else { f.seek(tam>>1); System.out.println("O byte no meio é: "+f.read()); } } catch (Exception e) { System.out.println("Erro: " + e.toString()); }} Exemplo V.1 – Uso da classe RandomAccessFile. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 132Capítulo VI – java.util O pacote java.util reúne um conjunto interessante de classes einterfaces úteis ao desenvolvimento de aplicações. Contém recursos para lidarcom coleções, data e hora, internacionalização, arrays de bits, tokenização decadeias de caracteres e etc. Nesta seção abordaremos as classes e interfaces maisutilizadas.Lidando com Coleções Antigamente, era muito comum que, durante o desenvolvimento de umsistema, os programadores tivessem a necessidade de implementar uma estruturade dados como uma lista, pilha ou tabela hash para agrupar e gerenciar umconjunto de elementos. Como as primeiras linguagens de programação nãopossuíam recursos para que se implementasse estas estruturas de forma genérica,de modo que pudessem ser usadas independentemente do tipo dos elementos, oprogramador era obrigado a implementar deste o início toda a estrutura paracada novo tipo de elemento. Com as linguagens de programação mais recentes este quadro mudou. Asnovas linguagens permitem que o programador implemente estruturas de dadosgenéricas, independentes de tipos. Além disso, a maioria delas já implementam,embutidas na linguagem ou na forma de bibliotecas, as estruturas de dados maiscomuns. Este é o caso da linguagem Java que possui, dentro do pacotejava.util classes e interfaces que implementam estruturas de dados comolistas (List), arrays crescentes (Vector), pilhas (Stack), tabela hash(Hashtable) e etc. O pacote possui também interfaces para percorrer oselementos das estruturas (Iterator e Enumeration). Apresentaremos aquiapenas as classes e interfaces mais usadas.As Interfaces Iterator e Enumeration As interfaces Iterator e Enumeration são usadas na criação deobjetos que tem por objetivo percorrer sequencialmente os elementos de umacoleção. Como ambas as interfaces possuem o mesmo objetivo o leitor deve Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 133estar se perguntando sobre necessidade de existirem duas interfaces. O fato é queaté a versão 1.1 da linguagem Java existia apenas a interface Enumeration.No entanto, como o nome deste tipo de objeto na comunidade de Engenharia deSoftware é iterator a Sun aproveitou para incluir uma interface com este nomena versão 1.2 e fazer algumas pequenas modificações. O métodos que devem ser implementados em cada interface sãosemelhantes e estão descritos nas tabelas VI.1 e VI.2.Método Descriçãoboolean hasMoreElements() Testa se Enumeration possui mais elementos.Object nextElement() Retorna o próximo elemento da Enumeration. Tabela VI.1 – Métodos da interface Enumeration.Método Descriçãoboolean hasNext() Testa se Iterator possui um próximo elemento.Object next() Retorna o próximo elemento do Iterator.void remove() Remove da coleção associada o último elemento retornado pelo Iterator. Tabela VI.2 – Métodos da interface Iterator. Um objeto que implementa a interface Enumeration é retornado poralguma classe que implementa uma estrutura de dados sempre que invocamos ométodo elements() da classe. Por exemplo, suponha que desejamos imprimiros elementos reunidos por um objeto v da classe Vector. O trecho de códigopara cumprir essa tarefa poderia ter a seguinte forma:for (Enumeration e = v.elements() ; e.hasMoreElements() ;){ System.out.println(e.nextElement());} Já no caso da interface é preciso usar o método iterator() herdadopor toda subclasse da interface Collection. Neste caso o trecho de códigopara cumprir essa tarefa poderia ter a seguinte forma: for (Iterator it = v.iterator() ; it.hasNext() ;) { System.out.println(it.next()); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 134 }Vectorpublic class Vectorextends AbstractListimplements List, Cloneable, Serializable A classe Vector implementa um array dinâmico. Ou seja, um array quecresce ou diminui a medida da necessidade. O uso de objetos classe Vector éindicado para situações onde o programador precisa manter uma lista deelementos mas não sabe, a priori, o número de elementos que pertencerão à listaou o número de elementos da lista irá variar durante o processamento.Hierarquiajava.lang.Object | +--java.util.AbstractCollection | +--java.util.AbstractList | +--java.util.VectorConstrutoresConstrutor Descriçãopublic Vector() Constrói um Vector vazio com espaço inicial para 10 elementos e incremento 0.public Vector(Collection c) Constrói um Vector contendo os elementos do objeto do tipo Collection.public Vector(int iniCapac) Constrói um Vector vazio com espaço inicial para iniCapac elementos e incremento 0.public Vector(int iniCapac, Constrói um Vector vazio com espaço inicial int inc) para iniCapac elementos e incremento inc. Tabela VI.3 – Construtores da classe Vector. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 135AtributosAtributo Descriçãoprotected int capacityIncrement Quantidade que é incrementada à capacidade do Vector toda vez que o tamanho se torna maior que a capacidade.protected int elementCount Número de elementos referenciadosprotected Object[] elementData Array onde são armazenadas as referencias aos elementos. Tabela VI.4 – Atributos públicos da classe Vector.Métodos Devido ao grande número de métodos da classe Vector mostraremosapenas os mais usados.Método Descriçãovoid add(int i, Object o) Adiciona um elemento na posição indicada por i.public boolean add(Object Adiciona um elemento no final do Vector.o)public boolean Adiciona todos os elementos da coleção especificada addAll (Collection c) no final do Vector.public void Adiciona um elemento no final do Vector. addElement(Object o)public int capacity() Retorna a capacidade atual.public void clear() Remove todos os elementos do Vector.public Object clone() Retorna um clone do Vector.public boolean Testa se o objeto é um elemento do Vector. contains(Object o)public boolean Retorna true se o Vector contém todos oscontainsAll(Collection c) elementos referenciados por c.public void Copia os elementos do Vector no array. copyInto (Object[] a)public Object Retorna o elemento na posição i. elementAt(int i)public Enumeration Retorna um objeto do tipo Enumeration queelements() permite percorrer os elementos do Vector.public void Aumenta a capacidade do Vector para o valor min.ensureCapacity(int min)public boolean Compara se o é igual ao Vector. Retorna trueequals(Object o) somente se o objeto é também do tipo List, possui o mesmo tamanho e referencia os mesmos elementos na mesma ordem. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 136public Object Retorna o primeiro elemento.firstElement()public Object get(int i) Retorna o elemento da posição i.public int Retorna a posição da primeira ocorrência de o. O indexOf(Object o) método equals() do objeto é usado para o teste de igualdade.public int indexOf(Object Retorna a posição da primeira ocorrência de o a partiro,int i) de i. O método equals() do objeto é usado para o teste de igualdade.public void Insere o objeto o na posição i.insertElementAt(Object o,int i)public boolean isEmpty() Testa se o Vector está vazio.public Object Retorna o último elemento.lastElement()public int Retorna a posição da última ocorrência de o. OlastIndexOf(Object o) método equals() do objeto é usado para o teste de igualdade.public Object remove(int Remove o elemento da posição i.i)public boolean Remove todos os elementos que também pertencem àremoveAll(Collection c) Collection.public void Remove todos os elementos.removeAllElements()public void Remove o elemento da posição i.removeElementAt(int i)public boolean Mantém apenas os elementos que também pertencemretainAll(Collection c) à Collection.public Object set(int i, Substitui o objeto na posição i pelo objeto o.Object o)public void setSize(int Define o tamanho do Vector.s)public int size() Retorna o tamanho do Vector.public List subList(int Retorna uma parte dos elementos do Vector entrei, int f) fromIndex, inclusive, e toIndex, exclusive.public Object[] toArray() Retorna um array contendo todos os elementos no Vector na ordem correta.public String toString() Retorna uma representação na forma de String do Vector. Tabela VI.5 – Métodos da classe Vector.Exemplo Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 137 O exemplo a seguir mostra a inserção das strings passadas pela linha decomando em um objeto da classe Vector. Os elementos do objeto Vectorpodem ser exibidos na tela invocando o método print().import java.util.*;public class TesteVector{ Vector v; public TesteVector(String a[]) { v = new Vector(a.length); v.copyInto(a); } public void print() { for (Iterator it = v.iterator(); it.hasNext() ;) { System.out.println((String)it.next()); } } public static void main(String args[]) { TesteVector teste = new TesteVector(args); teste.print(); }} Exemplo VI.xx – Uso do Vector.Stackpublic class Stackextends Vector A classe Stack implementa a estrutura de dados pilha. Ou seja, umaestrutura de dados que segue a regra LIFO (last-in-first-out – último a entrar,primeiro a sair). Esta regra impõe define uma lista que é acessada apenas poruma extremidade, de modo que o último elemento a ser inserido na pilha tenhaque ser o primeiro elemento a sair. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 138Hierarquiajava.lang.Object | +--java.util.AbstractCollection | +--java.util.AbstractList | +--java.util.Vector | +--java.util.StackConstrutorConstrutor Descriçãopublic Stack() Constrói um Stack vazio. Tabela VI.6 – Construtor da classe Stack.MétodosMétodo Descriçãopublic boolean empty() Testa se a Stack está vazia.public Object peek() Retorna uma referência para o elemento no topo da Stack sem retirá-lo.public Object pop() Retorna uma referência para o elemento no topo da Stack e o retira.public Object Insere o objeto o no topo da Stack. push(Object o)public int Retorna a distância do topo da pilha da primeira search(Object o) ocorrência de o. O elemento no topo da pilha possui a distância 1. O método equals() do objeto é usado para o teste de igualdade. Tabela VI.5 – Métodos da classe Stack.Exemplo Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 139 O exemplo a seguir mostra a inserção das strings passadas pela linha decomando em um objeto da classe Stack. Os elementos do objeto Stackpodem ser exibidos na tela invocando o método print().import java.util.*;public class TesteStack{ Stack s; public TesteStack(String a[]) { s = new Stack(); for (int i=0; i<a.length; i++) s.push(a); } public void desempilha () { String aux = (String)s.pop(); while (aux !=null) { System.out.println(aux); } } public static void main(String args[]) { TesteStack teste = new TesteStack(args); teste.desempilha(); }} Exemplo VI.xx – Uso do Stack.Hashtablepublic class Hashtableextends Dictionaryimplements Map, Cloneable, Serializable A classe Hashtable implementa uma estrutura de dados conhecidacomo tabela hash. Neste tipo de estrutura todo elemento armazenado possui uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 140chave que permite recuperar diretamente o elemento, sem a necessidade de irexaminando cada elemento armazenado até encontrar o elemento desejado,como seria o caso em uma lista. Cada chave identifica apenas um elemento.Existem vários bons livros sobre estruturas de dados nas livrarias que o leitorpode consultar para se aprofundar no tema.Hierarquiajava.lang.Object | +--java.util.Dictionary | +--java.util.HashtableConstrutoresConstrutor Descriçãopublic Hashtable() Constrói um Hashtable vazio com fator de carga 0,75.public Hashtable(int capac) Constrói um Hashtable com capacidade inicial capac e com fator de carga 0,75.public Hashtable(int capac, Constrói um Hashtable com capacidade float fatCarga) inicial capac e com fator de carga fatCarga.public Hashtable(Map m) Constrói um Hashtable com os elementos de m. Tabela VI.xx – Construtores da classe Hashtable.Métodos Devido ao grande número de métodos da classe Hashtable mostraremosapenas os mais usados.Método Descriçãopublic void clear() Remove todos os elementos do Hashtable.public Object clone() Retorna um clone raso do Hashtable.public boolean Testa se o objeto é acessado por alguma chave do contains(Object o) Hashtable.public boolean Testa se o objeto é chave no Hashtable. containsKey(Object o) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 141public boolean Testa se o objeto é acessado por alguma chave docontainsValue(Object o) Hashtable.public Enumeration Retorna um objeto do tipo Enumeration queelements() permite percorrer os elementos do Hashtable.public Set entrySet() Retorna um Set contendo os elementos do Hashtable.public boolean Compara se o é igual ao Hashtable. Retorna trueequals(Object o) somente se o objeto é também do tipo Map e faz o mesmo mapeamento.public Object get(Object Retorna o elemento da posição mapeado pela chavekey) key.public boolean isEmpty() Testa se o Hashtable está vazio.public Enumeration keys() Retorna um objeto do tipo Enumeration que permite percorrer as chaves do Hashtable.public Set keySet() Retorna um Set contendo as chaves do Hashtable.public Object put(Object Insere o objeto o no Hashtable tendo como chavekey,Object o) key.protected void rehash() Reorganiza internamente o Hashtable para acessar e acomodar os elementos mais eficientemente.public Object Remove o elemento que tem como chave key.remove(Object key)public int size() Retorna o número de chaves do Hashtable.public String toString() Retorna uma representação na forma de String do Hashtable.public Collection Retorna um Collection contendo os elementos dovalues() Hashtable. Tabela VI.xx – Métodos da classe Hashtable.Exemplos O exemplo a seguir mostra a inserção das objetos da classe Integer emum objeto Hashtable. A chave usada para cada objeto é o número porextenso. Hashtable numbers = new Hashtable(); numbers.put("one", new Integer(1)); numbers.put("two", new Integer(2)); numbers.put("three", new Integer(3)); ... Integer n = (Integer)numbers.get("two"); if (n != null) { System.out.println("two = " + n); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 142 } ... for (Enumeration e = numbers.elements();e.hasMoreElements();){ Integer i = (Integer)e.nextElement() System.out.println( i.toString()); } Exemplo VI.xx – Uso do Hashtable. O exemplo a seguir mostra a inserção das objetos da classe Pessoa emum objeto Hashtable. A chave usada para cada objeto é o nome da pessoa.class pessoa { String nome; String tel; public pessoa(String nome, String tel) {this.nome = nome; this.tel = tel;} public String getNome(){return nome;} public String getTel(){return tel;}} ... Hashtable pessoas = new Hashtable(); ... pessoa P1 = new pessoa("Pedro", "899-1313"); pessoas.put(P1.getNome(), P1); ... pessoa P2 =(pessoa) pessoas.get("Pedro"); if (P2!=null) System.out.println ("Nome:"+P2.getNome(), "nTel:"+P2.getTel()); Exemplo VI.xx – Uso do Hashtable.Miscelânea de Classes do pacote java.utilArrayspublic class Arraysextends Object Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 143 Esta classe foi inserida no pacote java.util a partir da versão 1.2 doSDK. É uma classe utilitária, fornecendo métodos de ordenação e busca emarrays.Hierarquiajava.lang.Object | +--java.util.ArraysMétodosMétodo Descriçãopublic static List asList(Object[] a) Retorna uma List criada a partir do array.public static int Realiza uma pesquisa binária retornando a binarySearch(byte[] a, byte key)public static int posição de key no array. binarySearch(char[] a, char key)public static int binarySearch(double[] a, double key)public static int binarySearch(float[] a, float key)public static int binarySearch(int[] a, int key)public static int binarySearch(long[] a, long key)public static int binarySearch(Object[] a, Object key)public static int binarySearch(short[] a, short key)public static int Realiza uma pesquisa binária retornando a binarySearch(Object[] a, Object key, Comparator c) posição de key no array. O array tem que estar ordenado ascendentemente de acordo com o Comparator.public static boolean Retorna true se os dois arrays são iguais. equals(boolean[] a, boolean[] a2)public static boolean equals(byte[] a, byte[] a2)public static boolean equals(char[] a, char[] a2)public static boolean equals(double[] a, double[] a2)public static boolean equals(float[] a, float[] a2)public static boolean equals(int[] a, int[] a2)public static boolean equals(long[] a, long[] a2)public static boolean equals(Object[] a, Object[] a2) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 144public static boolean equals(short[] a, short[] a2)public static void Preenche o array com o valor especificado. fill(boolean[] a, boolean val)public static void fill(byte[] a, byte val)public static void fill(double[] a, double val)public static void fill(float[] a, float val)public static void fill(int[] a, int val)public static void fill(long[] a, long val)public static void fill(Object[] a, Object val)public static void fill(short[] a, short val)public static void fill(boolean[] a, Preenche o array com o valor especificado a int ini, int fim, boolean val)public static void fill(byte[] a, partir do elemento de índice ini inclusive int ini, int fim, byte val) até o elemento de índice fim exclusive.public static void fill(double[] a, int ini, int fim, double val)public static void fill(float[] a, int ini, int fim, float val)public static void fill(int[] a, int ini, int fim, int val)public static void fill(long[] a, int ini, int fim, long val)public static void fill(Object[] a, int ini, int fim, Object val)public static void fill(short[] a, int ini, int fim, short val)public static void sort(byte[] a) Ordena o array em ordem ascendente.public static void sort(double[] a)public static void sort(float[] a)public static void sort(int[] a)public static void sort(long[] a)public static void sort(Object[] a)public static void sort(short[] a)public static void Ordena o array em ordem ascendente a sort(byte[] a, int ini, int fim)public static void partir do elemento de índice ini inclusive sort(double[] a, int ini, int fim) até o elemento de índice fim exclusive.public static void sort(float[] a, int ini, int fim)public static void sort(int[] a, int ini, int fim)public static void sort(long[] a, int ini, int fim)public static void sort(Object[] a, int ini, int fim)public static void sort(short[] a, int ini, int fim)public static void sort(Object[] a, Ordena o array em ordem ascendente Comparator c) definida pelo objeto Comparator.public static void sort(Object[] a, Ordena o array em ordem ascendente int ini, int fim, Comparator c) definida pelo objeto Comparator a partir do elemento de índice ini inclusive Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 145 até o elemento de índice fim exclusive. Tabela VI.5 – Métodos da classe Arrays. O algoritmo de ordenação O algoritmo de ordenação é uma variação quicksort apresentado por Jon L. Bentley eM. Douglas McIlroys "Engineering a Sort Function", Software-Practice and Experience, Vol.23(11) P. 1249-1265 (November 1993). Este algoritmo possui complexidade n*log(n) emconjunto de dados que causariam a degradação de outros algoritmos de quicksort para umdesempenho de ordem quadrática.Exemplo O exemplo a seguir mostra a impressão ordenada das strings passadaspela linha de comando.import java.util.arrays;class TestArrays{ public static void main(String a[]) { if(a.length>0) { Arrays.sort(a); for(int i=0;i<a.length; i++) System.out.println(a[i]); } }} Exemplo VI.xx – Uso do Arrays.Datepublic class Dateextends Objectimplements Serializable, Cloneable, Comparable Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 146 Esta classe é responsável pela representação da data com precisão demilisegundos. Antes da versão 1.1 do SDK a classe Date também tinha asfunções de formatação e análise de datas no tipo String assim como deinterpretar as datas em anos, meses, dias, horas, minutos e segundos. Devido àcomplexidade da internacionalização estas funções foram transferidas para asclasses DateFormat e Calendar. O métodos da classe Date que realizavamessas funções tornaram-se deprecated. A data base padrão, a partir da qual sãocontados os milisegundos é 01/01/1970, 00:00:00 GMT.Hierarquiajava.lang.Object | +--java.util.DateConstrutores Os construtores deprecated não estão listados.Construtor Descriçãopublic Date() Constrói um Date representando a data do momento de sua alocação.public Date(long data) Constrói um Date contendo a data calculada a partir número de millisegundos representados por data tendo como base a data 01/01/1970, 00:00:00 GMT. Tabela VI.xx – Construtores da classe Date.Métodos Os métodos deprecated não estão listados.Método Descriçãopublic boolean after(Date d) Testa se a data é anterior à data passada como argumento.public boolean before(Date d) Testa se a data é posterior à data passada como argumento.public Object clone() Cria um clone do objeto.public int compareTo(Date d) Compara duas datas. Retorna 0 se as duas Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 147 datas são iguais. Retorna um valor maior que 0 se a data passada como argumento é menor e um valor menor que 0 se data passada como argumento e maior.public boolean equals(Object o) Retorna true se duas datas são iguais.public long getTime() Retorna o número de milisegundos desde 01/01/1970, 00:00:00 GMT até a data representada pelo objeto corrente.public void setTime(long time) Define a data desde objeto usando o número de milisegundos desde 01/01/1970, 00:00:00 GMT passado como argumento. Tabela VI.5 – Métodos da classe Date.Exemplo O exemplo a seguir exibe a representação da data corrente emmilisegundos.import java.util.Date;class TestDate{ public static void main(String a[]) { System.out.println(new Date().getTime()); }} Exemplo VI.xx – Uso da classe Date.Observablepublic class Observableextends Object A classe Observable permite criar objetos “observáveis”. Objetoobservável é um objeto que, quando sofre alguma alteração, notifica outrosobjetos, chamados de “observadores”. Os objetos observáveis e observadoresfazem parte do padrão de projeto conhecido como MVC (Modelo–Visão–Controle) introduzido na linguagem Smalltalk. A utilização deste padrão de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 148projeto facilita a implementação programas onde um modelo possui váriasvisões que devem ser atualizadas toda vez que o modelo muda. O controle atuasobre o modelo, ocasionando alterações. Por exemplo, suponha que modelo quearmazene os valores de ações da bolsa. Podemos exibir várias visões dessesdados, como gráficos de barras e em forma de pizza. Os controladoresmodificariam o modelo que em seguida notificaria as visões para refletirem oestado atual do modelo. As figuras VI.XX e VI.XX ilustram esquematicamenteo padrão MVC. Na linguagem Java, para um objeto ser um observador é precisoimplementar a interface Observer. Visão Controle Modelo Visão Controle Figura VI.XX – Esquema do padrão MVC. window X window X a b a=30; x 30 45 b=45; a b Observável Figura VI.XX – Duas formas de visualização de um modelo. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 149Hierarquiajava.lang.Object | +--java.util.ObservableConstrutorConstrutor Descriçãopublic Observable() Constrói um Observable possuindo zero observadores. Tabela VI.XX – Construtor da classe Observable.MétodosMétodo Descriçãopublic void Adiciona um observador ao conjunto deaddObserver(Observer o) observadores do objeto.protected void clearChanged() Limpa a indicação de que o objeto mudou.public int countObservers() Retorna o número de objetos observadores deste objeto.public void Remove o objeto passado como argumentodeleteObserver(Observer o) do conjunto de objetos observadores.public void deleteObservers() Remove todos os objetos observadores do conjunto de objetos observadores.public boolean hasChanged() Retorna true se o objeto sofreu uma mudança.public void notifyObservers() Se o método hasChanged() retornar true notifica todos os objetos observadores e chama o método clearChanged().public void Se o método hasChanged() retornarnotifyObservers(Object arg) true notifica todos os objetos observadores e chama o método clearChanged(). O objeto arg é passado como argumento para o método update() do observador.protected void setChanged() Marca este objeto como tendo sofrido uma mudança. Tabela VI.XX – Métodos da classe Observable. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 150Exemplo O exemplo VI.xx mostra uma classe Observavel que muda de valoraleatoriamente. A classe implementa a interface Runnable, uma vez que seráexecutada concorrentemente. A concorrência será abordada detalhadamente noCapítulo XI.import java.util.*;public class Observavel extends Observable implements Runnable{ int valor =0; public void notifyObservers() { setChanged(); super.notifyObservers(); } public int getValue(){return valor;} public void run() { for(;;) { if (Math.random()>0.5) { valor =(new Double(Math.random()*200)).intValue(); this.notifyObservers(); } try {Thread.sleep(300);} catch(Exception e){}; } }} Exemplo VI.xx – Uma classe Observable. O exemplo a seguir mostra uma classe que define um observador. Paraisso é necessário implementar a interface Observer, cujo único método a sercodificado é o método update(). Este método é chamado quando o objetoobservado notifica alguma alteração. No exemplo o objeto observador simulauma barra de progresso que movimenta de acordo com a mudança do valor doobjeto observado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 151import java.awt.*;import java.util.*;public class FrameOb extends Frame implements Observer{ Observavel ob = new Observavel(); Thread t = new Thread(ob); Canvas progress = new Canvas(); public FrameOb() { setLayout(null); setSize(300,60); add(progress); progress.setBackground(Color.blue); progress.setBounds(0,0,0,30); setTitle("Exemplo de Observável"); SymWindow aSymWindow = new SymWindow(); this.addWindowListener(aSymWindow); ob.addObserver(this); t.start(); } static public void main(String args[]) { (new FrameOb()).setVisible(true); } class SymWindow extends java.awt.event.WindowAdapter { public void windowClosing(java.awt.event.WindowEvent event) { System.exit(0); } } public void update(Observable o, Object arg) { progress.setSize(ob.getValue(), 100); }} Exemplo VI.xx – Uso da classe Observable.StringTokenizer Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 152public class StringTokenizerextends Objectimplements Enumeration A StringTokenizer é uma classe que permite quebrar uma cadeia decaracteres em subcadeias denominadas de tokens. um token é uma subcadeiacercada por caracteres denominados delimitadores. Portanto, o que é um tokendependerá da especificação dos delimitadores. Por exemplo, dada cadeia decaracteres “ola mundo,ola vida” teremos os tokens “ola mundo” e“ola vida” caso o delimitador seja o caractere ‘,’ e os tokens “ola”,“mundo,ola” e “vida” caso o delimitador seja o caractere ‘ ’Hierarquiajava.lang.Object | +--java.util.StringTokenizerConstrutoresConstrutor Descriçãopublic Constrói um StringTokenizer para s.StringTokenizer(String s)public Constrói um StringTokenizer para s,StringTokenizer(String s,String del) usando como delimitadores os caracteres contidos em del.public StringTokenizer Constrói um StringTokenizer para s, (String s, String del, boolean voltaTokens) usando como delimitadores os caracteres contidos em del. Se voltaTokens possui o valor true, então os caracteres contidos em del também são retornados. Tabela VI.XX – Construtores da classe StringTokenizer.MétodosMétodo Descrição Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 153public int countTokens() Retorna o número de tokens.public boolean Mesmo efeito que hasMoreTokens().hasMoreElements()public boolean hasMoreTokens() Retorna true se existir mais tokens.public Object nextElement() Retorna o próximo token como uma instância de Object.public String nextToken() Retorna o próximo token como uma instância de String.public String nextToken(String Retorna o próximo token como uma instânciadel) de String usando como delimitadores os caracteres contidos em del. Tabela VI.XX – Métodos da classe StringTokenizer.Exemploimport java.util.*;public class TestToken{ static public void main(String args[]) { StringTokenizer st = new StringTokenizer("ola mundo louco"); while (st.hasMoreTokens()) println(st.nextToken()); }}Saída:olamundolouco Exemplo VI.XX – Uso da classe StringTokenizer.Agenda Eletrônica versão Console 2.0 Neste ponto já estamos preparados para fazer alguns aperfeiçoamentos nanossa agenda eletrônica de endereços. As alterações serão de dois tipos:passaremos a utilizar um objeto da classe Hashtable para agrupar as pessoasda agenda, e acrescentaremos métodos para gravar e recuperar os dados da Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 154agenda em um arquivo. Estas modificações acarretarão mudanças apenas noscódigos das classes Agenda e AgendaInt. O diagrama de classes da figuraIV.XX mostra as adições dos métodos gravarAgenda() erecuperarAgenda(), responsáveis pela gravação e recuperação dos dadosem arquivo. AgendaInt Pessoa+obterPessoa() Agenda+exibirLista() 0..* -String Nome+exibirPessoa() +inserir(pessoa p) -String Tel+gravarAgenda() +getPessoas() -String End+recuperarAgenda() +getPessoa(String Nome) +getNome() +getTel() +getEnd() Figura VI.xx – Diagrama de classes da versão console 2.0 da agenda eletrônica. Como a classe Pessoa não sofrerá nenhuma modificação. Ela éapresentada abaixo apenas por questões de comodidade./** Pessoa*/public class Pessoa{ private String Nome; private String Tel; private String End; // Construtor public Pessoa(String n, String t, String e) { Nome = n; Tel = t; End = e; } /** getNome */ public String getNome(){return Nome;} /** getNome Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 155 */ public String getTel(){return Tel;} /** getEnd */ public String getEnd(){return End;}} A classe Agenda será alterada de modo que o a associação deagrupamento com a classe Pessoa seja implementada por meio de um objeto daclasse Hashtable e não por um array./** AGENDA Versão Console 2.0.*/import java.util.*;public class Agenda{ Hashtable pessoas; // Construtor public Agenda() {pessoas = new Hashtable();} /** inserir */ public void inserir(Pessoa p) {pessoas.put(p.getNome(),p);} /** Consultar */ public Pessoa getPessoa(String nome) {return (Pessoa) pessoas.get(nome);} /** listar */ public Enumeration getPessoas(){return pessoas.elements();}} Podemos notar que o código fica bem mais simples com a adoção dainstância da classe Hashtable. Foi alterada a assinatura do métodogetPessoas(), de modo que não mais retorna um array e sim um objeto da Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 156classe Enumeration. A classe AgendaInt será alterada para tratar o retornodo método getPessoas() e receberá mais dois novos métodos. O métodomain() também será alterado para receber solicitações para a execução dasnovas funções./** AgendaInt Interface console da agenda.*/import java.io.*;import java.util.*;public class AgendaInt{ Agenda ag; BufferedReader in; // Construtor public AgendaInt() { ag = new Agenda(); in = new BufferedReader(new InputStreamReader(System.in)); } /** Exibirlista */ public void Exibirlista() { Pessoa p; for(Enumeration e = ag.getPessoas(); e.hasMoreElements();) { p = (Pessoa) e.nextElement(); System.out.println("nNome:"+p.getNome()+"nTelefone:" +p.getTel()+"nEndereço:"+p.getEnd()+"n"); } } /** exibirPessoa */ public void exibirPessoa() { String nome=null; try { System.out.println("Entre com o nome:"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 157 nome = in.readLine(); if (nome.length()<1) System.exit(-1); } catch(IOException e) {System.out.println(e.getMessage());System.exit(-1);} Pessoa p = ag.getPessoa(nome); if (p!=null) { System.out.println("nNome:"+p.getNome()+"nTelefone:" +p.getTel()+"nEndereço:"+p.getEnd()); }}/** obterPessoa*/public void obterPessoa(){ String nome; String tel; String end; try { System.out.println("Entre com o nome:"); System.out.flush(); nome = in.readLine(); if (nome.length()<1) System.exit(-1); System.out.println("nEntre com o Telefone:"); System.out.flush(); tel = in.readLine(); System.out.println("nEntre com o Endereço:"); System.out.flush(); end = in.readLine(); ag.inserir(new Pessoa(nome ,tel,end)); } catch(IOException e) {System.out.println(e.getMessage());System.exit(-1);}}/** gravar*/public void gravar(){ try { Pessoa p; BufferedWriter fout = new BufferedWriter( new FileWriter("agenda.dat")); for (Enumeration e = ag.getPessoas(); e.hasMoreElements();) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 158 { p = (Pessoa) e.nextElement(); fout.write(p.getNome()+"n"+p.getTel()+"n" +p.getEnd()+"n"); } fout.flush(); fout.close(); } catch(FileNotFoundException e) { System.out.println("Arq. Não encontrado");} catch(IOException e) {System.out.println("Erro na gravação!");}}/** carregar*/public void carregar(){ try { String nome; String tel; String end; BufferedReader fin = new BufferedReader( new FileReader("agenda.dat")); while ((nome = fin.readLine()) != null) { tel = fin.readLine(); end = fin.readLine(); ag.inserir(new Pessoa(nome,tel,end)); } fin.close(); } catch(FileNotFoundException e) {System.out.println("Arq. Não encontrado");} catch(IOException e) {System.out.println("Erro na leitura!"); }}// mainpublic static void main(String args[]){ AgendaInt agInt = new AgendaInt(); String opcao=""; for(;;) { System.out.println( Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 159 "nAgenda Tabajaran***********************n"); System.out.print("Opcoes:n(i)nserirn(c)onsultar"+ "n(l)istarn(g)ravarn(r)ecuperarn(f)im=>"); System.out.flush(); try { opcao = agInt.in.readLine(); if (opcao.length()==0) continue; } catch(IOException e) {System.out.println(e.getMessage());System.exit(-1);} switch(opcao.charAt(0)) { case f: System.exit(0); break; case i: agInt.obterPessoa(); break; case c: agInt.exibirPessoa(); break; case l: agInt.Exibirlista(); break; case g: agInt.gravar(); break; case r: agInt.carregar(); break; } } }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 160Capítulo VII - Serialização ePersistência Um objeto é serializável se podemos transformá-lo em uma sequência debytes de modo que seja possível o seu armazenamento em arquivo ou envioatravés de um stream. Desta forma o estado do objeto pode ser preservado emmemória não volátil. Neste caso dizemos que o objeto possui persistência, ouseja o estado do objeto persiste enter as execuções do programa. A persistênciaimplementada pela serialização é chamada de persistência leve, uma vez que oprogramador deve providenciar o armazenamento. Em uma persistênciacompleta o programador apenas informa ao sistema que o objeto é persistente,ficando a cargo do ambiente o armazenamento e recuperação do objeto de formatransparente. A serialização de objetos foi adicionada à linguagem Java a partir daversão 1.1 com o intuito de possibilitar a transmissão de objetos entre máquinasexecutando diferentes plataformas operacionais, viabilizando dessa forma o RMI(Remote Method Invocation) e permitir a utilização JavaBeans, que sãocomponentes configuráveis em tempo de execução, e que mantém aconfiguração entre ativações. Para que os objetos de uma classe sejam serializáveis basta que a classeimplemente a interface Serializable. A partir de então é possívelarmazenar e recuperar os objetos da classe por meio de instâncias das classesObjectOutputStream e ObjectInputStream, respectivamente. Oexemplo VII.1 mostra como armazenar e recuperar um objeto da classe Pessoaem um arquivo p.dat.class pessoa implements Serializable{ String Nome; String Tel; public pessoa(String Nome, String Tel) {this.Nome = Nome; this.Tel = Tel;}} ... Pessoa p = new pessoa(“Ana”,”234-6757”); FileOutputStream fout = null; ObjectOutputStream out; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 161 try { fout = new FileOutputStream(”p.dat"); out = new ObjectOutputStream(fout); out.writeObject(p); out.close(); } catch(Exception e) {System.out.println(”Erro:");return;} FileInputStream fin = null; ObjectInputStream in; try { fin = new FileInputStream(”p.dat"); in = new ObjectInputStream(fin); p = (pessoa) in.readObject(); in.close(); } catch(Exception e) { System.out.println(”Erro:”+e); return;} Exemplo VII.1 – Armazenamento e recuperação de um objeto da classe Pessoa. Uma questão interessante é: o que acontece com os objetos que sãoreferenciados pelo objeto que está sendo armazenado? Devem ser armazenadostambém ou não? Se os objetos referenciados não forem armazenados juntos como objeto corrente, a recuperação do mesmo posteriormente poderá resultar emuma instância incompleta. Por exemplo, um objeto do tipo Pessoa comomostrado no exemplo VII.1, referencia dois objetos do tipo String quearmazenam o nome e o telefone da pessoa representada pelo objeto. Se estesobjetos não forem armazenados junto com a instância de Pessoa, qual osentido da posterior recuperação do objeto? Portanto, quando um objeto éarmazenado todos os objetos referenciados por ele também são armazenados,desde que os objetos implementem a interface Serializable. Caso o objetoreferenciado também referencie outro objeto, este último também seráarmazenado, e assim por diante, até que toda os objetos da cadeia de referenciassejam armazenados. Isto pode fazer com que o objeto armazenado ocupe muitomais espaço do que o imaginado inicialmente pelo programador. Outra perguntaseria: o que acontece então quando um objeto é referenciado mais de uma vezou quando acontece um ciclo no grafo de referências? Neste caso, o objeto éarmazenado apenas uma vez. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 162Agenda Eletrônica versão Console 2.1 Com o objetivo de exemplificar o que foi discutido neste capítulo,modificamos a agenda eletrônica para que a gravação e a carga do arquivo sejafeita através da serialização do objeto Agenda. Primeiramente, foi modificadaas classes Pessoa e Agenda de modo que implementassem a interfaceSerializable. Para isto basta importar a interface do pacote java.io emodificar a declaração das classes, como mostrado abaixo. Como o restante docódigo dessas duas classes permanece inalterado, não o repetimos aqui. O leitordeve se reportar às versões anteriores caso deseje recordar sobre o códigoomitido./** Pessoa*/import java.io.*;public class Pessoa implements Serializable{ ... Sem alteração ...}/** AGENDA Versão Console 2.1.*/import java.util.*;import java.io.*;public class Agenda implements Serializable{ ... Sem alteração ...} A classe AgendaInt sofre modificações nos métodos gravar() ecarregar(), que os tornam bem mais simples, uma vez que o trabalho deseguir as referências do objeto da classe Agenda para serializá-los e armazená-los é feito implicitamente. Segue abaixo apenas o código dos métodosmodificados classe AgendaInt. Note que foi preciso usar a hierarquia stream Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 163para gravar e recuperar os objetos, uma vez que não existem classes do tipoObjectReader e ObjectWriter no novo conjunto de classes de E/S./** AgendaInt Interface console da agenda.*/import java.io.*;import java.util.*;public class AgendaInt{ ... Sem alteração ... /** gravar */ public void gravar() { try { ObjectOutputStream fout = new ObjectOutputStream( new FileOutputStream("agenda.dat")); fout.writeObject(ag); fout.close(); } catch(FileNotFoundException e) { System.out.println("Arq. Não encontrado");} catch(IOException e) {System.out.println("Erro na gravação!");} } /** carregar */ public void carregar() { try { ObjectInputStream fin = new ObjectInputStream( new FileInputStream("agenda.dat")); ag = (Agenda) fin.readObject(); fin.close(); } catch(FileNotFoundException e) {System.out.println("Arq. Não encontrado");} catch(Exception e) {System.out.println("Erro na leitura!"); } } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 164 ... Sem alteração ...} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 165Capítulo VIII – AWT (AbstractWindow Toolkit) Até este ponto, todos o exemplos apresentados neste livro foram deaplicações em modo texto, também chamadas de aplicações não gráficas ou deconsole. Hoje em dia, não é possível lançar no mercado uma linguagem deampla aplicação que não possua ferramentas para construção de interfacesgráficas sofisticadas. A linguagem Java além de ter a necessidade de atender esterequisito possui a condição adicional de prover recursos gráficos que permitam odesenvolvimento de interfaces independentes de plataforma. Talvez, devido aesta forte exigência, a primeira versão do pacote que implementa o suportegráfico acabou sendo conhecido como um excelente exemplo de como não sedeve realizar um projeto. O pacote conhecido como AWT 1.0 (Abstract WindowToolkit), não era muito harmônico, tinha um conjunto muito pobre decomponentes gráficos e possuía um modelo para tratamento de eventos muitoineficiente. A versão AWT 1.1 solucionou vários deste problemas, com ooferecimento de um novo modelo para tratamento dos eventos e com aintrodução de um modelo para programação de componentes, denominados deJavaBeans. Na versão 1.2 da linguagem novas facilidades foram incorporadascom a adição de um conjuntos de componentes leves, denominados de Swing, ouJFC (Java Foundation Classes). A denominação de componentes leves para aJFC se deve ao fato dos componentes não utilizarem os componentes nativos daGUI (Graphical User Interface) do ambiente. Eles utilizam primitivas de baixonível para sua construção na tela, obtendo assim um alto nível de portabilidade.Já a AWT utiliza os componentes da GUI (widgets), para sua exibição e por issosão chamados de componentes pesados. Por isso, para atingir uma portabilidaderazoável, apenas componentes básicos estão presentes na AWT. Mesmo assim aportabilidade da AWT não é tão grande quanto a JFC, apresentando, em algunscasos, grandes diferenças de visualização entre ambientes operacionais. Neste capítulo, abordaremos a versão 1.1 do AWT. Os componentes daJFC/Swing serão tratados isoladamente no capítulo XX.A Hierarquia de componentes Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 166 O AWT é um pacote contendo classes e interfaces para a criação de objetospara interação em janelas gráficas. Com essas classes é possível criar e manterobjetos tais como:♦ Botões (Classe Button)♦ Caixa de Escolha (Classe Choice)♦ Diálogos (Classe Dialog)♦ Janelas (Classe Window)♦ Menus (Classe Menu)♦ Barra de Rolamento (Classe Scrollbar)♦ Etc. As classes se organizam em uma hierarquia. A figura VI.XX mostra aorganização hierárquica das classes. ! Color ! Component " Button " Canvas " Checkbox " Choice " Container # Panel # ScrollPane # Window • Dialog ♦ FileDialog • Frame " Label " List " Scrollbar " TextComponent # TextArea # TextField ! MenuComponent " MenuBar " MenuItem # Menu Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 167 Figura VI.1 – Hierarquia das classes no pacote AWT.Olá Mundo AWT Para usar classes definidas na AWT é preciso importá-las: import java.awt.*; Algumas classes são usadas para criar objetos que servirão para conter outrosobjetos. Estas classes são descendentes da classe Container. Cada classepossui um conjunto de atributos que podem ser acessados por meio de métodos.Como de praxe, apresentaremos primeiramente a versão AWT do “olá mundo”para ilustrar os principais componentes de uma aplicação import java.awt.*; class OlaFrame extends Frame { public OlaFrame() { super(“Ola”); setSize(100,50); add(new Label("ola mundo")); } public static void main(String args[]){ new OlaFrame().setVisible(true); } } Exemplo XX.XX – Versão AWT do “Olá mundo”. Para criarmos uma aplicação gráfica precisaremos de algum tipo dejanela para colocarmos os componentes. Por isso a classe OlaFrame doexemplo XX.XX é uma subclasse da classe Frame que, por sua vez, esubclasse da classe Window. A classe Frame implementa uma janela gráficacom título e margem, sendo que a área do Frame inclui a margem. No exemploconstrutor da classe invoca o construtor da superclasse, passando comoargumento o título da janela. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 168 A classe Frame cria uma janela com 0 x 0 pixels e invisível. Paradimensioná-la e torná-la visível é necessário usar os métodos setSize() esetVisible(). A classe Label é usada para criar um objeto de texto que éadicionado ao Frame. O objeto é posicionado dentro do Frame de acordo comum esquema de posicionamento, denominado de layout. Se você executou esteprograma deve ter notado que não foi possível finalizar o programa a não ser pormeio de um Ctrl-C na console ou algum outro método indireto como o kill dashell Unix. Isto acontece porque os objetos gráficos na linguagem Java nãopossuem tratadores implícitos de eventos. Ou seja, se você quer que algumevento seja tratado, então forneça o código para isto. Existem dois modelos para tratamento dos eventos que incidem sobre ainterface. O primeiro foi introduzido na versão 1.0 do AWT e o segundo foiintroduzido na versão 1.1 do AWT com o objetivo de substituir o primeiro, umavez que ele sofre de deficiências de projeto e desempenho. Neste livroabordaremos apenas o modelo de eventos 1.1.Tratamento de Eventos O estilo de programação relacionado com interfaces gráficas é aprogramação voltada para eventos. Ou seja, o usuário define a interface e umconjunto de procedimentos para lidar com os eventos que incidirão sobre ainterface. A construção de uma aplicação gráfica exige a criação de pelo menosum objeto que defina uma área no vídeo para exibir os componentes daaplicação. Para isso pode-se utilizar um objeto da classe Window ou Frame. Oexemplo XX.XX contém o código de um programa que exibe uma mensagem natela. Posteriormente é necessário definir quem deve receber os eventos geradospela interação com a interface. Cada linguagem apresenta uma solução distintapara o tratamento de eventos. A solução Java implementada no modelo deeventos 1.1 é explicada a seguir.Modelo de Eventos 1.1 O Modelo de eventos do AWT1.1 é um grande avanço sobre o modelo1.0. Ele não só é mais flexível e orientado a objetos, como permitiu odesenvolvimento da interface de aplicação JavaBeans, que viabiliza a descriçãode componentes visuais. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 169 A idéia por trás do novo modelo é que uma fonte de eventos possa enviaros eventos para um ou mais objetos cadastrados para o recebimento do evento,denominados de event listeners. Geralmente, a fonte de evento é umcomponente, ou seja, um objeto da classe Component. Um listener é um objetoque implementa a interface EventListener ou alguma de suas sub-interfaces. A figura IV.XX ilustra a estratégia adotada. Componente Listener evento 1 A Listener Listener Componente 2 evento Listener B Listener Figura VI.XX – Esquema de delegação de eventos AWT1.1. Note que um Listener pode estar registrado em mais de umcomponente. Um componente pode ter mais de uma lista de Listener,dependendo dos tipos de eventos que ele pode gerar. Uma ação sobre umcomponente pode gerar mais de um evento. Para ilustrar o tratamento deeventos, o exemplo XX.XX mostra como criar uma janela da classe Frame quetrata o evento para fechar a janela, gerado quando o usuário clica o ícone ×,situado no canto superior direito do Frame.class FrameX extends Frame implements WindowListener{ public FrameX() {this("FrameX");} public FrameX(String Titulo){ super(Titulo); addWindowListener(this); setSize(100,50); } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 170 public void windowOpened(WindowEvent we){} public void windowClosed(WindowEvent we){} public void windowIconified(WindowEvent we){} public void windowDeiconified (WindowEvent we){} public void windowActivated(WindowEvent we){} public void windowDeactivated(WindowEvent we){} public void windowClosing(WindowEvent we){ setVisible(false); dispose(); System.exit(0); }}; Exemplo XX.XX – Código para tratar o evento para fechar a janela. Para simplificar o exemplo o próprio componente (do tipo Frame) seregistrou como um Listener para os eventos gerados por ele. De modo a sehabilitar a receber os eventos gerados por um componente do tipo Window aclasse deve implementar a interface WindowListener que é uma sub-interface da EventListener. class FrameX extends Frame implements WindowListener É preciso também se registrar junto ao componente para receber oseventos. Como no exemplo VI.XX o componente é uma instância da própriaclasse que implementa a interface, basta então adicionar a linhaaddWindowListener(this) no construtor da classe. Como a classeimplementa a interface é necessário incluir código para implementar todos osmétodos da interface. Cada método da interface trata um tipo de evento. No casodo exemplo VI.XX, estamos interessados em tratar eventos que solicitam ofechamento da janela. Portanto, é necessário incluir o código para tratamento doevento neste método. Os outros métodos são implementados sem linhas decódigo, para cumprir a exigência do compilador. Note que todos os métodos daclasse FrameX recebem um tipo de evento: WindowEvent. No modelo deeventos 1.1, na versão SDK1.3, existem 14 classes para os eventos, definidas nopacote java.awt.event, todas subclasses da classejava.awt.event.AwtEvent e cada uma representando um conjunto deeventos relacionados, como mostrado na tabela VI.XX.Evento DescriçãoComponentEvent Indica que um componente moveu, foi escondido, exibido ou mudou de tamanho. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 171FocusEvent Indica que um componente recebeu ou perdeu o foco.KeyEvent Indica que um componente recebeu uma entrada pelo teclado.MouseEvent Indica que um componente recebeu uma entrada pelo mouse.ActionEvent Indica que um componente foi ativado.AdjustmentEvent Indica que uma barra de rolamento ou componente similar foi movido.HierarchyEvent indica uma mudança na hierarquia de componentes a qual o componente pertence.InputEvent É o evento raiz de todos os eventos de entrada de componentes.InputMethodEvent Contém informação sobre o texto que está sendo editado. Sempre que o texto for alterado este evento será enviado.InvocationEvent O evento que executa o método run() em um tipo Runnable quando disparado pelo thread despachador de eventos da AWT.ItemEvent Indica que um item de um componente como lista, checkbox, ou similar foi selecionado.ContainerEvent Indica que um componente foi adicionado ou removido de um container.WindowEvent Indica que a janela mudou de estado.TextEvent Indica que uma mudança ocorreu em um campo de texto. Tabela VI.XX – Classes de Eventos. O exemplo XX.XX mostra o código de uma janela contendo um botão. Aclasse que implementa a janela se cadastra junto ao componente Button parareceber o eventos sobre os componente. Para diminuir a complexidade do códigoa classe FrameBotao é subclasse da FrameX definida anteriormente. Todavez que o componente Button é acionado, gerando um eventoActionEvent, o método actionPerformed() da instânciaFrameBotao é invocado. O método alterna o texto exibido pelo botão a cadachamada entre os textos “Aperte aqui” e “Valeu”. import java.awt.*; import java.awt.event.*; public class FrameBotao extends FrameX implements ActionListener { Button b; public FrameBotao() { setLayout(null); setSize(100,80); b = new Button("Aperte aqui"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 172 add(b); b.setBounds(10,40,80,30); b.addActionListener(this); } public void actionPerformed(ActionEvent e) { if (b.getLabel().equals("Aperte Aqui")) b.setLabel(“Valeu”); else b.setLabel("Aperte Aqui"); } public static void main(String args[]){ (new FrameBotao()).setVisible(true); } } Exemplo XX.XX – Código para tratar um evento gerado em botão.Tratamento de Eventos com classes Internas Agora vamos supor que uma determinada classe necessitasse recebervários eventos de vários componentes. O código da classe poderia ficar umpouco confuso, além da lista enorme de interfaces que necessitariam de serdeclarada após a palavra implements. Uma forma mais elegante de se lidarcom estes casos é por meio de classes internas, ou inner classes. Desta forma, ocódigo para tratar cada grupo de eventos fica localizado em uma única classe, ecomo as classes internas possuem acesso à classe externa, os atributos e métodosda classe externa podem ser diretamente referenciados. O exemplo XX.XXmostra o exemplo XX.XX alterado de forma que o evento ActionEventgerado acionamento do componente Button seja tratado por uma classeinterna. import java.awt.*; import java.awt.event.*; public class FrameBotao extends FrameX { Button b; Public FrameBotao() Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 173 { setLayout(null); setSize(100,80); b = new Button("Aperte Aqui"); add(b); b.setBounds(10,40,80,30); b.addActionListener(new Bl()); } class Bl implements ActionListener { public void actionPerformed(ActionEvent e) { if (b.getLabel().equals("Aperte Aqui")) b.setLabel(“Valeu”); else b.setLabel("Aperte Aqui"); } } public static void main(String args[]){ (new FrameBotao()).setVisible(true); } } Exemplo XX.XX – Código para tratar um evento gerado em botão. Cada componente pode receber um determinado conjunto de listener parareceber eventos. A Figura VI.XX mostra a relação entre alguns componentes eos eventos que podem ser gerados por eles. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 174 Button ComponentEvent Frame FocusEvent Choice KeyEventTextField MouseEventScrollbar ActionEventComponent AdjustmentEvent Label ItemEvent Dialog Panel WindowEvent Menu ContainerEventMenuItem TextEvent Figura XX.XX – Relação entre os componentes e os eventos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 175 As instâncias das classes de eventos mantém as informações relativas aoevento. Por exemplo, a classe MouseEvent possui os seguintes métodos pararecuperação de informação sobre o evento:Método Descriçãoint getId() tipo do evento. Por exemplo: MouseEvent.MOUSE_CLICKED, MouseEvent.MOUSE_PRESSEDint getX() coordenada x do evento.int getY() coordenada y do evento.Point getPoint() coordenada x e y do evento.int getClickCount() retorna o número de mouse clicks.boolean isPopupTrigger() indica se o evento é um disparo para menu pop-up.void translatePoint(int x, move a posição do evento por x e y. int y) Tabela VI.XX – Métodos da classe MouseEvent. Basicamente, para se codificar um tratador para um determinado eventobasta seguir os seguintes passos:1. Determine o grupo de eventos deseja tratar.2. No nome do grupo de eventos substitua o termo trecho Event por Listener. Este é o nome da interface que você deve implementar. Crie uma classe interna que implementa a interface.3. Codifique os métodos que tratam os eventos que você deseja tratar. Todos os métodos da interface tem que ser implementados, mas o corpo dos métodos que não interessam podem ser deixados vazios.4. Registre um objeto da classe interna junto ao componente, por meio do método addXXX, onde XXX é o nome da interface implementada. Por exemplo, no exemplo VI.XX, para tratar o grupo de eventosActionEvent foi criada uma classe interna que implementa a interfaceActionListener, e um objeto da classe interna é registrado no componentepor meio do método addActionListener. Portanto, tendo o nome do grupode eventos é fácil obter o nome da interface e do método de registro nocomponente. Segue abaixo uma lista com alguns métodos para registro delisteners.♦ Button.addActionListener(ActionListener l) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 176♦ Frame.addWindowListener(WindowListener l)♦ Choice.addItemListener(ItemListener l)♦ TextField.addTextListener(TextListener l)♦ Scrollbar.addAdjustamentListener(AdjustamentListene r l)♦ Component.addComponentListener(ComponentListener l)♦ Component.addFocusListener(FocusListener l)♦ Component.addKeyListener(KeyListener l) Algumas interfaces exigem a implementação de um grande número demétodos, como por exemplo a interface WindowListener, como foi visto noexemplo VI.XX. Isto pode tornar a implementação das interfaces uma tarefa umtanto tediosa. Com o objetivo de auxiliar esta tarefa, foi incluído no pacotejava.awt.event seis classes abstratas, denominadas adapters que facilitama implementação de Listener. O programador só precisa criar uma subclasse daclasse adapter escolhida e sobrescrever o método desejado. Para determinar onome da classe adapter basta substituir no nome da interface a subcadeiaListener por adapter. A tabela VI.XX apresenta os nomes das classes adapters. ComponentAdapter ContainerAdapter FocusAdapter KeyAdapter MouseAdapter MouseMotionAdapter WindowAdapter Tabela VI.XX – Classes adapters. O exemplo XX.XX mostra o exemplo XX.XX alterado de forma que oevento ActionEvent gerado acionamento do componente Button sejatratado por uma classe interna que é subclasse da classe MouseAdapter.import java.awt.*;import java.awt.event.*;public class Botao extends FrameX { Button b; public Botao() { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 177 setLayout(null); setSize(100,80); b = new Button("Aperte Aqui"); add(b); b.setBounds(10,40,80,30); b.addActionListener(new Bl()); } class Bl extends MouseAdapter { public void actionPerformed(ActionEvent e) { if (b.getLabel().equals("Aperte Aqui")) b.setLabel("Valeu"); else b.setLabel("Aperte Aqui"); } } public static void main(String args[]){ (new Botao()).setVisible(true); }} Exemplo XX.XX – Código para tratar um evento gerado em botão. No entanto, existem algumas desvantagens em se usar classes abstratasno lugar de interfaces. A primeira delas é que elimina a possibilidade da classeser subclasse de outra classe e a segunda é que se o programador cometer algumerro na digitação do nome de algum método, ele será encarado como um novométodo e o original não será sobrescrito.Exemplo Básico Apresentaremos agora um exemplo um pouco mais complexo, porémsimples o suficiente para que seja facilmente entendido. O objetivo desteexemplo e servir de base para apresentarmos os principais componentes dabiblioteca AWT. Portanto, a medida que novos componentes foremapresentados, iremos exemplificar o uso deste componentes acrescentando-osem nosso exemplo básico. A função de nosso exemplo é servir como ambiente para execução decomandos MS-DOS, tais como dir e type. O exemplo foi projetado parafuncionar nos ambientes MS-WINDOWS 95 e MS-WINDOWS 98 mas pode serfacilmente adaptado para funcionar em outros ambientes operacionais. A figuraXX.XX mostra a interface da primeira versão de nosso exemplo. Note que,apesar de simples, o nosso exemplo apresenta três componentes em sua Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 178interface: um botão e duas caixas de texto, sendo uma com barras de rolamento ecapacidade para múltiplas linhas. Figura XX.XX – Aparência da aplicação para execução de comandos MS- DOS. A caixa de texto com capacidade para uma linha de texto é um componenteTextField e sua função é permitir a entrada de comandos dos para aexecução. A caixa de texto com capacidade para múltiplas linhas de texto é umcomponente TextArea e sua função é exibir o resultado da execução docomando. Finalmente, o botão é implementado por um componente Button esua função e gerar eventos para execução do comando digitado. O exemploXX.XX mostra o código da aplicação, implementado pela classe Comando.1 import java.io.*;2 import java.awt.*;3 import java.awt.event.*;45 public class Comando extends Frame {6 private TextField tfComando; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 1797 private TextArea taSaida;8 private Button btExec;9 private String com;1011 public Comando() {12 com = "command.com /c "; // Altere essa linha para outros ambientes operacionais1314 tfComando = new TextField(50);15 taSaida = new TextArea(20,60);16 btExec = new Button(“Executa”);1718 taSaida.setEditable(false);1920 add(tfComando,BorderLayout.NORTH);21 add(btExec,BorderLayout.SOUTH);22 add(taSaida,BorderLayout.CENTER);2324 addWindowListener(new WindowAdapter() {25 public void windowClosing(WindowEvent evt) {26 System.exit(0);27 }28 });2930 btExec.addActionListener(new ActionListener() {31 public void actionPerformed(ActionEvent evt) {32 btExecActionPerformed(evt);33 }34 });35 pack();36 }3738 private void btExecActionPerformed(ActionEvent evt) {39 String s = tfComando.getText();40 if (s==null) return;41 try {42 Process p = Runtime.getRuntime().exec(com+s);43 InputStream in = p.getInputStream();44 BufferedReader br = new BufferedReader(new InputStreamReader(in));45 String line;46 taSaida.setText("");47 while ((line = br.readLine()) != null) {48 taSaida.append(line+n);49 }50 taSaida.append("Fim!");51 } catch(Exception e) {taSaida.setText(e.getMessage()); return;}52 }5354 public static void main(String args[]) {55 new Comando().show(); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 18056 }57 } Exemplo XX.XX – Código que executa um comando DOS. Na linha 12 é criado um objeto String contendo o parte inicial do comandonecessário para invocar a shell do MS-DOS. Essa parte inicial deve ser alteradapara adaptar o exemplo para outros sistemas operacionais. Nas linhas 14 a 16são criados os componentes que farão parte da interface. Na linha 14 ocomponente TextField é criado com espaço para exibir 50 caracteres. Nalinha 15 o componente TextArea é criado com espaço para exibir 20 linhas e50 caracteres por linha. Na linha 16 o componente Button é criado com um otexto “Executa”. Na linha 18 é chamado o método setEditable() docomponente TextArea com o argumento false para impedir que o seuconteúdo seja editado. Isso ocorre porque a função do componente é apenasexibir o resultado da execução dos comandos. O leitor deve ter notado que a criação das classes que irão tratar os eventos éum pouco diferente do que mostramos até agora. Nas linhas 24 a 28 e 30 a 34 asdeclarações das classes são feitas no mesmo local onde os objetos sãoinstanciados. Este tipo de classe interna é denominado de classe internaanônima. A classe é denominada de anônima pois nenhum nome é associado aela. A classe anônima se torna automaticamente subclasse da classe mencionadaapós o operador new. É vantajoso usar este tipo de construção quando apenasuma instância da classe será gerada, uma vez que amarra a declaração da classecom seu uso. No entanto, em alguns casos esta técnica pode diminuir alegibilidade do código. Outro fato que pode intrigar o leitor é a distribuição dos componentes najanela. Aparentemente, pouco código foi dedicado ao posicionamento doselementos na interface. Mesmo assim os componentes foram arranjados deforma razoavelmente ordenada na interface. Isto se deve ao fato de todos oscomponentes do tipo Container seguirem um arranjo predefinido (layout).Este arranjo é implementado pelas classes BorderLayout, CardLayout,FlowLayout, GridBagLayout e GridLayout, sendo o BorderLayouto arranjo default. Existe também a possibilidade de não se adotar nenhumlayout. Neste caso é preciso posicionar os componentes em termos decoordenadas dentro do objeto do tipo Container. Os objetos de layout serãotratados mais adiante. No momento basta saber que o layout adotado é o defaulte que este tipo de layout arranja os componentes de acordo com os pontoscardeais (NORTH, SOUTH, EAST, WEST, CENTER). As linhas 20 a 22 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 181mostram as adições de componentes dentro do Frame, com a indicação do seusposicionamentos relativos segundo o layout adotado. A adição de componentesé feita por meio do método add(). As linhas 38 a 52 mostram o código do método que executa o comando MS-DOS e exibe o resultado no componente TextArea. Na linha 42 o comandoMS-DOS é executado por meio do método exec() do objeto Runtime. Oobjeto Runtime é obtido pelo método estático getRuntime() da classeRuntime, uma vez que não pode ser instanciado diretamente. O processo filho,uma vez iniciado, é executado de forma concorrente com o processo pai. Ométodo exec() retorna um objeto do tipo Process, tornando possívelcontrolar o processo e obter informações sobre ele. No nosso caso estamosinteressados em capturar a saída padrão do processo filho para exibi-la nainterface. Isso é feito na linha 43 por meio do método getInputStream()do objeto Process. O objeto InputStream é canalizado para um objetoBufferedReader com o objetivo de facilitar sua manipulação. As linhasrestantes do método tratam da leitura da saída padrão do processo filho e de suaexibição na TextArea. Na linha 46 é usado o método setText() paracolocar um texto vazio no componente e, dessa forma, limpar a TextArea. Nalinha 48 a String lida da saída padrão do processo filho é anexada naTextArea.Acrescentando Cores Podemos alterar as cores de alguns componentes do exemplo XX.XX paratorná-lo visualmente mais interessante por meio de objetos da classe Color.Esta classe encapsula a criação de cores por meio dos níveis RGB. Ela mantémtambém um conjunto de atributos constantes com valores de cores predefinidos.Podemos, por exemplo, alterar a cor de fundo do componente TextArea pormeio do método setBackground(). taSaida.setBackground(Color.lightGray); Podemos alterar também a cor de fundo do componente Button. Nestecaso vamos obter para definir a cor por meio de um número que representa seuscomponentes RGB. btExec.setBackground(new Color(0x08FDDF10)); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 182 Para modificar a cor frontal é preciso utilizar o métodosetForeground(). Todos os componentes possuem métodos equivalentes aestes para alteração das cores.Gerenciando o LayoutO posicionamento de componentes dentro de objetos do tipo Container édeterminado por uma instância de objeto denominado de gerenciador de layout(layout managers). A AWT fornece 5 classes para a implementação de layouts,descritas na tabela XX.XX. O layout default é o implementado pela classeBorderLayout. O pacote Swing acrescenta a classe BoxLayout ao conjuntode gerenciadores de layout.Gerenciador de Layout DescriçãoBorderLayout Posiciona e redimensiona os componentes de um Container em cinco regiões: norte, sul, leste e oeste. Cada região é identificada respectivamente pelas constantes: NORTH, SOUTH, EAST, WEST, e CENTER.FlowLayout Posiciona os componentes de um Container em um fluxo da esquerda para a direita, como linhas em um parágrafo. Cada linha é centralizada.CardLayout Trata cada componente do Container como uma a carta. Somente uma carta é visível em um determinado instante e o Container funciona como uma pilha de cartas. O primeiro componente adicionado é o primeiro visível quando o Container é exibido.GridBagLayout É o gerenciador de layout mais flexível e o mais complexo. Ele arranja os componentes verticalmente e horizontalmente sem exigir que os componentes tenham o mesmo tamanho. Mantém um grade retangular de células, sendo que cada componente pode ocupar mais de uma célula.GridLayout Posiciona e redimensiona os componentes de um Container em uma grade retangular. O Container é dividido em retângulos de tamanhos iguais e um componente é colocado em cada retângulo. Tabela XX.XX –Gerenciadores de Layout. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 183 Para definir o layout de um objeto do tipo Container basta utilizar ométodo setLayout() do objeto, passando como argumento um objetogerenciador de layout, como mostrado abaixo:Frame f = new Frame();f.setLayout(FlowLayout); É possível também não adotar layout algum, optando por posicionar oscomponentes em coordenadas absolutas dentro do Container. Para isso bastapassar null como argumento para o método setLayout(). Oposicionamento absoluto de componentes pode ser feito pelos métodossetLocation() ou setBounds() do componente, como mostrado abaixo.Frame f = new Frame();f.setLayout(null);Button b = new Button(“Teste”);f.add(b);b. setLocation(10, 10); Porém, a adoção de gerenciadores de layout permite o desenvolvimento quese adaptam mais facilmente à redimensionamentos e à mudanças de linguagens.Isto é o posicionamento e dimensionamento absoluto pode fazer com quecomponentes tornem-se parcialmente ou totalmente ocultos com oredimensionamento da janela. O mesmo pode ocorrer com os “labels” doscomponentes quando forem traduzidos para outra língua. Já estes problemas nãoocorrem com o posicionamento e dimensionamento relativo.Exemplo com BorderLayout O exemplo XX.XX utiliza este gerenciador de layout para distribuir oscomponentes na interface. O exemplo abaixo mostra distribuição de cinco botõesem um Frame por meio deste tipo de gerenciador de layout. import java.awt.*; public class BorderTeste extends FrameX { public BorderTeste() { setLayout(new BorderLayout()); add(new Button("Norte"), BorderLayout.NORTH); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 184 add(new Button("Sul"), BorderLayout.SOUTH); add(new Button("Leste"), BorderLayout.EAST); add(new Button("Oeste"), BorderLayout.WEST); add(new Button("Centro"), BorderLayout.CENTER); } public static void main(String a[]){new BorderTeste().show();} } Exemplo XX.XX – Frame com BorderLayout. A figura XX.XX mostra o resultado da execução do código do exemploXX.XX. Figura XX.XX – Aparência do Frame com BorderLayout.Exemplo com FlowLayout O exemplo abaixo mostra distribuição de cinco botões em um Frame pormeio deste tipo de gerenciador de layout. import java.awt.*; public class FlowTeste extends FrameX { public FlowTeste() { setLayout(new FlowLayout()); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 185 add(new Button("UM")); add(new Button("DOIS")); add(new Button("TRÊS")); add(new Button("QUATRO")); add(new Button("CINCO")); setSize(200,100); } public static void main(String a[]){new FlowTeste().show();} } Exemplo XX.XX – Frame com FlowLayout. A figura XX.XX mostra o resultado da execução do código do exemploXX.XX. Note que quando acaba o espaço em uma linha os componentes sãoposicionados na linha de baixo seguindo da esquerda para a direita. Notetambém que cada linha é centralizada no Container. Figura XX.XX – Aparência do Frame com FlowLayout.Exemplo com CardLayout O exemplo abaixo mostra usar o CardLayout para alternar a exibição decomponentes. Um botão é adicionado à interface para receber eventos. Quando obotão é pressionado o tratador de eventos alterna a exibição dos componentes doCardLayout por meio de chamadas ao método next() do gerenciador delayout. A JFC fornece o componente JtabbedPane que apresenta maioresfacilidades.import java.awt.*;import java.awt.event.*;public class CardTeste extends FrameX { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 186 Panel p; CardLayout cl; Button b; public CardTeste() { setLayout(new BorderLayout()); p = new Panel(); b = new Button("Muda carta"); cl = new CardLayout(); p.setLayout(cl); p.add(new Label("Este Label está na primeira carta"),"um"); p.add(new Label("Este Label está na segunda carta"),"dois"); add(b, BorderLayout.NORTH); add(p, BorderLayout.SOUTH); b.addActionListener( new ActionListener() { public voidactionPerformed(ActionEvent evt) { cl.next(p); } }); pack(); } public static void main(String a[]){new CardTeste().show();}} Exemplo XX.XX – Frame com CardLayout. Note que ao adicionar um componente ao Container é preciso passar umidentificador. A figura XX.XX mostra o resultado da execução do código doexemplo XX.XX. Figura XX.XX – Aparência do Frame com CardLayout. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 187Exemplo com GridLayout O exemplo abaixo mostra distribuição de cinco botões em um Frame pormeio deste tipo de gerenciador de layout. import java.awt.*; public class GridTeste extends FrameX { public GridTeste() { setLayout(new GridLayout(3,2)); add(new Button("UM")); add(new Button("DOIS")); add(new Button("TRÊS")); add(new Button("QUATRO")); add(new Button("CINCO")); } public static void main(String a[]){new GridTeste().show();} } Exemplo XX.XX – Frame com GridLayout. A figura XX.XX mostra o resultado da execução do código do exemploXX.XX. Figura XX.XX – Aparência do Frame com GridLayout. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 188Exemplo com GridBagLayout Este gerenciador é o mais complexo, mas é também o que permite um maiorcontrole sobre o posicionamento dos elementos, sem perder as vantagens de umposicionamento relativo. O exemplo XX.XX mostra distribuição de nove botõesem um Frame por meio deste tipo de gerenciador de layout.import java.awt.*;public class GridBagTeste extends FrameX { public GridBagTeste() { Button b; GridBagLayout gridbag = new GridBagLayout(); GridBagConstraints c = new GridBagConstraints(); setLayout(gridbag); for (int i=1;i<10;i++) { switch(i) { case 1: c.fill = GridBagConstraints.BOTH; c.weightx = 1.0; break; case 6: case 3: c.gridwidth = GridBagConstraints.REMAINDER; c.weightx = 1.0; break; case 4: c.weightx = 0.0; break; case 5: c.gridwidth = GridBagConstraints.RELATIVE; c.weightx = 1.0; break; case 7: c.gridwidth = 1; c.gridheight = 2; c.weighty = 1.0; break; case 8: c.gridwidth = GridBagConstraints.REMAINDER; c.weighty = 0.0; c.gridheight = 1; break; } b = new Button("Botão "+i); gridbag.setConstraints(b, c); add(b); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 189 } pack(); } public static void main(String args[]) { new GridBagTeste().show(); }} Exemplo XX.XX – Frame com GridBagLayout. O posicionamento relativo dos componentes é controlado por meio de umobjeto da classe GridBagConstraints. Ele possui vários atributos públicos queorientam o gerenciador de layout no momento de posiciona e reorganizar oscomponentes. O objeto é associado a cada componente por meio do métodosetConstraints() da instância GridBagLayout. Os atributos utilizados noexemplo foram: fill – usado quando a área para a exibição do componente é maior que a área é requisitada pelo componente. Os valores possíveis (definidos na classe GridBagConstraints) são NONE (default), HORIZONTAL (torna o componente largo o suficiente para preencher a área horizontalmente), VERTICAL (torna o componente alto o suficiente para preencher a área na vertical), e BOTH (preenche nos dois sentidos). weightx, weighty – determina como o espaço excedente é distribuído, definindo o comportamento para o redimensionamento. Ou seja define a proporção do espaço que excedente que será distribuído entre os componentes. Se não for especificado para pelo menos uma linha (weightx) e coluna (weighty), todos os componentes serão agrupados no centro do Container, uma vez que o peso de cada um é zero (default). gridwidth, gridheight – Especifica o numero de células em um linha (gridwidth) ou coluna (gridheight) ocupadas pela área de exibição de um componente. O valor default é 1. Os valores possíveis (definidos na classe GridBagConstraints) são REMAINDER para especificar que o componente deve ser o último da linha (para gridwidth) ou coluna (para gridheight). RELATIVE para especificar que o componente deve ser o vizinho do último na linha (para gridwidth) ou coluna (para gridheight). Ou valores inteiros especificando o número de linhas e colunas ocupadas. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 190 A figura XX.XX mostra o resultado da execução do código do exemploXX.XX. Figura XX.XX – Aparência do Frame com GridBagLayout.Utilizando Listas Muitas vezes é necessário que o usuário selecione um item a partir de umalista de itens disponíveis. A AWT torna possível a seleção de um item em umalista de itens por meio do componente Choice. Este componente possui métodospara a adição, remoção e acesso a itens. O exemplo abaixo mostra a alteração doexemplo XX.XX que usa uma lista de escolha para armazenar os comandosanteriores. Desta forma o usuário economiza na digitação de comandosrepetidos.1 import java.io.*;2 import java.awt.*;3 import java.awt.event.*;45 public class Comando2 extends java.awt.Frame {6 private TextField tfComando;7 private TextArea taSaida;8 private Button btExec;9 private Panel panel;10 private Choice ch;11 private String com;1213 public Comando2() { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 19114 com = "command.com /c ";1516 tfComando = new TextField(50);17 taSaida = new TextArea(20,60);18 panel = new Panel();19 btExec = new Button("Executa");20 ch = new Choice();21 ch.setVisible(false);2223 btExec.setBackground(new Color(0x08FDDF10));24 taSaida.setBackground(Color.lightGray);25 taSaida.setEditable(false);2627 add(panel,BorderLayout.NORTH);28 panel.add(tfComando,BorderLayout.NORTH);29 panel.add(ch,BorderLayout.CENTER);30 add(btExec,BorderLayout.SOUTH);31 add(taSaida,BorderLayout.CENTER);3233 addWindowListener(new WindowAdapter() {34 public void windowClosing(WindowEvent evt) {35 System.exit(0);36 }37 });3839 btExec.addActionListener(new ActionListener() {40 public void actionPerformed(ActionEvent evt) {41 btExecActionPerformed(evt);42 }43 });4445 ch.addItemListener( new ItemListener() {46 public void itemStateChanged(ItemEvent evt) {47 if (evt.getStateChange() == ItemEvent.SELECTED)48 tfComando.setText(ch.getSelectedItem());49 }50 });51 pack();52 }5354 private void btExecActionPerformed(ActionEvent evt) {55 String s = tfComando.getText();56 if (s==null) return;57 boolean inclui =true;58 for (int i= ch.getItemCount()-1;i>=0;i--)59 if (s.equals(ch.getItem(i))) inclui=false;60 if (inclui) {61 ch.add(s);62 ch.setVisible(true); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 19263 pack();64 }65 try {66 Process p = Runtime.getRuntime().exec(com+s);67 InputStream in = p.getInputStream();68 BufferedReader br = new BufferedReader(new InputStreamReader(in));69 String line;70 taSaida.setText("");71 while ((line = br.readLine()) != null) taSaida.append(line+n);72 taSaida.append("Fim!");73 } catch(Exception e)74 {taSaida.setText(e.getMessage()); return;}75 }7677 public static void main(String args[]) { new Comando2().show(); }78 } Exemplo XX.XX – Aplicação para execução de comandos MS-DOS com lista de escolha. Na linha 21 é usado o método setVisible() para que o componenteChoice fique invisível inicialmente. Isto é feito porque no início a lista de itensestá vazia e, portanto, não é preciso exibi-la. Nas linhas 45 a 50 é adicionado umobjeto ItemListener à lista de listener do objeto Choice. Este objeto receberáos eventos de seleção de itens na lista de escolha. Nas linhas 58 a 64 é verificadose o comando digitado já está incluído na lista de itens. Caso não esteja o item éincluído e o método pack() do Frame é chamado, para que a janela se ajuste aotamanho dos componentes. A figura XX.XX mostra o resultado da execução do código do exemploXX.XX. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 193Figura XX.XX – Aparência da aplicação para execução de comandos MS-DOS com lista de escolha.Trabalhando com Menus e Diálogos Outros componentes importantes para criação de interfaces com o usuáriosão os menus e as caixas de diálogos. De forma a ilustrar o uso desses recursosmodificaremos o exemplo XX.XX para conter uma barra de menus com apenasum menu. O menu conterá dois itens de menu. O acionamento do primeiro itemde menu ocasionará a exibição de um pequeno texto de ajuda no componenteTextArea. O acionamento do segundo item de menu ocasionará a exibição deuma caixa de diálogo contendo informações sobre a aplicação.1 import java.io.*;2 import java.awt.*;3 import java.awt.event.*;45 public class Comando3 extends java.awt.Frame {6 private TextField tfComando; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 1947 private TextArea taSaida;8 private Button btExec;9 private Panel panel;10 private Choice ch;11 private String com;1213 public Comando3() {14 com = "command.com /c ";1516 tfComando = new TextField(50);17 taSaida = new TextArea(20,60);18 panel = new Panel();19 btExec = new Button("Executa");20 ch = new Choice();21 ch.setVisible(false);2223 btExec.setBackground(new Color(0x08FDDF10));24 taSaida.setBackground(Color.lightGray);25 taSaida.setEditable(false);2627 Menu menu = new Menu("Ajuda");28 menu.add("Resumo");29 menu.addSeparator();30 menu.add("Sobre");31 MenuBar mb = new MenuBar();32 mb.add(menu);33 setMenuBar(mb);3435 add(panel,BorderLayout.NORTH);36 panel.add(tfComando,BorderLayout.NORTH);37 panel.add(ch,BorderLayout.CENTER);38 add(btExec,BorderLayout.SOUTH);39 add(taSaida,BorderLayout.CENTER);4041 addWindowListener(new WindowAdapter() {42 public void windowClosing(WindowEvent evt) {43 System.exit(0);44 }45 });4647 btExec.addActionListener(new ActionListener() {48 public void actionPerformed(ActionEvent evt) {49 btExecActionPerformed(evt);50 }51 });5253 ch.addItemListener( new ItemListener() {54 public void itemStateChanged(ItemEvent evt) {55 if (evt.getStateChange() == ItemEvent.SELECTED) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 19556 tfComando.setText(ch.getSelectedItem());57 }58 });5960 menu.addActionListener(new ActionListener() {61 public void actionPerformed(ActionEvent evt) {62 if (evt.getActionCommand().equals("Sobre")) mostraSobre();63 else if (evt.getActionCommand().equals("Resumo"))64 taSaida.setText("Digite o Comando e pressione “+65 ”o botão <executa> para executar.");66 }67 });68 pack();69 }7071 private void mostraSobre() {72 Dialog d = new Dialog(this,"Sobre Comando");73 d.setModal(true);74 Label lb1 = new Label("Comando Versão 1.2", Label.CENTER);75 Label lb2 = new Label("Alcione de Paiva Oliveira", Label.CENTER);76 lb1.setFont(new Font ("Dialog", Font.BOLD|Font.ITALIC, 18));77 lb2.setFont(new Font ("Courier New", 0, 16));78 d.add(lb1,BorderLayout.NORTH);79 d.add(lb2,BorderLayout.SOUTH);80 d.setBackground(Color.cyan);81 d.addWindowListener(new WindowAdapter() {82 public void windowClosing(WindowEvent evt) {83 evt.getWindow().dispose();84 }85 });86 d.pack();87 d.show();88 }8990 private void btExecActionPerformed(ActionEvent evt) {91 String s = tfComando.getText();92 if (s==null) return;93 boolean inclui =true;94 for (int i= ch.getItemCount()-1;i>=0;i--)95 if (s.equals(ch.getItem(i))) inclui=false;96 if (inclui) {97 ch.add(s);98 ch.setVisible(true);99 pack();100 }101 try {102 Process p = Runtime.getRuntime().exec(com+s);103 InputStream in = p.getInputStream();104 BufferedReader br = new BufferedReader(new InputStreamReader(in)); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 196105 String line;106 taSaida.setText("");107 while ((line = br.readLine()) != null) taSaida.append(line+n);108 taSaida.append("Fim!");109 } catch(Exception e)110 {taSaida.setText(e.getMessage()); return;}111 }112113 public static void main(String args[]) { new Comando3().show(); }114 }Exemplo XX.XX – Aplicação para execução de comandos MS-DOS com barra de menus e uma caixa de diálogo.As linhas 27 a 33 contém o código para a inserção da barra de menus e do menu.Na linha 27 é criado um componente Menu com o label “Ajuda”. Nas linhas 28 a30 são adicionados dois itens de menu e um separador ao componente Menu. Naslinha 31 e 32 é criado um componente MenuBar e o componente Menu éadicionado ao MenuBar. Na linha 33 o componente MenuBar é definida como abarra de menu da janela corrente. Nas linhas 60 a 67 é adicionado um objetoActionListener à lista de Listener do objeto Menu. Este objeto receberá oseventos de seleção de itens do menu. Caso o item de menu selecionado seja o“Sobre” então o método mostraSobre() é invocado. Caso o item de menuselecionado seja o “Resumo” então é exibido um texto de ajuda no componenteTextArea. As linhas 71 a 88 contém o código do método mostraSobre(). Estemétodo é responsável pela montagem e exibição da caixa de diálogo cominformações sobre a aplicação. Na linha 72 é criada uma instância da classeDialog. O construtor desta classe exige que seja passado como parâmetro umobjeto da classe Frame ou Dialog para deter a posse do objeto a ser criado.Quando o objeto possuidor é tornado invisível ou minimizado a janela Dialog éautomaticamente tornada invisível ou minimizada. No caso do exemplo o Framecorrente é passado como parâmetro. Na linha 73 é invocado o métodosetModal() para torna a o diálogo modal. O diálogo modal bloqueia todaentrada em todas as janelas no contexto da aplicação, exceto pelas janelascriadas tendo o diálogo como possuidor. A figura XX.XX mostra o resultado da execução do código do exemploXX.XX. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 197Figura XX.XX – Aparência da aplicação para execução de comandos MS-DOS com barra de menus.Capturando Eventos do TecladoPrincipais ClassesColor Esta classe encapsula a criação de cores por meio dos níveis RGB. Elamantém também um conjunto de atributos constantes com valores de corespredefinidos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 198Hierarquiajava.lang.Object | +--java.awt.ColorAtributos públicos Atributo Descrição Color black A cor preta. Color blue A cor azul. Color cyan A cor azul claro. Color darkGray A cor cinza escuro. Color gray A cor cinza. Color green A cor verde. Color lightGray A cor cinza claro. Color magenta A cor violeta. Color orange A cor laranja. Color pink A cor rosa. Color red A cor vermelha. Color white A cor branca. Color yellow A cor amarela.ConstrutoresConstrutor DescriçãoColor(float r, float g, Cria uma cor opaca RGB com os valores red, green, e float b) blue especificados dentro da faixa (0.0 - 1.0).Color(int rgb) Cria uma cor opaca com os valores RGB combinados no parâmetro rgb. O componente red está definido nos bits 16-23, o componente green está definido nos bits 8- 15, e o componente blue está definido nos bits 0-7.Color(int r, int g, Cria uma cor opaca RGB com os valores red, green, e int b) blue especificados dentro da faixa (0 - 255).Métodos mais usadosMétodo DescriçãoColor brighter() Cria uma versão mais clara da cor corrente.Color darker() Cria uma versão mais escura da cor corrente.Color decode(String nm) Converte a String em um inteiro e retorna a cor Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 199 opaca relacionada.equals(Object obj) Verifica se o objeto é igual a essa cor.int getBlue() Retorna o componente azul da cor.int getGreen() Retorna o componente verde da cor.int getRed() Retorna o componente vermelho da cor.int getTransparency() Retorna o modo de transparência desta cor.String toString() Retorna a representação em String desta cor.Exemplo Color c = new Color(0xFFC0C0C0);Component Um componente é um objeto que possui uma representação gráfica quepode ser exibida em uma tela e pode interagir com o usuário.Hierarquia java.lang.Object | +--java.awt.ComponentAtributos públicos Atributo Descrição float BOTTOM_ALIGNMENT Alinhamento na parte inferior. float CENTER_ALIGNMENT Alinhamento ao centro. loat LEFT_ALIGNMENT Alinhamento à esquerda. float RIGHT_ALIGNMENT Alinhamento à esquerda. float TOP_ALIGNMENT Alinhamento na parte superior.ConstrutorConstrutor DescriçãoComponent() Constrói um novo Component. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 200Métodos mais usadosMétodo Descriçãovoid add(PopupMenu popup) Adiciona um menu do tipo PopupMenu ao componente.void addComponentListener( Adiciona o ComponentListener para ComponentListener l) receber eventos sobre o componente.boolean contains(int x, Verifica se o componente possui a coordenada. int y)float getAlignmentX() Retorna o alinhamento no eixo x.float getAlignmentY() Retorna o alinhamento no eixo y.Color getBackground() Retorna a cor de fundo do componente.Rectangle getBounds() Retorna as dimensões do componente.Component getComponentAt( Retorna o componente do Component que int x, int y) contém a coordenada especificada. Apenas o primeiro nível de descendência é examinado.Cursor getCursor() Retorna o cursor deste componente.Font getFont() Retorna o fonte deste componente.Color getForeground() Retorna a cor de frente deste componente.Graphics getGraphics() Cria um contexto gráfico para este componente.int getHeight() Retorna a altura deste componente.Point getLocation() Retorna a localização deste componente.String getName() Retorna o nome deste componente.Container getParent() Retorna o Container onde está inserido este componente.Dimension getSize() Retorna as dimensões deste componente.Toolkit getToolkit() Retorna o Toolkit deste componente.int getWidth() Retorna a largura deste componente.int getX() Retorna a coordenada X deste componente.int getY() Retorna a coordenada Y deste componente.boolean isDisplayable() Verifica se este componente pode se exibido.boolean isEnabled() Verifica se este componente está habilitado.boolean isFocusOwner() Verifica se este componente possui o foco.boolean isVisible() Verifica se este componente esta visível.void list(PrintStream out) Lista este componente no PrintStream.void paint(Graphics g) Pinta o este Container. Este método deve ser sobrescrito se o programador deseja desenhar no Container. Neste caso super.paint(g) deve ser invocado.void processEvent(AWTEvent e) Processa os eventos ocorrendo neste componente.void remove(MenuComponent Remove o menu popup menu destepopup) componente.void setBounds(int x, int y, Define os limites deste componente. int width, Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 201 int height)void setEnabled(boolean b) Define este componente como habilitado.void setFont(Font f) Define o fonte deste Component.void void setName(String name) Define o nome deste componente.void setSize(int width, Define o tamanho deste componente. int height)void setVisible(boolean b) Define este componente como visível.String toString() Retorna a representação em String deste componente.ExemploComponent c= new Component();Button Os objetos da classe Button são objetos gráficos que simulam botões egeram eventos quando são pressionados.Hierarquia java.lang.Object | +--java.awt.Component | +--java.awt.ButtonConstrutoresConstrutor DescriçãoButton() Constrói um botão sem texto.Button(String lbl) Constrói um botão com um texto.Métodos mais usadosMétodo DescriçãoString getLabel() Retorna o texto apresentado no botão.void setLabel(String lbl) Define o texto apresentado no botão como o referenciado por lbl. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 202ExemploButton b= new Button(“ok”);Label Os objetos da classe Label servem para exibir textos que não serãoeditados pelo usuário.Hierarquiajava.lang.Object | +--java.awt.Component | +--java.awt.LabelConstrutoresConstrutor DescriçãoLabel() Constrói um Label sem texto.Label(String lbl) Constrói um Label com um texto.Label(String lbl, Constrói um Label com um texto e com o alinhamento int alin) especificado por alin. Os valores possíveis para o alinhamento são Label.LEFT, Label.RIGHT, e Label.CENTER.Métodos mais usadosMétodo DescriçãoString getText() Retorna o texto apresentado no Label.void setText(String lbl) Define o texto apresentado no Label como o referenciado por lbl.int getAlignment() Retorna o alinhamento.void setAlignment(int alin) Estabelece o novo alinhamento, especificado por alin. Os valores possíveis para o Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 203 alinhamento são Label.LEFT, Label.RIGHT, e Label.CENTER.List O componente List permite que o programador crie uma lista deelementos passíveis de rolamento. Dependendo de como a lista foi definida ousuário pode selecionar um item ou múltiplo itens.Hierarquiajava.lang.Object | +--java.awt.Component | +--java.awt.ListConstrutoresConstrutor DescriçãoList() Constrói uma nova lista rolável.List(int linhas) Constrói uma nova lista rolável com o número de linhas visíveis igual a linhas.List(int linhas, Constrói uma nova lista rolável com o número de linhasboolean sm) visíveis igual a linhas e o parâmetro sm indicando se é para permitir seleções múltiplas.Métodos mais usadosMétodo Descriçãovoid add(String item) Adiciona o item referenciado por item no final da lista.void add(String item, Adiciona o item referenciado por item na int ind) posição indicada por ind. A base é 0. Se o valor de ind for menor que 0 ou maior que o número de elementos, o item será inserido no final da lista. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 204void deselect(int ind) remove a seleção do item no índice especificado.String getItem(int ind) Obtém o item no índice especificado.int getItemCount() Obtém o número de itens na lista.String[] getItems() Obtém todos os itens da lista.int getRows() Obtém o número de linhas visíveis da lista.int getSelectedIndex() Obtém o índice do elemento selecionado. Retorna -1 se nenhum elemento ou mais de um elemento estiver selecionado.int[] getSelectedIndexes() Retorna todos os itens selecionados.String getSelectedItem() Obtém o elemento selecionado.String[] getSelectedItems() Obtém todos os elementos selecionados.boolean isMultipleMode() Indica se o modo de seleção é múltiplo.void makeVisible(int ind) Torna visível o elemento no índice especificado.void remove(int ind) Remove o elemento no índice especificado.void removeAll() Remove todos os elementos na lista.void select(int ind) Seleciona o elemento no índice.ExemploList lista = new List(3);lista.add("Laranja");lista.add("Abacate");lista.add("Pera");lista.add("Uva");TextField O componente TextField é usado para implementar entrada e ediçãode uma linha de texto.Hierarquiajava.lang.Object | +--java.awt.Component | +--java.awt.TextComponent | +--java.awt.TextField Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 205ConstrutoresConstrutor DescriçãoTextField() Constrói um novo TextField.TextField(int cols) Constrói um novo TextField com o número de colunas especificado.TextField(String txt) Constrói um novo TextField exibindo o texto especificado.TextField(String Constrói um novo TextField com o número detxt,int cols) colunas e o texto especificados.Métodos mais usadosMétodo Descriçãoint getColumns() Retorna o número de colunas.String getText() Retorna o texto exibido no componente.void setColumns(int cols) Define o número de colunas.void setText(String txt) Define o número o texto a ser editado.Exemplo TextField tf; tf = new TextField("Ola mundo!";TextArea O componente TextArea é usado para implementar entrada e ediçãode texto com múltiplas linhas.Hierarquiajava.lang.Object | +--java.awt.Component | Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 206 +--java.awt.TextComponent | +--java.awt.TextAreaConstrutoresConstrutor DescriçãoTextArea() Constrói um novo TextArea.TextArea(int lin, Constrói um novo TextArea com o número de linhas int cols) e colunas especificados.TextArea(String txt) Constrói um novo TextArea exibindo o texto especificado.TextArea(String txt,int Constrói um novo TextArea com o número de linhas,cols) colunas e o texto especificados.Métodos mais usadosMétodo Descriçãoint getColumns() Retorna o número de colunas.int getRows() Retorna o número de linhas.String getText() Retorna o texto exibido no componente.void setColumns(int cols) Define o número de colunas.void setRows(int lin) Define o número de linhas.void setText(String txt) Define o número o texto a ser editado.Exemplonew TextArea("Ola mundo!", 3, 20);Containers Containers são componentes usados para conter outros componentes. Umobjeto da classe Container pode conter inclusive outros containers,permitindo assim a construção de interfaces complexas.Hierarquia Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 207java.lang.Object | +--java.awt.Component | +--java.awt.ContainerConstrutorConstrutor DescriçãoContainer() Constrói um novo Container.Métodos mais usadosMétodo DescriçãoComponent add( Adiciona o componente no final da lista de Component comp) componentes deste Container.Component add( Adiciona o componente na posição ind da Component comp, int ind) lista de componentes deste Container.Component findComponentAt( Retorna o componente visível do Container int x, int y) que contém a coordenada especificada. Todos os descendentes são examinados (SDK 1.2).float getAlignmentX() Retorna o alinhamento no eixo x.float getAlignmentY() Retorna o alinhamento no eixo y.Component getComponent( Retorna o componente na posição n na lista de int n) componentes deste Container.Component getComponentAt( Retorna o componente do Container que int x, int y) contém a coordenada especificada. Apenas o primeiro nível de descendência é examinado.int getComponentCount() Retorna o número de componentes deste Container.Component[] getComponents() Retorna todos os componentes deste Container.Insets getInsets() Retorna o Insets deste Container. Insets indicam o tamanho da borda do Container.LayoutManager getLayout() Retorna o Layout deste Container.boolean Indica se o componente está contido nesteisAncestorOf(Component c) Container.void list(PrintStream out, Imprime uma lista com o conteúdo deste int indent) Container.void paint(Graphics g) Pinta o este Container. Este método deve ser sobrescrito se o programador deseja Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 208 desenhar no Container. Neste caso super.paint(g) deve ser invocado.void remove(Component comp) Remove o componente deste Container.void remove(int index) Remove o componente com o índice especificado deste Container.void removeAll() Remove todos os componentes deste Container.void setFont(Font f) Define o fonte deste Container.void setLayout(LayoutManager Define o layout deste Container.mgr)Panel Esta classe é o Container mais simples. O Panel fornece um espaçoonde podem ser colocados outros componentes, inclusive outros objetos do tipoPanel.Hierarquiajava.lang.Object | +--java.awt.Component | +--java.awt.Container | +--java.awt.PanelConstrutorConstrutor DescriçãoPanel() Constrói um novo Panel.Panel(LayoutManager layout) Constrói um novo Panel usando o LayoutManager especificado.MétodoMétodo Descriçãovoid addNotify() Cria um par (peer) para o Panel. O par permite modificar o Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 209 Panel sem alterar a sua aparência.Exemplo Ver exemplo VI.XX.Frame Um Frame é uma janela com título e borda. A área do Frame inclui aárea destinada para a borda. As dimensões da borda pode ser obtida por meio dométodo getInsets().Hierarquiajava.lang.Object | +--java.awt.Component | +--java.awt.Container | +--java.awt.Window | +--java.awt.FrameConstrutoresConstrutor DescriçãoFrame() Constrói um novo Frame.Frame(String title) Constrói um novo Frame com o título especificado.Métodos mais usadosMétodo Descriçãostatic Frame[] getFrames() Retorna todos os frames criados pela aplicação.Image getIconImage() Retorna a imagem usada pelo Frame quando Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 210 minimizado.MenuBar getMenuBar() Retorna a barra de menu deste Frame.int getState() Retorna o estado deste Frame.String getTitle() Retorna o título deste Frame.boolean isResizable() Indica se o tamanho deste Frame pode ser mudado.void setIconImage(Image im) Define a imagem a ser usada como ícone para este Frame.void setMenuBar(MenuBar mb) Define o menu a ser usada como ícone para este Frame.void setResizable(boolean r) Define se o tamanho deste Frame pode ser mudado.void setState(int state) Define o estado deste Frame.void setTitle(String title) Define o título deste Frame.Exemplo Ver exemplo VI.XX.###Exemploimport java.awt.*;import java.awt.event.*;class testeFrame3 extends FrameX { Button b; class SymMouse extends MouseAdapter { public void mouseClicked(MouseEvent event) { Object object = event.getSource(); if (object == b) b.setLabel("Clik"); } } public testeFrame3 (String Titulo) { super(Titulo); b = new Button("ola"); b.addMouseListener(new SymMouse()); this.add(b); setSize(100,80); } public static void main(String args[]) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 211 { testeFrame3 t = new testeFrame3("Teste 3"); t.show(); }}public class testeFrame4 extends FrameX { public testeFrame4(String titulo) { super(titulo); setLayout(new GridLayout(1,2)); textField1 = new TextField(20); add(textField1); button1 = new Button("Duplica"); add(button1); button1.addMouseListener(new SymMouse()); } public synchronized void show() { move(50, 50); setSize(200,50); super.show(); } TextField textField1; Button button1;class SymMouse extends java.awt.event.MouseAdapter { public void mouseClicked(java.awt.event.MouseEventevent){ Object object = event.getSource(); if (object == button1) { int i = Integer.parseInt(textField1.getText()); textField1.setText(""+i*2); } } } public static void main(String args[]){ new testeFrame4("Teste 4").show(); }}public class testeFrame5 extends FrameX { public testeFrame5(String titulo) { super(titulo); setSize(220,70); setLayout(null); textField1 = new TextField(); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 212 textField1.setBounds(10,30,100,25); add(textField1); button1 = new Button("Duplica"); button1.setBounds(110,30,100,25); button1.addMouseListener(new SymMouse()); add(button1); }public class testeFrame6 extends FrameX { public testeFrame6(String titulo) { super(titulo); setSize(200,250); move(50, 50); theImage = tk.getImage("skisor.gif"); } private static Toolkit tk = Toolkit.getDefaultToolkit(); private Image theImage; public void paint(Graphics g) { g.drawImage(theImage, 20, 20, getSize().width-20, getSize().height-20, this); } public static void main(String args[]){ new testeFrame6("Teste 6").show(); }} O objeto Toolkit oferece recursos para carregar imagens da formacorreta para cada plataforma. O método paint() é responsável por desenhar afigura. Ele é chamado toda vez que ocorre um evento sobre o componente, demodo que a figura será sempre redesenhada.Agenda Eletrônica versão Gráfica 1.0/** AgendaInt Interface Gráfica da agenda.*/import java.awt.*;import java.awt.event.*;import java.io.*;import java.util.*; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 213public class AgendaInt extends FrameX{ Agenda ag; TextArea textArea1 = new TextArea(); TextField txtNome = new TextField(); TextField txtEnd = new TextField(); TextField txtTel = new TextField(); Button btCarregar = new Button(); Button btGravar = new Button(); Button brInserir = new Button(); Button btListar = new Button(); Button btConsultar = new Button(); Label label1 = new Label(); Label lbStatus = new Label(); Label label2 = new Label(); Label label3 = new Label(); public AgendaInt() { ag = new Agenda(); setLayout(null); setBackground(new Color(112,170,192)); setSize(400,320); setVisible(false); add(textArea1); textArea1.setBackground(Color.white); textArea1.setBounds(12,120,372,168); btCarregar.setLabel("Carregar"); add(btCarregar); btCarregar.setBackground(Color.lightGray); btCarregar.setBounds(12,12,72,24); btGravar.setLabel("Gravar"); add(btGravar); btGravar.setBackground(Color.lightGray); btGravar.setBounds(84,12,72,24); brInserir.setLabel("Inserir"); add(brInserir); brInserir.setBackground(Color.lightGray); brInserir.setBounds(156,12,72,24); btListar.setLabel("Listar"); add(btListar); btListar.setBackground(Color.lightGray); btListar.setBounds(228,12,84,24); btConsultar.setLabel("Consultar"); add(btConsultar); btConsultar.setBackground(Color.lightGray); btConsultar.setBounds(312,12,72,24); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 214 add(txtNome); txtNome.setBackground(Color.white); txtNome.setBounds(60,48,144,24); label1.setText("Nome:"); add(label1); label1.setFont(new Font("Serif", Font.BOLD, 12)); label1.setBounds(12,48,48,24); add(lbStatus); lbStatus.setBackground(Color.lightGray); lbStatus.setForeground(Color.red); lbStatus.setBounds(0,300,396,16); label2.setText("Telefone:"); add(label2); label2.setFont(new Font("Serif", Font.BOLD, 12)); label2.setBounds(216,48,60,24); add(txtTel); txtTel.setBackground(Color.white); txtTel.setBounds(276,48,108,24); label3.setText("Endereço:"); add(label3); label3.setFont(new Font("Serif", Font.BOLD, 12)); label3.setBounds(12,84,48,24); add(txtEnd); txtEnd.setBackground(Color.white); txtEnd.setBounds(72,84,312,24); setTitle("Agenda Eletônica"); // REGISTRA OS LISTENERS SymWindow aSymWindow = new SymWindow(); this.addWindowListener(aSymWindow); SymMouse aSymMouse = new SymMouse(); btGravar.addMouseListener(aSymMouse); btCarregar.addMouseListener(aSymMouse); btListar.addMouseListener(aSymMouse); brInserir.addMouseListener(aSymMouse); btConsultar.addMouseListener(aSymMouse);}public AgendaInt(String title){ this(); setTitle(title);}class SymWindow extends WindowAdapter{ public void windowClosing(WindowEvent event) { Object object = event.getSource(); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 215 if (object == AgendaInt.this) AgendaIntAwt_WindowClosing(event); }}void AgendaIntAwt_WindowClosing(WindowEvent event){ setVisible(false);}class SymMouse extends MouseAdapter{ public void mouseClicked(MouseEvent event) { Object object = event.getSource(); if (object == btGravar) btGravar_MouseClicked(event); else if (object == btCarregar) btCarregar_MouseClicked(event); else if (object == btListar) btListar_MouseClicked(event); else if (object == btConsultar) btConsultar_MouseClicked(event); else if (object == brInserir) brInserir_MouseClicked(event); }}void btGravar_MouseClicked(MouseEvent event){ gravar();}void btCarregar_MouseClicked(MouseEvent event){ carregar();}void btListar_MouseClicked(MouseEvent event){ Exibirlista();}void btConsultar_MouseClicked(MouseEvent event){ String nome = txtNome.getText(); if (nome.length()>0) exibirPessoa(nome); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 216 else lbStatus.setText("É necessário preencher o campoNome!"); } void brInserir_MouseClicked(MouseEvent event) { String nome = txtNome.getText(); String tel = txtTel.getText(); String end = txtEnd.getText(); if (nome.length()>0) ag.inserir(new Pessoa(nome,tel,end)); else lbStatus.setText("É necessário preencher o campoNome!"); } /** gravar */ public void gravar() { ObjectOutputStream fout; try { fout = new ObjectOutputStream( new FileOutputStream("agenda.dat")); fout.writeObject(ag); fout.close(); } catch(FileNotFoundException e) { System.out.println("Arq. Não encontrado");} catch(IOException e){System.out.println("Erro nagravação!");} } /** carregar */ public void carregar() { ObjectInputStream fin; try { fin = new ObjectInputStream( new FileInputStream("agenda.dat")); ag = (Agenda) fin.readObject(); fin.close(); } catch(FileNotFoundException e) { System.out.println("Arq. Não encontrado");} catch(Exception e) {System.out.println("Erro naleitura!");} } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 217 /** Exibirlista */ public void Exibirlista() { Pessoa p; textArea1.setText(""); for (Enumeration e = ag.getPessoas();e.hasMoreElements();) { p = (Pessoa) e.nextElement(); textArea1.append("nNome:"+p.getNome()+"nTelefone:" +p.getTel()+"nEndereço:"+p.getEnd()+"n"); } } // main public static void main(String args[]) { (new AgendaIntAwt("Agenda")).setVisible(true); } /** exibirPessoa */ public void exibirPessoa(String nome) { Pessoa p = ag.getPessoa(nome); if (p!=null) { txtTel.setText(p.getTel()); txtEnd.setText(p.getEnd()); } else textArea1.setText("Pessoa não cadastrada!"); }}ExercíciosFaça um programa para converter Graus Celcius em Farenheit Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 218Capítulo IX - Applets Applets são aplicações Java projetadas para serem executadas pornavegadores da World Wide Web (WWW). Isto é feito através de chamadasespeciais dentro do código HTML (Hyper Text Markup Language) das páginas.A possibilidade de desenvolver páginas HTML com a capacidade de invocarprogramas em Java foi uma das razões para o sucesso inicial, inédito em termosde linguagem de programação, de Java. Até então, as páginas HTML erambasicamente objetos passivos, com capacidade limitada de interação, a não serpor meio de CGI (Common Gateway Interface), que implementa a interatividadecom o uso de códigos executáveis (geralmente escritos em Perl) rodados noservidor. Esse tipo de arquitetura onera muito o servidor uma vez qualquerprocessamento tem que ser efetuado nele. ServidorCliente com browser Requisição de página Web O servidor Web Página Web construída 800 executa o programa pelo programa CGI CGI que constrói a página Web. APO Figura VII.1 – Interação via CGI. A idéia do uso de Java é enviar código para o lado cliente através darede, para que parte do processamento seja realizado no próprio cliente,liberando o servidor para tarefas mais importantes. Claro que isto será razoávelse o código puder trafegar pela rede rapidamente. Os programas em Bytecodesocupam pouco espaço e podem ser compactados antes de serem enviados pelarede, o que reduz bastante o tempo de transmissão. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 219 Cliente com browser Servidor O servidor WebExecuta o Requisição de página Web envia páginacódigo em Web e códigobytecodes em bytecodes 800 APO Página Web e bytecodes Figura VII.2 – Interação via Java. No entanto, é preciso ter cuidado quando se trata de enviar código pela rede para se executado em uma máquina cliente. Existe um grande potencial para o desenvolvimento acidental ou proposital de programas que podem atuar nocivamente nas máquinas clientes, seja pela leitura de dados privados, seja por destruição não autorizada de informações e programas. Preocupados com o isso, os projetistas da linguagem Java determinaram que, no caso de Applets, a máquina virtual impede que o programa tenha acesso limitado aos recursos da máquina. Nessa forma de execução o programa é dito estar sendo executado dentro de uma “caixa de areia” (Sand Box). Esta solução é em alguns casos por demais restritiva e tem sido relaxada nas últimas versões de Java para permitir o acesso aos recursos das máquinas clientes a Applets digitalmente assinados, denominados de Trusted (confiáveis). Outro benefício do uso de Java é possibilidade da produção de páginas para a WWW com animação. Inicialmente, as páginas em HTML não possuíam recurso para animação, a não ser por meio de GIFs animadas. Com Java é possível desenvolver animações bem mais sofisticadas. Para desenvolver um Applet é preciso criar uma subclasse da classe classe java.applet.Applet. Abaixo é mostrada forma geral de um código que implementa um Applet: import java.awt.*; import java.applet.Applet; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 220 public class indentificador extends Applet { corpo do applet } A figura VII.3 mostra a hierarquia de classes para a classe Applet. java.lang.Object java.awt.Component java.awt.Container java.awt.Panel java.applet.Applet Figura VII.3 – Hierarquia de classes. O exemplo VII.1 mostra o código de um Applet que exibe o texto “olamundo!” quando executado. import java.awt.*; import java.applet.*; public class Applet1 extends Applet { Label label1 = new Label(); public void init() { setLayout(null); setSize(150,87); label1.setText("Ola Mundo!"); add(label1); label1.setBounds(24,12,84,48); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 221 } } Exemplo VII.1 – Applet simples. O leitor pode observar algumas diferenças do código do exemplo VII.1para o código do exemplo III.1 que implementava um programa que exibia “olaMundo” na console. A primeira diferença é que não existe um método main().Isto ocorre porque os Applets foram projetados para serem executados por outraaplicação: um navegador Web. A aplicação é responsável por criar umainstância da subclasse da classe Applet e chamar os métodos de acordo com anecessidade. No exemplo acima será executado o método init(), que é oprimeiro método executado em um Applet e é executado apenas uma vez. Para executarmos o Applet, além de ser necessário compilá-lo, é precisocriar um arquivo com código HTML com um link para o código em bytecode.Isto é necessário já que o Applet vai ser executado por um navegador. Oexemplo VII.2 mostra o código HTML que possui um link para a classe Applet1.O link para o código em bytecodes pode possuir vários parâmetros. No exemploVII.2 são mostrados apenas os parâmetros que indicam a largura e altura que oApplet ocupará na página. Os outros parâmetros serão abordados mais adiante. <html> <applet code=Applet1.class width=400 height=300> </applet> </html> Exemplo VII.2 – HTML simples. Para executar o código basta direcionar o navegador para o HTML doexemplo VII.2. O SDK possui também uma aplicação capaz de executarApplets. É o appletviewer. A linha de comando abaixo mostra comoexecutar o Applet por meio do appletviewer. Note que é preciso passar onome do arquivo HTML como parâmetro: appletviewer applet1.html Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 222 A figura VII.4 mostra o resultado da execução do Applet1 por meio doappletviewer. Figura VII.4 – Execução do Applet1.Descrição do código HTML Não entraremos em detalhes da codificação em HTML. Abordaremosaqui apenas os parâmetros relacionados com o link para o código em bytecode.A forma geral de um link deste tipo é mostrada abaixo. <html> <applet..code= ... width=... height=... archive=... codebase=... align=... alt=... name=... hspace=... vspace=... mayscript=... > <param name=“...” value=“...”> ... <param name=“...” value=“...”> </applet> </html> O link HTML possui vários parâmetros, sendo a maioria deles opcionais.A tabela abaixo descreve cada um dos parâmetros. Parâmetro Descrição Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 223 code Nome da classe em bytecode. Por exemplo: Applet1.class. width Largura que o Applet vai ocupar na página HTML. height Altura que o Applet vai ocupar na página HTML. archive Opcional. Se a classe estiver armazenada em um arquivo JAR (Java Archive), então este parâmetro indica o nome do arquivo. Por exemplo: minhasclasses.jar. codebase Opcional. URL onde está localizada o Applet. align Alinhamento do Applet na página. (left, right, top, texttop, middle, absmiddle, baseline, bottom e absbottom). alt Mensagem alternativa caso o navegador não seja capaz de executar bytecodes. name Nome do Applet. Pode ser usado por outros Applets na mesma página para comunicação. hspace Define o número de pixels livres nos lados direito e esquerdo do Applet. vspace Define o número de pixels livres acima e abaixo do Applet. mayscript Valor booleano que indica se um Applet pode interagir com código Javascript. param Opcional. É usado para passar parâmetros para o Applet. Cada entrada param possui dois subparâmetros, name e value, indicando o nome do parâmetro e o valor respectivamente. Mais adiante será mostrado como o código Java recebe esses parâmetros. Tabela VII.1 – Parâmetros do link para o código em bytecodes.Métodos da Classe Applet A classe Applet define um número razoável de métodos. No entanto, namaioria das aplicações, o programador sobrescreverá um pequeno subconjuntodeste métodos. A tabela VII.2 descreve os métodos mais utilizados naimplementação de Applets. Método Descrição init É o primeiro método executado e é executado apenas uma vez. É utilizado para as inicializações do Applet. start É executado toda vez que o Applet aparece no navegador. É utilizado para iniciar a operação normal do Applet. stop É executado toda vez que o Applet passa a não ser exibido pelo navegador. É usado para terminar operações caras em termos computacionais. destroy É executado quando o navegador não precisa mais do Applet. É usado para liberar recursos. paint É executado toda vez que o Applet aparece no navegador. Recebe uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 224 instância da classe Graphics. O usuário pode solicitar a sua invocação por meio de uma chamada ao método repaint(). Neste caso o método paint() não será chamado imediatamente, e sim escalado para ser executado em um tempo menor do que 100msec. Tabela VII.2 –Principais métodos da classe Applet. Esses métodos são invocados pelo navegador conforme as situações descritasacima. A motivação por trás dos métodos start() e stop() é que não fazsentido desperdiçar ciclos de processador com um Applet que não está sendovisto. O método que talvez possa causar mais dúvidas quanto a sua utilidade é ométodo paint(). O método paint() é na verdade um método herdado daclasse container e é utilizado para desenhar em um objeto. O objeto da classeGraphics, recebido pelo método, representa a superfície onde podem serfeitos os desenhos e possui um conjunto de métodos para desenhar. Para ilustraro uso do paint() o exemplo VII.3 mostra o código de um Applet que desenhaum quadrado na tela que segue o mouse. import java.awt.*; import java.applet.*; import java.awt.event.*; public class Applet2 extends Applet { int x=0, y=0; public void init(){ setLayout(null); setSize(426,266); this.addMouseMotionListener(new SymMouseMotion()); } public void paint(Graphics g) { if (x>0)g.drawRect(x, y, 30, 30); } class SymMouseMotion extends MouseMotionAdapter{ public void mouseMoved(MouseEvent event){ if (event.getSource()== Applet2.this) { x = event.getX(); y = event.getY(); repaint(); } } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 225 } } Exemplo VII.3 – Applet que desenha um quadrado que acompanha o mouse. Note que o método paint() não é chamado diretamente pelo métodomouseMoved(). O que ocorre é que o método repaint() solicita amáquina virtual para chamar o método update() que por sua vez chama ométodo paint(). A máquina virtual não executa imediatamente o métodoupdate(). Ela escala o método update() para ser executado em pelo menos100 milisegundos. Se antes deste período ocorrer outra solicitação ela seráignorada. O diagrama da figura VII.5 ilustra o ciclo repaint-update-paint. repaint() update(Graphics g) paint(Graphics g) Chama escala (dentro de 100 ms) Figura VII.5 – Ciclo repaint-update-paint. Ao executar o Applet do exemplo VII.3 o leitor notará que apenas umquadrado permanece desenhado, apesar de existir código apenas para desenhar enenhum para apagar. A pergunta é: o que ocorre com os quadrados desenhadosanteriormente? Acontece que o método update() sempre apaga os desenhosque feitos anteriormente desenhando um retângulo com o tamanho da área dedesenho preenchido com a cor de fundo. É possível sobrescrever o métodoupdate() para alterar esse comportamento, como veremos no capítulo sobreanimação, no entanto é necessário sempre repintar todos os desenhos queprecisam permanecer a cada ciclo, até por que eles podem ser afetados pelamovimentação ou encobrimento da área de desenho. No exemplo VII.3utilizamos um método do objeto da classe Graphics para desenhar um quadrado.Essa classe possui vários métodos semelhantes para desenho de figuras e texto.A tabela VII.3 descreve alguns métodos desta classe.Método DescriçãodrawArc desenha um arco elíptico.drawChars desenha o texto especificado por um array de bytesdrawline desenha uma linha entre dois pontos.drawRect desenha um retângulo.drawRoundRect desenha um retângulo com bordas arredondadas.drawImage desenha um imagem Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 226draw3Drect desenha um retângulo 3D.drawOval desenha um oval.drawPolygon desenha um polígono usando um vetor de pontos.drawString desenha um string.fillRect desenha um retângulo preenchido.fillRoundRect desenha um retângulo com bordas arredondadas preenchido.fill3Drect desenha um retângulo 3D preenchido.fillOval desenha um oval preenchido.fillPolygon desenha um polígono usando um vetor de pontos preenchido.getColor obtém a cor corrente.setColor define a cor corrente.getFont obtém a fonte corrente.setFont define a fonte corrente. Tabela VII.3 –Principais métodos da classe Graphics. O exemplo VII.4 mostra os uso de alguns métodos da classe Graphics. Oprograma, ao ser executado, mostra uma figura com um texto ao usuário e cadavez que o usuário pressiona o mouse a figura muda.import java.awt.*;import java.awt.event.*;import java.applet.*;public class Applet3 extends Applet{ private int i =0; private static final int x[] = {10,100,105,80,20}; private static final int y[] = {10,15,70,40,65}; public void init() { setLayout(null); setSize(200,150); this.addMouseListener(new SymMouse()); } public void paint(Graphics g) { switch(i) { case 0: g.setColor(Color.green); g.fillRect(10,10,100,100); g.setColor(Color.black); g.drawString("Quadrado",30,50); break; case 1: g.setColor(Color.red); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 227 g.fillOval(10,10,100,70); g.setColor(Color.black); g.drawString("Oval",50,50); break; case 2: g.setColor(Color.blue); g.fillPolygon(x,y,5); g.setColor(Color.black); g.drawString("Poligono",40,30); break; } i = (i+1)%3; } class SymMouse extends MouseAdapter { public void mouseClicked(MouseEvent event) { if (event.getSource()== Applet3.this) repaint(); } }} Exemplo VII.4 – Applet que desenha várias figuras na tela.Exibindo uma imagem Um dos métodos mais interessantes desta classe Graphics é o métododrawImage(), que permite exibir uma imagem. O exemplo VII.5 contém ocódigo de um applet que mostra uma imagem que muda quando o mouse épressionado. A imagem é carregada no exemplo está codificada no formato jpeg.Os tipos de imagens suportadas dependem do navegador sendo utilizado. Afigura VII.6 mostra o resultado da execução do Applet.import java.awt.*;import java.awt.event.*;import java.applet.*;public class Applet4 extends Applet{ Image img[]; private static int i=0; public void init() { img = new Image[2]; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 228 img[0] = getImage(getDocumentBase(),"baleia1.jpg"); img[1] = getImage(getDocumentBase(),"baleia2.jpg"); this.addMouseListener(new SymMouse()); } public void paint(Graphics g) { g.drawImage(img[i],0,0,this); i=i==0?1:0; } class SymMouse extends MouseAdapter { public void mouseClicked(MouseEvent event) { if (event.getSource() == Applet4.this) repaint(); } }} Exemplo VII.5 – Applet que exibe imagens. Primeiramente foi necessário obter objetos to tipo Image. Para issoutilizamos o método getImage() que possui dois parâmetros. O primeiro éuma URL que indica a localização do arquivo contendo a figura e o segundo é onome do arquivo da figura, que pode conter informação de diretório relativo àURL. Se o arquivo estiver no mesmo diretório de onde foi carregado o arquivoHTML então basta usar a método getDocumentBase(), como no exemploVII.5. Se o Se o arquivo estiver no mesmo diretório de onde foi carregado oApplet então basta usar o método getCodeBase(). Figura VII.6 – Saídas do Applet4. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 229 O método getImage() retorna null se o arquivo não foi encontrado,caso contrário um objeto do tipo Image é retornado. A carga de uma imagempode ser muito demorada, dependendo do tamanho é formato dearmazenamento, principalmente em se tratando de imagens transmitidas atravésde uma rede com alto trafego de dados. Além disso, no caso de Applets, ousuário pode mudar de página antes mesmo de uma imagem ser completamenteexibida. Por essas razões, o método getImage() foi projetado para retornarimediatamente, antes mesmo da carga da imagem, de modo que a tarefa decarregar a imagem é iniciada no momento em que a imagem é usada e é feita emparalelo com a execução do programa por outra linha (Thread) de execução.Threads são descritos em detalhes no capítulo VIII. Por ora basta visualizá-loscomo um tipo de processo leve que compartilha o mesmo espaço deendereçamento com outros Threads. Uma vez de posse de um objeto tipo Image podemos exibi-lo por meiodo método: Graphics.drawImage(Image img,int x,int y, ImageObserver O) O primeiro parâmetro é o objeto tipo Image. Os segundo e terceirodefinem a posição dentro Applet. O quarto parâmetro do tipoImageObserver é o que necessita ser melhor descrito. O objeto passadocomo quarto parâmetro deve implementar a interface ImageObserver, o queo habilita a receber notificações sobre a carga da imagem. Como a classeComponent implementa esta interface, então qualquer subclasse da classeComponent também a implementa, portanto, podemos passar o próprio Appletcomo parâmetro, usando a palavra chave this. O método drawImage() desenha a imagem no estágio em que elaestiver. Deste modo, se apenas metade da imagem tiver sido carregada entãoapenas metade será mostrada. Em alguns casos o programador pode quererexibir uma imagem apenas quando ela for completamente carregada. Isto podeser feito por meio de um objeto da classe MediaTracker. A classeMediaTracker é usada para acompanhar o status de objetos de mídia. Umobjeto de mídia pode ser imagens ou sons, no entanto, no momento apenasimagens são suportadas. O exemplo XX.XX mostra o uso de um objeto destaclasse para monitorar o status de uma imagem.public void init() { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 230 MediaTracker tr = new MediaTracker(this); im = getImage(getDocumentBase(),”img.gif”); tr.addImage(im,0); try { tr.waitForID(0); } catch (InterruptedException excep) {}} Exemplo XX.XX – Uso do MediaTracker. No exemplo XX.XX é criado uma instância da classe MediaTracker e osobjetos que devem ser monitorados são adicionados à instância por meio dométodo addImage(). Além da imagem também é atribuído um identificadorúnico que será usado para controlar a ordem de prioridade de carga do objeto.Também pode ser usado para identificar subconjuntos imagens. As imagens comnúmero menor possuem maior prioridade no processo de carga em relação asimagens com número maior. O início da carga da imagem é feita por meio dométodo:public void waitForID(int id) throwsInterruptedExceptionO identificador da imagem (ou do subconjunto de imagens) é passado porparâmetro para o método. Este método espera até que todas as imagens com oidentificador sejam carregadas. Se ocorrer algum erro na carga a imagem éconsiderada carregada. O programador deve usar os métodos isErrorAny()e isErrorID() para detectar a ocorrência de erros.Áudio O versão JDK1.0 oferece suporte para execução de arquivos de áudioapenas no formato AU. No entanto, o SDK1.2 estendeu este suporte paraarquivos de áudio no formato AIFF, WAV, MIDI (tipo 0 e 1) e RMF. Java podemanipular dados de áudio em 8 e 16bits. A classe usada tratamento de áudio é aAudioClip, que contém os seguintes métodos:• play() – Inicia a execução do audio clip.• loop() – Executa o audio clip em um loop. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 231• stop() – Para a execução do audio clip. Para se criar uma instância da classe AudioClip pode-se usar o métodogetAudioClip() da classe Applet: getAudioClip(URL url, String nome) O método retorna imediatamente mesmo que o arquivo de áudio nãoexista. O arquivo será carregado quando o programa tentar usá-lo. O ExemploVII.xx mostra um Applet que faz uso de um objeto AudioClip. import java.lang.*; import java.net.URL; public class ExSom extends java.applet.Applet { AudioClip som; public void init() { som = getAudioClip(getDocument(),”ola.au”); } public void start() {som.play();} } Exemplo VII.XX – Applet que executa um arquivo de audio.Obtendo parâmetros Na seção XX comentamos o formato do link HTML que faz referência aum arquivo em bytecodes. Comentamos também a existência de marcadores noformato <param name=“...” value=“...”>que são usados para passagem de parâmetros do HTML para o programa embytecodes. Nesta seção é mostrado o código Java necessário para capturar essesparâmetros. De modo a facilitar a explicação faremos uso de um exemplo. Oexemplo VII.7 mostra o código HTML que passa dois valores e o exemplo VII.8mostra um código em Java que recebe os parâmetros.<HTML> Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 232<applet code=“Applet5.class” width=400 height=250><param name=“numero” value=“5”><param name=“nome” value=“Ana”></APPLET></HTML> Exemplo VII.7 – Código HTML passando valores.import java.awt.*;public class Applet5 extends java.applet.Applet{ Label label1 = new Label(); public void init() { setLayout(null); int i = Integer.parseInt(getParameter(“numero”)); setSize(150,87); label1.setText(getParameter(“nome”)+ “:”+i); add(label1); label1.setBounds(24,12,84,48); }} Exemplo VII.8 – Applet que recebe parâmetros. Os valores são recebidos por meio do método getParameter() querecebe como argumento o nome do parâmetro definido no código HTML. Osvalores são retornados como objetos do tipo String. Se não existir um parâmetrocom o nome passado para o método getParameter() o retorno será null. O programador também pode definir o método getParameterInfo(),cuja única ação é retornar um array de duas dimensões, contendo as informaçõessobre os parâmetros. As informações armazenadas são o nome, tipo e descriçãode cada parâmetro. Este método pode ser usado pelos navegadores Web paraajudar ao usuário a definir os valores a serem passados para o Applet.public String[][] getParameterInfo(){String[][] info = {{“numero”,”int”,”number qualquer”}, {“nome”,”string”,”nome de alguem”}}; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 233 return info;} Exemplo VII.9 – Definindo informações sobre os parâmetros .Executando um Applet como aplicação Algumas vezes desejamos desenvolver um programa que possa funcionarcomo aplicação e como Applet. Podemos atingir este objetivo criando ummétodo main() dentro da subclasse Applet que está sendo implementada. Ométodo main() deve criar uma instância da classe Frame e adicionar a ele umobjeto da subclasse do Applet. O exemplo VII.10 mostra como criar um métodomain() para o Applet do exemplo VII.1. import java.awt.*; import java.applet.*; public class Applet6 extends Applet { Label label1 = new Label(); public void init() { setLayout(null); setSize(150,87); label1.setText("Ola Mundo!"); add(label1); label1.setBounds(24,12,84,48); } static public void main(String[] args) { FrameX frame = new FrameX("OLA"); Applet6 applet = new Applet6(); frame.add("Center", applet); frame.setSize(200,100); frame.setVisible(true); applet.init(); applet.start(); } } Exemplo VII.10 – Applet com método main.Preparando Applets para produção e arquivos JARs Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 234 Após o desenvolvimento e teste do Applet chega o momento de colocá-loem produção. Isto é feito colocando a página HTML que faz referência aoarquivo em bytecodes, resultante da compilação do Applet, em um diretórioacessado por um servidor Web. Você já deve ter notado que cada classe Javagera um arquivo em bytecodes. Deste modo, um arquivo contendo várias classesem Java gerará, após a compilação vários arquivos de bytecodes, um para cadaclasse. No caso de Applets com um tamanho razoável pode ser gerado umgrande número de arquivos. Isto pode ser um problema em se tratando de umaaplicação que é projetada para ser transmitida em uma rede de longa distânciapor meio do protocolo HTTP, já que cada classe irá gerar uma transação HTTPquando for referenciada pela primeira vez. Além disso, apesar do código embytecodes ser menor do que o código gerado pela compilação da maioria dosprogramas escritos em outras linguagens de programação seria importantediminuir o máximo possível o tamanho dos arquivos, de modo a minimizar otráfego na rede. Para solucionar esses e outros problemas foi introduzido a partirda versão 1.1 da linguagem Java o formato de arquivo JAR (Java Archive). Oformato de arquivo JAR permite o agrupamento de vários arquivos em um únicoarquivo. Além disso, o formato JAR permite a compressão de dados de modootimizar o armazenamento e a transmissão de dados. O principais benefícios douso do formato JAR são os seguintes:• Menor tempo de carga de Applets: Se todos os arquivos relacionados com um Applet estão agrupados em um único arquivo JAR, apenas uma transação HTTP será necessária para carregar o Applet. Este tempo será ainda menor se os arquivos estiverem compactados.• Segurança: o conteúdo do arquivos JAR podem ser assinados digitalmente. Deste modo, os usuários que reconhecerem a sua assinatura podem conceder privilégios para acessar recursos que não estariam disponíveis, caso contrário.• Portabilidade: a API para manipulação dos arquivos JAR é parte integrante do núcleo da biblioteca de classes de Java, o que a torna independente de plataforma. Outros benefícios foram adicionados com o lançamento da versão 1.2 doSDK, como por exemplo, informações sobre versão. Os arquivos contidos em um arquivo JAR podem ser de tipos variados como,como bytecodes, imagens e sons, podendo pertencer a um Applet, aplicação ousimplesmente a uma biblioteca de classes. Além disso, um arquivo JAR podeconter uma descrição dos arquivos armazenados, chamada de manifest. O SDK Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 235vem com uma ferramenta para criação e manutenção de arquivos JAR. Oformato mais comum de invocação do programa é: jar [opções] destino arquivo(s)-de-entradaonde destino é o nome do arquivo, arquivo(s)-de-entrada representa onome dos arquivos que serão incluídos no arquivo JAR e opções é umacoleção de letras com o seguinte significado: Opções Descrição c Cria um arquivo novo. t Lista o conteúdo. x Extrai todos os arquivos. x file Extrai o arquivo especificado. f Indica que o nome do arquivo de saída, caso seja a criação de um arquivo, ou de entrada caso contrário, será especificado. Sem essa opção o programa jar assume que saída ou a entrada será a padrão. m Indica que o primeiro argumento será o nome de um arquivo manifest criado pelo usuário. v Gera saída com os detalhes da execução. O Não comprime os arquivos. Usada para criar arquivos JAR que podem ser colocados no classpath. M Não cria o arquivo manifest. Se um subdiretório for incluído nos arquivos de entrada então osubdiretório será automaticamente inserido no arquivo JAR, incluindo os seussubdiretórios. As informações sobre o caminho até o arquivo é tambémarmazenada. Para invocar um Applet inserido em um arquivo JAR utilize a palavrachave archive no arquivo HTML. O exemplo VII.11 mostra como invocar umApplet desta forma. <applet code=meuApplet.class archive=meuarquivo.jar width=width height=height> </applet> Exemplo VII.10 – Applet com método main. No caso de uma aplicação é necessário passar o arquivo JAR comoparâmetro. Na versão JDK1.1 é preciso usar o comando jre no lugar do Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 236comando java. Por exemplo, suponha que armazenamos um aplicação, cujaclasse principal é Mainclass, em um arquivo arq.jar. Para executá-labasta digitar o comando: jre -cp arq.jar Mainclassonde a opção cp indica que o arquivo arq.jar deve ser anexado aoclasspath. Já na versão SDK1.2 usa-se o comando java, sendo que oarquivo JAR deve conter um manifest indicando a classe principal: java -jar arq.jar A tabela VII.4 mostra alguns exemplos do uso do utilitário que geraarquivos JAR.jar cf meuarq.jar *.class Cria um arquivo JAR com o nome meuarq.jar contendo todos os arquivos de classes do diretório corrente. Um arquivo manifest é gerado automaticamente.jar cmf meuarq.jar Como o exemplo anterior, porém o arquivo manifestmeuManifest.mf *.class meuManifest.mf é adicionado.jar tf meuarq.jar Lista o conteúdo do arquivo meuarq.jar.jar xf meuarq.jar Extrai todos os arquivos contidos em meuarq.jar. Tabela VII.4 –Exemplos do uso do comando jar.Criando os próprios arquivos manifest A opção m da ferramenta para criação de arquivos JAR permite adicionarinformações ao arquivo manifest default. É necessário que o usuário crie umarquivo contendo as adições que devem ser feitas. O formato básico do comandoé: jar cmf arq_adições arq_jar arquivo(s) O arquivo de adições é simplesmente um arquivo texto é composto porum conjunto de declarações. Por exemplo se o usuário quiser especificar que aclasse que deve ser usada como ponto de entrada é a classe Mainclass, entãobasta inserir a seguinte linha no arquivo de adições: Main-Class: Mainclass Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 237ExercíciosFaça uma calculadora com o seguinte layout: 9 8 7 + 6 5 4 - 3 2 1 * 0 . = /Agenda Eletrônica versão Applet 1.0 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 238Capítulo X JavaBeanO que é um JavaBean? A API JavaBeans é a especificação que torna possível escrevercomponentes de software na linguagem Java. Componentes são peças desoftware, análogas a bloquinhos de montar, reutilizáveis, auto-contidas e quepodem ser usadas para comporem visualmente outros componentes, Applets,aplicações e Servlets usando um ambiente de desenvolvimento que suporte aespecificação de JavaBeans. Componentes JavaBean são conhecidos comoBeans. Diferente de outras ferramentas de programação, como Delphi ou VB, osuporte ao desenvolvimento de componentes foi acrescentado, de formaelegante, na linguagem Java sem alterá-la.JavaBeans são classes Java comuns que seguem na sua construção umaespecificação que permite o seu uso visual em ambientes RAD. JavaBeans foram projetados para trabalhar em conjunto com ferramentasde desenvolvimento "JavaBeans-enabled".JavaBeans e ferramentas RAD As ferramentas de desenvolvimento expõem as características públicas doBean visualmente. Eles obtêm as características do Bean (propriedades, métodose eventos) em um processo conhecido como introspection. A introspection podeser feita de duas maneiras:• Através da utilização de Reflection para o obtenção dos métodos, e do uso das convenções para determinação dos eventos e propriedades.• Por uso de uma class de informações denominada BeanInfo. Uma classe BeanInfo implementa a interface BeanInfo. Uma classe BeanInfo explicitamente lista todas as características do Bean que devem ser expostas para o ambiente de desenvolvimento. As tão faladas propriedades são características do Bean que podem sermudadas durante a programação. O ambiente de desenvolvimento faz a Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 239introspeção em um Bean para descobrir as propriedade e expo-las paramanipulação. Os Beans utilizam eventos para se comunicarem com outros Beans. Osambientes de desenvolvimento pode examinar os Beans e determinarem queeventos um determinado Bean pode disparar (fire) ou que eventos ele podemanipular (receive). Os métodos das classes que compõem um Bean são métodos Java simples,que podem ser chamados por qualquer outras classes. JavaBean é um padrão desenhado para ser utilizado por um ambientes dedesenvolvimento RAD. E todas as suas características foram projetas parapermitir o uso fácil por programadores sem modificar a linguagem Java. Nospróximos tópicos veremos as convenções de nomes e o funcionamento eutilização dessa poderosa especificação.Propriedades Em JavaBeans propriedade é um atributo público simples que pode ser deleitura/escrita, apenas leitura ou apenas escrita. Existem quatro tipos depropriedades: simples, indexada, ligada (bound), e restrita (constrained).Simples Representa um valor simples (Ex.: int, float, Object, ...). Pode serdefinida com um par de métodos getXxx/setXxx, onde xxx é o nome dapropriedade. Se for definido os dois métodos para a propriedade, esta será deleitura/escrita, caso seja definido apenas o método getXxx a propriedade seráapenas leitura, e finalmente se for definida apenas o método setXxx será apenasescrita. Quando uma propriedade for booleana, a convenção e modificada paraisXxx ou invés de getXxx (no desenho dessa característica resolveram aderir amáxima “toda regra possui uma exceção”). Abaixo temos o exemplo de uma classe que define uma propriedade: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 240Class Pessoa{ private String nome; private String telefone; private String endereço; public Pessoa(String n, String t, String e) { nome = n; telefone = t; endereço = e; } public void setNome(String n) { nome=n; } public void setTelefone(String t) telefone = t; } public void setEndereço(String e) { endereço = e; } public String getNome() { return nome; } public String getTelefone() { return telefone; } public String getEndereço() { return endereço; }} A classe acima define as propriedades simples: telefone, nome eendereço, sendo todas as três propriedades de leitura/escrita.Indexada Representa um array de valores (ex.: int[], float[], Object[] , ...). Osmétodos getXxx/setXxx que definem a propriedade devem ter como parâmetroum inteiro que será o índice de acesso ao array. A propriedade pode tambémsuportar getXxx/setXxx para todo o array.O exemplo abaixo trás a definição parcial de uma classe agenda:Public class Agenda{ private Pessoa pessoas[]; . . . Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 241 public Pessoa[] getPessoas(){return pessoas;} public void setPessoas(Pessoa[] i){ this.pessoas = i; } public Pessoa getPessoas(int indice){ return pessoas[indice]; } public void setPessoas(int indice, Pessoa p){ pessoas[indice] = p; } . . .} Neste exemplo, definimos uma propriedade indexada pessoas, que podeser acessada tanto na forma de uma array completo, quanto nos seus elementos,através dos seus índice.Ligada (Bound) Uma propriedade bound notifica outros objetos quando o seu valor ealterado. Toda vez que o valor de uma propriedade bound é modificado, apropriedade dispara um evento PropertyChange que contém o nome, o novoe o velho valores da propriedade.Class Pessoa { private String nome; private String telefone; private String endereço; Private PropertyChangeSupport changes = New PropertyChangeSupport(this); public Pessoa(String n, String t, String e) {nome = n; telefone = t; endereço = e;} public void addPropertyChangeListener(PropertyChangeListener l){ changes.addPropertyChangeListener(l); } public Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 242 void removePropertyChangeListener(PropertyChangeListener l) { changes.removePropertyChangeListener(l); } public void setNome(String n) { String nomevelho = nome; Nome = n; Changes.firePropertyChange(“nome”, nomevelho, nome); } public void setTelefone(String t) { String telefonevelho = telefone; telefone = t; Changes.firePropertyChange(“telefone”, telefonevelho,telefone); } public void setEndereço(String e) { String endereçovelho = endereço; endereço = e; Changes.firePropertyChange(“endereço”, nomeendereço,endereço); } public String getNome() { return nome; } public String getTelefone() { return telefone; } public String getEndereço() { return endereço; }} A classe Pessoa já foi implementada anteriormente neste capítulo, asmodificações introduzidas tornaram as propriedades nome, telefone e endereçoligadas, i. e., sempre que elas sofrerem alterações, os listener que implementamPropertyChangeListener e estão registrados como ouvintes da nossainstância da classe, serão notificados. Além das alterações no corpo dos métodos setXxx, que adicionou ocódigo que dispara o evento PropertyChange, nosso Bean também ganhouum novo objeto changes e dois métodos que cuidam do registro e exclusão delistener.Restringidas(Constrained) Um objeto com propriedade restrita permite que outros objetos vetem aalteração do valor dessa propriedade. listener de propriedades restritas podem Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 243vetar uma mudança de valor da propriedade através de uma exceçãoPropertyVetoException que é levantada. Geralmente, apesar de não serobrigatório, as propriedades restringidas também são ligadas.class CartãoCrédito{ private String número; private PropertyChangeSupport changes = new PropertyChangeSupport(this); private VetoableChangeSupport vetos = new VetoableChangesSupport(this); public addVetoableChangeListener(VetoableChangeListener l){ vetos.addVetoableChangeListener(l); } public removeVetoableChangeListener(VetoableChangeListener l){ vetos.removeVetoableChangeListener(l); } . . . public void setNúmero(String n) { String numeroVelho = numero; Vetos.fireVetoableChange(número,numeroVelho,n); número = n; changes.firePropertyChange(número,numeroVelho,numero);} . . .} No exemplo acima definimos parcialmente uma classe com o nomeCartãoCrédito, esta classe possui uma propriedade de nome número que é umapropriedade restringida. Para implementamos esta característica, primeirointroduzimos uma novo objeto, veto, que nos dá o suporte ao registro doslistener que terão poder de veto sobre a propriedade. Em seguida aparecem dois métodos que cuidam apropriadamente,repassando para VetoableChangeSupport, do registro dos listener quepodem vetar alterações. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 244A parte mais interessante fica por conta do método setNúmero, ele é muitoparecido com um método de uma propriedade ligada, mas acrescenta uma linhaantes de alterar o valor da variável número. Sendo assim, a alteração só serárealizada, se o evento disparado com fireVetoableChange não levantarnenhuma exceção. Depois disso tudo, as coisa voltam a funcionar como em umapropriedade ligada convencional.Eventos Sempre que estudamos algo, inicialmente obtemos uma grandequantidade de informações e depois começamos a fazer generalizaçõestransformando o estudado em conhecimento. Bem, até agora vimos queJavaBeans é um padrão que nos permite utilizar um ambiente de programaçãoRAD, e vimos algumas características de classes que seguem este padrão. Mas além desse padrão definir como as classes interage com o ambientede programação, ele também define como objetos destas classes interagem entresi. Aparece agora o conceito de eventos, que já vimos em capítulo anterior eagora veremos com as convenções de nossa API de componentes. Um bom lugar para começarmos é: o que é um evento? Para nossospropósitos um evento é um objeto que encapsula dados a respeito de algumacoisa que ocorreu. Por exemplo, o mouse foi movido, uma tecla foi digitada,chegou um pacote UDP pela rede. Todas estas ocorrências podem ser modeladascomo eventos e informações sobre o que aconteceu podem ser inclusas no objetoevento. Só para relembrar, no novo modelo de eventos da biblioteca de classesJava, um evento e “escutado” por classes que estão “capacitadas” para tratá-los,estas classes são chamadas de EventListener, e são um mecanismo geral decomunicação entre objetos sem a utilização de herança. Nesta seção, devemos nos preocupar apenas com as convenções denomes de eventos e classes relacionadas para utilização na construção de Beans.Suponhamos que nos desejamos construir um Bean de nome Timer. Nossoevento teria o nome TimerEvent, e nosso Listener para este eventoTimerEventListener. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 245 Na próxima seção veremos como juntar todos estes conceitos e o queaprendemos ate agora em um exemplos de Bean completo um não-visual, umBean visual será mostrado no capítulo sobre MVC.Um Bean para ser visual deve ser subclasse de java.awt.Component ou declasses que herdem java.awt.Component.Desenvolvimento do exemplo O Bean de exemplo que estudaremos agora é um componente que disparaum evento periodicamente em um intervalo de tempo definido pelo seuutilizador, este componente e semelhante ao componente Timer do Delphi e aoActiveX Timer do VB. Suas aplicações incluem atualizar o display de umrelógio ou acionar o método que mostra o próximo frame de uma animação. Nosso primeiro Bean será composto das seguintes classes:TimerBean - A classe principal do Bean;TimerEvent - A classe do evento disparado pelo Bean;TimerEventListener - A interface “ouvinte” para o evento do Bean;TimerEventListenerA classe TimerEventListener implementa a interface que será utilizada para queo nosso Bean notifique seus listeners sobre cada evento.Package timer;public interface TimerEventListener extends java.util.EventListener{ void timerEventDisparado(TimerEvent te);} Todos os listeners para JavaBeans devem herdar java.util.EventListenerou de alguma subclasse dela. O nome da interface deve ser XxxxListener, ondeXxxx corresponde ao nome do evento que esta interface habilita a tratar. Nonosso exemplo temos o evento TimerEvent e consequentemente a interface sechama TimerEventListener. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 246 Uma interface listener pode declarar quantos métodos seu desenvolvedordesejar. Normalmente estes métodos têm como parâmetro um objeto event. Nonosso caso declaramos somente um método.TimerEventA classe TimerEvent implementa o evento que será passado para cadaTimerEventListener.package timer;public class TimerEvent extends java.util.EventObject{ public TimerEvent(Object source) { super(source); }} Todos eventos JavaBeans devem herdar java.util.EventObject e seu nomedeve obedecer ao padrão XxxxEvent, onde Xxxx é arbitrário. No nosso casoficamos com o nome TimerEvent. Nosso construtor para a classe TimerListener tem como parâmetro umobjeto do tipo Object, e quando este construtor for chamado passaremos areferência para o objeto que o esta chamando. Eventos, por serem classes comuns, também podem carregar informaçõesadicionais, o que não é o nosso caso.TimerBean Esta é a nossa classe principal, e é onde realmente implementamos nossoBean.package timer;import java.util.*; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 247import java.beans.*;public class TimerBean implements java.io.Serializable, Runnable{ protected long intervalo = 1000; transient protected Thread th; protected java.util.Vector listeners = newjava.util.Vector(); private boolean ativo = false; private java.beans.PropertyChangeSupport mudancas = new java.beans.PropertyChangeSupport(this); public TimerBean() { super(); th = new Thread(this); th.start(); } public void addPropertyChangeListener( PropertyChangeListener l) { mudancas.addPropertyChangeListener(l); } public void addTimerEventListener(TimerEventListener tl) { listeners.addElement(tl); } public void disparaEvento(TimerEvent e) { Vector v; synchronized (this) { v = (Vector) listeners.clone(); } for (int elem = 0; elem < v.size(); elem++) { ((TimerEventListener)v.elementAt(elem)).timerEventDisparado(e); } } public long getIntervalo() { return intervalo; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 248 } public synchronized void inicia() { ativo = true; } public synchronized void para() { ativo = false; } public void removePropertyChangeListener(PropertyChangeListener l) { mudancas.removePropertyChangeListener(l); } public void removeTimerEventListener(TimerEventListener tl) { listeners.removeElement(tl); } public void run() { try { while (true) { th.sleep(intervalo); if (ativo) { TimerEvent evento = new TimerEvent(this); disparaEvento(evento); } } }catch (Exception e) {e.printStackTrace(); } } public void setIntervalo(long interv) { long valorVelho = intervalo; intervalo = interv; mudancas.firePropertyChange("intervalo", new Long(valorVelho), new Long(intervalo)); }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 249 Comecemos pelo princípio. Todos os Beans devem ser serializáveis, esteé o mecanismo que é normalmente utilizado para armazenar aplicaçõesJavaBeans. Para tornarmos nossa classe serializável declaramos que estaimplementa a interface java.io.Serializable e marcamos nossos campos que nãosão serializáveis como transient ou providenciarmos métodos de serializaçãocustomizados. Nossa classe também implementa Runnable para podermos utilizá-la emum thread. Em nossa classe possuímos os campos:1. intervalo: que armazena de quanto em quanto tempo desejamos que um evento seja disparado. Através dos métodos getIntervalo() e setIntervalo(long) implementamos uma propriedade bound de nome “intervalo”.2. th: Este campo é transient, isto é, quando esta classes for serializada esta informação não será gravada. Para nosso Bean th é o thread que periodicamente dispara eventos para seus listeners.3. listeners: Um Vector armazena a lista de listeners que estão registrados neste Bean para receber os eventos. Novos métodos são colocados em nossa classes para registrar ou remover listeners, este métodos tem nomes que seguem o padrão JavaBeans e têm as formas addXxxx e removeXxxx, onde Xxxx é o nome do tipo de listener que deve ser registrado ou removido. No nosso exemplo, temos addTimerEventListener e removeTimerEventListener.4. ativo: este campo é utilizado para indicar para o Bean se ele deve ou não disparar eventos para os seus listeners. Ativo não é acessado diretamente, e sim através dos métodos sincronizado para() e inicia(). Os métodos que merecem destaque são: 1. run(): método que implementa o thread, em nosso caso ele contém um laço infinito e dentro do laço, depois de fazer nosso thread “dormir”, com sleep, ele verifica se deve disparar um evento. Se deve dispará-lo, um evento e criado e o método disparaEvento e chamado. 2. disparaEvento(TimerEvent e): inicialmente este método cria dentro de uma seção sincronizado uma cópia do Vector listener. Em seguida através de um laço for, percorre este Vector chamando o método timerEventDisparado para cada listener registrado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 250Temos agora um exemplo completo de um JavaBeans. Mas esta tecnologia tempouca ou nenhuma utilidade se não a utilizarmos com ferramentas deprogramação visual como Visual Age, Visual Café, BDK e tantos outros. Como o BDK é de graça, nós o utilizaremos para mostrar nosso Bean emação.Instalando o Beans Development Kit (BDK) O Beans Development Kit (BDK) é uma aplicação Java pura, portanto sódepende do SDK para rodar. O BDK possui suporte para a API JavaBeans e umcontainer de teste (BeanBox), que manipula Beans visualmente. Para instalar o BDK basta ter na maquina o SDK instalado (acima do1.1.4), entrar na pagina http://www.javasoft.com e fazer download edescompactá-lo. Pronto, e só rodar. Acompanhando o BDK temos tambémdocumentação e JavaBeans com código fonte para serem explorados.Testando exemplo no BDK Para rodar o BDK utilizamos o arquivo run.bat ou run.sh, dependendo doseu sistema operacional. Quando o aplicativo e inicializa sua área de trabalhafica parecido com a figura abaixo. O BDK é composto de 3 janelas: • BeanBox: que é a janela onde os Beans são manipulados visualmente; • ToolBox: uma lista de Beans que podem ser usados; • Properties: um janela que se altera dependendo do Bean que esta selecionado no BeanBox. Ela mostra as propriedades do Bean selecionado e através dela o desenvolvedor pode alterar estas propriedade no Componente; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 251 Com o BDK rodando nosso próximo passo e criar um arquivo jarcontendo o nosso Bean compilado. Para criarmos um jar contendo Beans, devemos informar para aferramenta na qual este Bean será utilizado, quais classes são Beans. Para issoutilizamos o arquivo de manifesto do jar. Que ficaria assim para o nosso caso:Nome do arquivo: manifest.mfManifest-Version: 1.0Name: timer/TimerBean.classJava-Bean: TrueName: timer/TimerEventListener.className: timer/TimerEvent.class Para criar o arquivo jar, dentro do diretório que contenha o diretóriotimer, que é onde estão nossas classes compiladas, digite: jar cvfm timer.jar manifest.mf . Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 252 Com nosso jar criado temos agora que apresenta-lo ao BDK. Para issodevemos utilizar a opção File->LoadJar do menu da Janela BeanBox.Escolhemos então o arquivo jar que geramos, e o BDK irá carrega-lo. Apóscarregar nosso Bean a lista de Beans do ToolBean será adicionada de um entradachamada TimerBean, como mostrado na figura abaixo: Agora é tudo mais divertido, acabou a parte chata!!! Vamos começar a colocar os Beans na janela BeanBox para criarmosuma aplicação. Devemos colocar os seguintes Beans: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 253 Bean Propriedade(mudada) Novo valor Ourbutton label Iniciar Ourbutton label Parar TimerBean intervalo 2000 EventMonitor A posição dos Beans deve ser como na figura abaixo: Depois de colocar todos os Beans no lugar e mudarmos suaspropriedades, devemos conectar os eventos nos métodos corretos de cada Bean.Para ligar um evento disparado por um Bean a um método de outro, devemosselecionar o primeiro e clicarmos em Edit->Events, escolhermos o evento eclicarmos no Bean alvo. Um dialogo aparecerá com os métodos que podem serescolhidos para serem chamados. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 254Bean fonte Evento Bean alvo MétodoTimerBean TimerEvent- EventMonitor InitiateEventSourceMonito timerEventDisparado ring()OurButton action-actionPerformed TimerBean inicia()(iniciar)OurButton action-actionPerformed TimerBean para()(parar) A figura abaixo mostra parte da operação. Depois de tudo ligado, para testar basta clicar no botão de iniciar, entãoeventos serão disparados e aparecerão no Monitor de eventos. Depois clique nobotão parar parar para que os eventos deixem de ser disparados pela instância deTimerBean . Uma opção interessante para teste no BDK e clicarmos na opção demenu View->Disable Design Mode. A figura abaixo mostra o teste do Bean. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 255Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 256Capítulo XI - Concorrência Um sistema operacional é dito concorrente se permite que mais que umatarefa seja executada ao mesmo tempo. Na prática a concorrência real ouparalelismo só é possível se o hardware subjacente possui mais de umprocessador. No entanto, mesmo em computadores com apenas um processadoré possível obter um certo tipo de concorrência fazendo com o processadorcentral execute um pouco de cada tarefa por vez, dando a impressão de que astarefas estão sendo executadas simultaneamente. Dentro da nomenclatura empregada, uma instância de um programa emexecução é chamada de processo. Um processo ocupa um espaço em memóriaprincipal para o código e para as variáveis transientes (variáveis que sãoeliminadas ao término do processo). Cada processo possui pelo menos uma linhade execução (Thread). Para ilustrarmos o que é uma linha de execução suponhaum determinado programa prog1. Ao ser posto em execução é criado umprocesso, digamos A, com uma área de código e uma área de dados e é iniciadaa execução do processo a partir do ponto de entrada. A instrução inicial assimcomo as instruções subsequentes formam uma linha de execução do processo A.Portanto, um thread nada mais é que uma sequência de instruções que está emexecução de acordo com que foi determinado pelo programa. O estado correnteda linha de execução é representada pela instrução que está sendo executada. Afigura IX.1 mostra a relação entre estes elementos. arquivo prog1 Memória Principal Área de código 101001101 101001101 Linha de execução 010110010 010110010 010101100 010101100 (thread) 100011101 100011101 Processo Área de dados 100101010 101001010 Figura IX.1 – Relação entre Programa, Processo e Thread. É possível existir mais de uma linha de execução em um único processo.Cada linha de execução pode também ser vista como um processo, com a Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 257diferença que enquanto cada processo possui sua área de código e dadosseparada de outros processos, os threads em um mesmo processo compartilhamo código e a área de dados. O que distingue um thread de outro em um mesmoprocesso é a instrução corrente e uma área de pilha usada para armazenar ocontexto da sequência de chamadas de cada thread. Por isso os threads tambémsão chamados de processos leves (light process). A figura IX.2 mostraesquematicamente a diferença entre processos e threads. Memória Processo A 10100 01001 B 11001 1010001001110 10100 01010 0101010101010 01001 1010 11001 1010000101101 1010100010101 Thread 1 0111 01010 1010 Código 0101011011001 0101010100101 0111 0101010010101 Thread 2 C 0101001000000 1010101010101 10100 01001 11001 10100111001 Área de pilha 01010101010 01010 10101010101 do thread2 1010 Dados 01010101000 11110101010 0111 Área de pilha do thread1 Figura IX.2 – (a) Processos; (b) Threads. Sistemas monotarefas e monothreads como o DOS possuem apenas umprocesso em execução em um determinado instante e apenas um thread noprocesso. Sistemas multitarefas e monothreads como o Windows 3.1 permitemvários processos em execução e apenas um thread por processo. Sistemasmultitarefas e multithread como o Solaris, OS/2, Linux e Windows 95/98/NTpermitem vários processos em execução e vários threads por processo. Como os threads em um mesmo processo possuem uma área de dados emcomum, surge a necessidade de controlar o acesso a essa área de dados, de modoque thread não leia ou altere dados no momento que estão sendo alterados poroutro thread. A inclusão de instruções para controlar o acesso a áreascompartilhadas torna o código mais complexo do que o código de processosmonothreads. Uma pergunta pode surgir na mente do leitor: se a inclusão de mais deum thread torna o código mais complexo porque razão eu deveria projetarcódigo multithread. Processos com vários threads podem realizar mais de uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 258tarefa simultaneamente. São úteis na criação de processos servidores, criação deanimações e no projeto de interfaces com o usuário que não ficam travadasdurante a execução de alguma função. Por exemplo, imagine um processoservidor a espera de requisições de serviços, podemos projetá-lo de modo que aosurgir uma solicitação de um serviço por um processo cliente ele crie um threadpara atender a solicitação enquanto volta a esperar a requisição de novosserviços. Com isto os processos clientes não precisam esperar o término doatendimento de alguma solicitação para ter sua requisição atendida. O mesmo pode ser dito em relação ao projeto de interfaces com ousuário. O processo pode criar threads para executar as funções solicitadas pelousuário, enquanto aguarda novas interações. Caso contrário, a interface ficariaimpedida de receber novas solicitações enquanto processa a solicitação corrente,o que poderia causar uma sensação de travamento ao usuário. Outra aplicação para processos multithread é a animação de interfaces.Nesse caso cria-se um ou mais threads para gerenciar as animações enquantooutros threads cuidam das outras tarefas como por exemplo entrada de dados. A rigor todas as aplicações acima como outras aplicações de processosmultithread podem ser executados por meio de processos monothreads. Noentanto, o tempo gasto na mudança de contexto entre processos na maioria dossistemas operacionais é muito mais lenta que a simples alternância entre threads,uma vez que a maior parte das informações contextuais são compartilhadas pelosthreads de um mesmo processo. Mudança de Contexto (task switch) É o conjunto de operações necessárias para gravar o estado atual do processo corrente erecuperar o estado de outro processo de modo a torná-lo o processo corrente. Mesmo que você não crie mais de um thread todo processo Java possuivários threads: thread para garbage collection, thread para monitoramento deeventos, thread para carga de imagens, etc.Criando threads em Java Processos Multithread não é uma invenção da linguagem Java. É possívelcriar processos multithread com quase todas as linguagens do mercado, comoC++, e Object Pascal. No entanto Java incorporou threads ao núcleo básico dalinguagem tornado desta forma mais natural o seu uso. Na verdade o uso de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 259threads está tão intimamente ligado a Java que é quase impossível escrever umprograma útil que não seja multithread. A classe Thread agrupa os recursos necessários para a criação de umthread. A forma mais simples de se criar um thread é criar uma classe derivadada classe Thread. Por exemplo: class MeuThread extends Thread { ... } É preciso também sobrescrever o método run() da classe Thread. Ométodo run() é o ponto de entrada do thread, da mesma forma que o métodomain() é ponto de entrada de uma aplicação. O exemplo IX.1 mostra umaclasse completa. public class MeuThread extends Thread { String s; public MeuThread (String as) { super(); s = new String(as); } public void run() { for (int i = 0; i < 5; i++) System.out.println(i+” “+s); System.out.println("FIM! "+s); } } Exemplo IX.1 – Subclasse da classe Thread. No exemplo IX.1foi inserido um atributo para identificar o thread, apesarde existir formas melhores de se nomear um thread como veremos mais adiante.O método run() contém o código que será executado pelo thread. No exemploIX.1 o thread imprime cinco vezes o atributo String. Para iniciar a execução deum thread cria-se um objeto da classe e invoca-se o método start() doobjeto. O método start() cria o thread e inicia sua execução pelo métodorun(). Se o método run() for chamado diretamente nenhum thread novo serácriado e o método run() será executado no thread corrente. O exemplo IX.2mostra uma forma de se criar um thread usando a classe definida no exemploIX.1. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 260 public class TesteThread1 { public static void main (String[] args) { new MeuThread("Linha1").start(); } } Exemplo IX.2 – Criação de um Thread. No exemplo acima apenas um thread, além do principal é criado. Nadaimpede que sejam criados mais objetos da mesma classe para disparar umnúmero maior de threads. O exemplo IX.3 mostra a execução de dois threadssobre dois objetos de uma mesma classe. public class TesteThread2 { public static void main (String[] args) { new MeuThread("Linha1").start(); new MeuThread("Linha2").start(); } } Exemplo IX.3 – Criação de dois Threads. Cada thread é executado sobre uma instância da classe e, porconsequência, sobre uma instância do método run(). A saída gerada pelaexecução do exemplo IX.3 depende do sistema operacional subjacente. Umasaída possível é a seguinte: 0 Linha2 0 Linha1 1 Linha2 1 Linha1 2 Linha2 2 Linha1 3 Linha2 3 Linha1 4 Linha2 4 Linha1 FIM! Linha2 FIM! Linha1 A saída acima mostra que os threads executam intercaladamente. Noentanto, em alguns sistemas operacionais os threads do exemplo IX.3executariam um após o outro. A relação entre a sequência de execução e osistema operacional e dicas de como escrever programas multithread com Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 261sequência de execução independente de plataforma operacional serão em umaseção mais adiante neste mesmo capítulo.Criando threads por meio da interface Runnable Algumas vezes não é possível criar uma subclasse da classe Threadporque a classe já deriva outra classe, por exemplo a classe Applet. Outrasvezes, por questões de pureza de projeto o projetista não deseja derivar a classeThread simplesmente para poder criar um thread uma vez que isto viola osignificado da relação de classe-subclasse. Para esses casos existe a interfaceRunnable. A interface Runnable possui apenas um método para serimplementado: o método run(). Para criar um thread usando a interfaceRunnable é preciso criar um objeto da classe Thread, passando para oconstrutor uma instância da classe que implementa a interface. Ao invocar ométodo start() do objeto da classe Thread, o thread criado, inicia suaexecução no método run() da instância da classe que implementou a interface.O exemplo IX.4 mostra a criação de um thread usando a interface Runnable. public class TesteThread2 implements Runnable { private String men; public static void main(String args[]) { TesteThread2 ob1 = new TesteThread2 (“ola”); Thread t1 = new Thread(ob1); t1.start(); } public TesteThread2 (String men) {this.men=men;} public void run() { for(;;) System.out.println(men); } } Exemplo IX.4 – Criação de um thread por meio da interface Runnable. Note que agora ao invocarmos o método start() o thread criadoiniciará a execução sobre o método run() do objeto passado como parâmetro, enão sobre o método run() do objeto Thread. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 262 Nada impede que seja criado mais de um thread executando sobre omesmo objeto:Thread t1 = new Thread(ob1);Thread t2 = new Thread(ob1); Neste caso alguns cuidados devem ser tomados, uma vez que existe ocompartilhamento das variáveis do objeto por dois threads. Os problemas quepodem advir de uma situação como esta serão tratados mais adiante.A classe Thread A classe Thread é extensa, possuindo vários construtores, métodos evariáveis públicas. Aqui mostraremos apenas os mais usados.HierarquiaA classe Thread deriva diretamente da classe Object.java.lang.Objectjava.lang.ThreadConstrutores Construtor DescriçãoThread(ThreadGroup g, String nome) Cria um novo thread com o nome especificado dentro do grupo g.Thread(Runnable ob, String nome) Cria um novo thread para executar sobre o objeto ob, com o nome especificado.Thread(ThreadGroup g, Runnable ob, Cria um novo thread para executar String nome) sobre o objeto ob, dentro do grupo g, com o nome especificado.Thread(String nome) Cria um novo thread com o nome especificado.Thread() Cria um novo thread com o nome default.Thread(Runnable ob) Cria um novo thread para executar Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 263 sobre o objeto ob.Thread(ThreadGroup g, Runnable ob) Cria um novo thread para executar sobre o objeto ob, dentro do grupo g. Tabela IX.1 – Construtores da classe Thread. A tabela X.1 mostra os principais construtores da classe Thread.Podemos notar que é possível nomear os threads e agrupá-los. Isto é útil paraobter a referência de threads por meio do seu nome.Métodos Método DescriçãocurrentThread() Retorna uma referência para o thread corrente em execução.destroy() Destroi o thread sem liberar os recursos.dumpStack() Imprime a pilha de chamadas do thread corrente.enumerate(Thread[] v) Copia para o array todos os thread ativos no grupo do thread.getName() Obtém o nome do thread.getPriority() Obtém a prioridade do thread.getThreadGroup() Retorna o grupo do thread.resume() Reassume a execução de um thread previamente suspenso.run() Se o thread foi construído usando um objeto Runnable separado então o método do objeto Runnable é chamado. Caso contrário nada ocorre.setName(String name) Muda o nome do thread.setPriority(int newPriority) Muda a prioridade do thread.sleep(long millis) Suspende o thread em execução o número de milisegundos especificados.sleep(long millis, int Suspende o thread em execução o número denanos) milisegundos mais o número de nanosegundos especificados.start() Inicia a execução do thread. A máquina virtual chama o método run() do thread.stop() Força o encerramento do thread.suspend() Suspende a execução de um thread.yield() Faz com que o thread corrente interrompa permitindo que outro thread seja executado. Tabela IX.2 – Métodos da classe Thread. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 264 A tabela X.2 apresenta os principais métodos do classe Thread. Algunsmétodos muito usados nas versões anteriores do SDK1.2 foram depreciados naversão atual por serem considerados inseguros ou com tendência a causaremdeadlock . Os métodos depreciados são: stop(), suspend(), resume() edestroy(). Deadlock Travamento causado pela espera circular de recursos em um conjunto de threads. Otravamento por deadlock mais simples é o abraço mortal onde um thread A espera que um threadB libere um recurso, enquanto que o thread B só libera o recurso esperado por A se obter umrecurso mantido por A. Desta forma os dois threads são impedidos indefinidamente deprosseguir. Existem alguns métodos da classe Object que são importantes para ocontrole dos threads. O leitor pode estar se perguntando porque métodosrelacionados threads estão na superclasse Object que é “mãe” de todas asclasse em Java. A razão disso é que esses métodos lidam com um elementoassociado a todo objeto e que é usado para promover o acesso exclusivo aosobjetos. Esse elemento é chamado de monitor. Na seção que aborda asincronização os monitores serão discutidos mais detalhadamente. Os métodosherdados relacionados com controle dos threads estão descritos na tabela IX.3.Método Descriçãonotify() Notifica um thread que está esperando sobre um objeto.notifyAll() Notifica todos os threads que está esperando sobre um objeto.wait() Espera para ser notificado por outro thread.wait(long timeout, int nanos) Espera para ser notificado por outro thread.wait(long timeout) Espera para ser notificado por outro thread. Tabela IX.3 – Métodos da classe Object relacionados com threads.Variáveis públicas As variáveis públicas da classe Thread definem valores máximo, mínimoe default para a prioridade de execução dos threads. Java estabelece dez valoresde prioridade. Como essas prioridades são relacionadas com as prioridades do Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 265ambiente operacional depende da implementação máquina virtual e podeinfluenciar no resultado final da execução do programa. Mais adianteabordaremos a influência do ambiente operacional na execução de programasmultithread. Variável Descriçãostatic final int MAX_PRIORITY A prioridade máxima que um thread pode ter.static final int MIN_PRIORITY A prioridade mínima que um thread pode ter.static final int NORM_PRIORITY A prioridade default associado a um thread. Tabela IX.4 – Variáveis públicas.Ciclo de Vida dos Threads Um thread pode possuir quatro estados conforme mostra a figura IX.3.Podemos observar que uma vez ativo o thread alterna os estados em execução esuspenso até que passe para o estado morto. A transição de um estado paraoutro pode ser determinada por uma chamada explícita a um método ou devida aocorrência de algum evento a nível de ambiente operacional ou de programa. Estados Ativos thread em Execução thread thread novo morto thread suspenso Figura IX.3 – Estados de um thread. A transição de um thread do estado novo para algum estado ativo ésempre realizada pela invocação do método start() do objeto Thread. Já astransições do estado em execução para o estado suspenso e vice-versa e dessespara o estado morto podem ser disparadas tanto pela invocação de variadosmétodos como pela ocorrência de eventos. O exemplo IX.5 mostra as ocorrênciade transição em um código. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 266 public class TesteThread3 extends Thread { public TesteThread3 (String str) {super(str);} public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { // Comando para suspender o thread por // 1000 milisegundos (1 segundo) // Transição do estado em execução para o // estado suspenso sleep(1000); } catch (InterruptedException e) {} // Evento: fim do tempo de suspensão // Transição do estado em suspenso para o // estado em execução } System.out.println("FIM! " + getName()); // Evento: fim da execução do thread // Transição do estado ativo suspenso para o // estado morto } public static void main(String args[]) { TesteThread3 t1 = new TesteThread3(args[0]); t1.start(); // Transição para um estado ativo } } Exemplo IX.5 – Alguns comandos e eventos que acarretam transição de estados.sleep(), yield(), join(), destroy(), stop(), suspend() eresume(). Agora que vimos os estados que podem ser assumidos por um thread emseu ciclo de vida vamos examinar mais detalhadamente alguns dos métodosresponsáveis pela mudança de estado de um thread. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 267sleep() O método sleep()é um método estático e possui as seguintesinterfaces:static void sleep(long ms) throws InterruptedException oustatic void sleep(long ms, int ns) throws InterruptedException Onde ms é um valor em milisegundos e ns é um valor em nanosegundos. O método sleep() faz com que o thread seja suspenso por umdeterminado tempo, permitindo que outros threads sejam executados. Como ométodo pode lançar a exceção InterruptedException, é preciso envolver achamada em um bloco try/catch ou propagar a exceção. O exemplo IX.6define uma espera mínima de 100 milisegundos entre cada volta do loop. Noteque o tempo de suspensão do thread pode ser maior que o especificado, uma vezque outros threads de maior ou mesmo de igual prioridade podem estar sendoexecutados no momento em que expira o tempo de suspensão solicitado. public class ThreadComYield extends Thread { String s; public ThreadComYield(String as) { super(); s = new String(as); } public void run() { for (int i = 0; i < 5; i++) { System.out.println(i+” “+s); try{ Thread.sleep(100); catch(InterruptedException e){} } System.out.println("FIM! "+s); } } Exemplo IX.6 – Uso do método sleep(). Outro problema com o sleep() é que a maioria dos SistemasOperacionais não suportam resolução de nanosegundos. Mesmo a resolução anível de unidade de milisegundo não é suportada pela maioria dos SOs. No casodo SO não suportar a resolução de tempo solicitada, o tempo será arredondadopara a nível de resolução suportado pela plataforma operacional. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 268yield() O método yield() é um método estático com a seguinte interface: static void yield() Uma chamada ao método yield() faz com que o thread corrente libereautomaticamente a CPU para outro thread de mesma prioridade. Se não houvernenhum outro thread de mesma prioridade aguardando, então o thread correntemantém a posse da CPU. O exemplo IX.7 altera o exemplo IX.1 de modo apermitir que outros threads de mesma prioridade sejam executados a cada voltado loop. Public class ThreadComYield extends Thread { String s; public ThreadComYield(String as) { super(); s = new String(as); } public void run() { for (int i = 0; i < 5; i++) { System.out.println(i+” “+s); Thread.yield(); } System.out.println("FIM! "+s); } } Exemplo IX.7 – Uso do método yield().join() O método join() é um método de instância da classe Thread e éutilizado quando existe a necessidade do thread corrente esperar pela término daexecução de outro thread. As versões do método join() são as seguintes:public final void join();public final void join(long millisecond);public final void join(long millisecond, int nanosecond); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 269 Na primeira versão o thread corrente espera indefinidamente peloencerramento da execução do segundo thread. Na segunda e terceira versão othread corrente espera pelo término da execução do segundo thread até nomáximo um período de tempo prefixado. O exemplo IX.8 mostra o como usar ométodo join(). class ThreadComJoin extends Thread { String s; public ThreadComJoin(String as) { super(); s = new String(as); } public void run() { for (int i = 0; i < 10; i++) System.out.println(i+” “+s); System.out.println("Fim do thread!"); } } public class TestaJoin { public static void main(String args[]) { ThreadComJoin t1 = new ThreadComJoin(args[0]); t1.start(); // Transição para um estado ativo t1.join(); // Espera pelo término do thread System.out.println("Fim do programa!"); } } Exemplo IX.8 – Uso do método join().stop(), suspend(), resume() e destroy() A partir da versão 1.2 do SDK os métodos stop(), suspend(), andresume() tornaram-se deprecated uma vez que a utilização desses métodostendia a gerar erros. No entanto, devido a grande quantidade de código que aindautiliza estes método, acreditamos que seja importante mencioná-los. O método stop() é um método de instância que encerra a execução dothread ao qual pertence. Os recursos alocados ao thread são liberados. Érecomendável substituir o método stop() pelo simples retorno do métodorun(). Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 270 O método suspend() é um método de instância que suspende aexecução do thread ao qual pertence. Nenhum recurso é liberado, inclusive osmonitores que possuir no momento da suspensão (os monitores serão vistos maisadiante e servem para controlar o acesso à variáveis compartilhadas). Isto fazcom que o método suspend() tenda a ocasionar deadlocks. O métodoresume() é um método de instância que reassume a execução do thread ao qualpertence. Os métodos suspend() e resume() devem ser substituídosrespectivamente pelos métodos wait() e notify(), como veremos maisadiante. O método destroy() é um método de instância que encerra a execuçãodo thread ao qual pertence. Os recursos alocados ao thread não são liberados.Não é um método deprecated mas é recomendável substituí-lo pelo simplesretorno do método run().Daemon Threads Daemon threads são threads que rodam em background com a função deprover algum serviço mas não fazem parte do propósito principal do programa.Quando só existem threads do tipo daemon o programa é encerrado. Umexemplo de daemon é o thread para coleta de lixo. Um thread é definido como daemon por meio do método de instânciasetDaemon(). Para verificar se um thread é um daemon é usado o método deinstância isDaemon(). O exemplo IX.9 mostra o como usar esses métodos.import java.io.*;class ThreadDaemon extends Thread{ public ThreadDaemon() { setDaemon(true); start(); } public void run() { for(;;) yield(); }}public class TestaDaemon{ Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 271 public static void main(String[] args) { Thread d = new ThreadDaemon(); System.out.println("d.isDaemon() = " + d.isDaemon()); BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in)); System.out.println("Digite qualquer coisa"); try { stdin.readLine(); } catch(IOException e) {} }} Exemplo IX.9 – Uso dos métodos relacionados com daemons. No exemplo IX.9 o método main() da classe TestaDaemon cria umobjeto da classe ThreadDaemon. O construtor da classe ThreadDaemondefine o thread como daemon por meio do método setDaemon() e inicia aexecução do thread. Como é apenas um thread de demonstração o método run()da classe ThreadDaemon não faz nada, apenas liberando a posse da CPU todavez que a adquire. Após a criação da instância da classe ThreadDaemon nométodo main() é testado se o thread criado é um daemon, utilizando para essefim o método isDaemon(). Depois disso o programa simplesmente espera ousuário pressionar a tecla <enter>. O programa termina logo em seguida aoacionamento da tecla, mostrando dessa forma que o programa permanece ativoapenas enquanto existem threads não daemons ativos.Influência do Sistema Operacional no Comportamentodos Threads Apesar da linguagem Java prometer a construção de programasindependentes de plataforma operacional, o comportamento dos threads pode serfortemente influenciado pelo sistema operacional subjacente. Portanto, oprogramador deve tomar alguns cuidados se deseja construir programas quefuncionem da mesma forma, independente do ambiente onde está sendoexecutado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 272 Alguns sistemas operacionais não oferecem suporte a execução dethreads. Neste caso, cada processo possui apenas um thread. Mesmo em sistemasoperacionais que oferecem suporte a execução de múltiplos threads por processoo projetista da máquina virtual pode optar por não usar o suporte nativo athreads. Deste modo, é responsabilidade da máquina virtual criar um ambientemultithread. Threads implementados desta forma, a nível de usuário, sãochamados de green-threads. As influências da plataforma operacional podem agrupadas em doistipos: 1) Forma de escalonamento de threads. O ambiente pode adotar um escalonamento não preemptivo ou preemptivo. No escalonamento não preemptivo (também chamado de cooperativo) um thread em execução só perde o controle da CPU (Central Processing Unit) se a liberar voluntariamente ou se necessitar de algum recurso que ainda não está disponível. Já no escalonamento preemptivo, além das formas acima um thread pode perde o controle da CPU por eventos externos, como o fim do tempo máximo definido pelo ambiente para a execução contínua de um thread (fatia de tempo) ou porque um thread de mais alta prioridade está pronto para ser executado. Exemplos de sistemas operacionais não preemptivos são Windows 3.1 e IBM OS/2. Exemplos de sistemas operacionais preemptivos são Windows 95/98/NT e Linux, QNX, e muitos outros. Alguns sistemas operacionais adotam uma abordagem híbrida, suportando tanto o modelo cooperativo como o preemptivo, como o Solaris da Sun. 2) Relacionamento entre os níveis de prioridades definidas na linguagem Java e os níveis de prioridades definidas nos Sistemas Operacionais. Em um SO preemptivo um thread de uma determinada prioridade perde a posse da CPU para um thread de prioridade mais alta que esteja pronto para ser executado. A linguagem Java prevê dez níveis de prioridades que podem ser atribuídas aos threads. No entanto, cada SO possui um número de prioridades diferente e o mapeamento das prioridades da linguagem Java para as prioridades do SO subjacente pode influenciar o comportamento do programa.Forma de escalonamento de threads Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 273 A especificação da máquina virtual Java determina que a forma deescalonamento de threads seja preemptiva. Portanto, mesmo em ambienteoperacionais cooperativos a máquina virtual deve garantir um escalonamentopreemptivo. No entanto, um escalonamento preemptivo não obriga a preempçãopor fim de fatia de tempo. Podemos ter um escalonamento preemptivo onde umthread de mais alta prioridade interrompe o thread que tem a posse da CPU masnão existe preempção por fim de fatia de tempo. Um escalonamento ondethreads de mesma prioridade intercalam a posse da CPU por força do fim dafatia de tempo é chamado de escalonamento Round-Robin. A especificação damáquina virtual Java não prevê o escalonamento Round-Robin, mas também nãoo descarta, abrindo uma possibilidade de implementações distintas de máquinavirtual e introduzindo o não determinismo na execução de programasmultithread. Por exemplo, o exemplo IX.3 poderia ter uma saída distinta daapresentada anteriormente caso seja executado por uma máquina virtual que nãoimplementa o escalonamento Round-Robin. Nesse caso a saída seria a seguinte: 0 Linha2 1 Linha2 2 Linha2 3 Linha2 4 Linha2 FIM! Linha2 0 Linha1 1 Linha1 2 Linha1 3 Linha1 4 Linha1 FIM! Linha1 Neste caso, se o programador deseja que a execução de threads seprocesse de forma alternada, independentemente da implementação da máquinavirtual, então é necessário que ele insira código para a liberação voluntária daCPU. Isso pode ser feito com o método yield() ou com o método sleep().Relacionamento entre os níveis de prioridades definidas nalinguagem Java e os níveis de prioridades definidas nos SistemasOperacionais. Como já dissemos a linguagem Java prevê dez níveis de prioridades quepodem ser atribuídas aos threads. Na verdade são onze prioridades, mas aprioridade nível 0 é reservada para threads internos. As prioridades atribuídas Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 274aos threads são estáticas, ou seja não se alteram ao longo da vida do thread, anão ser que por meio de chamadas a métodos definidos para esse propósito. Aclasse thread possui variáveis públicas finais com valores de prioridadepredefinidos, como mostrado na tabela IX.4. No entanto, os sistemasoperacionais podem possuir um número maior ou menor de níveis deprioridades. Vamos citar um exemplo: o MSWindows 95/98/NT. Este sistemapossui apenas sete níveis de prioridades e estes sete níveis devem ser mapeadospara os onze níveis de prioridades especificados em Java. Cada máquina virtualfará este mapeamento de modo diferente, porém a implementação comum émostrada na tabela IX.5. Prioridades Java Prioridades MSWindows 0 THREAD_PRIORITY_IDLE 1(Thread.MIN_PRIORITY) THREAD_PRIORITY_LOWEST 2 THREAD_PRIORITY_LOWEST 3 THREAD_PRIORITY_BELOW_NORMAL 4 THREAD_PRIORITY_BELOW_NORMAL 5(Thread.NORM_PRIORITY) THREAD_PRIORITY_NORMAL 6 THREAD_PRIORITY_ABOVE_NORMAL 7 THREAD_PRIORITY_ABOVE_NORMAL 8 THREAD_PRIORITY_HIGHEST 9 THREAD_PRIORITY_HIGHEST 10(Thread.MAX_PRIORITY) THREAD_PRIORITY_TIME_CRITICAL Tabela IX.5 –Mapeamento das prioridades de Java para MSWindows. Note que nesta implementação níveis de prioridades diferentes em Javaserão mapeados para um mesmo nível de prioridade em MSWindows. Isto podelevar a resultados inesperados caso o programador projete uma aplicaçãoesperando, por exemplo, que um thread de prioridade 4 irá interromper umthread de prioridade 3. Para evitar este tipo de problema o programador podeadotar dois tipos de abordagem:1) utilizar, se for possível, apenas as prioridades Thread.MIN_PRIORITY, Thread.NORM_PRIORITY e Thread.MAX_PRIORITY para atribuir prioridades aos threads; ou2) não se basear em níveis de prioridades para definir o escalonamento de threads, utilizando, alternativamente, primitivas de sincronização que serão abordadas na próxima seção. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 275Compartilhamento de Memória e Sincronização Como já foi dito, mais de um thread pode ser criado sobre um mesmoobjeto. Neste caso cuidado especiais devem ser tomados, uma vez que os threadscompartilham as mesmas variáveis e problemas podem surgir se um thread estáatualizando uma variável enquanto outro thread está lendo ou atualizando amesma variável. Este problema pode ocorrer mesmo em threads que executamsobre objetos distintos, já que os objetos podem possuir referências para ummesmo objeto. O exemplo IX.8 mostra a execução de dois threads sobre ummesmo objeto. O nome do thread é usado para que o thread decida que açãotomar. O thread de nome “um” ontem um número de 0 a 1000 geradoaleatoriamente e o coloca na posição inicial de um array de dez posições. Asoutras posições do array são preenchidas com os nove números inteirosseguintes ao número inicial. O thread de nome “dois” imprime o conteúdo dovetor. Obviamente o programa é apenas ilustrativo, não possuindo aplicaçãoprática. A intenção inicial do projetista é obter na tela sequências de deznúmeros inteiros consecutivos iniciados aleatoriamente. No entanto, como osdois threads compartilham o mesmo objeto e não existe qualquer sincronismoentre sí, é pouco provável que o projetista obtenha o resultado esperado. public class CalcDez implements Runnable { private int vetInt[]; public CalcDez () {vetInt=new int[10]; } public void run() { if (Thread.currentThread().getName().equals(”um”)) for (;;) { vetInt[0] = (int)(Math.random() * 1000); for (int i=1;i<10;i++) vetInt[i]= vetInt[0]+i; } else for (;;) { System.out.println(“Serie iniciada por”+ vetInt[0]); for (int i=1;i<10;i++) System.out.println(vetInt[i]+ “ “); } } public static void main(String args[]) { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 276 CalcDez ob = new CalcDez(); Thread t1 = new Thread(ob,”um”); Thread t2 = new Thread(ob,”dois”); t1.start(); t2.start(); } } Exemplo IX.8 – Dois threads executando sobre o mesmo objeto. Se a máquina virtual não implementar um escalonamento Round-Robinapenas um thread será executado, visto que os dois threads possuem a mesmaprioridade. Já no caso da máquina virtual implementar um escalonamento Round-Robin a alternância da execução dos threads produzirá resultados imprevisíveis.Um trecho de uma das saídas possíveis pode ser visto na figura IX.4. Ele foiobtido em Pentium 100MHz executando a máquina virtual da Sun, versão 1.2,sob o sistema operacional MSWindows 95.258259Serie iniciada por573574575576577578579580581582Serie iniciada por808182 Figura IX.4 – Saída do exemplo IX.8. Podemos notar as sequências estão misturadas, mostrando que cadathread interrompe o outro no meio da execução da tarefa especificada. O mesmoproblema pode mesmo em threads que executam sobre objetos diferentes,bastando que cada thread possua referência para um mesmo objeto. O exemploIX.9 mostra a execução de dois threads sobre objetos distintos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 277class Compartilhada{ private int vetInt[]; public Compartilhada() {vetInt=new int[10];} public void setVal() { for (;;) { vetInt[0] = (int)(Math.random() * 1000); for (int i=1;i<10;i++) vetInt[i]= vetInt[0]+i; } } public int getVal(int i) {return vetInt [i];}}public class CalcDez2 extends Thread{ private Compartilhada obj; private int tipo; public CalcDez2 (Compartilhada aObj, int aTipo) { obj = aObj; tipo = aTipo;} public void run() { for (;;) if (tipo==1) obj.setVal(); else { System.out.println(“Serie iniciada por”+ obj.getVal(0)); for (int i=1;i<10;i++) System.out.println(obj.getVal(i)+ “ “); } } public static void main(String args[]) { Compartilhada obj = new Compartilhada(); CalcDez2 t1 = new CalcDez2(obj,1); CalcDez2 t2 = new CalcDez2(obj,2); t1.start(); t2.start(); }} Exemplo IX.9 – Dois threads executando sobre objetos distintos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 278 É importante que o leitor não confunda o exemplo IX.9 com o exemploIX.8 achando que nos dois exemplos os dois threads executam sobre o mesmoobjeto, uma vez que a etapa da criação dos threads é bem parecida. No entanto,no exemplo IX.9 foi declarada uma subclasse da classe Thread e não umaclasse que implementa a interface Runnable. Apesar de parecer que noexemplo IX.9 ambos os threads executaram sobre um mesmo objeto da classeCompartilhada que é passado como argumento, na verdade cada threadexecutará sobre sua própria instância da classe CalcDez2, sendo que o objetoda classe Compartilhada é referenciado pelos dois threads. Ocomportamento do código do exemplo IX.9 é semelhante ao do exemplo IX.8,com a diferença que no primeiro a sequência de inteiros é encapsulado peloobjeto da classe Compartilhada. Este tipo de situação, onde o resultado de uma computação depende daforma como os threads são escalonados, é chamada de condições de corrida(Race Conditions). É um problema a ser evitado uma vez que o programa passaa ter um comportamento não determinístico.Atomicidade de Instruções e Sincronização do Acesso à SessõesCríticas A condição de corrida ocorre porque os acesso à áreas de memóriacompartilhada não é feita de forma atômica, e nem de forma exclusiva. Porforma atômica queremos dizer que o acesso é feito por meio de várias instruçõese pode ser interrompido por outro thread antes que toda as instruções quecompõem o acesso sejam executadas. Por forma exclusiva queremos dizer queum thread podem consultar/atualizar um objeto durante a consulta/atualização domesmo objeto por outros threads. Poucas operações são atômicas em Java. Emgeral, as atribuições simples, com exceção dos tipos long e double, sãoatômicas, de forma que o programador não precisa se preocupar em serinterrompido no meio de uma operação de atribuição. No entanto, no caso deoperações mais complexas sobre variáveis compartilhadas é preciso que oprogramador garanta o acesso exclusivo a essas variáveis. Os trechos de códigoonde é feito o acesso às variáveis compartilhadas são chamados de SeçõesCríticas ou Regiões Críticas. Uma vez determinada uma região crítica como garantir o acessoexclusivo? A linguagem Java permite que o programador garanta o acessoexclusivo por meio utilizando o conceito de monitor. O conceito de monitor foiproposto por C. A. R. Hoare em 1974 e pode ser encarado como um objeto que Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 279garante a exclusão mútua na execução dos procedimentos a ele associados. Ouseja, apenas um procedimento associado ao monitor pode ser executado em umdeterminado momento. Por exemplo, suponha que dois procedimentos A e Bestão associados a um monitor. Se no momento da invocação do procedimento Aalgum o procedimento B estiver sendo executando o processo ou thread queinvocou o procedimento A fica suspenso até o término da execução doprocedimento B. Ao término do procedimento B o processo que invocou oprocedimento A é “acordado” e sua execução retomada. O uso de monitores em Java é uma variação do proposto por Hoare. nalinguagem Java todo objeto possui um monitor associado. Para facilitar oentendimento podemos encarar o monitor como um detentor de um “passe”.Todo thread pode pedir “emprestado” o passe ao monitor de um objeto antes derealizar alguma computação. Como o monitor possui apenas um passe, apenasum thread pode adquirir o passe em um determinado instante. O passe tem queser devolvido para o monitor para possibilitar o empréstimo do passe a outrothread. A figura IX.5 ilustra essa analogia. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 280 Monitor de x Monitor de x passe $ Objeto x Objeto xthread t1 $thread t2 Instante 1: o thread t1 solicita Instante 2: o thread t2 solicita o passe ao monitor o passe ao monitor do objeto x. do objeto x e é bloqueado. Monitor de x Monitor de x $ Objeto x Objeto x $ Instante 3: o thread t1 libera Instante 4: o thread t2 recebe o passe. o passe do monitor do objeto x. Figura IX.5 – Uma possível sequência na disputa de dois threads pela autorização de um monitor. Nos resta saber como solicitar o passe ao monitor. Isto é feito por meio da palavra chave synchronized. Existem duas formas de se usar a palavra chave synchronized: na declaração de métodos e no início de blocos. O exemplo IX.10 mostra duas versões da classe FilaCirc que implementa uma fila circular de valores inteiros: uma com métodos synchronized e outra com blocos synchronized. Um objeto desta classe pode ser compartilhado por dois ou mais threads para implementar o exemplo clássico de concorrência do tipo produtor/consumidor. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 281a) Versão com métodos b) Versão com blocossynchronized synchronizedclass FilaCirc class FilaCirc{ { private final int TAM = 10; private final int TAM = 10; private int vetInt[]; private int vetInt[]; private int inicio, total; private int inicio, total; public FilaCirc() public FilaCirc() { { vetInt=new int[TAM]; vetInt=new int[TAM]; inicio=0; inicio=0; total =0; total =0; } } public synchronized void public void addElement(int v) addElement(int v) throws Exception throws Exception { { if (total == TAM) throw new synchronized(this) { Exception("Fila cheia!"); if (total == TAM) throw new vetInt[(inicio+total)%TAM] = v; Exception("Fila cheia!"); total++; vetInt[(inicio+total)%TAM] = v; } total++; public synchronized int getElement() } throws Exception } { public int getElement() if (total == 0 ) throw new throws Exception Exception("Fila vazia!"); { int temp = vetInt[inicio]; synchronized(this) { inicio = (++inicio)%TAM; if (total == 0 ) throw new total--; Exception("Fila vazia!"); return temp; int temp = vetInt[inicio]; } inicio = (++inicio)%TAM;} total--; } return temp; } }Exemplo IX.10 – Duas versões de uma classe que implementa uma fila circular de inteiros. A palavra chave synchronized na frente dos métodos de instânciasignifica que o método será executado se puder adquirir o monitor do objeto aquem pertence o método4. Caso contrário o thread que invocou o método serásuspenso até que possa adquirir o monitor. Este forma de sincronização éabordada no exemplo IX.10.a. Portanto, se algum thread chamar algum métodode um objeto da classe FilaCirc nenhum outro thread que compartilha omesmo objeto poderá executar um método do objeto até que o método chamado4 Não usaremos mais a analogia com a aquisição do passe do monitor. Ela foi usada apenas parafacilitar o entendimento do leitor. Quando se trata de monitores os termos mais usados são:“adquirir o monitor” e “liberar o monitor”. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 282pelo primeiro thread termine. Caso outro thread invoque um método do mesmoobjeto ficará bloqueado até que possa adquirir o monitor. O leitor pode estar se perguntando sobre a necessidade de sincronizar osmétodos da classe FilaCirc uma vez que ocorrem apenas atribuições simplesa elementos individuais de um vetor e as atribuições de inteiros são atômicas. Defato o problema ocorre não na atribuição dos elementos e sim na indexação doarray. Por exemplo, a instrução inicio = (++inicio)%TAM;do método getElement() não é atômica. Suponha que a os métodos daclasse FilaCirc não são sincronizados e que as variáveis inicio e totalpossuem os valores 9 e 1 respectivamente. Suponha também que thread invocouo método getElement() e foi interrompido na linha de código mostradaacima após o incremento da variável inicio mas antes da conclusão da linhade código. Nesse caso o valor de inicio é 10. Se neste instante outro threadexecutar o método getElement() do mesmo objeto ocorrerá uma exceçãoIndexOutOfBoundsException ao atingir a linha de código int temp = vetInt[inicio]; Se alterarmos a linha de código para inicio = (inicio+1)%TAM;evitaremos a exceção, mas não evitaremos o problema de retornar mais de umavez o mesmo elemento. Por exemplo, se um thread for interrompido no mesmolocal do caso anterior, outro thread pode obter o mesmo elemento, uma vez queos valores de inicio e total não foram alterados. Na verdade o número desituações problemáticas, mesmo para esse exemplo pequeno, é enorme eperderíamos muito tempo se tentássemos descreve-las em sua totalidade. Em alguns casos pode ser indesejável sincronizar todo um método, oupode-se desejar adquirir o monitor de outro objeto, diferente daquele a quempertence o método. Isto pode ser feito usando a palavra chave synchronizedna frente de blocos. Este forma de sincronização é mostrada no exemploIX.10.b. Neste modo de usar a palavra-chave synchronized é necessárioindicar o objeto do qual tentara-se adquirir o monitor. Caso o monitor sejaadquirido o bloco é executado, caso contrário o thread é suspenso até que possaadquirir o monitor. O monitor é liberado no final do bloco. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 283 No exemplo IX.10.b o monitor usado na sincronização é o do próprioobjeto do método, indicado pela palavra chave this. Qualquer outro objetoreferenciável no contexto poderia ser usado. O que importa que os grupos dethreads que possuem áreas de código que necessitam de exclusão mútua usem omesmo objeto. No exemplo IX.10 não existe vantagem da forma de implementação a)sobre a forma de implementação b) ou vice-versa. Isso ocorre principalmentequando os métodos são muito pequenos ou não realizam computações muitocomplexas. No entanto, se o método for muito longo ou levar muito tempo paraser executado, sincronizar todo o método pode “travar” em demasia a execuçãoda aplicação. Nesses casos, a sincronização somente das seções críticas é maisindicada. Outra vantagem da segunda forma de sincronização é a liberdade nouso de monitores qualquer objeto referenciável. Isto permite a implementaçãosincronizações mais complexas como veremos mais adiante. O exemplo IX.11 mostra como pode ser usado um objeto da classeFilaCirc. public class TestaFilaCirc extends Thread { private FilaCirc obj; private int tipo; public TestaFilaCirc (FilaCirc aObj, int aTipo) { obj = aObj; tipo = aTipo;} public void run() { for (;;) try { if (tipo==1){ int i = (int)(Math.random() * 1000); System.out.println("Elemento gerado:"+i); obj.addElement(i); } else System.out.println("Elemento obtido:"+obj.getElement()); } catch(Exception e) {System.out.println(e.getMessage());} } public static void main(String args[]) { FilaCirc obj = new FilaCirc(); TestaFilaCirc t1 = new TestaFilaCirc(obj,1); TestaFilaCirc t2 = new TestaFilaCirc(obj,2); t1.start(); t2.start(); } } Exemplo IX.11 – Uso da fila circular de inteiros. Um trecho possível da saída obtida na execução do programa do exemploIX.11 seria o seguinte:...Elemento obtido:154 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 284Elemento gerado:725Fila vazia!Elemento gerado:801Elemento obtido:725Elemento gerado:204Elemento obtido:801... É importante observar que o monitor em Java por si só não implementa aexclusão mútua. Ele é apenas um recurso que pode ser usado pelo programadorpara implementar o acesso exclusivo à variáveis compartilhadas. Cabe aoprogramador a responsabilidade pela uso adequado deste recurso. Por exemplose o programador esquecer de sincronizar um bloco ou método que necessita deexclusão mútua, de nada adianta ter sincronizado os outros métodos ou blocos.O thread que executar o trecho não sincronizado não tentará adquirir o monitor,e portanto de nada adianta os outros threads terem o adquirido. Outro ponto que é importante chamar a atenção é ter o cuidado de usar apalavra chave synchronized com muito cuidado. A sincronização custamuito caro em se tratando de ciclos de CPU. A chamada de um métodosincronizado é por volta de 10 vezes mais lenta do que a chamada de um métodonão sincronizado. Por essa razão use sempre a seguinte regra: não sincronize oque não for preciso.Comunicação entre Threads: wait() e notify() O exemplo IX.10 não é um modelo de uma boa implementação deprograma. O thread que adiciona elementos à fila tenta adicionar um elemento àcada volta do laço de iteração mesmo que a fila esteja cheia. Por outro lado, othread que retira os elementos da fila tenta obter um elemento a cada volta dolaço de iteração mesmo que a fila esteja vazia. Isto é um desperdício de tempode processador e pode tornar o programa bastante ineficiente. Alguém poderia pensar em uma solução onde o thread testaria se acondição desejada para o processamento ocorre. Caso a condição não ocorra othread poderia executar o método sleep() para ficar suspenso por algumtempo para depois testar novamente a condição. O thread procederia desta formaaté que a condição fosse satisfeita. Este tipo de procedimento economizariaalguns ciclos de CPU, evitando que a tentativa incessante de executar oprocedimento mesmo quando não há condições. O nome desta forma de ação, Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 285onde o procedimento a cada intervalo de tempo pré-determinado testa se umacondição é satisfeita é chamado de espera ocupada (pooling ou busy wait). No entanto, existem alguns problemas com este tipo de abordagem.Primeiramente, apesar da economia de ciclos de CPU ainda existe apossibilidade de ineficiência, principalmente se o tempo não for bem ajustado.Se o tempo for muito curto ocorrerá vários testes inúteis. Se for muito longo, othread ficará suspenso além do tempo necessário. Porém, mais grave que isto éque o método sleep() faz com que o thread libere o monitor. Portanto, se otrecho de código for uma região sincronizada, como é o caso do exemplo IX.10,de nada adiantará o thread ser suspenso. O thread que é capaz de realizar acomputação que satisfaz a condição esperada pelo primeiro thread ficaráimpedido de entrar na região crítica, ocorrendo assim um deadlock: o thread quedetém o monitor espera que a condição seja satisfeita e o thread que podesatisfazer a condição não pode prossegui porque não pode adquirir o monitor. O que precisamos é um tipo de comunicação entre threads quecomunique que certas condições foram satisfeitas. Além disso, é preciso que, aoesperar por determinada condição, o thread libere o monitor. Esta forma deinteração entre threads é obtido em Java com o uso dos métodos de instânciawait(), notify() e notifyAll(). Como vimos anteriormente, essesmétodos pertencem à classe Object e não à classe Thread. Isto ocorre porqueesses métodos atuam sobre os monitores, que são objetos relacionados a cadainstância de uma classe Java e não sobre os threads. Ao invocar o método wait() de um objeto o thread é suspenso einserido em uma fila do monitor do objeto, permanecendo na fila até receberuma notificação. Cada monitor possui sua própria fila. Ao invocar o métodonotify() de um objeto, um thread que está na fila do monitor do objeto énotificado. Ao invocar o método notifyAll() de um objeto, todos os threadsque estão na fila do monitor do objeto são notificados. A única exigência é que esses métodos sejam invocados em um threadque detenham a posse do monitor do objeto a que pertencem. Essa exigência fazsentido uma vez que eles sinalizam a threads que esperam na fila dessesmonitores. Devido a essa exigência a invocação desses métodos ocorre emmétodos ou blocos sincronizados. O exemplo IX.12 mostra as formas maiscomuns de chamadas desses métodos. Note que o thread deve possuir o monitor do objeto ao qual pertence ométodo. Por isso, nos exemplo IX.12 b e c, o objeto sincronizado no bloco é omesmo que invoca os métodos notify() e notifyAll().a) b)class X class Y Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 286{ { ... X ob; public synchronized int ma() ... { public int mb() ... { // Espera uma condição ... while(!cond) wait(); synchronized (ob) // Prossegue com a { // condição satisfeita // Notifica algum thread ... ob.notify(); } ... ... }} ... }c)class Z{ X ob; ... public int mc() { ... synchronized (ob) { // Notifica todos os threads que esperam na fila // do monitor de ob ob.notifyAll(); ... } ...}Exemplo IX.12 – Exemplos de chamadas dos métodos wait(), notify() e notifyAll(). Outra observação importante é que o thread que invoca o métodowait() o faz dentro de um laço sobre a condição de espera. Isto ocorre porqueapesar de ter sido notificado isto não assegura que a condição está satisfeita. Othread pode ter sido notificado por outra razão ou entre a notificação e aretomada da execução do thread a condição pode ter sido novamente alterada. Uma vez notificado o thread não retoma imediatamente a execução. Épreciso primeiro retomar a posse do monitor que no momento da notificaçãopertence ao thread que notificou. Mesmo após a liberação do monitor nada Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 287garante que o thread notificado ganhe a posse do monitor. Outros threads podemter solicitado a posse do monitor e terem preferência na sua obtenção. O exemplo IX.12 mostra apenas um esquema para uso dos métodos paranotificação. O exemplo IX.13 é uma versão do exemplo IX.10a que usa osmétodos de notificação para evitar problemas como a espera ocupada. Oexemplo IX.11 pode ser usado sem modificações para testar essa versão.class FilaCirc{ private final int TAM = 10; private int vetInt[]; private int inicio, total; public FilaCirc() { vetInt=new int[TAM]; inicio=0; total =0; } public synchronized void addElement(int v) throws Exception { while (total == TAM) wait(); vetInt[(inicio+total)%TAM] = v; total++; notify(); } public synchronized int getElement() throws Exception { while (total == 0 ) wait(); int temp = vetInt[inicio]; inicio = (++inicio)%TAM; total--; notify(); return temp; }} Exemplo IX.13 – Classe que implementa uma fila circular de inteiros com notificação. A necessidade de se testar a condição em loop pode ser observada nafigura IX.6 que mostra a evolução da execução de três threads sobre objetos quecompartilham uma instância da classe FilaCirc. O thread 3 executa o métodoaddElement(), no entanto, em virtude da condição total==TAM éobrigado a invocar o método wait() e esperar uma notificação. O próximo Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 288thread a assumir a CPU é o thread 1 que executa o método getElement(), queestabelece a condição total<TAM e executa um notify(). No entanto, opróximo thread a assumir a CPU é o thread 2 e não o thread 3. O thread 2executa o método addElement(), o qual estabelece novamente a condiçãototal==TAM. Quando o thread 3 assumi novamente a CPU, uma vez que foinotificado, testa a condição e invoca novamente o método wait() para esperara condição favorável à execução. Caso não testasse a condição em um loop othread 3 tentaria inserir um elemento em uma fila cheia. O método notify() não indica que evento ocorreu. No caso doexemplo IX.13 existem dois tipos de eventos (a fila não está cheia e a fila nãoestá vazia), no entanto, podemos observar que não existe a possibilidade de umthread ser notificado em decorrência de um evento diferente do que estáaguardando. Método: addElement() condição: total == TAMthread 3thread 2 Método: addElement() condição: total < TAMthread 1 Método: getElement() TempoExecutando Esperando CPU Esperando notificação Figura IX.6 – Uma possível sequência na execução de três threads. Porém, existem alguns casos mais complexos onde podem existir váriosthreads aguardando em um mesmo monitor mas esperando por evento diferentes.Neste caso podemos usar o notifyAll() para notificar todos os threads queesperam em um único monitor que um evento ocorreu. Cada thread, a medidaque fosse escalado, testaria se ocorreu condição para a execução e em casopositivo prosseguiria na execução e em caso contrário voltaria a aguardar nomonitor. O exemplo IX.14 mostra o código de um gerenciador de mensagens. Eleé responsável por receber mensagens destinadas à vários threads. As mensagens Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 289de cada thread são colocadas em uma fila implementada por um objeto da classeVector. Cada fila é por sua vez colocada em uma tabela hash onde a chave éum nome associado ao thread a que as mensagens se destinam. As filas sãocriadas na primeira tentativa de acesso, tanto na leitura quanto noarmazenamento. Não existe bloqueio devido à fila cheia, uma vez que as filassão implementadas por objetos da classe Vector que crescem conforme anecessidade. Portanto, o único evento que necessita ser notificado é a chegada dealguma mensagem. Como todos os threads aguardam sobre o mesmo monitor éusado o método notifyAll() para notificar todos os threads.import java.util.*;class GerenteMen { private Hashtable tamMen; public GerenteMen() {tamMen=new Hashtable(); } // Método para adicionar uma mensagem à fila de // um destinatário public synchronized void addMen(String dest, String men){ if (dest==null || men==null) return; Vector listaMen = (Vector) tamMen.get(dest); if (listaMen==null) listaMen = new Vector(); listaMen.addElement(men); tamMen.put(dest, listaMen); notifyAll(); } // Método para obtenção da mensagem public synchronized String getMen(String dest) throws Exception { if (dest==null) return null; Vector listaMen = (Vector) tamMen.get(dest); // Se não existe a fila para esse thread cria uma vazia if (listaMen==null) { listaMen = new Vector(); tamMen.put(dest, listaMen); } // A fila está vazia, portanto thread deve esperar // a chegada de mensagens while(listaMen.size()==0) wait(); String temp = (String) listaMen.firstElement(); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 290 // A mensagem é removida da fila listaMen.removeElementAt(0); return temp; }} Exemplo IX.14 – Gerenciador de mensagens. O exemplo IX.15 mostra como pode ser usado o gerente de filas doexemplo IX.14. Devido o uso da classe ThreadGroup assim como vários deseus métodos, resolvemos numerar as linhas de código do exemplo IX.15 paramelhor podermos explicar o seu funcionamento. 1 class Receptor extends Thread 2 { 3 private GerenteMen ger; 4 public Receptor(ThreadGroup tg, String nome, GerenteMen aGer) 5 { 6 super(tg,nome); 7 ger = aGer; 8 } 9 public void run() { 10 String nome = Thread.currentThread().getName(); 11 for (;;) 12 try { 13 String men = ger.getMen(nome); 14 if (men.equals("fim")) return; 15 System.out.println(nome+">Mensagem recebida:"+men); 16 } catch(Exception e) {System.out.println(e.getMessage());} 17 } 18 } 19 20 class Gerador extends Thread 21 { 22 private GerenteMen ger; 23 public Gerador(ThreadGroup tg, String nome, GerenteMen aGer) 24 { 25 super(tg,nome); 26 ger = aGer; 27 } 28 public void run() { 29 String nome = Thread.currentThread().getName(); 30 ThreadGroup tg = Thread.currentThread().getThreadGroup(); 31 Thread[] tl=null; 32 for (int i=0;i<100;i++) 33 { 34 if (tl==null || tl.length!=tg.activeCount()) 35 tl= new Thread[tg.activeCount()]; 36 tg.enumerate(tl); 37 int n = (int)(Math.random() * 1000)%tl.length; 38 if (tl[n]!= Thread.currentThread()) 39 { 40 System.out.println(nome+">Mensagem enviada para "+ 41 tl[n].getName()+":mensagem "+i); 42 ger.addMen(tl[n].getName(),"mensagem "+i); 43 } Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 291 44 } 45 tl= new Thread[tg.activeCount()]; 46 tg.enumerate(tl); 47 for (int i=0;i<tl.length;i++) 48 if (tl[i]!= Thread.currentThread()) 49 ger.addMen(tl[i].getName(),"fim"); 50 } 51 } 52 53 public class TestaGerenteMen { 54 public static void main(String args[])throws Exception { 55 GerenteMen ger = new GerenteMen(); 56 ThreadGroup tg = new ThreadGroup("tg"); 57 Receptor r1 = new Receptor(tg,"r_um",ger); 58 Receptor r2 = new Receptor(tg,"r_dois",ger); 59 Gerador g = new Gerador(tg,"g",ger); 60 r1.start(); 61 r2.start(); 62 g.start(); 63 } 64 } Exemplo IX.15 – Uso do gerenciador de filas. Um objeto da classe ThreadGroup agrupa um conjunto de threads.Um ThreadGroup pode possuir como membros outros objetos daThreadGroup formando assim uma árvore onde todos os grupos, exceto oprimeiro possui um grupo pai. O objetivo de se agrupar os threads em conjuntosé facilitar a sua manipulação. No caso do exemplo IX.15 usaremos esseagrupamento para poder acessar cada thread. As linhas 1 a 18 definem a classe que será usada para criação de objetosreceptores de mensagens. Na linha 3 é declarada a variável que irá referenciarum objeto do tipo GerenteMen. As linhas 4 a 8 contém o código do únicoconstrutor da classe. Ele recebe uma referência para o grupo de threads ao qualdeve se associar, o nome que deve ser atribuído ao thread e a referência aogerente de filas. Na linha 6 os primeiros dois parâmetros são passados aoconstrutor da superclasse. Na linha 7 a referência ao gerente de filas é atribuída àvariável da instância. As linhas 9 a 17 contém o código do método run() que éo método de entrada do thread. Na linha 10 é invocado o método Thread.currentThread().getName();para se obter o nome do thread corrente. O nome do thread é usado parareferenciar a fila de mensagens do thread. Entre as linhas 11 e 16 é executadoum laço infinito onde o thread recebe e imprime as mensagens recebidas. Nalinha 14 o thread testa se a mensagem recebida é igual a “fim”. Neste caso othread encerra sua execução. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 292 As linhas 20 a 51 definem a classe que será usada para criação do objetogerador de mensagens. Este exemplo foi projetado para lidar com apenas umthread gerador de mensagem. Modificações devem ser realizadas para tratar deaplicações com mais de um thread gerador de mensagens. Na linha 22 édeclarada a variável que irá referenciar um objeto do tipo GerenteMen. Aslinhas 23 a 27 contém o código do único construtor da classe. Ele recebe umareferência para o grupo de threads ao qual deve se associar, o nome que deve seratribuído ao thread e a referência ao gerente de filas. Na linha 25 os primeirosdois parâmetros são passados ao construtor da superclasse. Na linha 26 areferência ao gerente de filas é atribuída à variável da instância. As linhas 28 a50 contém o código do método run() que é o método de entrada do thread. Nalinha 29 é obtido o nome do thread corrente que será usado na impressão demensagens. Na linha 30 o método Thread.currentThread().getThreadGroup();obtém uma referência para o grupo de threads ao qual pertence o thread corrente.Na linha 31 é declarada uma variável que irá referenciar um vetor contendoreferências a todos os threads ativos do grupo. Entre as linhas 32 e 44 éexecutado um laço com 100 iterações que produz e armazena as mensagens. Nalinha 34 é realizado um teste para a verificação da necessidade de criar o vetorque irá conter as referências para os threads ativos. Ele deve ser criado aprimeira vez e toda vez que a capacidade do vetor for diferente do número dethreads ativos do grupo. O tamanho do vetor é determinado pelo método deinstância activeCount() da classe ThreadGroup. A linha 36 contém ocódigo tg.enumerate(tl);que atribui as referencias aos threads no vetor. O comando int n = (int)(Math.random()*1000)%tl.length;da linha 37 calcula um número que será usado para acessar o thread dentro dovetor de referências. O teste da linha 38 impede que seja enviada uma mensagempara o próprio gerador. Essas mensagens são descartadas. As linhas 40 a 42tratam da impressão e envio da mensagem construída. Já fora da iteração, aslinhas 45 a 49 tratam da do envio da mensagem “fim” para todos os threadsreceptores, o que fará com que encerrem sua execução. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 293 As linhas 53 a 64 definem a classe que será usada como ponto de entradada aplicação. Ela é responsável pela criação dos objetos e disparos dos threads.No exemplo, além do thread gerador apenas dois threads receptores são criados.É interessante notar que não é preciso indicara para o thread gerador asreferências para os threads receptores. Elas são obtidas dinamicamente por meiodo grupo de threads. Um trecho possível da saída obtida na execução do programa do exemploIX.15 seria o seguinte:...g>Mensagem enviada para r_dois:mensagem 88r_um>Mensagem recebida:mensagem 87g>Mensagem enviada para r_dois:mensagem 90r_dois>Mensagem recebida:mensagem 88g>Mensagem enviada para r_um:mensagem 91r_dois>Mensagem recebida:mensagem 90g>Mensagem enviada para r_um:mensagem 93r_um>Mensagem recebida:mensagem 91g>Mensagem enviada para r_um:mensagem 95r_um>Mensagem recebida:mensagem 93g>Mensagem enviada para r_um:mensagem 96r_um>Mensagem recebida:mensagem 95g>Mensagem enviada para r_um:mensagem 97r_um>Mensagem recebida:mensagem 96g>Mensagem enviada para r_dois:mensagem 99r_um>Mensagem recebida:mensagem 97r_dois>Mensagem recebida:mensagem 99Pressione qualquer tecla para continuar . . .Otimizando a Programação Multithread Existe um problema óbvio com a abordagem do exemplo IX.14: amensagem é dirigida a apenas um thread mas todos serão notificados,sobrecarregando o sistema, uma vez que todos os threads precisaram testar se amensagem é destinada a eles. Para contornar esses problema é necessáriovislumbrar uma forma de notificar apenas o thread destinatário. Essa solução pode ser obtida se cada thread esperar em um monitor deum objeto diferente. Não importa o tipo do objeto desde que seja referenciávelpelo thread receptor e pelo thread que irá armazenar a mensagem. Um candidatonatural é a fila de mensagem de cada thread. Existe uma fila para cada thread e o Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 294thread que armazena a mensagem tem acesso a todas a filas por meio da tabelahash. O exemplo IX.16 mostra uma versão do exemplo IX.14 que utiliza estatécnica para criar uma aplicação multi-thread mais otimizada.import java.util.*;class GerenteMen { private Hashtable tamMen; public GerenteMen() {tamMen=new Hashtable(); } // Método para adicionar uma mensagem à fila de // um destinatário public void addMen(String dest, String men){ if (dest==null || men==null) return; Vector listaMen = (Vector) tamMen.get(dest); if (listaMen==null) listaMen = new Vector(); synchronized (listaMen) { listaMen.addElement(men); tamMen.put(dest, listaMen); listaMen.notify(); }; } // Método para obtenção da mensagem public String getMen(String dest) throws Exception { if (dest==null) return null; Vector listaMen = (Vector) tamMen.get(dest); // Se não existe a fila para esse thread cria uma vazia if (listaMen==null) { listaMen = new Vector(); tamMen.put(dest, listaMen); } // A fila está vazia, portanto thread deve esperar while(listaMen.size()==0) synchronized (listaMen) {listaMen.wait();} String temp = (String) listaMen.firstElement(); // A mensagem é removida da fila listaMen.removeElementAt(0); return temp; }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 295 Exemplo IX.16 – Gerenciador de mensagens otimizado. Note que os métodos wait() e notify() invocados pertencem à filarelacionada com cada thread. O exemplo IX.15 pode ser usado semmodificações para testar essa versão.Criando outros mecanismos de sincronização Existem várias propostas de primitivas de sincronização. Dentre as maiscomuns podemos citar os semáforos, mutex, variáveis condicionais, monitores eencontros (rendevouz). Cada uma dessas primitivas é mais adequada a umdeterminado propósito. A implementação de monitores na linguagem Java,juntamente com os métodos wait() e notify() que formam um tipo devariáveis condicionais podem ser combinadas para implementar muitas dessasoutras primitivas, de modo a atender objetivos específicos. Para exemplificaressa possibilidade mostraremos como implementar um semáforo usando asprimitivas de sincronização da linguagem Java. Um semáforo é uma variável inteira sobre a qual pode-se realizar asseguintes operações:Operação Descriçãoinicializar Um valor inteiro maior ou igual a zero é atribuído ao semáforo.P Se o semáforo é maior que zero, o semáforo é decrementado. Caso contrário, o thread é suspenso até que o semáforo contenha um valor maior que zero.V Incrementa o semáforo e acorda os threads que estiverem bloqueados na fila de espera do semáforo. Tabela IX.6 –Operações sobre um semáforo. Semáforo é um mecanismo de sincronização muito utilizado quandoexiste a necessidade de comunicação entre dois ou mais processos, como no casode sistemas do tipo produtor/consumidor. Por exemplo, suponha dois processosonde um coloca mensagens em buffer e outro retira as mensagens. Os processospodem usar dois semáforos para sincronizar o acesso ao buffer de mensagens:um para controlar a entrada na região crítica e outro para contar o número demensagens. A figura IX.xx mostra os esquemas dos processos. A implementaçãodos semáforos em Java pode ser visto no exemplo IX.xx e o uso dos semáforos Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 296em uma situação como a ilustrada pela figura IX.xx pode ser visto no exemploIX.xx.Produtor Consumidors=1; n=0;início loop início loop Produz mensagem P(n) // Verifica se existe mensagens P(s) // Verifica se pode entrar na região P(s) // Verifica se pode entrar na região // crítica //crítica Coloca mensagem no buffer Retira mensagem V(n) // incrementa no, de mensagens V(s) // sai da região crítica V(s) // sai da região crítica Consome Mensagemfim loop fim loop Figura IX.xx – Comunicação entre processos usando semáforos.public class Semaforo{ private int cont; public Semaforo(){cont =0;} public Semaforo(int i){cont =i;} public synchronized void P() throws InterruptedException { while(cont <=0) this.wait(); cont--; } public synchronized void V() { cont++; notifyAll(); }} Exemplo IX.XX – Implementação de um Semáforo. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 297import java.util.Vector;class Consumidor extends Thread{ private Vector buff; private Semaforo s,n; public Consumidor(Vector aBuff, Semaforo as, Semaforo an) { super(); buff = aBuff; s = as; n = an; } public void run() { for (;;) try { n.p(); // Verifica se existe mensagens s.p(); // Verifica se pode entrar na região crítica String men = (String)buff.firstElement(); buff.removeElementAt(0); s.v(); if (men.equals("fim")) return; System.out.println("Mensagem recebida:"+men); } catch(Exception e) {System.out.println(e.getMessage());} }}class Produtor extends Thread{ private Vector buff; private Semaforo s,n; public Produtor(Vector aBuff, Semaforo as, Semaforo an) { super(); buff = aBuff; s = as; n = an; } public void run() { for (int i=0;i<11;i++) { try { s.p();// Verifica se pode entrar na região crítica if (i<10) { buff.addElement(""+i); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 298 System.out.println("Mensagem enviada: "+ i); } else buff.addElement("fim"); n.v(); // incrementa o número de mensagens s.v(); // abandona a região crítica Thread.yield(); } catch(Exception e) {System.out.println(e.getMessage());} } }}public class TestaSemaforo{ public static void main(String args[])throws Exception { Vector buff = new Vector(); Semaforo s = new Semaforo(1); Semaforo n = new Semaforo(0); Produtor t1 = new Produtor(buff,s,n); Consumidor t2 = new Consumidor (buff,s,n); t1.start(); t2.start(); }} Exemplo IX.XX – Uso de semáforos por dois threads. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 299Capítulo XII - Animação Animação é exibir uma figura que muda com o tempo. No momento osuporte a animação da API central do Java é limitado. Espera-se para o final de1997 uma API que dê suporte avançado para animação. A animação pode sercontrolado por um thread que é executado em um certo intervalo pré-definido.Exemplo básico de animação “in-place”.import java.awt.*; import java.applet.Applet;public class exemplo10 extends Applet implements Runnable{ Image imgs[]; int ind=0; Thread t1; public void init() {imgs = initImgs(); t1=new Thread(this); t1.start();} public void paint(Graphics g) {g.draw.Image(imgs[ind],0,0,this);} public void start() { if (t1 == null) { t1 = new Thread(this); t1.start();} } public void stop() { if (t1 != null) {t1.stop();t1 = null;} } public void run() { while (true){ try {Thread.sleep(100};} catch(InterruptedException ex){} repaint(); ind=++ind % imgs.length; } }}Problemas com o exemplo Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 300 Ele não permite interromper a animação. O repaint() chama oupdate() default que repinta todo o fundo, o que causa “flicker” na animação.Existe um problema relacionado com a integridade da variável ind. A variável éatualizada pelo Thread t1 (run) e lida pelo Thread update (paint).permitir interromper a animação.boolean pause = false;public boolean mouseDown(Event e, int x, int y){ if (pause) {t1.resume();} else {t1.suspend();} pause = !pause; return true;}Eliminar o “flicker”Defaultpublic void update(Graphics g){ g.setColor(getBackground()); g.fillRect(0,0,width, height); g.setColor(getForeground()); paint(g);}Mudançapublic void update(Graphics g) {paint(g);}Eliminando conflitospublic synchronized void paint(Graphics g){ g.draw.Image(imgs[ind],0,0,this);}public synchronized void mudaInd() Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 301{ ind = ++ind % imgs.length;}Copiando a figurapublic void drawStickFigure (Graphics g, int nX, int nY){ g.drawOval (nX + 10, nY + 20, 20, 40); g.drawLine (nX + 20, nY + 60, nX + 20, nY + 100); g.drawLine (nX + 10, nY + 70, nX + 30, nY + 70); g.drawLine (nX + 10, nY + 150, nX + 20, nY + 100); g.drawLine (nX + 20, nY + 100, nX + 30, nY + 150);}public void paint (Graphics g, Applet Parent){ if (bFirstTime) { bFirstTime = false; drawStickFigure (g, nX, nY); } else { g.copyArea (nX, nY, 35, 155, 5, 0);}}Double-bufferoffScreenImage = createImage (nWidth, nHeight);offScreenGraphic = offScreenImage.getGraphics(); ...offScreenGraphic.setColor (Color.lightGray);offScreenGraphic.fillRect (0, 0,nWidth, nHeight);offScreenGraphic.setColor (Color.black); ...offScreenGraphic. drawOval(10,10,20,20); ...g.drawImage (offScreenImage, 0, 0, this);Ticker-Tapeclass TextScrolling extends AnimationObject{ String pcMessage; // The message int nXPos; // The location of the message int nYPos; // The location of the message int nAppletWidth; // The width of the applet int nMessageWidth; // The width of the messagepublic TextScrolling (String pcMsg, int nWide) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 302{ pcMessage = pcMsg; nAppletWidth = nWide; nMessageWidth = -1; nYPos = -1; nXPos = 0;}public void paint (Graphics g, Applet parent){ if (nYPos < 0) { nYPos = (g.getFontMetrics ()).getHeight (); char pcChars []; pcChars = new char [pcMessage.length() + 2]; pcMessage.getChars(0, pcMessage.length()- 1, pcChars, 0); nMessageWidth = (g.getFontMetrics ()).charsWidth (pcChars, 0, pcMessage.length()); } g.drawString (pcMessage, nXPos, nYPos);}public void clockTick (){ if (nMessageWidth < 0) return; // Move Right nXPos -= 10; if (nXPos < -nMessageWidth) nXPos = nAppletWidth - 10;}public void run(){ int ndx = 0; Thread.currentThread().setPriority (Thread.MIN_PRIORITY); while (size().width > 0 && size().height > 0 && kicker != null) { AnimatedObjects[0].clockTick (); repaint(); try {Thread.sleep(nSpeed);} catch (InterruptedException e){} }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 303Capítulo XIII - Programação emrede Diferentemente das linguagens mais populares atualmente, Java foiprojetada na era da Internet, e por isso mesmo ferramentas para comunicaçãodentro da Grande Rede foram incorporadas à linguagem desde a sua concepção.Classes para manipulação de URLs e dos protocolos que constituem a Internetfazem parte do núcleo básico da linguagem. Isto facilita muito a tarefa dedesenvolver aplicações que para a Internet ou outras redes que fazem uso domesmo conjunto de protocolos. Esta é uma das principais forças da linguagemJava. De modo a entendermos como desenvolver aplicações em rede com Java éimportante o compreensão de alguns conceitos básicos sobre protocolos decomunicação.Conceitos Sobre Protocolos Usados na Internet Um protocolo de comunicação é um conjunto de formatos e regrasusadas para transmitir informação. Computadores distintos devem obedecerestas regras e formatos de modo que se possam comunicar. Podemos encarar oprotocolo como a definição de uma linguagem comum de modo a possibilitar acomunicação entre diferentes entidades. Visando diminuir a complexidade de implementação e uso do protocolo,ele é divido e organizado em forma de camadas de protocolos, onde a camadarelativamente inferior na pilha a outra estabelece as regras para a camadasuperior sobre a utilização de seus serviços. As camadas inferiores fornecemserviços mais básicos de transmissão de dados, enquanto que as camadassuperiores oferecem serviços de mais alto nível. Esta forma de organizaçãohierárquica de protocolos é também chamada de pilha de protocolos. A principal pilha de protocolo sobre o qual a Internet se organiza é oTCP/IP. Por simplicidade chamaremos a pilha de protocolos TCP/IP apenascomo protocolo TCP/IP ou TCP/IP. A figura XI.1 mostra como se organizamalguns dos protocolos que fazem parte do TCP/IP. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 304 A camada física é a responsável pela transporte efetivo dos dados sobre omeio físico. A camada de rede é responsável pela interface lógica entre oscomputadores. A camada de transporte provê transferência de dados a nível deserviço, e a camada de aplicação provê comunicação a nível de processos ouaplicações. Exemplos de protocolos a nível de aplicação são: FTP, usado paratransferência de arquivos; HTTP, usado para transmissão de páginas Web;TELNET provê capacidade de log-on remoto; SMTP provê serviços básicos decorreio eletrônico; SNMP usado para gerência da rede; e MIME que é umaextensão do SMTP para lidar com mensagens com conteúdos diversos. MIMECamada de Aplicação FTP HTTP SMTP TELNET SNMPCamada de Transporte TCP UDPCamada de rede IPCamada física Ethernet, X.25, Token Ring FTP - File Transfer Protocol SMTP - Simple Mail Transfer Protocol HTTP - Hypertext Transfer Protocol SNMP - Simple Network Management Protocol IP - Internet Protocol TCP - Transmission Control Protocol MIME - Multi-purpose Internet Mail Extensions UDP - User Datagram Protocol Figura XI.1 –Alguns protocolos da pilha TCP/IP. No processo de transmissão de dados sobre uma rede TCP/IP os dadossão divididos em grupos chamados de pacotes. Cada camada adiciona um algunsdados a mais no início de cada pacote para permitir que o pacote chegue aodestino. Os dados adicionados são chamados de headers. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 305 Dados Aplicação TCP Dados Transporte Header IP TCP Dados Rede Header Header Ethernet IP TCP Dados Física Header Header Header Figura XI.2 –Headers adicionados a cada camada de protocolo. Na camada de transporte existem dois protocolos que fazem uso doprotocolo IP: o protocolo TCP/IP e o UDP.TCP O protocolo TCP é um protocolo orientado a conexão que provê umfluxo confiável de dados entre dois computadores. Por protocolo orientado aconexão queremos dizer que é estabelecido um canal de comunicação ponto-a-ponto onde os dados podem trafegar em ambas as direções. O TCP garante queos dados enviados em uma ponta cheguem ao destino, na mesma ordem queforam enviados. Caso contrário, um erro é reportado. Protocolos como HTTP,FTP e TELNET exigem um canal de comunicação confiável e a ordem derecebimento dos dados é fundamental para o sucesso dessas aplicações.UDP No entanto, nem todas as aplicações necessitam destas características doprotocolo TCP e o processamento adicional exigido para garantir aconfiabilidade e a ordenação dos dados podem inviabilizá-las. Para esses casosexiste o protocolo de transporte UDP. UDP é um protocolo para envio de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 306pacotes independentes de dados, chamados de datagramas, de um computador aoutro, sem garantias sobre a chegada dos pacotes. O protocolo UDP não éorientado a conexão.IDENTIFICAÇÃO DE HOSTS (Número IP) Cada computador conectado a uma rede TCP/IP é chamado de Host e éidentificado por um único número de 32 bits, denominado de número IP. Onúmero IP é representado por quatro grupos de 8 bits, limitando desta forma ovalor numérico de cada grupo ao valor máximo de 255. Um exemplo de númeroIP é 200.65.18.70. Uma vez que é muito difícil lembrar e atribuir significado anúmeros existe uma forma alternativa de identificar os computadores da rede pormeio de nomes. Um ou mais computadores da rede fazem o papel deresolvedores de nomes, mantendo bases de dados que associam o nomes doHosts à seus números IP. Desta forma é possível um computador comunicar comoutro computador por meio do nome lógico e não por meio do número IP. Afigura XI.3 ilustra a comunicação entre dois computadores. A Internet érepresentada como uma nuvem devido a complexidade da rede. Host meucomp.com.br Host outrocomp.edu IP: 200.18.46.12 IP: 205.50.30.75 Figura XI.3 –Representação da comunicação entre dois computadores. O representação dos nomes dos computadores na Internet é feita porsubstrings separadas por ‘.’ e obedecem uma regra de nomeação que define queo primeiro substring representa o nome da máquina, e os restantes representa odomínio onde está inserida a máquina. Um domínio é um agrupamento decomputadores que pertencem a uma instituição, órgão, empresa, ou umaorganização qualquer. Assim, no exemplo da figura XI.3 o computadormeucomp pertence ao domínio com.br. No Brasil a FAPESP (Fundação de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 307Amparo à Pesquisa do Estado de São Paulo) responsável pela gerência dosnomes dos domínios na Internet.Identificação de Processos (Portas) A comunicação entre dois processos em uma rede TCP/IP é assimétrica,no sentido um processo faz o papel de servidor, oferecendo um serviço e outrofaz o papel de cliente do serviço. Em um único Host vários processos podemestar fazendo o papel de servidor, oferecendo serviços através de um único meiofísico. Portanto, é preciso uma forma de identificar as servidores em um mesmoHost. Isto é feito por meio da associação de um número inteiro, chamado deporta, ao processo servidor. Essa associação é feita pelo processo assim que écarregado, por meio de uma chamada ao sistema. O número da porta pode variarde 1 a 65535, no entanto os números de 1 a 1023 são reservados para serviçosconhecidos como FTP e HTTP. O programador não deve usar estas portas a nãoser que esteja implementando algum desses serviços. Nos ambientes Unix asportas que vão de 6000 a 6999 são usadas pelo gerenciador de Interfaces XWindows e 2000 a 2999 por outros serviços, como o NFS. Nestes ambientes,estas faixas de números de portas também devem ser evitadas. A tabela XI.1mostra o número da porta de alguns dos serviços mais conhecidos. Protocolo Porta HTTP 80 echo 7 FTP 20,21 SMTP 25 Finger 79 Daytime 13 pop3 110 Tabela XI.1 – Número das portas dos principais serviços. Uma vez associado a uma porta o serviço pode ser acessado por umaaplicação cliente, bastando para isso que ela indique o nome do Host e o númeroda porta ao se comunicar. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 308Programação em Rede com Java O pacote java.net contém as classes e interfaces usadas paraprogramação de sistemas em rede com Java. As classes podem ser enquadradasem três categorias: 1. Classes para comunicação básica em rede. Tratam da comunicação em baixo nível entre aplicações. Outros protocolos podem ser implementados usando como base esta comunicação básica. 2. Classes para comunicação dentro da Web. Estas classes provêem facilidades para acessar conteúdos por meio de URLs. 3. Classes para tratamento dos formatos estendidos da Web. Utilizadas para tratar novos protocolos e tipos MIME.Comunicação Básica Entre Aplicações As classes Socket, ServerSocket, DatagramSocket,DatagramPacket e InetAddress, fornecem os métodos necessários paraa comunicação básica entre dois processos. A tabela XI.2 descreve sucintamentecada uma das classes.Classe DescriçãoSocket Provê um socket cliente para comunicação orientada à conexão via protocolo TCP.ServerSocket Provê um socket servidor para comunicação orientada à conexão via protocolo TCP.DatagramSocket Provê um socket UDP para comunicação não orientada à conexão.DatagramPacket Representa um datagrama que pode ser enviado usando DatagramSocket.InetAddress Representa os dados de um Host (Nome e endereço IP) Tabela XI.2 – Classes para comunicação básica. As classes Socket e ServerSocket são utilizadas para comunicaçãoorientada à conexão, enquanto que as classes DatagramSocket eDatagramPacket são utilizadas para comunicação não orientada à conexão. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 309Comunicação orientada à conexão (cliente) Para comunicar via protocolo TCP é preciso que a aplicação cliente crieum objeto Socket. É preciso passar o nome ou número IP do Host e o númeroda porta onde o servidor está esperando as solicitações de serviço. A ClasseSocket possui os métodos getInputStream() egetOutputStream(), que são usados para obter Streams associados aoSocket. Deste modo, a transmissão de dados via Socket é idêntica à leitura eescrita em arquivos via Streams. O exemplo XI.1 mostra o código de um clienteque acessa um servidor de Daytime. O serviço de Daytime é disponibilizado nasplataformas UNIX e é acessado via porta 13. Sua função enviar, aos processosclientes, uma linha de texto contendo a data e a hora corrente .import java.io.*;import java.net.*;public class ClienteData { public static void main(String[] args) throws IOException { Socket socket = null; BufferedReader in = null; try { socket = new Socket(args[0], 13); in = new BufferedReader(new InputStreamReader( socket.getInputStream())); }catch (UnknownHostException e) {System.err.println("Não achou o host:"+args[0]); System.exit(1);} catch (IOException e) {System.err.println("Erro de I/O."+e.getMessage()); System.exit(1);} System.out.println("Data: " + in.readLine()); } in.close(); socket.close(); }} Exemplo XI.1 – Cliente para o serviço de Daytime. No programa do exemplo XI.1 o usuário precisa passar o nome do Hostservidor pela linha de comando. Você pode testar este programa mesmo que seu Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 310computador não esteja conectado em uma rede, desde que o protocolo TCP/IPesteja instalado. É que você pode passar como parâmetro o nome do seucomputador ou, alternativamente, o nome localhost, ainda o número IP127.0.0.0. O nome localhost e o número IP127.0.0.0 sempre identificam ocomputador local. Note que após a criação do objeto Socket, o métodogetInputStream() é chamado e o objeto retornado é envolvido por umobjeto BufferedReader de modo a comunicar dados via rede da mesma formaque é realizada uma operação de E/S. Ao se terminar a operação é preciso fechartanto a instância BufferedReader quanto o objeto Socket. A instância da Classede E/S sempre deve ser fechada primeiro. Os Hosts que utilizam as variações do sistema operacional UNIXpossuem o serviço de Daytime, no entanto, outros sistemas operacionais podemnão implementar este serviço. O programador pode resolver este problemaimplentando ele mesmo um servidor de Daytime. A próxima seção mostrarácomo isto pode ser feito.Comunicação orientada à conexão (servidor) Para criar um processo servidor é preciso associá-lo à uma porta. Isto éfeito ao se criar uma instância da classe ServerSocket. Se estamos criando umnovo serviço é preciso associar a uma porta com valor maior que 1023. Seestamos implementando um serviço já estabelecido é preciso obedecer asespecificações definidas para o serviço. O exemplo XI.2 mostra o código de umservidor do serviço Daytime. Como não queremos substituir o serviço padrão deDaytime utilizaremos o número de porta 5013 no lugar do número 13. Para setestar este servidor com o programa cliente do exemplo X.1 é preciso alterar onúmero da porta no código do cliente. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 311import java.util.*;import java.io.*;import java.net.*;public class ServerData { public static void main(String[] args) throws IOException { SeverSocket ssocket = null; Socket socket = null; BufferedWriter out = null; ssocket = new SeverSocket (5013,5); for(;;) { socket = ssocket.accept(); out = new BufferedWriter (new OuputStreamWriter ( socket.getOuputStream())); out.write((new Date()).toString()+”n”); } out.close(); socket.close(); }} Exemplo XI.2 – Servidor de Daytime. Ao criar uma instância da classe ServerSocket o programador podeindicar o tamanho da fila de solicitações de conexão. As conexões são colocadasna fila até que o servidor possa atende-las. Se chegar alguma conexão e nãohouver espaço na fila a conexão será recusada. No nosso exemplo passamoscomo parâmetro o valor 5. Após criar o objeto ServerSocket o servidor deveindicar que está disposto a receber conexões. Isto é feito por meio da execuçãodo método accept() do objeto ServerSocket. Ao executar este método oprocesso passa para o estado bloqueado até que alguma conexão seja solicitada.Quando a conexão é solicitada o método accept() retorna um objeto Socketigual ao do processo cliente, que será usado para obter os Streams onde seráefetuada a comunicação. O Stream obtido do objeto Socket é encapsulado emobjeto BufferedWriter que será encarregado de enviar a cadeia de caracterescontendo a data e a hora para o cliente. O Servidor em implementa um laçoinfinito, recebendo e tratando solicitações de serviços. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 312 O servidor implementado acima trata uma solicitação de serviço por vez.Isto pode ser problemático quando existem vários clientes solicitando serviçosao mesmo tempo e o servidor leva um longo tempo tratando cada solicitação.Nesta situação o cliente pode ficar um longo tempo a espera de atendimento. Istopode ser remediado por meio da implementação de servidores Multithreaded.Apesar do serviço implementado pelo exemplo XI.2 não exigir um servidorMultithreaded, uma vez que o cliente é atendido rapidamente, o servidorDaytime foi alterado para exemplificar a implementação de um servidorMultithreaded. O exemplo XI.3 mostra o código da versão Multithreaded doservidor.import java.util.*;import java.net.*;import java.io.*;public class ServerData{ public static void main(String args[]) { ServerSocket ssocket=null; try { ssocket = new ServerSocket(pt); } catch(Exception e) {System.err.println(e);System.exit(1);} while(true) { try { Socket socket = ssocket.accept(); (new serversec(socket)).start(); } catch(Exception e) {System.err.println(e);} } }}class serversec extends Thread{ Socket socket; public serversec(Socket aSocket) {socket = aSocket;} public void run() { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 313 try { BufferedWriter out = new BufferedWriter (newOuputStreamWriter ( socket.getOuputStream())); out.write((new Date()).toString()+”n”); out.flush(); out.close(); socket.close(); } catch(Exception e) {System.err.println(e);} }} Exemplo XI.3 – Servidor de Daytime Multithreaded. No exemplo XI.3, ao receber uma conexão o servidor cria um Threadpara atender o cliente e fica disponível para receber novas solicitações. Esseexemplo pode ser usado como esqueleto para desenvolvimento de servidoresmais complexos, porém, neste caso é necessário limitar o número de Threadsque podem ser criados.Comunicação Sem Conexão (UDP) Como já dissemos na seção anterior, nem sempre é necessário um canalde comunicação confiável entre duas aplicações. Para estes casos existe oprotocolo UDP, que provê uma forma de comunicação onde a aplicação enviapacotes de dados, chamados de datagramas, para outra aplicação, sem garantiasse e quando a mensagem vai chegar, nem se o conteúdo está preservado. As portas do protocolo UDP obedecem a mesma distribuição das TCPporém são distintas uma da outra, de modo que o programador pode associaruma porta TCP de um determinado número à uma aplicação em um host e omesmo número de porta UDP a outra aplicação no mesmo host. As classes DatagramPacket e DatagramSocket contém osmétodos necessários para realizar este tipo de comunicação. Para ilustrar o usodestas classes modificaremos os exemplos XI.1 e XI.2 para implementarmosuma aplicação Cliente/Servidor Daytime que usa o protocolo UDP. O ExemploXI.4 mostra o código fonte do cliente e o Exemplo XI.5 mostra o código doservidor. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 314 Analisando o código da aplicação cliente podemos notar que é necessáriocriar um objeto da classe DatagramPacket para representar os Datagrama ondeos dados são armazenados. No nosso exemplo colocamos também os dados doHost e a porta, porém estes dados poderiam ser omitidos na construção doDatagrama e serem passados somente no envio/recepção do pacote ou naconstrução do DatagramSocket. O Datagrama deverá armazenar os dadosenviados pelo servidor e foi dimensionado para conter 64 bytes. O métodoreceive() do objeto DatagramSocket aguarda o recebimento do pacote,tendo como argumento o objeto da classe DatagramPacket. Após o recebimentodo pacote os dados são convertidos para String e exibidos na saída padrão. O servidor, diferentemente do servidor TCP, precisa saber a quem deveenviar os pacotes, uma vez que não é estabelecida uma conexão. Podíamossimplesmente passar o nome do host pela linha de comando, mas resolvemosadotar uma estratégia de Broadcasting. Nesta abordagem os datagramas sãoenviados a vários computadores e não apenas um. Isto é feito passando-se comoargumento para o método InetAddress.getByName() o endereço deBroadcast da rede.import java.io.*;import java.net.*;public class DataClienteUDP{ public static void main(String args[]) throws Exception { if (args.length != 1) { System.err.println("Uso: java DataClienteUDP host"); System.exit(1); } byte [] buff = new byte[64]; DatagramSocket ds = new DatagramSocket(); DatagramPacket dp = new DatagramPacket(buff, buff.length, InetAddress.getByName(args[0]),5013); ds.receive(dp); String s = new String(dp.getData()); System.out.println("Data e hora recebidade”+dp.getAddress()+ " : "+s); }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 315 Exemplo XI.4 – Cliente Daytime UDP.import java.io.*;import java.net.*;public class DataServerUDP{ public static void main(String args[]) throws Exception { DatagramSocket ds; DatagramPacket dp; InetAddress addr = InetAddress.getByName(“255.255.255.0”); ds = new DatagramSocket(); byte [] buff; for (;;) { Thread.sleep(1000); String s = (new Date()).toString(); buff = s.getBytes(); dp = new DatagramPacket(buff, buff.length, addr, 5013); ds.send(dp); } }} Exemplo XI.5 – Servidor Daytime UDP. O tipo de endereço de Broadcast depende da classe de endereçamento IPda rede. O endereço usado no exemplo IX.5 funciona para a classe deendereçamento C. Para descobrir que tipo de classe pertence a rede onde está seucomputador olhe o primeiro byte do endereço IP de sua máquina e verifiquejunto a tabela XI.3. Primeiro byte do endereço IP Classe Endereço de Broadcast 0 a 126 A 255.0.0.0 128 a 191 B 255.255.0.0 192 a 223 C 255.255.255.0 Tabela XI.3 – Classes para comunicação básica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 316 O envio dos dados é feito pelo método send() do objetoDatagramSocket, tendo como argumento um objeto da classe DatagramPacket.Note que não é necessário um “Socket servidor” uma vez que o servidor enviaos pacotes independentemente de existir clientes solicitando-os.Comunicação por meio de URL URLs Um URL (Uniform Resource Locator) é uma referência (um endereço) aum recurso na Internet. O URL é dividido em partes, sendo que apenas aprimeira parte é obrigatória. A maioria das URLs é dividida em três partes: Informação sobre o Host 678 123 Protocolo 123 http://dpi.ufv.br/professores.html endereço do recurso no Host A parte do protocolo define o protocolo que deve ser usado para acessaro recurso. Os protocolos mais comuns são FTP, HTTP e file, este últimoindicando que o recurso se encontra no sistema de arquivos local. O protocolo éseguido do caractere “:”. A parte com informação sobre o Host fornece a informação necessáriapara acessar o Host onde está localizado o recurso. Esta parte é omitida caso orecurso esteja no sistema de arquivos local. A informação sobre o Host éprecedida por duas barras (“//”), no caso de aplicação na Internet e apenas poruma barra (“/”), caso contrário. A informação sobre o Host também pode serdividida em três partes: a) o nome do domínio do Host; b) o nome e senha dousuário para login; e c) o número da porta caso necessário, após o nome do host,precedida pelo caractere “:”. Exemplos: http://java.sun.com:80/doc/tutorial.html http://infax.com.br."claudio"."1234"/base/vendas Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 317 A última parte de uma URL representa o caminho até o recurso nosistema de arquivos do Host. Esta seção é separada da seção anterior por umabarra simples (“/”). Manipulando URLs em Java A linguagem Java fornece as seguintes classes para manipulação deURLs:Classe DescriçãoURL Representa um URLURLConnection Classe abstrata que representa uma conexão entre uma aplicação e um URL. Instâncias desta classe podem ser usadas para ler e escrever no recurso referenciado pela URL.URLEncoder Usada para lidar com o formato MIME. Tabela XI.3 – Classes para manipulação de URLs. Um objeto URL é criado passando como parâmetro para o construtor oURL na forma de String: URL dpi = new URL("http://www.dpi.ufv.br"); Um objeto URL pode ser construído passando como parâmetro outroURL para servir de endereço base. Por exemplo URL profs = new URL (dpi,”professores.html”); Isto tem o mesmo efeito que gerar uma instância da classe URL comprimeiro construtor, passando como parâmetro o endereço: http://www.dpi.ufv.br/professores.html Os construtores geram a exceção MalformedURLException, se oURL é inválido. Portanto, o programador deve providenciar o código para acaptura e tratamento desta exceção. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 318 De posse de um objeto URL é possível obter um objeto InputStream paraler os dados endereçados pelo URL, utilizando o método openStream() doobjeto URL. O Exemplo XI.4 mostra o código de um programa que pode serusado para listar na saída padrão o conteúdo de um URL passado pela linha decomando.import java.net.*;import java.io.*;public class LeURL{ public static void main(String[] args) throws Exception { if (args.length < 1) { System.err.println("uso: java LeURL <URL>..."); System.exit(1); } URL url = new URL(args[0]); BufferedReader in = new BufferedReader( new InputStreamReader(url.openStream())); String linha; while ((linha = in.readLine()) != null) System.out.println(linha); in.close(); }} Exemplo XI.4 – Leitor de URL. Comunicando por meio de URLConnection O programador pode utilizar o método openConnection() do objetoURL para obter uma conexão entre a aplicação é o recurso referenciado pelo oURL. O método openConnection() retorna um objeto URLConnection,que permite que a aplicação escreva e leia através da conexão. Alguns URLs,como os conectados à scripts CGI5 (Common-Gateway Interface), permitem que5 Common-Gateway Interface (CGI) é um mecanismo para gerar páginas Web dinamicamente.Os dados são obtidos de fórmulários HTML e submetidos a um programa binário no servidor Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 319aplicação cliente escreva informação no URL. A saída do programa CGI podeser interceptada pelo programa Java de modo que possa ser exibida para ousuário. Esta forma de comunicação com scripts CGI é melhor do que por meiode formulários HTML, uma vez que o usuário não precisa navegar entre páginaspara visualizar os formulários e a resposta retornada. O Applet Java se encarregade enviar os dados e exibir o resultado na mesma página. Para ilustrar esta formade comunicação mostraremos um programa que submete uma cadeia decaracteres a um URL para que seja invertido e enviado de volta. O script CGIutilizado, escrito em Perl é exibido no exemplo XI.5 e foi escrito por HassanSchroeder, um membro da equipe de desenvolvimento da linguagem Java. EsteCGI pode ser acessado no URL http://java.sun.com/cgi-bin/backwards.#!/opt/internet/bin/perlread(STDIN, $buffer, $ENV{CONTENT_LENGTH});@pairs = split(/&/, $buffer);foreach $pair (@pairs){ ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /; $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg; # Stop people from using subshells to execute commands $value =~ s/~!/ ~!/g; $FORM{$name} = $value;}print "Content-type: text/plainnn";print "$FORM{string} reversed is: ";$foo=reverse($FORM{string});print "$foon";exit 0; Exemplo XI.5 – Script backwards para inverter uma cadeia de caracteres. O exemplo XI.6 contém o programa que envia uma cadeia de caracteresao URL e recebe de volta outra cadeia de caracteres que é a inversão daprimeira. A ação necessária é codificar a cadeia de caracteres por meio dométodo estático encode() da classe URLEncoder:que gera a resposta na forma de uma página Web. O programa pode ser escrito em umavariadade delinguagens, como Perl e C. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 320 String string = URLEncoder.encode(args[0]); Isto é necessário porque a string enviada a um URL necessita de umacodificação particular, como por exemplo, os espaços em branco sãosubstituídos pelo caractere “+”, os campos são separados pelo caractere “&”evalor do campo é separado do nome do campo pelo caracteres “=”. Em seguida o programa cria um objeto URL relacionado com o endereçoonde se encontra o script, abre uma conexão e define que será usada para entradae saída.URL url = new URL("http://java.sun.com/cgi-bin/backwards");URLConnection c = url.openConnection();c.setDoOutput(true); Neste momento o programa está preparado para trabalhar com o URLcomo se fosse um Stream. O Stream para escrever no URL é obtido do objetoURLConnection por meio do método getOutputStream() e o Streampara ler do URL é obtido do objeto URLConnection por meio do métodogetInputStream(). Primeiro o programa submete a cadeia de caracteres aser invertida precedida pelo nome do campo e pelo caractere “=”: out.println("string=" + string);import java.io.*;import java.net.*;public class Inverte{ public static void main(String[] args) throws Exception { if (args.length != 1) { System.err.println("Uso: java Inverte string"); System.exit(1); } String string = URLEncoder.encode(args[0]); URL url = new URL("http://java.sun.com/cgi- Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 321bin/backwards"); URLConnection c = url.openConnection(); c.setDoOutput(true); PrintWriter out = new PrintWriter(c.getOutputStream()); out.println("string=" + string); out.close(); BufferedReader in = new BufferedReader(newInputStreamReader( c.getInputStream())); String retorno; while ((retorno = in.readLine()) != null) System.out.println(retorno); in.close(); }} Exemplo XI.6 – Programa que escreve em um URL. Após isso o Stream de saída é fechado e o Stream de entrada é aberto. Acadeia de caracteres invertida é lida e exibida no dispositivo de saída padrão. No exemplo apresentado o script CGI usa o POST METHOD para lerdados enviados pelo cliente. Alguns scripts CGI usam o GET METHOD para lerdados do cliente, no entanto, este último está ficando rapidamente obsoletodevido a maior versatilidade do primeiro. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 322Capítulo XIV – Computaç ã oDistribuída (RMI) A RMI (Invocação de métodos remotos) é uma tecnologia que coloca aprogramação com rede em um nível mais alto. RMI torna possível que objetosdistribuídos em uma rede se comuniquem de forma transparente para oprogramador utilizando chamadas de procedimentos remotos. O principal objetivo da tecnologia RMI é permitir que programadoresdesenvolvam programas distribuídos utilizando a mesma sintaxe e semântica deprogramas Java convencionais. Antes da introdução da RMI no mundo Java, noJDK 1.1, para fazer com que dois objetos em máquinas diferentes secomunicassem o programador deveria definir um protocolo de comunicação eescrever código utilizando socket para implementar este protocolo. Com RMI amaior parte do trabalho quem realiza é a máquina virtual Java. Existem outras tecnologias, como CORBA (Common Object RequestBrocker Architecture), que também tem como objetivo fazer com que objetosdistribuídos em uma rede se comuniquem. Java também tem suporte a CORBA,mas para projetos em um ambiente Java puro, a RMI é consideravelmente maissimples que a CORBA.Criando nossa agenda distribuída De modo exemplificar o uso de RMI modificaremos a agenda distribuídafazendo uso desta tecnologia. Os passos a serem seguidos são: 1. Escrever e compilar a interface que descreve a como serão as chamadas do cliente ao servidor; 2. Escrever e compilar a classe que implementa a interface do passo 1 (objeto servidor); 3. Gerar Stubs e Skeleton do objeto distribuído; 4. Desenvolver o código que disponibiliza o objeto; 5. Escrever e compilar o código para o cliente RMI; e 6. Testar.Implementar interface do objeto remoto Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 323 O primeiro passo quando se deseja criar um objeto Remoto com RMI éimplementar uma interface para este Objeto. Essa interface deve herdar ainterface Remote. É através dessa interface Remote, que não tem métodos, que amáquina virtual Java sabe qual objeto pode ser disponibilizado para acessoremoto. Abaixo temos o exemplo da interface do nosso objeto: 1 public interface Agenda extends java.rmi.Remote{ 2 public void inserir(Pessoa p) 3 throws java.rmi.RemoteException; 4 public Pessoa getPessoa(String nome) 5 throws java.rmi.RemoteException; 6 public java.util.Enumeration getPessoas() 7 throws java.rmi.RemoteException; 8 } Exemplo XX.XX – Interface do objeto remoto.A interface Remote deve ser herdada pela nossa interface Agenda. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 324Capítulo XV - Acesso a B a nco deDados No dias de hoje, uma linguagem sem recursos para acesso a sistemas deBanco de Dados está fadada ao fracasso. Pensando nisso a Sun incluiu comoparte do núcleo de bibliotecas de classes da linguagem Java uma API com oobjetivo de preencher esta função, chamada de JDBC (segundo a Sun JDBC éapenas um acronismo, no entanto, muitas pessoas acreditam que é uma siglapara Java Database Connectivity). JDBC é uma API baseada no X/Open SQLCall Level Interface, tendo sido desenvolvida originalmente como um pacoteseparado, porém a partir do JDK1.1 passou a fazer parte do núcleo básico depacotes. Utilizando a API JDBC é possível conectar um programa Java comservidores de Banco de Dados e executar comandos SQL (Structure QueryLanguage). Sendo uma API independente do Sistema Gerenciador de Banco deDados, não é necessário escrever uma aplicação para acessar um Banco deDados Oracle, outra para uma Base de Dados Sybase, outra para o DB2, e assimpor diante. A idéia de se usar uma camada intermediária entre o Banco de Dados e aaplicação, com o objetivo de isolá-la das particularidades do SGBD, não é nova.O exemplo mais popular deste enfoque é a API ODBC (Open DataBaseConnectivity), proposta pela Microsoft. O leitor pode estar se perguntandoporque a Sun resolveu propor mais uma API em vez de adotar a ODBC. Existemvários motivos, porém o principal é que a API ODBC simplesmente não éadequada para a linguagem Java. Isto ocorre porque ODBC foi desenvolvidapara ser usada na linguagem C e é baseada fortemente no uso de ponteiros,estrutura que não existe em Java.Modelos de Acesso a Servidores O modelo mais simples de aplicação Cliente/Servidor é o chamado demodelo de duas camadas, onde a aplicação acessa diretamente o Banco deDados. A figura XIII.1 mostra o esquema para uma aplicação que acessa umBanco de Dados usando o modelo de duas camadas. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 325 Aplicação Java DBMS Figura XIII.1 – Modelo de acesso a Banco de Dados em duas camadas. Aplicação Java ou Applet HTTP, RMI, CORBA Aplicação Servidora Java JDBC DBMS Figura XIII.2 – Modelo de acesso a Banco de Dados em três camadas.Tipos de Drivers JDBC Os drivers JDBC devem suportar o nível de entrada do padrão ANSISQL-2. No momento, os drivers JDBC existentes se encaixam em um dos quatrotipos abaixo:1. Ponte JDBC-ODBC com driver ODBC – o driver JDBC acessa o banco de dados via drivers ODBC. Como ODBC é um código binário e, em alguns casos, compõe o código do cliente, é necessário instalar em cada máquina cliente que usa o driver. Essa é uma solução adequada somente para uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 326 interna corporativa, ou em aplicações que adotam o modelo de três camadas sendo a camada intermediária um servidor Java. SGBD1 Cliente Ponte SGBD2 Java JDBC-ODBC SGBD32. Driver Java parcial e Api Nativa – neste caso as chamadas JDBC são convertidas para as chamadas às APIs nativas do SGBD. Como o driver possui uma parte em código binário é necessário instalar algum código na máquina cliente, como é feito nos drivers do tipo 1. Protocolo do SGBD Cliente JDBC Java & SGBD Java Código Binário3. Driver puro Java e protocolo de rede – neste caso as chamadas JDBC são convertidas para um protocolo de rede independente do SGBD que é depois traduzido para as chamadas às APIs nativas do SGBD por um servidor. Esta é uma arquitetura em três camadas, onde o servidor middleware é capaz de conectar seus clientes Java puros com vários SGBDs. Esta solução permite o desenvolvimento de clientes 100% Java, tendo como consequência a não necessidade de instalação de qualquer código na máquina cliente. JDBC DRIVER (100% Java) SGBD1 Cliente Servidor de SGBD2 Java acesso SGBD34. Driver Java Puro e protocolo nativo - neste caso as chamadas JDBC são convertidas para as chamadas às APIs nativas do SGBD pelo driver, que foi escrito totalmente em Java. Protocolo do SGBD Cliente JDBC Java SGBD Java (100% Java) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 327 Atualmente existe uma maior disponibilidade dos drivers tipo 1 e 2, mas atendência é que estes desapareçam, sendo substituídos pelos drivers do tipo 3 e4.Obtendo os Drivers JDBC Informações sobre como obter drivers JDBC podem ser obtidas no sitehttp://www.javasoft.com/products/jdbc. Outra alternativa éacessar as páginas dos fabricantes de SGBD, para verificar se existe driverdisponível.Preparando um Banco de Dados Os exemplos deste livro usam a ponte JDBC-ODBC para conectar com oBanco de Dados. Isto facilita para os usuários que possuem um gerenciadorBanco de Dados pessoal como o Access, Paradox, e outros semelhantes. Alémdisso, como driver JDBC-ODBC está incorporado ao SDK, o usuário nãonecessita procurar um driver para testar os exemplos. O lado negativo destaabordagem está na necessidade de configurar o ODBC e no fato de que asaplicações remotas deverão ser desenvolvidas em três camadas. No entanto,nada impede que o leitor use outro driver para rodar os exemplos, bastando paraisso alterar a chamada da carga do driver. Primeiramente é necessário criar uma base de dados em algum SGBD.Nos exemplos deste livro será usada uma base contendo dados sobre livros,alunos e empréstimos de livros aos alunos. Não trataremos neste livro dosconceitos relacionados com banco de dados relacionais nem sobre a linguagemde consulta SQL. Existem vários textos sobre o assunto onde o leitor podebuscar informação. As figuras XIII.3 a XII.5 mostram as tabelas que formam a base de dadosusada nos exemplos. O banco de dados é formado por três tabelas. Uma paraarmazenar os dados dos alunos, outra para receber os dados dos livros e umaterceira para conter os dados dos empréstimos. alunos matricula nome 1 Railer Costa Freire 2 Alexandre Altoé Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 328 3 André M. A. Landro 4 Ana Maria Freitas 5 Claudia Maria 6 Alexandra Moreira Figura XIII.3 – Tabela de alunos livros codlivro titulo volume 1 Curso Pratico de Java 1 2 Curso Pratico de Java 2 3 Introdução a Compiladores 1 4 Fundamentos de Banco de Dados 1 5 Redes de Computadores 1 6 Redes de Computadores Fácil 2 7 Lógica matemática 1 8 Engenharia de Software para Leigos 1 9 Aprenda Computação Gráfica em duas 1 10 Aprenda Inteligência Artificial em 5 1 Figura XIII.4 – Tabela de livros. emprestimos codlivr matricu data_empresti data_devoluc 1 1 01/01/99 10/01/99 7 3 03/01/99 13/01/99 9 6 12/01/99 22/01/99 1 3 20/01/99 30/01/99 4 2 03/02/99 13/02/99 10 2 12/02/99 22/02/99 Figura XIII.5 – Tabela de empréstimos. Em um Banco de Dados Relacional cada tabela representa um conjuntode entidades ou relacionamentos entre entidades, e cada linha da tabelarepresenta uma entidade particular ou um relacionamento entre entidades.Assim, cada linha das tabelas alunos e livros representa um aluno e um livrorespectivamente. Já na tabela empréstimos cada linha representa orelacionamento por empréstimo de um livro a um aluno. Para estabelecer este Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 329tipo de relacionamento em um Banco de Dados Relacional é preciso colocar natabela que representa o relacionamento os atributos chaves de cada entidade queparticipa da relação. Atributos chaves são os atributos que identificam cadaentidade. No caso dos alunos é seu número de matrícula, uma vez que podeexistir dois alunos com o mesmo nome. Já no caso de um livro o seu atributochave é o código do livro. Um Banco de Dados Relacional pode ser representadopelo diagrama de classes da UML, como mostrado pela figura XIII.6, onde cadatabela é vista como uma classe. Alunos livros matricula codlivro nome titulo volume emprestimos data_emprestimo data_devolução Figura XIII.6 – Diagrama de Classes do Banco de Dados. Para criação das tabelas em banco de dados relacional deve-se usarcomandos DDL (Data Definition Language). O exemplo XX.XX mostra oscomandos em DDL para a criação das tabelas do exemplo:CREATE TABLE ALUNOS (MATRICULA INT PRIMARY KEY, NOME VARCHAR(50) NOT NULL);CREATE TABLE LIVROS (CODLIVRO INT PRIMARY KEY, TITULO VARCHAR(50) NOT NULL, VOLUME INT NOT NULL);CREATE TABLE EMPRESTIMOS ( CODLIVRO INT NOT NULL, MATRICULA INT NOT NULL, DATAEMP DATE NOT NULL, DATADEV DATE NOT NULL, CONSTRAINT PK_EMP PRIMARY KEY (CODLIVRO, MATRICULA, DATAEMP), CONSTRAINT FK_EMP1 FOREIGN KEY (CODLIVRO ) REFERENCES LIVROS (CODLIVRO ), Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 330 CONSTRAINT FK_EMP2 FOREIGN KEY (MATRICULA) REFERENCES ALUNOS (MATRICULA ));Exemplo XX.XX – Comandos em DDL para criação das tabelas em um SGBD relacional.Configurando o ODBC Como utilizamos nos exemplos a ponte JDBC-ODBC é necessárioconfigurar o ODBC para acessar a base de dados acima. Na plataformaWindows 98 isso é feito da seguinte forma: 1. Execute o programa de configuração do ODBC por meio do ícone “ODBC de 32bits” do painel de controle. 2. Clique na pasta “NFD do sistema” e em seguida no botão de “adicionar...”. O NFD do sistema é escolhido no lugar da opção “NFD do usuário” porque permite o compartilhado à base de dados. 3. Selecione o driver do banco de dados e pressione o botão de concluir. Por exemplo, se você estiver usando o Access selecione a opção “Driver para o Microsoft Access (*.mdb)”. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 331 Figura XIII.7 – Seleção do driver ODBC no Windows. 4. Ao surgir a tela para a entrada seleção do Banco de Dados, utilize a tecla “Selecionar...” localizar o arquivo onde está a base de dados e preencha a janela de texto “Nome da fonte de dados” com o nome que será usado para referenciar a base. 5. Feche o programa de configuração. A configuração de uma base de dados para ser acessada via ODBCpossui vários outros detalhes que consideramos não ser relevantes para ospropósitos deste livro. A configuração como apresentada acima é a suficientepara se executar os exemplos deste livro.Exemplo Inicial O pacote java.sql fornece as classes e interfaces necessárias para aconexão com uma base de dados e a posterior manipulação dos dados. As etapaspara se criar uma aplicação cliente de um SGBD em Java são as seguintes: 1. Carregar o driver JDBC. 2. Estabelecer a conexão. 3. Criar um objeto Statement. 4. Executar o comando SQL por meio de um método do objeto Statement. 5. Receber o resultado, se for o caso. Para comentar cada uma destas etapas utilizaremos o exemplo XII.1 quemostra o código de uma aplicação que lista no dispositivo de saída padrão onome de todos os alunos.import java.sql.*;import java.net.URL;class jdbc{ public static void main(String a[]) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 332 { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection con = DriverManager.getConnection("jdbc:odbc:biblioteca"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT NOME FROM alunos"); System.out.println("Nome"); while(rs.next()) System.out.println(rs.getString("nome")); stmt.close(); con.close(); } catch(Exception e) {System.out.println(e.getMessage()); e.printStackTrace();} }} Exemplo XX.XX – Código para listar o nome dos alunos.Carregando o Driver A primeira etapa é carregar o driver JDBC. Para isso é usado o métodoestático forName() da classe Class. Em caso de erro este método lança aexceção ClassNotFoundException. O método cria uma instância dodriver e o registra junto ao DriverManager. No exemplo XIII.1 é carregado odriver JDBC-ODBC que vem junto com o SDK.Estabelecendo a conexão A segunda etapa é realizada por meio do método estáticogetConnection() da classe DriverManager. Este método, na sua forma maissimples, recebe como parâmetro um URL que faz referência a base de dados eretorna um objeto da classe Connection, que representa a conexão com a base dedados. Já discutimos sobre URLs no capítulo XI. No entanto, existem algumasparticularidades no que refere a URLs que fazem referência à Banco de Dados.O formato padrão deste tipo de URL é o seguinte: jdbc:<subprotocolo>:<identificador>onde: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 333 1. jdbc representa o protocolo; 2. <subprotocolo> se refere ao driver ou ao mecanismo de conexão com o Banco de Dados, que pode ser suportado por um ou mais drivers. No exemplo XII.1 o nome é utilizada a ponte JDBC-ODBC, representada pela palavra odbc no subprotocolo. 3. <identificador> é a parte onde se identifica o Banco de Dados. A forma de identificação varia de acordo com o subprotocolo. No nosso exemplo é colocado o mesmo nome usado para identificar a fonte de dados na configuração do ODBC. A sintaxe para o subprotocolo odbc é a seguinte: jdbc:odbc:<fonte de dados>[;<atributo>=<valor>]* onde <atributo> e <valor> representam parâmetros a serem passados para o gerente de conexão do Banco de Dados. Um banco de dados acessado remotamente requer maiores informações,como o nome do host e a porta. Tanto o uso local como remoto pode requerer aidentificação do usuário, assim como uma senha. Estes dados podem serpassados como parâmetro no método getConnection(): getConnection("jdbc:odbc:contas",”ana”,”sght”);ou como parte do URL. Alguns exemplos de URLs estão descritos na tabelaXIII.1 URL Descriçãojdbc:odbc:biblioteca Referencia fonte de dados biblioteca via ponte JDBC-ODBC.jdbc:odbc:bd1;CacheSize=20 Referencia fonte de dados bd1 via ponte JDBC-ODBC. É definido o tamanho do cache.jdbc:odbc:contas;UID=ana;PWD=sght Referencia fonte de dados contas via ponte JDBC-ODBC. É passado também o nome do usuário e a senha.jdbc:oracle:thin:@sap.dpi.ufv.br:1521:agenda Referencia fonte de dados agenda no host remoto sap.dpi.ufv.br via subprotocolo oracle. É passado também o número da porta usada no acesso. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 334 Tabela.1 – Exemplos de URLs JDBC.Criando e Executando Comandos É necessário cria um ou mais objetos da classe Statement, que possui osmétodos necessários para manipular a base de dados. Este objeto é criado pormeio do método createStatement() do objeto da classe Connection. Statement stmt = con.createStatement(); Podemos então usar o objeto Statement para executar comandos demanipulação do Banco de Dados. No exemplo XIII.1 o objetivo é recuperar snomes dos alunos. Este objetivo é atingido por meio da execução do comandoSQL SELECT nome FROM alunospassado como parâmetro para o método executeQuery() do objetoStatement. Este método retorna um objeto que implementa a interfaceResultSet, e que fornece os meios de acesso ao resultado da consulta. Muitasvezes, como no exemplo, o resultado de uma consulta é uma tabela com váriaslinhas. O programador pode utilizar o objeto ResultSet para acessar cada linhada tabela resultante em sequência. Para isso o objeto mantém um apontador paraa linha corrente, chamado de cursor. Inicialmente o cursor é posicionado antesda primeira linha, movimentado para próxima linha por meio de chamadas aométodo next() do objeto ResultSet. O método executeQuery() é usado apenas para consultas. Alémdesse método, a classe Statement possui o método execute() que retornamúltiplos ResultSets e o método executeUpdate(), para atualização(comandos INSERT, DELETE e UPDATE da linguagem SQL), criação detabelas (comandos CREATE TABLE) e remoção (DROP TABLE). O valor deretorno do método executeUpdate() é um valor inteiro indicando onúmero de linhas afetadas ou zero no caso do DROP TABLE. Um exemplo deum comando para inserir um uma novo aluno na tabela seria: stmt.executeUpdate("INSERT INTO alunos VALUES(7, Ana mia)"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 335Recuperando Valores O objeto ResultSet possui os métodos necessários para recuperar osvalores de cada coluna da tabela, bastando passar o nome da coluna comoparâmetro. No exemplo XIII.1 é utilizado método getString() pararecuperar o valor da coluna “nome”. Os métodos para recuperação possuem oformato geral getXXX(), onde XXX é o nome de um tipo. A tabela XIII.2mostra qual o método mais indicado para cada tipo SQL. T S I B R F D D N B C V L B V L D T T I M N I E L O E U I H A O I A O A I I N A T G A O U C M T A R N N R N T M M Y L E I L A B I E R C G A B G E E E I L G N T L M R H V R I V S N I E T E A I A A Y N A T T N R L C R R A R A T C R B M H Y I P A N R A R YgetByte X x x x x x x x x x x x xgetShort x X x x x x x x x x x x xgetInt x x X x x x x x x x x x xgetLong x x x X x x x x x x x x xgetFloat x x x x X x x x x x x x xgetDouble x x x x x X X x x x x x xgetBigDecimal x x x x x x x X X x x x xgetBoolean x x x x x x x x x X x x xgetString x x x x x x x x x x X X x x x x x x xgetBytes X X xgetDate x x x X xgetTime x x x X xgetTimestamp x x x x XgetAsciiStream x x X x x xgetUnicodeStre x x X x x xam Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 336getBinaryStrea x x XmgetObject x x x x x x x x x x x x x x x x x x x“x” indica que o método pode ser usado para recuperar o valor no tipo SQL especificado.“X” indica que o método é recomendado para ser usado na recuperação do valor no tipo SQL especificado Tabela XIII.2 – Tabelas com os métodos indicados para recuperação de valores. É possível recuperar o valor da coluna passando como parâmetro onúmero da coluna no lugar de seu nome. Neste caso a recuperação no nome doaluno no exemplo XIII.1 ficaria na seguinte forma: rs.getString(1);Transações e Nível de IsolamentoTransação Uma Transação é um conjunto de operações realizadas sobre um bancode dados tratadas atomicamente, em outras palavras, ou todas operações sãorealizadas e o seu resultado registrado permanentemente na base de dados ounenhuma operação é realizada. Por default, o banco de dados trata cada operaçãocomo uma transação, realizando implicitamente uma operação de commit ao fimde cada uma delas. A operação de commit registra permanentemente o resultadoda transação na tabela. No entanto, existem situações onde é necessário tratar como umatransação um conjunto de operações, e não apenas uma transação. Por exemplo,suponha que em um Banco de Dados de uma agência bancária exista uma tabelacom informações sobre a conta de corrente e outra com informações sobrecontas de poupança. Suponha também que um cliente deseje transferir o dinheiroda conta corrente para uma conta de poupança. Essa transação é constituídapelas seguintes operações: 1. Caso exista saldo suficiente, subtração do montante da transferência do saldo da conta corrente. 2. Adição do montante da transferência ao saldo da conta de poupança. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 337 As operações acima precisam ocorrer totalmente ou o efeito de nenhumadelas deve ser registrado na base de dados. Caso contrário podemos ter umasituação onde o dinheiro sai da conta corrente mas não entra na conta dapoupança. Este estado, onde as informações do banco de dados não reflete arealidade, é chamado de estado inconsistente. De modo a obter esse controle sobre as transações é necessáriodesabilitar o modo de auto-commit. Isto é feito por meio métodosetAutoCommit() do objeto Connection. con.setAutoCommit(false); A partir do momento em que é executado o comando acima, oprogramador é responsável pela indicação do final da transação, por meio daexecução do método commit() do objeto Connection. con.commit(); Se alguma exceção for levantada durante a execução de qualqueroperação da transação, o programador pode usar o método rollback() paradesfazer as operações já realizadas após o último commit(). con.setAutoCommit(false); try { Statement stmt = con.createStatement(); stmt.executeUpdate(“UPDATE ...” ); stmt.executeUpdate(“UPDATE ...” ); con.commit(); stmt.close(); } catch(Exception e){con.rollback();} finally { try{ con.setAutoCommit(true);} catch(SQLException sqle) {System.out.prinln(sql.getMessage());} } Exemplo XX.X – Uso dos métodos commit() e rollback(). Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 338Níveis de isolamento Além da atomicidade outra propriedade desejável em uma transação é oisolamento. A propriedade de isolamento implica que uma transação não éafetada pelas operações realizadas por outras transações que estão sendorealizadas concorrentemente. O isolamento completo entre transações prejudica muito a execuçãoconcorrente de transações e pode ser desnecessário em determinados tipos deaplicações. Por isso os SGBDs permitem que o programador defina o nível deisolamento entre as transações. De acordo com o relaxamento do isolamentocertos problemas devido a interferência entre as transações podem ocorrer e oprogramador deve estar ciente disso. O número de níveis de isolamento, sua nomenclatura e característicasdepende do SGBD utilizado. Descreveremos os níveis de isolamento definidosno pacote java.sql. Para exemplificar os problemas que podem ocorrerdevido a interferência entre transações utilizaremos um banco de dados exemplocom a seguinte tabela: NumCC Saldo 10189-9 200,00 20645-7 300,00• Read uncommitted - É o nível menos restritivo. Pode ocorrer leituras de registros não committed (Dirty reads). Usados em onde não existe concorrência ou não existem alterações em registros ou quando essas alterações não são relevantes. Exemplo de problema: Uma transação deve transferir R$50,00 da conta 10189-9 para a conta 20645-7 e uma segunda transação deve somar R$70,00 à conta 10189-9. A figura abaixo mostra o estado inicial e o estado final desejado da tabela: Estado antes das Estado desejado após as transações transações NumCC Saldo NumCC Saldo 10189-9 200,00 10189-9 220,00 20645-7 300,00 20645-7 350,00 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 339 Cada transação é divida em operações de leitura e escrita. Suponha que o intercalamento das operações seja feito como mostrado abaixo: Transação 1 Transação 2 leitura do saldo 10189 Escrita do Saldo-50,00 leitura do saldo 10189 leitura do saldo 20645 (falha na transação, realizado rollback) Escrita do Saldo+70,00 Como a transação 1 falhou o valor lido pela transação 2 é um valor que não foi tornado permanente na tabela. Isto faz com que a transação 2 opere sobre um resultado desfeito. A tabela resultante, mostrada abaixo estará em um estado inconsistente. NumCC Saldo 10189-9 220,00 20645-7 300,00• Read committed - Somente registros committed podem ser lidos. Evita o problema de Dirty reads, no entanto duas leituras de um mesmo item em uma mesma transação podem possuir valores diferentes, uma vez que o valor pode ser mudado por outra transação entre duas leituras.• Repeatable Read - Somente registros committed podem ser lidos, além disso impede a alteração de um item lido pela transação. Evita o problema de Dirty reads e o problema do non-repeatable Read .• Serializable - É o nível mais restritivo. Impede Dirty reads e non-repeatable reads. Além disso impede o problema de phantom reads onde um conjunto de registros satisfazendo a condição WHERE é lido enquanto outra transação insere novos registros que satisfazem a condição. Para se definir o nível de isolamento na linguagem Java usa-se um objetoDatabaseMetaData que é obtido por meio do objeto getMetaData() doConnection. Primeiro é preciso saber se o SGBD suporta o nível de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 340isolamento desejado para depois definir o nível. O exemplo XX.X mostra umasequência típica comandos. DatabaseMetaData meta=con.getMetaData(); if(meta.supportsTransactionIsolationLevel( con.TRANSACTION_READ_COMMITTED)) { con.setTransactionIsolation( con.TRANSACTION_READ_COMMITTED); } else return; Exemplo XX.X – Exemplo do estabelecimento do nível de isolamento. A tabela abaixo mostra as constantes relacionadas com os níveis deisolamento da linguagem Java: Constante TRANSACTION_NONE TRANSACTION_READ_UNCOMMITTED TRANSACTION_READ_COMMITTED TRANSACTION_REPEATABLE_READ TRANSACTION_SERIALIZABLE Tabela XX.X – Tabela com as constantes dos níveis de isolamento.Prepared Statements Cada vez que se executa um comando SQL passado por meio de umaString. Este String deve ser analisado pelo processador de SQL do SGBD queirá, no caso da String estar sintaticamente correta, gerar um código binário queserá executado para atender à solicitação. Todo esse processo é caro e suaexecução repetidas vezes terá um impacto significativo sobre o desempenho daaplicação e do SGBD como um todo. Existem duas abordagens para tentar solucionar esse problema:Comandos preparados (prepared statements) e procedimentos armazenados(stored procedures). Discutiremos primeiramente os prepared statements. Prepared Statement é indicado nos casos onde um comando seráexecutado várias vezes em uma aplicação. Neste caso é melhor compilar ocomando uma única vez e toda vez que for necessário executá-lo basta enviar o Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 341comando compilado. Além disso, o comando pré-compilado pode serparametrizado, tornando-o mais genérico e, portanto, apto a expressar um maiornúmero de consultas. Para criar um Prepared Statement é necessário obter um objetoPreparedStatement por meio do método prepareStatement() doobjeto Connection, passando como argumento um comando SQL.PreparedStatement pstmt = con.prepareStatement( “INSERT INTO alunos(matricula,nome) VALUES(?, ? )”); O comando anterior insere uma nova linha na tabela alunos com osvalores das colunas matricula e nome passados por parâmetro. O caractere ‘?’representa o parâmetro. Este tipo de comando só possui valor tendo parâmetros,caso contrário teria pouca chance de ser reutilizado. Para executar o comandodevemos especificar o valor dos parâmetros e executar o comando, comomostrado no exemplo abaixo: pstmt.clearParameters(); pstmt.setInt(1,8); pstmt.setString(2,”Clara Maria”); pstmt.executeUpdate(); Antes de especificar os parâmetros é necessário limpar qualquer outroparâmetro previamente especificado. Para especificar os parâmetros sãoutilizados um conjunto de métodos com o nome no formato setXXX(), ondeXXX é o tipo sendo passado. O primeiro parâmetro do método setXXX() é oíndice da ocorrência do caractere ‘?’ que será substituído pelo valor. O segundoparâmetro é o valor que será transmitido.Procedimentos Armazenados (Stored Procedures) A maioria dos SGBDs possuem algum tipo de linguagem deprogramação interna, como por exemplo a PL/SQL do Oracle ou mesmo Java eC/C++. Estas linguagens permitem que os desenvolvedores insiram parte docódigo da aplicação diretamente no banco de dados e invoquem este código apartir da aplicação. Esta abordagem possui as seguintes vantagens: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 342 •Reuso de código – o código precisa ser escrito apenas uma vez e usado em várias aplicações, comunicando com várias linguagens. •Independencia entre a aplicação e o esquema do BD – se o esquema mudar, provavelmente apenas os procedimentos armazenados. •Desempenho – os procedimentos são previamente compilados, eliminando esta etapa. •Segurança – as aplicações possuem privilégio apenas para execução de procedimentos armazenados, evitando assim acessos não autorizados. A sintaxe dos procedimentos armazenados depende do SGBD emquestão. Utilizaremos um exemplo em PL/SQL. No exemplo abaixo oprocedimento retorna o nome do aluno a partir de sua matricula.CREATE OR REPLACE PROCEDURE sp_obtem_nome (id IN INTEGER, Nome_aluno out VARCHAR2)ISBEGIN SELECT nome INTO Nome_aluno FROM alunos WHERE matricula = id;END;/ Para invocar o procedimento anterior de dentro de uma aplicação Java énecessário obter um objeto CallableStatement por meio do métodoprepareCall() do objeto Connection, passando como argumento umcomando SQL.CallableStatement cstmt = con.prepareCall("{ CALL sp_obtem_nome(?,?)}");cstmt.registerOutParameter(2, Types.VARCHAR);cstmt.setInt(1, 3);cstmt.execute();System.out.prinln(“O nome do aluno numero 3 :” +cstmt.getString(2); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 343Agenda Eletrônica versão JDBCPessoaimport java.io.*;public class pessoa implements Serializable{ String Nome; String Tel; // Construtor public pessoa(String n, String t) {Nome = n; Tel = t;} public String getNome(){return Nome;} public String getTel(){return Tel;}}agendaimport java.util.*;import java.io.*;import java.sql.*;import java.net.URL;public class agenda{ Connection con=null; // Construtor public agenda()throws Exception { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); con=DriverManager.getConnection("jdbc:odbc:agenda"); }/** CloseAgenda */ public void CloseAgenda() { if (con != null) try{con.close();}catch(Exception e){}; } /** inserir Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 344 */ public void inserir(pessoa p) { if (con == null) return; try { Statement stmt = con.createStatement(); stmt.executeUpdate("INSERT INTO pessoas(nome,telefone)"+ "values("+p.getNome()+","+p.getTel()+")"); stmt.close(); }catch(Exception e) {System.err.println(e);} } /** Consultar */ /** listar */ public Enumeration getLista() { if (con == null) return null; Vector pessoas = new Vector(); try { Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery ("SELECT Nome, Telefone FROM pessoas"); while(rs.next()) pessoas.addElement(newpessoa(rs.getString("Nome"), rs.getString("Telefone"))); stmt.close(); } catch(Exception e) {System.out.println(e.getMessage()); e.printStackTrace();} return pessoas.elements(); }}Servidorimport java.util.*;import java.net.*;import java.io.*; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 345/**CLASS server*/class server{ public static void main(String args[]) { String oHost="localhost"; ServerSocket ssocket=null; serversec oServersec; int pt = 4444; agenda ag; try {ag = new agenda();} catch(Exception e){System.err.println(e); return;}; if (args.length > 0) pt = Integer.parseInt(args[0]); try { ssocket = new ServerSocket(pt); pt = ssocket.getLocalPort(); oHost =ssocket.getInetAddress().getHostName().trim(); } catch(Exception e) {System.err.println(e);System.exit(1);} System.out.println("Porta:"+pt+" Host: "+oHost); while(true) { try { Socket clisocket = ssocket.accept(); oServersec = new serversec(ag,clisocket); oServersec.start(); } catch(Exception e) {System.err.println(e);} } }}/** CLASS serversec*/class serversec extends Thread{ Socket oSocket; BufferedWriter soutput; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 346 BufferedReader cinput; agenda ag; public serversec(agenda ag, Socket aoSocket) { this.ag = ag; oSocket = aoSocket; } public void run() { try { soutput = new BufferedWriter(newOutputStreamWriter(oSocket.getOutputStream())); cinput = new BufferedReader(newInputStreamReader(oSocket.getInputStream())); String losLinha = cinput.readLine(); switch(losLinha.charAt(0)) { case i: String Nome = cinput.readLine(); String Tel = cinput.readLine(); ag.inserir(new pessoa(Nome,Tel)); soutput.write("OKn#n"); break; case l: pessoa p; for (Enumeration e = ag.getLista();e.hasMoreElements() ;) { p = (pessoa) e.nextElement();soutput.write(p.getNome()+"n"+p.getTel()+"n"); } soutput.write("#n"); break; } soutput.flush(); Thread.yield(); soutput.close(); oSocket.close(); } catch(Exception e) {System.err.println(e);} }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 347Appletimport java.awt.*;import java.applet.*;import java.util.*;import java.net.*;import java.io.*;public class agendaapplet extends Applet{ int port = 4444; TextField txtNome = new TextField(); TextField txtTel = new TextField(); Label label1 = new Label(); Label label2 = new Label(); Button btIns = new Button(); Button btList = new Button(); Button btCons = new Button(); Button btSair = new Button(); TextArea Saida = new TextArea(); Button btLimpar = new Button(); public void init() { setLayout(null); setSize(376,224); add(txtNome); txtNome.setBounds(108,48,232,24); add(txtTel); txtTel.setBounds(108,84,232,24); label1.setText("Nome"); add(label1); label1.setBounds(24,48,60,26); label2.setText("Telefone"); add(label2); label2.setBounds(24,84,60,26); btIns.setActionCommand("button"); btIns.setLabel("Inserir"); add(btIns); btIns.setBackground(java.awt.Color.lightGray); btIns.setBounds(12,12,49,23); btList.setActionCommand("button"); btList.setLabel("Listar"); add(btList); btList.setBackground(java.awt.Color.lightGray); btList.setBounds(149,12,60,23); btCons.setActionCommand("button"); btCons.setLabel("Consultar"); add(btCons); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 348 btCons.setBackground(java.awt.Color.lightGray); btCons.setBounds(75,12,60,23); btSair.setActionCommand("button"); btSair.setLabel("Sair"); add(btSair); btSair.setBackground(java.awt.Color.lightGray); btSair.setBounds(297,12,60,23); add(Saida); Saida.setBounds(24,120,338,90); btLimpar.setActionCommand("button"); btLimpar.setLabel("Limpar"); add(btLimpar); btLimpar.setBackground(java.awt.Color.lightGray); btLimpar.setBounds(223,12,60,23); SymMouse aSymMouse = new SymMouse(); btSair.addMouseListener(aSymMouse); btIns.addMouseListener(aSymMouse); btList.addMouseListener(aSymMouse); btLimpar.addMouseListener(aSymMouse); } public void transmit(int port,String mensagem) { BufferedWriter soutput; BufferedReader cinput; Socket clisoc=null; try { if (clisoc != null) clisoc.close(); clisoc = newSocket(InetAddress.getByName(getCodeBase().getHost()),port); soutput = new BufferedWriter (new OutputStreamWriter(clisoc.getOutputStream())); cinput = new BufferedReader(new InputStreamReader(clisoc.getInputStream())); soutput.write(mensagem+"n"); soutput.flush(); String losRet = cinput.readLine(); while (losRet.charAt(0)!=#) { Saida.setText(Saida.getText()+losRet+"n"); losRet = cinput.readLine(); } Thread.sleep(500); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 349 soutput.close(); clisoc.close(); } catch(Exception e) {System.err.println(e);} } class SymMouse extends java.awt.event.MouseAdapter { public void mouseClicked(java.awt.event.MouseEvent event) { Object object = event.getSource(); if (object == btSair) btSair_MouseClick(event); else if (object == btIns) btIns_MouseClick(event); else if (object == btList) btList_MouseClick(event); else if (object == btLimpar)btLimpar_MouseClick(event); } } void btSair_MouseClick(java.awt.event.MouseEvent event) { System.exit(0); } void btIns_MouseClick(java.awt.event.MouseEvent event) { String nome = txtNome.getText(); String tel = txtTel.getText(); if (nome.length()>0 && tel.length()>0) transmit(port,"in"+nome+"n"+tel+"n"); } void btList_MouseClick(java.awt.event.MouseEvent event) { transmit(port,"ln"); } void btLimpar_MouseClick(java.awt.event.MouseEvent event) { Saida.setText(""); }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 350Capítulo XVI Servlets e JSP Servlets e JSP são duas tecnologias desenvolvidas pela Sun paradesenvolvimento de aplicações na Web a partir de componentes Java queexecutem no lado servidor. Essas duas tecnologias fazem parte da plataformaJ2EE (Java 2 Platform Enterprise Edition) que fornece um conjunto detecnologias para o desenvolvimento de soluções escaláveis e robustas para aWeb. Neste livro abordaremos apenas as tecnologias Servlets e JSP, sendo osuficiente para o desenvolvimento de sites dinâmicos de razoável complexidade.Se a aplicação exigir uma grande robustez e escalabilidade o leitor deveconsiderar o uso em conjunto de outras tecnologias da plataforma J2EE.Servlets Servlets são classes Java que são instanciadas e executadas emassociação com servidores Web, atendendo requisições realizadas por meio doprotocolo HTTP. Ao serem acionados, os objetos Servlets podem enviar aresposta na forma de uma página HTML ou qualquer outro conteúdo MIME. Naverdade os Servlets podem trabalhar com vários tipos de servidores e não sóservidores Web, uma vez que a API dos Servlets não assume nada a respeito doambiente do servidor, sendo independentes de protocolos e plataformas. Emoutras palavras Servlets é uma API para construção de componentes do ladoservidor com o objetivo de fornecer um padrão para comunicação entre clientese servidores. Os Servlets são tipicamente usados no desenvolvimento de sitesdinâmicos. Sites dinâmicos são sites onde algumas de suas páginas sãoconstruídas no momento do atendimento de uma requisição HTTP. Assim épossível criar páginas com conteúdo variável, de acordo com o usuário, tempo,ou informações armazenadas em um banco de dados. Servlets não possuem interface gráfica e suas instâncias são executadasdentro de um ambiente Java denominado de Container. O container gerencia asinstâncias dos Servlets e provê os serviços de rede necessários para asrequisições e respostas. O container atua em associação com servidores Webrecebendo as requisições reencaminhada por eles. Tipicamente existe apenasuma instância de cada Servlet, no entanto, o container pode criar vários threadsde modo a permitir que uma única instância Servlet atenda mais de uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 351requisição simultaneamente A figura XX fornece uma visão do relacionamentodestes componentes. Máquina Virtual Java Requisições Container Servidor Web Instâncias de Servlets RespostasFigura XVI-1. Relacionamento entre Servlets, container e servidor Web Servlets provêem uma solução interessante para o relacionamentocliente/servidor na Internet, tornando-se uma alternativa para a implantação desistemas para a Web. Antes de entrarmos em detalhes na construção de Servlets,compararemos esta solução com outras duas soluções possíveis para implantaçãode aplicações na Internet.Applets X ServletsApesar de ser uma solução robusta existem problemas no uso de Applets paravalidação de dados e envio para o servidor. O programador precisa contar com ofato do usuário possuir um navegador com suporte a Java e na versãoapropriada. Você não pode contar com isso na Internet, principalmente se vocêdeseja estender a um grande número de usuário o acesso às suas páginas. Em setratando de Servlets, no lado do cliente pode existir apenas páginas HTML,evitando restrições de acesso às páginas. Em resumo, o uso de Applets não érecomendado para ambientes com múltiplos navegadores ou quando a semânticada aplicação possa ser expressa por componentes HTML. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 352CGI X Servlets Como visto no Capítulo IX, scripts CGI (Common Gateway Interface),acionam programas no servidor. O uso de CGI sobrecarrega o servidor uma vezcada requisição de serviço acarreta a execução de um programa executável (quepode ser escrito em com qualquer linguagem que suporte o padrão CGI) noservidor, além disso, todo o processamento é realizado pelo CGI no servidor. Sehouver algum erro na entrada de dados o CGI tem que produzir uma páginaHTML explicando o problema. Já os Servlets são carregados apenas uma vez ecomo são executados de forma multi-thread podem atender mais de uma mesmasolicitação por simultaneamente. Versões posteriores de CGI contornam estetipo de problema, mas permanecem outros como a falta de portabilidade e ainsegurança na execução de código escrito em uma linguagem como C/C++.A API Servlet A API Servlet é composta por um conjunto de interfaces e Classes. Ocomponente mais básico da API é interface Servlet. Ela define ocomportamento básico de um Servlet. A figura XX.XX mostra a interfaceServlet. public interface Servlet { public void init(ServletConfig config) throws ServletException; public ServletConfig getServletConfig(); public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException; public String getServletInfo(); public void destroy(); } Figura XV.XX. Interface Servlet. O método service() é responsável pelo tratamento de todas dasrequisições dos clientes. Já os métodos init() e destroy() são chamadosquando o Servlet é carregado e descarregado do container, respectivamente. Ométodo getServletConfig() retorna um objeto ServletConfig quecontém os parâmetros de inicialização do Servlet. O método Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 353getServletInfo() retorna um String contendo informações sobre oServlet, como versão e autor. Tendo como base a interface Servlet o restante da API Servlet seorganiza hierarquicamente como mostra a figura XV.XX. Servlet GenericServlet HttpServlet Figura XV.XX. Hierarquia de classes da API Servlet. A classe GenericServlet implementa um servidor genérico egeralmente não é usada. A classe HttpServlet é a mais utilizada e foiespecialmente projetada para lidar com o protocolo HTTP. A figura XX.XXmostra a definição da classe interface HttpServlet.HttpServletpublic abstract class HttpServletextends GenericServletimplements java.io.Serializable Figura XV.XX. Definição da classe HttpServlet. Note que a classe HttpServlet é uma classe abstrata. Para criar umServlet que atenda requisições HTTP o programador deve criar uma classederivada da HttpServlet e sobrescrever pelo menos um dos métodosabaixo: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 354 doGet Trata as requisições HTTP GET. doPost Trata as requisições HTTP POST. doPut Trata as requisições HTTP PUT. doDelete Trata as requisições HTTP DELETE. Tabela XV.XX. Métodos da classe HttpServlet que devem sersobrescritos para tratar requisições HTTP. Todos esses métodos são invocados pelo servidor por meio do métodoservice(). O método doGet() trata as requisições GET. Este tipo derequisição pode ser enviada várias vezes, permitindo que seja colocada em umbookmark. O método doPost() trata as requisições POST que permitem que ocliente envie dados de tamanho ilimitado para o servidor Web uma única vez,sendo útil para enviar informações tais como o número do cartão de crédito. Ométodo doPut() trata as requisições PUT. Este tipo de requisição permite queo cliente envie um arquivo para o servidor à semelhança de como é feito viaFTP. O método doPut() trata as requisições DELETE, permitindo que ocliente remova um documento ou uma página do servidor. O métodoservice(), que recebe todas as requisições, em geral não é sobrescrito, sendosua tarefa direcionar a requisição para o método adequado.Exemplo de Servlet Para entendermos o que é um Servlet nada melhor que um exemplosimples. O exemplo XV.XX gera uma página HTML em resposta a umarequisição GET. A página HTML gerada contém simplesmente a frase Olamundo!!!. Este é um Servlet bem simples que ilustra as funcionalidades básicasda classe.import javax.servlet.*;import javax.servlet.http.*;public class Ola extends HttpServlet{ public String getServletInfo() { return "Ola versão 0.1";} public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 355 res.setContentType("text/html"); java.io.PrintWriter out = res.getWriter(); out.println("<html>"); out.println("<head>"); out.println("<title>Servlet</title>"); out.println("</head>"); out.println("<body>Ola mundo!!!"); out.println("</body>"); out.println("</html>"); out.close(); }} Exemplo XV.XX. Servlet Ola. O método doGet() recebe dois objetos: um da classeHttpServletRequest e outro da classe HttpServletResponse. OHttpServletRequest é responsável pela comunicação do cliente para oservidor e o HttpServletResponse é responsável pela comunicação doservidor para o cliente. Sendo o exemplo XV.XX apenas um exemplo simplesele ignora o que foi enviado pelo cliente, tratando apenas de enviar uma páginaHTML como resposta. Para isso é utilizado o objeto da classeHttpServletResponse. Primeiramente é usado o métodosetContentType() para definir o tipo do conteúdo a ser enviado ao cliente.Esse método deve ser usado apenas uma vez e antes de se obter um objeto dotipo PrintWriter ou ServletOutputStream para a resposta. Após issoé usado o método getWriter() para se obter um objeto do tipoPrintWriter que é usado para escrever a resposta. Neste caso os dados daresposta são baseados em caracteres. Se o programador desejar enviar a respostaem bytes deve usar o método getOutputStream() para obter um objetoOutputStream. A partir de então o programa passa usar o objetoPrintWriter para enviar a página HTML.Compilando o Servlet A API Servlet ainda não foi incorporado ao SDK, portanto, para compilarum Servlet é preciso adicionar a API Servlet ao pacote SDK. Existem váriasformas de se fazer isso. A Sun fornece a especificação da API e diversosprodutores de software executam a implementação. Atualmente, a especificação Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 356da API Servlet está na versão 2.XX. Uma das implementações da API que podeser baixada gratuitamente pela Internet é a fornecida pelo projeto Jakarta(http://jakarta.apache.org) denominada de Tomcat. Aimplementação da API Servlet feita pelo projeto Jakarta é a implementação dereferência indicada pela Sun. Ou seja, é a implementação que os outrosfabricantes devem seguir para garantir a conformidade com a especificação daAPI. No entanto, uma vez que o Tomcat é a implementação mais atualizada daAPI, é também a menos testada e, por consequência, pode não ser a mais estávele com melhor desempenho.Instalando o Tomcat Assim como para se executar um Applet era preciso de um navegadorWeb com Java habilitado no caso de Servlets é preciso de servidor Web queexecute Java ou que passe as requisições feitas a Servlets para programas queexecutem os Servlets. O Tomcat é tanto a implementação da API Servlet como aimplementação de um container, que pode trabalhar em associação com umservidor Web como o Apache ou o IIS, ou pode também trabalhar isoladamente,desempenhando também o papel de um servidor Web. Nos exemplos aquimostrados usaremos o Tomcat isoladamente. Em um ambiente de produção estaconfiguração não é a mais adequada, uma vez que os servidores Web possuemum melhor desempenho no despacho de páginas estáticas. As instruções paraconfigurar o Tomcat para trabalhar em conjunto com um servidor Web podemser encontradas junto às instruções gerais do programa. As figuras XV.XXilustram essas duas situações. Servidor Web Internet Servlet habilitado Figura XV.XX. Servidor Web habilitado para Servlet. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 357 Internet Servidor Web Servlet Container Figura XV.XX. Servidor Web reencaminhando as requisições para o Servlet container. A versão estável do Tomcat é a 3.2.3.XX é após baixá-la do site doprojeto Jakarta o usuário deve descomprimir o arquivo. Por exemplo, noambiente Windows o usuário pode descomprimir o arquivo na raiz do disco C:,o que gerará a seguinte árvore de diretórios: C: jakarta-tomcat-3.2.3 | |______bin |______conf |______doc |______lib |______logs |______src |______webapps No diretório bin encontram-se os programas execução e interrupção docontainer Tomcat. No diretório conf encontram-se os arquivos de configuração.No diretório doc encontram-se os arquivos de documentação. No diretório libencontram-se os bytecodes do container e da implementação da API. Nodiretório logs são registradas as mensagens da geradas durante a execução dosistema. No diretório src encontram-se os arquivos fontes do container e daimplementação da API de configuração. Finalmente, No diretório webappsencontram-se as páginas e códigos das aplicações dos usuários. No ambiente MS-Windows aconselhamos usar um nome dentro doformato 8.3 (oito caracteres para o nome e três para o tipo). Assim o diretóriojakarta-tomcat-3.2.3 poderia ser mudado para simplesmente tomcat. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 358 Antes de executar o Tomcat é necessário definir duas variáveis deambiente. Por exemplo, supondo que no MS-Windows o Tomcat foi instalado nodiretório c:tomcat e que o SDK está instalado no diretório c:jdk1.3então as seguintes variáveis de ambiente devem ser definidas: set JAVA_HOME=C:jdk1.3 set TOMCAT_HOME=C:tomcat Agora é possível executar o Tomcat por meio do seguinte comando: C:tomcatbinstartup.bat Para interromper a execução servidor basta executar o arquivo c:tomcatbinshutdown.bat Falta de espaço para variáveis de ambiente Caso ao iniciar o servidor apareça a mensagem “sem espaço de ambiente”clique com o botão direito do mouse no arquivo .bat e edite as propriedades definindo oambiente inicial com 4096. Feche o arquivo é execute novamente. Ao entrar em execução o servidor lê as configurações constantes noarquivo server.xml e, por default, se anexa à porta 8080. Para verificar se oprograma está funcionando corretamente execute um navegador como oNetscape ou o Internet Explorer e digite a seguinte URL:http://127.0.0.1:8080/index.html A figura XX.XX mostra a tela principal do Tomcat. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 359 Figura XV.XX. Tela inicial do Tomcat. A número porta default para recebimento das requisições HTTP pode seralterada por meio da edição do arquivo server.xml do diretório conf comomostrado abaixo:<Connector className="org.apache.tomcat.service.PoolTcpConnector"> <Parameter name="handler"value="org.apache.tomcat.service.http.HttpConnectionHandler"/> <Parameter name="port" value="Número da porta"/></Connector> No entanto, caso o Tomcat esteja operando em conjunto com umservidor, o ideal é que o Tomcat não responda requisições diretamente.Preparando para executar o ServletCompilando o Servlet Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 360 Antes de executar o Servlet e preciso compilá-lo. Para compilá-lo épreciso que as classes que implementam a API Servlet estejam no classpath.Para isso é preciso definir a variável de ambiente. No ambiente MS-Windowsseria set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%libservlet.jare no ambiente Unix seria CLASSPATH=${CLASSPATH}:${TOMCAT_HOME}/lib/servlet.jar Alternativamente, é possível indicar o classpath na própria linha deexecução do compilador Java. Por exemplo, No ambiente MS-Windows ficariana seguinte forma:javac -classpath "%CLASSPATH%;c:tomcatlibservlet.jar Ola.javaCriando uma aplicação no Tomcat Agora é preciso definir onde deve ser colocado o arquivo compilado.Para isso é preciso criar uma aplicação no Tomcat ou usar uma das aplicações jáexistentes. Vamos aprender como criar uma aplicação no Tomcat. Para isso épreciso cria a seguinte estrutura de diretórios abaixo do diretório webapps doTomcat: webapps |_____ Nome aplicação |_____ Web-inf |_____classes Diretório de Aplicações Na verdade é possível definir outro diretório para colocar as aplicações do Tomcat. Paraindicar outro diretório é preciso editar o arquivo server.xml e indicar o diretório por meio dadiretiva home do tag ContextManager. O diretório de uma aplicação é denominado de contexto da aplicação. Épreciso também editar o arquivo server.xml do diretório conf, incluindo aslinhas: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 361<Context path="/nome aplicação" docBase="webapps/ nome aplicação" debug="0” reloadable="true" ></Context> Finalmente, é preciso criar (ou copiar de outra aplicação) um arquivoweb.xml no diretório Web-inf com o seguinte conteúdo:<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd"><web-app></web-app> Copie então o arquivo compilado Ola.class para o subdiretório/webapps/nome aplicação/Web-inf/classes do Tomcat.Executando o ServletInvocando diretamente pelo Navegador Podemos executar um Servlet diretamente digitando a URL do Servlet nonavegador. A URL em geral possui o seguinte formato: http://máquina:porta/nome aplicação/servlet/nome servlet A palavra servlet que aparece na URL não indica um subdiretório noservidor. Ela indica que esta é uma requisição para um Servlet. Por exemplo,suponha que o nome da aplicação criada no Tomcat seja teste. Então a URLpara a invocação do Servlet do exemplo XX.XX teria a seguinte forma: http://localhost:8080/teste/servlet/Ola A URL para a chamada do Servlet pode ser alterada de modo a ocultarqualquer referência à diretórios ou a tecnologias de implementação. No caso doTomcat essa configuração é no arquivo web.xml do diretório Web-inf daaplicação. Por exemplo, para eliminar a palavra servlet da URL poderíamos Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 362inserir as seguintes linhas no arquivo web.xml entre os tags <web-app> e</web-app>: <servlet> <servlet-name> Ola </servlet-name> <servlet-class> Ola </servlet-class> </servlet> <servlet-mapping> <servlet-name> Ola </servlet-name> <url-pattern> /Ola </url-pattern> </servlet-mapping>Invocando em uma página HTML No caso de uma página HTML basta colocar a URL na forma de link.Por exemplo,<a href="http://localhost:8080/teste/servlet/Ola>Servlet Ola</a> Neste caso o Servlet Ola será solicitado quando o link associado ao texto“Servlet Ola” for acionado.Diferenças entre as requisições GET e POST Os dois métodos mais comuns, definidos pelo protocolo HTTP, de seenviar uma requisições a um servidor Web são os métodos POST e GET. Apesarde aparentemente cumprirem a mesma função, existem diferenças importantesentre estes dois métodos. O método GET tem por objetivo enviar uma requisiçãopor um recurso. As informações necessárias para a obtenção do recurso (comoinformações digitadas em formulários HTML) são adicionadas à URL e, porconsequência, não são permitidos caracteres inválidos na formação de URLs, Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 363como por espaços em branco e caracteres especiais. Já na requisição POST osdados são enviados no corpo da mensagem. O método GET possui a vantagem de ser idempotente, ou seja, osservidores Web podem assumir que a requisição pode ser repetida, sendopossível adicionar à URL ao bookmark. Isto é muito útil quando o usuário desejamanter a URL resultante de uma pesquisa. Como desvantagem as informaçõespassadas via GET não podem ser muito longas, um vez o número de caracterespermitidos é por volta de 2K. Já as requisições POST a princípio podem ter tamanho ilimitado. Noentanto, elas não são idempotente, o que as tornam ideais para formulários ondeos usuários precisam digitar informações confidenciais, como número de cartãode crédito. Desta forma o usuário é obrigado a digitar a informação toda vez quefor enviar a requisição, não sendo possível registrar a requisição em umbookmark.Concorrência Uma vez carregado o Servlet não é mais descarregado, a não ser que oservidor Web tenha sua execução interrompida. De modo geral, cada requisiçãoque deve ser direcionada a determinada instância de Servlet é tratada por umthread sobre a instância de Servlet. Isto significa que se existirem duasrequisições simultâneas que devem ser direcionadas para um mesmo objeto ocontainer criará dois threads sobre o mesmo objeto Servlet para tratar asrequisições. A figura XX.XX ilustra esta situação. usuário thread1 1 Servlet1 usuário thread2 2 thread1 Servlet2 usuário 3 Figura XV.XX. Relacionamento entre as instâncias dos Servlets e os threads. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 364 Em conseqüência disto temos o benefícios de uma sobrecarga paraservidor, uma vez que a criação de threads é menos onerosa do que a criação deprocessos, e uma aparente melhora no tempo de resposta. Por outro lado, o fato dos Servlets operarem em modo multi-threadaumenta a complexidade das aplicações e cuidados especiais, como visto nocapítulo sobre concorrência, devem tomados para evitar comportamentoserráticos. Por exemplo, suponha um Servlet que receba um conjunto de númerosinteiros e retorne uma página contendo a soma dos números. A exemplo XX.XXmostra o código do Servlet. O leitor pode imaginar um código muito maiseficiente para computar a soma de números, mas o objetivo do código doexemplo é ilustrar o problema da concorrência em Servlets. O exemplo contémtambém um trecho de código para recebimento de valores de formulários, o queserá discutido mais adiante.import java.util.*;import javax.servlet.*;import javax.servlet.http.*;public class Soma extends HttpServlet { Vector v = new Vector(5); protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, java.io.IOException { v.clear(); Enumeration e = req.getParameterNames(); while (e.hasMoreElements()) { String name = (String)e.nextElement(); String value = req.getParameter(name); if (value != null) v.add(value); } res.setContentType("text/html"); java.io.PrintWriter out = res.getWriter(); out.println("<html>"); out.println("<head><title>Servlet</title></head>"); out.println("<body>"); out.println("<h1> A soma e"); int soma =0; for(int i =0; i< v.size() ; i++) { soma += Integer.parseInt((String)v.get(i)); } out.println(soma); out.println("<h1>"); out.println("</body>"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 365 out.println("</html>"); out.close(); }} Exemplo XX.XX- Servlet com problemas de concorrência. Note que o Servlet utiliza uma variável de instância para referenciar oVector que armazena os valores. Se não forem usadas primitivas desincronização (como no código do exemplo) e duas requisições simultâneaschegarem ao Servlet o resultado pode ser inconsistente, uma vez que o Vectorpoderá conter parte dos valores de uma requisição e parte dos valores de outrarequisição. Neste caso, para corrigir esse problema basta declarar a variávelcomo local ao método doPost() ou usar primitivas de sincronização.Obtendo Informações sobre a Requisição O objeto HttpServletRequest passado para o Servlet contémvárias informações importantes relacionadas com a requisição, como porexemplo o método empregado (POST ou GET), o protocolo utilizado, oendereço remoto, informações contidas no cabeçalho e muitas outras. O Servletdo exemplo XX.XX retorna uma página contendo informações sobre arequisição e sobre o cabeçalho da requisição.import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;public class RequestInfo extends HttpServlet{ public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { res.setContentType("text/html"); PrintWriter out = res.getWriter(); out.println("<html><head>"); out.println("<title>Exemplo sobre Requisicao de Info </title>"); out.println("</head><body>"); out.println("<h3> Exemplo sobre Requisicao de Info </h3>"); out.println("Metodo: " + req.getMethod()+”<br>”); out.println("Request URI: " + req.getRequestURI()+”<br>”); out.println("Protocolo: " + req.getProtocol()+”<br>”); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 366 out.println("PathInfo: " + req.getPathInfo()+”<br>”); out.println("Endereco remoto: " + req.getRemoteAddr()+”<br><br>”); Enumeration e = req.getHeaderNames(); while (e.hasMoreElements()) { String name = (String)e.nextElement(); String value = req.getHeader(name); out.println(name + " = " + value+"<br>"); } out.println("</body></html>"); } public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { doGet(req, res); }} Exemplo XX.XX- Servlet que retorna as informações sobre a requisição. Note que o método doPost() chama o método doGet(), de modoque o Servlet pode receber os dois tipos de requisição. A figura XX.XX mostra oresultado de uma execução do Servlet do exemplo XX.XX.Exemplo sobre Requisicao de InfoMetodo: GETRequest URI: /servlet/RequestInfoProtocolo: HTTP/1.0PathInfo: nullEndereco remoto: 127.0.0.1Connection = Keep-AliveUser-Agent = Mozilla/4.7 [en] (Win95; I)Pragma = no-cacheHost = localhost:8080Accept = image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*Accept-Encoding = gzipAccept-Language = enAccept-Charset = iso-8859-1,*,utf-8Figura XX.XX- Saída da execução do Servlet que exibe as informações sobre a requisição. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 367Lidando com Formulários Ser capaz de lidar com as informações contidas em formulários HTML éfundamental para qualquer tecnologia de desenvolvimento de aplicações paraWeb. É por meio de formulários que os usuários fornecem dados, preenchempedidos de compra e (ainda mais importante) digitam o número do cartão decrédito. As informações digitadas no formulário chegam até o Servlet por meiodo objeto HttpServletRequest e são recuperadas por meio do métodogetParameter() deste objeto. Todo item de formulário HTML possui umnome e esse nome é passado como argumento para o métodogetParameter() que retorna na forma de String o valor do item deformulário. O Servlet do exemplo XX.XX exibe o valor de dois itens de formuláriosdo tipo text. Um denominado nome e o outro denominado de sobrenome.Em seguida o Servlet cria um formulário contendo os mesmos itens deformulário. Note que um formulário é criado por meio do tag <form>. Comoparâmetros opcionais deste tag temos método da requisição (method), é a URLpara onde será submetida a requisição (action). No caso do exemplo, ométodo adotado é o POST e a requisição será submetida ao próprio ServletForm.import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;public class Form extends HttpServlet{ public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { res.setContentType("text/html"); PrintWriter out = res.getWriter(); out.println("<html>"); out.println("<head><title>Trata formulario</title></head>"); out.println("<body bgcolor="white">"); out.println("<h3>Trata formulario</h3>"); String nome = req.getParameter("nome"); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 368 String sobreNome = req.getParameter("sobrenome"); if (nome != null || sobreNome != null) { out.println("Nome = " + nome + "<br>"); out.println("Sobrenome = " + sobreNome); } out.println("<P>"); out.print("<form action="Form" method=POST>"); out.println("Nome : <input type=text size=20 name=nome><br>"); out.println("Sobrenome: <input type=text size=20 name=sobrenome><br>"); out.println("<input type=submit>"); out.println("</form>"); out.println("</body></html>"); } public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { doGet(req, res); }} Exemplo XX.XX- Servlet para lidar com um formulário simples.Lidando com Cookies Um cookie nada mais é que um bloco de informação que é enviado doservidor para o navegador no cabeçalho página. A partir de então, dependendodo tempo de validade do cookie, o navegador reenvia essa informação para oservidor a cada nova requisição. Dependo do caso o cookie é tambémarmazenado no disco da máquina cliente e quando o site é novamente visitado ocookie enviado novamente para o servidor, fornecendo a informação desejada. Os cookies foram a solução adotada pelos desenvolvedores do Netscapepara implementar a identificação de clientes sobre um protocolo HTTP que nãoé orientado à conexão. Esta solução, apesar das controvérsias sobre apossibilidade de quebra de privacidade, passou ser amplamente adotada e hojeos cookies são parte integrante do padrão Internet, normalizados pela normaRFC 2109. A necessidade da identificação do cliente de onde partiu a requisição e omonitoramento de sua interação com o site (denominada de sessão) é importantepara o desenvolvimento de sistemas para a Web pelas seguintes razões: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 369 • É necessário associar os itens selecionados para compra com o usuário que deseja adquiri-los. Na maioria da vezes a seleção dos itens e compra é feita por meio da navegação de várias páginas do site e a todo instante é necessário distinguir os usuários que estão realizando as requisições. • É necessário acompanhar as interação do usuário com o site para observar seu comportamento e, a partir dessas informações, realizar adaptações no site para atrair um maior número de usuários ou realizar campanhas de marketing. • É necessário saber que usuário está acessando o site para, de acordo com o seu perfil, fornecer uma visualização e um conjunto de funcionalidades adequadas às suas preferências. Todas essas necessidades não podem ser atendidas com o uso básico doprotocolo HTTP, uma vez que ele não é orientado à sessão ou conexão. Com oscookies é possível contornar essa deficiência, uma vez que as informações quesão neles armazenadas podem ser usadas para identificar os clientes. Existemoutras formas de contornar a deficiência do protocolo de HTTP, como acodificação de URL e o uso de campos escondidos nas páginas HTML, mas ouso de cookies é a técnica mais utiliza, por ser mais simples e padronizada. Noentanto, o usuário pode impedir que o navegador aceite cookies, o que torna oato de navegar pela Web muito desagradável. Neste caso, é necessário utilizar asoutras técnicas para controle de sessão. A API Servlet permite a manipulação explicita de cookies. Para controlede sessão o programador pode manipular diretamente os cookies, ou usar umaabstração de nível mais alto, implementada por meio do objeto HttpSession.Se o cliente não permitir o uso de cookies a API Servlet fornece métodos para acodificação de URL. O exemplo XX.XX mostra o uso de cookies paraarmazenar as informações digitadas em um formulário.import java.io.*;import javax.servlet.*;import javax.servlet.http.*;public class CookieTeste extends HttpServlet{ public void doGet(HttpServletRequest req, HttpServletResponseres) throws IOException, ServletException { Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 370 res.setContentType("text/html"); PrintWriter out = res.getWriter(); out.println("<html>"); out.println("<body bgcolor="white">"); out.println("<head><title>Teste de Cookies</title></head>"); out.println("<body>"); out.println("<h3>Teste de Cookies</h3>"); Cookie[] cookies = req.getCookies(); if (cookies.length > 0) { for (int i = 0; i < cookies.length; i++) { Cookie cookie = cookies[i]; out.print("Cookie Nome: " + cookie.getName() +"<br>"); out.println(" Cookie Valor: " + cookie.getValue() +"<br><br>"); } } String cName = req.getParameter("cookienome"); String cValor = req.getParameter("cookievalor"); if (cName != null && cValor != null) { Cookie cookie = new Cookie(cName ,cValor); res.addCookie(cookie); out.println("<P>"); out.println("<br>"); out.print("Nome : "+cName +"<br>"); out.print("Valor : "+cValor); } out.println("<P>"); out.print("<form action="CookieTeste" method=POST>"); out.println("Nome : <input type=text length=20 name=cookienome><br>"); out.println("Valor : <input type=text length=20 name=cookievalor><br>"); out.println("<input type=submit></form>"); out.println("</body>"); out.println("</html>"); } public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { doGet(req, res); }} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 371 Exemplo XX.XX- Servlet para lidar com Cookies. Para se criar um cookie é necessário criar um objeto Cookie, passandopara o construtor um nome e um valor, sendo ambos instâncias de String. Ocookie é enviado para o navegador por meio do método addCookie() doobjeto HttpServletResponse. Um vez que os cookies são enviados nocabeçalho da página, o método addCookie() deve ser chamado antes doenvio de qualquer conteúdo para o navegador. Para recuperar os cookiesenviados pelo navegador usa-se o método getCookies() do objetoHttpServletRequest que retorna um array de Cookie. Os métodosgetName() e getvalue() do objeto Cookie são utilizados para recuperaro nome o valor da informação associada ao cookie. Os objetos da classe Cookie possuem vários métodos para controle douso de cookies. É possível definir tempo de vida máximo do cookie, os domíniosque devem receber o cookie (por default o domínio que deve receber o cookie éo que o criou), o diretório da página que deve receber o cookie, se o cookie deveser enviado somente sob um protocolo seguro e etc. Por exemplo, para definir aidade máxima de um cookie devemos utilizar o método setMaxAge(),passando um inteiro como parâmetro. Se o inteiro for positivo indicará emsegundos o tempo máximo de vida do cookie. Um valor negativo indica que ocookie deve apagado quando o navegador terminar. O valor zero indica que ocookie deve ser apagado imediatamente. O trecho de código exemplo XX.XXmostra algumas alterações no comportamento default de um cookie....Cookie cookie = new Cookie(cName ,cValor);cookie.setDomain(“*.uvf.br”); // todos os domínios como dpi.ufv.br mas não *.dpi.ufv.brcookie.setMaxAge (3600); // uma hora de tempo de vida... Exemplo XX.XX- Mudanças no comportamento default do cookie.Lidando com Sessões A manipulação direta de cookies para controle de sessão é um tanto baixonível, uma vez que o usuário deve se preocupar com a identificação, tempo devida e outros detalhes. Por isso a API Servlet fornece um objeto com controles Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 372de nível mais alto para monitorar a sessão, o HttpSession. O objetoHttpSession monitora a sessão utilizando cookies de forma transparente. Noentanto, se o cliente não aceitar o uso de cookies é possível utilizar comoalternativa a codificação de URL para adicionar o identificador da sessão. Essaopção, apesar de ser mais genérica, não á primeira opção devido a possibilidadede criação de gargalos pela necessidade da análise prévia de todas requisiçõesque chegam ao servidor. O exemplo XX.XX mostra o uso de um objetoHttpSession para armazenar as informações digitadas em um formulário.import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;public class SessionTeste extends HttpServlet{ public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException { resp.setContentType("text/html"); PrintWriter out = resp.getWriter(); out.println("<html><head>"); out.println("<title>Teste de Sessao</title>"); out.println("</head>"); out.println("<body>"); out.println("<h3>Teste de Sessao</h3>"); HttpSession session = req.getSession(true); out.println("Identificador: " + session.getId()); out.println("<br>"); out.println("Data: "); out.println(new Date(session.getCreationTime()) + "<br>"); out.println("Ultimo acesso: "); out.println(new Date(session.getLastAccessedTime())); String nomedado = req.getParameter("nomedado"); String valordado = req.getParameter("valordado"); if (nomedado != null && valordado != null) { session.setAttribute(nomedado, valordado); } out.println("<P>"); out.println("Dados da Sessao:" + "<br>"); Enumeration valueNames = session.getAttributeNames(); Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 373 while (valueNames.hasMoreElements()) { String name = (String)valueNames.nextElement(); String value = (String) session.getAttribute(name); out.println(name + " = " + value+"<br>"); } out.println("<P>"); out.print("<form action="SessionTeste" method=POST>"); out.println("Nome: <input type=text size=20 name=nomedado><br>"); out.println("Valor: <input type=text size=20 name=valordado><br>"); out.println("<input type=submit>"); out.println("</form>"); out.println("</body></html>"); } public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException { doGet(req, resp); }} Exemplo XX.XX- Servlet para lidar com Sessões. Para controlar a sessão é necessário obter um objeto HttpSession pormeio do método getSession() do objeto HttpServletRequest. Opcionalmente, ométodo getSession() recebe como argumento um valor booleano que indica se épara criar o objeto HttpSession se ele não existir (argumento true) ou se é pararetorna null caso ele não exista (argumento false). Para se associar um objeto ouinformação à sessão usa-se o método setAttribute() do objeto HttpSession,passando para o método um String e um objeto que será identificado pelo String.Note que o método aceita qualquer objeto e, portanto, qualquer objeto pode serassociado à sessão. Os objetos associados a uma sessão são recuperados com ouso método getAttribute() do objeto HttpSession, que recebe como argumento onome associado ao objeto. Para se obter uma enumeração do nomes associados àsessão usa-se o método getAttributeNames() do objeto HttpSession. A figura XX.XX mostra o resultado da execução do exemplo XX.XX. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 374 Teste de Sessao Identificador: session3 Data: Sun May 28 15:19:15 GMT-03:00 2000 Ultimo acesso: Sun May 28 15:19:43 GMT-03:00 2000 Dados da Sessao: Alcione = 4 Alexandra = 6 Nome Valor Enviar ConsultaFigura XVI-1 Saída resultante da execução do Servlet que lida com Sessões. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 375JSP Servlets é uma boa idéia, mas você se imaginou montando uma páginacomplexa usando println()? Muitas vezes o desenvolvimento de um site éuma tarefa complexa que envolve vários profissionais. A tarefa de projeto dolayout da página fica a cargo do Web Designer, incluindo a diagramação dostextos e imagens, aplicação de cores, tratamento das imagens, definição daestrutura da informação apresentada no site e dos links para navegação pelamesma. Já o Desenvolvedor Web é responsável pela criação das aplicações quevão executar em um site. O trabalho destes dois profissionais é somado nacriação de um único produto, mas durante o desenvolvimento a interferênciamutua deve ser a mínima possível. Ou seja, um profissional não deve precisaralterar o que é foi feito pelo outro profissional para cumprir sua tarefa. Atecnologia Servlet não nos permite atingir esse ideal. Por exemplo, suponha queum Web Designer terminou o desenvolvimento de uma página e a entregou parao Desenvolvedor Web codificar em um Servlet. Se após a codificação o WebDesigner desejar realizar uma alteração na página será necessário que ele altere ocódigo do Servlet (do qual ele nada entende) ou entregar uma nova página para oDesenvolvedor Web para que ele a codifique totalmente mais uma vez. Qualqueruma dessas alternativas são indesejáveis e foi devido a esse problema a Sundesenvolveu uma tecnologia baseada em Servlets chamada de JSP. Java Server Pages (JSP) são páginas HTML que incluem código Java eoutros tags especiais. Desta forma as partes estáticas da página não precisam sergeradas por println(). Elas são fixadas na própria página. A parte dinâmicaé gerada pelo código JSP. Assim a parte estática da página pode ser projetadapor um Web Designer que nada sabe de Java. A primeira vez que uma página JSP é carregada pelo container JSP ocódigo Java é compilado gerando um Servlet que é executado, gerando umapágina HTML que é enviada para o navegador. As chamadas subsequentes sãoenviadas diretamente ao Servlet gerado na primeira requisição, não ocorrendomais as etapas de geração e compilação do Servlet. A figura XX.XX mostra um esquema das etapas de execução de umapágina JSP na primeira vez que é requisitada. Na etapa (1) a requisição é enviadapara um servidor Web que reencaminha a requisição (etapa 2) para o containerServlet/JSP. Na etapa (3) o container verifica que não existe nenhuma instânciade Servlet correspondente à página JSP. Neste caso, a página JSP é traduzidapara código fonte de uma classe Servlet que será usada na resposta à requisição.Na etapa (4) o código fonte do Servlet é compilado, e na etapa (5) é criada uma Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 376instância da classe. Finalmente, na etapa (6) é invocado o método service()da instância Servlet para gerar a resposta à requisição. Navegador (1) Requisição de página JSP Servidor Http (2) Encaminha a requisição (6) Resposta à (3) requisição Container Traduz Página Servlet/JSP jsp (5) (4) Instancia e Compila executa Bytecode Fonte Servlet Servlet Figura XVI-1 Etapas da primeira execução de uma página JSP. A idéia de se usar scripts de linguagens de programação em páginasHTML que são processados no lado servidor para gerar conteúdo dinâmico nãoé restrita à linguagem Java. Existem várias soluções desse tipo fornecida poroutros fabricantes. Abaixo segue uma comparação de duas das tecnologias maispopulares com JSP.PHP X JSP PHP (Personal Home Pages) é uma linguagem script para ser executadano lado servidor criada em 1994 como um projeto pessoal de Rasmus Lerdorf.Atualmente encontra-se na versão 4. A sintaxe é fortemente baseada em C maspossui elementos de C++, Java e Perl. Possui suporte à programação OO pormeio de classes e objetos. Possui também suporte extensivo à Banco de dadosODBC, MySql, Sybase, Oracle e outros. PHP é uma linguagem mais fácil nodesenvolvimento de pequenas aplicações para Web em relação à JSP, uma vez Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 377que é uma linguagem mais simples e menos rígida do que JSP. No entanto, amedida que passamos para aplicações de maior porte, o uso de PHP não éindicado, uma vez que necessário o uso de linguagens com checagem maisrígidas e com maior suporte à escalabilidade, como é o caso de Java.ASP X JSP ASP (Active Server Pages) é a solução desenvolvida pela Microsoft®para atender as requisições feitas à servidores Web. Incorporada inicialmenteapenas ao Internet Information Server (IIS), no entanto, atualmente já ésuportada por outros servidores populares, como o Apache. O desenvolvimentode páginas que usam ASP envolve a produção de um script contendo HTMLmisturado com blocos de código de controle ASP. Este código de controle podeconter scripts em JavaScript ou VBScript. A primeira vantagem de JSP sobreASP é que a parte dinâmica é escrita em Java e não Visual Basic ou outralinguagem proprietária da Microsoft, portanto JSP é mais poderoso e fácil deusar. Em segundo lugar JSP é mais portável para outros sistemas operacionais eservidores WEB que não sejam Microsoft.Primeiro exemplo em JSP Para que o leitor possa ter uma idéia geral da tecnologia JSPapresentaremos agora a versão JSP do Olá mundo. O exemplo XX.XX mostra ocódigo da página. <html> <head> <title>Exemplo JSP</title> </head> <body> <% String x = "Ol&aacute; Mundo!"; %> <%=x%> </body> </html> Exemplo XX.XX- Versão JSP do Olá mundo. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 378 Quem está habituado aos tags HTML notará que se trata basicamente deuma página HTML contendo código Java delimitado pelos símbolos “<%” e“%>”. Para facilitar a visualização destacamos os scripts Java com negrito. Noprimeiro trecho de script é declarada uma variável x com o valor “Olá mundo”(a seqüência &acute; é denota ‘á’ em HTML). No segundo trecho de script oconteúdo da variável x é extraído e colocado na página resultante da execuçãodo Servlet correspondente. Em seguida mostraremos como executar o exemploXX.XX.Executando o arquivo JSP Para executar o exemplo XX.XX salve-o com a extensão .jsp. Porexemplo ola.jsp. Se você estiver usando o servidor Tomcat, coloque-oarquivo no subdiretório /webapps/examples/jsp do Tomcat. Por exemploexamples/jsp/teste. Para invocar o arquivo JSP basta embutir a URL emuma página ou digitar diretamente a seguinte URL no navegador. http://localhost:8080/examples/jsp/ola.jsp Usamos o diretório /webapps/examples/jsp para testar rapidamenteo exemplo. Para desenvolver uma aplicação é aconselhável criar um diretórioapropriado como mostrado na seção que tratou de Servlets. O Servlet criado a partir da página JSP é colocado em um diretório detrabalho. No caso do Tomcat o Servlet é colocado em subdiretório associado àaplicação subordinado ao diretório /work do Tomcat. O exemplo XX.XXmostra os principais trechos do Servlet criado a partir da tradução do arquivoola.jsp pelo tradutor do Tomcat. Note que o Servlet é subclasse de umaclasse HttpJspBase e não da HttpServlet. Além disso, o método queexecutado em resposta à requisição é o método _jspService() e não ométodo service(). Note também que todas as partes estáticas da página JSPsão colocadas como argumentos do método write() do objeto referenciadoout. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 379public class _0002fjsp_0002fola_00032_0002ejspola_jsp_0 extends HttpJspBase { ....public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { .... PageContext pageContext = null; HttpSession session = null; ServletContext application = null; ServletConfig config = null; JspWriter out = null; ... try { ... out.write("<html>rn <head>rn <title>Exemplo JSP</title>rn</head>rn <body>rn"); String x = "Ol&aacute; Mundo!"; out.write("rn"); out.print(x); out.write("rn </body>rn</html>rn"); ... } catch (Exception ex) { ... } }} Exemplo XX.XX- Servlet correspondente à página JSP do Olá mundo.Objetos implícitos No exemplo XX.XX pode-se ver a declaração de variáveis quereferenciam a alguns objetos importantes. Estas variáveis estão disponíveis parao projetista da página JSP. As variáveis mais importantes são: Classe Variável HttpServletRequest request HttpServletResponse response PageContext pageContext ServletContext application HttpSession session JspWriter out Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 380 Os objetos referenciados pelas variáveis request e response játiveram seu uso esclarecido na seção sobre Servlets. O objeto do tipoJspWriter tem a mesma função do PrinterWriter do Servlet. Os outrosobjetos terão sua função esclarecida mais adiante.Tags JSP Os tags JSP possuem a seguinte forma geral: <% Código JSP %> O primeiro caractere % pode ser seguido de outros caracteres quedeterminam o significado preciso do código dentro do tag. Os tags JSP possuemcorrespondência com os tags XML. Existem cinco categorias de tags JSP: Expressões Scriptlets Declarações Diretivas Comentários Em seguida comentaremos cada uma dessas categorias.Expressões <%= expressões %> Expressões são avaliadas, convertidas para String e colocadas napágina enviada. A avaliação é realizada em tempo de execução, quando a páginaé requisitada.Exemplos: <%= new java.util.Date() %> <%= request.getMethod() %> No primeiro exemplo será colocado na página a data corrente emmilésimo de segundos e no segundo será colocado o método usado na Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 381requisição. Note que cada expressão contém apenas um comando Java. Notetambém que o comando Java não é terminado pelo caractere ‘;’.Scriptlets <% código Java %> Quando é necessário mais de um comando Java ou o resultado dacomputação não é para ser colocado na página de resposta é preciso usar outracategoria de tags JSP: os Scriptlets . Os Scriptlets permitem inserir trechos decódigo em Java na página JSP. O exemplo XX.XX mostra uma página JSPcontendo um Scriptlet que transforma a temperatura digitada em celcius para oequivalente em Fahrenheit. <html> <head><title>Conversao Celcius Fahrenheit </title></head> <body> <% String valor = request.getParameter("celcius"); if (valor != null ) { double f = Double.parseDouble(valor)*9/5 +32; out.println("<P>"); out.println("<h2>Valor em Fahrenheit:" +f +"<h2><br>"); } %> <form action=conversao.jsp method=POST> Celcius: <input type=text size=20 name=celcius><br> <input type=submit> </form> </body> </html> Exemplo XX.XX- Página JSP que converte graus Celcius para Fahrenheit. Note o uso das variáveis request e out sem a necessidade dedeclaração. Todo o código digitado é inserido no método _jspService(). Afigura XX.XX mostra o resultado da requisição após a digitação do valor 30 nacaixa de texto do formulário. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 382 Valor em Fahrenheit:86.0 Celcius: Enviar Consulta Figura XVI-XX Resultado da conversão de 30 graus celcius. O código dentro do scriptlet é inserido da mesma forma que é escrito etodo o texto HTML estático antes e após ou um scriptlet é convertido paracomandos print(). Desta forma o scriptlets não precisa conter comandos paracódigo estático e blocos de controle abertos afetam o código HTML envolvidospor scriptlets. O exemplo XX.XX mostra dois formas de se produzir o mesmoefeito. No código da esquerda os Scriplets se intercalam com código HTML. Ocódigo HTML, quando da tradução da página JSP para Servlet é inserido comoargumentos de métodos println() gerando o código da direita. Ambas asformas podem ser usadas em páginas JSP e produzem o mesmo efeito.Previs&atilde;o do Tempo out.println("Previs&atilde;o do Tempo");<% if (Math.random() < 0.5) { %> if (Math.random() < 0.5) {Hoje vai <B>fazer sol</B>! out.println(" Hoje vai <B>fazer sol</B>!");<% } else { %> } else {Hoje vai <B>chover</B>! out.println(" Hoje vai <B>chover</B>!");<% } %> } Exemplo XX.XX- Dois códigos equivalentes.Declarações <%! Código Java %> Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 383 Uma declaração JSP permite definir variáveis ou métodos que sãoinseridos no corpo do Servlet. Como as declarações não geram saída, elas sãonormalmente usadas em combinação com expressões e scriptlets. O ExemploXX.XX mostra a declaração de uma variável que é usada para contar o númerode vezes que a página corrente foi requisitada desde que foi carregada.<%! Private int numAcesso = 0; %>Acessos desde carregada:<%= ++ numAcesso %> Exemplo XX.XX- Declaração de uma variável usando o tag de declaração. As variáveis declaradas desta forma serão variáveis de instância. Já asvariáveis declaradas em Scriptlets são variáveis locais ao método_jspService(). Por isso é possível contar o número de requisições com oexemplo XX.XX. Se variável fosse declarada em um Scriptlet a variável serialocal ao método _jspService() e, portanto, teria seu valor reinicializado acada chamada. Como já foi dito, os tags de declarações permitem a declaração demétodos. O Exemplo XX.XX mostra a declaração de um método que convertecelcius para Fahrenheit. <%! private double converte(double c) { return c*9/5 +32; } %> Exemplo XX.XX- Declaração de um método para a conversão de celcius para Fahrenheit.Comentários Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 384 Existem dois tipos de comentários utilizados em páginas JSP. O primeiroexclui todo o bloco comentado da saída gerada pelo processamento da página. Aforma geral deste tipo de comentário é a seguinte: <%--comentário --%> O segundo tipo de comentário é o utilizado em páginas HTML. Nestecaso o comentário é enviado dentro da página de resposta. A forma geral destetipo de comentário é a seguinte: <!—comentário -->Diretivas Diretivas são mensagens para JSP container. Elas não enviam nada para apágina mas são importantes para definir atributos JSP e dependências com o JSPcontainer. A forma geral da diretivas é a seguinte: <%@ Diretiva atributo="valor" %>ou <%@ Diretiva atributo1 ="valor1" atributo2 ="valor2" ... atributoN =" valorN " %> Em seguida comentaremos as principais diretivas.Diretiva page <%@ page atributo1 ="valor1" ... atributoN =" valorN " %>A diretiva page permite a definição dos seguintes atributos: import contentType isThreadSafe Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 385 session buffer autoflush info errorPage isErrorPage languageSegue a descrição de cada um desses atributos.Atributo e Forma Geral Descriçãoimport="package.class" Permite especificar os pacotes que devem ser importados para serem usados na página JSP.ou Exemplo:import="package.class1,...,package.classN" <%@ page import="java.util.*" %>contentType="MIME-Type" Especifica o tipo MIME da saída. O default é text/html. Exemplo: <%@ page contentType="text/plain" %> possui o mesmo efeito do scriptlet <% response.setContentType("text/plain") ; %>isThreadSafe="true|false" Um valor true (default) indica um processamento normal do Servlet, onde múltiplas requisições são processadas simultaneamente. Um valor false indica que o processamento deve ser feito por instancias separadas do Servlet ou serialmente.session="true|false” Um valor true (default) indica que a variável predefinida session (HttpSession) deve ser associada à sessão, se existir, caso contrário uma nova sessão deve ser criada e associada a ela. Um valor false indica que nenhuma sessão será usada.buffer="sizekb|none" Especifica o tamanho do buffer para escrita usado pelo objeto JspWriter. O tamanho default não é menor que 8k..autoflush="true|false” Um valor true (default) indica que o buffer deve ser Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 386 esvaziado quando estiver cheio.info="mensagem" Define uma cadeia de caracteres que pode ser recuperada via getServletInfo().errorPage="url” Especifica a página JSP que deve ser processada em caso de exceções não capturadas.isErrorPage="true|false” Indica se a página corrente pode atuar como página de erro para outra página JSP. O default é false.Language="java” Possibilita definir a linguagem que está sendo usada. No momento a única possibilidade é Java. Tabela XVI.XX –Atributos da diretiva page.Diretiva include <%@ include file="relative url" %> Permite incluir arquivos no momento em que a página JSP é traduzidaem um Servlet.Exemplo:<%@ include file="/meuarq.html" %>Extraindo Valores de Formulários Uma página JSP, da mesma forma que um Servlet, pode usar o objetoreferenciado pela variável request para obter os valores dos parâmetros de umformulário. O exemplo XX.XX usado para converter graus Celcius emFahrenheit fez uso deste recurso. O exemplo XX.XX mostra outra página JSPcom formulário. Note que o scriptlet é usado para obter o nome e os valores detodos os parâmetros contidos no formulário. Como o métodogetParameterNames() retorna uma referência a um objetoEnumeration é preciso importar o pacote java.util, por meio da diretivapage.<%@ page import="java.util.*" %><html><body><H1>Formulário</H1><% Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 387 Enumeration campos = request.getParameterNames(); While(campos.hasMoreElements()) { String campo = (String)campos.nextElement(); String valor = request.getParameter(campo); %> <li><%= campo %> = <%= valor %></li><% } %> <form method="POST" action="form.jsp"> Nome: <input type="text" size="20" name="nome" ><br> Telefone: <input type="text" size="20" name="telefone"><br> <INPUT TYPE=submit name=submit value="envie"> </form></body></html> Exemplo XVI.XX – Página JSP com formulário. A figura XX.XX mostra o resultado da requisição após a digitação dosvalores Alcione e 333-3333 nas caixas de texto do formulário. Formulário • telefone = 333-3333 • nome = Alcione • submit = envie Nome: Telefone: envie Figura XVI.XX- Saída do exemplo XX.XX.Criando e Modificando Cookies Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 388 Da mesma for que em Servlets os cookies em JSP são tratados por meioda classe Cookie. Para recuperar os cookies enviados pelo navegador usa-se ométodo getCookies() do objeto HttpServletRequest que retorna umarranjo de Cookie. Os métodos getName() e getvalue() do objetoCookie são utilizados para recuperar o nome o valor da informação associadaao cookie. O cookie é enviado para o navegador por meio do métodoaddCookie() do objeto HttpServletResponse. O exemplo XX.XXmostra uma página JSP que exibe todos os cookies recebidos em uma requisiçãoe adiciona mais um na resposta.<html><body><H1>Session id: <%= session.getId() %></H1><% Cookie[] cookies = request.getCookies(); For(int i = 0; i < cookies.length; i++) { %> Cookie name: <%= cookies[i].getName() %> <br> Value: <%= cookies[i].getValue() %><br> antiga idade máxima em segundos: <%= cookies[i].getMaxAge() %><br> <% cookies[i].setMaxAge(5); %> nova idade máxima em segundos: <%= cookies[i].getMaxAge() %><br><% } %><%! Int count = 0; int dcount = 0; %><% response.addCookie(new Cookie(”Cookie " + count++, ”Valor " + dcount++)); %></body></html> Exemplo XVI.XX – Página JSP que exibe os cookies recebidos. A figura XX.XX mostra o resultado após três acessos seguidos à páginaJSP. Note que existe um cookie a mais com o nome JSESSIONID e valor igualà sessão. Este cookie é o usado pelo container para controlar a sessão. Session id: 9ppfv0lsl1 Cookie name: Cookie 0 value: Valor 0 antiga idade máxima em segundos: -1 nova idade máxima em segundos: 5 Cookie name: Cookie 1 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 389 value: Valor 1 antiga idade máxima em segundos: -1 nova idade máxima em segundos: 5 Cookie name: JSESSIONID value: 9ppfv0lsl1 antiga idade máxima em segundos: -1 nova idade máxima em segundos: 5 Figura XVI.XX- Saída do exemplo XX.XX após três acessos.Lidando com sessões O atributos de uma sessão são mantidos em um objeto HttpSessionreferenciado pela variável session. Pode-se armazenar valores em uma sessãopor meio do método setAttribute() e recuperá-los por meio do métodogetAttribute(). O tempo de duração default de uma sessão inativa (sem orecebimento de requisições do usuário) é 30 minutos mas esse valor pode seralterado por meio do método setMaxInactiveInterval(). O exemploXX.XX mostra duas páginas JSP. A primeira apresenta um formulário ondepodem ser digitados dois valores recebe dois valores de digitados em umformulário e define o intervalo máximo de inatividade de uma sessão em 10segundos. A segunda página recebe a submissão do formulário, insere os valoresna sessão e apresenta os valores relacionados com a sessão assim como aidentificação da sessão.<%@ page import="java.util.*" %><html><body><H1>Formulário</H1><H1>Id da sess&atilde;o: <%= session.getId() %></H1><H3><li>Essa sess&atilde;o foi criada em<%= session.getCreationTime() %></li></H3><H3><li>Antigo intervalo de inatividade = <%= session.getMaxInactiveInterval() %></li><% session.setMaxInactiveInterval(10); %><li>Novo intervalo de inatividade= <%= session.getMaxInactiveInterval() %></li></H3> Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 390<% Enumeration atribs = session.getAttributeNames(); while(atribs.hasMoreElements()) { String atrib = (String)atribs.nextElement(); String valor = (String)session.getAttribute(atrib); %> <li><%= atrib %> = <%= valor %></li><% } %> <form method="POST" action="sessao2.jsp"> Nome: <input type="text" size="20" name="nome" ><br> Telefone: <input type="text" size="20" name="telefone" > <br> <INPUT TYPE=submit name=submit value="envie"> </form></body></html><html><body><H1>Id da sess&atilde;o: <%= session.getId() %></H1><% String nome = request.getParameter("nome"); String telefone = request.getParameter("telefone"); if (nome !=null && nome.length()>0) session.setAttribute("nome",nome); if (telefone !=null &&telefone.length()>0) session.setAttribute("telefone",telefone);%><FORM TYPE=POST ACTION=sessao1.jsp><INPUT TYPE=submit name=submit Value="Retorna"></FORM></body></html> Exemplo XVI.XX – Exemplo do uso de sessão. O exemplo XX.XX mostra que a sessão é mantida mesmo quandoo usuário muda de página. As figura XX.XX e XX.XX mostram o resultado darequisição após a digitação dos valores Alcione e 333-3333 nas caixas detexto do formulário, à submissão para página sessao2.jsp e o retorno àpágina sessao1.jsp. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 391 Formulário Id da sessão: soo8utc4m1 Essa sessão foi criada em 1002202317590 Antigo intervalo de inatividade = 1800 Novo intervalo de inatividade= 10 telefone = 333-3333 nome = Alcione Nome: Telefone: envie Figura XVI.XX- Tela da página sessao1.jsp. Id da sessão: soo8utc4m1 Retorna Figura XVI.XX- Tela da página sessao2.jsp.O Uso de JavaBeans Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 392 A medida que o código Java dentro do HTML torna-se cada vez maiscomplexo o desenvolvedor pode-se perguntar: Java em HTML não é o problemainvertido do HTML em Servlet? O resultado não será tão complexo quantoproduzir uma página usando println()? Em outras palavras, estounovamente misturando conteúdo com forma? Para solucionar esse problema a especificação de JSP permite o uso deJavaBeans para manipular a parte dinâmica em Java. JavaBeans já foramdescritos detalhadamente em um capítulo anterior, mas podemos encarar umJavaBean como sendo apenas uma classe Java que obedece a uma certapadronização de nomeação de métodos, formando o que é denominado depropriedade. As propriedades de um bean são acessadas por meio de métodosque obedecem a convenção getXxxx e setXxxx. , onde Xxxx é o nome dapropriedade. Por exemplo, getItem() é o método usado para retornar o valorda propriedade item. A sintaxe para o uso de um bean em uma página JSP é: <jsp:useBean id="nome" class="package.class" /> Onde nome é o identificador da variável que conterá uma referência parauma instância do JavaBean. Você também pode modificar o atributo scopepara estabelecer o escopo do bean além da página corrente.<jsp:useBean id="nome" scope="session" class="package.class" /> Para modificar as propriedades de um JavaBean você pode usar ojsp:setProperty ou chamar um método explicitamente em umscriptlet. Para recuperar o valor de uma propriedade de um JavaBean vocêpode usar o jsp:getProperty ou chamar um método explicitamente emum scriptlet. Quando é dito que um bean tem uma propriedade prop dotipo T significa que o bean deve prover um método getProp() e um métododo tipo setProp(T). O exemplo XX.XX mostra uma página JSP e umJavaBean. A página instancia o JavaBean, altera a propriedade mensagem erecupera o valor da propriedade, colocando-o na página.Página bean.jsp<HTML> <HEAD><TITLE>Uso de beans</TITLE></HEAD> <BODY> <CENTER> Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 393<TABLE BORDER=5> <TR><TH CLASS="TITLE"> Uso de JavaBeans </TABLE></CENTER> <P><jsp:useBean id="teste" class=”curso.BeanSimples" /><jsp:setProperty name="teste" property="mensagem" value=”Ola mundo!" /><H1> Mensagem: <I><jsp:getProperty name="teste" property="mensagem" /> </I></H1></BODY> </HTML>Arquivo Curso/BeanSimples.javapackage curso;public class BeanSimples { private String men = "Nenhuma mensagem"; public String getMensagem() { return(men); } public void setMensagem(String men) { this.men = men; }} Exemplo XVI.XX – Exemplo do uso de JavaBean. A figura XX.XX mostra o resultado da requisição dirigida à páginabean.jsp. Uso de JavaBeans Mensagem: Ola mundo! Figura XVI.XX- Resultado da requisição à página bean.jsp. Se no tag setProperty usarmos o valor “*” para o atributoproperty então todos os valores de elementos de formulários que possuíremnomes iguais à propriedades serão transferidos para as respectivas propriedades Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 394no momento do processamento da requisição. Por exemplo, seja uma página jspcontendo um formulário com uma caixa de texto com nome mensagem, comomostrado no exemplo XX.XX. Note que, neste caso, a propriedade mensagemdo JavaBean tem seu valor atualizado para o valor digitado na caixa de texto,sem a necessidade de uma chamada explícita no tag setProperty. Osvalores são automaticamente convertidos para o tipo correto no bean.<HTML> <HEAD><TITLE>Uso de beans</TITLE> </HEAD><BODY> <CENTER><TABLE BORDER=5> <TR><TH CLASS="TITLE"> Uso de JavaBeans </TABLE></CENTER> <P><jsp:useBean id="teste" class="curso.BeanSimples" /><jsp:setProperty name="teste" property="*" /><H1> Mensagem: <I><jsp:getProperty name="teste" property="mensagem" /></I></H1><form method="POST" action="bean2.jsp"> Texto: <input type="text" size="20" name="mensagem" ><br> <INPUT TYPE=submit name=submit value="envie"></form></BODY> </HTML> Exemplo XVI.XX – Exemplo de atualização automática da propriedade. A figura XX.XX mostra o resultado da requisição dirigida à páginabean2.jsp após a digitação do texto Olá! Uso de JavaBeans Mensagem: Ola! Texto: envie Figura XVI.XX- Resultado da requisição à página bean2.jsp. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 395Escopo Existem quatro valores possíveis para o escopo de um objeto: page,request, session e application. O default é page. A tabelaXX.XX descreve cada tipo de escopo. Escopo Descriçãopage Objetos declarados com nesse escopo são válidos até a resposta ser enviada ou a requisição ser encaminhada para outro programa no mesmo ambiente, ou seja, só podem ser referenciados nas páginas onde forem declarados. Objetos declarados com escopo page são referenciados pelo objeto pagecontext.request Objetos declarados com nesse escopo são válidos durante a requisição e são acessíveis mesmo quando a requisição é encaminhada para outro programa no mesmo ambiente. Objetos declarados com escopo request são referenciados pelo objeto request.session Objetos declarados com nesse escopo são válidos durante a sessão desde que a página seja definida para funcionar em uma sessão. Objetos declarados com escopo session são referenciados pelo objeto session.application Objetos declarados com nesse escopo são acessíveis por páginas no mesmo servidor de aplicação. Objetos declarados com escopo application são referenciados pelo objeto application. Tabela XVI.XX –Escopo dos objetos nas páginas JSP.Implementação de um Carrinho de compras O exemplo abaixo ilustra o uso de JSP para implementar um carrinho decompras virtual. O carrinho de compras virtual simula um carrinho de comprasde supermercado, onde o cliente vai colocando os produtos selecionados paracompra até se dirigir para o caixa para fazer o pagamento. No carrinho decompras virtual os itens selecionados pelo usuário são armazenados em umaestrutura de dados até que o usuário efetue o pagamento. Esse tipo de exemplo Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 396exige que a página JSP funcione com o escopo session para manter ocarrinho de compras durante a sessão. O exemplo XX.XX mostra um exemplosimples de implementação de carrinho de compras. O exemplo é composto pordois arquivos: um para a página JSP e um para o JavaBean que armazena ositens selecionados.Página compras.jsp<html><jsp:useBean id="carrinho" scope="session" class="compra.Carrinho" /><jsp:setProperty name="carrinho" property="*" /><body bgcolor="#FFFFFF"><% carrinho.processRequest(request); String[] items = carrinho.getItems(); if (items.length>0) {%> <font size=+2 color="#3333FF">Voc&ecirc; comprou os seguintes itens:</font> <ol> <% for (int i=0; i<items.length; i++) { out.println("<li>"+items[i]); } }%></ol><hr><form type=POST action= compras.jsp> <br><font color="#3333FF" size=+2>Entre um item para adicionar ou remover: </font><br> <select NAME="item"> <option>Televis&atilde;o <option>R&aacute;dio <option>Computador <option>V&iacute;deo Cassete </select> <p><input TYPE=submit name="submit" value="adicione"> <input TYPE=submit name="submit" value="remova"></form></body></html>JavaBean compra/Carrinho.javapackage compra; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 397import javax.servlet.http.*;import java.util.Vector;import java.util.Enumeration;public class Carrinho { Vector v = new Vector(); String submit = null; String item = null; private void addItem(String name) {v.addElement(name); } private void removeItem(String name) {v.removeElement(name); } public void setItem(String name) {item = name; } public void setSubmit(String s) { submit = s; } public String[] getItems() { String[] s = new String[v.size()]; v.copyInto(s); return s; } private void reset() { submit = null; item = null; } public void processRequest(HttpServletRequest request) { if (submit == null) return; if (submit.equals("adicione")) addItem(item); else if (submit.equals("remova")) removeItem(item); reset(); }} Exemplo XVI.XX – Implementação de um carrinho de compras Virtual. O exemplo XX.XX implementa apenas o carrinho de compras, deixandode fora o pagamento dos itens, uma vez que esta etapa depende de cada sistema.Geralmente o que é feito é direcionar o usuário para outra página onde eledigitará o número do cartão de crédito que será transmitido por meio de umaconexão segura para o servidor. Existem outras formas de pagamento, como Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 398boleto bancário e dinheiro virtual. O próprio carrinho de compras geralmente émais complexo, uma vez que os para compra devem ser obtidos dinamicamentede um banco de dados. A figura XX.XX mostra a tela resultante de algumasinterações com o carrinho de compras. Figura XVI.XX- Carrinho de compras virtual. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 399Reencaminhando ou Redirecionando requisições Existem algumas situações onde pode ser desejável transferir umarequisição para outra URL. Isto é feito com frequência em sistemas quecombinam o uso de Servlets juntamente com JSP. No entanto, a transferênciapode ser para qualquer recurso. Assim, podemos transferir uma requisição de umServlet para uma página JSP, HTML ou um Servlet. Da mesma forma umapágina JSP pode transferir uma requisição para uma página JSP, HTML ou umServlet. Existem dois tipos de transferência de requisição: o redirecionamento e oreencaminhamento. O redirecionamento é obtido usando o métodosendRedirect() de uma instância HttpServletResponse, passandocomo argumento a URL de destino. O exemplo XX.XX mostra o código de umServlet redirecionando para uma página HTML.import javax.servlet.*;import javax.servlet.http.*;import java.io.*;public class Redireciona extends HttpServlet{ public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { res.sendRedirect("/test/index.html"); }} Exemplo XVI.XX – Redirecionamento de requisição. Note pelo exemplo que é preciso passar o contexto do recurso(/teste). No caso de redirecionamento o a requisição corrente é perdida e umanova requisição é feita para a URL de destino. Por isso não se deve associarnenhum objeto à requisição, uma vez que o objeto HttpServletRequestcorrente será perdido. O que ocorre na prática é que o servidor envia umamensagem HTTP 302 de volta para o cliente informando que o recurso foitransferido para outra URL e o cliente envia uma nova requisição para a URLinformada. Já no caso de reencaminhamento a requisição é encaminhada diretamentepara a nova URL mantendo todos os objetos associados e evitando uma nova ida Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 400ao cliente. Portanto, o uso de reencaminhamento é mais eficiente do que o usode redirecionamento. O reencaminhamento é obtido usando o métodoforward() de uma instância RequestDispatcher, passando comoargumento os objetos HttpServletRequest e HttpServletResponsepara a URL de destino. Uma instância RequestDispatcher é obtida pormeio do método getRequestDispatcher()de uma instânciaServletContext , que é obtido, por sua vez, por meio do métodogetServletContext() do Servlet. O exemplo XX.XX mostra o código deum Servlet reencaminhando a requisição para uma página JSP.import javax.servlet.*;import javax.servlet.http.*;public class Reencaminha extends HttpServlet{ public void doGet(HttpServletRequest request, HttpServletResponse response) { try { getServletContext().getRequestDispatcher("/index.html"). forward(request,response); }catch (Exception e) { System.out.println("Servlet falhou: "); e.printStackTrace(); } }} Exemplo XVI.XX – Reencaminhamento de requisição. Note que não é necessário passar o contexto na URL, como é feito noredirecionamento, uma vez que a requisição é encaminhada no contextocorrente. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 401Uma Arquitetura para comércio eletrônico O projeto de uma solução para comércio eletrônico é uma tarefacomplexa e deve atender diversos requisitos. Nesta seção mostraremos umamodelo de arquitetura básico para comércio eletrônico que pode ser adaptadopara soluções mais específicas. Este modelo implementa o padrão de projetoMVC, procurando, desta forma, isolar esses aspectos de um sistema decomputação.Tipos de aplicações na WEB Podemos enquadra as aplicações na Web em um dos seguintes tipos:• Business-to-consumer (B2C) – entre empresa e consumidor. Exemplo: uma pessoa compra um livro na Internet.• Business-to-business (B2B) – Troca de informações e serviços entre empresas. Exemplo: o sistema de estoque de uma empresa de automóveis detecta que um item de estoque precisa ser resposta e faz o pedido diretamente ao sistema de produção do fornecedor de autopeças. Neste tipo de aplicação a linguagem XML possui um papel muito importante, uma vez que existe a necessidade de uma padronização dos tags para comunicação de conteúdo.• User-to-data – acesso à bases de informação. Exemplo: uma usuário consulta uma base de informação.• User-to-user – chat, e troca de informações entre usuários (Morpheus). O exemplo que mostraremos é tipicamente um caso de User-to-data,(agenda eletrônica na Web) mas possui a mesma estrutura de um B2C.Arquitetura MVC para a Web A figura XX.XX contém um diagrama de blocos que mostra aparticipação de Servlets, JSP e JavaBeans na arquitetura proposta. A idéia éisolar cada aspecto do modelo MVC com a tecnologia mais adequada. A página Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 402JSP é ótima para fazer o papel da visão, uma vez que possui facilidades para ainserção de componentes visuais e para a apresentação de informação. Noentanto, é um pouco estranho usar uma página JSP para receber e tratar umarequisição. Esta tarefa, que se enquadra no aspecto de controle do modelo MVCé mais adequada a um Servlet, uma vez que neste momento componentes deapresentação são indesejáveis. Finalmente, é desejável que a modelagem donegócio fique isolada dos aspectos de interação. A proposta é que a modelagemdo negócio fique contida em classes de JavaBeans. Em aplicações maissofisticadas a modelagem do negócio deve ser implementada por classes deEnterprise JavaBeans (EJB), no entanto esta forma de implementação foge aoescopos deste livro. Cada componente participa da seguinte forma:• Servlets – Atuam como controladores, recebendo as requisições dos usuários. Após a realização das análises necessária sobre a requisição, instancia o JavaBean e o armazena no escopo adequado (ou não caso o bean já tenha sido criado no escopo) e encaminha a requisição para a página JSP.• JavaBeans – Atuam como o modelo da solução, independente da requisição e da forma de apresentação. Comunicam-se com a camada intermediária que encapsula a lógica do problema.• JSP – Atuam na camada de apresentação utilizando os JavaBeans para obtenção dos dados a serem exibidos, isolando-se assim de como os dados são obtidos. O objetivo é minimizar a quantidade de código colocado na página.• Camada Intermediária (Middleware) – Incorporam a lógica de acesso aos dados. Permitem isolar os outros módulos de problemas como estratégias de acesso aos dados e desempenho. O uso de EJB (Enterprise JavaBeans) é recomendado para a implementação do Middleware, uma vez que os EJBs possuem capacidades para gerência de transações e persistência. Isto implica na adoção de um servidor de aplicação habilitado para EJB. A figura XX.XX mostra a interação entre os componentes. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 403 Servidor de Aplicação 1 Navegador Web Servlet Cria uma instância Requisição (controlador) 2 3 JavaBean (modelo) 4 5 JSP Resposta (Apresentação) MiddleWare JDBC SGBD Figura XV.XX. Arquitetura de uma aplicação para Comércio Eletrônico. Essa arquitetura possui as seguintes vantagens:1. Facilidade de manutenção: a distribuição lógica das funções entre os módulos do sistema isola o impacto das modificações.2. Escalabilidade: Modificações necessária para acompanhar o aumento da demanda de serviços (database pooling, clustering, etc) ficam concentradas na camada intermediária. A figura abaixo mostra a arquitetura física de uma aplicação de comércioeletrônico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 404Figura XV.XX. Arquitetura física de uma aplicação para Comércio Eletrônico. Demilitarized Zone (DMZ) é onde os servidores HTTP são instalados. ADMZ é protegida da rede púbica por um firewall, também chamado de firewallde protocolo. O firewall de protocolo deve ser configurado para permitir tráfegoapenas através da porta 80. Um segundo firewall, também chamado de firewallde domínio separa a DMZ da rede interna. O firewall de domínio deve serconfigurado para permitir comunicação apenas por meio das portas do servidorde aplicaçãoAgenda Web: Um Exemplo de uma aplicação Web usando aarquitetura MVC O exemplo a seguir mostra o desenvolvimento da agenda eletrônica parao funcionamento na Web. A arquitetura adotada é uma implementação domodelo MVC. Apenas, para simplificar a solução, a camada intermediária foisimplificada e é implementada por um JavaBean que tem a função de gerenciar aconexão com o banco de dados. O banco de dados será composto por duastabelas, uma para armazenar os usuários autorizados a usar a tabela e outra paraarmazenar os itens da agenda. A figura XX.XX mostra o esquema conceitual dobanco de dados e a figura XX.XX mostra o comando para a criação das tabelas.Note que existe um relacionamento entre a tabela USUARIO e a tabela PESSOA,mostrando que os dados pessoais sobre o usuário ficam armazenados na agenda. USUARIO PESSOA Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • Java na Prática 405 1:1 1:1