POO. Tratamento de Eventos n Eventos são a forma utilizada por Java para adicionar interatividade...
Transcript of POO. Tratamento de Eventos n Eventos são a forma utilizada por Java para adicionar interatividade...
POO
Tratamento de Eventos
Eventos são a forma utilizada por Java para adicionar interatividade em interfaces gráficas.
Cada vez que o usuário pressionar um botão, digitar um caracter ou movimentar o mouse, por exemplo, ocorre um evento.
Sempre que o usuário utiliza o mouse, o teclado ou outro dispositivo de entrada qualquer, o sistema operacional se encarrega de converter essas ações em eventos.
Para cada evento que o sistema operacional é capaz de gerar, a aplicação deve prever um tratamento correspondente (“o que deve acontecer em resposta”).
Em Java a ação resposta padrão para qualquer evento é “não fazer nada”.
Para se ter uma ação em resposta, é necessário definir qual ou quais os componentes que serão encarregados de monitorar determinado evento, reagindo ao mesmo quando este ocorrer.
Dizemos que um componente capaz de perceber um evento é um componente capaz de “escutá-lo” ou “captá-lo”.
Em Java, dizemos que para um componente ser capaz de perceber um evento (e tratá-lo) é necessário associar um “listener” (algo como um “ouvinte”) ao componente.
Existem 4 componentes envolvidos no processo de tratamento de eventos:– Origem do evento: é um componente onde o
evento é gerado.• Ex.: um evento de clique do mouse pode ser
originado de um botão
– Evento: é um objeto que representa o evento gerado.
– Listener ou Receptor de Evento: é um objeto responsável por “ouvir” ou “captar” a ocorrência do evento.
– Handler: é um método do Listener responsável por executar as ações decorrentes do evento.
OK
Origem do Evento
Listener
Handler
Notificação doEvento contendo o objeto que representa o Evento.
Como isso acontece?– Em primeiro lugar
• O listener tem que se registrar no objeto origem do evento, informando que tipo de evento ele está interessado em receber.
– Quando um evento ocorre• O listener é notificado que o evento ocorreu• O objeto origem notifica o listener através da
execução de um método específico, o qual recebe como parâmetro o objeto evento.
– Quando o listener recebe a notificação• Ele executa o método handler apropriado.
Como implementar um listener?– Vimos que o objeto origem de um evento
notifica o listener através da execução de um método específico.
• Cada tipo de evento possui métodos específicos para o seu tratamento.
– Que métodos são esses? Como a minha classe listener sabe quais métodos ela deve implementar?
– Utilizamos o conceito de interface.• Não confundir com interface gráfica, interface
de usuário...!
– Dessa forma, um listener deve implementar um certa interface.
• Esta interface define os métodos que serão chamados quando os eventos ocorrerem.
– Ex.:• O evento que ocorre quando um botão é clicado
é o evento (objeto) ActionEvent.
• Todos os listeners que estão registrados para um botão, que esperam receber a notificação de um clique do botão, devem implementar o método actionPerformed(), que será chamado pelo botão quando for clicado.
• Este método está definido na interface ActionListener, logo o listener deverá implementar esta interface.
public interface ActionListener{
void actionPerformed(ActionEvent e );
}
public class AcoesBotao implements ActionListener{
public void actionPerfomed(ActionEvent e){
//Aqui vem o código que é executado
//quando o botão for pressionado.
}
}
Como registrar um listener?– Os listeners devem ser registrados com o
objeto que gera o evento.• Ou seja, devemos indicar quem implementa as
ações para os eventos daquele componente.
– Cada tipo de evento tem um correspondente método para adicionar um listener.
– Ex.: para ActionEvent, o método é addActionListener().
JButton ok = new JButton (“Ok”);
AcoesBotao botaoListener = new AcoesBotao();
ok.addActionListener(botaoListener);
Exemploimport javax.swing.*;
import java.awt.event.*; //Para utilizar eventos
public class TestaEventos extends JFrame implements ActionListener {
//Esta classe é um listener de eventos de ação
JButton but;
JLabel texto;
JPanel painel;
int cont;
public TestaEventos() {
//Cria um frame com os componentes
super("TestaEventos");
cont = 0; //Contador do número de cliques no botão
but = new JButton("Clique aqui");
texto = new JLabel("Total de cliques: 0");
painel = new JPanel();
painel.setLayout(new BoxLayout(painel,BoxLayout.Y_AXIS));
painel.add(but);
painel.add(texto);
//Registra o listener para ações no botão
but.addActionListener(this); // A própria classe implementa as ações
this.getContentPane().add(painel);
}
//Método exigido pela interface ActionListener
public void actionPerformed(ActionEvent e) {
cont++;
texto.setText("Total de cliques: "+cont);
}
public static void main(String[] args){
JFrame janela = new TestaEventos();
janela.setDefaultCloseOperation( WindowConstants.DISPOSE_ON_CLOSE);
janela.show();
}
}
Classe ActionEvent:– Método getSource()
• Retorna uma referência ao objeto que gerou o evento.
– Método getActionCommand()• Retorna informações sobre o objeto origem do
evento, por exemplo, se chamado em um botão, por default retornará o string do texto do botão.
• Retorna a string relacionada ao componente que foi atribuída pelo método setActionCommand(string).
– Podemos usar esses métodos para gerenciar eventos de mais do que um componente, com o mesmo listener.
Exemplo2:import javax.swing.*;
import java.awt.event.*;
public class TestaEventos2 extends JFrame implements ActionListener {
JButton but1;
JButton but2;
JPanel painel;
public TestaEventos2() {
...
but1.addActionListener(this);
but2.addActionListener(this);
...
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == but1) setTitle("Botão 1");
else if (e.getSource() == but2) setTitle("Botão 2");
repaint(); //Redesenha a janela após mudanças
}
...
}
import javax.swing.*;
import java.awt.event.*;
public class TestaEventos2 extends JFrame implements ActionListener {
JButton but1;
JButton but2;
JPanel painel;
public TestaEventos2() {
...
but1.addActionListener(this);
but2.addActionListener(this);
...
}
public void actionPerformed(ActionEvent e) {
if (“Botão 1”.equals(e.getActionCommand())) setTitle("Botão 1");
else if (“Botão 2”.equals(e.getActionCommand())) setTitle("Botão 2");
repaint(); //Redesenha a janela após mudanças
}
...
}
ActionEvent ActionListener actionPerformed()
FocusEvent FocusListener focusGained()
focusLost()
ItemEvent ItemListener itemStateChanged()
KeyEvent KeyListener keyPressed()
keyReleased()
keyTyped()
MouseEvent MouseListener mouseClicked()
mouseEntered()
mouseExited()
mousePressed()
mouseReleased()
TextEvent TextListener textValueChanged()
Exemplos de eventos, listeners e métodos:
JButton ActionEvent botão “clicado”
JCheckbox ItemEvent item selecionado/desmarcado
JCheckboxMenuItem ItemEvent idem
JChoice ItemEvent idem
JList ActionEvent duplo-clique sobre o item
ItemEvent item selecionado/desmarcado
JMenuItem ActionEvent item selecionado/desmarcado
JScrollbar AdjustmentEvent scrollbar movimentada
JTextComponent TextEvent texto alterado
JTextField ActionEvent término da edição do texto
Eventos gerados por componentes (resumo):
Classes Adaptadoras:– Algumas das interfaces para a construção
dos listeners possuem mais de um método.
– Ao implementar o listener, precisamos definir todos os métodos, mesmo que só estejamos interessados só em um tipo de evento.
– Ex.:•MouseListener contém 5 métodos, e
devemos implementar todos eles, mesmo que só utilizemos o método mousePressed().
– Para facilitar a implementação de listeners, Java fornece um conjunto de classes adaptadoras.
– As classes adaptadoras (adapter) são utilizadas para que o usuário tenha que implementar apenas os métodos que ira utilizar.
– Estas classes já implementam a interface de interesse, mas com todos os métodos com corpo vazio (sem código).
– Para programar o listener, herdamos da classe adapter e sobrescrevemos apenas os métodos que desejamos utilizar!
– Algumas classes adaptadoras:• ComponentAdapter - ComponentListener• ContainerAdapter - ContainerListener• FocusAdapter - FocusListener• KeyAdapter - KeyListener• MouseAdapter - MouseListener• MouseMotionAdapter - MouseMotionListener• WindowAdapter - WindowListener• ActionListener não possui classe adaptadora
pois só possui um método.
– Ex.: queremos um listener para o MouseListener.
import java.awt.event.*;
public class TestaEventos4Adaptador extends MouseAdapter{
public void mousePressed(MouseEvent e){
System.out.println("Botao pressionado");
}
public void mouseReleased(MouseEvent e){
System.out.println("Botao liberado");
}
}
Classes Anônimas Internas:– Uma vez criada a classe que implementa a
interface ou define uma subclasse de uma classe adaptadora, esta precisa ser instanciada e o objeto registrado como listener.
– É possível implementar e registrar o listener em um passo só.
– Basta implementar o listener como uma classe anônima (sem nome) interna (uma classe definida dentro de outra classe.
– Observe que se forem utilizadas classes internas anônimas, não será possível tratar múltiplos componentes.
– Deveremos implementar uma classe anônima para cada componente.
– Não aconselhável para código de tratamento que seja muito longo.
Exemplo:
but.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
cont++;
texto.setText("Total de cliques: "+cont);
}
});
janela.addWindowListener(
//código para executar quando a janela é fechada
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0); // fecha e sai do programa
}
});
Exemplo Menu:
JMenu mFile = new JMenu("File");
JMenuItem miOpen = new JMenuItem("Open");
miOpen.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
campo.setText(e.getActionCommand());
}
});
mFile.add(miOpen);
– Algumas interfaces (java.awt.event.*):• ActionListener - eventos de ação, que são gerados por um
usuário agindo sobre um componente, como um clique em um botão.
• FocusListener - eventos de foco de teclado, que são gerados quando um componente, como um campo de texto, ganha ou perde o foco.
• ItemListener - eventos de item, que são gerados quando um item, como uma caixa de seleção, foi alterado.
• KeyListener - eventos de teclado, que ocorrem quando uma tecla é pressionada.
• MouseListener - eventos de mouse, que são gerados por cliques do mouse, um mouse entrando ou deixando uma área de um componente.
• MouseMotionListener - eventos de movimento de mouse, usados para controlar a movimentação do mouse sobre um componente.
• WindowListener - eventos de janela, que são gerados por uma janela ao ser maximizada, minimizada, movida ou fechada.
WindowListener:– windowOpened(WindowEvent e) - Chamado a primeira vez que a
janela é aberta.– windowClosing(WindowEvent e) - Chamado quando o ícone de
fecha janela é selecionado.– windowClosed(WindowEvent e) - Chamado quando do fechamento
de uma janela.– windowActivated(WindowEvent e) - Chamado quando uma janela é
ativada (clicando sobre a mesma, por exemplo).– windowDeactivated(WindowEvent e) - Chamado quando uma janela
é desativada (clicando sobre uma outra janela, por exemplo).– windowIconified(WindowEvent e) - Chamado quando uma janela é
minimizada.– windowDeiconified(WindowEvent e) - Chamado quando uma janela
é restaurada a partir de um ícone.
ActionListener:– actionPerformed - Chamado quando uma ação ocorre.
MouseListener:– 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.
MouseMotionListener:– mouseMoved(MouseEvent e) - Chamado quando o mouse
se movimenta com um componente (drag)– mouseDragged(MouseEvent e) - Chamado quando o
mouse se movimenta com um componente (drag) enquanto o botão do mouse está pressionado
KeyListener:– keyTyped(KeyEvent e) - Chamado quando uma tecla do
teclado é pressionada e solta– keyPressed(KeyEvent e) - Chamado quando uma tecla do
teclado é pressionada– keyReleased(KeyEvent e) - Chamado quando uma tecla do
teclado é solta
Exercícios
1) Escreva um programa em Java que implemente uma calculadora simples (com operações de adição, subtração e multiplicação) para números inteiros.