Java

Programação II

Swing Java
Agenda

• Origens e filosofias de design Swing

• Caixas de Diálogo
• Componentes e Contêineres
– Componentes
– Contêiner
– Painéis do contêiner de nível superior
• Gerenciadores de Layout
• Criando a Primeira Janela
Origens e filosofias de design
Swing
• Antes de começarmos a estudar Interface Gráfica, precisamos
conhecer o significado de GUI (Interface Gráfica de Usuário)

• Estudos para construção dessas interfaces hoje em dias

Na vida real a maioria

dos aplicativos é baseada
em GUI
Origens e filosofias de design
Swing
• Swing define uma coleção de classes e interfaces que dá
suporte a um rico conjunto de componentes visuais.
Origens e filosofias de design
Swing
• Com esses controles é possível construir interfaces gráficas
poderosas e ainda assim fáceis de usar.

• É importante destacar que um novo framework para GUI foi

criado na linguagem Java e se chama:

• O JavaFX fornece uma linguagem poderosa, otimizada e

flexível que simplifica a criação de GUIs visualmente
atraentes.
Então porque estudar Swing?
Origens e filosofias de design
Swing
• História
– Swing não existia nos primórdios da linguagem Java.

Ele foi uma resposta às deficiências presentes no

subsistema de GUI original da linguagem.

AWT define um conjunto básico de componentes, que dá

acesso a uma interface gráfica usável mas limitada.

Limitação
• Converter seus diversos componentes visuais nos
equivalentes, ou pares, específicos da plataforma
(sistema operacional)
• A aparência de um componente é definido pela
plataforma e não por java.
• Precisava usar recursos de códigos nativos
Origens e filosofias de design
Swing
• Logo depois do lançamento do Java, não demorou muito
tempo para verificar que as limitações e restrições presentes
em AWT eram graves
• Dessa forma uma nova abordagem para criação de interface
de usuário foi colocado na linguagem Java

Swing Java
• Introduzido em 1997
• Mas desde o Java 1.1 já
podia ser utilizada como
uma biblioteca separada
• Foi totalmente integrado ao Java
a partir da versão 1.2
Origens e filosofias de design
Swing
• O Swing resolve as limitações associados aos de AWT com o uso de
dois recursos chaves:
– Componentes Leves
– Aparência adaptável
Filosofia de design swing

• Os componentes Swing são escritos totalmente em Java, ou seja

não depende de pares específicos da plataforma.
• A aparência de cada componente é determinada pelo swing, e não
pelo sistema operacional subjacente. Dessa forma cada
componente pode funcionar de forma coerente em cada
plataforma.
Origens e filosofias de design
Swing
• Já que os componentes do swing são gerados por código java
é possível separar a aparência e a lógica de cada
componentes.
• A independência da aparência permite alterar a maneira de
como o componente é gerado sem afetar nenhum de seus
outros aspectos, ou seja, é possível conectar uma nova
aparência sem criar nenhum efeito colateral no código.
• O Java fornece dois tipos de aparências:
– Metal e o Nimbus
Metal
Nimbus
Caixas de Mensagem

• Para começarmos vamos lembrar um pouco sobre

Overloading
– Métodos que possuem mesmo nome, mas com assinaturas diferentes.
– Assinaturas diferentes: Diferente números de argumentos e diferentes
tipos de argumentos.

• JoptionPane
Método Descrição
showConfirmDialog Faz uma pergunta
showInputDialog É possível fornecer uma entrada de
dados
showMessageDialog Exibe uma mensagem
showOptionDialog Uma mistura dos três anteriores
 Caixas de Mensagem

• ShowMessageDialog

JOptionPane.showMessageDialog(parentComponent, message);

JOptionPane.showMessageDialog(parentComponent, message,
title, messageType);

JOptionPane.showMessageDialog(parentComponent, message,
title, messageType, icon);
new ImageIcon(“camiho”);
Message Type
• ERROR_MESSAGE
• INFORMATION_MESSAGE
• WARNING_MESSAGE
• QUESTION_MESSAGE
• PLAIN_MESSAGE
 Caixas de Mensagem

• ShowConfirmDialog

JOptionPane.showConfirmDialog(parentComponent, message);

JOptionPane.showConfirmDialog(parentComponent, message,
title, optionType);

