1

2

Interfaces Gráficas (GUIs) em Java usando Swing

Componentes Atômicos

São elementos ou componentes que não permitem conter outros elementos.

Podemos citar, dentre outros, botões, labels, textFields, sliders, check boxes,

scrollbars, etc.

JLabel

São rótulos estáticos que geralmente apresentam funcionalidades de outros

componentes GUI, como por exemplo, campos de texto, ícones, etc. Também

servem para apresentar um pequeno texto. As instruções são mostradas por meio de

uma linha de texto somente leitura, uma imagem, ou ambos.

O construtor mais elaborado é JLabel (String, Icon, int). Os argumentos representam

respectivamente o rótulo a ser exibido, um ícone e o alinhamento.

3

Muitos componentes Swing permitem a exibição de ícones. Para JLabels, basta

especificar um arquivo com extensão png, gif ou jpg no segundo argumento do

construtor do JLabel, ou utilizar o método setIcon(Icon), o arquivo da imagem

algumNome.xxx deve encontrar-se no mesmo diretório do programa, ou deve-se

especificar corretamente a estrutura de diretórios até ele.

As constantes SwingConstants, que definem o posicionamento de vários

componentes GUI e aqui são apropriadas ao terceiro argumento, determinam a

locação do ícone em relação ao texto. São elas:

• SwingConstants.NORTH,

• SwingConstants.SOUTH,

• SwingConstants.EAST,

• SwingConstants.WEST,

• SwingConstants.TOP,

• SwingConstants.BOTTOM,

4

• SwingConstants.CENTER,

• SwingConstants.HORIZONTAL,

• SwingConstants.VERTICAL,

• SwingConstants.LEADING,

• SwingConstants.TRAILING,

• SwingConstants.NORTH EAST,

• SwingConstants.NORTH WEST,

• SwingConstants.SOUTH WEST,

• SwingConstants.SOUTH EAST,

• SwingConstants.RIGHT,

• SwingConstants.LEFT

5

Exercício:

Utilizando o NetBeans, crie um projeto como um novo aplicativo Java. Dentro deste

aplicativo, crie um novo formulário JFrame. Dê o nome de Aula1Swing.java.

Coloque um JLabel no frame e coloque o nome desejado que apareça.

Execute o arquivo para ver o resultado.

6

Botões

É um componente que tem o comportamento semelhante ao de um botão real, quer

dizer, ao clicarmos ou apertarmos o botão, uma ação é executada. Um programa

Java pode utilizar vários tipos de botões, incluindo botões de comando, caixas de

marcação, botões de alternância e botões de opção. Para se criar algum desses tipos

de botões, deve-se instanciar uma das muitas classes que descendem da classe

AbstractButton, a qual define muito dos recursos que são comuns aos botões do

Swing. Este comportamento semelhante ao mundo real ajuda aos usuários na

compreensão da interface.

JButton

É um dos componentes mais familiares e intuitivos ao usuário. Os botões de

comando são criados com a classe JButton e seu pressionamento geralmente

dispara a ação especificada em seu rótulo, que também suporta a exibição de

pequenas imagens. Ao pressionar o botão, é gerado um evento ActionEvent que,

7

juntamente com outros eventos, executam algum comando desejado. Estudaremos a

fundo este comportamento na próxima aula.

JCheckBox

A classe JCheckBox dá suporte à criação de botões com caixa de marcação, sendo que

qualquer número de itens pode se selecionado. Quando um item é selecionado, um ItemEvent

é gerado. O mesmo pode ser tratado por um objeto que implemente a interface ItemListener. A

classe que fornece as funcionalidades para este objeto deve definir o método

itemStateChanged, mas isso será visto na próxima aula.

8

JRadioButton

Os botões de opção, que são definidos na classe JRadioButton, assemelham-se às

caixas de marcação no que concerne aos seus estados (selecionado ou não

selecionado). Entretanto, costumeiramente são usados em grupo no qual apenas um

botão de opção pode ser marcado, forçando os demais botões ao estado não-

selecionado.

9

JTextField

Compreende a área de uma única linha que suporta a inserção ou exibição de texto.

Pode-se definir se o texto pode ser manipulado com o método setEditable(boolean),

utilizando no argumento o valor true. Quando o usuário digita os dados em uma

JTexField e pressiona Enter, ocorre um evento de ação. Esse evento é processado

pelo ouvinte de evento registrado que pode usar os dados que estão no JTexField no

momento em que o evento ocorre.

10

JPasswordField

É uma subclasse de JTextField e acrescenta vários métodos específicos para o

processamento de senhas. Sua aparência e comportamento quase nada diferem de

uma JTextField, a não ser quando o texto é digitado, pois o mesmo fica ocultado

