gerenciadores de layout e
tratadores de evento
Objetivos
Esperamos que, ao final desta aula, você seja capaz de:
relembrar e compreender conceitos relacionados aos gerenciadores de •
layout para aplicações visuais e os tratadores de eventos.
Pré-requisitos
É de fundamental importância, para um melhor desenvolvimento e entendimen- to desta aula, que você já tenha fixado os conceitos expostos nas aulas 1 e 2. É importante também conhecer os componentes da biblioteca AWT, para a definição de uma interface mais amigável através da disposição dos componentes, bem como as interfaces necessárias para a implementação dos tratadores de evento.
introdução
No desenvolvimento de aplicações gráficas, interfaces mais amigáveis pro- porcionam uma melhor aceitação por parte dos usuários, uma vez que, além dos aspectos estéticos, uma melhor organização dos componentes visuais de maneira mais eficiente auxilia a reduzir dificuldades de entendimento, locali- zação de componentes ou mesmo agilizam os trabalhos para os usuários mais avançados, com a utilização de teclas de atalho definidas junto ao sistema.
Além disso, uma interface amigável não garantirá o sucesso do sistema se este não desempenhar suas funções da maneira correta, reagindo a ações dos usuários. Desta forma, nesta aula, iremos rever conceitos relacionados aos tratadores de even- tos, porém desta vez de maneira isolada, sendo o ponto central de nosso estudo, onde nos atentaremos a conhecer as interfaces que podem ser utilizadas para o tratamento dos principais eventos. Então, pessoal, uma boa aula e tentem aproveitar ao máximo.
3.1 gerenciamento de layouts
Como visto nas aulas anteriores, quando criamos uma interface em Java podemos utilizar componentes no qual devem ser incorporados a ou- tros componentes, conforme visto, containers Frame e o Panel. Porém, estes funcionam de maneira diferente nas demais linguagens de programação quanto à definição de posições na janela, no qual podem ser especificadas ecoordenadas para sua definição. A linguagem Java fornece os gerencia- dores de layout, responsáveis por, de forma simples, dispor os componentes na interface gráfica. Devido ao fato de tentar se obter o máximo do concei- to de portabilidade, criou-se o conceito de gerenciadores de layout, para que, qualquer que seja o sistema operacional que esteja executando, essa aplicação seja interpretada da mesma forma, evitando surpresas quanto a disposição dos elementos na janela (DEITEL, 2005).
Como visto na disciplina anterior, e até mesmo com exemplos práticos nas aulas desta aula, os objetos podem ser dispostos dentro de janelas e painéis, sendo que estes podem assumir posições relativas em uma janela, tudo definido pelos gerenciadores de layout.
Os gerenciadores de layout são classes especiais que realizam a im- plementação de interfaces, determinando como os componentes presentes em um container são ordenados e posicionados. Desta forma, podem ser definidos gerenciadores para os painéis que irão compor uma determina- da janela, bem como definidos os gerenciadores para os componentes que serão agregados aos painéis. A biblioteca AWT disponibiliza alguns ge- renciadores de layout, sendo eles: FlowLayout, GridLayout, BorderLayout, CardLayout e GridBagLayout (DEITEL, 2005). A seguir iniciaremos uma maior explanação dessas classes.
3.1.1 gerenciador flowlayout
Vamos iniciar esta seção, relembrando os exercícios feitos nas seções e aulas anteriores, então sugerimos uma rápida observação sobre eles para então percebemos a utilização do gerenciador FlowLayout.
Segundo Deitel (2005), o gerenciador FlowLayout consiste no mais simples dos gerenciadores, padrão para os applets e painéis. Neste tipo de gerenciador, todos os componentes são dispostos da esquerda para a direita. Ele obedece a ordem como os objetos são adicionados ao contai-
ner, sendo que os componentes são apresentados em uma mesma linha até que não exista mais espaço nela, isto obedecendo ao tamanho do container, criando-se uma nova linha logo abaixo para a disposição dos outros componentes. Certo, pessoal? Vamos a mais um exemplo para que sejam apresentadas a disposição dos componentes por meio da utilização do gerenciador FlowLayout.
// GerenciadorLayout.java
import java.awt.*; import java.awt.event.*;
public class GerenciadorLayout extends Frame {
// método construtor
public GerenciadorLayout() { super(“Gerenciador Layout”); setSize(200, 115);
setLayout(new FlowLayout()); for (int i=1; i<7; i++)
add(new TextField(“Texto “+i)); }
// método executavel
public static void main(String args[]) {
GerenciadorLayout gerente = new GerenciadorLayout(); EventosWindows evt = new EventosWindows();
gerente.addWindowListener(evt); gerente.setVisible(true); }
}
class EventosWindows implements WindowListener{ public void windowClosing(WindowEvent e){
System.exit(0); }
public void windowClosed(WindowEvent e){} public void windowIconified(WindowEvent e){} public void windowOpened(WindowEvent e){} public void windowDeiconified(WindowEvent e){} public void windowActivated(WindowEvent e){} public void windowDeactivated(WindowEvent e){} }
Como pôde ser observado no exemplo anterior, cria-se uma seqüência de componentes, que, conforme mencionado, é realizada uma quebra de linha a cada momento em que não existe mais espaço para novos objetos na linha. Outro tipo de gerenciador muito utilizado na construção de aplicações gráficas consiste no GridLayout, então vamos a ele.
Pensando sobre o assunto
Como mencionado na aula anterior, todos os tipos de containers da linguagem de programação Java derivam da classe Container, sendo que esta disponibiliza o método setLayout() para a definição do gerenciador de um componente do tipo container. Utilize este método sempre que necessário para a redefinição da disposição dos objetos em sua janela.
3.1.2 gerenciador gridlayout
Conforme mencionado, outro gerenciador de layout trata-se da classe
GridLayout. Esse gerenciador permite que os componentes sejam arruma-
dos em uma grade formada por células de igual tamanho até que toda a área do container, no caso o Frame ou o Panel, seja ocupada (DEITEL, 2005).
Assim como em vetores, podem ser especificadas as quantidades de li- nhas e colunas, sendo que todos os componentes adicionados aos containers ocupam todo o espaço da celula do qual fazem parte, sendo que alterações quanto à sua dimensão são repassadas, automaticamente, para as células e obviamente para os componentes que as ocupam.
Com isto, vamos a um exemplo para que seja observada a disposição dos componentes visuais utilizando este tipo de gerenciador. Para tanto, altere apenas a linha que é responsável pela definição do layout no método construtor do exem- plo anterior, substituindo pelo código no quadro a seguir e execute o programa.
// GerenciadorLayout.java
import java.awt.*; import java.awt.event.*;
public class GerenciadorLayout extends Frame{
// método construtor public GerenciadorLayout(){ ... setLayout(new GridLayout(2,3)); ... } // método executavel
public static void main(String args[]){ ... } }
Se tudo ocorreu como o esperado, provavelmente você deve ter percebido a mudança na disposição dos objetos na tela de seu programa. Isto tudo com apenas a redefinição do gerenciador de layout. A linguagem Java ainda dis- põe do gerenciador BorderLayout, CardLayout e GridBagLayout.
3.1.3 gerenciador borderlayout
Assim como em uma bússola, o gerenciador de layout BorderLayout execu- ta a disposição de componentes em um container dividido em cinco regiões, sendo elas: east, west, north, south e center, no caso direita, esquerda, norte, sul e centro, respectivamente. Este, por sua vez, é o gerenciador padrão para o container Frame da API (Application Program Interface) AWT, bem como JFrame do pacote Swing, conforme foi visto na aula anterior (DEITEL, 2005).
Um detalhe interessante, e que foge do que foi visto até agora para os demais gerenciadores já apresentados, consiste no fato de que a ordem como os componentes são adicionados não afetará o resultado final da tela: eles devem ser adicionados explicitamente a uma região fixa do gerenciador, sen- do que uma vez adicionado um componente, ele ocupará toda a região. Tudo isso foi demonstrado no exemplo utilizado para a apresentação do container criado por meio da utilização da classe Panel, na aula 2 na seção 2.1.1. Desta forma, revisem o exemplo mencionado.
3.1.4 Cardlayout
A partir desta seção, trabalharemos com gerenciadores de layout diferen- ciados frente aos demais apresentados. Embora bem mais flexíveis, estes são muitas vezes ineficientes para resolver alguns problemas. No caso, a classe Car- dLayoout é responsável por gerenciar um layout mais incrementado, que trata os componentes presentes no container como uma pilha de cartas (FILHO, 2005).
Saiba mais
Conforme mencionado, cada região definida pelo gerenciador de layout só pode ser ocupada por apenas um componente, sendo que este é redimensionado ocupando-a toda. Assim, uma vez que dois ou mais elementos forem inseridos na mesma região um sobrescreverá o outro, sendo que o primeiro não estará disponível para visualização ou mesmo acesso (DEITEL, 2005).
Este gerenciador disponibiliza formas de acesso aos diversos componen- tes que podem ser “empilhados” no container, sendo que este permite a exi- bição do primeiro componente ou mesmo o último, ficando livre a navegação entre estes (FILHO, 2005).
Desta forma, é possível navegarmos em diversos componentes Panel ou mesmo Frame, sendo que estes podem conter diversos outros tipos de compo- nentes, conforme demonstrado nas aulas anteriores. Assim, conseguimos obter o aspecto de aplicações com diversas janelas, sendo que estas podem ser acessa- das a qualquer momento por componentes como os Menus. Isto, porém, é mais trabalhoso, uma vez que exige que mais código seja necessário, mas os resul- tados compensam todo o trabalho. O exemplo a seguir demonstra a utilização deste gerenciador visual. Alguns pontos do código foram suprimidos, pois não sofrem alteração do último exemplo apresentado, então os reutilize.
// GerenciadorLayout.java
import java.awt.*; import java.awt.event.*;
public class GerenciadorLayout extends Frame implements ActionListener {
private Panel windows;
private Button anterior, proximo;
// método executável, reutilize o código do outro exemplo
public static void main(String args[]) { ... } // método construtor public GerenciadorLayout() { super(“Janelas”); setSize(250, 100);
// Painel Lateral de Controle
Panel lateral = new Panel();
lateral.setBackground(SystemColor.control); Panel p2 = new Panel();
p2.setBackground(SystemColor.control); p2.setLayout(new GridLayout(2, 1));
p2.add(anterior = new Button(“Anterior”)); anterior.addActionListener(this);
p2.add(proximo = new Button(“Proximo”)); proximo.addActionListener(this);
lateral.add(p2); add(“East”, lateral);
Panel painel1 = new Panel();
painel1.add(new Label(“Segundo Painel”)); painel1.add(anterior);
// Painel Múltiplo
windows = new Panel();
windows.setLayout(new CardLayout());
windows.add(new Label(“Primeiro Painel”), “Janela2”); windows.add(painel1, “Janela2”);
add(“Center”, windows); }
public void actionPerformed(ActionEvent e) {
CardLayout janelas = (CardLayout) windows.getLayout(); if (e.getSource()==anterior) { janelas.previous(windows); } if (e.getSource()==proximo) { janelas.next(windows); } } }
class EventosJanela implements WindowListener{ ...
}
Note que, neste exemplo, consegue-se criar diversos painéis, construíndo o efeito de que existem diversas janelas que são executadas ao clicar sobre os botões. Isto tudo é possível devido às características da classe CardLayout, sendo que tais funcionalidades o diferenciam dos demais. Nosso último geren- ciador consiste no mais complexo, mas também o que mais dispõe de funcio- nalidades dentre os gerenciadores.
3.1.5 gridbaglayout
Finalizando os gerenciadores de layout, apresentaremos o mais flexí- vel dentre todos os apresentados, o GridBagLayout. Assim como o Car- dLayout, devido a esta flexibilidade, este torna-se o mais complexo de todos os gerenciadores (FILHO, 2005).
O GridBagLayout, por sua vez, permite, assim como o GridLayout, definir a posição de componentes em uma tabela com linhas e colunas. Porém, dife- rentemente do gerenciador GridLayout, este é bem mais tratável, permitindo que os componentes sejam adicionados em qualquer ordem, além de poder variar o tamanho das células, sendo que um componente pode ocupar mais de uma linha ou coluna (FILHO, 2005).
Este gerenciador é mais utilizado por programas que utilizam a API Swing, porém este também pode ser utilizada pelos componentes AWT. A utilização deste gerenciador consiste na definição de um objeto para a caracterização, através da classe GridBagConstraints, na qual podem ser definidas a quanti- dade de células, a posição, tamanho e, por exemplo, se o componente deve ocupar todo o espaço da celular. Vamos a um pequeno exemplo para fixação.
// ExemploGridBag.java
import java.awt.*; import javax.swing.*;
public class ExemploGridBag extends JFrame { public ExemploGridBag { super(“Exemplo1”); this.setDefaultCloseOperation(EXIT_ON_CLOSE); Container c = this.getContentPane();
GridBagConstraints cons = new GridBagConstraints(); c.setLayout(new GridBagLayout());
c.add(new Button(“Esquerda”), cons); c.add(new Button(“Direita”), cons);
this.setSize(600,600); }
public static void main(String[] args ) { ExemploGridBag exe = new ExemploGridBag(); exe.setVisible(true);
} }
Conforme mencionado, criado um objeto da classe GridBagConstraints que será o responsável pela redefinição das características da interface como os componentes devem ser apresentados, estes devem ser associados à janela através do método add(). Assim finalizamos nossa seção de gerenciamento de layout e agora iremos trabalhar mais a fundo com os tratadores de eventos.
Saiba mais
Para uma melhor utilização da classe GridBagConstraints, sugerimos leituras complementares para que sejam conhecidas todas as
características que podem ser manuseadas através de uma instância desta classe, enriquecendo suas interfaces através do gerenciamento de layout flexível com a classe GridBagLayout.
3.2 tratadores de eventos
Assim como vimos em diversos exemplos até aqui, os eventos ocorrem quan- do existe uma interação dos usuários por meio de operações com o mouse (pres- sionar um botão ou arrastar) ou através do teclado (pressionando alguma tecla).
O modelo de eventos da AWT é o responsável por este serviço, identificando os objetos em que ocorreram as interações, os sources e os que atuarão como re- ceptores, escutando as mensagens do sistema operacional mais conhecidos como listeners. Neste modelo de eventos, mais especificamente os objetos receptores são os responsáveis por além de receber, processar os eventos reagindo a intera- ção realizada pelos usuários, chamando determinadas tarefas (DEITEL, 2005).
Os eventos são objetos de uma classe, enquanto os listeners são interfaces que implementam os métodos que tratam estes eventos. Usualmente, cada tipo de componente pode disparar certos tipos de eventos que podem ser “escutados” por mais de um listener, conforme é apresentado na Tabela 1 (FLANAGAN, 2006).
evento interface ou aDaptaDor métoDos
ActionEvent ActionListener actionPerformed AdjustmentEvent AdjustmentListener adjustmentValueChanged
ComponentEvent ComponentAdapterComponentListener componentHiddencomponentMoved componentResized ContainerEvent ContainerListenerContainerAdapter componentRemovedcomponentAdded
FocusEvent FocusAdapterFocusListener focusGainedfocusLost ItemEvent ItemListener itemStateChanged
KeyEvent KeyAdapterKeyListener keyReleasedkeyPressed keyTyped MouseEvent MouseListener MouseAdapter MouseMotionListener MouseMotionAdapter mousePressed mouseReleased mouseEntered mouseExited mouseClicked mouseDragged mouseMoved
TextEvent TextListener textValueChanged
WindowEvent WindowAdapterWindowListener
windowClosing windowOpened windowIconified windowDeiconified windowClosed windowActivated windowDeactivated
Alguns destes eventos, interfaces e métodos foram implementados nos exemplos desta disciplina. Assim, vamos finalizar nossa 3ª aula falando de uma maneira mais simples de tratar os listeners.
Como ficou claro no decorrer desta disciplina, ao implementarmos uma interface todos os métodos nela declarados deverão ser redefinidos na classe que a implementa. Conforme pôde ser observado nos diversos exemplos que fizemos até o momento, ou mesmo na Tabela 1, muitas vezes somente um dos métodos nos interessa.
Por exemplo, isto acontece quando uma classe implementa a interface WindowListener, sendo que assim é necessário que se declarem todos os sete métodos que estão definidos na interface. Mas se quisermos tratar somente um determinado evento, quando este ocorre ignorando o restante, sem precisar ficar reescrevendo os métodos que são desnecessários, como podemos agir?
Para podermos fazer isso, apenas redefinimos somente o método que se necessita, ignorando os demais, para tanto utilizamos as classes adaptadoras, que também foram apresentadas na Tabela 1, juntamente com as interfaces.
As classes adaptadoras são classes que já implementam as interfaces lis- tener para os eventos, redefinindo todos os seus métodos (DEITEL, 2005). Porém, os métodos definidos na classe adaptadora não possuem corpo ou funcionalidade, fazendo com isto que tenhamos que utilizar o processo de herança, criando uma subclasse das classes adaptadoras e nela redefinirmos ou implementarmos somente o método que nos interessa. Desta forma, vamos a um exemplo que demonstra tudo o que mencionamos: para fechar uma das janelas de nossos exemplos, era necessário declarar, nada mais, nada menos, que sete métodos da interface WindowListener.
// GerenciadorLayout.java
import java.awt.*; import java.awt.event.*;
public class GerenciadorLayout extends Frame{
// método construtor public GerenciadorLayout(){ ... setLayout(new GridLayout(2,3)); ... } // método executavel
public static void main(String args[]){ ... } }
class EventosWindows extends WindowAdapter{ public void windowClosing(WindowEvent e){
System.exit(0); }
}
Note que apenas alteramos nossa classe EventosWindows e, consideran- do o código apresentado e qualquer outro exemplo, fica claro que as classes adaptadoras reduzem, consideravelmente, o trabalho, sendo apenas necessá- rio que sejam implementados os métodos listerner que realmente serão neces- sários. Isto não é possível quando temos uma classe que já herda de alguma outra classe. Bom, pessoal, assim chega ao fim nossa 3ª aula, espero que todos tenham conseguido sanar qualquer dúvida sobre os conceitos aqui tra- tados, de suma importância para aplicações visuais.
Síntese da aula
Nesta aula, foram apresentados os conceitos relacionados aos métodos cons- trutores, responsáveis por inicializar o espaço de memória de uma instância de uma classe, bem como realizar operações e inicializar atributos e variáveis com valores, tornando possível o perfeito funcionamento da funcionalidades da instân- cia da classe. Da mesma maneira que existem os métodos construtores, existem os métodos destrutores, sendo responsáveis por colocar ordem na casa, liberando espaços de memória e finalizando operações da instância. Porém, diferentemente das outras linguagens de programação, em Java não é necessário se preocupar com a liberação do espaço de memória: Java possui um coletor de lixo automático, que se responsabiliza pela liberação de memória para o bom funcionamento do programa. Finalizando, apresentamos os conceitos vinculados ao encapsulamento, que tem por objetivo, além da segurança evitando acesso direto aos atributos, es- conder detalhes de implementação do usuário, fornecendo somente a real função da classe, sem que os detalhes de como isto ocorrer fiquem explícitos.
Atividades
1. Quais são os gerenciadores de layout definidos pela biblioteca AWT? 2. A implementação de interfaces listener são responsáveis por interpretar os
eventos oriundos da interação do usuário com o sistema. Estas, muitas vezes, se tornam dispendiosas devido a obrigar que todos os métodos da interface sejam declarados na classe que implementa a interface. Dessa forma, qual a outra possibilidade fornecida pela linguagem Java para tratar os eventos?
Comentário das atividades
Na atividade 1, os gerenciadores de layout definidos pela biblioteca AWT consistem nas classes FlowLayout, BorderLayout, CardLayout, GridLayout, Gri- dBagLayout, sendo que este podem ser definidos a qualquer componente que seja um container. Já na atividade 2, a outra possibilidade fornecida pela lin- guagem Java para tratar os eventos de um sistema consiste nas classes adapta- doras, que implementam as interfaces, e desta forma fornecem a possibilidade de que outras classes derivem destas classes adaptadoras e assim, deixa de ser obrigatória a definição de todos os métodos das interfaces listener, sendo somente redefinindo os métodos que realmente serão utilizados pelo sistema.
referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice Hall, 2005.
FILHO, Renato Rodrigues. Desenvolva aplicativos com Java 2. São Paulo: Érica, 2005.
FLANAGAN, David. Java: o guia essencial. 5. ed. Porto Alegre. Bookman, 2006.
na próxima aula
Serão expostos os conceitos sobre conexão de aplicações Java com ban- co de dados, possibilitando a construção de programas que realizem as ope- rações básicas com o manuseio de dados, além de, com isto, enriquecê-los.