JOptionPane.showConfirmDialog(parentComponent, message,
title, optionType, messageType);

JOptionPane.showConfirmDialog(parentComponent, message,
title, optionType, messageType, icon);
 Caixas de Mensagem

• ShowConfirmDialog

Option Type
• DEFAULT_OPTION
• YES_NO_OPTION
• YES_NO_CANCEL_OPTION
• OK_CANCEL_OPTION
Título Botão de fechar janela -1

Texto
Ícone de tipo de
mensagem

Botões (0,1,2)
Caixas de Mensagem
• ShowInputDialog
JOptionPane.showInputDialog(message);

JOptionPane.showInputDialog(parentComponent, message);

JOptionPane.showInputDialog(message,
initialSelectionValue);

JOptionPane.showInputDialog(parentComponent,
message, initialSelectionValue);

JOptionPane.showInputDialog(parentComponent,
message, title, messageType);

JOptionPane.showInputDialog(parentComponent, message,
title, messageType, icon,
selectionValues, initialSelectionValue);
Caixas de Mensagem

• ShowInputDialog
– selectionValues: É um vetor de Objetos

Caixa de texto

Combobox

Botões
X: null
Ok: O valor da String
Cancelar: null
 Caixas de Mensagem

• ShowOptionDialog

JOptionPane.showOptionDialog(parentComponent, message,
title, optionType, messageType, icon,
options, initialValue);

Para mais informações acesse:

https://docs.oracle.com/javase/7/docs/api/javax/swing/JOptionPane.html
Componentes e Contêiner
• Uma GUI no Swing Java é composta por dois itens principais:
– Contêineres
– Componentes

• No entanto, todo contêiner também é um componente.

• A diferença entre contêiner e componente é meramente conceitual

e pode ser encontrada em sua finalidade
– Componente: Controle visual independente (botão ou campo de texto).
Para um componente ser exibido ele deve estar dentro de um contêiner.
– Contêiner: serve para agrupar outros componentes. Já que um contêiner é
um componente, ele pode conter outros contêineres. Isso permite que o
java crie uma hierarquia de contenção.
Componentes e Contêiner
javax.swing.*
Hierarquia dos
componentes Swing.

Obs. Com exceção dos

quatro contêineres
superior.

Component (AWT)

Jcomponent
Contêineres

• Contêineres de Nível Superior

– Jframe, Japplet, JDialog, Jwindow

• Esses quatro contêineres não herdam de Jcomponent

• Herdam de Component e Container de AWT
• Diferente dos outros componentes esses Contêineres são
pesados

• Um contêiner de nível superior deve esta no topo de uma

hierarquia de contenção.
Contêineres

• O segundo tipo de Contêiner no Swing é o contêiner leve.

– Esses contêineres herdam de JComponent
• JPanel
• JScrollPane
• JRootPane

• Os contêineres leves podem estar contidos dentro de outros

contêineres. Dessa forma podem ser utilizados para agrupar
subgrupos de controles (componentes).
Criando a Primeira Janela
import javax.swing.JFrame;

