Principais Classes Swing AWT

As classes e interfaces localizadas nos pacotes

java.awt e javax.swing são recursos para o desenvolvimento
de GUIs (Graphic User Interface – Interface Gráfica do
Usuário).

Uma GUI é desenvolvida utilizando-se componentes, que

são objetos visuais que possibilitam ao usuário realizar a
interação com o programa por meio do mouse e do teclado. Os
componentes mais comuns são: rótulos (Label), botões
(button), campo de texto (text field), áreas de texto (text
area), caixas de checagem (check box), botões de rádio
(radio button), listas (list) e menus.

Na versão 1.0 de Java, encontramos um pacote chamado

AWT (Abstract Window Toolkit – kit de ferramentas de
janelas abstratas) contendo todas as classes necessárias
para a construção de GUIs. A estratégia adotada, naquele
momento, para tratar dos elementos da interface do usuário
fora delegar a sua criação e seu comportamento ao kit de
ferramentas nativo do sistema operacional específico onde
fossem criados.

Algum tempo depois se verificou que os componentes

apresentavam diferenças entre as diversas plataformas e
isto dificultava a construção de GUIs. Além disto, ocorriam
erros diferentes com os componentes em cada plataforma,
obrigando os desenvolvedores a testar seus aplicativos em
cada uma delas.

Devido a este problema, a Sun começou a desenvolver

uma nova biblioteca de componentes que aperfeiçoasse o
método adotado. Essa biblioteca foi chamada de Swing e
passou a ser o nome oficial do kit de componentes para a
construção de GUIs.

O pacote Swing não é sobrecarregado com as complexas

capacidades da plataforma em que são utilizados e, por
isto, são freqüentemente chamados de peso leve. Ao
contrário, os componentes AWT precisam contar com o sistema
de janelas da plataforma local para determinar sua
funcionalidade, sua aparência e seu comportamento.
Entretanto, alguns componentes Swing ainda requerem
interação direta com o sistema local de janelas, como é o
caso de todas as classes derivadas de Window (como JFrame).

Os componentes AWT continuam disponíveis nas últimas

versões do J2SDK e encontra-se no pacote java.awt. Os
componentes Swing foram dispostos no pacote javax.swing.

1
Component

A classe Component representa as características

comuns de todos os componentes, ou seja, de todos aqueles
objetos que possuem uma representação gráfica, que podem
interagir com o usuário e que possuem uma aparência e um
comportamento.

Container

A classe Container representa um contêiner,ou seja, um

componente que pode abrigar dentro de si outros
componentes.

Os contêineres criados com a classe Container

funcionam como painéis e janelas, que abrigam outros
contêineres e/ou componentes que aparecem na tela.

A classe javax.swing.JFrame

JFrame é um container de janela e é uma versão

estendida da classe java.awt.Frame que adiciona suporte à
arquitetura dos componentes Swing. Entretanto, ela é
incompatível com a classe Frame.

Para adicionar um componente a um JFrame é preciso

invocar o método add() do objeto que representa seu painel
de conteúdo. Como esse objeto não pode ser acessado
diretamente, deve-se recuperá-lo utilizando o método
getContentPane() da janela. A instrução para adição de um
componente a um JFrame deve, então obedecer ao seguinte
padrão.

JFrame f = new JFrame ();

f.getContentPane().add(<nome do Componente>);

2
Veja abaixo um exemplo da utilização do container JFrame.

import java.awt.*;
import javax.swing.*;
class TesteJFrame extends JFrame{

public TesteJFrame(){
//Titulo da janela
1 setTitle("Primeira Janela Swing");
//tamanho da janela
2 setSize(275,100);
// anula o layout padrao
3 getContentPane().setLayout(null);
//cor de fundo da janela no padrão RGB (Red Green Blue)
4 getContentPane().setBackground(new Color(255,255,255));
//provoca o termino da execução (encerra o programa)
5 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String [] args){
6 TesteJFrame janela = new TesteJFrame();
7 janela.setVisible(true);
}
}

