UNIVERSIDADE FEDERAL RURAL DE PERNAMBUCO (UFRPE)

COORDENAO GERAL DE EDUCAO A DISTNCIA (EAD/UFRPE)

Programao III

Fernando Antonio Mota Trinta

Volume 2

Recife, 2010

Universidade Federal Rural de Pernambuco Reitor: Prof. Valmar Corra de Andrade Vice-Reitor: Prof. Reginaldo Barros Pr-Reitor de Administrao: Prof. Francisco Fernando Ramos Carvalho Pr-Reitor de Atividades de Extenso: Prof. Delson Laranjeira Pr-Reitora de Ensino de Graduao: Prof Maria Jos de Sena Pr-Reitora de Pesquisa e Ps-Graduao: Prof Antonia Sherlnea Chaves Vras Pr-Reitor de Planejamento: Prof. Romildo Morant de Holanda Pr-Reitor de Gesto Estudantil: Prof. Valberes Bernardo do Nascimento Coordenao Geral de Ensino a Distncia: Prof Marizete Silva Santos

Produo Grfica e Editorial Capa e Editorao: Rafael Lira, Italo Amorim e Arlinda Torres Reviso Ortogrfica: Elias Vieira Ilustraes: Allyson Vila Nova e Fernando Trinta Coordenao de Produo: Marizete Silva Santos

Sumrio
Apresentao. ................................................................................................................. 5 Conhecendo o Volume 2................................................................................................. 6 Captulo 1 Frameworks Orientados a Objetos............................................................... 8 1. Introduo....................................................................................................................8 2. Conceito de Frameworks..............................................................................................9 3. Caractersticas Bsicas de Frameworks......................................................................10 4. Vantagens e Desvantagens no Uso de Frameworks. ...................................................11 5. Framework Collection.................................................................................................12 6. Utilizando Colees na Prtica. ...................................................................................15 Captulo 2 Interface Grfica do Usurio...................................................................... 22 1. Introduo..................................................................................................................22 2. Modelo de Construo de Aplicaes Grficas em Java.............................................23 3. Bibliotecas para Criao de Interfaces Grficas em Java............................................24 4. Hierarquia de Classes para Componentes e Conteiners.............................................25 5. Trabalhando com Conteiners......................................................................................27 6. JFrame........................................................................................................................28 7. JDialog........................................................................................................................30 8. Painis........................................................................................................................32 9. Gerenciadores de Leiaute...........................................................................................33 10. Principais Componentes Swing. ................................................................................41 11. Menus.......................................................................................................................53 Captulo 3 Tratamento de Eventos.............................................................................. 60 1. Introduo..................................................................................................................60

2. O Padro de Projeto Observador................................................................................60 3. O Tratamento de Eventos em Java..............................................................................61 4. Principais Tipos de Eventos de uma Interface Grfica em Java..................................62 5. Ouvintes de Eventos...................................................................................................63 6. Ligao entre Fontes de Eventos e Ouvintes..............................................................64 7. Adaptadores...............................................................................................................70 8. Classes Internas e Classes Annimas..........................................................................72 Conhea o Autor........................................................................................................... 78

Apresentao
Caro cursista, Seja bem-vindo(a) ao curso de Programao III. Esta disciplina dar sequncia aos estudos iniciados na disciplina de Programao II, apresentando conceitos avanados relacionados construo de aplicaes orientadas a objetos. Este curso composto por 4 volumes. Neste primeiro volume, vamos estudar a importncia da boa organizao dos sistemas, por meio dos conceitos de arquitetura de software e padres de projeto. Em seguida, estudaremos como podemos criar aplicaes multitarefa, por meio dos conceitos de threads, para no ltimo captulo, aprendermos a gerenciar arquivos em aplicaes orientadas a objetos. O segundo volume dedicado ao estudo do conceito de frameworks, onde utilizaremos uma API muito til dentro da linguagem Java como estudo de caso, a API collections. A segunda parte deste volume a construo da interface do usurio, utilizando recursos avanados como janelas, botes, listas de seleo, e outras metforas bastante conhecidas das aplicaes modernas. Este assunto aborda ainda o chamado modelo de programao orientado a eventos. O terceiro volume dedicado totalmente ao estudo da integrao de aplicaes com bancos de dados. Para isto, veremos primeiramente conceitos fundamentais sobre bancos de dados, para depois vermos como se d sua integrao com aplicaes Java. No quarto e ltimo volume, voc aprender a criar aplicaes distribudas utilizando duas abordagens: a de sockets e a de objetos distribudos. Em todos estes volumes, reutilizaremos conceitos aprendidos no curso de linguagem de programao II, e sempre que possvel, utilizaremos o estudo de caso desenvolvido anteriormente, o sistema de controle bancrio, para apresentar os novos conceitos de cada captulo. Portanto, de fundamental importncia que voc tenha bem sedimentado os conceitos de orientao a objetos para dar prosseguimento a esta disciplina. No mais, espero que voc aproveite este material para aprofundar-se ainda mais sobre como deve-se construir aplicaes mais robustas e prximas de cenrios reais do desenvolvimento de software na atualidade. Bons estudos! Fernando Trinta Professor Autor

Programao III

Conhecendo o Volume 2
Neste segundo volume, voc ir encontrar o Mdulo 2 da disciplina Programao III. Para facilitar seus estudos, veja a organizao deste segundo mdulo.

Mdulo 2 Uma introduo ao paradigma orientado a objetos

Carga Horria do Mdulo 2: 15 h Objetivo do Mdulo 2: Introduzir o conceito de framework ou arcabouo de software. Apresentar a API collections como paradigma de programao orientada a objetos. Apresentar o modelo de programao orientado a eventos, a partir da construo de interfaces grficas em Java.

Contedo Programtico do Mdulo 2

Frameworks de desenvolvimento orientados a objetos: vantagens e desvantagens. O Framework java.util.Collections. Construo de Interface Grfica em Java. Conteiners, Componentes e Gerenciadores de Leiaute. Tratamento de eventos em Java. O padro de projeto observador. Ouvintes de Eventos. Classes Annimas e Internas.

Programao III

Captulo 1
O que vamos estudar neste captulo?
Neste captulo, vamos estudar os seguintes temas: Frameworks de software.

Metas
Aps o estudo deste captulo, esperamos que voc consiga: Aprender os conceitos relacionados com frameworks de software.

Programao III

Captulo 1 Frameworks Orientados a

Objetos
Vamos conversar sobre o assunto?
Caro cursista, voc viu no captulo um do mdulo anterior que um dos caminhos utilizados pela engenharia de software para diminuir o esforo e lidar melhor com a complexidade dos atuais sistemas de informao o reuso. A reutilizao de cdigo e outros artefatos permite que se ganhe tempo, economize dinheiro e se reaproveite solues que j tenham sido utilizadas e testadas previamente. Este primeiro captulo tambm segue esta mesma premissa ao apresentar para voc o conceito de frameworks (ou arcabouos) de desenvolvimento.

1. Introduo
Os avanos tecnolgicos alcanados ao longo dos anos levaram concepo de aplicaes cada vez mais complexas. A heterogeneidade de plataformas, incluindo diferentes arquiteturas de hardware, sistemas operacionais, linguagens de programao, dentre outras, levam a dificuldades na eficincia e manuteno dos sistemas modernos, bem como na portabilidade e no controle de gastos de construo dos mesmos. No captulo um do primeiro volume desta disciplina vimos que uma resposta a estes problemas buscada por meio do reuso de software. Conceitos como arquitetura de software e padres de projeto buscam promover reuso em diferentes nveis de abstrao, chegando at mesmo em princpios bsicos da orientao a objetos, como herana e polimorfismo. Outro conceito que foi amadurecendo aos longos dos anos e que hoje se estabeleceu como uma estratgia extremamente til para se alcanar o reuso o de frameworks orientados a objetos. De maneira sucinta, um framework (tambm referenciado como arcabouo) uma aplicao semi-completa e reusvel que deve ser especializada para produzir outras aplicaes mais especficas e concretas, como ilustrado na Figura 1.

Figura 1 - Viso do Desenvolvimento utilizando frameworks

Programao III Observe que a Figura 1 passa a ideia que um framework uma aplicao quase completa, mas com pedaos faltando. Ao utilizar um framework, o trabalho de um desenvolvedor consiste em prover os pedaos que so especficos para a aplicao em desenvolvimento. Com isto, o tempo para produo de uma aplicao reduzido, promovendo reuso de projeto e de cdigo. As aplicaes-alvo de um determinado framework devem ter um razovel nmero de aspectos em comum. Em outras palavras, frameworks so voltados para aplicaes que pertencem a um mesmo domnio de aplicao, como jogos, aplicaes web, dentre outras. Neste captulo vamos entender melhor o que so frameworks, quais so os tipos existentes, assim como suas vantagens e desvantagens. Para melhor exemplificar seu uso, utilizaremos como estudo de caso o framework collections oferecido pela plataforma Java para lidar com famlias ou colees de objetos. Este framework muito utilizado em programas escritos na linguagem e ser til nos captulos futuros de nossa disciplina. Ao estudar este framework, aproveitaremos para tambm apresentar novas sintaxes oferecidas pela plataforma Java para facilitar o desenvolvimento e reuso de aplicaes, principalmente o conceito de tipos genricos.

2. Conceito de Frameworks
A ideia de frameworks de desenvolvimento no nova. Desde meados da dcada de oitenta que o termo j era mencionado em pesquisas sobre linguagens orientadas a objetos. Desde ento vrias foram as definies propostas na literatura. Algumas delas so citadas a seguir: 1. Um framework um conjunto de classes que encapsula um projeto abstrato para solues de uma famlia de problemas relacionados. 2. Um framework um conjunto de objetos que colaboram para realizar um conjunto de responsabilidades para um subsistema de um domnio de aplicao. 3. Um framework um conjunto de classes abstratas e a forma que objetos nestas classes colaboram. 4. Um framework um conjunto de classes que cooperam entre si e constituem um projeto reusvel para uma classe especfica de aplicaes. 5. Um framework um conjunto extensvel de classes orientadas a objetos que so integradas para executar conjuntos de comportamento computacional bem definidos. 6. Um framework uma coleo abstrata de classes, interfaces e padres dedicados a solucionar uma classe de problemas por meio de uma arquitetura extensvel e flexvel. 7. Um framework uma biblioteca de classes que captura padres de interao entre objetos. Este constitui-se de um grupo de classes concretas e abstratas, explicitamente projetadas para trabalhar em conjunto. 8. Um framework um conjunto de classes que constituem um design abstrato para solues de uma famlia de problemas. 9. Um framework um conjunto de objetos que colaboram com o objetivo de cumprir um conjunto de responsabilidades para uma aplicao ou um domnio de um

Programao III subsistema. 10. Uma arquitetura desenvolvida com o objetivo de se obter a mxima reutilizao, representada como um conjunto de classes abstratas e concretas, com grande potencial de especializao. Os dez conceitos apresentados anteriormente apesar de escritos de diferentes formas, buscam ressaltar diferentes aspectos que so tratados por frameworks, como a colaborao entre classes, o foco em reuso, extensibilidade e flexibilidade, alm do fato de tratarem problemas comuns a uma determinada classe ou domnio de aplicaes. De modo a unificar tais conceitos, uma definio mais completa seria: Um framework prov uma soluo para uma famlia de problemas semelhantes, usando um conjunto de classes e interfaces que mostra como decompor a famlia de problemas e como objetos dessas classes colaboram para cumprir suas responsabilidades. Este conjunto de classes deve ser flexvel e extensvel para permitir a construo de vrias aplicaes com pouco esforo, especificando apenas as particularidades de cada aplicao.

2.1 Diferenas entre um Framework e uma Biblioteca de Classes

Uma importante considerao que por vez se confunde a ideia de um framework com uma biblioteca de classes. Porm, h uma importante distino entre os dois conceitos. Em uma biblioteca de classes, cada classe nica e independente das outras, enquanto em um framework, as colaboraes e dependncias esto embutidas. Com biblioteca, as aplicaes criam estas colaboraes. No framework, um modelo de colaborao definido de antemo, desde o processo de anlise e design do prprio framework, fazendo com que o desenvolvedor tenha que se adaptar ao mesmo. O modelo de pr-definido de colaborao de uma framework induz que a comunio entre objetos j est definida, e o desenvolvedor de uma aplicao que utilize o framework no precisa saber quando chamar cada mtodo: o framework se encarrega de fazer isso. Geralmente, frameworks so concebidos em cima de conceitos mais abstratos como padres de projeto. Exemplo: Design patterns so frequentemente usados para documentar frameworks

3. Caractersticas Bsicas de Frameworks

Existem frameworks para diversos domnios de aplicao, desde aplicaes web, passando por jogos e chegando at aplicaes de tempo real. Embora possuam propsitos diferentes, estes frameworks possuem caractersticas comuns. Algumas delas so citadas a seguir. Primeiramente, um framework deve ser reusvel, afinal este seu propsito final. O fato de um framework poder ser reutilizado em diversos projetos, indica que o mesmo deve possuir caractersticas como facilidade de uso, uma boa documentao e facilidade de extenso. Estas caractersticas aumentaro a aceitao de um framework pela comunidade de desenvolvedores de aplicaes. Um framework contm funcionalidade abstrata que deve ser completada por seus usurios. Seu uso deve oferecer segurana a quem queira utiliz-lo. Esta segurana busca passar a ideia que um desenvolvedor no pode destruir um framework e fazer com que ele se comporte de uma forma indesejvel.

10

Programao III Uma questo muito importante a eficincia de um framework, pois em vrias situaes, as aplicaes possuem fortes restries sobre seu desempenho. Se ao usar um determinado framework houver srias penalizaes no tempo de execuo de suas tarefas, o uso do framework ser desencorajado. Outra caracterstica importante a completude do framework. Idealmente, um framework deve enderear o domnio do problema pretendido. Em outras palavras, um framework para comrcio eletrnico deve oferecer solues para todas (ou pelo menos principais) questes relacionadas a estes tipos de aplicaes.

4. Vantagens e Desvantagens no Uso de Frameworks

Existem vrios pontos positivos no uso de frameworks, mas tambm existem fatores negativos em sua utilizao. Um primeiro benefcio a reduo do tempo de desenvolvimento das aplicaes, uma vez que haver um reuso de anlise, projeto e cdigo de vrios componentes que sero reaproveitados na criao de cada nova aplicao. Esta reduo de tempo implica tambm em uma reduo de custos, uma vez que quanto menos tempo de desenvolvimento, menos gastos o projeto ter. O uso de frameworks tambm proporciona que os desenvolvedores possam se concentrar em aspectos especficos de cada aplicao desenvolvida, uma vez que as questes comuns ao domnio de sua aplicao j estaro solucionadas pelo framework. Com isso, menos cdigo especfico gerado, o que tambm leva a uma reduo no esforo de manuteno dos programas, levando tambm a uma estabilizao melhor do cdigo, com menos defeitos devido ao uso em vrias aplicaes, gerando uma melhor consistncia e compatibilidade entre mesmas. Outro aspecto importante que frameworks servem como um repositrio onde o conhecimento de especialistas sobre domnios de problemas so armazenados e disponibilizados para serem reutilizados por outras pessoas. Isso muito importante para se preservar o conhecimento gerado ao longo dos anos em uma empresa, onde por exemplo, haja uma sada de um especialista sobre o domnio dos sistemas desenvolvidos. O estabelecimento de um framework permite que todas as decises tomadas ao longo dos anos sejam preservadas, e que quando novos contratados entrem na empresa, consigam utilizar os frameworks desenvolvidos e consigam ser produtivos de forma mais rpida e eficiente. Porm, no h s vantagens. Construir um framework uma tarefa complexa, que requer um forte planejamento. Logo, se tivermos que construir um framework para depois comear a utiliz-lo, os custos sero maiores assim como seu tempo de desenvolvimento. Os benefcios s sero alcanados a longo prazo. Outra questo que, em geral, frameworks impe um modelo de desenvolvimento fixo, onde os desenvolvedores precisam seguir as regras de sua utilizao. Por vezes, tal imposio gera desconforto entre os desenvolvedores. Primeiro, estes desenvolvedores se veem limitados em relao s regras definidas pelos frameworks. Segundo, certos programadores sofrem de uma chamada sndrome do no feito em casa, onde acreditam que em vez de seguir um produto que pode ter sido feito da empresa, poderiam criar um novo framework mais eficiente, ou at mesmo, no utiliz-lo.