pelos asteriscos. Tal procedimento se justifica para ocultar os caracteres inseridos,

dado que esse campo contém uma senha.

11

JTextArea

É uma área dimensionável que permite que múltiplas linhas de texto sejam editadas

com a mesma fonte. Esta classe é herdada de JTextComponent, que define métodos

comuns para JTextField, JTextArea e outros elementos GUI baseados em texto.

As JTextAreas não têm eventos de ação como os objetos da classe JTextField, cujo

o pressionamento de Enter gera um evento. Então, utiliza-se um outro componente

GUI (geralmente um botão) para gerar um evento externo que sinaliza quando o texto

de uma JTextArea deve ser processado. Pode-se configurar um texto com setText

(String) ou acrescentar texto com o método append (String). Para evitar que um

longo texto digitado fique incluso em somente uma linha, usa-se o método

setLineWrap (boolean), que define a quebra da linha quando o texto alcançar a borda

da JTextArea. Porém, as palavras podem ficar “quebradas”, com caracteres em uma

linha e outros na próxima, sem nenhum compromisso com as normas gramaticais.

Uma maneira de sanar paliativamente esse problema é invocar o método

12

setWrapStyleWord (boolean), o qual determina que a mudança de linha seja definida

pelas palavras.

JScrollPane

Objetos dessa classe fornecem a capacidade de rolagem a componentes da classe

JComponent, quando estes necessitam de mais espaço para exibir dados.

JScrollpane (Component, int, int) é o construtor mais elaborado e recebe um

componente (JTextArea por exemplo) como primeiro argumento, definindo qual será

o cliente do JScrollPane, ou seja, para que membro será fornecido as barras de

13

rolagem. Os dois próximos argumentos definem o comportamento da barra vertical e

da horizontal, respectivamente. Para isso, pode-se fazer uso das constantes

definidas na interface ScrollPaneConstants que é implementada por JScrollPane.

Veja elas:

JScrollPane.VERTICAL SCROLLBAR AS NEEDED

JScrollPane.HORIZONTAL SCROLLBAR AS NEEDED Indicam que as barras de

rolagem devem aparecer somente quando necessário.

JScrollPane.VERTICAL SCROLLBAR ALWAYS

JScrollPane.HORIZONTAL SCROLLBAR ALWAYS Indicam que as barras de

rolagem devem aparecer sempre.

JScrollPane.VERTICAL SCROLLBAR NEVER

JScrollPane.HORIZONTAL SCROLLBAR NEVER Indicam que as barras de

rolagem nunca devem aparecer.

14

É possível configurar o comportamento do JScrollPane para um objeto com os

métodos setVerticalScrollBarPolicy(int) e setHorizontalScrollBarPolicy(int), valendo-se

das mesmas constantes como argumentos.

JSlider

É um marcador que desliza entre um intervalo de valores inteiros, podendo

selecionar qualquer valor de marca de medida em que o marcador repouse. Uma das

inúmeras utilidades desse controle deslizante é restringir os valores de entrada em

um aplicativo, evitando que o usuário informe valores que causem erros. Os JSlider

15

comportam a exibição de marcas de medidas principais, secundárias e rótulos de

medida. A aderência às marcas (snap to ticks) possibilita ao marcador aderir à marca

mais próxima, quando este situar-se entre dois valores. Este componente responde

às interações feitas pelo mouse e pelo teclado (setas, PgDn, PgUp, Home e End).

Sua orientação pode ser horizontal, na qual o valor mínimo está situado na extrema

esquerda, ou vertical, na qual o valor mínimo está situado na extremidade inferior. As

posições de valor mínimo e máximo podem ser invertidas, valendo-se do método

setInvert(boolean), com um argumento true.

16

JComboBox

Assemelha-se a um botão, porém, quando clicado, abre uma lista de possíveis

valores ou opções. Mais precisamente é uma caixa de combinação que permite ao

usuário fazer uma seleção a partir de uma lista de itens. Atende-se para que a lista

da caixa de combinação, quando aberta, não ultrapasse os limites da janela da

aplicação. Também é possível digitar nas linhas de uma caixa de combinação. Elas

são implementadas com a classe JComboBox, herdada de JComponent. Tais caixas

de combinação geram ItemEvents, assim como as JCheckBoxes.

17

Menus

Os menus talvez sejam os componentes que mais aparecem nas ferramentas

computacionais. Geralmente eles são encontrados no topo da janela da aplicação, de

onde dão suporte à organização e agrupamento de funções afins em um mesmo

contexto visual, o que facilita muito a localização e entendimento por parte do

usuário, já que a estrutura de cada menu está delineada pelas características dos

itens.

Os menus, que são instanciados a partir da classe JMenu, são anexados a uma