public class Janela extends JFrame{

public Janela() {

super.setSize(500,300);
super.setVisible(true);
}

public static void main(String[] args) {

new Janela();

}
Contêiner

Jframe
Gerenciadores de Leiaute

• O gerenciador de leiaute controla a posição dos componentes

dentro de um contêiner.

• Java fornece vários gerenciadores de leiaute e a maioria é

fornecido por awt (java.awt). Todos os gerenciadores de
leioute são instancias de uma classe que implementa
LayoutManager, alguns também implementam a interface
LayoutManager2.
Gerenciadores de Leiaute
Layout Descrição
FlowLayout Leiaute simples que posiciona os
componentes da esquerda para direita de
cima para baixo
BorderLayout Posiciona os componentes no centro ou
na borda dos leiautes
GridLayout Dispões os componentes dentro de uma
grade
GridBagLayout Dispões os componentes de tamanhos
diferentes em uma grade flexível
BoxLayout Dispões os componentes vertical ou
horizontalmente dentro de uma caixa
SpringLayout Dispões os componentes de acordo com
um conjunto de restições
null Dispões os componentes de acordo com
as coordenadas do plano cartesiano
 FlowLayout

Construtor
int align;
int hgap, vgap;
 BorderLayout
Construtor/Métod Próposito
o
BorderLayout(int Define os espaços
hGap, int vGap) verticais e
horizontais entre os
componentes
setHGap(int) Define os espaços
horizontais entre os
componentes

setVGap(int) Define os espaços

verticais entre os
componentes O BorderLayout foca em cinco áreas:
•PAGE_START
•PAGE_END
•LINE_START
•LINE_END
•CENTER
GridLayout
GridBagLayout
Null Layout

• Dispões os componentes de acordo com as coordenadas do

plano cartesiano
Null Layout

• Para atribuit o null layout é necessário usar o método

setLayout() na janela ou Jpanel.

• painel.setLayout(null);
Null Layout
import javax.swing.JFrame;

public class Janela extends JFrame{

Jpanel painelPrincipal;
public Janela() {
painelPrincipal = new Jpanel();
painelPrincipal.setLayout(null);
super.setContentPane(painelPrincipal);
super.setSize(500,300);
super.setVisible(true);
}

public static void main(String[] args) {

new Janela();

}
Exemplo

Janela (Jframe)
Painel Principal (Jpanel)

• Com o exemplo do código anterior (slide 33) o painel principal

está dentro (contido) da janela e serve para agrupar outros componentes.
Passo a Passo para Criação de uma Janela

• O pacote javax.swing contém os componentes e modelos

definidos por Swing. Por exemplo, ele define classes que
implementam rótulos (label), botões, controles de edição,
caixas de texto e menus.
• Esse pacote será incluído em todos os programas que usarem
Swing.
Passo a Passo para Criação de uma Janela

• Primeiro Passo
• Uma das maneiras de criar uma janela é necessário fazer uma
classe herdar da classe javax.swing.JFrame.

import javax.swing.JFrame;

public class Janela extends JFrame{

}
Passo a Passo para Criação de uma Janela
• Segundo Passo
• Definir as propriedades da janela dentro do construtor da
classe. Para fazer isso é necessário acessar alguns atributos da
super classe (JFrame).

• Essas propriedades são:

– Visibilidade da janela (super.setVisible())
– Tamanho da Janela (super.setBounds() / super.setSize())
– Posição da janela na tela (super.setBounds() / super.setLocation())
– Título da janela (super.setTitle())
– Propriedade de fechamento da janela
(super.setDefaultCloseOperation())
Passo a Passo para Criação de uma Janela

import javax.swing.JFrame;

public class Janela extends JFrame{

public Janela() {

super.setDeafultCloseOperation(Jframe.EXIT_ON_CLOSE);
super.setTitle(“Titulo da Janela”);
super.setBounds(100,100, 500,300);
super.setVisible(true);
}

}
Passo a Passo para Criação de uma Janela

• Terceiro Passo
• Definir um contêiner secundário (JPanel) e atribuir ao
contêiner principal (Janela que herda de JFrame)
– Declara o painel na classe
– Instancia o painel no construtor
– Seta o layout Nulo (painel.setLayout(null))
– Atribui o painel na janela com o método seContentPane(painel);
• JPanel
– Contêiner/Componente secundário.
Passo a Passo para Criação de uma Janela
import javax.swing.JFrame;

public class Janela extends JFrame{

Jpanel painelPrincipal;

public Janela() {
painelPrincipal = new Jpanel();
painelPrincipal.setLayout(null);
super.setContentPane(painelPrincipal);

super.setDeafultCloseOperation(Jframe.EXIT_ON_CLOSE);
super.setTitle(“Titulo da Janela”);
super.setBounds(100,100, 500,300);
super.setVisible(true);
}
}
 Componentes
• JButton
– Um dos componentes mais usados do Swing é o botão de ação. Um botão
de ação é a instância de JButton. JButton herda da classe abstrata
AbstractButton, que define a funcionalidade comum dos botões. Os
botões de ação Swing podem conter texto, imagem ou ambos. E esses
elementos podem ser adicionados através da sua sobrecarga de
construtores ou seus métodos.

• Para criar uma botão de ação é necessário:

– Declarar um botão na classe
– Instanciar o botão no construtor e passar o seu texto/imagem no
construtor
– Adicionar as propriedades de posições x e y, e a largura e altura (método
setBounds)
– Adicionar o botão no painel principal

https://docs.oracle.com/javase/7/docs/api/jav
ax/swing/JButton.html
Componentes
import javax.swing.Jframe;
public class Janela extends JFrame{
JButton btnBotao;
Jpanel painelPrincipal;
public Janela() {
painelPrincipal = new Jpanel();
painelPrincipal.setLayout(null);

btnBotao = new JButton(“Clique”);

btnBotao.setBounds(10,10, 100, 25);
painelPrincipal.add(btnBotao);
super.setContentPane(painelPrincipal);

super.setDeafultCloseOperation(Jframe.EXIT_ON_CLOSE);
super.setTitle(“Titulo da Janela”);
super.setBounds(100,100, 500,300);
super.setVisible(true);
}
}
Componentes
Evento Ação (Action Listener)
• Quando um botão de ação é pressionado, ele gera um ActionEvent.
A classe ActionEvent é definida por AWT e também é usada por
Swing.

• Para manipular esse evento, JButton fornece os seguintes métodos:

– addActionListener(ActionListener al)
• Adiciona um listener (ouvinte) a ação
– removeActionListener(ActionListener al)
• Remove um listener (ouvinte) da ação

• Nesse caso “al” especifica um objeto que receberá notificações do

evento. Esse objeto deve ser instância de uma classe que
implemente a interface ActionListener.
Evento Ação (Action Listener)

• ActionListener
– É uma interface que define apenas um método, o actionPerformed.
• void actionPerformed(ActionEvent e){}
– Esse método é chamado quando o botão for pressionado. Ele é o
tratador de eventos chamado quando ocorre um evento de
pressionamento de botão.

btnBotao.addActionListener(new ActionListener(
@Override
public void actionPerformed(ActionEvent){
//onde o evento deverá ser tratado
}
));

Criação de uma classe anônima que implementa ActionListener para

tratamento do evento.
 Componentes

• JLabel
– Jlabel é um componente no Swing que cria um rótulo, que é um
componente que exibe informações.
– O rótulo é componente mais simples do Swing, porque é passivo, ou
seja, não responde a entradas do usuário, ele apenas exibe saídas. Ele
apenas usa um contêiner para armazenar uma instância de JLabel.
– Pode exibir texto ou imagens. Isso pode ser definido através de sua
sobrecarga de construtores.

JLabel label = new JLabel(“Texto”);

label.setBounds(10,10,100,25);

painelPrincipal.add(label);
https://docs.oracle.com/javase/7/docs/api/jav
ax/swing/JLabel.html
Componentes
Componentes

• Métodos mais usados de JLabel

– Para obter a string exibida atualmente no rótulo, chame o método
getText(), na instância do JLabel.
– Para configurar o texto do rótulo é chamado o método setText(String
text)

• label.getText() Retorna o texto atual do rótulo

• label.setText(“Novo Texto”)
Componentes

• JTextField
– Componente que permite que o usuário insira uma linha de texto.
JTextField herda a classe abstrata JTextComponent, que é a
superclasse de todos os componentes de texto. Ele define vários
construtores.

JTextField tfCaixaTexto = new JTextField();

tfCaixaTexto.setBounds(10,10,150,25);

painelPrincipal.add(tfCaixaTexto);
Componentes
Componentes

• Métodos mais usados de JTextField

– Para obter a string exibida atualmente no campo de texto, chame o
método getText(), na instância do JTextField.
– Para configurar o texto de um campod de Texto é chamado o método
setText(String text)

• tfCaixaTexto.getText() Retorna o texto atual do rótulo

• tfCaixaTexto.setText(“Novo Texto”)
Componentes

• JCheckBox
– Uma caixa de seleção no Swing pode ser um objeto do tipo JCheckBox
e o mesmo herda de AbstractButton e JToggleButton. Logo, uma caixa
de seleção é, essencialmente, um tipo especial de botão.

– O JCheckBox não tem a característica de seleção exclusiva, onde

apenas um de um conjunto de botões pode ser selecionado por vês.

JCheckBox checkBox = new JCheckBox(“Texto do CheckBox”);

checkBox.setBounds(10,10,100,25);

painelPrincipal.add(checkBox);
Componentes
Componentes

• Métodos mais usados de um JCheckBox

– A maneira mais fácil de determinar o estado de uma caixa de seleção é
chamar o método isSelected()

• checkBox.isSelected() Retorna true se o coponete estiver

selecionado false se não estiver
Componentes

• JList
– O JList é a classe de lista básica do Swing, ela da suporte à seleção de
um ou mais itens de uma lista. Embora geralmente a lista seja
composta por strings, é possível criar uma lista de quase todos os
objetos que possam ser exibidos.
– No passado, os itens de JList eram representados como referências
Object. No entanto, com o lançamento da JDK 7, JList tornou-se
genérica.
– O JList pode receber um objeto vector ou um array em seu construtor
Vector<String> vectorLista = new Vector<String>();
vectorLista.add(“A”);
vectorLista.add(“B”);
JList<String> lista = new JList<String>(vectorLista);
lista.setBounds(10,10,100,80);

painelPrincipal.add(lista);
Componentes
Componentes

• Métodos mais utilizados de um JList:

– Você pode obter o índice do primeiro item selecionado, que também
será o índice do único item selecionado quando o modo de seleção
simples for usado, chamando o método getSelectedIndex()
– Você pode obter o objeto do primeiro item selecionado, chamando o
método getSelectedItem();

Retorna o índice do item selecionado

• lista.getSelectedIndex() da lista

Retorna o objeto do item selecionado

• lista.getSelectedItem() da lista
Componentes

• JRadioButton
– Uma caixa de seleção no Swing pode ser um objeto do tipo
JRadioButton e o mesmo herda de AbstractButton e JToggleButton.
Logo, uma caixa de seleção é, essencialmente, um tipo especial de
botão.

– O JRadioButton possui uma característica de seleção exclusiva, onde

apenas um de um conjunto de botões pode ser selecionado por vês.

JRadioButton radio1 = new JRadioButton("JRadio 1");

radio1.setBounds(10, 10, 80, 25);

painelPrincipal.add(radio1);
Componentes

• JRadioButton
– No entanto, para deixar a característica de seleção exclusiva nos
JRadioButtons é necessário usar o objeto ButtonGroup, que irá
gerenciar a seleção e a não seleção de quem estiver selecionado.

JRadioButton radio1 = new JRadioButton("JRadio 1");

radio1.setBounds(10, 10, 80, 25);

JRadioButton radio2 = new JRadioButton("JRadio 2");

radio2.setBounds(10, 40, 80, 25);

private ButtonGroup grupoBotoes = new ButtonGroup();

grupoBotoes.add(radio1);
grupoBotoes.add(radio2);
Componentes

• TextArea
– O JTextArea é uma área de texto multi-linha, ou seja, é possível digitar
um texto com várias linhas dentro desse componente. A finalidade de
um caixa de texto é o de permitir ao utilizador inserir informações de
texto de entrada a ser utilizado pelo programa.
– Diretrizes de interface do usuário recomendam uma caixa com uma
única linha de texto quando é necessária apenas uma linha de
entrada, e uma caixa de texto de várias linhas somente se for
necessária mais de uma linha de entrada. Caixas de texto não
editáveis ​pode servir ao propósito de simplesmente exibir texto.

JTextArea areaTexto = new JTextArea();

areaTexto.setBounds(10, 10, 200, 200);
Componentes
Componentes

• Métodos mais utilizados de um JTextArea:

• Obter texto do JTextArea

– areaTexto.getText()
• Guardar um texto no JTextArea
– areaTexto.setText()
• Fazer o texto do componente pular linha automática assim
que chegar no final da área de digitação.
– areaTexto.setLineWrap(boolean wrap);
Componentes

• JComboBox
– Jcombobox é um componente muito utilizado em Java para a criação
de formulários onde há a possibilidade de várias respostas definidas
para uma pergunta.
– Para popular um JComboBox pode ser usado um Array de objetos ou
Strings e também um Vector de objetos ou Strings.

Vector<String> uf = new Vector<String>();

uf.add("PB");
uf.add("PE");
JComboBox<String> comboBox = new JComboBox<String>(uf);
comboBox.setBounds(10, 10, 100, 25);
Componentes
Componentes

• Métodos mais utilizados de um JComboBox

• Pegar o objeto selecionado (lembrando que se não for String

ele retorna um Object e o casting será necessário)
– getSelectedItem()
• Pegar o índice do objeto selecionado
– getSelectedIndex()
• Adicionar um item
– addItem(String item)
• Remover um item
– remove(int index)
Componentes

• JMenuBar, Jmenu, JMenuItem

– Um menu é uma lista de opções ou comandos apresentados a um
operador por um computador ou sistema de comunicações .
– Os menus são, por vezes, hierarquicamente organizado, permitindo
uma navegação através de diferentes níveis da estrutura do menu.
– A seleção de um item do menu com uma seta irá expandi-lo,
mostrando um segundo menu (o sub-menu) com opções relacionadas
com a entrada selecionada.
– É possível adicionar outros componentes ao menu como ícones de
imagem, um componente de botões de radio e até mesmos botões de
cheque.
Componentes

• JMenubar
– Uma implementação de uma barra de menu. Você pode adicionar
objetos JMenu para a barra de menu para a construção de um menu.
• JMenu
– Uma implementação de um menu – uma janela pop-up contendo
JMenuItems que é exibido quando o usuário seleciona um item no
JMenuBar.
• JMenuItem
– Uma implementação de um item em um menu. Um item de menu é
essencialmente um botão em uma lista. Quando o usuário seleciona o
botão, a ação associada ao item de menu é executado.
Componentes

JMenuBar menuBar = new JMenuBar();

JMenu menuCarro = new JMenu("Carro");
JMenuItem menuItemCadastrar = new JMenuItem("Cadastrar");
JMenuItem menuItemAlterar = new JMenuItem("Alterar");
JMenuItem menuItemListar = new JMenuItem("Listar");
menuCarro.add(menuItemCadastrar);
menuCarro.add(menuItemAlterar); Adicionando cada componente
menuCarro.add(menuItemListar); no seu menu respectivo
menuBar.add(menuCarro);

super.setJMenuBar(menuBar);//O JMenuBar é adicionado na janela

JMenuBar

JMenu

JMenuItem JMenuItem JMenuItem

Componentes
JMenuBar
menuBar

menuCarro

JMenu

menuItemCadastrar menuItemDeletar
JMenuItem
menuItemAlterar
Eventos

• 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);
Eventos

• 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.
Eventos

• Hierarquia de Eventos do pacote AWT

Eventos

• Existem três elementos para o funcionamento de 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.
Eventos

• Interfaces ouvintes de eventos do pacote javax.swing.event.

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.
Evento Janela (Window Listener)
• Quando o evento de uma janela precisa ser manipulado, é usada a
interface WindowListener. A interface WindowListener é definida
por AWT e também é usada por Swing.

• Para manipular esse evento, JFrame fornece os seguintes métodos:

– addWindowListener(WindowListener al)
• Adiciona um listener (ouvinte) a ação
– removeWindowListener(WindowListener al)
• Remove um listener (ouvinte) da ação

• Nesse caso “al” especifica um objeto que receberá notificações do

evento. Esse objeto deve ser instância de uma classe que
implemente a interface WindowListener.
Evento Janela (Window Listener)
• WindowListener
– É uma interface que define sete métodos, são eles:
• public void windowActivated(WindowEvent e){}
– Esse método é chamado quando a janela é ativada.
• public void windowClosed(WindowEvent e){}
– Esse método é chamado quando o usuário fechou a janela e retornou dispose
• public void windowClosing(WindowEvent e){}
– Esse método é chamado quando o usuário está fechando a janela
• public void windowDeactivated(WindowEvent e) {}
– Esse método é chamado quando a janela é desativada.
• public void windowDeiconified(WindowEvent e) {}
– Esse método é chamdado quando a janela sai de minimizada para normal
• public void windowIconified(WindowEvent e) {}
– Esse método é chamado quando a janela é minimizada
• public void windowOpened(WindowEvent e) {}
– Esse método é chamado assim que a janela se tornar visível.
Evento Janela (Window Listener)

• WindowListener
– Para implementar o evento de WindowListener não é muito utilizado
classes anônimas. Geralmente a própria classe que herda de JFrame
para criação da janela implementa a interface WindowListener.
– Como é possível visualizar no exemplo abaixo:

public class JanelaPrincipal extends JFrame implements WindowListener{

@Override
public void windowActivated(WindowEvent e) {}
@Override
public void windowClosed(WindowEvent e) {}
@Override
public void windowClosing(WindowEvent e) {}
@Override
public void windowDeactivated(WindowEvent e) {}
@Override
public void windowDeiconified(WindowEvent e) {}
@Override
public void windowIconified(WindowEvent e) {}
@Override
public void windowOpened(WindowEvent e) {}
}
Evento Item (Item Listener)
• Quando é necessário verificar se algum botão que implementa a
interface ItemSelectable está ligado/desligado é necessário usar a
interface ItemListener. A interface ItemListener é definida por AWT
e também é usada por Swing.

• Para manipular esse evento, JFrame fornece os seguintes métodos:

– addItemListener(ItemListener al)
• Adiciona um listener (ouvinte) a ação
– removeItemListener(ItemListener al)
• Remove um listener (ouvinte) da ação

• Nesse caso “al” especifica um objeto que receberá notificações do

evento. Esse objeto deve ser instância de uma classe que
implemente a interface ItemListener.
Evento Item (Item Listener)

• ItemListener
– É uma interface que define apenas um método, o itemStateChanged.
• void itemStateChanged (ItemEvent e){}
– Esse método é chamado quando o botão for ativado ou desativa. Ele é
o tratador de eventos chamado quando ocorre um evento de botão
ativado/desativado.
checkBox.addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
//Onde o evento deverá ser tratado
}
});
Criação de uma classe anônima que implementa ItemListener para
tratamento do evento.
Evento Item (Item Listener)

