UNIVERSIDADE FEDERAL DE VIÇOSA DEPARTAMENTO DE …vladimir/java/Java na Pratica_vol1.pdf · milhões de programadores Java no mundo e a ... Nas linguagens onde existe alocação

UNIVERSIDADE FEDERAL DE VIÇOSA

DEPARTAMENTO DE INFORMÁTICA

JAVA NA PRÁTICA

Volume I

Alcione de Paiva OliveiraVinícius Valente Maciel

2002

Java na Prática

Alcione de P. Oliveira, Vinícius V. Maciel - UFV

1

SumárioCapítulo I - Introdução ....................................... 5

CONVENÇÕES............................................................................................................................. 9Capítulo II - Programação Orientada a Objetos .................. 10

CLASSES E OBJETOS E LINGUAGENS DE PROGRAMAÇÃO ......................................................... 11Ocultando de Informação................................................................................................... 15Especialização e Herança .................................................................................................. 16Sobrescrita, Sobrecarga e Polimorfismo............................................................................ 17

INTRODUÇÃO À DIAGRAMA DE CLASSES ................................................................................. 19Diagrama de Classes.......................................................................................................... 19

Capítulo III - Introdução à Linguagem Java ..................... 26PALAVRAS RESERVADAS ......................................................................................................... 29LITERAIS .................................................................................................................................. 30SEPARADORES.......................................................................................................................... 33TIPOS DE DADOS....................................................................................................................... 34

Tipos de dados simples....................................................................................................... 34Tipos de dados compostos .................................................................................................. 36

CONVERSÃO DE TIPOS.............................................................................................................. 40OPERADORES ........................................................................................................................... 41

Expressões e Precedência entre Operadores ..................................................................... 49COMENTÁRIOS ......................................................................................................................... 50BLOCOS E ESCOPO ................................................................................................................... 51ESTRUTURAS DE CONTROLE .................................................................................................... 52

Seleção ............................................................................................................................... 52Repetição............................................................................................................................ 56break e continue ......................................................................................................... 59

ARGUMENTOS DA LINHA DE COMANDO.................................................................................... 61ASSERT (ASSERTIVAS) ............................................................................................................. 62

Sintaxe e semântica ............................................................................................................ 63Habilitando e Desabilitando Assertivas ............................................................................. 63

Capítulo IV Classes, Packages e Interfaces ................... 66CLASSES .................................................................................................................................. 66

Construtores ....................................................................................................................... 68Valor de Retorno ................................................................................................................ 68

OBJETOS .................................................................................................................................. 69MODIFICADORES DE ACESSO.................................................................................................... 72

Outros Modificadores......................................................................................................... 74REFERÊNCIAS COMPARTILHADAS ............................................................................................ 78COPIANDO OBJETOS................................................................................................................. 81

O objeto this ................................................................................................................... 85PACKAGES ............................................................................................................................... 86

Usando Packages ............................................................................................................... 87Criando Packages .............................................................................................................. 87Empacotando packages em arquivos JARs ........................................................................ 89O Mecanismo de Extensão ................................................................................................. 92

DERIVANDO CLASSES............................................................................................................... 94

Java na Prática


2super ................................................................................................................................... 97A classe Object ............................................................................................................... 97Sobrescrita e Polimorfismo ................................................................................................ 98

CLASSES E MÉTODOS ABSTRATOS ......................................................................................... 101INTERFACES ........................................................................................................................... 102CLASSES INTERNAS................................................................................................................ 105

Classes Internas Anônimas............................................................................................... 107INICIALIZAÇÃO E FINALIZAÇÃO DE OBJETOS ......................................................................... 109

Inicialização automática .................................................................................................. 109Inicialização de atributos de Instância ............................................................................ 109Inicialização de atributos de classe.................................................................................. 110Blocos de inicialização..................................................................................................... 110Ordem de inicialização .................................................................................................... 111Finalização de Objetos..................................................................................................... 112

CONVERSÃO DE OBJETOS....................................................................................................... 112EXCEÇÕES.............................................................................................................................. 113

Continuação após o Tratamento da Exceção................................................................... 115A hierarquia de Exceções................................................................................................. 115Capturando mais de uma exceção.................................................................................... 116Lançando exceções........................................................................................................... 117Comportamento do Sistema diante das Exceções ............................................................ 119Criando suas próprias exceções....................................................................................... 120A cláusula finally ....................................................................................................... 121

DOCUMENTANDO O CÓDIGO................................................................................................... 122Rótulos.............................................................................................................................. 122HTML embutida ............................................................................................................... 124

AGENDA ELETRÔNICA VERSÃO CONSOLE 1.0 ........................................................................ 125Capítulo V – Entrada e Saída (java.io) ...................... 132

ACESSO SEQUENCIAL............................................................................................................. 132ACESSO DIRETO..................................................................................................................... 137

Capítulo VI – java.util ..................................... 141LIDANDO COM COLEÇÕES...................................................................................................... 141

As Interfaces Iterator e Enumeration ................................................................... 141Vector ........................................................................................................................... 143Stack .............................................................................................................................. 146Hashtable .................................................................................................................... 148

MISCELÂNEA DE CLASSES DO PACOTE JAVA.UTIL................................................................. 151Arrays ........................................................................................................................... 151Date ................................................................................................................................ 154Observable .................................................................................................................. 156StringTokenizer ...................................................................................................... 160

AGENDA ELETRÔNICA VERSÃO CONSOLE 2.0 ........................................................................ 162Capítulo VII - Serialização e Persistência .................... 169

AGENDA ELETRÔNICA VERSÃO CONSOLE 2.1 ........................................................................ 171Capítulo VIII – AWT (Abstract Window Toolkit) ............... 174

A HIERARQUIA DE COMPONENTES ......................................................................................... 174OLÁ MUNDO AWT ................................................................................................................ 176TRATAMENTO DE EVENTOS ................................................................................................... 177

Java na Prática


3Modelo de Eventos 1.1 ..................................................................................................... 177Tratamento de Eventos com classes Internas................................................................... 181

EXEMPLO BÁSICO .................................................................................................................. 186ACRESCENTANDO CORES....................................................................................................... 190GERENCIANDO O LAYOUT...................................................................................................... 191

Exemplo com BorderLayout....................................................................................... 192Exemplo com FlowLayout ........................................................................................... 193Exemplo com CardLayout ........................................................................................... 194Exemplo com GridLayout ........................................................................................... 196Exemplo com GridBagLayout .................................................................................... 197

UTILIZANDO LISTAS............................................................................................................... 199TRABALHANDO COM MENUS E DIÁLOGOS............................................................................. 202CAPTURANDO EVENTOS DO TECLADO ................................................................................... 206PRINCIPAIS CLASSES.............................................................................................................. 206

Color .............................................................................................................................. 206Component .................................................................................................................... 208Button ........................................................................................................................... 210Label .............................................................................................................................. 211List ................................................................................................................................ 212TextField .................................................................................................................... 213TextArea....................................................................................................................... 214

CONTAINERS.......................................................................................................................... 215Panel .............................................................................................................................. 217Frame .............................................................................................................................. 218

AGENDA ELETRÔNICA VERSÃO GRÁFICA 1.0......................................................................... 221Capítulo IX - Applets ....................................... 227

DESCRIÇÃO DO CÓDIGO HTML ............................................................................................. 231MÉTODOS DA CLASSE APPLET............................................................................................... 232EXIBINDO UMA IMAGEM ........................................................................................................ 236ÁUDIO.................................................................................................................................... 239OBTENDO PARÂMETROS......................................................................................................... 240EXECUTANDO UM APPLET COMO APLICAÇÃO ........................................................................ 241PREPARANDO APPLETS PARA PRODUÇÃO E ARQUIVOS JARS ................................................. 242AGENDA ELETRÔNICA VERSÃO APPLET 1.0 ........................................................................... 244

Capítulo X JavaBean ......................................... 245O QUE É UM JAVABEAN? ....................................................................................................... 245JAVABEANS E FERRAMENTAS RAD ....................................................................................... 245PROPRIEDADES ...................................................................................................................... 246

Simples ............................................................................................................................. 246Indexada ........................................................................................................................... 247Ligada (Bound)................................................................................................................. 248Restringidas(Constrained) ............................................................................................... 249

EVENTOS................................................................................................................................ 251DESENVOLVIMENTO DO EXEMPLO ......................................................................................... 252

TimerEventListener .......................................................................................................... 252TimerEvent ....................................................................................................................... 253TimerBean ........................................................................................................................ 253

INSTALANDO O BEANS DEVELOPMENT KIT (BDK)................................................................ 257

Java na Prática


4TESTANDO EXEMPLO NO BDK............................................................................................... 257

Capítulo XI Perguntas Frequentes ............................ 264Bibliografia ................................................ 265Links ....................................................... 266Índice ...................................................... 268

Java na Prática


5

Capítulo I - IntroduçãoJava é uma linguagem de programação desenvolvida pela Sun

Microsystems 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

Java na Prática


6

estã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 aobjetos como Smalltalk, onde tudo é objeto ou métodos de objetos. Porquestões de eficiência foram mantidos alguns tipos primitivos e suasoperações. No entanto, Java possui um grau de orientação a objetos bemmaior que C/C++, o que a torna bem mais harmoniosa e fácil de assimilar,uma vez que o programador tenha compreendido esta forma dedesenvolvimento.

• Compilação do código fonte para código de uma máquina virtual(Bytecodes). Esta característica visa tornar a linguagem independente deplataforma de Hardware e Sistema Operacional. Obviamente é necessárioque exista um programa capaz de interpretar o código em Bytecodes paracada Sistema Operacional, denominado de Máquina Virtual. No entanto,nada impede que o código fonte seja traduzido diretamente para o códigoexecutável na máquina de destino. Já existem ambientes de desenvolvimentoque apresentam este tipo de opção. Alternativamente, é possível projetarequipamentos que processem em hardware os Bytecodes. A Sundesenvolveu um processador que executa operações em Bytecodes,denominado de JavaChip. O diagrama abaixo ilustra as etapas envolvidas naexecuçã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 comoC/C++ e Pascal existe o tipo ponteiro como tipo primitivo da linguagem. Aespecificação original de Pascal é restritiva no uso de ponteiros, permitindoque sejam usados apenas para referenciar memória obtida na área dealocação dinâmica (heap) e não permite que o programador examine o valor

Java na Prática


7

da variável do tipo ponteiro, nem que realize operações aritméticas componteiros. Já a linguagem C/C++ permite que o valor armazenado navariá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 deponteiros e o exame direto do valor armazenado. A manipulação do tipoponteiro exige uma grande dose de atenção por parte do programador emesmo programadores experientes frequentemente cometem erros no seuuso. Além disso, o uso de ponteiros é uma fonte de insegurança nalinguagem, uma vez que permite que o usuário faça acesso a memória quepode pertencer a outros processos, abrindo a possibilidade paradesenvolvimento de programas hostis ao sistema. A linguagem Java nãopossui o tipo ponteiro. Isto não que dizer que não seja possível realizaralocação dinâmica de memória. Todo objeto criado é alocado na área deheap, mas o usuário não pode manipular a referência ao objetoexplicitamente.

• Recuperação automática de memória não utilizada (Coleta de Lixo –Garbage Collection). Nas linguagens onde existe alocação dinâmica dememória, o programador é responsável pela liberação de memóriapreviamente obtida na área de alocação dinâmica e que não está sendo maisutilizada. Se houver falhas na execução desta responsabilidade ocorrerá oproblema 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 consigaobter memória para criação de novos objetos, apesar de existir área que nãoestá 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 permitemalocação dinâmica conhecem bem estes problemas e sabem o quanto é difícilimplementar programas que não possuam estes tipos de erros. A maior partedos erros que ocorrem no uso destas linguagens é devido a problemas naalocação/liberação de memória. Visando o desenvolvimento de aplicaçõesrobustas, livres deste tipo de falha, os projetistas de Java incorporaram umprocedimento de coleta automática de lixo à máquina virtual. Deste modo, osobjetos que não estão sendo mais usados são identificados peloprocedimento, que libera a memória para ser utilizada na criação de novosobjetos.

• Segurança. As pessoas costumam dizer que Java é uma linguagem segura.Mas o que é ser uma linguagem de programação segura? Segurança possuisignificados distintos para pessoas diferentes. No caso da linguagem Java na

Java na Prática


8

versão 1.0 segurança significa impedir que programas hostis que possamcausar danos ao ambiente computacional, ou que busquem informaçõessigilosas em computadores remotos para uso não autorizado. Na versão 1.1foi adicionada a capacidade de permitir a verificação da identidade dosprogramas (autenticação) e na versão 1.2 os dados que os programas enviame 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 deprogramas com interfaces gráficas, e programas semelhantes que tem emcomum a necessidade de que o atendimento de uma solicitação nãoincapacite o sistema de responder a outras solicitações concorrentemente,demandam o uso de uma linguagem que facilite o desenvolvimento destetipo de programa. As linguagens projetadas antes do surgimento destasnecessidades, como C/C++, não previam facilidades para este tipo deprogramação, o que obrigou a incorporação destes recursos posteriormente,por meio de funções adicionais. Como a programação concorrente é umaforma de programação que difere bastante da programação sequencialconvencional, a simples adição de novas funções para tentar adaptar alinguagem a esta forma de codificação, não cria um ajuste perfeito com alinguagem subjacente. Por outro lado, Java foi projetada visando facilitar aprogramação concorrente. Isto faz com que a criação linhas de execução(threads) seja bem mais natural dos que nas linguagenstradicionais.Programação em rede. Java possui em seu núcleo básicoclasses para comunicação em rede por meio dos protocolos pertencentes àpilha de protocolos TCP/IP. A pilha de protocolos TCP/IP é a utilizada pelaInternet e tornou-se o padrão de fato para comunicação entre computadoresem uma rede heterogênea. Isto torna Java particularmente atrativa para odesenvolvimento de aplicações na Internet. Além disso Java está incorporaum amplo de conjunto de soluções para computação distribuída, comoCORBA (Common Object Request Broker Architecture), RMI (RemoteMethod Invocation) e Servlets/JSP (aplicações Java que são executadas porservidores 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

Java na Prática


9

especí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.4 que pode ser obtida gratuitamente no site http://java.sun.com/.

Convenções

As 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 decó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.

Java na Prática


10

Capí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

Java na Prática


11

Subclasses. 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.

Java na Prática


12

type Classe_Retangulo = recordX1,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 = recordX1,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);