11

Programao III

5. Framework Collection
Para exemplificar os benefcios do uso de frameworks, vamos agora estudar um dos mais conhecidos e teis arcabouos orientados a objeto projetados e utilizados na programao de sistemas orientadas a objetos: o framework collections. Este framework parte integrante do pacote java.util, composto por um conjunto de classes e interfaces para representar colees de objetos. Uma coleo neste contexto um objeto que agrupa mltipos objetos em uma nica entidade e que usada para armazenar, recuperar e manipular elementos deste grupo. Trabalhar com grupos de objetos uma necessidade de muitas aplicaes. Para isto em geral, cada programador precisa criar suas estruturas de dados como vetores, pilhas, listas, dentre outras, para manipular suas colees. O framework collections disponibiliza uma API (do ingls Application Programming Interface) para vrios tipos de colees de objetos existentes na computao, como vetores, listas, rvores, dentre outras, encapsulando tanto estruturas de dados quanto algoritmos associados s abstraes do framework. As classes fornecidas permitem que programadores ganhem tempo na implementao de seus sistemas, ao reusar o framework, ao mesmo tempo que abre espao para novas implementaes como pilhas ou filas de objetos. A estrutura do framework fortemente baseada em um conjunto de interfaces que classificam as colees em grupos de objetos, com diferentes caractersticas. Uma vez compreendidas, estas interfaces permitem compreender o funcionamento do framework. A plataforma fornece implementaes especficas das interfaces, sendo que um desenvolvedor pode desenvolver suas prprias implementaes, baseadas nas interfaces disponibilizadas. A hierarquia de interface do framework.

Figura 2 - Hierarquia de Interfaces do framework collection

O framework composto por duas hierarquias distintas de grupos de objetos. Na primeira, a interface Collection generaliza o tipo mais bsico de um grupo de objetos. Esta coleo no possui implementaes diretas, mas uniformiza mtodos para incluso, remoo, consulta, verificao da quantidade e outras mais para manipulao de grupos de objetos. A assinatura dos mtodos da interface descrita a seguir:
public interface Collection {

// Operaes Bsicas int size(); boolean isEmpty(); boolean contains(Object element);

12

Programao III
boolean add(Object element); boolean remove(Object element); Iterator iterator();

// Operaes sobre conjuntos boolean containsAll(Collection c); boolean addAll(Collection c); boolean removeAll(Collection c); boolean retainAll(Collection c); void clear(); // Operaes sobre vetores Object[] toArray(); Object[] toArray(Object a[]);
}

As sub-interfaces Set, SortedSet e List mantm esta definio de interface, mas com caractersticas distintas. Set e SortedSet estabelecem o conceito matemtico de um conjunto, onde no pode haver repetio de elementos. Nenhum novo mtodo adicionado nos conjuntos em relao interface Collection. A diferena entre os dois que um Set no define nenhum critrio de ordenao, enquanto um SortedSet estabelece. List define uma coleo de elementos que ordena os elementos e permite a duplicao de objetos. Alm disso, um objeto que siga a interface List permite ainda um controle sobre a posio onde um determinado inserido ou de onde ele removido. O controle de acesso aos elementos da coleo feito atravs de um ndice. A interface List adiciona novos mtodos para possibilitar a manipulao de ndices, de acordo como apresentado a seguir.
public interface List extends Collection {

// Acesso aos elementos Object get(int index); Object set(int index, Object element); void add(int index, Object element); Object remove(int index); abstract boolean addAll(int index, Collection c); // Busca int indexOf(Object o); int lastIndexOf(Object o); // Iterao ListIterator listIterator(); ListIterator listIterator(int index); // Viso de sub-listas List subList(int from, int to);
}

13

Programao III A interface Map uma representao do framework para colees que precisam mapear um dicionrio de dados, onde cada dados possui uma chave nica que o identifica na coleo. As buscas so feitas de acordo com estes valores da chave de busca. As chaves no podem ser duplicadas, onde cada chave leva a um nico elemento. A listagem a seguir mostra as principais operaes que a interface Map define.
public interface Map {

// Operaes bsicas Object put(Object key, Object value); Object get(Object key); Object remove(Object key); boolean containsKey(Object key); boolean containsValue(Object value); int size(); boolean isEmpty(); // Operaes sobre conjuntos de dados void putAll(Map t); void clear(); // Operaes de transformao em colees do Tipo Collection public Set keySet(); public Collection values(); public Set entrySet();
}

Assim como conjuntos, Map e SortedMap tm como diferena o fato do segundo manter as chaves de pesquisa ordenadas por algum critrio. Note que todas as definies das interfaces so baseadas na classe Object. Isso indica que as colees podem ser utilizadas para agrupar qualquer tipo de objeto, uma vez que a classe Object superclasse de qualquer em Java. No caso de colees de tipos primitivos, as classes wrapper (Integer, Character, Float, etc) podem ser utilizadas para encapsular valores primitivos em objetos. A partir da verso 5.0, a plataforma Java criou o conceito de tipos parametrizados, que auxiliam a definir os tipos das colees, como veremos a seguir. Para facilitar seu uso, o framework fornece implementaes de referncia para as interfaces definidas. A figura abaixo mostra algumas destas implementaes.

Figura 3 - Algumas implementaes de para as interfaces do framework Collection

14

Programao III Cada uma das classes possuem caractersticas peculiares na implementao de uma interface. Por exemplo, a classe LinkedList a implementao de uma list (List) utilizando uma lista ligada. Com isso, esta implementao oferece um tempo constante para operaes de insero e um tempo linear para acesso aos elementos. J a classe ArrayList implementa a lista utilizando um vetor, o que acarreta em um tempo constante para acesso a qualquer elemento da lista. As caractersticas de cada implementao so disponveis na documentao do framework, que pode ser acessada na URL: http://download.oracle.com/ javase/tutorial/collections/.

6. Utilizando Colees na Prtica

Para ilustrar o uso do framework collections, vamos revisitar o sistema bancrio implementado na disciplina de linguagem de programao II. Lembrando do sistema, ele manipula um conjunto de contas. Para representar um conjunto de contas foi definida a interface ConjuntoContas, listada a seguir:
package ufrpe.contas; public interface ConjuntoContas {

public void inserir(Conta conta) throws ContaJaCadastradaException; public void atualizar(Conta conta) throws ContaInexistenteException; public void remover(int numero) throws ContaInexistenteException; public Conta procurar(int numero) throws ContaInexistenteException; public Conta[] getContas();

Figura 4 - Interface ConjuntoContas

Com isso, cada desenvolvedor precisa implementar classes que sigam o contrato definido na interface ConjuntoContas. Vamos ento implementar duas novas classes que utilizam o framework collections para criar conjuntos de contas. Primeiro, vamos utilizar uma lista para guardar um conjunto de contas. Para isto, vamos utilizar a interface List e sua implementao ArrayList. At a verso 5.0 da plataforma Java, a forma para definir uma coleo era utilizando a notao:
List nomeColecao = new ClasseConcreta(); Exemplo: List contas = new ArrayList();

Com isto, a coleo permitia que qualquer tipo de objeto fosse armazenado. Em muitas aplicaes, esta ocasionava um problema de projeto, pois seria interessante limitar o tipo dos objetos que a coleo pudesse conter. Porm, a partir da verso 5, o conceito de tipos genricos permitiu parametrizar as colees de objetos. Assim, possvel utilizar a seguinte notao:
List<Tipo> nomeColecao = new ClasseConcreta<Tipo>(); Exemplo: List<Conta> contas = new ArrayList<Conta>();

15

Programao III Logo, faz-se apenas necessrio implementar uma nova classe que siga o contrato definido na interface ConjuntoContas e utilize uma Lista de Contas para armazenar o conjunto.
package ufrpe.contas; import java.util.ArrayList; import java.util.List; public class ListaContas implements ConjuntoContas{ private List<Conta> contas = new ArrayList<Conta>(); public void atualizar(Conta conta) throws ContaInexistenteException { int posicao = -1; for (Conta c:contas){ if (conta.getNumero() == c.getNumero() ){ posicao = contas.indexOf(c); break;

} } }

if (posicao == -1) throw new ContaInexistenteException(conta.getNumero()); contas.set(posicao, conta);

public Conta[] getContas() { return (Conta[]) contas.toArray(); } public void inserir(Conta conta) throws ContaJaCadastradaException { try { procurar(conta.getNumero()); throw new ContaJaCadastradaException(conta); contas.add(conta);

} }

} catch (ContaInexistenteException e) {

public Conta procurar(int numero) throws ContaInexistenteException { Conta c = null; for (Conta conta:contas){ if (conta.getNumero() == numero ){ c = conta; break;

} } }

if (c == null) throw new ContaInexistenteException(numero); return c;

16

Programao III
public void remover(int numero) throws ContaInexistenteException { int posicao = -1; for (Conta c:contas){ if (numero == c.getNumero() ){ posicao = contas.indexOf(c); break;

} } } }

if (posicao == -1) throw new ContaInexistenteException(numero); contas.remove(posicao);

Vamos ento entender o funcionamento da classe ListaContas, partindo dos mtodos mais simples para os mais complexos, embora todos sejam relativamente parecidos. O mtodo procurar aquele que recebe um nmero de uma conta e retorna o objeto com este nmero caso este exista. Para isto, o procedimento com uma lista percorrer todos os elementos, verificando se o nmero do objeto igual ao nmero pesquisado. Nas verses anteriores do framework, a maneira correta de se varrer um List, seria por meio de um objeto auxiliar chamador Iterator. Ao obter um Iterator de uma coleo, um ponteiro era posicionado no incio desta coleo e o objeto Iterator possua mtodos para varrer e obter os objetos da Lista. Os principais mtodos eram o hasNext() e next(), que permitiam respectivamente, verificar se havia ou no um prximo elemento na lista, enquanto o segundo, obtinha este objeto ao mesmo tempo que posicionando o ponteiro sobre o prximo elemento. Com isso, um tpico cdigo para ler todas as contas de um List seria como o ilustrado a seguir:
Iterator i = contas.iterator(); while (i.hasNext()) { } Conta conta = (Conta) i.next(); System.out.println(conta.getNumero());

Porm, com a introduo dos parmetros nas colees e com a grande utilizao deste tipo de construo, a linguagem Java lanou uma verso compacta deste lao. A verso resumida apresentada a seguir:
for (Conta c: contas){ } System.out.println(conta.getNumero());

Nesta nova construo, a coleo contas lida desde seu primeiro elemento at o ltimo, onde para cada iterao, o valor do objeto corrente atribudo varivel c. Neste lao, os comandos continue e break continuam vlidos, como em um lao convencional. Logo, para verificar se uma conta j est ou no cadastrada, o mtodo procurar busca em todos os objetos da coleo por aquele que possui um determinado nmero. Caso este objeto exista, ele atribudo a uma varivel temporria e o lao interrompido. feito um teste para saber se a varivel temporria recebeu algum objeto, indicando que a conta com o nmero procurado existe na coleo. Se ela no existir (c == null), a exceo ContaInexistente levantada. Caso contrrio, o objeto devolvido como retorno do mtodo. O mtodo inserir reaproveita o mtodo procurar para s permitir a incluso de

17

Programao III contas que no existam na coleo. Para isso, se ao chamar o mtodo procurar, a exceo ContaInexistente for levantada, significa que a conta no existe e portanto, o objeto pode ser includo na coleo. Para adicion-lo, utiliza-se o mtodo add, passando o objeto conta que se quer incluir. Se a exceo no for levantada, ento porque j existe uma conta com o nmero da conta que se quer incluir, o que uma ao ilegal. Por isso, ento levantada a exceo ContaJaExistenteException. O mtodo atualizar segue uma abordagem parecida com a do mtodo procurar. Ao receber um objeto conta, o mtodo busca a posio do objeto que possui o nmero igual ao da conta que se quer modificar. Se esta condio for verdadeira para alguma conta, o mtodo indexOf, retorna a posio do objeto passado como parmetro na lista. Esta posio ou ndice por sua vez utilizada no mtodo set(posicao, objeto) para colocar o objeto passado como parmetro na posio da antiga conta. Caso nenhuma conta seja encontrada, o indice continuar valendo -1, e por isso, uma exceo (ContaInexistente) ser levantada. O mtodo remover muito semelhante ao mtodo atualizar, s que para retirar um objeto da coleo deve-se utilizar o mtodo remove, passando o ndice do objeto que se quer remover. O mtodo mais simples o getContas, que devolve todas as contas existentes na coleo. Para isso, utiliza-se o mtodo toArray, que devolve o conjunto de objetos como um vetor de objetos, e portanto, utiliza-se um cast para transform-lo em um vetor de Contas. Utilizar um Map como estrutura de armazenamento para o conjunto de contas pode simplificar ainda mais a tarefa de um programador. Maps representam necessria para agrupar as contas que so identificadas de forma unvoca por seu nmero. Com isto, o nmero da conta a chave que deve ser usada no mapeamento que leva aos objetos conta da estrutura.
package ufrpe.contas; import java.util.HashMap; import java.util.Map; public class MapContas implements ConjuntoContas { private Map<Integer, Conta> contas = new HashMap<Integer, Conta>(); public void atualizar(Conta conta) throws ContaInexistenteException { procurar(conta.getNumero()); contas.put(conta.getNumero(), conta);

public Conta[] getContas() { return (Conta[]) contas.values().toArray(); } public void inserir(Conta conta) throws ContaJaCadastradaException { try { procurar(conta.getNumero()); contas.put(conta.getNumero(), conta); } catch (ContaInexistenteException e) { }

18

Programao III
public Conta procurar(int numero) throws ContaInexistenteException { Conta c = contas.get(numero); if (c == null) throw new ContaInexistenteException(numero); return c; }

public void remover(int numero) throws ContaInexistenteException { procurar(numero); contas.remove(numero);

} }

Nesta implementao de exemplo, a coleo definida pelo objeto contas, que utiliza a classe concreta HashMap para guardar as chaves e objetos. Utilizando parametrizao, um Map utiliza dois parmetros, um para o tipo da chave e outro para o tipo do objeto que so mapeados pelas chaves. Como os objetos do framework collections no trabalham com tipos primitivos, deve-se utilizar as classes wrapper. O nmero de uma conta um inteiro, e portanto, deve-se utilizar a classe Integer para parametrizar as chaves do Map, enquanto utiliza-se o tipo Conta para parametrizar o tipo de objetos da coleo. Os mtodos da interface ConjuntoContas so reimplementados de acordo com os mtodos oferecidos para objetos do tipo Map. Por exemplo, o mtodo procurar utiliza o mtodo get. Este mtodo recebe como parmetro o valor de uma chave, e retorna o objeto cujo valor da sua chave seja igual ao valor buscado, caso exista. Se no existir, o valor de retorno do mtodo nulo (null). Logo, se o valor for nulo, a exceo ContaInexistente deve ser levantada. Os demais mtodos reaproveitam o mtodo procurar para definir seu comportamento. Os mtodo inserir, por exemplo, insere uma nova conta na coleo apenas caso a chamada ao mtodo procurar levante a exceo ContaInexistente. Para isto, utilizado o mtodo put, onde so passados dois parmentros: a chave e o objeto a ser inserido. No caso, a chave o nmero da conta e o objeto a prpria conta. O mtodo atualizar bem parecido ao mtodo inserir. Porm, ao contrrio do primeiro, o mtodo atualizar s faz sentido se a conta a ser atualizada j existir na coleo. Por isso, a chamada ao mtodo procurar no tem sua exceo tratada. Se esta exceo ocorrer, ela repassada para quem chamou o mtodo atualizar. Caso ela no seja chamada, porque existe uma conta com o nmero que se procura e ento chamado o mesmo mtodo put. Quando este mtodo insere um objeto com um valor de chave j existente no mapeamento, o novo par chave/objeto substitui o valor antigo, dando exatamente o comportamento de atualizao desejado na aplicao. Para remover uma conta da coleo, utiliza-se o mtodo remove, passando a chave do objeto que se quer apagar. Por fim, o mtodo getContas utiliza o mtodo values, que retorna uma coleo dos valores do Map. Como o retorno do mtodo um vetor, encadeado uma chamado ao mtodo toArray desta coleo, e realizado um cast para um vetor de contas. Note que a implementao da classe ficou extremamente enxuta em relao a todas implementao j feitas para um conjunto de contas.

19

Programao III

Exerccios

1. De acordo com o que foi explanado no captulo, explique quais so as motivaes para o surgimento de frameworks? 2. Com suas prprias palavras, defina: o que so frameworks? 3. Cite e explique as principais vantagens do uso de frameworks. 4. Usando o framework collections, crie uma classe chamada LivroVisitas. Esta classe deve ter como atributo nico uma lista (List) de strings. No construtor da classe, este atributo deve ser inicializado. Crie os seguintes mtodos: 1) O mtodo assinar(String nome), que adiciona um nome na lista; 2) O mtodo listar(), que retorna a lista de nomes cadastrados; 3) O mtodo getTotal() que retornar o total de assinaturas cadastradas at o momento; 5. Repita o exerccio anterior, substituindo o tipo do atributo para um Map. 6. Busque informaes sobre o framework de testes em JUnit, identificando sua motivao, principais classes e forma de uso.