• ItemListener
– Para verificar se o botão foi habilitado e desabilitado dentro da classe
anônima que implementa ItemListener, é necessário pegar os dados
do evento passado como parâmetro no método itemStateChanged a
partir do método getStateChange() e comparar com o valor SELECTED
E DESELECTED da enum da Classe ItemEvent.

checkBox.addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
if(e. getStateChange() == ItemEvent.SELECTED){
//Trata o evento aqui
}
}
});
Evento Mouse (Mouse Listener)
• Quando é necessário verificar se algum botão do mouse foi
pressionado é necessário usar a interface MouseListener. A
interface MouseListener é definida por AWT e também é usada por
Swing.

• Para manipular esse evento, JFrame fornece os seguintes métodos:

– addMouseListener(MouseListener al)
• Adiciona um listener (ouvinte) a ação
– removeMouseListener(MouseListener al)
• Remove um listener (ouvinte) da ação

• Nesse caso “al” especifica um objeto que receberá notificações do

evento. Esse objeto deve ser instância de uma classe que
implemente a interface MouseListener.
Evento Mouse (Mouse Listener)

• MouseListener
– É uma interface que define cinco métodos, são eles:
• public void mouseReleased(MouseEvent e) {}
– Esse método é chamado quando o botão do mouse é solto (released)
• public void mousePressed(MouseEvent e){}
– Esse método é chamado quando o botão do mouse é pressionado (pressed)
• public void mouseExited(MouseEvent e){}
– Esse método é chamado quando o cursor do mouse sai da área do componente
• public void mouseExited(MouseEvent e){}
– Esse método é chamado quando o cursor do mouse entra na área do
componente
• public void mouseClicked(MouseEvent e){}
– Esse método é chamdado quando o botão do mouse é clicado e solto (pressed e
released)
Evento Teclado (Key Listener)
• Quando é necessário verificar se alguma tecla do teclado foi
pressionado é necessário usar a interface KeyListener. A interface
KeyListener é definida por AWT e também é usada por Swing.

• Para manipular esse evento, JFrame fornece os seguintes métodos:

– addKeyListener(KeyListener al)
• Adiciona um listener (ouvinte) a ação
– removeKeyListener(KeyListener al)
• Remove um listener (ouvinte) da ação

• Nesse caso “al” especifica um objeto que receberá notificações do

evento. Esse objeto deve ser instância de uma classe que
implemente a interface KeyListener.
Evento Teclado (Key Listener)

• KeyListener
– É uma interface que define três métodos, são eles:
• public void keyTyped(KeyEvent e){}
– Esse método é chamado quando uma Tecla for digitada. Verificar classe
KeyEvent para verificar a tecla
• public void keyReleased(KeyEvent e){}
– Esse método é chamado quando uma tecla for solta (released)
• public void keyPressed(KeyEvent e){}
– Esse método é chamado quando uma tecla for pressionada (pressed)