beginR.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.

Java na Prática


13

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 procedimentosque não foram projetados para a sua manipulação. É muito importanteque a linguagem forneça recursos para se implementar este tipo deisolamento. Se acessarmos uma estrutura apenas por meio dosprocedimentos projetados para este fim, quando a estrutura for alteradaapenas os procedimentos que manipulam a estrutura sofreriammodificações. No entanto, se não agirmos desta forma será necessárioprocurar em todo o programa os acessos diretos à estrutura. Claro queeste comportamento pode ser adotado em qualquer linguagem, mas émais seguro se a linguagem fornece meios para o programador forçareste tipo de comportamento. A capacidade de “esconder” a estrutura dedados de acessos diretos é chamada de ocultação de informação.

• Não existem recursos para herança de propriedades entre classes esubclasses. Se precisarmos implementar uma estrutura que é umaespecialização de outra já implementada, será preciso codificarnovamente todas as propriedades, mesmo as comuns, e todos osprocedimentos de acesso. Isto dificulta o reaproveitamento de código, oque, consequentemente aumenta o tempo de desenvolvimento e apossibilidade de erros.

• Não existe uma forma de relacionar explicitamente as estruturas de dadoscom os procedimentos que as manipulam. O relacionamento entre osprocedimentos que manipulam uma estrutura de dados e a estrutura éestabelecido implicitamente, por meio de alguma convenção definidapelo programador. É importante que a linguagem obrigue o programadorrelacionar explicitamente os procedimentos com a estrutura de dados, demodo 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 é

Java na Prática


14

objeto. 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;

Java na Prática


15

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;

Java na Prática


16X2 = 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.

Java na Prática


17

Sobrescrita, 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)

Java na Prática


18{

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.

Java na Prática


19

Introduçã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.

Java na Prática


20

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.

Java na Prática


21

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çãoPú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.

Java na Prática


22

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:

Java na Prática


23

Notação Descrição1 Exatamente um* ou 0..* Zero ou mais0..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.

Java na Prática


24

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.

Java na Prática


25

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.

Java na Prática


26

Capí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.

Java na Prática


27

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á

Java na Prática


28

gerado 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 o

1 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).

Java na Prática


29

primeiro 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álidoAluno10 Aluno#10Num_Alunos Num Alunos_disciplina$ !disciplinaProfessor_10 10Professorαβγ &uuuNã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

Java na Prática


30