A classe TesteJFrame é filha de JFrame, logo herda os

atributos e métodos da super classe.

Na linha 1 está sendo definido o título da janela.

Na linha 2 está sendo definido o tamanho da janela.

Na linha 3 está sendo anulado o layout padrão para que

seja possível definir manualmente o tamanho e a posição dos
componentes que ele abrigará.

Na linha 4 está sendo definida a cor de fundo da

janela. As cores seguem o padrão RGB (Red Green Blue) e
podem ser representadas por números inteiros de 0 a 255 ou
por números em ponto flutuante entre 0,0 e 1,0.

Na linha 5 estamos definindo o comportamento que será

executado quando clicarmos no botão "X" no canto superior
direito da janela, ou seja, encerrar a execução do
programa. Caso não seja definido este comportamento, a
janela irá assumir o comportamento default (HIDE_ON_CLOSE)
ou seja, a janela será "escondida", mas o processo
continuará executando.

Na linha 6 está sendo criado um objeto da classe. Veja

que todas as definições da janela estão sendo executadas
dentro do método construtor.

Na linha 7 a janela torna-se visível para o usuário.

3
Veja a janela gerada pela execução do programa anterior.

Esta janela não irá aparecer centralizada na tela e

caso este seja o objetivo, devemos alterar o código da
classe anterior.

Veja o exemplo abaixo:

import java.awt.*;
import javax.swing.*;
class TesteJFrame extends JFrame{

public TesteJFrame(){
//Titulo da janela
setTitle("Primeira Janela Swing");
//tamanho da janela
setSize(275,100);
// anula o layout padrao
getContentPane().setLayout(null);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteJFrame janela = new TesteJFrame();
janela.setVisible(true);
}
}

4
Inserindo Textos, Campos de Edição e Botões na
Tela

A Classe javax.swing.JLabel

Um rótulo (JLabel) é uma área para a exibição de um

texto, uma imagem ou ambos. Ele não reage a eventos de
entrada e, por isto, não pode receber o foco do teclado.
Entretanto, pode incluir teclas de atalho para passar o
foco para outro componente.

Veja o exemplo abaixo:

import java.awt.*;
import javax.swing.*;
class TesteJLabel extends JFrame{

public TesteJLabel(){
//Titulo da janela
setTitle("Primeira Janela Swing");
//tamanho da janela
setSize(275,100);
//anula o layout padrao
getContentPane().setLayout(null);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
//Cria um JLabel
JLabel jl= criarJLabel();
//insere o JLabel no ContentPane da Janela
getContentPane().add(jl);
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
}
public JLabel criarJLabel(){
JLabel jl = new JLabel();
jl.setText("JLabel inserido");
jl.setLocation(10, 10);
jl.setSize(370, 50);
//Torna opaco o fundo do rótulo
jl.setOpaque(true);
jl.setBackground(new Color(255,255,255));
jl.setForeground(new Color(0,0,0));
jl.setFont(new Font("Courier new", Font.BOLD, 12));
jl.setToolTipText("JLabel Exemplo");
jl.setHorizontalAlignment(SwingConstants.LEFT);
jl.setVerticalAlignment(SwingConstants.TOP);

return jl;
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

5
 if (janela.height > screen.height)
setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteJLabel janela = new TesteJLabel();
janela.setVisible(true);
}
}

Veja a janela gerada pela execução do programa anterior

A Classe javax.swing.JButton

Um botão (button) é um componente que pode ser

pressionado pelo usuário, utilizando o mouse ou teclado,
para acionar uma ação específica.

Veja o exemplo abaixo:

import java.awt.*;
import javax.swing.*;
class TesteJButton extends JFrame{

public TesteJButton(){
//Titulo da janela
setTitle("Primeira Janela Swing");
//tamanho da janela
setSize(new Dimension(300,100));
//anula o layout padrao
getContentPane().setLayout(null);
//cor de fundo da janela no padrao RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
JButton b1, b2;
//Cria um JButton "gravar"
b1 = new JButton();
b1.setText("Gravar");
//50 posição x, 30 posição y, 100 largura, 30 altura
b1.setBounds(50, 30, 100, 30);
b1.setBackground(new Color(0,0,170));
b1.setForeground(Color.YELLOW);
b1.setFont(new Font("Helvetica", Font.BOLD, 12));
b1.setToolTipText("Botao b1");
b1.setHorizontalAlignment(SwingConstants.CENTER);
b1.setVerticalAlignment(SwingConstants.CENTER);
b1.setEnabled(false);

6
 b1.setMnemonic('G');

b2 = new JButton();
b2.setText("Sair");
b2.setBounds(150, 30, 100, 30);
b2.setBackground(new Color(0,0,170));
b2.setForeground(Color.YELLOW);
b2.setFont(new Font("Helvetica", Font.BOLD, 12));
b2.setToolTipText("Botao b2");
b2.setHorizontalAlignment(SwingConstants.CENTER);
b2.setVerticalAlignment(SwingConstants.CENTER);
b2.setEnabled(true);
b2.setMnemonic('S');

//insere os botões no ContentPane da Janela

getContentPane().add(b1);
getContentPane().add(b2);
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtem a altura e largua da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteJButton janela = new TesteJButton();
janela.setVisible(true);
}
}

Veja abaixo a saída gerada pela execução do programa acima.

Vários métodos da classe JButton realizam as mesmas

tarefas realizadas por métodos com nomes idênticos da
classe JLabel e já foram analisados. Veja abaixo um resumo
desses métodos:

7
 setText(): define o texto do botão
setBounds(): define o tamanho e a posição em seu
contêiner
setBackground(): define a cor de fundo
setForeground(): define a cor do texto
setFont(): define o tipo, o estilo e o tamanho da
fonte
setToolTipText(): define uma dica
setHorizontalAlignment(): define o alinhamento
horizontal do conteúdo.
setVerticalAlignment(): define o alinhamento vertical
do conteúdo.

Apenas dois métodos utilizados nesse exemplo não

haviam sido introduzidos durante o estudo dos Labels
(JLabel). São eles: setEnabled() e setMnemonic().

setEnabled(): exige um argumento booleano e serve para

habilitar ou desabilitar o botão.

setMnemonic(): define um atalho de teclado para o

botão. Deve-se informar para esse método um caracter que
exista no seu texto. Posteriormente, o botão poderá ser
acessado, a partir de qualquer ponto da janela,
pressionando-se a tecla ALT em conjunto com esse caracter.

A Classe javax.swing.JTextField

Esta classe representa um campo de texto para

digitação pelo usuário, usualmente empregado para campos de
cadastro de uma única linha.

Veja o exemplo abaixo:

import java.awt.*;
import javax.swing.*;
class TesteJTextField extends JFrame{

public TesteJTextField(){
//Titulo da janela
setTitle("Primeira Janela Swing");
//tamanho da janela
setSize(new Dimension(300,100));
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(200,230,200));
//Cria JTextField
JTextField jt = new JTextField();
jt.setText("Insira texto aqui");
jt.setHorizontalAlignment(JTextField.CENTER);

8
 //insere o JTextField no ContentPane da Janela
getContentPane().add(jt);
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteJTextField janela = new TesteJTextField();
janela.setVisible(true);
}
}

Layouts de Tela

Gerenciamento de Layout

Nos exemplos anteriores, o tamanho e o posicionamento

dos componentes nas janelas foram definidos através dos
métodos setSize(), setBounds() e setLocation(). Utilizou-se
o sistema de coordenadas x e y para posicionar os
componentes e a definição de valores absolutos para sua
altura e largura. Entretanto, essa forma de organização
esbarra em vários inconvenientes.

Deve-se evitar o uso de valores absolutos para

definição do tamanho e posição de componentes porque eles
comprometem duas importantes características da qualidade
do software: sua portabilidade e manutenção. Eles
comprometem a portabilidade porque os componentes
dimensionados e posicionados com valores absolutos se
apresentam de forma distinta em diferentes plataformas.
Eles também comprometem a manutenibilidade porque o
trabalho necessário para realizar ajustes em uma GUI se
torna mais complexo, gastando muito mais tempo.