Vamos Revisar?
Neste captulo, voc aprendeu como o conceito de frameworks auxilia a criao de sistemas orientados a objetos, ao ofertar uma soluo semi-pronta que pode ser complementada por cada desenvolvedor de acordo com suas necessidades. Voc viu, na prtica, como o framework collections pode ser til para representar colees de objetos. Este framework ser bastante utilizado ainda nesta disciplina.

20

Programao III

Captulo 2
O que vamos estudar neste captulo?
Neste captulo, vamos estudar os seguintes temas: Construo da Interface Grfica do Usurio.

Metas
Aps o estudo deste captulo, esperamos que voc consiga: Entender como funciona o modelo de criao de interfaces grficas em Java, assim como quais so os principais componentes disponveis para construo de janelas; Aprender sobre os conceitos de conteiners e componentes atmicos; Entender como so as regras para o posicionamento e dimensionamento de componentes grficos.

21

Programao III

Captulo 2 Interface Grfica do

Usurio
Vamos conversar sobre o assunto?
Caro cursista, sistemas de informao so criados para facilitar as tarefas de seres humanos. Com isto, uma parte fundamental dos sistemas a sua interface de comunicao com seus usurios. O que vamos estudar nos dois prximos captulos como criar interfaces grficas ricas em componentes como botes, caixas de texto e listas de seleo que busquem facilitar sua utilizao por seus usurios. Estes captulos so extensos e mesmo assim no cobrem todo o assunto, dado que o mesmo bastante volumoso. No entanto, os conceitos aqui expostos sero suficientes para que voc se aprofunde no assunto.

1. Introduo
Como temos ressaltado ao longo deste curso, a informtica tem cada vez mais assumido um papel importante nas atividades da sociedade moderna. Desde sistemas bancrios at jogos digitais, as aplicaes so construdas para pessoas realizarem diversas tarefas de seu cotidiano. Sendo assim, uma questo muito importante a forma como os usurios interagem com as aplicaes. Em geral, para que uma aplicao obtenha sucesso na utilizao por seus usurios, necessrio facilitar a forma como tais usurios interagem com as aplicaes. Nisso, um aspecto fundamental a construo da interface grfica do usurio, comumente chamada de GUI (do ingls, Graphical User Interface). A interface grfica tem uma importncia fundamental para o sucesso de seu sistema. Hoje, basicamente todo sistema oferece metforas como janelas, botes, listas de opes, dentre outras, para facilitar a vida de seus usurios e enriquecer a usabilidade de seus sistemas. Ento, as linguagens de programao devem oferecer formas de criao destas telas. At ento, todos os programas que foram demonstrados nas disciplinas de orientao a objetos utilizaram o console do computador para que o usurio fornea dados e receba informaes dos programas construdos. Apesar de realizarem com sucesso seus objetivos, estas aplicaoes no so agradaveis aos usuarios acostumados aos ambientes grficos como windows, linux ou mac. Chegou a hora de aprendermos como podemos criar aplicaes mais ricas graficamente. Para isto, este captulo vai apresentar as bibliotecas AWT (do ingls, Abstract Windowing Toolkit) e Swing. Estas bibliotecas fornecem um conjunto de classes e interfaces que permite que programadores em Java construam aplicaes grficas utilizando os componentes mais conhecidos e utilizados em aplicaes modernas. Tanto AWT quanto Swing possuem um modelo de programao orientado a eventos, como o clicar em um boto, mudar o foco de um determinado componente, etc. Devido a extenso dos assuntos, vamos dividir sua apresentao em dois captulos. Neste

22

Programao III captulo sero apresentados seus principais componentes e a relao entre eles. No captulo que segue, ser apresentado o modelo de tratamento de eventos utilizado para dar vida s requisies do usurio de acordo com a manipulao dos componentes da interface grfica do usurio.

2. Modelo de Construo de Aplicaes Grficas em Java

Uma questo importante, antes de se detalhar aspectos especficos de construo de uma interface grfica em Java, entender a organizao de como estas interfaces so estruturadas. Para isto, vamos utilizar uma analogia onde as construo de interfaces seria como colar adesivos em uma folha em branco. Para isto, a folha de papel na qual cada interface construda serve como suporte bsico, sobre o qual outros elementos so dispostos. A folha de papel assume o papel de um recipiente, cujo termo mais utilizado ser o de conteiner. Na construo de uma interface, adesivos de diversos tamanhos podem ser distribudos e afixados na superfcie do papel. Estes adesivos ajudam a organizar a disposio dos elementos sobre a folha de papel principal e so chamados de painis. Existem ainda outros adesivos mais elaborados que representam elementos pr-definidos como rtulos, caixas de texto, botes, etc. Estes componentes so distribudos diretamente na folha em branco ou dentro de algum dos painis existentes, sendo que quando colocados dentro de uma painel, so tratados como um grupo. Na organizao de uma GUI, os elementos grficos pr-definidos so chamados de componentes atmicos (tambm chamados de componentes visuais, controles ou widgets). Estes representam os aspectos visiveis de uma interface grfica, como botes, campos de texto, dentre outros. Estes elementos so definidos como classes onde objetos so ento instanciados para compor as telas de interao do usurio. Os componentes atmicos so agrupados em recipientes, referenciadas como conteiners, e tambm so definidos em classes da plataforma Java. Estes recipientes podem conter um ou mais componentes, assim como outros conteiners. Esta composio fundamental para a criao de interfaces mais aprimoradas. Nesta composio, painis so chamados de conteiners intermedirios, pois tipicamente servem para o agrupamento de componentes atmicos e manipulao destes como um grupo. Componentes de mais alto nvel representam as janelas de apresentao para o usurio. A Figura 5 ilustra um exemplo de como diferentes componentes grficos podem ser agrupados em conteiners para organizar a apresentao de uma tela para o usurio final.

Figura 5 - Exemplo do Uso de Recipientes e Componentes Visuais

23

Programao III A utilizao de componentes atmicos e conteiners cria um modelo bastante interessante para concepo das interfaces grficas. Porm, existe uma srie de outros aspectos que precisam ser aprendidos para comearmos a criao de uma simples janela.

3. Bibliotecas para Criao de Interfaces Grficas em Java

Basicamente, como tudo em Java, a criao de interfaces grficas baseada no modelo de objetos. Para isto, as classes e interfaces relacionadas a este propsito esto agrupadas em dois grandes pacotes: o java.awt (pacote de ncleo) e o javax.swing (pacote de extenso). Ambas ainda hoje esto presentes na plataforma Java, e fazem parte de um importante componente chamado Java Foundation Classes (JFC). Este componente composto de cinco partes que englobam recursos para construo de interfaces grficas (GUIs), alm de interatividade aos aplicativos Java. Fazem parte do JFC as bibliotecas de acessibilidade, internacionalizao, Java2D e Look-and-feel. Cada um destes componentes trata de um aspecto importante da concepo da interface grfica de uma aplicao, porm os aspectos principais se concentram hoje sobre a biblioteca Swing.

3.1. Abstract Windowing Toolkit

A biblioteca AWT foi a proposta inicial da plataforma Java para construo de interfaces grficas mais elaboradas. Porm, AWT utiliza aspectos nativos da plataforma sobre o qual a aplicao esteja sendo executada para construir os elementos de suas telas e janelas. Esta opo de projeto faz com que a aparncia dos componentes mude quando se troca a plataforma de execuo, por exemplo, do Windows para o Linux. Com isto, o projeto de AWT acabou limitando as possibilidades de interfaces grficas a um denominador comum presente nas plataformas compatveis com kit de desenvolvimento Java. Alm desta limitao, as aplicaes escritas em Java apresentavam comportamentos distintos ao utilizar AWT. Isto acabou sendo um grande problema para Java que tinha como um de seus pontos mais destacados, a portabilidade de suas aplicaes. Hoje, A biblioteca AWT est desatualizada, sendo substituda pela biblioteca Swing.

3.2. Biblioteca Swing

Swing foi a resposta da plataforma Java aos problemas existentes na biblioteca AWT. Para isto, todos seus componentes foram escritos totalmente em Java. Com isto, Swing assegura que aplicaoes desenvolvidas em diferentes plataformas tenham a mesma aparncia e comportamento. No incio, o preo a ser pago foi o desempenho. Aplicaes escritas em Swing tinham um desempenho pior que aqueles escritos com AWT. Porm, com a evoluo da plataforma Java, esta diferena tem cada vez mais sido reduzida. Hoje, os componentes Swing so mais populares e poderosos que os da biblioteca AWT, sendo que alguns componentes Swing so construdos como extenses de componentes AWT. Na realidade, para cada componente AWT existe um componente swing alternativo, com funcionalidades a mais. Os nomes dos componentes so inclusive relacionados, onde os componentes seguinte so iniciados com um J, como JLabel, ou JButton, enquanto os componentes AWT so nomeados Label ou Button.

24

Programao III Apesar de garantir a portabilidade, Swing ainda utiliza certas classes da biblioteca AWT, que no presas a cdigo nativos de plataformas especficas, o que indica estas bibliotecas no so mutuamente exclusivas entre si. Porm, recomenda-se que ao se criar uma interface grfica no se misture os componentes AWT com componentes Swing. Pelas questes apresentadas, este captulo foca nos componentes Swing. Porm, de acordo com o modelo utilizado nas duas bibliotecas, o aluno no dever sentir dificuldades caso opte em utilizar a biblioteca AWT.

4. Hierarquia de Classes para Componentes e Conteiners

Tanto AWT quanto Swing utilizam o mesmo modelo de organizao para construo de interfaces grficas, baseadas na analogia de conteiners, painis e componentes atmicos. A Figura 6 apresenta de forma simplificada a hierarquia de classes utilizada para representar cada um de containers e componentes.

Figura 6 - Hierarquia Simplificada de Classes Swing e AWT

Nesta figura, a classe java.awt.Component representa qualquer componente utilizado para criar uma tela em Java, quer seja um componente atmico ou um conteiner. Esta classe possui mtodos para posicionamento, tamanho, visibilidade, tratamento de eventos, bem como uma srie de procedimentos comuns a todo tipo de componente. Por ser a raiz da hierarquia de componentes, seus mtodos esto presentes em todos componentes grficos. Dentre os principais mtodos, pode-se citar: void paint(java.awt.Graphics), void repaint(), void update(java.awt.Graphics): Estes trs mtodos so utilizados pelo sistema para desenhar cada componente. Em geral, no so mtodos que so modificados pelo desenvolvedor. Porm, possvel utilizar o objeto do tipo Graphics para modificar o comportamento convencional de um componente. Este componente permite que se utilize primitivas como linhas, crculos e pontos para desenhar no componente;

25

Programao III Dimension getSize(): Todo componente possui um tamanho que dado em pixels. Este mtodo retorna um objeto que representa as dimenses do componentes, por meio dos atributos pblicos, width (largura) e heigth (altura); setSize(int, int) ou setSize(Dimension): Altera o tamanho do componente. Este mtodo particularmente til para conteiners, pois deve-se dizer o tamanho inicial da tela; getLocation() e setLocation(int x,int y) estes metodos alteram a localizao dos componentes (em pixels) relativa ao canto superior esquerdo do componente. O tipo de retorno de getLocation() e Dimension; setForeground(java.awt.Color) e setBackground(java.awt.Color) Todo componente possui cores, associadas ao plano principal (foreground) e ao fundo (background) do mesmo. Estes mtodos modificam estes planos e para isso utilizam a classe java.awt.Color; setEnabled(boolean) Um componente pode ser habilitado ou no. Uma caixa de texto no habilitada no permite que texto seja inserido ou modificado. O mtodo em questo permite modificar o estado de um componente, de acordo com o parmetro passado; setVisible(boolean) Um componente pode ficar invisvel ao usurio, quer seja este um container ou um componente atmico. O mtodo setVisible permite definir se o mesmo deve aparecer ou no ao usurio, de acordo com o valor do parmetro passado como argumento do mtodo. A classe java.awt.Container representa a classe raiz para conteiners que permitem que componentes atmicos e outros conteiners possam ser agrupados em um conjunto. Esta classe oferece suporte a este agrupamento, bem como a disposio dos componentes atmicos na rea visvel do conteiner. A Figura 7 apresenta uma verso simplificada da hierarquia de recipientes.

Figura 7 Hierarquia de Recipientes (Containers)

