Componentes GUI

Componentes GUI




GUI – Grafical User Interface – São construídas a partir
de componentes GUI chamados de controles ou widgets
(windows gadgets – engenhocas de janela).
Ex: JOptionPane fornece caixas de diálogos prépréempacotadas para entrada/saída, como vimos ao
usarmos showMessageDialog e showInputDialog.
Existe diversas funcionalidades disponíveis nas
bibliotecas de classes Java destinadas a prover a
comunicação homemhomem-máquina via interface gráfica.
Os elementos básicos para criar um GUI residem em
dois pacotes: Swing e AWT.


AWT: Abstract Window Toolkit (pacote java.awt) são classes
básicas para construção de interfaces com janelas.
Swing: Fornece melhores alternativas aos componentes da
AWT. Implementado somente a partir da versão 1.2.
Componentes GUI
A aparência e maneira como um usuário pode interagir com
componentes AWT diferem de acordo com a plataforma.
Componentes Swing permitem especificar uniformemente a
aparência e o comportamento para o aplicativo em todas as
plataformas ou utilizar aparência e comportamento personalizados
em cada plataforma.
 Componentes Swing são implementados diretamente na plataforma
Java sendo mais portáveis e flexíveis que os componentes originais
do pacote AWT que foram implementados na GUI da plataforma
subjacente, ou seja em código nativo. Por isto geralmente Swing
são mais usados.

Componentes GUI
Estas classes são parte de um conjunto mais genérico de
capacidades gráficas chamado de Java Foundation Classes, ou
JFC.
 Componentes leves X Componentes pesados: São chamados de
componentes pesados aqueles que são vinculados à plataforma
local, ou dependem do sistema de janela da plataforma local para
determinar seu comportamento e aparência, já os componentes
leve são aqueles que não estão vinculados a componentes GUI
reais da plataforma subjacente.
 Alguns componentes Swing também são componentes pesados,
requerem interação direta com o sistema de janela local o que pode
restringir sua aparência e funcionalidade.
 Componentes leves fornecem melhor controle sobre sua aparência
e funcionalidade.

Componentes GUI

Duas palavras chave para nossa compreensão
são:


Componentes: Partes individuais a partir das quais
uma GUI é construída. São botões, menus, itens de
menu, caixas de seleção, etc.
Tratamento de eventos: São as possíveis respostas
disparadas por ações do usuário. Caso o usuário
ative um componente o sistema gerará um evento
que enviará uma notificação ao nosso sistema que
poderá então chamar um de seus métodos.
Componentes GUI
 Suplerclasses
comuns de muitos
componentes swing
Componentes GUI

Uma interface gráfica em Java é baseada em dois tipos
de elementos:



Todo programa que ofereça uma interface gráfica vai
conter pelo menos um container, que pode ser:





containers: São componentes que servem para agrupar e exibir
containers:
outros componentes
components:: São botões, labels, scrollbars, etc.
components
JFrame – janela principal do programa
JDialog – janela para diálogos
JApplet – janela para Applets
Para construirmos uma interface gráfica em Java
adicionamos componentes (botões, menus, textos,
tabelas, listas, etc) sobre a área de um container
Em nosso exemplo iremos usar um JFrame:


Vejamos uma janela simples.
Esta janela possui os seguintes elementos:





JFrame: Armazena os demais componentes
JPanel: Serve para facilitar o posicionamento do botão label
JButton: O botão
JLabel: O texto: “Quantidade de clicks: 0”
Dos elementos acima:



JFrame são containers toptop-level, sempre haverá um dos 3
anteriormente citados
JPanel são containers intermediate, podem estar ou não
presentes (mas geralmente estão).
JButton e JLabel são componentes atômicos, não podem ser
usados para conter outros e geralmente respondem ao usuário.

Vejamos o código do exemplo anterior:
import javax.swing.*;
public class ExJanela
{
public static void main(String args[])
{
JFrame frame = new JFrame("Aplicação Swing");
JButton but = new JButton("Sou um botão");
JLabel texto = new JLabel("Quantidade de clicks: 0");
JPanel painel = new JPanel();
painel.add(but);
painel.add(texto);
frame.getContentPane().add(painel);
frame.pack();
frame.show();
}
}
 Como
poderíamos adicionar
funcionalidades à janela? Usando herança
para gerar uma nova classe a partir de
JFrame.
 Vejamos como ficaria o código caso
usássemos herança:
import javax.swing.*;
public class ExJanela2 extends JFrame
{
JButton but;
JLabel texto;
JPanel painel;
public ExJanela2()
{
super("Aplicação Swing");
but = new JButton("Sou um botão");
texto = new JLabel("Quantidade de clicks: 0");
painel = new JPanel();
painel.add(but);
painel.add(texto);
getContentPane().add(painel);
}
public static void main(String args[])
{
ExJanela2 janela = new ExJanela2();
janela.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); // Nova linha
janela.pack();
janela.show();
}
}

Observe a nova linha acrescentada ao método main. O
método setDefaultCloseOperation especifica como a
janela irá se comportar ao ser fechada. Seus possíveis
argumentos são:






DISPOSE_ON_CLOSE – Destrói a janela
DO_NOTHING_ON_CLOSE – Desabilita a opção de fechar a
janela
HIDE_ON_CLOSE – Apenas fecha a janela
Teste o programa variando os parâmetros de
setDefaultCloseOperation e verificando o que acontece.
Temos uma questão ainda não resolvida: Como iremos
organizar os componentes em um JPanel? Java oferece
diversos layouts para estruturação de componentes.
Para JPanel o layout default é FlowLayout que distribui
os componentes na horizontal.
Vejamos alguns outros possíveis layouts:
BoxLayout: Posiciona os componentes na horizontal ou vertical. Ex:

public class ExJanela2 extends JFrame
{
...
public ExJanela2()
{
...
painel = new JPanel();
painel.setLayout(new BoxLayout(painel,BoxLayout.Y_AXIS));
painel.add(but);
painel.add(texto);
...
}
public static void main(String args[])
{
...
}
}










import javax.swing.*;
import java.awt.*;
public class TestaContainer
{
public static void main(String args[])
{
int i;
JFrame janela = new JFrame("Teste de janela");
janela.setBounds(200,200,400,150);
janela.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

FlowLayout flow = new FlowLayout(FlowLayout.LEFT);


janela.setLayout(flow);
for (i = 1; i <= 6; i++)
janela.add(new JButton("aperte" + i));
janela.setVisible(true);
}






}

Façamos alguns exercícios bem simples:




1) Implemente e execute o código abaixo no BlueJ.
2) Redimensione interativamente o tamanho da
janela e observe o posicionamento dos botões.
3) Coloque no construtor de FlowLayout um
argumento FlowLayout.LEFT e observe o resultado.
4) Adicione ao programa os seguintes componentes:
• JLabel label1 = new JLabel("Exemplo de texto");
• JTextField campo = new JTextField(15);
• Obs: Não esqueça de adicionáadicioná-los à janela.