Literais

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òu ´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 á` até ´f` ou Á` 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

Java na Prática


31

hexadecimal 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 0x100000000L

Literais 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+23f

Exemplos de literais do tipo double:

1e1 2. .3 0.0 3.14 1e-9d 1e137

Java na Prática


32

Literais 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.

Java na Prática


33

"\"" Uma cadeia com apenas o caractere "."esta é uma cadeia" Uma cadeia contendo 17 caracteres."esta é uma "+"cadeia "

Uma cadeia formada por dois literais dotipo 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:

( ) { } [ ] ; , .

Java na Prática


34

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

Java na Prática


35

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 Tamanhobyte 8 bitsshort 16 bitsint 32 bitslong 64 bits

Tabela III-6. Tipos inteiros.

Ponto Flutuante

Nome Tamanhofloat 32 bitsdouble 64 bits

Tabela III-7. Tipos de ponto flutuante.

booleanos

boolean {true,false}

Java na Prática


36

Caractere

char 16 bits

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

Exemplos

int numeros[];char[] letras;

Java na Prática


37

long 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

Java na Prática


38

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,int num)

Constrói uma nova String convertendo o subarray debytes especificado

String(StringBuffer buffer) Constrói uma nova String usando a sequência decaracteres contida no StringBuffer.

String(byte[] bytes) Constrói uma nova String convertendo o array debytes especificado

String(String valor) Constrói uma nova String com o mesmo conteúdoda 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,int num)

Constrói uma nova String convertendo o subarray decaracteres especificado.

Java na Prática


39

Tabela III-8. Principais construtores da classe String.

Método DescriçãocharAt(int indice) Retorna o caractere localizado no índice especificado.compareTo(StringoutraString)

Compara duas Strings lexicograficamente.

equals(Object anObject) Verifica se dois objetos são iguais.getChars(int srcBegin,int srcEnd, char[] dst,int dstBegin)

Copia os caracteres da String em um array decaracteres.

indexOf(String str) Retorna o índice da primeira ocorrência do substringno string.

indexOf(String str, intfromIndex)

Retorna o índice da primeira ocorrência do substringno string a partir do índice especificado.

indexOf(int ch, intfromIndex)

Retorna o índice da primeira ocorrência do caractereno string a partir do índice especificado.

indexOf(int ch) Retorna o índice da primeira ocorrência do caractereno string .

length() Retorna o comprimento do string.replace(char oldChar,char newChar)

Retorna uma nova String onde todos os caracteresoldChar foram substituídos pelos caracteresnewChar.

substring(int beginIndex) Retorna uma nova string que é substring da atual.substring(int beginIndex,int endIndex)

Retorna uma nova string que é substring da atual.

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.

Java na Prática


40

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 tipobyte charshort byte, charchar byte, shortint byte, short, charlong byte, short, char, intfloat byte, short, char, int, longdouble byte, short, char, int, long, float

Tabela III-10. Conversão de tipos que podem causar perda de informação.

Java na Prática


41

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 Classeint Integerfloat Floatdouble Doubleboolean Booleanbyte Byteshort Shortlong 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:

Java na Prática


42

= > < ! ~ ? :== <= >= != && || ++ --+ - * / & | ^ % << >> >>>+= -= *= /= &= |= ^= %= <<= >>= >>>=

Os operadores podem ser divididos nas seguintes classes.

Unários

Descrição SímboloIncremento ++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 abaixo

int 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

Java na Prática


43x = ~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 = 10y = 0++x = 11y++ = 0x = 11y = 1-x = -11~y = -2

Exemplo III-2. Uso dos operadores unários.

Binários

Descrição SímboloAdiçã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 <<

Java na Prática


44

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, ou

seja, 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;byte x = Y & 5;

é 1.O operador | realiza a operação lógica OU entre cada bit individual dos

operandos. Por exemplo, o valor da variável x após a execução do trecho decódigo

byte y = 3;byte x = Y | 5;

é 7.O operador ^ realiza a operação lógica XOU (ou exclusivo) entre cada bit

individual dos operandos. Por exemplo, o valor da variável x após a execução dotrecho de código

byte y = 3;byte x = Y & 5;

é 6.

y 000000114 00000101 &1 00000001

y 000000114 00000101 |7 00000111

y 000000114 00000101 ^1 00000110

Java na Prática


45

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 = 7y = -7x <<= 14x >> 2= 1y >> 2= -2y >>> 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

Java na Prática


46

não ocorre, devido ao fato da representação de números inteiros ser feita emcomplemento a dois.

Relacionais

Descrição SímboloMenor 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 = 7y = 8x < y = truex > 10 = falsey <= 8 = truey == 5 = falsex != y = true

Exemplo III-4. Uso dos operadores relacionais.

Java na Prática


47

Booleanos

Descrição SímboloE &OU |OU Exclusivo Ê 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 truetrue false false true true false true falsefalse true false true true false true falsefalse 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 falsefalse true

Tabela III-17. Operador de negação.

Java na Prática


48

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ímboloSimples =Adição +=Subtração -=Multiplicação *=Divisão /=Modulo %=AND &=OR |=XOR ^=

Java na Prática


49

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

Java na Prática


50

definida 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

Java na Prática


51

final 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;...{ int x =2;...}...

}}

escopo do x interno

escopo do x externo

escopo de y{ }

}}

Java na Prática


52

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

if (condição)comando1

elsecomando2

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

elsey+=6;

Exemplo III-7. Comando if.

Java na Prática


53

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;

Java na Prática


54

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

Java na Prática


55

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:

inseriralterarexcluirAçã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:

Java na Prática


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

Java na Prática


57int 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 é:

doComando;

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;

dox +=i++;

while(i<100);

Exemplo III-16. Soma dos 100 primeiros números inteiros com do-while.

Java na Prática


58

for

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.

Java na Prática


59

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.

Java na Prática


60

while (Condição){... fluxo retomado aquicontinue;...}...

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.

break e continue com rótulos

Diferentemente C/C++ Java permite o uso de rótulos após os comandosbreak e continue para permitir que a saída para mais de um nível de iteraçãoquando em laços aninhados. Rótulos correspondentes aos usados nos comandosbreak/continue devem ser posicionados imediatamente antes dos comandos delaços, seguidos do caractere ‘:’. O exemplo III-21 mostra o uso de rótulos paradesviar para um laço mais externo ao corrente. No caso do exemplo uma novaiteração do laço mais externo é iniciada quando o continue é executado.

public static boolean contemstr(String sub, String str){ prox: for (int i=0; i<=str.length()-sub.length(); i++) { for (int j=0; j<sub.length(); j++) if (str.charAt(i+j) != sub.charAt(j)) continue prox; return true; } return false;}

Exemplo III-21. Uso de comandos com rótulos.

Java na Prática


61

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ês

o 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

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-22 mostra um programa que imprime osargumentos recebidos, um em cada linha do dispositivo de saída.

public class ImpLinha{

Java na Prática


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

int i;for (i=0;i<args.length;i++)

System.out.println(args[i]);}

}

Exemplo III-22. 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-23 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-23. Imprimindo a soma dos números.

Assert (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 de

Java na Prática


63

Java, 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ântica

A formato geral de uma assertiva é:

assert<expressão booleana1>;

ou

assert<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.

O exemplo III-24 mostra um exemplo do uso de assertivas para garantirque uma determinada condição seja verdadeira.

... assert b > 0; int x = a/b;...

Exemplo III-24. Uso de assertivas.

Habilitando e Desabilitando Assertivas

Java na Prática


64

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.

Habilitaçã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 pordefault 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.

Java na Prática


65

Java na Prática


66

Capítulo IV Classes, Pac kages 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

Java na Prática


67

de 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çãoCada arquivo fonte Java é uma unidade de compilação. Ao compilar o arquivo fonte o

compilador irá gerar um arquivo .class para cada classe constante no arquivo. O nome decada arquivo será o nome da cada classe.

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

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.

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

Java na Prática


71

membros 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.

Java na Prática


72

Modificadores 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çãodefault Somente classes do mesmo package possuem acessopublic Todos possuem acessoprotected Apenas os membros da classe e subclasseprivate 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 escopo de pacote. Ou seja,não existe uma palavra reservada default. O acesso default determina que todasas classes dentro do mesmo package (pacote) podem acessar os membros daclasse corrente. 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;

...

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[]) {

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çãostatic 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{

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:

Java na Prática


76Valor 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();

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() {

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 Erro! A origem dareferência não foi encontrada..

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. Essa

Java na Prática


79

situação é melhor ilustrada graficamente, como pode ser visto na figura IV-1,onde é 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

nome null

Após a atribuição

n

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 com

Objeto

Objeto

Java na Prática


80

a 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.

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

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 resultanterecebem os valores dos atributos correspondentes no objeto original. Osobjetos referenciados pelo objeto original serão compartilhados peloobjeto resultante. A figura IV-2 ilustra este tipo de cópia. Note ocompartilhamento 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 tipode cópia pode ser bastante ineficiente. A figura IV-3 ilustra este tipo decópia.

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). A interface Cloneable não declara nenhum método,portanto, para implementar a interface basta apenas escrever Cloneable após apalavra reservada implements na declaração da classe, como mostrado noexemplo IV-12.

class Clonavel implements Cloneable{ int a[];

public Clonavel(int n) { a = new int[n]; } public void setElemento(int i, int el) { if (i < a.length) a[i] = el; } public int getElemento(int i) { if (i < a.length) return a[i]; else return 0; }

public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) {return null;} }}

public class CloneTeste

Java na Prática


83{ public static void main(String a[]) { Clonavel x1 = new Clonavel(2); x1.setElemento(0,1); x1.setElemento(1,2); Clonavel x2 = (Clonavel) x1.clone(); x1.setElemento(0,3); System.out.println("x1:"+x1.getElemento(0)+", "+ x1.getElemento(1)); System.out.println("x2:"+x2.getElemento(0)+", "+ x2.getElemento(1)); }}Saída

x1:3, 2x2:3, 2

Exemplo IV-12. Cópia rasa.

Além de implementar a interface é preciso sobrescrever o métodoclone() da classe Object, uma vez que este método é declarado com omodificador protected e portanto não é visível fora da linha hierárquica. Se oobjetivo for uma cópia rasa então basta invocar o método clone() da classeObject de dentro método que o está subscrevendo, como feito no exemploIV-12, por meio da palavra chave super. Note que é preciso capturar umaexceção que é lançada (a CloneNotSupportedException) caso a classe nãosuporte a clonagem (se não implementar a interface Cloneable). Note tambémque o método clone() da classe Object retorna um Object e, portanto, precisaser feita uma conversão explicita para o tipo apropriado.

Para demonstrar que o exemplo IV-12 implementa uma cópia rasa é feitoum teste onde são criados dois objetos, sendo um deles o clone do outro. A saídado programa mostra que ao alterarmos um objeto referenciado por um dos objetoque foram duplicados a alteração afeta o outro, uma fez que as referências sãocompartilhadas.

Se o usuário desejar realizar uma cópia profunda, então ele deve fornecero código necessário ao sobrescrever o método clone(). Neste caso ele deveinvocar os métodos clone() dos objetos referenciados. Esta pode ser uma tarefabastante complexa uma vez que um objeto pode referenciar vários objetos eestes podem referenciar outros objetos e assim sucessivamente, em uma longacadeia de referências. Além disso é preciso contar com o fato dos objetos

Java na Prática


84

referenciados terem sobrescrito o método clone(). O exemplo IV-13 mostracomo implementar uma cópia profunda para o exemplo anterior.

class Clonavel implements Cloneable{ int a[];

public Clonavel(int n) { a = new int[n]; } public void setElemento(int i, int el) { if (i < a.length) a[i] = el; } public int getElemento(int i) { if (i < a.length) return a[i]; else return 0; }

public Object clone() { Clonavel o = null; try { o = (Clonavel) super.clone(); } catch (CloneNotSupportedException e) {return null;} o.a = (int []) a.clone(); return o; }

}

public class CloneTeste{

public static void main(String a[]) { Clonavel x1 = new Clonavel(2); x1.setElemento(0,1); x1.setElemento(1,2); Clonavel x2 = (Clonavel) x1.clone(); x1.setElemento(0,3); System.out.println("x1:"+x1.getElemento(0)+", "+ x1.getElemento(1)); System.out.println("x2:"+x2.getElemento(0)+", "+ x2.getElemento(1));

Java na Prática


85 }}Saída

x1:3, 2x2:1, 2

Exemplo IV-13. Cópia profunda.

Note que no exemplo IV-13 a saída do programa mostra que aoalterarmos um objeto referenciado por um dos objeto que foram duplicados aalteração não afeta o outro, uma fez que as referências foram clonadas. Isso foipossível porque os arrays sobrescrevem o método clone(). E quanto às classesda biblioteca padrão do SDK? Elas sobrescrevem o método clone()? A respostaé: poucas sobrescrevem. Portanto, o programador deve estar atento e verificar seé possível invocar o método clone() de uma classe da biblioteca padrão ou seterá que proceder de outra forma.

O objeto this

Em algumas situações é necessário referenciar o próprio objeto corrente.Por essa razão todo objeto possui um atributo especial identificado por thisque é uma referência para o próprio objeto. O exemplo IV-14 mostra um usotípico do atributo this. Ele mostra um método cujo parâmetro formal possui omesmo 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-14. Exemplo de uso do atributo this.

Java na Prática


86

Outro uso típico e quando queremos passar a instância corrente comoargumento de um método. Como mostra o exemplo IV-15.

class X{ ...

public void mx(Y y) {

...; }}

class Y{ X x;

public void my() {

x.mx(this); ... }}

Exemplo IV-15. Exemplo de uso do atributo this como argumento.

No exemplo IV-15 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-se a colisão entre os nomes dasclasses. No caso dos métodos isso não é necessário, pois métodos com o mesmonome 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 o 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 foi

Java na Prática


87

baixada de outra máquina não possua o mesmo nome de uma classe local? Paracontornar todos estes problemas foram criados os Pacotes.

Usando Packages

Toda classe pertence a um pacote. No caso do programador não indicar aque pacote pertence a classe, o compilador irá assumir que a classe pertence aopacote default que é o diretório corrente. Para se usar uma classe definida emoutro package é preciso usar a palavra chave import seguida do nome daclasse qualificada pelo nome do pacote 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 o nomedo pacote toda vez que a classe for referenciada. Por exemplo, no caso da classeColor seria necessário qualificá-la da seguinte forma:

java.awt.Color

Existem dois pacotes que não precisam ser importados para que suasclasses possam ser usadas 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

Java na Prática


88

Para incluir uma unidade compilação em um pacote basta que oprogramador inclua a seguinte declaração no arquivo.

package nomepacote;

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 de ambienteclasspath indica os diretórios que servem como pontos de entrada para procurade 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. Paraindicar que unidade de compilação pertence a esse pacote devemos colocar adiretiva adequada no início do arquivo fonte, como mostrado no exemplo IV-16.

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-16. Indicando que uma classe pertence ao pacotebr.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:\JAVA\LIB;C:\meujavalib

Java na Prática


89

então o arquivo objetoGeo.class resultante da compilação do arquivoobjetoGeo.java pode ser colocado no diretório:

C:\meujavalib\br\com\alcione\geo

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 domínio (alcione.com.br) concatenado com o nome geo.

Por simplicidade, na maioria dos exemplos adotados neste livro,adotaremos o pacote default.

Empacotando packages em arquivos JARs

Um sistema pode possuir um grande número de classes organizadas empacotes. Essas classes espalhadas pela estrutura de diretório de um computadorpode se tornar um problema no momento da distribuição de uma aplicação. Omelhor seria organizar as classes em um único arquivo para poder serdistribuída. Para solucionar esses e outros problemas foi introduzido a partir daversã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 comum Applet estão agrupados em um único arquivo JAR, apenas uma transaçãoHTTP será necessária para carregar o Applet. Este tempo será ainda menorse 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

Java na Prática


90

privilégios para acessar recursos que não estariam disponíveis, casocontrário.

• Portabilidade: a API para manipulação dos arquivos JAR é parte integrantedo núcleo da biblioteca de classes de Java, o que a torna independente deplataforma.

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 SDKvem 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-entrada

onde destino é o nome do arquivo, arquivo(s)-de-entrada representa o nomedos arquivos que serão incluídos no arquivo JAR e opções é uma coleção deletras com o seguinte significado:

Opções Descriçãoc 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 jarassume que saída ou a entrada será a padrão.

m Indica que o primeiro argumento será o nome de um arquivo manifest criadopelo 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.

Tabela IV-3. Opções para uso do comando jar.

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.

Java na Prática


91

Para invocar uma aplicação armazenada em um arquivo JAR é necessáriopassar o nome do arquivo JAR como parâmetro. Na versão JDK1.1 é precisousar o comando jre no lugar do comando java. Por exemplo, suponha quearmazenamos uma aplicação, cuja classe principal é Mainclass, em um arquivoarq.jar. Para executá-la basta digitar o comando:

jre -cp arq.jar Mainclass

onde a opção cp indica que o arquivo arq.jar deve ser anexado ao classpath.Já na versão SDK1.2 usa-se o comando java, sendo que o arquivo JAR deveconter um arquivo 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.jarcontendo todos os arquivos de classes do diretóriocorrente. Um arquivo manifest é geradoautomaticamente.

jar cmf meuarq.jarmeuManifest.mf *.class

Como o exemplo anterior, porém o arquivo manifestmeuManifest.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 IV-4. Exemplos do uso do comando jar.

O arquivo manifest é um arquivo de texto onde cada linha possui pardiretiva-valor no formato:

<diretiva>:<valor>

As diretivas dependem da versão do SDK. Por exemplo, na versão 1.2 aclasse principal é indicada por meio da diretiva Main-Class, como mostradoabaixo:

Main-Class: nome da classe

Criando os próprios arquivos manifest

Java na Prática


92

Os arquivos manifest são criados automaticamente. O conteúdo originalde um arquivo manifest criado pelo SDK 1.3 é:

Manifest-Version: 1.0Created-By: 1.3.0 (Sun Microsystems Inc.)

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 onde cada linha épar diretiva-valor. Por exemplo se o usuário quiser especificar que a classe quedeve ser usada como ponto de entrada é a classe Mainclass, então basta inserir aseguinte linha no arquivo de adições:

Main-Class: Mainclass

O Mecanismo de Extensão

A partir da versão 1.2 a linguagem Java introduziu um mecanismo paraadicionar classes ao núcleo básico da linguagem, sendo uma alternativa ao usoda variável de ambiente classpath. Este mecanismo é chamado de Mecanismode Extensão. O mecanismo de extensão também oferece suporte para envio declasses pela rede para uso em Applets. As extensões são agrupadas em arquivosJAR. Uma vez feito isso, pode-se transformar as classes em extensõesutilizando-se uma das duas formas:

1. Extensão Instalada – colocando o arquivo JAR em um localpredeterminado na estrutura de diretórios do ambiente de tempo deexecução de Java (Java Runtime Environment ou JRE).

2. Extensão de download –Extensão referenciando o arquivo JAR de umaforma específica, a partir do manifest de outro arquivo JAR.

Extensão Instalada

Java na Prática


93

Para incluir uma nova classe ou pacote no núcleo básico da linguagembasta colocar o arquivo JAR que contém a classe no diretório /lib/ext doambiente de tempo de execução. O diagrama mostrado na figura IV-4 mostra alocalização deste diretório dentro da estrutura de diretórios do ambiente Java.

Figura IV-4. localização do diretório ext dentro da estrutura de diretóriosJava.

Por exemplo, suponha que desejamos acrescentar o pacote do exemploIV-16 como uma extensão da linguagem Java no ambiente local. Para issodevemos criar primeiro o arquivo JAR. No ambiente DOS o comando seria oabaixo, executado no diretório acima do diretório /br:

jar cvf geo.jar br\com\alcione\geo\objetoGeo.class

Após isso colocaríamos o arquivo geo.jar dentro do diretório /ext.Para se 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 queexistem dois arquivos JAR, x.jar e y.jar, localizados no mesmo diretório.

Java na Prática


94

Para tornar o arquivo y.jar uma extensão do arquivo x.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árioindicar o caminho relativo até o arquivo da extensão. É possível indicar váriasextensões, separando-as por espaço ou usando várias diretivas Class-Path. Paraindicar um diretório como extensão basta adicionar o sufixo ‘/’ ao nome dodiretório. Por exemplo:

Class-Path: meudir/

Derivando classes

O reuso de componentes de programas é uma das principais metas dosprojetistas de linguagens de programação. A razão deste objetivo é 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 e métodos da classe base ou superclasse.Por exemplo, suponha que alguém tenha definido uma classe para representar osdados de uma conta bancária:

Figura IV-5. 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

Java na Prática


95

atributos 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. A conta especialpossui todos os atributos de uma corrente e mais um atributo contendo o valor delimite 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 à 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-17 mostra o códigoJava correspondente.

Figura IV-3. Relação entre as classes.

public class Conta{ protected long numero; protected long cpf; protected double saldo;

public Conta(long n, long c, double s) { numero = n; cpf = c; saldo = s; }

Java na Prática


96 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{ private Date dataAber;

public CPoupanca(long n, long c, double s, Date d) { super(n,c,s); dataAber = d; } public Date getData(){return dataAber;}}

public class CEspecial extends Conta{ private 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-17. Implementação das Classes com herança.

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

Java na Prática


97A capacidade de possuir mais de uma superclasse é chamada de herança múltipla. A

linguagem 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

Podemos notar também que nos construtores das subclasses do exemploIV-17 existem chamadas 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 é araiz 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(Objectobj)

Verifica se dois objetos são iguais. Averificação é feita sobre o endereço do objeto .

public final native ClassgetClass()

Retorna a classe do objeto em tempo deexecução.

public native int hashCode() Retorna o valor hash do objeto.public final native voidnotify()

Notifica um thread que está esperando sobre omonitor do objeto.

public final void notifyAll() Notifica todos os threads que está esperandosobre o monitor do objeto.

public String toString() Retorna uma representação em String do

Java na Prática


98

objeto.public final void wait() Espera no monitor do objeto para ser

notificado por outro thread.public final void wait(longtimeout)

Espera no monitor do objeto para sernotificado por outro thread.

public final void wait(longtimeout, int nanos)

Espera no monitor do objeto para sernotificado por outro thread.

Métodos Protegidos Descriçãoprotected native Object clone() Cria uma cópia rasa do objeto corrente.protected void finalize() Chamado pelo coletor de lixo antes de liberar a

área de memória.

Tabela IV-5. Métodos públicos e protegidos da classe Object.

Sobrescrita e Polimorfismo

Outro ponto interessante que podemos observar no exemplo IV-17 é quea classe CEspecial possui um método com a mesma assinatura que um métododa superclasse. É o método getSaldo() que no caso da classe CEspecial deveincluir 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 invocado dentrode algum método da classe CEspecial ou for chamado por meio de um objetoda classe CEspecial o método chamado será o declarado na classe e não odeclarado na superclasse. No entanto, é possível invocar o método declarado nasuperclasse de dentro de algum método da subclasse, bastando qualificar ométodo com a palavra chave super como mostrado abaixo:

super.getSaldo();

Por exemplo, o método getSaldo() da classe CEspecial poderia serreescrito da seguinte forma:

public double getSaldo(){ return super.getSaldo()+limite;}

Suponha agora uma classe como mostrada no exemplo IV-18. 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 classe

Java na Prática


99

CEspecial é 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[]) { TestaConta testa = new TestaConta(); CEspecial c= new CEspecial(1, 123456, 500.0, 100.0); testa.imprimeSaldo(c); }}

Exemplo IV-18. 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-18 seja feita 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 (ou vinculação). Se estemomento ocorre em tempo de compilação a amarração é dita estática (staticbinding). Se associação ocorre em tempo de execução a amarração é ditadinâmica (dynamic binding). Assim, na linguagem Java, em se tratando daassociação da chamada do método ao código do método, a amarração édinâmica. A única exceção é se o método for declarado como final. Neste casoa amarração é estática porque não é possível sobrescrever 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(), nenhuma

Java na Prática


100

modificação precisaria ser feita em métodos como o imprimeSaldo() da classeTestaConta, uma vez que o método correto sempre é chamado. Portanto,podemos ampliar a hierarquia de um conjunto de classes sem precisar alterar, namaioria 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 classe aqual o objeto realmente pertence.

Amarração Dinâmica em C++Apesar da amarração dinâmica entre os identificadores dos métodos e o corpo dos

mé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. Caso o programador desejeque os métodos possuam amarração dinâmica então deve instruir o compilador explicitamenteprefixando os métodos com a palavra-chave virtual. A razão para esta decisão dos projetistasda linguagem 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-19 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();}}

Java na Prática


101

Exemplo IV-19. Classes de vozes dos animais.

No exemplo IV-19 o método falaAnimal() da classe UsaAnimal recebequalquer subclasse da classe Animal é invoca o método fala() da subclasse.Para incluir mais um animal na hierarquia basta declarar mais uma subclasse:

public class Pato extends Animal{ public void fala(){System.out.println(“Quá Quá!”);}}

Exemplo IV-20. 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-21. Classe com a voz do pato.

Podemos observar que a classe Animal propriamente dita não faz nada anã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 será tratado na próxima seção.

Classes e Métodos Abstratos

Classes abstratas são esquemas ou esqueletos de classes. Uma classeabstrata não pode ser instanciada e possui um ou mais métodos abstratos. Ummétodo abstrato é um método sem corpo cuja assinatura é precedida da palavra-chave abstract. As subclasses de uma classe abstrata precisam sobrescrever osmétodos abstratos, caso contrário também serão abstratas e não poderão serinstanciadas.

A classe Animal do exemplo IV-19 é uma ótima candidata à classeabstrata. Para torná-la uma classe abstrata basta preceder a declaração da classe

Java na Prática


102

com a palavra chave abstract e declarar como abstratos os métodos que sedeseje tornar abstratos, como mostra o exemplo IV-22.

abstract public class Animal{ abstract public void fala();}

Exemplo IV-22. 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 interface não é usada como superclasse de outras classes. Umainterface é implementada por outras classes. A classe que implementa umainterface precisa fornecer uma implementação para todas os métodos definidosna Interface. Para que uma determinada classe seja vista como umaimplementação de uma interface é preciso indicar isto colocando a palavra chaveimplements na declaração da classe e após a palavra chave a lista com o nomede todas as interfaces que se deseja implementar, separados por vírgula. Oesquema abaixo mostra a forma geral do uso de interfaces.

class Identificador implements Interface1, Interface2,...{

corpo da classe}

Java na Prática


103

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 classeimplemente tantas interfaces quantas se desejar. Desta forma Java evita osprincipais problemas da herança múltipla (herdando múltiplas declaraçõ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-23 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-23. Classe que recebe um objeto de interface.

Suponha também que deseja-se que o programa tenha tanto uma interfacecom o usuário em modo gráfico como em modo texto. Usaremos de agora emdiante as iniciais IU para significar interface com o usuário para evitar aconfusão com o conceito de interfaces que estamos introduzindo. Se deseja-seque 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 deve herdar de uma classe como a Frame e da classe InterUsuario. Asolução é simples. Basta definir InterUsuario como uma interface comomostra o exemplo IV-24.

Java na Prática


104

interface InterUsuario{ abstract public void exibeMensagem(String men);}

Exemplo IV-24. Definição de como InterUsuario interface.

Agora basta que cada classe que representa um tipo de IU implemente ainterface InterUsuario. O exemplo IV-25 mostra a implementação de uma IUgráfica simples e o exemplo IV-26 mostra a implementação de uma IU em modotexto 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-25. IU gráfica.

public class Console implements InterUsuario

Java na Prática


105{ public void exibeMensagem(String men) { System.out.println(men); }}

Exemplo IV-26. IU em modo texto.

O exemplo IV-27 mostra uma forma de uso das classes definidas nosexemplos de IV-24 a IV-26.

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-27. 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 asassinaturas dos métodos sendo que a implementação dos mesmos pode ser feitaposteriormente. Isto permite separar a especificação do uso de uma classe (o queela faz) de sua implementação (como ela faz), reduzindo a complexidade datarefa de implementação e permitindo uma melhor divisão de tarefas. Noentanto, 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

Java na Prática


106

A partir da versão 1.1 da linguagem Java foi incluída a permissão paradefinir uma classe dentro da definição de outra. As classes declaradas dentro deoutras são denominadas de Classes Internas. O exemplo IV-28 mostra umesquema contendo o posicionamento relativo de uma classe interna.

public class Externa{ ... class Interna { ... }}

Exemplo IV-28. 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 externa se forem declarados como públicos.

Como já foi dito as classes mais externas (nível topo) só podem serdeclaradas como públicas ou com escopo de pacote (default). No entanto, asclasses internas também podem receber os qualificadores private e protected.O efeito destes qualificadores sobre a visibilidade da instância da classe é omesmo obtido sobre um atributo qualquer. O exemplo IV-29 mostra o caso deuma classe contendo uma classe interna privada.

public class Calc{ Incrementa inc1, inc5; private int num; public Calc () { inc1=new Incrementa(1); inc5=new Incrementa(5); }

private class Incrementa { int i; public Incrementa(int ai){i=ai;} public int inc(){return i+num;} } public int calcula(){return inc1.inc()+inc5.inc();}

Java na Prática


107}

Exemplo IV-29. Uso de classes internas.

A inclusão de classes internas foi uma modificação a nível de linguagemmotivada pelo modelo de eventos proposto a partir da versão 1.1. Neste modelo,como poderá ser constatado no capítulo que trata sobre a AWT, as classesinternas se ajustam perfeitamente. O exemplo IV-30 mostra o uso de uma classeinterna para capturar eventos. Este tipo de uso será tratado com maiores detalhesno capítulo 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-30. 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 é

Java na Prática


108

avaliada. O exemplo IV-31 mostra o retorno de um objeto de uma classeanônima.

public class TesteAnonima{ public Object retAnon() { return new Object() { // Definição da classe anônima private int i=10; public int value(){return i;} }; }}

Exemplo IV-31. Retorno de um objeto de uma classe anônima.

Pode parecer pelo exemplo IV-31 que o objeto retornado é uma instânciada classe Object, no entanto, na verdade é uma instância de uma classe anônimaque é subclasse da classe Object. A classe anônima possui atributos e métodospróprios que a diferenciam da classe Object e estão definidos na declaração daclasse. Usamos a classe Object apenas para exemplificar com uma classeconhecida. Qualquer classe pode fazer o papel de superclasse. O exemplo IV-32mostra o uso de uma classe anônima na criação de um objeto para lidar comeventos sobre um botão.


public class BT extends Frame{ Button bt; public BT()

{ bt = new Button(“OK”); bt.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { dispose(); } });

}}

Java na Prática


109

Exemplo IV-32. 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.

Inicialização e Finalização de Objetos

Inicialização automática

A inicialização automática de variáveis em Java se dá de duas formas:

1. Variáveis locais a métodos – nenhuma inicialização automática érealizada. O compilador checa se as variáveis foram inicializadasantes do seu uso.

2. Variáveis de instância ou de classe – tipos numéricos e caracteresão inicializados com zeros (caso o caractere seja impresso a saídaserá um espaço), tipo booleano é inicializado com false ereferências são inicializadas com null.

Inicialização de atributos de Instância

Existem dois lugares onde os atributos de instância podem serinicializados: dentro do construtor ou na declaração do atributo. O exemploIV-33 mostra estes dois tipos de inicialização. O atributo a é inicializado nadeclaração e o atributo b é inicializado no construtor.

public class ExInicia{ int a = 10; // inicializa o atributo a

int b; public ExInicia()

{ b = 20; // inicializa o atributo b

}}

Java na Prática


110

Exemplo IV-33. Tipos de inicialização de atributos de instância.

Qual é a diferença entre os dois tipos de inicialização? A primeiradiferença é que os construtores são parametrizados e, portanto, a inicializaçãocom construtor pode variar conforme os parâmetros passados. A segundadiferença é que a inicialização no construtor é feita após a inicialização nadeclaração.

A inicialização pode ser realizada com o uso de invocação de métodos ecom o uso de outros atributos, desde que já tenham sido inicializados.

Inicialização de atributos de classe

A inicialização das variáveis de classe não pode ocorrer dentro dosconstrutores, uma vez que o construtor pertence ao objeto e não à classe. Outradiferença é que a inicialização só ocorre uma vez, já que existe apenas umaversão atributo. A inicialização ocorre quando o primeiro objeto é criado.

Blocos de inicialização

Java permite que as inicializações de atributos, tanto de classe como deinstâncias de classe sejam agrupadas em blocos. O exemplo IV-34 mostra o usode blocos de inicialização.

public class ExBlocoInicia{ static int a;

static int b; int c;

int d;

static { a = 10; b = 20; }

{ c = 30;

d = 40;}

}

Java na Prática


111

Exemplo IV-34. Uso de blocos de inicialização.

Note que o bloco que inicia os atributos de instância é precedido pelapalavra reservada static.

Ordem de inicialização

Como já foi dito a inicialização na declaração é feita antes dainicialização no construtor. E no caso da herança? O que é inicializado primeiro?A classe ou a superclasse? Nesse caso a superclasse é inicializada primeiro.Mesmo que não ocorra uma invocação explícita ao construtor da superclasse échamado o construtor default. O exemplo IV-35 mostra a seqüência deinicialização em uma herança.

class X{ public X() { System.out.println("X foi inicializada!"); }}

public class Y extends X{ public Y() { System.out.println("Y foi inicializada!"); } public static void main(String a[]) { new Y(); }}Saída:

X foi inicializada!Y foi inicializada!

Exemplo IV-35. Sequência de inicialização em herança.

Java na Prática


112

Finalização de Objetos

Com a linguagem Java não existe a preocupação de liberar a memória,como é o caso de C/C++, uma vez que os objetos que não estão sendoreferenciados são coletados automaticamente pelo coletor de lixo. No entanto,como Java pode invocar uma função de C/C++ por meio de uma chamadanativa, e como esta função pode alocar memória que não será devolvida pelocoletor de lixo, então pode ser necessária alguma forma de devolverexplicitamente esta memória quando o objeto for coletado. Para esses casos aprogramador deve prover o método finalize(), que será invocado quando oobjeto for coletado. O método finalize() não é para ser chamadoexplicitamente. Ele é invocado pela máquina virtual antes de devolver amemória usada pelo objeto. Nele o programador deve devolver a memóriaalocada por métodos nativos e associada ao objeto.

Conversão de Objetos

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ão inversasó é possível se o objeto for realmente do tipo da subclasse e, mesmo assim, épreciso utilizar um operador de conversão forçada (casting):

Object o;String s = “teste”;String t;o = s;t = (String) o;

Java na Prática


113

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, provavelmentea interrupção do programa, ou no mínimo do comando onde ocorreuo erro, e a exibição de uma mensagem ininteligível na saída padrão,gerada pelo sistema. Esta é abordagem mais simples, mas certamentenão é a mais interessante, principalmente do ponto de vista do usuáriofinal.

2) Retornar o código de erro. No caso da linguagem Java este retornosó pode ser feito via valor de retorno da função. No entanto algumasvezes não existem valores disponíveis para indicar o erro. Porexemplo, quando um método retorna um valor inteiro costuma-seusar os valores 0 ou –1 para sinalizar uma condição de erro, mascomo agir no caso desses e todos os outros valores de inteiros seremvalores válidos em uma execução normal? Existe ainda o problemade que esta abordagem não resolve o problema de erros que ocorremnos construtores. Como os construtores não retornam valores não épossível sinalizar erros dessa forma. Esta é uma abordagem muitocomum entre os programadores de C e Pascal, e é ainda usada pelosprogramadores de C++. No entanto, as linguagens mais modernascomo C++ e Java disponibilizam recursos que permitem um melhortratamento de exceções, como veremos na terceira abordagem.

3) Declarar um ou mais tratadores de exceções. Um tratador deexceção é uma parte do código que tem por objetivo recuperar aexecução do programa após a ocorrência da exceção, permitindo queo sistema se comporte “suavemente”, mesmo sob condições adversas.A sintaxe e semântica dos tratadores de exceção variam muito delinguagem para linguagem, mas tem tendido a uma certauniformização nas linguagens mais modernas. A linguagem Java, porter como objetivo ser uma linguagem segura, obriga que os

Java na Prática


114

programadores capturem todas as exceções, menos as derivadas daclasse 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}

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 trataas exceções não tem acesso às variáveis declaradas dentro do bloco try{}, umavez que o escopo destas variáveis está delimitado pelo bloco. O exemplo IV-36mostra um bloco para capturar a exceção NumberFormatException que pode serlançada pelo método estático parseInt() da classe Integer se o métodoreceber como argumento uma cadeia de caracteres que não pode traduzido parauma representação inteira. Note que a variável i não pode ser acessada dentro dobloco catch, uma vez que foi declarada dentro do bloco try.

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

Java na Prática


115

Exemplo IV-36. Capturando a exceção NumberFormatException.

Continuação após o Tratamento da Exceção

Se o bloco catch não possuir nenhum comando return, throw oualguma chamada à função exit(), então o programa é reassumido após o últimobloco catch. O caso de relançamento de exceções (throw) será tratado maisadiante.

A hierarquia de Exceções

As exceções são objetos que pertencem a classes que estão organizadasem uma hierarquia. A classe que se encontra no topo da hierarquia é a classeThrowable. A classe Throwable possui duas subclasses: Exception e Error.Exception e suas subclasses são usadas para indicar condições que podem serrecuperadas. Error e suas subclasses indicam condições que em geral nãopodem ser recuperadas, causando a terminação do programa.

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 das classes RuntimeException. A RuntimeException ésuas subclasses definem as exceções que podem ser lançadas durante a execuçãonormal da máquina virtual, como divisão por zero ou indexação fora dos limitesdo array. A exceção NumberFormatException mostrada no exemplo é umasubclasse da RuntimeException. Como essas exceções podem ser lançadas porum número muito grande de métodos, seria trabalhoso para o programador se elefosse obrigado a incluir código para capturar todas essas exceções. Portanto,instâncias da classe RuntimeException e suas subclasses não precisam sercapturadas. A Figura IV-4 mostra uma parte da hierarquia Throwable até o nível3. O programador pode também adicionar classes a esta hierarquia comoveremos mais adiante.

Java na Prática


116

Figura IV-4. Hierarquia parcial das exceções.

Capturando mais de uma exceção

Um método pode lançar mais de uma exceção, assim como pode existirmais de um método dentro de um bloco try/catch com potencial de lançarexceções. Portanto, muitas vezes é preciso definir um bloco try/catch comcapacidade de tratar mais de uma exceção. Isto é feito por meio da definição demais de uma cláusula catch. Cada cláusula catch trata uma exceção. Como abusca pela cláusula catch que deve tratar uma determinada exceção é feita decima para baixo é preciso tomar o cuidado de posicionar as o tratamento dasexceções mais genéricas mais abaixo do que o tratamento das exceções maisespecíficas. Caso contrário o tratamento das exceções mais especificas nuncaserá executado. O exemplo IV.xx mostra um trecho de código cujo blocotry/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[])

Java na Prática


117 { 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:

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>{

}

Java na Prática


118

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 omé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); }}

Java na Prática


119

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

m1

m2

m3

public class Excecao5{ public void m1(int i) { try { m2(i) }catch (Exception e){...}; ... }

public void m2(int i) throws Exception { m3(i); }

public void m3(int i) throws Exception { if (i == 0 ) throw new Exception(); System.out.println(2/i); }}

ocorrênciada exceção

tratamentoda exceção

Java na Prática


120

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

Java na Prática


121

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.”);} }}

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.

Java na Prática


122

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 comandosde documentação; ou

2. por meio de código HTML embutido.

Ró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

Java na Prática


123

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> <descrição>

Usado para incluir informação sobre aexceção que pode ser lançada pelométodo.

@deprecated Incluído a partir da versão 1.1. Indicaque o método pode não ser mantidonas 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.

Java na Prática


124/** Pessoa Mantem os dados pessoais de uma pessoa. @author Alcione de Paiva Oliveira @author [email protected] @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

@return uma String contendo o endereço */

public String getEnd(){return End;}}

Exemplo IV.XX- Exemplo de documentação.

HTML embutida

Java na Prática


125

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 gerar adocumentação. Não use rótulos de títulos como <h1> ou <hr>, uma vez que ojavadoc 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óriapermanente, 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.

Java na Prática


126

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.

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

AgendaInt

+obterPessoa()+exibirLista()+exibirPessoa()

Agenda

+inserir(pessoa p)+pessoas getPessoas()+Pessoa getPessoa(String Nome)

Pessoa

-String Nome-String Tel-String End

+getNome()+getTel()+getEnd()

0..*

Java na Prática


127{

private String Nome;private String Tel;private String End;

// Construtorpublic 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[];

// Construtorpublic Agenda() {pessoas = null;}

// Metodos/**

inserir*/public void inserir(Pessoa p){

if (pessoas == null) pessoas = new Pessoa[1];else AumentaCapacidade();

pessoas[pessoas.length-1] = p;}

Java na Prática


128/**

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.

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 um novoarray 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.

Java na Prática


129

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.

/**AgendaIntInterface console da agenda.

*/

import java.io.*;

public class AgendaInt{

Agenda ag;BufferedReader in;

// Construtorpublic AgendaInt(){

ag = new Agenda();in = new BufferedReader(new

InputStreamReader(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()+"\nTelefone:"

+p[i].getTel()+"\nEndereço:"+p[i].getEnd()+"\n");}

/**exibirPessoa

*/public void exibirPessoa(){

String nome=null;

try {System.out.println("Entre com o nome:");nome = in.readLine();

Java na Prática


130if (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[]){ AgendaInt agInt = new AgendaInt(); String opcao="";

for(;;) {

System.out.println("\nAgenda Tabajara\n***********************\n");System.out.print("Opcoes:\n(i)nserir\n(c)onsultar\n(l)istar\n(f)im=>"

);try { opcao = agInt.in.readLine();

Java na Prática


131 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 o uso destasclasses, que será abordado no próximo capítulo. No momento basta observarmosque a entrada de dados será realizada por meio do método readLine(), queretorna a linha digitada pelo usuário.

Java na Prática


132

Capítulo V – Entrada e Saí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.

CCaammaaddaa nn

CCaammaaddaa 1

CCllaassssee II//OOBBáássiiccaa

NNíívveellddoosssseerrvviiççooss

Java na Prática


133

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.

Figura V.3 Comparação entre as classes de entrada.

SSttrriinnggBBuuffffeerrIInnppuuttSSttrreeaammBByytteeAArrrraayyIInnppuuttSSttrreeaammPPiippeeddIInnppuuttSSttrreeaammFFiilleeIInnppuuttSSttrreeaammIInnppuuttSSttrreeaamm

iinnttssffllooaattss

SSttrriinnggeettcc..

bbyytteess

FFiilltteerrIInnppuuttSSttrreeaammDDaattaaIInnppuuttSSttrreeaammBBuuffffeerreeddIInnppuuttSSttrreeaammLLiinneeNNuummbbeerrIInnppuuttSSttrreeaamm


SSttrriinnggeettcc..

ccaarraacctteerreePPiippeeddRReeaaddeerrCChhaarrAArrrraayyRReeaaddeerrSSttrriinnggRReeaaddeerrFFiilleeRReeaaddeerrRReeaaddeerr

FFiilltteerrRReeaaddeerrBBuuffffeerreeddRReeaaddeerrLLiinneeNNuummbbeerrRReeaaddeerr

Java na Prática


134

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.*;

class TesteIO101{ public static void main(String a[])

import java.io.*;

class TesteIO111{ public static void main(String a[])

BByytteeAArrrraayyOOuuttppuuttSSttrreeaammPipedOutputStreamFileOutputStreamOutputStream


SSttrriinnggsseettcc..

bbyytteess

FFiilltteerrOOuuttppuuttSSttrreeaammPrintStreamDataInputStreamBufferedOutputStream


SSttrriinnggsseettcc..

ccaarraacctteerreePPiippeeddWWrriitteerrCharArrayWriterStringWriterFileWriterWriter

FilterWriterBBuuffffeerreeddWWrriitteerrPPrriinnttWWrriitteerr

Java na Prática


135 { try { DataInputStream in = new DataInputStream( new BufferedInputStream( new FileInputStream(a[0]))); String str; while((str = in.readLine())!= null) System.out.println(str); } catch(IOException e) { System.out.println(e.getMessage());} }}

{ try { BufferedReader in = new BufferedReader( new FileReader(a[0])); String str; while((str = in.readLine())!= null) System.out.println(str); } catch(IOException e) {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 mensagem

The 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.*;

class TesteIO102{ public static void main(String a[]) { try { PrintStream out = new PrintStream( new BufferedOutputStream( new FileOutputStream("saida.out"))); out.println("Linha de teste 1"); out.println("Linha de teste 2"); out.close();

import java.io.*;

class TesteIO112{ public static void main(String a[]) { try { PrintWriter out = new PrintWriter( new BufferedWriter( new FileWriter("saida.out"))); out.println("Linha de teste 1"); out.println("Linha de teste 2"); out.close();

Java na Prática


136 }catch(IOException e) { System.out.println(e.getMessage());} }}

}catch(IOException e) { System.out.println(e.getMessage());} }}

Exemplo V.2 – Escrita não formatada em arquivos.

a) Streamsimport 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 DataReader eDataWriter, somos obrigados a usar o conjunto antigo de classes para realizar aleitura 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. Comoessas variáveis referenciam a objetos das classes InputStream eOutputStream, se desejarmos manipular os dispositivos de E/S padrões com oconjunto de classes novos devemos utilizar as classes tradutorasInputStreamReader e OutputStreamWriter, como mostrado no exemplo V.4.

import java.io.*;

Java na Prática


137

public 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 IOExceptionpublic RandomAccessFile(String name, String mode) throws IOException

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á

Java na Prática


138

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 que permitemdefinir a posição corrente no arquivo e estabelecer onde será lido/escrito opróximo dado. A tabela V.1 mostra os métodos da classe RandomAccessFile.

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, intoff, int len)

Lê até len bytes em um array de bytes.

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 byte.readChar() Lê um caracter Unicode.readDouble() Lê um double.readFloat() Lê um float.readFully(byte[] b,int off, int len)

Lê exatamente len bytes no array byte.

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.readShort() 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

Java na Prática


139

onde será feita a próxima leitura/escrita.skipBytes(int n) Salta exatamente n bytes.write(int b) Escreve um byte.write(byte[] b, intoff, int len)

Escreve len bytes do array iniciando em off.

write(byte[] b) Escreve b.length bytes do array.writeBoolean(booleanv)

Escreve um boolean como um valor 1-byte.

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(doublev)

Escreve um double como um valor de 8-bytes.

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); } try { RandomAccessFile f = new RandomAccessFile(args[0], "r"); long tam = f.length(); if (tam==0)

Java na Prática


140 { 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.

Java na Prática


141

Capí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

Java na Prática


142

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

Java na Prática


143}

Vector

public 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.

Hierarquia

java.lang.Object | +--java.util.AbstractCollection | +--java.util.AbstractList | +--java.util.Vector

Construtores

Construtor 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, int inc)

Constrói um Vector vazio com espaço inicialpara iniCapac elementos e incremento inc.

Tabela VI.3 – Construtores da classe Vector.

Java na Prática


144

Atributos

Atributo Descriçãoprotected int capacityIncrement Quantidade que é incrementada à

capacidade do Vector toda vez que otamanho 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(Objecto)

Adiciona um elemento no final do Vector.

public boolean addAll (Collection c)

Adiciona todos os elementos da coleção especificadano final do Vector.

public void addElement(Object o)

Adiciona um elemento no final do Vector.

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 contains(Object o)

Testa se o objeto é um elemento do Vector.

public booleancontainsAll(Collection c)

Retorna true se o Vector contém todos oselementos referenciados por c.

public void copyInto (Object[] a)

Copia os elementos do Vector no array.

public Object elementAt(int i)

Retorna o elemento na posição i.

public Enumerationelements()

Retorna um objeto do tipo Enumeration quepermite percorrer os elementos do Vector.

public voidensureCapacity(int min)

Aumenta a capacidade do Vector para o valor min.

public booleanequals(Object o)

Compara se o é igual ao Vector. Retorna truesomente se o objeto é também do tipo List, possui omesmo tamanho e referencia os mesmos elementos namesma ordem.

Java na Prática


145public ObjectfirstElement()

Retorna o primeiro elemento.

public Object get(int i) Retorna o elemento da posição i.public int indexOf(Object o)

Retorna a posição da primeira ocorrência de o. Ométodo equals() do objeto é usado para o teste deigualdade.

public int indexOf(Objecto,int i)

Retorna a posição da primeira ocorrência de o a partirde i. O método equals() do objeto é usado para oteste de igualdade.

public voidinsertElementAt(Object o,int i)

Insere o objeto o na posição i.

public boolean isEmpty() Testa se o Vector está vazio.public ObjectlastElement()

Retorna o último elemento.

public intlastIndexOf(Object o)

Retorna a posição da última ocorrência de o. Ométodo equals() do objeto é usado para o teste deigualdade.

public Object remove(inti)

Remove o elemento da posição i.

public booleanremoveAll(Collection c)

Remove todos os elementos que também pertencem àCollection.

public voidremoveAllElements()

Remove todos os elementos.

public voidremoveElementAt(int i)

Remove o elemento da posição i.

public booleanretainAll(Collection c)

Mantém apenas os elementos que também pertencemà Collection.

public Object set(int i,Object o)

Substitui o objeto na posição i pelo objeto o.

public void setSize(ints)

Define o tamanho do Vector.

public int size() Retorna o tamanho do Vector.public List subList(inti, int f)

Retorna uma parte dos elementos do Vector entrefromIndex, inclusive, e toIndex, exclusive.

public Object[] toArray() Retorna um array contendo todos os elementos noVector na ordem correta.

public String toString() Retorna uma representação na forma de String doVector.

Tabela VI.5 – Métodos da classe Vector.

Exemplo

Java na Prática


146

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.

Stack

public 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.

Java na Prática


147

Hierarquia

java.lang.Object | +--java.util.AbstractCollection | +--java.util.AbstractList | +--java.util.Vector | +--java.util.Stack

Construtor

Construtor Descriçãopublic Stack() Constrói um Stack vazio.

Tabela VI.6 – Construtor da classe Stack.

Métodos

Mé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 push(Object o)

Insere o objeto o no topo da Stack.

public int search(Object o)

Retorna a distância do topo da pilha da primeiraocorrência de o. O elemento no topo da pilha possui adistância 1. O método equals() do objeto é usadopara o teste de igualdade.

Tabela VI.5 – Métodos da classe Stack.

Exemplo

Java na Prática


148

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.

Hashtable

public 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

Java na Prática


149

chave 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.

Hierarquia

java.lang.Object | +--java.util.Dictionary | +--java.util.Hashtable

Construtores

Construtor 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, float fatCarga)

Constrói um Hashtable com capacidadeinicial capac e com fator de carga fatCarga.

public Hashtable(Map m) Constrói um Hashtable com os elementos dem.

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 contains(Object o)

Testa se o objeto é acessado por alguma chave doHashtable.

public boolean containsKey(Object o)

Testa se o objeto é chave no Hashtable.

Java na Prática


150public booleancontainsValue(Object o)

Testa se o objeto é acessado por alguma chave doHashtable.

public Enumerationelements()

Retorna um objeto do tipo Enumeration quepermite percorrer os elementos do Hashtable.

public Set entrySet() Retorna um Set contendo os elementos doHashtable.

public booleanequals(Object o)

Compara se o é igual ao Hashtable. Retorna truesomente se o objeto é também do tipo Map e faz omesmo mapeamento.

public Object get(Objectkey)

Retorna o elemento da posição mapeado pela chavekey.

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(Objectkey,Object o)

Insere o objeto o no Hashtable tendo como chavekey.

protected void rehash() Reorganiza internamente o Hashtable para acessare acomodar os elementos mais eficientemente.

public Objectremove(Object key)

Remove o elemento que tem como chave 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 Collectionvalues()

Retorna um Collection contendo os elementos doHashtable.

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

Java na Prática


151 } ... 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.util

Arrays

public class Arraysextends Object

Java na Prática


152

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.

Hierarquia

java.lang.Object | +--java.util.Arrays

Métodos

Método Descriçãopublic static List asList(Object[] a) Retorna uma List criada a partir do array.public static int binarySearch(byte[] a, byte key)public static int 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)

Realiza uma pesquisa binária retornando aposição de key no array.

public static int binarySearch(Object[] a, Object key, Comparator c)

Realiza uma pesquisa binária retornando aposição de key no array. O array tem queestar ordenado ascendentemente de acordocom o Comparator.

public static boolean 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)

Retorna true se os dois arrays são iguais.

Java na Prática


153public static boolean equals(short[] a, short[] a2)public static void 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)

Preenche o array com o valor especificado.

public static void fill(boolean[] a, int ini, int fim, boolean val)public static void fill(byte[] a, int ini, int fim, byte val)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)

Preenche o array com o valor especificado apartir do elemento de índice ini inclusiveaté o elemento de índice fim exclusive.

public static void sort(byte[] a)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)

Ordena o array em ordem ascendente.

public static void sort(byte[] a, int ini, int fim)public static void sort(double[] a, int ini, int fim)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)

Ordena o array em ordem ascendente apartir do elemento de índice ini inclusiveaté o elemento de índice fim exclusive.

public static void sort(Object[] a, Comparator c)

Ordena o array em ordem ascendentedefinida pelo objeto Comparator.

public static void sort(Object[] a, int ini, int fim, Comparator c)

Ordena o array em ordem ascendentedefinida pelo objeto Comparator apartir do elemento de índice ini inclusive

Java na Prática


154

até o elemento de índice fim exclusive.

Tabela VI.5 – Métodos da classe Arrays.

O algoritmo de ordenaçãoO algoritmo de ordenação é uma variação quicksort apresentado por Jon L. Bentley e

M. Douglas McIlroy's "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.

Date

public class Dateextends Objectimplements Serializable, Cloneable, Comparable

Java na Prática


155

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.

Hierarquia

java.lang.Object | +--java.util.Date

Construtores

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 tendocomo 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

Java na Prática


156

datas são iguais. Retorna um valor maior que0 se a data passada como argumento é menore um valor menor que 0 se data passada comoargumento 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 datarepresentada pelo objeto corrente.

public void setTime(long time) Define a data desde objeto usando o númerode milisegundos desde 01/01/1970, 00:00:00GMT 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.

Observable

public 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

Java na Prática


157

projeto 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.

Figura VI.XX – Esquema do padrão MVC.

Observável

Figura VI.XX – Duas formas de visualização de um modelo.

Visão

Visão

Modelo

Controle

Controle

a bx 30 45

window X window X

a b

a=30; b=45;

Java na Prática


158

Hierarquia

java.lang.Object | +--java.util.Observable

Construtor

Construtor Descriçãopublic Observable() Constrói um Observable possuindo zero

observadores.

Tabela VI.XX – Construtor da classe Observable.

Métodos

Método Descriçãopublic voidaddObserver(Observer o)

Adiciona um observador ao conjunto deobservadores 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 voiddeleteObserver(Observer o)

Remove o objeto passado como argumentodo conjunto de objetos observadores.

public void deleteObservers() Remove todos os objetos observadores doconjunto 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 observadorese chama o método clearChanged().

public voidnotifyObservers(Object arg)

Se o método hasChanged() retornartrue notifica todos os objetos observadorese chama o método clearChanged(). Oobjeto arg é passado como argumento para ométodo update() do observador.

protected void setChanged() Marca este objeto como tendo sofrido umamudança.

Tabela VI.XX – Métodos da classe Observable.

Java na Prática


159

Exemplo

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 noErro! A origem da referência não foi encontrada..

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.

Java na Prática


160import 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

Java na Prática


161

public 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 ‘ ’

Hierarquia

java.lang.Object | +--java.util.StringTokenizer

Construtores

Construtor DescriçãopublicStringTokenizer(String s)

Constrói um StringTokenizer para s.

publicStringTokenizer(String s,String del)

Constrói um StringTokenizer para s,usando como delimitadores os caracterescontidos em del.

public StringTokenizer (String s, String del, boolean voltaTokens)

Constrói um StringTokenizer para s,usando como delimitadores os caracterescontidos em del. Se voltaTokens possui ovalor true, então os caracteres contidos emdel também são retornados.

Tabela VI.XX – Construtores da classe StringTokenizer.

Métodos

Método Descrição

Java na Prática


162public int countTokens() Retorna o número de tokens.public booleanhasMoreElements()

Mesmo efeito que hasMoreTokens().

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(Stringdel)

Retorna o próximo token como uma instânciade String usando como delimitadores oscaracteres contidos em del.

Tabela VI.XX – Métodos da classe StringTokenizer.

Exemplo

import 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.


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

Java na Prática


163

agenda 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.

Figura VI.xx – Diagrama de classes da versão console 2.0 da agendaeletrô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

AgendaInt

+obterPessoa()+exibirLista()+exibirPessoa()+gravarAgenda()+recuperarAgenda()

Agenda

+inserir(pessoa p)+getPessoas()+getPessoa(String Nome)

Pessoa

-String Nome-String Tel-String End

+getNome()+getTel()+getEnd()

0..*

Java na Prática


164 */ 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.


*/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

Java na Prática


165

classe 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.


*/

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

Java na Prática


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

Java na Prática


167 { 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!"); } }

// main public static void main(String args[]) { AgendaInt agInt = new AgendaInt(); String opcao="";

for(;;) { System.out.println(

Java na Prática


168 "\nAgenda Tabajara\n***********************\n"); System.out.print("Opcoes:\n(i)nserir\n(c)onsultar"+ "\n(l)istar\n(g)ravar\n(r)ecuperar\n(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; } }

}}

Java na Prática


169

Capí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ível armazenar erecuperar os objetos da classe por meio de instâncias das classesObjectOutputStream e ObjectInputStream, respectivamente. O exemploVII.1 mostra como armazenar e recuperar um objeto da classe Pessoa em umarquivo 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;

Java na Prática


170 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 classePessoa.

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 o sentidoda posterior recuperação do objeto? Portanto, quando um objeto é armazenadotodos os objetos referenciados por ele também são armazenados, desde que osobjetos implementem a interface Serializable. Caso o objeto referenciadotambém referencie outro objeto, este último também será armazenado, e assimpor diante, até que toda os objetos da cadeia de referencias sejam armazenados.Isto pode fazer com que o objeto armazenado ocupe muito mais espaço do que oimaginado inicialmente pelo programador. Outra pergunta seria: o que aconteceentão quando um objeto é referenciado mais de uma vez ou quando acontece umciclo no grafo de referências? Neste caso, o objeto é armazenado apenas umavez.

Java na Prática


171


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...

}


*/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

Java na Prática


172

para gravar e recuperar os objetos, uma vez que não existem classes do tipoObjectReader e ObjectWriter no novo conjunto de classes de E/S.


*/

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!"); } }

Java na Prática


173 ... Sem alteração ...}

Java na Prática


174

Capí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

Java na Prática


175

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

Java na Prática


176

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.

Java na Prática


177

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.

Java na Prática


178

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.

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

Componente1

A

Componente2

B

Listener

Listener

Listener

Listener

Listener

evento

evento

Java na Prática


179 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.

Java na Prática


180FocusEvent 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”.


public class FrameBotao extends FrameX implements ActionListener{ Button b;

public FrameBotao() { setLayout(null); setSize(100,80); b = new Button("Aperte aqui");

Java na Prática


181 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.


public class FrameBotao extends FrameX{ Button b;

Public FrameBotao()

Java na Prática


182 { 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); }}


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.

Java na Prática


183

Figura XX.XX – Relação entre os componentes e os eventos.

FocusEvent

ActionEvent

AdjustmentEvent

ItemEvent

ContainerEvent

TextEvent

WindowEvent

TextFieldMouseEvent

Scrollbar

Component

Label

Dialog

Panel

MenuItem

Button

Frame

Choice

Menu

ComponentEvent

KeyEvent

Java na Prática


184

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_PRESSED

int 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, int y)

move a posição do evento por x e 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. Crieuma classe interna que implementa a interface.

3. Codifique os métodos que tratam os eventos que você deseja tratar. Todos osmétodos da interface tem que ser implementados, mas o corpo dos métodosque não interessam podem ser deixados vazios.

4. Registre um objeto da classe interna junto ao componente, por meio domé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)

Java na Prática


185

♦ 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.

ComponentAdapterContainerAdapterFocusAdapterKeyAdapterMouseAdapterMouseMotionAdapterWindowAdapter

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() {

Java na Prática


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


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

Java na Prática


187

interface: 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.

123456

import java.io.*;import java.awt.*;import java.awt.event.*;

public class Comando extends Frame { private TextField tfComando;

Java na Prática


188

78910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455

private TextArea taSaida; private Button btExec; private String com;

public Comando() { com = "command.com /c "; // Altere essa linha para outros ambientes operacionais

tfComando = new TextField(50); taSaida = new TextArea(20,60); btExec = new Button(“Executa”);

taSaida.setEditable(false);

add(tfComando,BorderLayout.NORTH); add(btExec,BorderLayout.SOUTH); add(taSaida,BorderLayout.CENTER);

addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent evt) {

System.exit(0); }

});

btExec.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) {

btExecActionPerformed(evt); }

}); pack(); }

private void btExecActionPerformed(ActionEvent evt) { String s = tfComando.getText(); if (s==null) return; try { Process p = Runtime.getRuntime().exec(com+s); InputStream in = p.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; taSaida.setText(""); while ((line = br.readLine()) != null) { taSaida.append(line+'\n'); } taSaida.append("Fim!"); } catch(Exception e) {taSaida.setText(e.getMessage()); return;} }

public static void main(String args[]) {new Comando().show();

Java na Prática


189

5657

}}

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

Java na Prática


190

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

Java na Prática


191

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 Layout

O 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 daesquerda para a direita, como linhas em um parágrafo. Cadalinha é centralizada.

CardLayout Trata cada componente do Container como uma a carta.Somente uma carta é visível em um determinado instante e oContainer funciona como uma pilha de cartas. O primeirocomponente adicionado é o primeiro visível quando oContainer é exibido.

GridBagLayout É o gerenciador de layout mais flexível e o mais complexo. Elearranja os componentes verticalmente e horizontalmente semexigir que os componentes tenham o mesmo tamanho. Mantémum grade retangular de células, sendo que cada componentepode ocupar mais de uma célula.

GridLayout Posiciona e redimensiona os componentes de um Containerem uma grade retangular. O Container é dividido emretângulos de tamanhos iguais e um componente é colocado emcada retângulo.

Tabela XX.XX –Gerenciadores de Layout.

Java na Prática


192

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

Java na Prática


193

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

Java na Prática


194

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.


public class CardTeste extends FrameX {

Java na Prática


195

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.

Java na Prática


196

Exemplo 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.


Figura XX.XX – Aparência do Frame com GridLayout.

Java na Prática


197

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

Java na Prática


198

} 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 naclasse GridBagConstraints) são NONE (default), HORIZONTAL (torna ocomponente largo o suficiente para preencher a área horizontalmente),VERTICAL (torna o componente alto o suficiente para preencher a áreana 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 aproporção do espaço que excedente que será distribuído entre oscomponentes. Se não for especificado para pelo menos uma linha(weightx) e coluna (weighty), todos os componentes serão agrupadosno 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çãode um componente. O valor default é 1. Os valores possíveis (definidosna classe GridBagConstraints) são REMAINDER para especificar que ocomponente deve ser o último da linha (para gridwidth) ou coluna(para gridheight). RELATIVE para especificar que o componente deveser o vizinho do último na linha (para gridwidth) ou coluna (paragridheight). Ou valores inteiros especificando o número de linhas ecolunas ocupadas.

Java na Prática


199


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.

12345678910111213


public class Comando2 extends java.awt.Frame { private TextField tfComando; private TextArea taSaida; private Button btExec; private Panel panel; private Choice ch; private String com;

public Comando2() {

Java na Prática


200

14151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162

com = "command.com /c ";

tfComando = new TextField(50); taSaida = new TextArea(20,60); panel = new Panel(); btExec = new Button("Executa"); ch = new Choice(); ch.setVisible(false);

btExec.setBackground(new Color(0x08FDDF10)); taSaida.setBackground(Color.lightGray); taSaida.setEditable(false);

add(panel,BorderLayout.NORTH); panel.add(tfComando,BorderLayout.NORTH); panel.add(ch,BorderLayout.CENTER); add(btExec,BorderLayout.SOUTH); add(taSaida,BorderLayout.CENTER);

addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent evt) { System.exit(0); } });

btExec.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { btExecActionPerformed(evt); } });

ch.addItemListener( new ItemListener() { public void itemStateChanged(ItemEvent evt) { if (evt.getStateChange() == ItemEvent.SELECTED) tfComando.setText(ch.getSelectedItem()); } }); pack(); }

private void btExecActionPerformed(ActionEvent evt) { String s = tfComando.getText(); if (s==null) return; boolean inclui =true; for (int i= ch.getItemCount()-1;i>=0;i--) if (s.equals(ch.getItem(i))) inclui=false; if (inclui) { ch.add(s); ch.setVisible(true);

Java na Prática


201

63646566676869707172737475767778

pack(); } try { Process p = Runtime.getRuntime().exec(com+s); InputStream in = p.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; taSaida.setText(""); while ((line = br.readLine()) != null) taSaida.append(line+'\n'); taSaida.append("Fim!"); } catch(Exception e) {taSaida.setText(e.getMessage()); return;} }

public static void main(String args[]) { new Comando2().show(); }}

Exemplo XX.XX – Aplicação para execução de comandos MS-DOS com listade 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.


Java na Prática


202

Figura XX.XX – Aparência da aplicação para execução de comandos MS-DOScom 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.

123456


public class Comando3 extends java.awt.Frame { private TextField tfComando;

Java na Prática


203

78910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455

private TextArea taSaida; private Button btExec; private Panel panel; private Choice ch; private String com;

public Comando3() { com = "command.com /c ";

tfComando = new TextField(50); taSaida = new TextArea(20,60); panel = new Panel(); btExec = new Button("Executa"); ch = new Choice(); ch.setVisible(false);

btExec.setBackground(new Color(0x08FDDF10)); taSaida.setBackground(Color.lightGray); taSaida.setEditable(false);

Menu menu = new Menu("Ajuda"); menu.add("Resumo"); menu.addSeparator(); menu.add("Sobre"); MenuBar mb = new MenuBar(); mb.add(menu); setMenuBar(mb);

add(panel,BorderLayout.NORTH); panel.add(tfComando,BorderLayout.NORTH); panel.add(ch,BorderLayout.CENTER); add(btExec,BorderLayout.SOUTH); add(taSaida,BorderLayout.CENTER);

addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent evt) { System.exit(0); } });

btExec.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { btExecActionPerformed(evt); } });

ch.addItemListener( new ItemListener() { public void itemStateChanged(ItemEvent evt) { if (evt.getStateChange() == ItemEvent.SELECTED)

Java na Prática


204

5657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104

tfComando.setText(ch.getSelectedItem()); } });

menu.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { if (evt.getActionCommand().equals("Sobre")) mostraSobre(); else if (evt.getActionCommand().equals("Resumo")) taSaida.setText("Digite o Comando e pressione “+ ”o botão <executa> para executar."); } }); pack(); }

private void mostraSobre() { Dialog d = new Dialog(this,"Sobre Comando"); d.setModal(true); Label lb1 = new Label("Comando Versão 1.2", Label.CENTER); Label lb2 = new Label("Alcione de Paiva Oliveira", Label.CENTER); lb1.setFont(new Font ("Dialog", Font.BOLD|Font.ITALIC, 18)); lb2.setFont(new Font ("Courier New", 0, 16)); d.add(lb1,BorderLayout.NORTH); d.add(lb2,BorderLayout.SOUTH); d.setBackground(Color.cyan); d.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent evt) { evt.getWindow().dispose(); } }); d.pack(); d.show(); }

private void btExecActionPerformed(ActionEvent evt) { String s = tfComando.getText(); if (s==null) return; boolean inclui =true; for (int i= ch.getItemCount()-1;i>=0;i--) if (s.equals(ch.getItem(i))) inclui=false; if (inclui) { ch.add(s); ch.setVisible(true); pack(); } try { Process p = Runtime.getRuntime().exec(com+s); InputStream in = p.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(in));

Java na Prática


205

105106107108109110111112113114

String line; taSaida.setText(""); while ((line = br.readLine()) != null) taSaida.append(line+'\n'); taSaida.append("Fim!"); } catch(Exception e) {taSaida.setText(e.getMessage()); return;} }

public static void main(String args[]) { new Comando3().show(); }}

Exemplo XX.XX – Aplicação para execução de comandos MS-DOS com barrade 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.


Java na Prática


206

Figura XX.XX – Aparência da aplicação para execução de comandos MS-DOScom barra de menus.

Capturando Eventos do Teclado

Principais Classes

Color

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.

Java na Prática


207

Hierarquia

java.lang.Object | +--java.awt.Color

Atributos públicos

Atributo DescriçãoColor 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.

Construtores

Construtor DescriçãoColor(float r, float g, float b)

Cria uma cor opaca RGB com os valores red, green, eblue especificados dentro da faixa (0.0 - 1.0).

Color(int rgb) Cria uma cor opaca com os valores RGB combinados noparâmetro rgb. O componente red está definido nosbits 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, int b)

Cria uma cor opaca RGB com os valores red, green, eblue especificados dentro da faixa (0 - 255).

Métodos mais usados

Mé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

Java na Prática


208

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.Component

Atributos públicos

Atributo Descriçãofloat 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.

Construtor

Construtor DescriçãoComponent() Constrói um novo Component.

Java na Prática


209


Método Descriçãovoid add(PopupMenu popup) Adiciona um menu do tipo PopupMenu ao

componente.void addComponentListener( ComponentListener l)

Adiciona o ComponentListener parareceber eventos sobre o componente.

boolean contains(int x, int y)

Verifica se o componente possui a coordenada.

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( int x, int y)

Retorna o componente do Component quecontém a coordenada especificada. Apenas oprimeiro 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 desejadesenhar no Container. Neste casosuper.paint(g) deve ser invocado.

void processEvent(AWTEvent e) Processa os eventos ocorrendo nestecomponente.

void remove(MenuComponentpopup)

Remove o menu popup menu destecomponente.

void setBounds(int x, int y, int width,

Define os limites deste componente.

Java na Prática


210 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, int height)

Define o tamanho deste componente.

void setVisible(boolean b) Define este componente como visível.String toString() Retorna a representação em String deste

componente.

Exemplo

Component 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.Button

Construtores

Construtor DescriçãoButton() Constrói um botão sem texto.Button(String lbl) Constrói um botão com um texto.


Mé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.

Java na Prática


211

Exemplo

Button b= new Button(“ok”);

Label

Os objetos da classe Label servem para exibir textos que não serãoeditados pelo usuário.

Hierarquia

java.lang.Object | +--java.awt.Component | +--java.awt.Label

Construtores

Construtor DescriçãoLabel() Constrói um Label sem texto.Label(String lbl) Constrói um Label com um texto.Label(String lbl, int alin)

Constrói um Label com um texto e com o alinhamentoespecificado por alin. Os valores possíveis para oalinhamento são Label.LEFT, Label.RIGHT, eLabel.CENTER.


Mé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

Java na Prática


212

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.

Hierarquia

java.lang.Object | +--java.awt.Component | +--java.awt.List

Construtores

Construtor 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,boolean sm)

Constrói uma nova lista rolável com o número de linhasvisíveis igual a linhas e o parâmetro sm indicando seé para permitir seleções múltiplas.


Método Descriçãovoid add(String item) Adiciona o item referenciado por item no

final da lista.void add(String item, int ind)

Adiciona o item referenciado por item naposição indicada por ind. A base é 0. Se ovalor de ind for menor que 0 ou maior que onúmero de elementos, o item será inserido nofinal da lista.

Java na Prática


213void 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 umelemento 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.

Exemplo

List 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.

Hierarquia

java.lang.Object | +--java.awt.Component | +--java.awt.TextComponent | +--java.awt.TextField

Java na Prática


214

Construtores

Construtor 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(Stringtxt,int cols)

Constrói um novo TextField com o número decolunas e o texto especificados.


Mé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.

Hierarquia

java.lang.Object | +--java.awt.Component |

Java na Prática


215

+--java.awt.TextComponent | +--java.awt.TextArea

Construtores

Construtor DescriçãoTextArea() Constrói um novo TextArea.TextArea(int lin, int cols)

Constrói um novo TextArea com o número de linhase colunas especificados.

TextArea(String txt) Constrói um novo TextArea exibindo o textoespecificado.

TextArea(String txt,intcols)

Constrói um novo TextArea com o número de linhas,colunas e o texto especificados.


Mé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.

Exemplo

new 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

Java na Prática


216

java.lang.Object | +--java.awt.Component | +--java.awt.Container

Construtor

Construtor DescriçãoContainer() Constrói um novo Container.


Método DescriçãoComponent add( Component comp)

Adiciona o componente no final da lista decomponentes deste Container.

Component add( Component comp, int ind)

Adiciona o componente na posição ind dalista de componentes deste Container.

Component findComponentAt( int x, int y)

Retorna o componente visível do Containerque contém a coordenada especificada. Todosos 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( int n)

Retorna o componente na posição n na lista decomponentes deste Container.

Component getComponentAt( int x, int y)

Retorna o componente do Container quecontém a coordenada especificada. Apenas oprimeiro nível de descendência é examinado.

int getComponentCount() Retorna o número de componentes desteContainer.

Component[] getComponents() Retorna todos os componentes desteContainer.

Insets getInsets() Retorna o Insets deste Container.Insets indicam o tamanho da borda doContainer.

LayoutManager getLayout() Retorna o Layout deste Container.booleanisAncestorOf(Component c)

Indica se o componente está contido nesteContainer.

void list(PrintStream out, int indent)

Imprime uma lista com o conteúdo desteContainer.

void paint(Graphics g) Pinta o este Container. Este método deveser sobrescrito se o programador deseja

Java na Prática


217

desenhar no Container. Neste casosuper.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(LayoutManagermgr)

Define o layout deste Container.

Panel

Esta classe é o Container mais simples. O Panel fornece um espaçoonde podem ser colocados outros componentes, inclusive outros objetos do tipoPanel.

Hierarquia

java.lang.Object | +--java.awt.Component | +--java.awt.Container | +--java.awt.Panel

Construtor

Construtor DescriçãoPanel() Constrói um novo Panel.Panel(LayoutManager layout) Constrói um novo Panel usando o LayoutManager

especificado.

Método

Método Descriçãovoid addNotify() Cria um par (peer) para o Panel. O par permite modificar o

Java na Prática


218

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().

Hierarquia

java.lang.Object | +--java.awt.Component | +--java.awt.Container | +--java.awt.Window | +--java.awt.Frame

Construtores

Construtor DescriçãoFrame() Constrói um novo Frame.Frame(String title) Constrói um novo Frame com o título especificado.


Método Descriçãostatic Frame[] getFrames() Retorna todos os frames criados pela aplicação.Image getIconImage() Retorna a imagem usada pelo Frame quando

Java na Prática


219

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.

###Exemplo


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[])

Java na Prática


220 { 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.MouseEvent

event){ 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();

Java na Prática


221 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

/**AgendaIntInterface Gráfica da agenda.

*/

import java.awt.*;import java.awt.event.*;import java.io.*;import java.util.*;

Java na Prática


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

Java na Prática


223add(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 LISTENERSSymWindow 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();

Java na Prática


224if (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);

Java na Prática


225 else lbStatus.setText("É necessário preencher o campo

Nome!");}

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!");}

}

Java na Prática


226

/**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");

} }

// mainpublic 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ícios

Faça um programa para converter Graus Celcius em Farenheit

Java na Prática


227

Capítulo IX - AppletsApplets são aplicações Java projetadas para serem executadas por

navegadores 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.

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.

Cliente com browserServidor

Requisição de página Web

Página Web construídapelo programa CGI

O servidor Webexecuta o programaCGI que constrói apágina Web.

800

APO

Java na Prática


228

Figura VII.2 – Interação via Java.

No entanto, é preciso ter cuidado quando se trata de enviar código pelarede para se executado em uma máquina cliente. Existe um grande potencialpara o desenvolvimento acidental ou proposital de programas que podem atuarnocivamente nas máquinas clientes, seja pela leitura de dados privados, seja pordestruição não autorizada de informações e programas. Preocupados com o isso,os projetistas da linguagem Java determinaram que, no caso de Applets, amáquina virtual impede que o programa tenha acesso limitado aos recursos damáquina. Nessa forma de execução o programa é dito estar sendo executadodentro de uma “caixa de areia” (Sand Box). Esta solução é em alguns casos pordemais restritiva e tem sido relaxada nas últimas versões de Java para permitir oacesso 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áginaspara a WWW com animação. Inicialmente, as páginas em HTML não possuíamrecurso 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 classejava.applet.Applet. Abaixo é mostrada forma geral de um código queimplementa um Applet:

import java.awt.*;import java.applet.Applet;

public class indentificador extends Applet

Cliente com browserServidor

Requisição de página Web

Página Web e bytecodes

O servidor Webenvia páginaWeb e códigoem bytecodes

Executa ocódigo embytecodes

800

APO

Java na Prática


229{

corpo do applet}

A figura VII.3 mostra a hierarquia de classes para a classe 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);

}}

java.awt.Component

java.lang.Object

java.awt.Container

java.awt.Panel

java.applet.Applet

Java na Prática


230

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

A figura VII.4 mostra o resultado da execução do Applet1 por meio doappletviewer.

Java na Prática


231

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çãocode 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. Porexemplo: 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 eabsbottom).

alt Mensagem alternativa caso o navegador não seja capaz de executarbytecodes.

name Nome do Applet. Pode ser usado por outros Applets na mesmapágina para comunicação.

Java na Prática


232hspace 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. Maisadiante 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çãoinit É 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

instância da classe Graphics. O usuário pode solicitar a sua invocação pormeio de uma chamada ao método repaint(). Neste caso o métodopaint() não será chamado imediatamente, e sim escalado para serexecutado 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.

Java na Prática


233

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

} } }}

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 menos

Java na Prática


234

100 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.

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 imagemdraw3Drect 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.

repaint() update(Graphics g)

escala (dentro de 100 ms)

paint(Graphics g)Chama

Java na Prática


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

}

Java na Prática


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

Java na Prática


237{

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.

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.

Java na Prática


238

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() {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.

Java na Prática


239

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

O 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.• 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.

Java na Prática


240

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><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.*;

Java na Prática


241public class Applet5 extends java.applet.Applet{


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”}};

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. O

Java na Prática


242

mé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{


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

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 dos

Java na Prática


243

programas 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. Como já foi visto, para solucionar esses e outros problemas foiintroduzido a partir da versão 1.1 da linguagem Java o formato de arquivo JAR(Java Archive). O formato de arquivo JAR permite o agrupamento de váriosarquivos em um único arquivo. Além disso, o formato JAR permite acompressão de dados de modo otimizar o armazenamento e a transmissão dedados. O principais benefícios do uso do formato JAR são os seguintes:

• Menor tempo de carga de Applets: Se todos os arquivos relacionados comum Applet estão agrupados em um único arquivo JAR, apenas uma transaçãoHTTP será necessária para carregar o Applet. Este tempo será ainda menorse 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 concederprivilégios para acessar recursos que não estariam disponíveis, casocontrário.

• Portabilidade: a API para manipulação dos arquivos JAR é parte integrantedo núcleo da biblioteca de classes de Java, o que a torna independente deplataforma.

Outros benefícios foram adicionados com o lançamento da versão 1.2 doSDK, como por exemplo, informações sobre versão.

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.

Exercícios

Faça uma calculadora com o seguinte layout:

0 . =

3 2 1

6 5 4

9 8 7

/

*

-

+

Java na Prática


244

Agenda Eletrônica versão Applet 1.0

Java na Prática


245

Capí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 usodas convenções para determinação dos eventos e propriedades.

• Por uso de uma class de informações denominada BeanInfo. Uma classeBeanInfo implementa a interface BeanInfo. Uma classe BeanInfoexplicitamente lista todas as características do Bean que devem ser expostaspara 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

Java na Prática


246

introspeçã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:

Java na Prática


247

Class 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[];

.

.

.

Java na Prática


248

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

Java na Prática


249

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

Java na Prática


250

vetar 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.

Java na Prática


251

A 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.

Java na Prática


252

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;

TimerEventListener

A 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.

Java na Prática


253

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.

TimerEvent

A 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.*;

Java na Prática


254import 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;

Java na Prática


255 }

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

}

Java na Prática


256

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 umevento seja disparado. Através dos métodos getIntervalo() esetIntervalo(long) implementamos uma propriedade bound de nome“intervalo”.

2. th: Este campo é transient, isto é, quando esta classes for serializada estainformação não será gravada. Para nosso Bean th é o thread queperiodicamente dispara eventos para seus listeners.

3. listeners: Um Vector armazena a lista de listeners que estão registrados nesteBean para receber os eventos. Novos métodos são colocados em nossaclasses para registrar ou remover listeners, este métodos tem nomes queseguem 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 eremoveTimerEventListener.

4. ativo: este campo é utilizado para indicar para o Bean se ele deve ou nãodisparar eventos para os seus listeners. Ativo não é acessado diretamente, esim 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 devedispará-lo, um evento e criado e o método disparaEvento e chamado.

2. disparaEvento(TimerEvent e): inicialmente este método cria dentrode uma seção sincronizado uma cópia do Vector listener. Em seguidaatravés de um laço for, percorre este Vector chamando o métodotimerEventDisparado para cada listener registrado.

Java na Prática


257

Temos 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 manipuladosvisualmente;

• 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 Beanselecionado e através dela o desenvolvedor pode alterar estaspropriedade no Componente;

Java na Prática


258

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.0

Name: timer/TimerBean.classJava-Bean: True

Name: timer/TimerEventListener.class

Name: 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 .

Java na Prática


259

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:

Java na Prática


260

Bean Propriedade(mudada) Novo valorOurbutton label IniciarOurbutton label PararTimerBean intervalo 2000EventMonitor

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.

Java na Prática


261

Bean fonte Evento Bean alvo MétodoTimerBean TimerEvent-

timerEventDisparadoEventMonitor InitiateEventSourceMonito

ring()OurButton(iniciar)

action-actionPerformed TimerBean inicia()

OurButton(parar)

action-actionPerformed TimerBean para()

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.

Java na Prática


262

Java na Prática


263

Java na Prática


264

Capítulo XI Perguntas FrequentesComo executar um programa a partir de uma aplicação em Java?

Resposta: isso pode ser feito com o método de instância exec da classeRuntime.

Como criar um TextField que não exiba o que está sendo digitado parase usado como campo de entrada de senhas?

Resposta: use o método setEchoChar() do TextField para definir qualcaractere que deve ser ecoado.

Como aumentar a área de ambiente do DOS para caber o CLASSPATH?

Resposta: coloque a seguinte linha no autoexec.bat

set shell=c:\command.com /e:4096

Java na Prática


265

BibliografiaEckel B. Thinking in Java. 2nd Ed. New Jersey : Prentice Hall, 2000.

Gosling J., Joy W., Steele G. The Java Language Specification. Massachusetts :Addison-Wesley, 1996.

Oaks S. Java Security. California : O’Reilly & Associates, Inc, 1998.

Oaks S., Wong H. Java Threads. 2ª Ed. California : O’Reilly & Associates, Inc,1999.

Watt D. A. Programming Language Concepts and Paradigms. Great Britain :Prentice Hall, 1990.

Ethan H., Lycklama E. How do you Plug Java Memory Leaks? Dr. Dobb´sJournal, San Francisco, CA, No. 309, February 2000.

Wahli U. e outros. Servlet and JSP Programming with IBM WebSphere Studioand VisualAge for Java, IBM RedBooks, California, May 2000.

Sadtler C. e outros. Patterns for e-business: User-to-Business Patterns for Topology1 and 2 using WebSphere Advanced Edition, IBM RedBooks, California, April2000.

Bagwel D. e outros. An Approach to Designing e-business Solutions, IBMRedBooks, California, December 1998.

Java na Prática


266

LinksRevistas

http://www.javaworld.com/Revista online sobre Java.

Livroshttp://www.eckelobjects.com/Página do autor do livro Thinking in Java, atualmente em segunda edição. Olivro pode ser baixado gratuitamente no site.

http://www.redbooks.ibm.com/booklist.htmlLivros da IBM

Servidoreshttp://jakarta.apache.orgPágina do projeto Jakarta que desenvolveu o Tomcat.

http://www.metronet.com/~wjm/tomcatLista Tomcat

http://www.jboss.orgServidor de aplicação gratuito habilitado para EJB

Dicas Java e recursoshttp://java.sun.com/Página da Sun com informações, tutoriais e produtos Java.

http://gamelan.earthweb.com/Página da com informações, Applets, Lista de discussão, tutoriais.

http://www.inquiry.com/techtips/java_proAsk the Java Pro

http://www.jguru.com/jGuru.com(Home): Your view of the Java universe

http://www.soujava.org.br

Java na Prática


267

Bem Vindo ao SouJava!

Servlets e JSPhttp://www.servlet.com/srvdev.jhtmlServlet Inc : Developers Forum

http://www.servlets.comServlets.com

http://www.jspin.com/homeJspin.com - The JSP Resource Index

http://www.burridge.net/jsp/jspinfo.htmlWeb Development with JSP: JSP, Java Servlet, and Java BeanInformation

http://www.apl.jhu.edu/~hall/java/Servlet-TutorialA Tutorial on Java Servlets and Java Server Pages (JSP)

Java na Prática


268

ÍndiceA

Acesso Direto.........................................137Acesso Sequencial .................................132Agregação ................................................24amarração.................................................99Arrays .............................................36, 151Assert ...................................................62Assertivas ......................Consulte AssertAssinatura dos métodos .....................17, 20Associação comum ..................................22Atribuição ...............................................48atributos ...................................................67Atributos ..................................................10AWT ......................................................174

B

Bloco........................................................51boolean.....................................................32booleanos

boolean................................................35break .....................................................59Button .................................................210Bytecodes.............................................6, 27

C

cadeias de caracteres ......... Consulte StringsCalendar ................................................1Caractere

char......................................................36cardinalidade da relação...........................22casting ............ Consulte Conversão de tiposchar ..........................................................32Classe .................................................10, 66classe anônima .......................................189Classes Abstratas ...................................101Classes Internas....................................105Classes Internas Anônimas .................107clone.........................................................81Coleta de Lixo............................................7Color ...................................................206Comentários ...........................................50Component ..........................................208Construtor ................................................15

Construtores........................................... 68Containers.............................................. 215continue .............................................. 59Convenções................................................ 9Conversão de Objetos.......................... 112Conversão de Tipos ............................... 40Cópia profunda ...........Consulte deep copyCópia rasa ............. Consulte Shallow copyCriptografia................................................ 8

D

Date ..................................................... 154deep copy ................................................. 81Derivando classes ..........Consulte herançaDiagrama de Classes................................ 19double ...................................................... 31do-while .................................................. 57

E

escape ...................................................... 33Escopo ..................................................... 51escopo de pacote...................................... 72Estruturas de Controle.......................... 52Exceções................................................ 113extends............................................... 16, 96

F

final ..................................................... 76Finalização ........................................... 109finalize() ................................................ 112finally .............................................. 121float.......................................................... 31for............................................................ 58Frame ................................................... 218

G

Garbage Collection ..Consulte coleta de lixoGeneralização .......................................... 24

H

Hashtable ......................................... 148herança ................................................... 94Herança.............................................. 11, 13Herança Múltipla ..................................... 96

Java na Prática


1hexadecimal .............................................30

I

Identificadores........................................28if.............................................................52Inicialização ..........................................109Instância ...................................................10Inteiros

int 35Interfaces ..............................................102

J

J2EE...........................................................9J2ME..........................................................9JAR ..................................................89, 242java.io...............................................132JavaBean ................................................245JCE.............................................................8JDK............................................................8

L

Label ...................................................211linha de comando ...................................61List......................................................212Literais ....................................................30

M

main .........................................................27manifest ....................................................90Máquina Virtual .........................................6Mecanismo de Extensão.........................92método de classe ......................................71método de instância..................................71métodos....................................................67Métodos ...................................................14Modificadores de acesso ........................72MVC ......................................................156

N

native ...................................................78null........................................................33

O

Object.......................................................18Objeto

Comportamento...................................11Objetos...............................................10, 69Observable .......................................156

Observer .................................... 157, 159octal ......................................................... 30Ocultação de informação ................... 13, 15Olá mundo ............................................... 26Operadores ............................................. 41

P

Packages ................................................. 86Pacotes...........................Consulte PackagesPalavras Reservadas.............................. 29Panel ................................................... 217polimorfismo ......................................... 100Polimorfismo ........................................... 18Ponteiro ..................................................... 6Ponto Flutuante

float, double ........................................ 35Precedência entre Operadores.............. 49private ...................................................... 15Propriedades ............................................ 10

R

RandomAccessFile ................................ 137recursão ................................................... 56Referências Compartilhadas................. 78return................................................... 69

S

separadores .............................................. 33shallow copy ............................................ 81Smalltalk.................................................... 6Sobrecarga ............................................... 17Sobrescrita ......................................... 17, 98Stack ................................................... 146static................................................... 74String ....................................................... 32StringBuffer .................................... 79Strings..................................................... 37StringTokenizer ........................... 160super ..................................................... 73Superclasse .............................................. 10switch................................................... 54synchronized .................................... 78

T

TextArea .................................... 187, 214TextField ................................. 187, 213this ....................................................... 85

Java na Prática


2

Throwable ..........................................115Tipos de dados ........................................34toString()..................................................41Tratamento de Eventos...........................177try/catch ..........................................114

U

UML.........................................................19Unicode....................................................28Unidade de Compilação ...........................67

V

Vector................................................. 143vinculação.....................Consulte amarraçãoVisibilidade.............................................. 21void ....................................................... 69

W

while ..................................................... 56widgets................................................... 174

Java na Prática


1

Documents

UNIVERSIDADE FEDERAL DE VIÇOSA DEPARTAMENTO DE …vladimir/java/Java na Pratica_vol1.pdf · milhões de programadores Java no mundo e a ... Nas linguagens onde existe alocação