Dentre os principais conteiners destacam-se os Frames, Panels e Applets. O primeiro representa aplicaes visuais convencionais do tipo janela que so executadas a partir do sistema operacional. O segundo representa recipientes que podem ser aninhados para melhor organizar os componentes em uma janela. J applets representam um tipo especial de aplicao que so executadas no contexto de um navegador web, como Internet Explorer ou Mozilla Firefox. Neste captulo no sero abordados applets, embora boa parte dos conceitos apresentados aqui tambm possam ser aplicados a tais aplicaes. Frames e Applets so comumente classificados como conteiners de alto nvel, assim como as caixas de dilogo vistas na disciplina de linguagem de programao I. Painis so chamados de conteiners intermedirios, cuja principal funo facilitar o agrupamento de outros componentes. Os demais componentes como botes e campos de texto so

26

Programao III chamados de componentes atmicos, pois agrupam outros componentes. Componentes atmicos mostram ou obtm alguma informao do usurio. Um container segue um padro de projeto chamado composite ou composio. Neste padro, as propriedades do container so aplicadas a todos componentes contidos por este container. Por exemplo, ao mudar a cor de fundo (background) de um painel ou janela, todos os componentes tm sua cor de fundo tambm alterada. Porm, se um componente atmico redefinir sua cor, esta redefinio se sobrepe sobre a definio do container. Isso permite uma flexibilidade de que mesmo tratando objetos como um grupo, haja liberdade para se tratar cada componente de forma peculiar. Um container serve para agrupar vrios componentes. Para isto, um container possui o mtodo add(Component). Este mtodo sobrecarregado e possui outras verses. No decorrer deste captulo voc aprender mais como utilizar esta operao. Os componentes especficos da biblioteca Swing herdam da classe JComponent. Esta classe estende as funcionalidades disponibilizadas em suas super-classes. A Figura 8 apresenta as principais subclasses de JComponent, e que so utilizados para instanciar componentes grficos nos conteiners das interfaces do usurio.

Figura 8 - Principais componentes Swing

Boa parte destes componentes ser abordada neste captulo, mas no todos.

5. Trabalhando com Conteiners

Como apresentado no incio, a organizao da interface grfica do usurio feita por meio de componentes que agregam outros componentes que representam os vrios

27

Programao III elementos grficos de uma tela, os chamados conteiners. Os containers de alto-nvel, citados na seo anterior, compartilham a ideia de janelas que possuem um painel de contedo onde os componentes da interface grfica so dispostos. Este painel compreende a rea abaixo da barra de ttulo da janela e vai at os limites desta. A forma como os componentes atmicos so apresentados ao usurio vai depender de dois aspectos. Primeiro, do tamanho preferencial de cada componente. Cada componente possui um tamanho que o mesmo define como tamanho ideal que o mesmo deve ocupar na rea de um conteiner. Por exemplo, um rtulo ocupa exatamente o espao necessrio para desenhar o texto associado a si. Segundo, cada conteiner possui um diagramador ou gerenciador de leiaute, que aplica diferentes regras na disposio de seus componentes. Em muitos casos, os gerenciadores podem ou no respeitar os tamanhos preferenciais de um componente atmico. Qualquer que seja a aplicao que apresente uma interface grfica, dever utilizar pelo menos um conteiner, que pode ser um JFrame, ou um JDialog ou um JApplet. A seguir vamos falar sobre os dois primeiros.

6. JFrame
A classe JFrame representa objetos que so comumente utilizados para construo de aplicativos grficos e representam uma janela do sistema nativo em que o programa java esteja sendo executado. Esta janela pode ser movimentada na tela do computador do usurio de forma independente de quaisquer outras janelas da interface grfica do usurio. JFrame uma subclasse das classes java.awt.Window e java.awt.Frame. Por ser subclasse de Window, indica que esta uma janela que possui bordas, um ttulo e botes de minimizar, restaurar e maximizar. O cdigo da Figura 9 apresenta a criao de uma janela simples, com um ttulo.
import javax.swing.JFrame; public class Moldura {

public static void main(String[] args) { JFrame f = new JFrame(Primeira moldura); f.setSize(300, 250);
} Figura 9 - Criao de uma janela Simples f.setVisible(true); }

A criao do objeto f utiliza uma das vrias verses do construtor da classe JFrame. Neste caso, a string passada como parmetro define o ttulo da janela. Depois definido o tamanho da janela, e finalmente exposta para o usurio, utilizando o mtodo setVisible(). Porm, outra possibilidade utilizar herana. Esta mesma janela poderia ser definida segundo o cdigo da Figura 9.

28

Programao III
import javax.swing.JFrame; public class Moldura2 extends JFrame{ public Moldura2(){ super(Primeira moldura); setSize(300,250); setVisible(true); } Figura 10 Criando um JFrame usando herana } public static void main(String[] args) { JFrame f = new Moldura2(); }

No caso do uso da herana, o desenvolvedor pode determinar aes quando o usurio desejar fechar a janela. JFrame so considerados elementos muito pesados, e quando no so mais necessrios, os recursos utilizados devem ser devolvidos para serem utilizados por novos recursos. Por padro, a fechar uma janela, a mesma ocultada do usurio. Para modificar esta ao, o JFrame possui o mtodo setDefaultCloseOperation(int), que pode utilizar as constantes da classe WindowConstants, para determinar novas aes. So elas: DISPOSE ON CLOSE: descarta a janela devolvendo os seus recursos ao sistema; DO NOTHING ON CLOSE: indica que o programador determinar o que fazer quando o usurio designar que a janela deve ser fechada; HIDE ON CLOSE: (o default) a janela ocultada, removida da tela; EXIT ON CLOSE: determina que ao fechar o JFrame, o aplicativo seja finalizado. Essa uma constante definida na classe JFrame, e no na classe WindowConstants; Os mtodos setSize e setVisible, como explicados anteriormente, so utilizados para dimensionar e apresentar a Janela. O dimensionamento de uma janela tambm pode ser feito em funo dos componentes atmicos que ela contm. Por exemplo, se uma janela possui 3 caixas de texto e no lhe atribudo nenhum tamanho inicial, a janela pode ser dimensionada para ocupar o tamanho mnimo necessrio para mostrar os elementos que ela contm. Para isto, o JFrame oferece o mtodo pack, que utiliza os tamanhos preferenciais dos componentes englobados pela janela. Todo componente possui um mtodo getPreferredSize, que retorna seu tamanho preferencial de apresentao. A plataforma Java implementa este mtodo para cada componente visual da plataforma, porm o desenvolvedor pode sobrescrever o mesmo de acordo com suas necessidades. Em relao ao posicionamento, o canto superior esquerdo da janela posicionado nas coordenadas (0,0) da tela do computador, ou seja, no canto superior esquerdo. Podemos alterar essa caracterstica com o mtodo setLocation(int, int).

29

Programao III

7. JDialog
JDialog uma classe utilizada para criao das chamadas caixas de dilogo. Estas janelas representam telas de interao com o usurio para situaes comuns em aplicaes grficas. Existem caixas de dilogo pr-definidas, como a JOptionPane, que j foi apresentada na disciplina de linguagem de programao I. Toda vez que utilizamos um JOptionPane, por baixo dos panos estamos tambm utilizando um JDialog. Apesar de representarem um forma fcil de criao de janelas de interao com usurio, caixas de dilogo so, em geral, mais limitadas que janelas criadas com a classe JFrame. Caixas de dilogo normalmente apresentam ou recebem apenas uma informao por vez, sendo mais utilizadas para efeitos de alerta ou confirmao de aes do usurio. Um aspecto importante que as caixas de dilogo podem ser modais ou no modais. Caixas de dilogo modais fazem com que o acesso a outras janelas da aplicao no seja permitido enquanto a caixa de dilogo esteja em exibio, ao contrrio das no modais. Este comportamento determinado pelo mtodo setModal(boolean). A classe JOptionPane a opo mais comum para criao de caixas de dilogo. Esta classe j apresentada previamente como uma forma simples de entrada de dados pelo usurio permite a construo de caixas de dilogo para apresentaes de mensagens, alertas ou mesmo entrada de um nico dado pelo usurio. A construo de caixas de dilogo com JOptionPane utiliza mtodos estticos, dentre os quais, destacam-se: showInputDialog(String): permite a entrada de um dado do tipo String, como ilustrado no exemplo a seguir.
String retorno = JOptionPane.showInputDialog(Digite o nome do aluno:); System.out.println(O nome digitado foi = + retorno);

showMessageDialog(Component, Object, String, int, Icon): exibe uma caixa de dilogo com texto, cone, posicionamento e ttulo definidos pelo programador. O componente passado como argumento no primeiro parmetro representa alguma janela que serve de referncia para a caixa de dilogo, e sobre a qual a caixa de dilogo ser centralizada. Caso no seja passado nenhuma referncia (null), a caixa de dilogo ser centralizada em relao tela do computador. O segundo argumento representa a mensagem a ser apresentada ao usurio, o que em geral uma string. O terceiro o ttulo da caixa de dilogo. O quarto argumento um inteiro referente ao cone e ao tipo de caixa de dilogo a ser apresentada. possvel utilizar constantes da classe JOptionPane: Tipos de Mensagem

30

JOptionPane.INFORMATION_MESSAGE:

exibe

uma

mensagem

com

Programao III informaes que podem ser dispensadas; JOptionPane.WARNING_MESSAGE: indica mensagem de advertncia sobre algum problema em potencial; JOptionPane.QUESTION_MESSAGE: impe uma mensagem que pergunta algo ao usurio; JOptionPane.PLAIN_MESSAGE: exibe um dilogo que simplesmente contm uma mensagem sem nenhum cone.

O ltimo parmetro um cone que pode ser apresentado com a caixa de dilogo, mas opcional. O cdigo a seguir mostra um exemplo.
JOptionPane.showMessageDialog (this, Aluno inserido com sucesso!, Mensagem, JOptionPane.WARNING_MESSAGE)

showConfirmDialog(Component, Object, String, int, int, Icon, Object[ ],Object) cria uma janela de dilogo para mostrar uma mensagem que exige uma confirmao. Esta confirmao se d por meio de botes criados a partir do valor passado no quarto parmetro. Este valor pode assumir as seguintes constantes: YES_NO_OPTION: apresenta dois botes: YES e NO; DEFAULT_OPTION ou YES_NO_CANCEL_OPTION: apresenta trs botes: YES, NO e CANCEL; OK_CANCEL_OPTION: apresenta dois botes: YES e CANCEL.

Os primeiros trs parmetros so os mesmos do mtodo anterior. O quinto parmetro um inteiro referente ao cone e ao tipo de caixa de dilogo a ser apresentada. O sexto parmetro permite que uma imagem seja associada caixa de dilogo. showOptionDialog(Component, Object, String, int, int, Icon, Object[], Object): Esta ltima opo permite uma personalizao da caixa de dilogo, por meio de seus dois ltimos parmetros. Todos os primeiros parmetros tm funo semelhante ao mtodo anterior. Os ltimos parmetros permitem uma personalizao das opes da caixa de dilogo. Em geral, so passados um array de strings com as opes personalizadas a serem apresentadas nos rtulos dos botes e qual destes deve ser o boto padro.
package cap5; import javax.swing.JOptionPane; public class Exemplo JOptionPane { public static void main(String[] args) { String[] opcoes = {Sim, achei legal!!!, No, muito complicado};

31

Programao III
int escolha = JOptionPane.showOptionDialog(null, Voc gostou deste exemplo?, Ttulo, JOptionPane.INFORMATION_MESSAGE, JOptionPane.DEFAULT_OPTION, null, opcoes, opcoes[0]);

if (escolha == 0) {

JOptionPane.showMessageDialog(null, Que bom que voc gostou!, Resposta, JOptionPane.INFORMATION_MESSAGE);

} } }

Figura 11 - Exemplo de Caixa de Dilogo personalizada

8. Painis
Painis representam conteiners intermedirios, que so comumente utilizados para melhor agrupar outros componentes, inclusive painis. A classe utilizada para esta funo a JPanel, derivada da classe Container. Diferente de applets, frames ou caixas de dilogo, painis no possuem ttulo nem bordas. Alm do JPanel, existem outros subtipos de painis que so muito teis para vrias situaes na criao das telas em Java. Uma delas a classe JScrollPane, que cria um painel com barras de rolagem para controlar componentes que podem conter muitos elementos, e que no podem apresentar todos os elementos ao mesmo tempo. Exemplos de elementos com estas caractersticas so as tabelas, listas ou grandes caixas de texto. J a classe JTabbedPane permite que se crie painis com abas, onde cada aba representa um painel com elementos que so apresentados de acordo com a seleo do usurio. O principal construtor deste painel recebe um inteiro que define em que posio do painel as abas sero posicionadas. Para facilitar seu uso, possvel utilizar as constantes da prpria classe apresentadas a seguir: JTabbedPane.TOP (padro): onde as abas ficam na parte de cima do painel; JTabbedPane.BOTTOM: as abas ficam na parte de baixo do painel; JTabbedPane.LEFT: as abas ficam esquerda do painel; JTabbedPane.RIGHT: as abas ficam direita do painel. Cada aba fica associada a um painel e o JTabbedPane utiliza o mtodo addTab para adicionar uma aba no painel. Este mtodo recebe como parmetros uma string com o rtulo da aba e um painel com os elementos que devem ser apresentados quando a aba for selecionada. A Figura 12 apresenta uma classe que cria uma janela com um JTabbedPane e

32

Programao III duas abas. Cada aba associada a um painel convencional com um rtulo textual.
package cap5; import java.awt.*; import javax.swing.*; public class TesteAbas { public static void main(String a[]) { Frame janela = new JFrame(Janela com abas...); JTabbedPane tabelaDePaineis = new JTabbedPane(JTabbedPane.TOP); JPanel painel01 = new JPanel(); painel01.add(new JLabel(Painel01)); JPanel painel02 = new JPanel(); painel02.add(new JLabel(Painel02)); tabelaDePaineis.addTab(Aba 01, painel01); tabelaDePaineis.addTab(Aba 02, painel02); janela.add(tabelaDePaineis); janela.setSize(350, 200); janela.setVisible(true); } Figura 12 - Exemplo JTabbedPane }

A Figura 13 mostra a execuo de uma janela com um painel que utiliza abas.

Figura 13 - Execuo de uma janela com JTabbedPane

9. Gerenciadores de Leiaute
Os conteiners permitem que os componentes sejam dispostos em uma rea visvel ao usurio para que este interaja com a aplicao. Porm, para determinar como tais componentes atmicos so dispostos preciso entender o conceito de gestores de leiuate.

33

Programao III Um gerenciador de leiaute(do ingls, Layout Manager) um objeto que define uma estratgia de posicionamento de componentes em um conteiner. Estes objetos fazem com que os objetos sejam posicionados atravs de regras bsicas do tipo um componente deve ficar ao lado do outro, este componente tem o mesmo tamanho deste ou um componente acima do seu antecessor, de modo que o programador no necessite determinar de forma minuciosa a posio de um elemento no conteiner. Na teoria, o uso de gestores de leiaute permite que seja utilizada uma abordagem orientada a objeto para a construo da interface grfica do usurio, em que o controle da apresentao de telas e componentes delegada a um conjunto de classes. Na prtica, esta forma de organizao permite que os componentes sejam automaticamente reorganizados em caso de alterao nas dimenses de um conteiner, alm de garantir uma aparncia semelhante em mltiplas plataformas. Cada conteiner possui somente um gerenciador de leiaute e cada conteiner possui um gestor de leiaute default. Para alterar o gestor de leiaute de um conteiner, deve-se utilizar o mtodo setLayout(), passando o objeto correspondente a um gestor de leiaute vlido. Embora esta restrio possa parecer muito rgida, o uso de painis aninhados permite que vrias estratgias de posicionamento sejam utilizadas em uma nica interface grfica do usurio, permitindo um maior refinamento e preciso na distribuio dos elementos. Por fim, preciso ressaltar que gestores de leiaute impem regras que impossibilitam a garantia sobre o tamanho preciso de um determinado componente apresentado em um conteiner controlado por um gerente de leiaute. O tamanho a ser considerado ser ou o tamanho preferencial de um componente ou as regras impostas pelo gerente de leiaute. A seguir vamos apresentar os principais gestores de leiaute disponibilizados em Java.

