•  Vamos discutir como construir aplicações com interface gráfica de usuário

(conhecida como GUI - Graphical User Interface).

•  Numa interface gráfica existem botões, rótulos, caixas de texto, painéis,

barras de rolagem e muitos outros componentes.
•  Com alguns componentes o usuário poderá interagir.
•  A linguagem Java dispõe de classes apropriadas para a construção de cada
componente que compõe uma GUI.
© ELFS 89
 •  Toda interface gráfica em Java tem como superclasse a classe Component (do
pacote java.awt). Logo, qualquer componente presente em uma janela gráfica
é um objeto da classe Component.

java.lang.Object

java.awt.Component

java.awt.Container

javax.swing.JComponent

•  Vamos considerar, basicamente, os componentes da classe JComponent (do

pacote javax.swing) como: JFrame, JDialog, JPanel, JButton, JLabel,
JCheckBox, JList, JMenu, JRadioButton, JScrollPane, ...
•  Alguns destes componentes são contêineres, ou seja, componentes que são
usados para acomodar outros componentes, por exemplo, JFrame e JPanel.

© ELFS 90
 •  A janela de uma interface gráfica é construída a partir de uma classe
descendente da classe Window (do pacote java.awt).

•  As duas principais classes para construção de GUIs são:

•  JFrame: Implementa uma janela gráfica com todas as funcionalidades
(redimensionamento, fechamento, minimização, ...) sendo, portanto, a
classe base para qualquer aplicativo com GUI.
•  JDialog: Implementa uma janela gráfica dependente de outra janela.

•  As classes JFrame e JDialog são contêineres e irão acomodar todos os demais

componentes que irão compor a GUI.

•  O posicionamento dos elementos num contêiner é feito de maneira

automática por gerenciadores de layout. Cada contêiner tem seu gerenciador
de layout padrão. Se não existir um gerenciador de layout associado ao
contêiner (layout = null), então o posicionamento dos componentes no
contêiner deverá ser feito manualmente.

© ELFS 91
 Exemplo 1: Uma janela sem nada
Exemplo1.java
public class Exemplo1
{
private JFrame janela;

public Exemplo1()
{
janela = new JFrame("Primeira Janela");

janela.setSize(400,300); Os métodos setSize() e setVisible()

janela.setVisible(true); são obrigatórios. Comente essas linhas e
} verifique o que acontece.

public static void main(String[] args)

{ O objeto p foi usado onde?
Exemplo1 p = new Exemplo1();
Então poderia ser escrito apenas:
}
} new Exemplo1();

•  A GUI será um objeto da classe JFrame (campo privado da classe).

•  O construtor padrão da classe cria a GUI.
•  A GUI define o título e o tamanho da janela.
•  O que acontece ao fechar a janela?
© ELFS 92
 Exemplo 2: Liberar a JVM ao fechar a janela
Exemplo2.java
public class Exemplo2
{
private JFrame janela;

public Exemplo2()
{
janela = new JFrame("Primeira Janela");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

janela.setSize(400,300); Todas as características desejadas

janela.setVisible(true); para um componente gráfico será
} estabelecido por meio de um setter.
Em geral, as classes definem
public static void main(String[] args)
{
constantes estáticas.
new Exemplo2(); EXIT_ON_CLOSE, por exemplo, é
} uma constante estática da classe
} JFrame.

•  Normalmente, o fechamento de uma janela apenas a torna invisível. Com o

método setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE), ao fechar a
janela será chamado o método exit(), que libera a JVM.
© ELFS 93
 Exemplo 3: Adicionando componentes
Exemplo3.java
public class Exemplo3
{ Por que alguns componentes são
private JFrame janela;
declarados como campos privados
public Exemplo3() da classe e outros não?
{
janela = new JFrame("Janela com Componentes");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Container c = janela.getContentPane(); Notar que os componentes

JLabel rotulo = new JLabel("Elemento JLabel"); são incluídos no painel de
JButton botao = new JButton("Botão Simples");
conteúdo (ContentPane)
c.setLayout(new FlowLayout());
c.add(botao); da janela gráfica.
c.add(rotulo);
O gerenciador FlowLayout acomoda os
janela.setSize(400,100); componentes da esquerda para a direita,
janela.setVisible(true); na ordem em que são incluídos na janela.
}

public static void main(String[] args)

{
new Exemplo3();
}
}
© ELFS 94
 O Componente JPanel