9
 Em função do exposto acima, é aconselhável evitar o
uso de valores absolutos para o dimensionamento e
posicionamento de componentes. Para isso, deve-se
substituir esse procedimento pelo uso dos gerenciadores de
leiaute (layout) disponíveis na API Java.

Os gerenciadores de leiaute (layout) nada mais são que

classes que aplicam um conjunto de regras predefinidas para
determinar o tamanho e a posição de cada componente em um
contêiner. Para que os componentes de uma janela ou de um
painel sejam organizados, automaticamente, você precisará
vincular um gerenciador de leiaute (layout) a esse
contêiner e adicionar os componentes a ele.

O objetivo de um gerenciador de leiaute (layout) é

organizar os componentes em seu contêiner para uma
apresentação adequada. Além de serem mais eficientes, eles
fornecem capacidades que são muito mais fáceis de utilizar
do que a definição de tamanho e posição por valores
absolutos.

Além disso, utilizando-se gerenciadores de leiaute

(layout), os componentes são reorganizados automaticamente,
quando a janela em que estão dispostos é redimensionada e
se ajustam a mudanças feitas em seu conteúdo.

Layout de Fluxo (FlowLayout)

O leiaute (layout) de fluxo (flowLayout) alinha os

componentes em um fluxo, da esquerda para a direita e de
cima para baixo, muito parecido com o texto de um
parágrafo. Esse tipo de leiaute (layout) é representado
pela classe java.awt.FlowLayout.

Em um painel cujo gerenciamento de leiaute (layout) é

delegado a um objeto da classe FlowLayout, os componentes
são dispostos em colunas e linhas, da esquerda para a
direita e de cima para baixo, à medida que são adicionados.
Quando um componente é adicionado, ele é disposto do lado
direito do último componente presente no painel e, se ele
não é comportado na mesma linha, ele é posicionado na linha
seguinte.

10
Veja o exemplo abaixo.

import java.awt.*;
import javax.swing.*;
class TesteFlowLayout extends JFrame{

public TesteFlowLayout(){
//Titulo da janela
setTitle("Teste FlowLayout");
//Define um tamanho inicial para a janela
setSize(300,120);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
//Cria um flowlayout alinhando seus componentes ah esquerda
//e definindo o espaçamento horizontal e vertical entre eles
FlowLayout fl = new FlowLayout(FlowLayout.LEFT, 10, 10);

getContentPane().setLayout(fl);

JButton b1 = new JButton("Botao 1");

JButton b2 = new JButton("Botao 2");
JButton b3 = new JButton("Botao 3");
JButton b4 = new JButton("Botao 4");
JButton b5 = new JButton("Botao 5");

getContentPane().add(b1);
getContentPane().add(b2);
getContentPane().add(b3);
getContentPane().add(b4);
getContentPane().add(b5);

}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteFlowLayout janela = new TesteFlowLayout();
janela.setVisible(true);
}
}

11
 Neste exemplo foi criado um objeto da classe
FlowLayout com um de seus construtores que modifica o
alinhamento padrão dos componentes (centralizado) para que
sejam alinhados à esquerda e definiu-se também o
espaçamento horizontal e vertical entre estes componentes.

Para definir esse objeto como gerenciador de leiaute

(layout) do painel de conteúdo da janela, invocou-se o
método setLayout() desse painel e utilizou-se o objeto "fl"
como argumento.

Neste exemplo, à medida que a janela for

redimensionada, os botões serão reorganizados como se
fossem palavras em um parágrafo alinhado à esquerda. Se a
largura da janela for incrementada, alguns botões podem
passar para as linhas precedentes àquelas em que se
encontram.

Veja abaixo a tela gerada pela execução deste programa.

Layout de Bordas (BorderLayout)

O leiaute (layout) de bordas é representado pela