9.1. FlowLayout
O FlowLayout (Leiaute de Fluxo) o mais elementar dos gerenciadores disponibilizados. Este leiaute o padro para painis e applets, e distribui os componentes sequencialmente da esquerda para a direita, na ordem em que os mesmos foram adicionados no conteiner, de acordo com seu tamanho preferencial. Seu comportamento assemelha-se forma como escrevemos. No caso de no haver mais espao em uma linha, o prximo componente colocado na prxima linha abaixo. Para exemplificar o uso do FlowLayout, o cdigo abaixo insere trs botes em um container do tipo JFrame.
package cap5; import java.awt.FlowLayout; import javax.swing.JButton; import javax.swing.JFrame; public class ExemploFlowLayout{ private JButton botao1 = new JButton(Boto1); private JButton botao2 = new JButton(Boto1); private JButton botao3 = new JButton(Boto1); private JButton botao4 = new JButton(Boto1); public ExemploFlowLayout() { JFrame janela = new JFrame(Janela teste); janela.setSize(200,200);

34

Programao III
} } public static void main(String[] args) { new ExemploFlowLayout(); } FlowLayout f = new FlowLayout(); janela.setLayout(f); janela.add(botao1); janela.add(botao2); janela.add(botao3); janela.add(botao4); janela.setVisible(true);

No cdigo anterior, so adicionados quatro botes em um JFrame cujo gerenciador de leiaute um FlowLayout. Quando h espao suficiente, os botes so apresentados em uma nica linha. Se a janela for redimensionada, verifica-se que os botes so reposicionados e o quarto boto colocado abaixo dos primeiros botes. O alinhamento do FlowLayout pode ser modificado pelo mtodo setAlignment. Este mtodo recebe como argumento um valor inteiro que indica o novo alinhamento. Para facilitar seu uso, a classe FlowLayout fornece constantes relacionadas com o tipo de alinhamento que pode ser utilizado. So elas FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER e FlowLayout.TRAILING. Estas constantes definem, respectivamente, o alinhamento esquerda, direita, centralizado e justificado.

9.2. GridLayout
Este gerente de leiaute divide a rea de um conteiner em linhas e colunas como em uma tabela. As intersees entre linhas e colunas formam clulas e os componentes so adicionados nestas clulas da esquerda para a direita, linha a linha. Toda clula da grade possui a mesma largura e comprimento, sendo que s possvel colocar um componente atmico em cada clula, que ocupa inteiramente o espao da clula. Em outras palavras, o tamanho preferencial de cada componente ignorado.

35

Programao III Para ilustrar tal comportamento, a criao de um JFrame cujo painel de contedo dividido em duas linhas e duas colunas. Nas quatro clulas so inseridos quatro botes.
package cap5; import java.awt.Container; import java.awt.FlowLayout; import java.awt.GridLayout; import javax.swing.JButton; import javax.swing.JFrame; public class ExemploGridLayout{ private JButton botao1 = new JButton(Boto1); private JButton botao2 = new JButton(Boto1); private JButton botao3 = new JButton(Boto1); private JButton botao4 = new JButton(Boto1); public ExemploGridLayout() { JFrame janela = new JFrame(Janela teste); janela.setSize(200,200); GridLayout f = new GridLayout(2,2); Container painel = janela.getContentPane(); painel.setLayout(f); painel.add(botao1); painel.add(botao2); painel.add(botao3); painel.add(botao4); janela.setVisible(true);

} }

public static void main(String[] args) { new ExemploGridLayout(); }

Figura 14 - Exemplo de uma janela GridLayout

36

Programao III

9.3. BorderLayout
Este o gerenciador de leiaute padro para JFrames. Sua organizao divide a rea do conteiner em cinco regies. Quatro delas so baseadas nos pontos cardeais: norte, sul, leste e oeste; e mais a regio central do conteiner. Cada uma destas regies pode conter no mximo um componente. Para facilitar o uso deste gerenciador, a classe fornece constantes para identificar cada uma destas regies. So elas: NORTH, SOUTH, EAST, WEST e CENTER. Cada uma das regies define regras especficas sobre o posicionamento e preenchimento do componente adicionado. As regies norte e sul fazem com que o componente adicionado estenda-se horizontalmente por todo o conteiner, porm tem a altura preferencial do componente respeitada. As regies leste e oeste invertem esta situao. Os componentes estendem-se verticalmente por todo conteiner, ignorando a altura preferencial do componente. Porm, a largura do componente preservada. J a regio central representa o meio do conteiner. Esta regio no honra nem a altura nem largura preferencial do componente, e expande-se por toda a regio restante do conteiner. Se a regio norte ou sul no estiver ocupada, os componentes das demais regies expandem-se verticalmente para preencher o espao restante. Porm, caso a regio central no esteja ocupada, esta rea permanecer vazia, pois os demais componentes no se expandiro para preencher o espao restante. Para incluir um componente em uma rea especfica, o desenvolvedor pode utilizar o mtodo add(componente, regio). O cdigo a seguir ilustra o exemplo.
package cap5; import java.awt.BorderLayout; import java.awt.Container; import java.awt.FlowLayout; import java.awt.GridLayout; import javax.swing.JButton; import javax.swing.JFrame; public class ExemploBorderLayout{ private JButton botao1 = new JButton(Boto1); private JButton botao2 = new JButton(Boto2); private JButton botao3 = new JButton(Boto3); private JButton botao4 = new JButton(Boto4); private JButton botao5 = new JButton(Boto5); public ExemploBorderLayout() { JFrame janela = new JFrame(Janela teste); janela.setSize(200,200); BorderLayout f = new BorderLayout(); Container painel = janela.getContentPane(); painel.setLayout(f); painel.add(botao1, BorderLayout.NORTH); painel.add(botao2, BorderLayout.SOUTH);

37

Programao III
} } public static void main(String[] args) { new ExemploBorderLayout(); } painel.add(botao3, BorderLayout.EAST); painel.add(botao4, BorderLayout.WEST); painel.add(botao5, BorderLayout.CENTER); janela.setVisible(true);

Figura 15 - Exemplo de uma janela usando o BorderLayout

9.4. GridBagLayout
Este , sem dvida, o mais poderoso dos gerenciadores de leiaute que so prdefinidos pela plataforma Java, porm tambm o mais complexo. Ele pode realizar o trabalho de todos os outros gerenciadores de leiaute, sem a necessidade de trabalhar com painis aninhados. O GriBagLayout, assim como o GridLayout, divide a rea de um conteiner em uma tabela, com linhas e colunas. Porm, ao contrrio do GriLayout, componentes podem se espalhar em mltiplas linhas ou colunas, alm de permitirem que os componentes sejam posicionados em diferentes pontos de cada clula. Veja o exemplo da Figura 16, onde diferentes botes so posicionados em clulas de uma tabela. Certos componentes ocupam toda a rea de uma clula (boto 1). Outros estendem-se em mais de uma linha ou coluna e ocupam toda a rea de cada clula (botes 2, 3 e 7). Outros ocupam apenas uma clula e no expandem-se por toda a rea desta clula (botes 4 e 5). J o boto 6, expande-se por duas linhas e ocupa todo o expao na horizontal, mas no na vertical.

38

Programao III

Figura 16 - Diviso de um container segundo um GridBagLayout

Para quem est comeando a construo de uma GUI, um processo mais didtico criar um esboo da sua interface em um papel, e ento traar retas para delimitar as colunas e linhas da tabela. Estas linhas devem ser traadas de acordo com as extremidades de cada componente. Com isso, cada componente ficar incluso em uma ou mais clulas resultantes da interseo das retas traadas. Feito isso, cada componente est contido em uma ou mais clulas. Feito este esboo, o GridBagLayout utiliza uma classe auxiliar para o posicionamento dos componentes chamada GridBagConstraints. Esta classe possui uma srie de atributos que permitem posicionar e determinar as caractersticas de ocupao de uma clula da tabela. Dentre seus principais atributos, destacam-se. gridx: define a coluna em que o canto superior esquerdo do componente ser posicionado; gridy: define a linha em que o canto superior esquerdo do componente ser posicionado; gridwidth: determina o nmero de colunas que o componente ocupa; gridheight: determina o nmero de linhas que o componente ocupa; fill: determina como o componente ir preencher a rea ocupada pelo componente. Esta varivel utiliza constantes da prpria classe GridBagConstraints: NONE: o valor padro e indica que o componente no se expandir em nenhuma direo; VERTICAL: indica que o componente se expandir verticalmente; HORIZONTAL: indica que o componente se expandir horizontalmente; BOTH: indica que o componente se expandir em ambas direes e ocupar toda a regio da clula;

anchor: permite que se determine a qual extremo da clula o componente deve ficar atrelado. Esta constante faz uma analogia aos pontos cardeais para definir constantes relacionadas aos possveis pontos onde se pode fixar um componente, como ilustrado na Figura 17. O valor default para este atributo CENTER;

39

Programao III

Figura 17 - Possveis opes para o atributo anchor

weigthx e weigthy: estes dois atributos servem para determinar a proporo que cada linha ou coluna ocupa no conteiner. Estes atributos so teis quando as janelas so redimensionadas e deseja-se manter a mesma proporo (ou no) entre os componentes. Caso o valor de um destes atributos seja igual a zero, indica que o componente no altera sua altura ou largura. Se todos os componentes utilizarem o mesmo valor, que o comportamento padro, significa que todas as linhas e colunas tero exatamente a mesma largura e mesma altura, e mantero esta proporo quando forem redimensionadas. Porm, se forem usados valores distintos, as clulas com valores maiores ocuparo um espao maior de forma proporcional aos valores das demais clulas de suas linhas ou colunas. A listagem da Figura 16 mostra o uso do gerenciador de leiaute GridBagLayout para criar a tela da Figura 15. Note que o objeto gbc do tipo GridBagConstraints reaproveitado para posicionar cada boto da tela.
package cap5; import java.awt.BorderLayout; import java.awt.Container; import java.awt.GridBagConstraints; import java.awt.GridBagLayout; import javax.swing.JButton; import javax.swing.JFrame; public class ExemploGridBagLayout { private JButton botao1 = new JButton(Boto1); private JButton botao2 = new JButton(Boto2); private JButton botao3 = new JButton(Boto3); private JButton botao4 = new JButton(Boto4); private JButton botao5 = new JButton(Boto5); private JButton botao6 = new JButton(Boto6); private JButton botao7 = new JButton(Boto7); public ExemploGridBagLayout() { JFrame janela = new JFrame(Janela teste); janela.setSize(200, 200); GridBagLayout f = new GridBagLayout(); GridBagConstraints gbc = new GridBagConstraints(); Container painel = janela.getContentPane(); painel.setLayout(f);

40

Programao III
} Figura 18 - Exemplo do uso do GridBagLayout } public static void main(String[] args) { new ExemploGridBagLayout(); } // Coloca o primeiro boto gbc.gridx = 0; gbc.gridy = 0; gbc.fill = GridBagConstraints.BOTH; painel.add(botao1, gbc); // Coloca o segundo boto, fazendo com que ele ocupe duas colunas gbc.gridx = 1; gbc.gridy = 0; gbc.gridwidth = 2; painel.add(botao2, gbc); // Coloca o terceiro boto, fazendo com que ele ocupe duas linhas gbc.gridx = 0; gbc.gridy = 1; gbc.gridwidth = 1; gbc.gridheight = 2; painel.add(botao3, gbc); // Coloca o quarto boto gbc.gridx = 1; gbc.gridy = 1; gbc.gridheight = 1; painel.add(botao4, gbc); // Coloca o quinto boto gbc.gridx = 2; gbc.gridy = 1; painel.add(botao5, gbc); // Coloca o sexto boto, fazendo com que ele ocupe duas colunas gbc.gridx = 1; gbc.gridy = 2; gbc.gridwidth = 2; painel.add(botao6, gbc); // Coloca o stimo boto, fazendo com que ele ocupe trs colunas gbc.gridwidth = 3; gbc.gridx = 0; gbc.gridy = 3; painel.add(botao7, gbc); janela.setVisible(true);

10. Principais Componentes Swing

Visto como podemos construir as janelas, importante ento conhecer alguns dos principais componentes atmicos utilizados para construo de interfaces grficas em Java.

10.1. javax.swing.JLabel
Este componente permite a representao de um rtulo marcado com texto, imagem ou ambos, porm sem a edio do usurio, como apresentado na Figura 19.

41

Programao III

Figura 19 Exemplos JLabel

Para criar um objeto do tipo JLabel pode-se utilizar os seguintes construtores: JLabel(): cria um rtulo vazio, sem texto ou imagem. JLabel(String): cria um rtulo com o texto passado no construtor. Por exemplo, new JLabel(Exemplo de um JLabel sem imagem); JLabel(String, Icon, int): cria um rtulo com o texto passado no primeiro argumento e mais uma imagem passada no segundo argumento. O terceiro argumento um inteiro que determina o alinhamento do texto. Pode-se usar as constantes definidas na prpria classe: LEFT, CENTER, RIGHT, LEADING or TRAILING. Dentre os principais mtodos desta classe, destacam-se: getText(): que retorna o texto do rtulo; setText(String): que modifica o texto do rtulo. A Figura 20 apresenta uma classe que cria 3 rtulos e os apresenta em uma janela.
package cap5; import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JLabel; public class ExemploLabel extends JFrame { JLabel label1; JLabel label2; public ExemploLabel(String title) { super(title); setLayout(new FlowLayout()); label1 = new JLabel(Rtulo 1); label2 = new JLabel(); label2.setText(Rtulo 2); add(label1); add(label2); setSize(100,100);

42

Programao III
} } Figura 20 - Exemplo de JLabel public static void main(String[] args) { ExemploLabel e = new ExemploLabel(Exemplo Label); } setVisible(true);

A Figura 21 apresenta a execuo desta classe.

Figura 21 - Execuo da Classe Exemplo para JLabels

10.2. javax.swing.JTextField e javax.swing.JPasswordField

Estes componentes permitem a representao de um campo de edio de texto de uma nica linha como ilustrado na Figura 22, sendo que o JPasswordField permite a digitao de campos de senha, onde os caracteres so ocultados.

Figura 22 Exemplo JTextField

Para criar um objeto do tipo JTextField pode-se utilizar os seguintes construtores: JTextField() ou JPasswordField: cria um campo de texto ou de senha vazio. JTextField(String) ou JPasswordField(String): cria um campo de texto com o texto passado no construtor. O mesmo vale para o campo de senha. Dentre os mtodos ofertados, os principais so: getText(): que retorna o texto do campo; setText(String): que modifica o texto do campo; setColumns(int): que indica o tamanho em colunas que o campo ocupa no container. A Figura 23 apresenta uma classe que ilustra a criao de caixas de texto e para

43

Programao III digitao de senhas.