•  GUIs complexas exigem componentes colocados em posições específicas. A
interface gráfica a seguir, por exemplo, pode ser construída usando-se 4
painéis: superior (P1), inferior (P2), central (P3) e à direita (P4).

P1

P3
P4

P2

•  Um painel é um contêiner e portanto, pode conter qualquer outro

componente, inclusive outros painéis. Cada painel pode ter o seu próprio
gerenciador de layout. Assim, pode-se construir GUIs bastante sofisticadas.
© ELFS 95
 Exemplo 4: Janela usando painéis
Exemplo4.java
public class Exemplo4
{
private JFrame janela;

public Exemplo4()
{
janela = new JFrame("Janela com Componentes");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanel p1 = new JPanel(); O layout padrão de um JPanel é o

JPanel p2 = new JPanel(); FlowLayout com alinhamento central.
JPanel p3 = new JPanel();

JLabel label = new JLabel("Elemento JLabel");

JButton botao = new JButton("Botão simples");
JButton outro = new JButton("Outro botão");

p1.setBackground(Color.yellow);
p2.setBackground(Color.white); Cor de fundo do painel.
p1.add(label); Notar o uso de setters e de
p2.add(botao); constrantes estáticas.
p3.add(outro);

© ELFS 96
 Container c = janela.getContentPane();
c.setLayout(new BorderLayout()); O gerenciador BorderLayout
divide o painel de conteúdo em 5
c.add(p1,BorderLayout.NORTH); regiões: norte, sul, oeste, leste e
c.add(p2,BorderLayout.SOUTH); centro. Notar que a classe
c.add(p3,BorderLayout.EAST); BorderLayout define constantes
janela.setSize(400,300); para cada uma das regiões:
janela.setVisible(true); NORTH, SOUTH, WEST, EAST,
} CENTER.

public static void main(String[] args)

{
new Exemplo4();
}
}

© ELFS 97
 Gerenciadores de Layout
•  Os gerenciadores de layout organizam os componentes da GUI em um
contêiner. Estes gerenciadores definem o posicionamento e o tamanho dos
componentes no contêiner.
•  Se o gerenciador de layout for desligado, com setLayout(null), será
necessário posicionar cada um dos componentes manualmente, com o
método setBounds(x, y, largura, altura).
•  Os principais gerenciadores de layout são:
•  FlowLayout
•  BorderLayout
•  GridLayout

•  Outro gerenciador de layout:

•  SpringLayout
Gerenciador de layout bem flexível, normalmente utilizado por construtores
automáticos de GUI.

© ELFS 98
 FlowLayout (padrão para JPanel)
Organiza os componentes sequencialmente, linha por linha, da esquerda para a
direita, na ordem em que são incluídos. Os componentes podem ser alinhados à
esquerda, à direita ou no centro (o padrão).

BorderLayout (padrão para JFrame e JDialog)

Organiza os componentes em 5 regiões: Norte, Sul, Oeste, Leste e Centro. Todo
o espaço não utilizado pelas regiões é deixado para o centro. Cada uma das
regiões só aceita um componente. No caso de haver vários componentes, incluir
um JPanel e depois adicionar os componentes ao painel.

GridLayout
Organiza os componentes em linhas e colunas, como numa tabela. Os
componentes são incluídos nas células da esquerda para a direita e de cima para
baixo. Qualquer componente adicionado a uma célula ocupa toda a célula.

© ELFS 99
 Exemplo 5: Uso do gerenciador FlowLayout
Exemplo5.java
public class Exemplo5
{
private JFrame janela;

public Exemplo5()
{
janela = new JFrame("Janela com FlowLayout");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton b1 = new JButton("Botão 1");
JButton b2 = new JButton("Botão 2");
JButton b3 = new JButton("Botão 3");
Container c = janela.getContentPane();
c.setLayout(new FlowLayout(FlowLayout.RIGHT));
c.add(b1);
c.add(b2);
c.add(b3);
janela.setSize(400,200);
janela.setVisible(true);
}

public static void main(String[] args)

{
new Exemplo5();
}
}
© ELFS 100
 Exemplo 6: Uso do gerenciador BorderLayout