classe java.awt.BorderLayout. Ela posiciona e redimensiona
os componentes para ajustarem-se a cinco regiões de seu
contêiner: norte, sul, leste, oeste e centro. Cada uma
dessas regiões pode conter somente um componente e sua
localização é definida por uma constante, como segue:

BorderLayout.NORTH: representa a região norte (superior)

BorderLayout.SOUTH: representa a região sul (inferior)
BorderLayout.EAST: representa a região leste (direita)
BorderLayout.WEST: representa a região oeste (esquerda)
BorderLayout.CENTER: representa a região central.

12
Veja abaixo um exemplo.

import java.awt.*;
import javax.swing.*;
class TesteBorderLayout extends JFrame{

public TesteBorderLayout(){
//Titulo da janela
setTitle("Teste BorderLayout");
//Define um tamanho inicial para a janela
setSize(350,150);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
//Cria um borderlayout definindo o espaçamento horizontal e
//vertical entre cada uma das regiões
BorderLayout bl = new BorderLayout(5,5);

getContentPane().setLayout(bl);

JButton b1 = new JButton("Botao Norte");

JButton b2 = new JButton("Botao Sul");
JButton b3 = new JButton("Botao Leste");
JButton b4 = new JButton("Botao Oeste");
JButton b5 = new JButton("Botao Centro");

getContentPane().add(b1,BorderLayout.NORTH);
getContentPane().add(b2,BorderLayout.SOUTH);
getContentPane().add(b3,BorderLayout.EAST);
getContentPane().add(b4,BorderLayout.WEST);
getContentPane().add(b5,BorderLayout.CENTER);

}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteBorderLayout janela = new TesteBorderLayout();
janela.setVisible(true);
}
}

13
 Um objeto da classe BorderLayout foi criado
utilizando-se uma versão alternativa do construtor, de modo
a ser possível definir um espaçamento horizontal e vertical
entre cada uma de suas regiões. Na linha seguinte esse
objeto é configurado como gerenciador de leiaute (layout)
do painel de conteúdo da janela.

Foi utilizado o método add() para adicionar

componentes ao contêiner. Como o gerenciador de leiaute
(layout) é o borderLayout, foi preciso informar, além do
nome do componente, uma das constantes que representa a
região onde o botão será inserido.

Ao redimensionar a janela, aumentando ou diminuindo

tanto a largura quando a altura, os botões adicionados ao
seu painel de conteúdo têm largura e/ou altura modificadas,
mas matem sempre as mesmas posições.

Veja abaixo a tela gerada pela execução deste programa.

Layout de Grade (GridLayout)

Um gerenciador de leiaute (layout) de grade é aquele

que dispõe os componentes em um contêiner em forma de uma
grade retangular. O contêiner é dividido em células
retangulares de tamanhos iguais e cada componente é
disposto em uma célula diferente.

O leiaute (layout) de grade (GridLayout) é

representado pela classe java.awt.GridLayout e, do mesmo
modo que no leiaute (layout) de fluxo, os componentes são
dispostos da esquerda para a direita, mas ocupam uma célula
da grade e ajustam seu tamanho a ela.

14
Veja abaixo um exemplo.

import java.awt.*;
import javax.swing.*;
class TesteGridLayout extends JFrame{

public TesteGridLayout(){
//Titulo da janela
setTitle("Teste GridLayout");
//Define um tamanho inicial para a janela
setSize(300,150);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();

GridLayout gl = new GridLayout(3,2,0,0);

getContentPane().setLayout(gl);

JButton b1 = new JButton("Linha 1 - Coluna 1");

JButton b2 = new JButton("Linha 1 - Coluna 2");
JButton b3 = new JButton("Linha 2 - Coluna 1");
JButton b4 = new JButton("Linha 2 - Coluna 2");
JButton b5 = new JButton("Linha 3 - Coluna 1");
JButton b6 = new JButton("Linha 3 - Coluna 2");

getContentPane().add(b1);
getContentPane().add(b2);
getContentPane().add(b3);
getContentPane().add(b4);
getContentPane().add(b5);
getContentPane().add(b6);
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteGridLayout janela = new TesteGridLayout();
janela.setVisible(true);
}
}

