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 Notificação do Evento contendo o objeto que representa o Evento. Handler

Como isso acontece? Em primeiro lugar Quando um evento ocorre 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);

Exemplo import 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() Método getActionCommand() 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

Exemplos de eventos, listeners e métodos: 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()

Eventos gerados por componentes (resumo): 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

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: MouseListener: 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.