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é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 homem-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
outros componentes , podem ser de alto nível ou intermediários.
components: São botões, labels, scrollbars, etc.
JFrame – janela principal do programa (top-level containers )
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
(container intermediário)
JButton: O botão
JLabel: O texto: “Quantidade de clicks: 0”
Dos elementos acima:
JFrame são containers top-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.setVisible(true);
}
}
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.
Acrescente a linha
painel.setLayout(new BoxLayout(painel,BoxLayout.Y_AXIS));
Observe o que acontece:
BoxLayout.Y_AXIS posiciona os componentes na vertical, se
colocar BosLayout.X_AXIS irá posicional na horizontal.
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[])
{
...
}
}
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á-los à janela.
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.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);
}
}
