Tratamento de eventos para interfaces gráfica

Prévia do material em texto

TRATAMENTO DE EVENTOS PARA INTERFACES GRÁFICA
As aplicações em geral precisam de alguns eventos para o funcionamento completo do programa. Normalmente as GUI´s do Java são baseadas em eventos, que são tarefas realizadas quando um usuário faz a interação com algum componente GUI, convertendo as ações do usuário em eventos, como por exemplo:
Quando ocorre uma ação (ActionEvent);
Clique do mouse (MouseEvent);
Apertar em uma tecla (KeyEvent);
Fechar uma janela (WindowEvent);
As tarefas de respostas realizadas em um evento são conhecidas como handler de evento e o processo total de responder a eventos é conhecido como tratamento de evento. Para cada tipo de evento precisa ser implementada uma interface de escuta.
Handler de Evento
Quando um evento acontece, é realizado o despacho (dispatching) para os ouvintes apropriados. Esse despacho é o processo em que o componente GUI chama um método de tratamento de evento em cada um de seus ouvintes, sendo registrados para o tipo de evento ocorrido.
A ocorrência de um evento faz com que o componente receba um ID único de evento. Esse ID especifica o tipo de evento. Então o componente pega esse ID para decidir qual tipo de ouvinte irá ser útil para o evento que deverá ser despachado, decidindo qual o método que vai chamar para cada objeto listener.
O evento é despachado por todas as decisões que são tratadas para o usuário através dos componentes GUI. Sendo necessário ser feito, pois precisa ser registrado um handler de evento para o tipo particular de evento que o aplicativo exige. O componente vai assegurar que o método apropriado do handler de evento é chamado quando o evento ocorrer. Abaixo ilustramos alguns exemplos de componentes GUI e manipulações de alguns eventos.
As informações de evento são armazenadas em um objeto de uma classe que estende AWT.Event.
A interface gráfica em Java é dita orientada a eventos: 
– Cada vez que um usuário clica em um botão, seleciona um item em uma lista, ou pressiona uma tecla, o sistema operacional gera um evento 
– Se uma aplicação está interessada em um evento específico (por exemplo, clique em um botão), deve solicitar ao sistema para “escutar” o evento 
– Se a aplicação não está interessada, seu processamento continua de forma normal. É importante observar que a aplicação não espera pela ocorrência de eventos: isso é controlado pelo sistema
 • Para que um componente ou container possa “escutar” eventos, é preciso instalar um listener
• Listeners são classes criadas especificamente para o tratamento de eventos
Há dois tipos de eventos: 
baixo nível e semânticos. 
• Eventos de baixo nível incluem: 
– eventos de container (inserção ou remoção de componente)
– eventos de foco (mouse entrou ou saiu de um componente) 
– eventos de entrada: teclado e mouse 
– eventos de janela: open, close, resize, minimize, etc 
• Eventos semânticos incluem: 
– eventos de ação: notificam a ação de um componente específico (ex: clique em um botão)
– eventos de ajuste: movimento de um scrollbar, por exemplo 
– eventos de item: seleção de um elemento em uma lista, checkbox, etc 
– eventos de texto: alteração do texto em um JTextArea, JTextField, etc
HIERARQUIA DE EVENTOS REFERENTE AO PACOTE JAVA.AWT.
Existem três elementos para o funcionamento do tratamento de evento que são:
Origem do Evento: é o componente GUI com qual o usuário interage.
Objeto do Evento: contém os dados do evento invocado, sendo como uma referência à origem do evento e quaisquer informações específicas do evento que podem ser exigidas pelo ouvinte para testar o evento.
Ouvinte do Evento: é um objeto que é notificado pela origem de evento quando um evento ocorre.
INTERFACES OUVINTES DE EVENTOS DOS PACOTES JAVAX.SWING.EVENT.
Figura 2: Interfaces listener de eventos
Lembrando que as interfaces providas da classe Listener podem ter um ou mais métodos de tratamento de evento que devem ser declarados na classe que implementa a interface.
Listeners são implementados através de interfaces 
• Uma interface define um conjunto de métodos que uma classe deve implementar mas não define como esses métodos devem ser implementados 
• Ou seja, é um modelo de como escrever esses métodos 
• Não confundir com classes abstratas: as interfaces não servem para criar novas classes, mas sim para implementar funcionalidades diversas! 
• Uma classe implementa uma ou mais interfaces 
• De certa forma, substitui a herança múltipla em Java 
• Exemplo: MouseListener - interface para eventos de mouse
Os componentes Swing podem gerar vários tipos de eventos diferentes. �
Alguns exemplos: �
Usuário clica em um botão --: ActionListener � 
Usuário fecha um frame --: WindowListener � 
Usuário pressiona um botão do mouse --: MouseListener � 
Usuário move o mouse --: MouseMotionListener � 
Componentes se tornam visíveis --: ComponentListener
Classes adaptadoras
Muitas das interfaces listeners de eventos fornecem múltiplos métodos. Nem sempre é desejável definir todos os métodos em uma interface listener de eventos. Por exemplo, o programa pode precisar apenas do tratador de mouseClicked da interface MouseListener. Para muitas das interfaces listeners que contém múltiplos métodos, os pacotes java.awt.event 
e javax.swing.event fornecem classes adaptadoras de ouvintes de eventos. Uma classe adaptadora implementa uma interface e fornece uma implementação default (com o corpo do método vazio) de cada método na interface. O programador pode estender a classe adaptadora para herdar a implementação default de cada método e depois sobrescrever o(s) método(s) necessário(s) para o tratamento de eventos.
As classes adaptadoras java.awt.event são as seguintes:
	Classe adaptadora de eventos
	Implementa a interface
	ComponentAdapter
	ComponentListener
	ContainerAdapter
	ContainerListener
	FocusAdapter
	FocusListener
	KeyAdapter
	KeyListener
	MouseAdapter
	MouseListener
	MouseMotionAdapter
	MouseMotionListener
	WindowAdapter
	WindowListener
