Trabalhando com eventos na GUI do Java

AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
Trabalhando com eventos na GUI do Java
As aplicações em geral precisam de alguns eventos para o funcionamento
completo do programa. Normalmente as GUIs 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.
As informações de evento são armazenadas em um objeto de uma classe que
estende AWT.Event. Veja abaixo na Figura 1 a hierarquia de eventos referente
ao pacote java.awt.
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
Figura 1: Classes de evento do 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.
Na Figura 2 são mostradas as 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.
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
LINGUAGEM DE PROGRAMAÇÃO II
AULA II
Turma 2111
Data
22-02-2016
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:
1. Especificar uma classe que implemente uma interface de
ActionListener:
public class CapturaEvento implements ActionListener {
2. Executar um código que registre uma instância desta classes como um
listener
de
um
ou
mais
componentes:
botao.addActionListener(this);
3. Definir o método de manipulação de eventos interface ActionListener:
public void actionPerformed(ActionEvent evento) {
Listagem 1: Captura o evento de um botão
import
import
import
import
import
java.awt.Font;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
javax.swing.JButton;
javax.swing.JFrame;
public class CapturaEventoBotao implements ActionListener {
private JButton botao;
public void janela() {
JFrame frame = new JFrame();
botao = new JButton();
//REGISTRA O EVENTO
botao.addActionListener(this);
frame.getContentPane().add(botao);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300,100); frame.setVisible(true);
frame.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent evento) {
botao.setText("Botão foi clicado!");
//ALTERA A FONTE
botao.setFont(new Font("SansSerif", Font.BOLD, 20));
}
public static void main(String[] args) {
CapturaEventoBotao captura = new CapturaEventoBotao();
captura.janela();
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
}
}
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.
Listagem 2: Criação de botões e aplicação de eventos
import
import
import
import
import
import
java.awt.FlowLayout;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
javax.swing.JButton;
javax.swing.JFrame;
javax.swing.JOptionPane;
public class ButtonFrame2 extends JFrame {
private JButton botaoPrata;
private JButton botaoOuro;
//BUTTONFRAME ADICIONA JBUTTONS AO JFRAME
public ButtonFrame2() {
super("Testando Botões");
setLayout(new FlowLayout());
//CONFIGURA O LAYOUT DE FRAME
botaoPrata = new JButton("Prata");
//BOTÃO COM TEXTO
add(botaoPrata);
//ADICIONA botaoPrata AO JFRAME
botaoOuro = new JButton("Ouro");
add(botaoOuro); //ADICIONA botaoOuro AO JFRAME
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
//CRIA NOVO BUTTON HANDLER PARA TRATAMENTO DE EVENTO DE BOTÃO
ButtonHandler handler = new ButtonHandler();
botaoOuro.addActionListener(handler);
botaoPrata.addActionListener(handler);
}
//CLASSE INTERNA PARA TRATAMENTO DO BOTÃO
public class ButtonHandler implements ActionListener {
//TRATA EVENTO DO BOTÃO
public void actionPerformed(ActionEvent event) {
JOptionPane.showMessageDialog(ButtonFrame2.this,
String.format("Você pressionou: %s", event.getActionCommand()));
}
}
}
Apenas comentando que no código da Listagem 2 foi criada uma classe
interna chamada ButtonHandler. Uma clsse interna é criada para capturar os
eventos de dois ou mais componentes diferentes. A classe interna pode usar
todos os métodos e variáveis da classe externa.
Listagem 3: Testa a classe ButtonFrame2
import javax.swing.JFrame;
public class TestaButton {
public static void main(String[] args) {
ButtonFrame2 buttonFrame = new ButtonFrame2();
buttonFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
buttonFrame.setSize(275, 210);
buttonFrame.setVisible(true);
}
}
O exemplo acima cria arquivos separados e apenas um arquivo, que contém a
classe public static voi main(String[] args) , que é aquela que chama qualquer
classe criada na pasta do mesmo pacote.
Outro maneira de programar é utilizar o mesmo arquivo contendo a classe
principal. Particularmente não gosto de trabalhar desta forma, mas é excelente
método para principiantes.
O script abaixo simula uma tela de login.
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
AULA II
Turma 2111
LINGUAGEM DE PROGRAMAÇÃO II
Data
22-02-2016
http://www.devmedia.com.br/trabalhando-com-eventos-na-gui-do-java/25898