15
 No exemplo acima foi instanciado um novo objeto da
classe GridLayout, chamado "gl", utilizando-se uma versão
do construtor que exige quatro números inteiros como
argumentos. Eles representam, respectivamente: o número de
linhas, o número de colunas, o espaçamento horizontal e o
espaçamento vertical entre os componentes (em pixels).

Na instrução seguinte o objeto "gl" é definido como o

gerenciador de leiaute (layout) do painel de conteúdo da
janela. A partir deste momento, todos os componentes
adicionados a esse painel serão posicionados na grade de
três linhas e duas colunas que ele representa.

Se a janela for redimensionada, todos os componentes

também serão redimensionados na mesma proporção para
ocuparem todo o seu espaço.

Veja abaixo a tela gerada pela execução deste programa.

Painéis - Inserindo novos containeres a tela a

partir do JPanel

Os painéis agem como contêineres que servem para

dividir a janela. Eles são utilizados para possibilitar
maior controle da organização de interfaces gráficas mais
complexas e, em conjunto com os gerenciadores de leiaute
(layout), permitem mais exatidão no posicionamento dos
componentes.

A classe javax.swing.Jpanel representa um contêiner

genérico. Ela deriva da classe Jcomponent, que é uma classe
derivada de Java.awt.Container. Pode-se dizer que todo
painel, representado como um objeto da classe Jpanel, é um
contêiner e pode abrigar componentes, inclusive outros
painéis.

16
Veja o exemplo abaixo.

import java.awt.*;
import javax.swing.*;
class TesteJPanel extends JFrame{
JButton b1, b2;
JPanel p1, p2;
public TesteJPanel(){
//Titulo da janela
setTitle("Teste JPanel");
//tamanho da janela
setSize(200,200);
// anula o layout padrao
getContentPane().setLayout(null);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));
//provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();

p1 = new JPanel();
p1.setLayout(null);
p1.setBounds(10, 10, 170, 70);
p1.setBackground(Color.BLUE);

p2 = new JPanel();
p2.setLayout(null);
p2.setBounds(10,90,170,70);
p2.setBackground(Color.YELLOW);

b1 = new JButton("Gravar");
b1.setBounds(35, 30, 100, 30);
b2 = new JButton("Sair");
b2.setBounds(35, 30, 100, 30);

p1.add(b1);
p2.add(b2);
getContentPane().add(p1);
getContentPane().add(p2);
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public static void main(String [] args){
TesteJPanel janela = new TesteJPanel();
janela.setVisible(true);
}
}

17
 O objetivo deste exemplo é criar dois painéis e
adiciona-los ao painel de conteúdo da janela e, em seguida,
adicionar um botão em cada um dos painéis criados.

Para facilitar o exemplo, os gerenciadores de leiaute

(layout) não foram utilizados, logo o leiaute (layout)
padrão desses painéis foi anulado pela chamada as
instruções setLayout(null). Com isto foi possível adicionar
componentes e posicioná-los utilizando posições absolutas
(coordenadas x e y).

Veja abaixo a saída gerada pela execução do programa

anterior.

Interface

Interface é um recurso da programação orientada a

objetos que define ações (comportamentos) que devem ser
obrigatoriamente executadas, porém cada classe que
implementa esta interface pode executar de forma diferente.

Interfaces possuem valores constantes ou assinaturas

de métodos que devem ser implementados dentro de uma
classe. Uma interface é a definição de um tipo, uma classe
é a implementação de um tipo e um objeto é uma instância de
um tipo.

A interface define um tipo porque muitos objetos

(instâncias de classes) podem possuir a mesma ação (método
ou comportamento), porém podem executar esta ação de forma
diferente.

Para exemplificar o conceito de interface, vamos

definir uma interface chamada País que possui a assinatura
do método criarConstituicao(). Ou seja, toda classe que
implementar País deve definir como criar uma constituição
por meio do método criarConstituicao(). Devido a isto, se
eu tenho uma classe chamada Brasil e outra chamada México,