package cap5; import java.awt.FlowLayout; import javax.swing.ImageIcon; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPasswordField; import javax.swing.JTextField; public class ExemploCamposTexto extends JFrame { private JTextField campo1; private JPasswordField campo2; public ExemploCamposTexto(String title) { super(title); setLayout(new FlowLayout()); campo1 = new JTextField(10); campo1.setText(Digite aqui!!); add(campo1); campo2 = new JPasswordField(); campo2.setColumns(15); campo2.setText(Senha); add(campo2); setSize(100,100); setVisible(true);

} }

public static void main(String[] args) { ExemploCamposTexto e = new ExemploCamposTexto(Exemplo Campos de Texto); }

Figura 23 - Exemplo do uso de JTextField e JPasswordField

J a Figura 24 mostra a execuo desta classe.

Figura 24 - Execuo da Classe de Exemplo de Caixas de Texto

44

Programao III

10.3. javax.swing.JTextArea
Um JTextArea permite a criao de uma caixa de texto com mltiplas linhas e colunas. Ao contrrio das caixas de texto convencionais, um JTextArea permite longos textos com mais de 256 caracteres. Seu principal construtor aquele em que se informa o nmero de linhas e colunas da caixa de texto. Em geral, o JTextArea deve ser includo em um JScrollPane, de forma que quando o texto inserido for maior que a rea disponvel, sejam apresentadas barras de rolagem horizontais e verticais. A Figura 25 apresenta a listagem de uma classe que cria um JFrame em que inserido um JTextArea de cinco linhas e dez colunas. importante salientar que a quantidade de linhas e colunas depende do tipo de gerenciador de leiaute. Por exemplo, se o gerenciador de leiaute fosse um BorderLayout ou GridLayout, a caixa de texto ocuparia a rea disponvel.
import java.awt.FlowLayout; import javax.swing.JScrollPane; import javax.swing.JTextArea; public class ExemploJTextArea extends JFrame { public ExemploJTextArea () { setTitle(TextArea); JTextArea campo = new JTextArea(5, 10); JScrollPane barras = new JScrollPane(campo); add(barras); setSize(100, 100); setLayout(new FlowLayout()); setVisible(true); } } Figura 25 - Exemplo do uso de JTextArea } public static void main(String[] args) { JFrame f = new ExemploJTextArea ();

J a Figura 26 apresenta a execuo desta classe.

Figura 26 - Execuo de uma classe exemplo de um JTextArea.

45

Programao III A classe JTextArea possui mtodos semelhantes a outros componentes de texto para modificao do contedo. O mtodo setText(string) modifica o texto da caixa de texto, e o mtodo getText() retorna o texto.

10.4. javax.swing.JButton
Este componente permite a representao de um boto de pressionamento, como ilustrado na Figura 27.

Figura 27 Exemplo JButton

Para criar um objeto do tipo JButton pode-se utilizar os seguintes construtores: JButton(): cria um boto com o rtulo de texto vazio; JButton(String): cria um boto com o rtulo de texto preenchido com o texto passado no construtor; JButton(Icon): cria um boto com o rtulo preenchido com uma imagem. A Figura 28 apresenta uma classe que ilustra a criao de dois botes, com e sem imagens. Note que, da mesma forma como caixas de texto e rtulos, botes tambm possuem os mtodos getText e setText que acessam e alteram seus rtulos.
package cap5; import java.awt.FlowLayout; import javax.swing.ImageIcon; import javax.swing.JButton; import javax.swing.JFrame; public class ExemploBotao extends JFrame{ private JButton botao1; private JButton botao2; public ExemploBotao(String title) { super(title); setLayout(new FlowLayout()); botao1 = new JButton(); botao1.setText(Aperte aqui!!); add(botao1); botao2 = new JButton(new ImageIcon(imagens/java.gif)); botao2.setText(Boto com Imagem); add(botao2); setSize(100,100);

46

Programao III
} } public static void main(String[] args) { ExemploBotao e = new ExemploBotao(Exemplo BOTES); } setVisible(true);

J a Figura 29 mostra a execuo desta classe.

Figura 29 - Execuo da Classe de Exemplo de Botes

10.5. javax.swing.JComboBox
Este componente permite a representao de uma caixa de seleo que permite que o usurio selecione uma entre vrias opes possveis, como ilustrado na Figura 30.

Figura 30 Exemplo JComboBox

Para criar um objeto do tipo JComboBox, pode-se utilizar os seguintes construtores: JComboBox(): cria uma lista de seleo vazia; JComboBox(Object[]): cria uma lista composta pelos elementos passados como argumento do construtor. Em geral, repassado um vetor de strings que representa as opes que podem ser selecionadas. Dentre seus principais mtodos esto aqueles relacionados com a opo escolhida pelo usurio. Destacam-se: getSelectedIndex(): retorna a posio do item selecionado pelo usurio. Esta seleo varia de 0 at N-1 itens da seleo; setSelectedIndex(int): posiciona a opo corrente da lista de seleo de acordo com o nmero passado como argumento do mtodo. A Figura 31 mostra uma classe que ilustra o uso de um JComboBox.

47

Programao III
package cap5; import java.awt.FlowLayout; import javax.swing.JComboBox; import javax.swing.JFrame; public class ExemploJComboBoxes extends JFrame{ public ExemploJComboBoxes() { this.setLayout(new FlowLayout()); String opcoes[] = {Opo 1, Opo 2}; JComboBox combo = new JComboBox(opcoes); add(combo); setSize(200,200); setVisible(true); } Figura 31 - Exemplo de JComboBox } public static void main(String[] args) { new ExemploJComboBoxes(); }

A Figura 32 mostra a sua execuo.

Figura 32 - Exemplos da execuo de JComboBox

10.6. javax.swing.JCheckBox, java.swing.JRadioButton e javax. swing.ButtonGroup

Estes componentes permitem a representao de uma caixa de seleo que permite ao usurio ativar ou desativar uma determinada opo ou situao, como ilustrado na Figura 33.

Figura 33 Exemplo JCheckBox

48

Programao III Para criar um objeto do tipo JCheckBox pode-se utilizar os seguintes construtores: new JCheckBox(): cria uma caixa de seleo vazia; new JCheckBox (String): cria uma caixa de seleo com o texto passado no construtor. Por exemplo, new JCheckBox (Opo 1). Estes mesmos construtores valem para a classe JRadioButton. Dentre seus principais mtodos esto aqueles relacionados em saber se uma opo est ou no selecionada. So eles: setSelected(boolean): faz com que o checkbox fique ou no selecionado, de acordo com o valor do argumento boleano passado no mtodo. Caso o valor seja verdadeiro, o checkbox selecionado. Caso contrrio, este no ser selecionado; isSelected(): este mtodo retorna true ou false, se o checkbox estiver ou no marcado. As caixas de seleo podem ser utilizadas individualmente ou em grupo. Neste segundo caso, a ideia que s seja possvel escolher apenas uma entre as opes apresentadas pelas opes que esteja agrupadas em um grupo. Para se agrupar um conjunto de caixas de seleo, deve utilizar a classe ButtonGroup em conjunto com a clase JRadioButton. ButtonGroup oferece um construtor sem parmetros e como principal mtodo o add(JCheckBox). Este mtodo adiciona um JRadioButton ao grupo e faz com que apenas um possa ser selecionado. A Figura 34 mostra uma classe que cria um conjunto de caixas de seleo. A primeira delas permite que se escolha mais de uma opo em relao a um conjunto de pratos favoritos de uma pessoa. J a segunda permite que se escolha apenas uma opo para representar o estado civil de uma pessoa.
package cap5; import java.awt.GridLayout; import javax.swing.ButtonGroup; import javax.swing.JCheckBox; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JRadioButton; public class ExemplobuttonGroup extends JFrame{ public ExemplobuttonGroup() { this.setLayout(new GridLayout(1,1)); JPanel painel1 = new JPanel(); JPanel painel2 = new JPanel(); JLabel label1 = new JLabel(Comidas favoritas); JCheckBox arroz = new JCheckBox(Arroz); JCheckBox feijao = new JCheckBox(Feijo); JCheckBox macarrao = new JCheckBox(Macarro); painel1.add(label1); painel1.add(arroz); painel1.add(feijao); painel1.add(macarrao); add(painel1);

49

Programao III
} Figura 34 - Exemplo de JCheckBox e ButtonGroup } public static void main(String[] args) { new ExemplobuttonGroup(); } ButtonGroup g = new ButtonGroup(); JRadioButton solteiro = new JRadioButton(Solteiro); JRadioButton casado = new JRadioButton(Casado); JRadioButton divorciado = new JRadioButton(Divorciado); g.add(solteiro); g.add(casado); g.add(divorciado); painel2.add(solteiro); painel2.add(casado); painel2.add(divorciado); add(painel2); setSize(200,200); setVisible(true);

A Figura 35 mostra a execuo da classe.

Figura 35 - Execuo da Classe de exemplo de JCheckBox e ButtonGroup

10.7. javax.swing.JList
Este componente permite a representao de uma lista de seleo que permite ao usurio uma ou mais opes, como ilustrado na Figura 36.

Figura 36 Exemplo JList

50

Programao III Para criar um objeto do tipo JList pode-se utilizar os seguintes construtores: new JList(): cria uma lista de seleo vazia; new JList(Object[]): cria um lista composta pelos elementos passados como argumento do construtor. Por exemplo, new JList (new String[]{Opo1, Opcao2, Opcao2}). Dentre seus principais mtodos, pode-se destacar: setSelectionMode(int): este mtodo permite determinar o modo de seleo da lista. So possveis 3 modos de seleo, e para facilitar sua utilizao, o programador pode utilizar as constantes da classe ListSelectionModel. So elas: SINGLE_SELECTION: indica que s se pode selecionar uma opo da lista; SINGLE_INTERVAL_SELECTION: indica que podem ser escolhidas vrias opes da lista, desde que estas sejam contguas; MULTIPLE_INTERVAL_SELECTION: podem ser selecionadas vrias opes da lista, quer estejam contguas ou no. Este o modo padro de todas as listas.

getSelectedValue(): retorna um objeto com a opo selecionada na lista. Caso se tenha passado uma lista de string no construtor da lista, deve-se fazer um cast para string; getSelectedValues(): retorna uma lista de objetos com as opes selecionadas na lista. Em geral, listas so inseridas em painis de rolagem (JScrollPane), de forma que as barras de rolagem sejam automaticamente criadas quando o espao do container no seja suficiente para apresentar todas as opes da lista. A Figura 37 mostra uma classe que insere um JList em um JScrollPane, e por sua vez inclui este painel do JFrame.
package cap5; import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JList; import javax.swing.JScrollPane; public class ExemploJList extends JFrame{ public ExemploJList() { this.setLayout(new FlowLayout()); JList lista = new JList(new String[]{Pernambuco, Cear, Maranho, Bahia, So Paulo,Rio de Janeiro,Piau,Par, Amazonas});

} add(painel); setSize(200,200); setVisible(true);

JScrollPane painel = new JScrollPane(lista);

51

Programao III
} Figura 37 - Exemplo de JList public static void main(String[] args) { new ExemploJList(); }

A Figura 38 mostra a execuo da classe. Veja que possvel selecionar mais de uma opo da lista, mesmo quando estas no so contguas.

Figura 38 - Execuo da classe exemplo de JList

10.8. javax.swing.JTable
Este componente permite a representao de uma tabela com rtulos e clulas, como ilustrado na Figura 39.

Figura 39 Exemplo JButton

Para criar um objeto do tipo JTable pode-se utilizar os seguintes construtores: new JTable(): cria uma lista de seleo vazia; new JTable (Object[], Object[][]): cria uma lista composta onde o primeiro argumento representa um vetor com o nome dos rtulos de cada coluna da tabela, e o segundo argumento uma matriz com os dados de cada clula, como ilustrado a seguir;

52

Programao III
String[] rotulos = { Nome, Email }; String[][] dados = { { Fernando, fernando@ufrpe.br }, { Maria, maria@ufrpe.br } }; JTable campo = new JTable(dados, rotulos);

Da mesma forma como na JList, em geral, a JTable inserida em um painel de rolagem, para que quando houver mais linhas ou colunas que a rea possa apresentar, as barras de rolagem permitam rolar estas colunas ou linhas.

11. Menus
Um conceito bastante comum em aplicaes a ideia de menus. Em geral, toda aplicao possui um conjunto de menus na parte superior da janela principal, que agrupam um conjunto de funes afins, de modo a facilitar o uso da aplicao pelos seus usurios. Em Java, Menus so criados a partir da classe JMenu, e podem ser adicionados a janelas por meio do mtodo add(JMenu) de um objeto do tipo JMenuBar. Este ltimo objeto representa uma barra de menus, fornecendo operaes para o gerenciamento da barra onde os menus so anexados. As barras de menu so anexadas s janelas como JFrame, JApplet ou JDialog por meio do mtodo setJMenuBar(JMenuBar). Um menu composto por uma srie de itens, onde cada item representado por um objeto do tipo JMenuItem. Os objetos JMenuItem so anexados a um JMenu e aparecem na ordem em que os mesmos so inseridos. interessante que pode haver uma recurso, onde objetos JMenu pode ser includos como itens de outros JMenu, criando a ideia de menus internos. Por fim, existem ainda subtipos de itens de menu, como objetos JCheckBoxMenuItem, semelhantes s caixas de marcao e JRadioButtonMenuItem, semelhantes aos botes de rdio descritos anteriormente. A listagem a seguir mostra a criao de um menu em um JFrame.
package cap5; import javax.swing.JCheckBoxMenuItem; import javax.swing.JFrame; import javax.swing.JMenu; import javax.swing.JMenuBar; import javax.swing.JMenuItem; import javax.swing.JRadioButtonMenuItem; public class ExemploJMenu extends JFrame { public ExemploJMenu() { JMenuBar barraMenu = new JMenuBar(); JMenu menuArquivo = new JMenu(Arquivo); MenuItem arquivoAbrir = new JMenuItem(Abrir); JMenuItem arquivoSalvar = new JMenuItem(Salvar); JMenuItem arquivoFechar = new JMenuItem(Fechar); menuArquivo.add(arquivoAbrir);

53

Programao III
} } public static void main(String[] args) { new ExemploJMenu(); } menuArquivo.add(arquivoSalvar); menuArquivo.add(arquivoFechar); JMenu menuEditor = new JMenu(Editar); JMenuItem editarCopiar = new JMenuItem(Copiar); JMenuItem editarRecortar = new JMenuItem(Recortar); JMenuItem editarColar = new JMenuItem(Colar); JMenu subMenu = new JMenu(Mais opes); JRadioButtonMenuItem opcao = new JRadioButtonMenuItem(Outra opo); subMenu.add(opcao); menuEditor.add(editarCopiar); menuEditor.add(editarRecortar); menuEditor.add(editarColar); menuEditor.add(subMenu); barraMenu.add(menuArquivo); barraMenu.add(menuEditor); setJMenuBar(barraMenu); setSize(200,100); setVisible(true);

Note que existe uma hierarquia na definio de um menu. Primeiro so definidos seus itens, depois estes itens so incluidos em um JMenu. Depois cada JMenu adicionado barra de menu (JMenuBar). Por fim, a barra de menu setada na Janela. A Figura 40 apresenta a execuo da classe.

Figura 40 - Exemplo de um JMenu

Importante frisar que o comportamento ao selecionar uma opo s ser visto na prximo captulo, sobre o tratamento de eventos.

54

Programao III

Exerccios

1. Utilizando os componentes apresentados neste captulo, crie uma janela que servir para cadastrar funcionrios de uma empresa, segundo a figura abaixo.

2. As figuras 41 e 42 apresentam uma aplicao para apresentao dos 100 primeiros nmeros de progresses aritmticas e geomtricas. A atualizao da lista de termos ocorre quando o usurio modifica o tipo de progresso ou o valor da razo. Crie um JFrame utilizando com a interface apresentada. No h necessidade de implementar as funcionalidades que calculam as progresses.

Figura 41 - Progresso Aritmtica

55

Programao III

Figura 42 - Progresso Geomtrica

3. Crie uma classe para a entrada de informaes sobre pessoas, seguindo o modelo da figura abaixo.

4. Crie uma aplicao que pergunte por meio de uma caixa de dilogo o valor da taxa de cmbio do real em relao ao dlar e ao euro. De acordo com estas informaes, apresente um janela com uma tabela (JTable), com os 3 colunas: a primeira para valores em real, a segunda seu valor convertido em dlar e a terceira seu valor convertido em euro. Apresente a tabela de converso para o intervalo de R$ 1,00 at R$ 10.000,00. 5. Crie uma janela para entrada de dados sobre notas de alunos, seguindo o modelo da figura a seguir.

56

Programao III

6. Crie 4 janelas para entrada de dados do sistema bancrio. A primeira para cadastro de um nova conta, a segunda para realizao de crditos e dbitos, a terceira para a realizao de transferncia de valores entre contas e a quarta para a verificao do saldo e do tipo das contas. Este exerccio apenas para a confeco das telas. No necessrio criar as funcionalidades correspondentes.

57

Programao III

Vamos Revisar?
Neste captulo, voc aprendeu a como criar a interface grfica de seus programas por meio de um conjunto de classes conteiners e elementos grficos que representam botes, caixas de texto, dentre vrias outras metforas comuns criao das aplicaes modernas. Voc tambm viu que para determinar como os conteiners posicionam os componentes, Java utiliza o conceito de gerenciadores de leiaute. No prximo captulo voc vai aprender a como dar vida a as estas telas, por meio do tratamento de eventos gerados pela manipulao de seus componentes.

58

Programao III

Captulo 3
O que vamos estudar neste captulo?
Neste captulo, vamos estudar os seguintes temas: Tratamento de eventos da Interface Grfica do Usurio.

Metas
Aps o estudo deste captulo, esperamos que voc consiga: Entender como tratar os diversos eventos possveis na manipulao de uma interface grfica pelo usurio.

59

Programao III

Captulo 3 Tratamento de Eventos

Vamos conversar sobre o assunto?
Caro cursista, este captulo complementa a criao de interfaces grficas em Java ao apresentar como devem ser tratados os diversos eventos causados pela manipulao dos usurios nos componentes das telas das aplicaes.

1. Introduo
No captulo anterior, voc aprendeu a como construir interfaces grficas utilizando os conteiners, gerenciadores de leiaute e componentes atmicos. Porm apenas construir as janelas no suficiente para a interao do usurio com as telas criadas pelos desenvolvedores. necessrio tambm tratar diversos eventos associados manipulao destas telas pelos seus usurios. Exemplos destes eventos so a movimentao do mouse, o clicar sobre um boto, o fechar uma janela, dentre outros. Neste captulo, voc aprender sobre o tratamento de eventos originados pela manipulao das interfaces grficas criadas por desenvolvedores. Este modelo comumente referenciado como programao orientada a eventos e so baseados no padro de projeto chamado observador.

2. O Padro de Projeto Observador

No tratamento de interfaces grficas, a manipulao dos componentes da tela ir disparar vrias aes relacionadas s intenes do usurio ao manipular os botes, caixas de seleo e demais elementos. Desta forma, de acordo com o que acontecer com cada um dos elementos que compe as telas, aes precisaro ser realizadas. Sendo assim, determinados componentes ou partes de uma aplicao so dependentes da notificao de um evento. Por exemplo, uma mensagem de aviso deve ser apresentada (e somente) quando um boto for pressionado. Isto induz que o componente responsvel por apresentar a mensagem deve ficar em constante observao sobre o boto, de modo a vigi-lo para saber o exato instante em que o boto tenha sido pressionado. De forma geral, preciso estabelecer um projeto em que sejam estabelecidas relaes entre (i) componentes que geram eventos de importncia para o funcionamento de uma aplicao e (ii) componentes que dependem destes eventos. O padro de projeto observador (do ingls, observer) um dos padres mais difundidos no mundo, pois esta questo de dependncia entre componentes muito comum em quase todo tipo de aplicaes, sendo que o modelo de tratamento de eventos de Java fortemente baseado em seu projeto. Na estrutura do padro de projeto observador so definidos dois principais tipos de elementos: os observveis e os observadores. A primeira classe representa elementos

60

Programao III que so de interesse de outros elementos e que portanto precisam ficar em constante observao. O segundo tipo representa elementos que tm interesse em aes que ocorram nos observveis e precisam ser informados quando da ocorrncia de um evento em um. A Figura 43 apresenta de forma simplificada os componentes do padro e sua relao. O sujeito representa um objeto que observado e desperta interesse dos observadores. Para ser notificado quando um evento ocorrer, um observador precisa manifestar interesse neste evento. Para isto, o objeto que representa o sujeito observvel mantm uma lista de todos os observadores que tm interesse em seus eventos, alm de mtodos que permitem aos observadores se cadastrarem e se retirarem desta lista.

Figura 43 - Estrutura Simplificada do Padro de Projeto Observador

Quando um evento considerado importante acontece no sujeito observado, o mtodo notificar se encarrega de avisar todos os interessados. Cada observador fornece uma operao especfica que ento chamada pelo sujeito observado, indicando uma notificao da ocorrncia de um evento. A forma como o padro estruturado permite um fraco acoplamento em uma relao de dependncia onde uma fonte tem muitos dependentes, caso tpico que acontece no tratamento de eventos de uma interface grfica. O clicar sobre um boto pode gerar vrias aes independentes entre si, como a incluso de um objeto, a apresentao de uma nova janela, etc. Com a estrutura de um observador, a organizao destas vrias aes acontece de forma organizada.

3. O Tratamento de Eventos em Java

Com o modelo de um observador na cabea, entender o modelo de eventos de Java tende a ser uma tarefa mais tranquila. Em java, o mecanismo de tratamento de eventos inclui trs partes: a origem do evento, o evento e o ouvinte do evento. Relacionando estes elementos com o padro observador, a origem do evento representa o elemento ou sujeito observado. O ouvinte do evento o observador. J o evento um objeto que encapsula vrias informaes sobre o mesmo e que sero teis para que o ouvinte do evento. A Figura 44 ilustra os relacionamentos entre estes componentes.

61

Programao III

Figura 45 - Modelo de Tratamento de Eventos em Java

H uma terminologia prpria em Java para cada um dos elementos participantes do tratamento de eventos. Os objetos listeners (do ingls, ouvintes) representam os observadores de eventos. Os event source (do ingls, fontes de evento) indicam componentes que produzem eventos e que so de interesse dos listeners. Note que uma nica fonte de eventos pode ser de interesse de mltiplos listeners, assim como um nico listener pode manifestar interesse em mais de uma fonte de eventos. Uma origem do evento um objeto que contm mtodos que permitem registrar objetos ouvintes dos eventos que ocorrem nele. Quando um evento ocorre no objeto origem, este ento envia esse evento para todos os objetos ouvintes que foram registrados para ele. Um objeto ouvinte uma instncia de uma classe que implementa uma interface especial chamada de interface ouvinte (listener interface). Os objetos ouvintes vo utilizar o objeto evento recebido para determinar sua resposta ao evento.

4. Principais Tipos de Eventos de uma Interface Grfica em Java

Objetos que representam eventos em java possuem como raiz comum a classe java. util.EventObject, que representa atributos e mtodos comuns a qualquer tipo de evento na plataforma Java. Um exemplo de uma informao comum a qualquer evento a sua origem ou fonte, que pode ser obtida por meio do mtodo getSource. Porm, ao lidar com eventos de uma interface grfica, eventos so especializados para representar os tipos mais comuns de eventos presentes em uma interface grfica. Estes eventos so agrupados nos pacotes java.awt.event e javax.swing.event, e possuem como raiz comum a classe java.awt.event.AWTEvent, sendo que so apresentados na tabela a seguir.

62

Programao III

Nome da Classe

Tipo de Evento Representam eventos de ao, como o clicar

Fontes componentes de ao, como botes, menus, dentre outros Qualquer componente que possa ser afetado pelo mouse Caixas de seleo e similares Componentes de Texto Barras de Rolagem Janelas Componentes de modo geral Componentes afetados pelo teclado

ActionEvent

em um boto ou mesmo a escolha de uma opo em um menu Representam eventos decorrentes de aes

MouseEvent

do mouse, como passar o mouse por cima do componente Representa aes relacionadas a componentes

ItemEvent

que possuem itens a serem selecionados, como mudar a opo selecionada Representam aes de modificao no contedo de componentes textuais Indicam eventos de redimensionamento de componentes Representam eventos relacionados com maximizar, fechar ou minimizar janelas Representam a mudana no foco de um determinado componente, como ele ser selecionado ou deselecionado Indicam eventos como pressionar uma tecla, solt-la, dentre outras Tabela 1 - Principais Tipos de Evento

TextEvent AdjustmentEvent WindowEvent

FocusEvent

KeyEvent

5. Ouvintes de Eventos
A partir dos objetos que definem os principais tipos de eventos existentes, a plataforma Java oferece um conjunto de interfaces para representar os vrios ouvintes para cada um destes eventos. Com exceo do MouseEvent, existe uma relao de um para um entre tipos de evento e a interface que define um ouvinte (ou listener) para este tipo de evento, como apresentado na tabela a seguir.
Tipo de Evento ActionEvent MouseEvent ItemEvent AdjustmentEvent TextEvent WindowEvent FocusEvent KeyEvent Ouvinte ActionListener MouseListener, MouseMotionListener ItemListener AdjustmentListener TextListener WindowListener FocusListener KeyListener

Tabela 2 - Tipos de Ouvintes de Evento

63

Programao III Cada um destes ouvintes define um conjunto de mtodos que reflete as possveis aes mais especficas de um determinado evento. Por exemplo, o evento ocasionado por um mouse por ter sido gerado pela ao de clicar o mouse, de simplesmente mover o mouse ou mesmo do mouse ter passado por cima de um componente. De acordo com a aplicao que se esteja desenvolvendo, cada uma destas aes pode necessitar uma contramedida diferente. A Figura 46 apresenta uma lista de mtodos de alguns dos ouvintes de evento em Java.
ActionListener ItemListener actionPerformed(ActionEvent) ItemStateChanged(ItemEvent) KeyPressed(KeyEvent) KeyListener KeyReleased(KeyEvent) KeyTyped(KeyEvent) mouseClicked(MouseEvent) mouseEntered(MouseEvent) MouseListener mouseExited(MouseEvent) mousePressed(MouseEvent) mouseReleased(MouseEvent) MouseMotionListener TextListener mouseDragger(MouseEvent) mouseMoved(MouseEvent) textValueChanged(TextEvent) windowActivated(WindowEvent) windowClosed(WindowEvent) windowClosing(WindowEvent) WindowListener windowDeactivated(WindowEvent) windowDeiconified(WindowEvent) windowIconified(WindowEvent) windowOpened(WindowEvent) Figura 46 - Mtodos de alguns dos principais ouvintes de eventos em Java

6. Ligao entre Fontes de Eventos e Ouvintes

Apresentados os objetos que representam os eventos e as interfaces que indicam como implementar objetos que devem escutar e tratar os eventos de uma interface, faz-se necessrio ento entender como estes elementos interagem. Os vrios componentes utilizados na construo das telas representam as diversas fontes de eventos que devem ser tratados em uma aplicao. Cada fonte de um tipo de evento deve ento oferecer um mtodo que permita que interessados se registrem nesta fonte para serem informados quando da ocorrncia de um evento. Para isto, toda fonte de um evento possui um mtodo no formato add<TipoListener> (referncia para um objeto do tipo Tipolistener), que permite que um ouvinte se cadastre naquela fonte de eventos. Para melhor ilustrar esta relao, tome-se como exemplo botes. Estes componentes so gerados de eventos de ao, os ActionEvents. Logo, todo boto possui

64

Programao III um mtodo addActionEvent, que recebe como parmetro um objeto do tipo ActionListener. Para deixar este exemplo ainda mais concreto, tome como exemplo a seguinte classe chamada Somador, listada a seguir.
package cap5; import java.awt.FlowLayout; import javax.swing.*; public class Somador extends JFrame { private JLabel rotulo1 = new JLabel(Valor 1:); private JLabel rotulo2 = new JLabel(Valor 2:); private JLabel rotulo3 = new JLabel(Resultado:); private JTextField valor1 = new JTextField(); private JTextField valor2 = new JTextField(); private JTextField resultado = new JTextField(); private JButton botao = new JButton(Somar); public Somador() { setLayout(new FlowLayout()); valor1.setColumns(5); valor2.setColumns(5); resultado.setColumns(5); add(rotulo1); add(valor1); add(rotulo2); add(valor2); add(rotulo3); add(resultado); add(botao); setSize(550,100); setVisible(true);

} }

public static void main(String[] args) { new Somador(); }

Esta classe representa uma pequena aplicao que possui trs caixas de texto, em que quando pressionado o boto Somar, o resultado da soma dos dois nmeros deve ser calculado. A ilustra mostra o que se pretende da aplicao.

Figura 47 - Execuo da Classe Somador

65

Programao III Para que se consiga tal efeito necessrio realizar uma srie de passos. A primeira criar uma classe que sirva como ouvinte para o evento de se clicar sobre o boto somar. O evento gerado pelo clique de um boto um evento de ao, ActionEvent. Logo, para tratar este tipo de evento necessrio criar um ouvinte para eventos de ao, um ActionListener. Este ouvinte, ao ser chamado, dever obter os valores das duas caixas de texto que referemse respectivamente aos valor1 e valor2, som-las e colocar seu resultado na caixa de texto do resultado. A classe SomadorListener faz exatamente isso.
package cap5; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; public class SomadorListener implements ActionListener { private Somador somador; SomadorListener(Somador somador){ this.somador = somador; } public void actionPerformed(ActionEvent arg0) { int v1 = somador.getValor1(); int v2 = somador.getValor2(); somador.setResultado(v1 + v2);

} }

Figura 48 - Classe SomadorListener

Ao implementar a interface ActionListener, a classe SomadorListener precisa dar corpo ao mtodo actionPerformed(ActionEvent), nico mtodo definido para ouvientes de eventos de ao. Para que este mtodo possa fazer a soma dos valores a serem somados, necessrio ter acesso aos campos de texto da classe Somador. Os mtodos getValor1 e getValor2 precisam ento ser definidos na classe Somador para ter acesso aos valores das caixas de texto, alm do que, a classe SomadorListener precisa de uma referncia para a classe Somador, que lhe passada no momento de sua criao em seu construtor. A mostra da verso modificada da classe Somador.
package cap5; import java.awt.FlowLayout; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JTextField; public class Somador extends JFrame { private JLabel rotulo1 = new JLabel(Valor 1:); private JLabel rotulo2 = new JLabel(Valor 2:);

66

Programao III
private JLabel rotulo3 = new JLabel(Resultado:) ; private JTextField valor1 = new JTextField(); private JTextField valor2 = new JTextField(); private JTextField resultado = new JTextField(); private JButton botao = new JButton(Somar); public Somador() { setLayout(new FlowLayout()); valor1.setColumns(5); valor2.setColumns(5); resultado.setColumns(5); add(rotulo1); add(valor1); add(rotulo2); add(valor2); add(rotulo3); add(resultado); add(botao); SomadorListener sl = new SomadorListener(this); botao.addActionListener(sl); setSize(550,100); setVisible(true);

} }

public static void main(String[] args) { new Somador(); } public int getValor1() { return Integer.parseInt(this.valor1.getText()); } public int getValor2() { return Integer.parseInt(this.valor2.getText()); } public void setResultado(int valor){ this.resultado.setText(valor+); }

Figura 49 - Classe Somador modificada para suporte ao tratamento de eventos

O ltimo passo no citado a necessidade de ligao entre a fonte de evento e seu respectivo tratador de evento. Isto feito no ponto em que o objeto boto adiciona a sua lista de ouvintes do recm criado objeto SomadorListener, usando o mtodo addActionListener. Em alguns casos mais simples, a prpria classe que gera o evento pode ser tambm aquela que trata o evento. Neste caso, a classe deve implementar tambm a interface referente ao ouvinte do mesmo. Por exemplo, a classe Somador poderia ser tambm aquela que trata do evento do boto, bastando para isso implementar a interface ActionListener. A

67

Programao III mostra da nova verso da classe Somador onde o tratamento do evento feito na prpria classe.
package cap5; import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton;} import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JTextField; public class Somador extends JFrame implements ActionListener{ private JLabel rotulo1 = new JLabel(Valor 1:); private JLabel rotulo2 = new JLabel(Valor 2:); private JLabel rotulo3 = new JLabel(Resultado:) ; private JTextField valor1 = new JTextField(); private JTextField valor2 = new JTextField(); private JTextField resultado = new JTextField(); private JButton botao = new JButton(Somar); public Somador() { setLayout(new FlowLayout()); valor1.setColumns(5); valor2.setColumns(5); resultado.setColumns(5); add(rotulo1); add(valor1); add(rotulo2); add(valor2); add(rotulo3); add(resultado); add(botao); botao.addActionListener(this); setSize(550,100); setVisible(true);

public static void main(String[] args) { new Somador(); } public void actionPerformed(ActionEvent arg0) { this.resultado.setText((Integer.parseInt(this.valor1.getText()) + Integer.parseInt(this.valor2.getText())+));

} }

Figura 50 - Classe Somador atuando tambm como ouvinte de evento

68

Programao III Outro ponto importante que uma mesma classe pode ser a ouvinte de vrios tipos de eventos, bastando para isso implementar cada interface correspondente a um tipo de evento especfico que se queira tratar. Tome como exemplo a aplicao a seguir.

Figura 51 - Aplicao ExemploOuvintes

Nesta aplicao, h dois tipos de eventos que precisam ser tratados. Um quando alguma caixa de seleo selecionada, e outro quando o boto pintar clicado. O primeiro evento faz com que uma mensagem seja modificada no lado direito da tela. O segundo evento faz com que o pano de fundo desta rea seja pintado de acordo com a cor selecionada. A Figura 52 mostra a listagem desta aplicao.
package cap5; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ExemploOuvintes extends JFrame implements ActionListener, ItemListener{ private JRadioButton opcao1 = new JRadioButton(Azul); private JRadioButton opcao2 = new JRadioButton(Vermelho); private JRadioButton opcao3 = new JRadioButton(Verde); private ButtonGroup grupo = new ButtonGroup(); private JButton botao = new JButton(Pintar); private JPanel painel = new JPanel(); private JLabel rotulo = new JLabel(); public ExemploOuvintes() { criaGUI(); } private void criaGUI() { painel.setLayout(new FlowLayout()); painel.add(rotulo); setLayout(new GridLayout(1,5)); grupo.add(opcao1); grupo.add(opcao2); grupo.add(opcao3); add(opcao1); add(opcao2); add(opcao3); add(botao); add(painel); botao.addActionListener(this); opcao1.addItemListener(this); opcao2.addItemListener(this); opcao3.addItemListener(this); setSize(500,100);

69

Programao III
} public static void main(String[] args) { new ExemploOuvintes(); } public void actionPerformed(ActionEvent arg0) { Color cor = Color.WHITE; if(opcao1.isSelected()){ cor = Color.BLUE; } if(opcao2.isSelected()) { cor = Color.RED; } if(opcao3.isSelected()){cor = Color.GREEN; } painel.setBackground(cor); setVisible(true);

public void itemStateChanged(ItemEvent arg0) { String mensagem = COR: ; String cor = ; if (opcao1.isSelected()) { cor = azul; } if(opcao2.isSelected()){ cor = vermelho; } if (opcao3.isSelected()) { cor = verde; } mensagem += cor; rotulo.setText(mensagem);

} }

Figura 52 - Classe ExemploOuvintes

Note que para dar suporte aos dois tipos de evento, a prpria classe ExemploOuvintes foi definida como uma ouvinte de eventos de ao (ActionListener), quanto de eventos de seleo dos itens (ItemListener). Para isto, os mtodos impostos por cada interface so implementados. O mtodo actionPerformed(ActionEvent) o responsvel por pintar a rea do painel colocado a direita da tela. Por sua vez, o mtodo itemStateChanged(ItemEvent) muda a mensagem toda vez que um item marcado.

7. Adaptadores
Segundo as regras de implementao de interfaces em Java, uma classe que implementa uma interface ouvinte deve definir todos os mtodos declarados nessa interface. Porm, nem sempre desejvel definir todo os mtodos. Algumas interfaces ouvintes possuem vrios mtodos para implementar as aes relacionados com um tipo especfico de evento. Um exemplo a interface MouseListener, que possui cinco mtodos para tratar quando o boto mouse pressionado, clicado ou solto, quando o mouse entra ou sai da rea de um componente. Porm, se um desenvolvedor s precisar tratar de um destes eventos, ele teria que implementar uma classe que criasse todos os cinco mtodos. Por exemplo, se quisssemos criar um ouvinte que toda vez que o mouse passasse por cima de um boto, ele imprimisse uma mensagem, teramos uma classe semelhante a descrita a seguir.

70

Programao III
package cap5; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; public class ExemploMouseListener implements MouseListener { } Figura 53 - Classe ExemploMouseListener public void mouseEntered(MouseEvent arg0) { System.out.println(O mouse est em cima do boto); } public void mouseClicked(MouseEvent arg0) { // No necessrio } public void mouseExited(MouseEvent arg0) { // No necessrio } public void mousePressed(MouseEvent arg0) { // No necessrio } public void mouseReleased(MouseEvent arg0) { // No necessrio }

Para facilitar a vida dos desenvolvedores, a plataforma Java utiliza o padro de projeto adaptador para disponibilizar classes que no exijam a implementao de todos os mtodos. Um adaptador uma classe que j implementa um ouvinte e possui implementaes vazias para todos seus mtodos. Para todo ouvinte que possui mais de um mtodo a ser implementado, existe uma classe adaptadora concreta que utiliza o padro de nomenclatura <NomedoEvento>Adapter. Por exemplo, para a interface MouseListener, existe o adaptador MouseAdapter. Os outros adaptadores so apresentados na Figura 54.
Classe Adaptadora ComponentAdapter ContainerAdapter FocusAdapter KeysAdapter MousesAdapter MouseMotionAdapter WindowsAdapter Interface ComponentListener ContainerListener FocusListener KeyListener MouseListener MouseMontionListener WindowListener

Figura 54 - Classes Adaptadoras

71

Programao III Ao utilizar um adaptador, o desenvolver em vez de implementar a interface, estende a classe, sobrescrevendo apenas o mtodo para o evento que se deseja criar uma ao. Para o nosso exemplo, a classe de tratamento do evento do mouse seria reduzida a verso a seguir.
package cap5; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; public class ExemploMouseAdapter extends MouseAdapter { } Figura 55 - Classe ExemploMouseAdapter public void mouseEntered(MouseEvent arg0) { System.out.println(O mouse est em cima do boto); }

Os demais mtodos que no utilizados na implementao seriam ignorados. Esta uma forma de diminuir o esforo do desenvolvedor no tratamento de eventos, mas no a nica, como ser visto a seguir.

8. Classes Internas e Classes Annimas

Uma aplicao por mais simples que seja, provavelmente necessitar um nmero razovel de classes ouvintes para o tratamento de eventos dos componentes de suas telas. Imaginando uma exploso de classes ouvintes, a plataforma Java oferece duas abordagens para lidar com esta questo. A primeira abordagem so as classes internas, que so classes que definidas dentro de outras classes. Veja o seguinte exemplo:
package cap5; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; public class ExemploClasseInterna extends JFrame { private JButton b1 = new JButton(Clicadas: ); private int contador = 0; public ExemploClasseInterna(String nome) { ActionListener listener = new Eco(); b1.addActionListener(listener); add(b1);

72

Programao III
class Eco implements ActionListener{ public void actionPerformed(ActionEvent e){ b1.setText(Clicadas: + contador++); }

public static void main(String[] args) { JFrame f = new ExemploClasseInterna(teste); f.setSize(300,300); f.setVisible(true);

} }

Figura 56 - Exemplo de uma classe interna

Esta classe cria um boto que a cada clique, modifica o rtulo do mesmo, colocando o nmero de vezes que o mesmo foi clicado. Para dar suporte ao evento de ao do boto, a classe interna Eco definida dentro da classe ExemploClasseInterna. De acordo com a especificao da linguagem, possvel definir uma nova classe em qualquer parte de uma outra classe, at mesmo de um mtodo ou construtor. Ao fazer isto, esta classe torna-se um membro da classe, podendo ser utilizada nos trechos de cdigo da classe que a contm, e apenas nela, pois estas so invisveis para outras classes. Apesar desta desvantagem, classes internas podem ter acesso a membros da classe que a define. Por exemplo, a classe interna Eco tem acesso aos atributos internos da classe externa, pois ela est definida no mesmo nvel de visibilidade destes atributos. Se a classe for definida dentro de um mtodo, a classe interna s ser vista dentro deste mtodo e s ter acesso aos membros (variveis) deste mtodo. Por fim, as aes de tratamento de eventos das telas so simples e esto diretamente relacionadas s classes que agrupam os componentes fontes de evento. Um recurso bastante utilizado para o tratamento de eventos o de classes annimas, classes internas que so definidas no corpo de mtodo, diretamente sobre a chamada de um mtodo. Estas classes so chamadas annimas, pois no lhes so dadas nomes, uma vez que as mesmas so utilizadas e esto diretamente relacionadas a uma fonte de eventos. Como as mesmas no sero reaproveitadas e outras instncias no sero necessrias, no h necessidade de um nome para um acesso posterior. Por isso mesmo classes annimas no possuem construtores. Para ilustrar o uso de classes annimas, a listagem abaixo apresenta a verso da aplicao da Figura 56, s que com esta nova abordagem. O trecho de cdigo em destaque ilustra a criao e uso de uma classe annima.
package cap5; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame;

73

Programao III
public class ExemploClasseAnonima extends JFrame { private JButton b1 = new JButton(Clicadas: ); private int contador = 0; public ExemploClasseAnonima(String nome) { b1.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ b1.setText(Clicadas: + contador++); }

} }); add(b1);

public static void main(String[] args) { JFrame f = new ExemploClasseAnonima(teste); f.setSize(300,300); f.setVisible(true);

} }

Figura 57 - Exemplo de uma classe annima

Veja que o mtodo addActionListener exige que lhe seja fornecido um objeto do tipo ActionListener. A ideia de uma classe annima que a definio e instanciao deste objeto seja feita no mtodo que pede e o solicita. Para isto utilizada a palavra reservada new e o nome da classe ou interface do tipo do objeto que se queira instanciar. Note que mesmo para interfaces possvel utilizar a palavra new. Depois vem o corpo do objeto, que segue a definio de uma classe convencional. Se a classe annima derivada de uma interface, todos os mtodos definidos devem ser implementados. Classes annimas so bastante criticadas por aparentarem uma forma no elegante de se programar, e que, dependendo de sua utilizao, pode tornar o programa ilegvel. Para o tratamento de eventos uma opo interessante, que deve ser utilizada com cautela. Elas devem ser utilizadas para pequenos trechos de cdigo, para evitar uma confuso muito grande em seu programa.

Exerccios

1. Crie uma aplicao segundo o modelo a seguir, que assume o papel de uma calculadora.

74

Programao III

2. De acordo com o exerccio 2 do captulo anterior, crie classes ouvintes para dar suporte s seguinte funcionalidades. Devem ser calculados os 30 primeiros nmeros de uma progresso, quer seja esta aritmtica ou geomtrica. As caixas de seleo so mutuamente exclusivas. Toda vez que o usurio clica em um tipo de progresso ou modifica o valor da razo, os nmeros das progresses devem ser recalculados.

Figura 58 - Progresso Aritmtica

Figura 59 - Progresso Geomtrica

3. De acordo com o exerccio 3 do captulo anterior, d suporte ao tratamento de eventos da janela abaixo. Toda vez que o usurio clicar no boto Adicionar Pessoa, os dados da pessoa devem ser armazenados em uma Lista. Quando o boto listar pessoas for clicado, deve ser apresentada uma janela com um Jtable, apresentando todas as pessoas cadastradas at ento. O menu Limpar Formulrio deve limpar

75

Programao III todos os campos do formulrio.

4 De acordo com o exerccio do captulo anterior, d suporte ao tratamento de eventos da janela abaixo.

O funcionamento deve seguir as seguintes regras: 1) Para alunos de primeiro grau, a mdia de aprovao 5,0 (cinco) e o nmero mximo de faltas 10 (dez). 2) Para alunos de segundo grau, a mdia de aprovao 7,0 (sete) e o nmero mximo de faltas 7(sete).