barra de menus com o método add(JMenu) de JMenuBar, sendo que instâncias

dessa última classe comportam-se como containers para menus. A classe JMenuBar

fornece os métodos necessários ao gerenciamento da barra onde os menus são

anexados. A ordenação dos mesmos depende da ordem em que foram adicionados,

sendo que são “empilhados” horizontalmente da esquerda para a direita.

Evidentemente, só pode-se anexar menus a janelas da classe JApplet, JDialog,

JFrame e JInternalFrame, e se faz isso usando-se o método

18

setJMenuBar(JMenuBar). A classe JMenuItem capacita a criação de itens de menu

que, por sua vez, devem ser anexados a um menu. Pode-se usar um item de menu

para executar alguma ação ou para gerir o acionamento de um submenu, o qual

fornece mais itens que estão relacionados por alguma característica comum.

Passo a passo para montagem de um menu em barras em Java:

1. Instancie um JMenuBar. Ele é o responsável pela estrutura do menu.

2. Adicione tantos JMenu’s quantos forem necessários para as opções.

19

a. Dentro de cada JMenu, coloque o JMenuItem, que é o responsável pela opção

a ser escolhida.

Trecho do código para montar a barra de menus apresentada na figura acima:

jMenuBar1.setName("jMenuBar1"); // NOI18N

jMenu1.setText("Arquivo"); //Aba Arq.na barra opções

jMenu1.setName("jMenu1"); // NOI18N

jMenuItem1.setText("Abrir"); // Opção Abrir do menu

jMenuItem1.setName("jMenuItem1"); // NOI18N

jMenu1.add(jMenuItem1);

jMenuItem2.setText("Editar"); // Opção Editar do menu

jMenuItem2.setName("jMenuItem2"); // NOI18N

jMenu1.add(jMenuItem2);

jMenuItem3.setText("Salvar"); // Opção Ajuda do menu

20

jMenuItem3.setName("jMenuItem3"); // NOI18N

jMenu1.add(jMenuItem3);

jMenuBar1.add(jMenu1); //Inclui Arquivo na barra menus

jMenu2.setText("Ajuda");//Aba Ajuda da barra opções

jMenu2.setName("jMenu2"); // NOI18N

jMenuItem4.setText("Ajuda"); // Opção Ajuda do menu

jMenuItem4.setName("jMenuItem4"); // NOI18N

jMenu2.add(jMenuItem4);

jMenuItem6.setText("Pesquisa");//Opção Pesq. do menu

jMenuItem6.setName("jMenuItem6"); // NOI18N

jMenu2.add(jMenuItem6);

jMenuItem5.setText("Sobre"); // Opção Sobre do menu

jMenuItem5.setName("jMenuItem5"); // NOI18N

21

jMenu2.add(jMenuItem5);

jMenuBar1.add(jMenu2); //Inclui Ajuda na barra menus

jMenu3.setText("Sair"); //Aba Sair da barra de opções

jMenu3.setName("jMenu3"); // NOI18N

jMenu3.add(jMenuItem7);

jMenuBar1.add(jMenu3); //Inclui Sair na barra menus

Containers

Dificilmente uma aplicação gráfica é composta por um único componente, mas sim

por vários componentes inter-relacionados. Para este tipo de aplicação, um

componente fundamental é a área onde os demais componentes da aplicação

estarão dispostos. Um componente que pode conter outros componentes é

denominado um container.

22

Em Java, a classe Container é a classe abstrata que define as funcionalidades

básicas associadas a um container, tais como adicionar e remover componentes, o

que é possível através dos métodos add() e remove(), respectivamente. É possível

também estabelecer qual a estratégia de disposição de componentes no container,

ou seja, qual o método de gerência de layout, através do método setLayout().

Window é uma classe derivada de Container cujos objetos estão associados a

janelas. Cada objeto Window é uma janela independente em uma aplicação, embora

a essa janela não estejam associadas às funcionalidades usualmente oferecidas por

gerenciadores de janela.

Windows são áreas retangulares que podem ser exibidas em qualquer parte da tela

gráfica de um usuário. Em AWT, objetos da classe Window estão associados a essa

funcionalidade, sendo que nessa classe são definidos os métodos aplicáveis a

qualquer tipo de janela. O framework Swing oferece a classe JWindow, derivada da

classe Window, com esse mesmo tipo de funcionalidade porém adaptada ao novo

framework.

23

Um objeto Window, no entanto, corresponde a uma janela sem nenhum tipo de

“decoração”. Convém destacar da classe Window os métodos show(), para trazer a

janela para a frente da tela; dispose(), para eliminar uma janela e liberar os recursos

usados por ela usados.

