AULA TEÓRICA 2

Tema 2. Adição de componentes à janela (cont).

 Componente botão
 Componentes Campo de texto e Campo de senha
Tema 3. Gestão de eventos
 Modelo de tratamento de eventos
 Tratamento de Eventos

Elaborado por eng.Tatiana Kovalenko

 Componente Botão
O botão é um componente em que o utilizador clica para activar uma acção específica.
O programa Java pode utilizar vários tipos de botões, incluindo botões de comando,
caixas de marcação, botões em alternativa e botões de opção. O esquema a seguir
mostra a hierarquia de herança dos alguns botões do swing.
javax.swing.JComponent

javax.swing.AbstractButton

javax.swing.JButton javax.swing.ToggleButton

javax.swing.JCheckButton javax.swing.JRadioButton

Todos os tipos de botão são subclasses de AbstractButton, que define muitos dos
recursos que são comuns aos botões do swing.
Os botões são criados com a classe JButton, que é subclasse da classe
AbstractButton. O texto na superfície de um botão chama-se rótulo de botão.
O exemplo a seguir cria dois botões e demonstra que JButtons (como JLabels)
suportam a exibição de ícones.
Para fornecer ao utilizador um nível extra de interactividade visual com a GUI, o
JButton também pode ter um Icon rollover – um Icon que é exibido quando o mouse é
posicionado sobre o botão. O ícone no botão muda quando o mouse se move para
dentro e para fora da área do botão na tela.
2
import javax.swing.*;
public class TestarBotoes1 extends JFrame
{ private JButton btnSimples, btnComIcone;
private Container cont;
public TestarBotoes1()
{ super("Testando Botoes");
cont = getContentPane();
cont.setLayout(new FlowLayout());
// cria botoes
btnSimples = new JButton("Botao Simples");
cont.add(btnSimples);
Icon bug1 = new ImageIcon("bug1.gif");
Icon bug2 = new ImageIcon("bug2.gif");
btnComIcone = new JButton("Botao com Icone", bug1);
btnComIcone.setRolloverIcon(bug2);
cont.add(btnComIcone);
setSize(375,100);
setVisible(true);
}

public static void main(String[] args)

{ TestarBotoes1 z = new TestarBotoes1();
z.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
} 3

}
 Componentes Campo do Texto e Campo de Senha
JTextField e JPasswordField são utilizados para criar áreas de uma única linha
em que o texto pode ser inserido pelo utilizador através do teclado ou o texto pode ser
simplesmente exibido. O Campo de Senha mostra que um caracter foi digitado quando
o utilizador insere os caracteres, mas oculta os caracteres assumindo que eles
representam uma senha.

