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.
Existem três elementos para o funcionamento d1o 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.
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 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) {
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import 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);
}
@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();
}
}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.
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.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
//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 classe 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.
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);
}
}Eventos nos TextField
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
public class TextFieldFrame extends JFrame {
private JTextField textField1;
private JTextField textField2;
private JTextField textField3;
private JPasswordField passwordField;
//CONSTRUTOR TEXTFIELDFRAME ADICIONA JTEXTDFIELDS A JFRAME
public TextFieldFrame()
{
super("Testando JTextField e JPasswordField");
setLayout(new FlowLayout());
//CONSTRÓI TEXTFIELD COM 10 COLUNAS
textField1 = new JTextField(10);
add(textField1); //ADICIONA TEXTFIELD2 AO JFRAME
textField2 = new JTextField("Entre com o texto aqui");
add(textField2);
//CONSTRÓI TEXTFIELD COM TEXTO PADRÃO E 21 COLUNAS
textField3 = new JTextField("Campo não editável",21);
textField3.setEditable(false); //DESATIVA EDIÇÃO
add(textField3);
//CONSTRÓI PASSWORDFIELD COM TEXTO PADRÃO
passwordField = new JPasswordField("Texto Escondido");
add(passwordField); //ADICIONA PASSWORDFIELD AO JFRAME
//HANDLERS DE EVENTO REGISTRADORES
TextFieldHandler handler = new TextFieldHandler();
textField1.addActionListener(handler);
textField2.addActionListener(handler);
textField3.addActionListener(handler);
passwordField.addActionListener(handler);
}
//CLASSE INTERNA PRIVATE PARA TRATAMENTO DE EVENTO
private class TextFieldHandler implements ActionListener
{
//PROCESSA EVENTOS DE CAMPO DE TEXTO
public void actionPerformed(ActionEvent event){
String string = "";
//USUÁRIO PRESSIONOU ENTER NO JTEXTFIELD TEXTFIELD1
if(event.getSource() == textField1)
string = String.format("textField1: %s",
event.getActionCommand());
//USUÁRIO PRESSIONOU ENTER NO JTEXTFIELD TEXTFIELD2
else if(event.getSource() == textField2)
string = String.format("textField2: %s",
event.getActionCommand());
//USUÁRIO PRESSIONOU ENTER NO JTEXTFIELD TEXTFIELD3
else if(event.getSource() == textField3)
string = String.format("textField3: %s",
event.getActionCommand());
//USUÁRIO PRESSIONOU ENTER NO JTEXTFIELD PASSWORDFIELD
else if(event.getSource() == passwordField)
string = String.format("passowordField: %s",
event.getActionCommand());
//EXIBE O CONTEÚDO DE JTEXTFIELD
JOptionPane.showMessageDialog(null, string);
}
}
}
import javax.swing.JFrame;
public class TestaTextField {
public static void main(String[] args) {
TextFieldFrame textFieldFrame = new TextFieldFrame();
textFieldFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
textFieldFrame.setSize(350,200);
textFieldFrame.setVisible(true);
}
}Conclusão
Para concluir esse artigo, abaixo é apresentado um resumo de algumas ações para servir como base de consulta.
- Sempre quando for criar um componente comece com uma Janela (JFrame) – Jframe frame = new Jframe();
- Para adicionar os componentes gráficos dentro de um Jframe – frame.getContentPane().add(nomeComponenteInstanciado);
- Para ouvir um evento, sempre registrar o interesse em uma origem de evento.
- Para registrar e ouvir ActionEvents de um componente – nomeDoComponente.addActionListener(this);
- Implemente a interface de escuta e insira todos os métodos de manipulação de eventos que essa interface tem.
public void actionPerformed(ActionEvent evento){
//DEFINE OS ESTADOS DOS COMPONENTES
}