É mais comum que aplicações gráficas criem janelas através de uma das classes

derivadas de Window, tais como um frame ou uma janela de diálogo.

Um frame agrega a uma janela as funcionalidades mínimas para que ela possa ser

identificada e manipulada pelo usuário da aplicação, tais como uma borda e a barra

de títulos com botões de controle da janela. Um frame é uma janela com

propriedades adicionais que a habilitam a ter uma “vida independente” no ambiente

de janelas gráficas. Para que um frame seja apresentado pela aplicação, um objeto

desse tipo de classe deve ser criado e algumas de suas propriedades básicas — tais

como sua dimensão e o fato de estar visível ou não — devem ser estabelecidas.

Em AWT, frames estão associados a objetos da classe Frame. O pacote Swing

24

também oferece a sua versão de um frame através da classe JFrame, que é uma

extensão da classe Frame.

JFrame

Esta classe define objetos que são frequentemente utilizados para criar aplicativos

baseados em GUI. Eles consistem em uma janela com barra de título e uma borda e

fornecem o espaço para a GUI do aplicativo ser construída.

A janela só será exibida na tela quando o programa invocar o método

setVisible(boolean) com um argumento true, ou o método show( ). O tamanho da

janela é configurado com uma chamada ao método setSize(int x, int y), que define

nos valores inteiros dos argumentos a largura e a altura da mesma. Se esse método

não for chamado, somente a barra de título será exibida. No que concerne ao

posicionamento, por default, o canto superior esquerdo da janela é posicionado nas

coordenadas (0, 0) da tela, ou seja, no canto superior esquerdo. Pode-se alterar essa

característica com o méodo setLocation(int x, int y).

25

Criando uma Tela

import javax.swing.*;

public class Frm01 {

public void criaTela(){

public void criaTela(){

JFrame f= new JFrame();

f.setSize(290,100);

f.setTitle("Cadastro");

f.setLocation(10,10);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

f.setVisible(true);

}

}

26

public class TestaFrm01 {

public static void main(String []args){

Frm01 tela = new Frm01();

tela.criaTela();

}

}

A classe TestaFrm01 cria uma instância do objeto tela e chama este objeto. Temos

como saída o seguinte resultado:

27

O método setDefaultCloseOperation()também pode ser executado com outras

constantes como argumento:

DISPOSE_ON_CLOSE - Destróia a janela

DO_NOTHING_ON_CLOSE - Desabilita opção

HIDE_ON_CLOSE - Apenas fecha a janela

EXIT_ON_CLOSE - Encerra a aplicação

Painéis

São áreas que comportam outros componentes, inclusive outros painéis. Em outras

palavras, são elementos que fazem a intermediação entre um container e os demais

GUI anexados. São criados com a classe JPanel, que é derivada da classe

Container. A classe JPanel não tem painel de conteúdo como JFrames, assim, os

elementos devem ser diretamente adicionados ao objeto painel. Além de agregar um

28

conjunto de componentes GUI para fins de layout, pode-se criar áreas dedicadas de

desenho e áreas que recebem eventos do mouse.

Inserindo componentes na tela

import javax.swing.*;

public class Frm02 {

public void criaTela() {

//criando o Frame

JFrame f= new JFrame();

f.setSize(300,100);

f.setTitle("Cadastro de Categorias");

f.setLocation(150,200);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

29

//criando o Painel

JPanel pl = new JPanel();

pl.setLayout(null);// gerenciador de Layout

//Criando os componentes:

//Label

JLabel meuLabel = new JLabel("Código");

meuLabel.setBounds(10, 10, 60, 20);

// Campo de Texto

JTextField meuCampoTexto = new JTextField(" ");

meuCampoTexto.setBounds(80, 10, 60, 20);

// Botão

JButton meuBotao = new JButton("NomeBotão");

meuBotao.setBounds(150, 10, 100, 20);

30

//colando os componentes no Painel

pl.add(meuLabel);

pl.add(meuCampoTexto);

pl.add(meuBotao);

//colando o painel no frame

f.add(pl);

f.setVisible(true);

}

}

31

Desafios

Nesta aula, vimos os conceitos de construção de telas e a importância das classes

do tipo Conteiner. Para relembrarmos os conceitos apresentados aqui e para

exercitarmos os conceitos tratados nas aulas de Linguagem de Programação, vamos

fazer o seguinte exercício:

Crie um projeto para implementar o sistema descrito abaixo:

1. Crie o conjunto de classes descritas abaixo:

2. Implemente uma tela principal com um menu para efetuar o cadastro de clientes.

3. Implemente uma tela de cadastro para que o cliente abra conta no Banco.

4. Crie mecanismos para efetuar depósitos e saques na conta escolhida.