18
ambas implementando a interface País, cada uma deverá
obrigatoriamente codificar a forma como a constituição será
criada. (Existe uma opção para não codificar utilizando a
palavra abstract que não será abordada no curso).

Uma interface pode ser criada da mesma forma que uma

classe, basta utilizar a palavra chave "interface" no lugar
de class. Veja o exemplo abaixo:

interface InterfaceName
{
método(args);
}

Uma classe pode estender suas funcionalidades obtendo

as características de outra classe num processo chamado de
herança. Uma interface não é herdada, mas sim implementada.
Todo o código dos métodos da interface deve ser escrito
dentro da classe que implementa a interface. Com isto,
obtemos as assinaturas dos métodos da interface em uma
classe utilizando a palavra chave implements.

A vantagem das interfaces está no fato de que não há

limites para a quantidade de interfaces que uma classe pode
implementar. Isto ajuda no caso de herança múltipla que não
é suportada pela linguagem Java, pois uma classe apenas
pode herdar as características e comportamentos de uma
única classe.

Vamos analisar o exemplo abaixo:

public interface Temperatura {

void converterTemperatura(double temperatura, String origem);
}

import javax.swing.JOptionPane;
public class Celcius implements Temperatura {
public void converterTemperatura(double temperatura, String origem)
{
double tempCelcius=0;
if( origem.equals("Fahrenheit")){
tempCelcius = (temperatura - 32) / 1.8;
}
else if (origem.equals("Kelvin")){
tempCelcius = temperatura - 273.15;
}
JOptionPane.showMessageDialog(null,"Temperatura em Celcius:
" + tempCelcius);
}
}

19
import javax.swing.JOptionPane;
public class Fahrenheit implements Temperatura {
public void converterTemperatura(double temperatura, String origem){
double tempFahrenheit =0;
if( origem.equals("Celcius")){
tempFahrenheit = temperatura * 1.8 + 32;
}
else if (origem.equals("Kelvin")){
tempFahrenheit = temperatura * 1.8 - 459.67;
}
JOptionPane.showMessageDialog(null, "Temperatura em
Fahrenheit: " + tempFahrenheit);
}
}

A interface Temperatura define o método

converterTemperatura(), já as classes Celcius e Fahrenheit
implementam o método converterTemperatura() de formas
diferentes, ou seja, cada implementação do método utiliza
fórmulas diferentes para converter a temperatura, pois o
objetivo do método converterTemperatura() da classe Celcius
é converter a temperatura para Celcius, já na classe
Fahrenheit o objetivo é converter a temperatura para
Fahrenheit.

Curiosidade: Em interfaces, os métodos são públicos

abstratos(public abstract) e os atributos são constantes
estáticas (final static), mesmo que o desenvolvedor não
defina essas palavras na assinatura do método.

A classe Java abaixo foi criada apenas para testar o

exemplo acima descrito. Veja que são solicitadas ao usuário
três informações:
1) Um valor de temperatura (origem);
2) Qual unidade está a temperatura (origem) informada;
3) Para qual temperatura deve-se converter a temperatura;

Em seguida é criado o objeto correspondente e a

temperatura será convertida.