Exemplo6.java
public class Exemplo6 {
private JFrame janela;

public Exemplo6() {
janela = new JFrame("Janela com BorderLayout");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton b1 = new JButton("Botão 1");
JButton b2 = new JButton("Botão 2");
JButton b3 = new JButton("Botão 3");
JButton b4 = new JButton("Botão 4");
JButton b5 = new JButton("Botão 5");
Container c = janela.getContentPane();
c.add(b1, BorderLayout.NORTH);
c.add(b2, BorderLayout.SOUTH);
c.add(b3, BorderLayout.EAST);
c.add(b4, BorderLayout.WEST);
c.add(b5, BorderLayout.CENTER);
janela.setSize(400,300);
janela.setVisible(true);
}

public static void main(String[] args) {

new Exemplo6();
}
}
© ELFS 101
 Exemplo 7: Uso do gerenciador GridLayout Exemplo7.java
public class Exemplo7
{
private JFrame janela;

public Exemplo7()
{
janela = new JFrame("Janela com GridLayout");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton b1 = new JButton("A"); JButton b2 = new JButton("B");

JButton b3 = new JButton("C"); JButton b4 = new JButton("D");
JButton b5 = new JButton("E"); JButton b6 = new JButton("F");
Container c = janela.getContentPane();
c.setLayout(new GridLayout(2,3));
Qual é o layout padrão de um
c.add(b1); c.add(b2);
c.add(b3); c.add(b4);
Container? É o BorderLayout.
c.add(b5); c.add(b6);
janela.setSize(400,200);
janela.setVisible(true);
}

public static void main(String[] args)

{
new Exemplo7();
}
}
© ELFS 102
 Exemplo 8: Usando painel Exemplo8.java
public class Exemplo8
{
private JFrame janela;

public Exemplo8() {
janela = new JFrame("Janela com GridLayout");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton b1 = new JButton("A"); JButton b2 = new JButton("B");

JButton b3 = new JButton("C"); JButton b4 = new JButton("D");
JButton b5 = new JButton("E"); JButton b6 = new JButton("F");
JPanel p = new JPanel(new GridLayout(2,3));
p.add(b1); p.add(b2);
P.add(b3); p.add(b4);
p.add(b5); p.add(b6);

Container c = janela.getContentPane();
c.add(p,BorderLayout.CENTER);
janela.setSize(400,200);
janela.setVisible(true);
}

public static void main(String[] args) {

new Exemplo8();
}
}
© ELFS 103
 •  Exercício: Construir a classe que implementa a interface gráfica de
usuário (GUI) mostrada a seguir. Considerar que todos os
componentes gráficos devem ser declarados como campos privados
da classe.

•  Quais são os componentes presentes nesta GUI?

•  São componentes das seguintes classes: JFrame, JPanel, JButton,
JLabel, JTextField.
© ELFS 104
 public class Exercicio
{
private JFrame janela;
private JPanel pcima,pcentro,pbaixo;
private JButton b;
private JLabel l1,l2,l3,tempo;
private JTextField t1,t2,t3;

private Exercicio()
{
janela = new JFrame("Exercício");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Painel superior
pcima = new JPanel();
pcima.setBackground(Color.ORANGE);
b = new JButton("Calcular");
pcima.add(b);

// Painel inferior
pbaixo = new JPanel();
pbaixo.setBackground(Color.YELLOW);
tempo = new JLabel("Tempo = 0");
pbaixo.add(tempo);
© ELFS 105
 // Painel central
pcentro = new JPanel(new GridLayout(3,2));
pcentro.setBackground(Color.WHITE);
l1 = new JLabel(" Espaço inicial:");
l2 = new JLabel(" Velocidade inicial:");
l3 = new JLabel(" Aceleração:");
t1 = new JTextField();
t2 = new JTextField();
t3 = new JTextField();
pcentro.add(l1);
pcentro.add(t1);
pcentro.add(l2);
pcentro.add(t2);
pcentro.add(l3);
pcentro.add(t3);

// Painel de conteudo da janela

Container c = janela.getContentPane();
c.add(pcima, BorderLayout.NORTH);
c.add(pbaixo, BorderLayout.SOUTH);
c.add(pcentro, BorderLayout.CENTER);

© ELFS 106
 // Dimensionar e mostrar a janela
janela.setSize(300,200);
janela.setVisible(true);
}

public static void main(String[] args)

{
new Exercicio();
}
}

© ELFS 107