Quando os dados forem inseridos e o boto calcular situao for pressionado, deve ser mostrada uma caixa de dilogo apresentando a situao do aluno. Caso a caixa de seleo sobre abono de faltas estiver selecionada, o nmero de faltas deve ser desconsiderado para calcular a situao do aluno.

5. Utilizando as 4 janelas criadas no ltimo exerccio do captulo anterior, utiliz-las para a interao do usurio com o sistema de controle bancrio.

Vamos Revisar?
Neste ltimo captulo, voc aprendeu por meio do padro de projeto observador,

76

Programao III a tratar eventos das interfaces grficas. Os ouvintes permitem que se crie um modelo flexvel, onde objetos so notificados quando determinados eventos ocorrem nos diversos componentes de uma GUI. Alm disso, voc tambm aprendeu que para facilitar a vida dos desenvolvedores, java fornece os conceitos de classes internas e annimas.

77

Programao III

Conhea o Autor
Fernando Trinta
Sou professor de cincia de computao, formado pela Universidade Federal do Maranho. Tenho Mestrado e Doutorado em Cincia da Computao pelo Centro de Informtica da Universidade Federal de Pernambuco, com nfase na rea de Sistemas Distribudos. Durante minha ps-graduao, estive envolvido com os temas de objetos distribudos e educao distncia no Mestrado, e jogos digitais, middleware e computao ubqua no Doutorado. Trabalhei no desenvolvimento de sistemas em vrias empresas, privadas e pblicas. Atualmente fao parte do corpo docente do Centro de Informtica da Universidade Federal de Pernambuco. Alm da informtica, gosto muito de esportes em geral e cinema. Mas nos ltimos anos, duas novas paixes tomaram conta do meu mundo: Ian e Ananda.

78