import java.awt.*;
import javax.swing.*;
public class TextFieldTest extends JFrame
{ private JTextField campoTexto1, campoTexto2, campoTexto3;
private JPasswordField campoSenha;
private Container cont;

public TextFieldTest()
{ super("Testando JTextField e JPasswordField");
cont = getContentPane();
cont.setLayout(new FlowLayout());
// constrói campo do texto
campoTexto1 = new JTextField(10); //define a largura do campo
cont.add(campoTexto1);
4
 // constrói campo do texto com dimensoes default
campoTexto2= new JTextField("Enter text here");
cont.add(campoTexto2);

//constrói campo do texto com dimensoes default e cumprimento 20

campoTexto3= new JTextField("Uneditable text field",20);
campoTexto3.setEditable(false);
cont.add(campoTexto3);

// constrói campo do texto

campoSenha = new JPasswordField (”Ola Ola”,10);
cont.add(campoSenha);

setSize(400,150);
setVisible(true);
}

public static void main(String args[])

{ TextFieldTest aplic = new TextFieldTest();
aplic.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
5
 Modelo de tratamento de eventos
As GUIs são baseadas em eventos. Algumas interacções comuns são: mover o mouse,
clicar num botão do mouse, clicar em botão na janela, digitar num campo de texto,
seleccionar o item de um menu, etc.
Quando ocorre uma interacção com o utilizador, um evento é enviado para o programa.
Informações de eventos GUI são armazenadas num objecto de uma classe que estende
de AWTEvent.
Os tipos de evento do pacote java.awt.event são usados tanto em componentes
awt como em componentes swing. Novos tipos de componentes do swing são
definidos no pacote javax.swing.event.
Para cada evento que o sistema operativo é capaz de gerar, a aplicação deve prever
um tratamento correspondente (“o que deve acontecer em resposta”).
Em Java a acção resposta padrão para qualquer evento é “não fazer nada”.
Para se ter uma acçã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”.
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. 6
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 objecto que representa o evento gerado.
• Listener ou Receptor de evento: é um objecto 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

Notificação do Listener
Evento

Handler
7
Como isso acontece?
– Primeiro
• O listener tem que se registrar no objecto 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 objecto origem notifica o listener através da execução de um método
específico, o qual recebe como parâmetro o objecto evento.
– Quando o listener recebe a notificação
• Executa o método handler apropriado

Tratamento de Eventos
Cada tipo de evento possui métodos específicos para o seu tratamento. Para
saber que métodos são esses e como a classe listener deve implementá-los
utilizamos o conceito de interface.

Um listener deve implementar uma interface que define os métodos que serão
chamados quando os eventos ocorrerem.

8
Ex.:
• O evento que ocorre quando um botão é clicado é o evento (objecto)
ActionEvent.
• Todos os listeners que estão registrados para um botão e 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.

Como registrar um listener?

• Os listeners devem ser registrados com o objecto que gera o evento.

• Cada tipo de evento tem um método correspondente para adicionar um
listener.

Formas de implementação:

1. A classe implementa o listener.

2. Classes internas.
3. Classes internas anônimas.
9
1. A classe implementa o listener:
import javax.swing.*;
import java.awt.event.*;
//Esta classe é um listener de eventos
public class TestEvent1 extends JFrame implements ActionListener
{ private JButton botao;
private JLabel texto;
private int cont;
. . .
botao = new JButton("Igual");
//Registra o listener para acções no botão
botao.addActionListener(this);
. . .
public void actionPerformed (ActionEvent ev)
{ cont++;
texto.setText("Total de cliques: "+cont);
}
. . .
}
2. Uso da Classe Interna
Java oferece um recurso, chamado de classes internas em que as classes podem
ser definidas dentro de outras classes. Tais classes podem ser:
 definições completas de classe ou 10
 definições de classe interna anónima (classe sem nome).
Ex-lo de implementação do listener(2a forma):

import javax.swing.*;
import java.awt.event.*;
public class TestEvent2 extends Jframe
{ private JButton botao;
private JLabel texto;
private int cont;
. . .
botao = new JButton("Igual");

//Registra o listener para acções no botão

//cria uma instancia da classe interna TrataEvDeBotao
TrataEvDeBotao tr = new TrataEvDeBotao();
botao.addActionListener(tr);
. . .
//classe interna completa
private class TrataEvDeBotao implements ActionListener
{ public void actionPerformed(ActionEvent e)
{ cont++;
texto.setText("Total de cliques: "+cont);
}
} 11
. . .
3. Classe interna anónima
Uma classe interna também pode ser definida dentro de um método de uma classe.
Essa classe interna tem acesso aos membros de sua classe externa. Entretanto, ela
tem acesso limitado às variáveis locais do método em que é definida.
Como uma classe interna anónima não tem nome, deve-se criar um objecto da classe
interna anónima no ponto em que se define a classe no programa. Neste caso, a classe
interna se chama inner class e a classe hospedeira se chama top-level class.

import javax.swing.*;
import java.awt.event.*;
public class TestEvent3 extends JFrame
{ private JButton botao;
private JLabel texto;
private int cont;
. . .
botao = new JButton("Igual");
botao.addActionListener(
new ActionListener()
{ public void actionPerformed(ActionEvent x)
{ cont++;
texto.setText("Total de cliques: "+cont);
} 12
} );
Existe uma variedade de interfaces listener (java.awt.event.* e
javax.swing.event.*), alguns deles são:

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.

13
Referência bibliográfica:
António José Mendes; Maria José Marcelino.
“Fundamentos de programação em Java 2”. FCA. 2002.
Elliot Koffman; Ursula Wolz.
“Problem Solving with Java”. 1999.
F. Mário Martins;
“Programação Orientada aos objectos em Java 2”, FCA, 2000,
John Lewis, William Loftus;
“Java Software Solutions: foundation of program design”, 2nd edition, Addision-Wesley

John R. Hubbard.
“Theory and problems of programming with Java”. Schaum’s Outline series. McGraw-Hill.
H. Deitel; P. Deitel.
“Java, como programar”. 4 edição. 2003. Bookman.
Rui Rossi dos Santos.
“Programando em Java 2– Teoria e aplicações”. Axcel Books. 2004

14