Sendo evento ouvinte
Quando existe a intenção de uma ação do usuário sobre algum componente, é necessário o componente saber que há esse interesse, sendo assim é implementado a interface ActionListener e usado o método addActionListener() sendo passado como parâmetro a palavra “this”, é a referência do objeto da classe que implementa a interface ActionListener, neste caso ela mesma. Após isso é preciso saber uma maneira de chamar o componente quando algum evento ocorrer, sendo que o componente irá chamar o método da interface de escuta, ActionListener.
PARA FAZERMOS UM TRATADOR DE EVENTOS PRECISAMOS DE TRÊS AÇÕES BÁSICAS:
Especificar uma classe que implemente uma interface de ActionListener: 
public class CapturaEvento implements ActionListener {
Executar um código que registre uma instância desta classes como um listener de um ou mais componentes:
botao.addActionListener(this);
Definir o método de manipulação de eventos interface ActionListener: 
public void actionPerformed(ActionEvent evento) {
Entendendo serialização em Java
@SuppressWarnings ("unchecked") - suprime algumas mensagens de alerta
@SuppressWarnings ("serial") - suprime o warning de que sua classe é serializable e portanto deveria definir um SerialVersionUID.
Para que esse warning apareça, basta fazer um filho de qualquer classe que seja serializable (JFrame ou JDialog, por exemplo).
A serialização resume-se em salvar, gravar, capturar o estado de um objeto. Ou seja, tenho um objeto de uma classe e quero salvar seu estado: uso
serialização pois, quando quiser usá-lo com seu último estado gravado, é somente des-serializá-lo.
Mas por que usar isso?
Usar serialização permite que você crie o objeto ou uma variável
de instância de uma classe e grave em um arquivo para, futuramente, utilizar esse objeto/variável com seu estado que foi gravado.
Lembre-se: quando o construtor é executado, os valores são perdidos, objeto = null, eos tipos primitivos recebem seus valores padrões.
Com a serialização, um objeto ou uma variável de instância tem o valor gravado (em um arquivo), armazenado e futuramente posso obter esse valor através da des-serialização.
tratadores de eventos de mouse são MouseListener
MouseListener - interface para eventos de mouse
 – mouseClicked(MouseEvent e) - chamado quando o botão do mouse é clicado (e solto) sobre um componente.
 – mousePressed(MouseEvent e) - chamado quando o botão do mouse é clicado sobre um componente
 – mouseReleased(MouseEvent e) - chamado quando o botão do mouse é solto sobre um componente 
– mouseEntered(MouseEvent e) - chamado quando o mouse “entra” na área de um componente
– mouseExited(MouseEvent e) - chamado quando o mouse deixa a área de um componente 
• MouseEvent é uma classe que representa eventos de mouse 
• Cada listener utiliza uma classe específica para representar o evento, de acordo com o tipo que será gerado
�PAGE �
�PAGE �5