import javax.swing.JOptionPane;
public class TestaConversao {
public static void main(String[] args) {
String temperatura = JOptionPane.showInputDialog("Digite o
valor da temperatura (origem)");
String origem = JOptionPane.showInputDialog("Digite a
unidade da temperatura");
String destino = JOptionPane.showInputDialog("Informe a
unidade da temperatura destino");

if(destino.equals("Celcius")){
Celcius c = new Celcius();
double temp = Double.parseDouble(temperatura);
c.converterTemperatura(temp, origem);
}
else if(destino.equals("Fahrenheit")){

20
 Fahrenheit f = new Fahrenheit();
double temp = Double.parseDouble(temperatura);
f.converterTemperatura(temp, origem);
}
}
}

Como exercício, crie a classe Kelvin, implemente o

método converterTemperatura() e faça as modificações
necessárias na classe TestaConversao para a mesma também
calcular a temperatura em graus Kelvin.

Fórmulas para conversão:

De Para Fórmula
Celsius Kelvin K = °C + 273,15
Fahrenheit Kelvin K = (°F + 459.67) / 1.8

Eventos de Clique (Ação)

Eventos de clique (aça)o são eventos de alto nível

gerados por um componente (como um botão) quando a ação
especificada por ele ocorrer (como ser pressionado). Quando
um evento desse tipo ocorre, o componente gerador envia um
objeto da classe ActionEvent para cada ouvinte, registrado
através do método addActionListener().

Cada vez que um botão é pressionado, o ouvinte será

notificado através de um objeto do tipo ActionEvent, que
contém informações acerca do evento ocorrido. Se ele é
ouvinte de dois ou mais botões, é preciso determinar qual
deles foi pressionado para tomar a decisão correta. Isso
pode ser feito invocando-se o método getSource(), que
retornará uma referência ao objeto que gerou o evento.

Veja o exemplo abaixo

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
class TesteEventoAcao extends JFrame implements ActionListener{
JLabel l1;
JButton b1, b2;
int i1, i2;
public TesteEventoAcao(){
setTitle("Teste Evento Acao");
//tamanho da janela
setSize(240,100);
// anula o layout padrao
getContentPane().setLayout(null);
//cor de fundo da janela no padrão RGB (Red Green Blue)
getContentPane().setBackground(new Color(255,255,255));

21
 //provoca o termino da execução (encerra o programa)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centralizar();
i1 = i2 = 0;
b1 = new JButton("Gravar");
b1.setBounds(10, 10, 100, 30);
b1.addActionListener(this);
b2 = new JButton("Sair");
b2.setBounds(120, 10, 100, 30);
b2.addActionListener(this);
l1 = new JLabel("Pressione os botões");
l1.setBounds(5, 50, 220, 20);
getContentPane().add(b1);
getContentPane().add(b2);
getContentPane().add(l1);
}
public void centralizar(){
//obtém a altura e largura da resolução vídeo
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
//obtém a altura e largura da minha janela
Dimension janela = getSize();

if (janela.height > screen.height)

setSize(janela.width, screen.height);
if (janela.width > screen.width)
setSize(screen.width, janela.height);

setLocation((screen.width - janela.width)/2,
(screen.height - janela.height)/2);
}
public void actionPerformed(ActionEvent e){
if (e.getSource() == b1)
l1.setText("Botão gravar pressionado " + ++i1 + " vez(es)");
if (e.getSource() == b2)
l1.setText("Botão sair pressionado " + ++i2 + " vez(es)");
}
public static void main(String [] args){
TesteEventoAcao janela = new TesteEventoAcao();
janela.setVisible(true);
}
}

Exercícios Sobre Interface Gráfica

1) Implemente uma classe Java que faça uso de

interface gráfica. Faça uma tela de login de
usuário com os seguintes componentes:
• Um rótulo (label) com a descrição
"Usuário"
• Um rótulo (label) com a descrição "Senha"
• Uma caixa de texto (TextField) para o
usuário digitar o seu nome
• Uma caixa de senha (PasswordField) para o
usuário digitar a sua senha
• Dois botões: Um "Ok" e outro "Cancelar"

22
 Quando o usuário clicar no botão "Cancelar" o
programa deve ser encerrado (Utilize o comando
System.exit(0) para isto).
Quando o usuário clicar no botão "Ok" valide o
usuário e senha e caso sejam informações corretas,
utilize um JOptionPane para informar ao usuário que
ele foi logado ao sistema e em seguida encerre o
programa (Utilize o comando System.exit(0) para
isto).
Caso as informações não estejam corretas, utilize
um JoptionPane para informar ao usuário que as
informações de login não estão corretas, e diga
para o usuário digitar as informações novamente.

2) Implemente uma classe Java com a seguinte GUI:

23