Componentes GUI - JAVA

UNIDADE II – PROGRAMAÇÃO UTILIZANDO AMBIENTE VIRTUAL EM JAVA
OBJETIVOS
• Construir janelas gráficas utilizando a linguagem Java e seus pacotes AWT e
SWING, possibilitando assim a construção de formulários para a geração de
protótipos para uma aplicação Desktop.
• Implementar eventos nos componentes gráficos para que se possa ter trocas de
mensagens entre eles.
Quando se fala em Interfaces Gráficas em Java, deve-se ter em mente dois

pacotes importantes: AWT (java.awt) e SWING (java.swing). Quando foi
desenvolvida a primeira plataforma de distribuição em Java, a SUN implementou o
pacote AWT para que os desenvolvedores pudessem realizar as interações gráficas
com os componentes conhecidos de ambientes gráficos de tal forma que só era
necessário ser compilado em um determinado ambiente e poderia ser executado em
qualquer lugar.
Porém, esses componentes sofreram alguns erros, que eram diferentes para
cada plataforma a qual era executado, o que acabou inviabilizando, por um
determinado tempo, o projeto de uma programação com interface gráfica multi-
plataforma em Java.
Para ser resolvido o problema, foi liberado um novo pacote de interface gráfica
chamado SWING que possuía novos componentes e alguns outros revisados do
pacote AWT que assim, o objetivo foi atingido, pois estes componentes não são
sobrecarregados com as capacidades complexas da plataforma onde estão sendo
utilizados. Deve-se ter em mente que o pacote SWING não veio substituir o pacote
AWT, ele é uma camada disposta confortavelmente sobre o AWT (SILVA, 2004,
pág.32), sendo assim, em uma programação utilizando interface gráfica, será
necessário conhecer os componentes dos dois pacotes pois poderão ser úteis no
decorrer da programação.
2.1 - CLASSES ESSENCIAIS DO AWT

O pacote AWT possui algumas classes que não possuem uma outra
correspondente no pacote SWING, dentre eles, destaca-se: Component, Container,
Color, Dimension, e Font.
2.1.1 – Component
Esta classe representa as características comuns de todos os componentes
(SANTOS,2004, pág.330), Como é uma classe abstrata, não é realizada uma
instância direta, porém, como todos os componentes derivam dela, é
importante ter um conhecimento básico a seu respeito.
2.1.2 - Container
Esta classe representa um componente que poderá abrigar outros
componentes dentro de si, dentre eles, destacam-se as janelas e painéis que
serão vistos nas suas versões dentro do pacote SWING.
DICA
Para diferençar um componente que possui uma versão tanto no pacote
SWING quanto no pacote AWT, o do pacote SWING vem com a letra J na
frente do seu nome, como por exemplo, Panel é no pacote AWT e JPanel, no
pacote SWING.
2.1.3. – Color
A classe Color encapsula as cores no padrão RGB (vermelho, verde e azul),
informando um valor para cada parâmetro no seu método construtor.
Exemplo:
Color verde = new Color(0,255,0);
2.1.4 – Dimension
Enquanto a classe Color encapsula as cores do padrão RGB, a classe
Dimension encapsula as dimensões (largura e altura) de um objeto.
Exemplo:
Dimension tamanho = new Dimension(200,30);
2.1.5 - Font
A classe Font representa as características das fontes que são usadas para
interpretar textos de modo a poder ser visualizado (SANTOS, 2004, pág. 333).
Exemplo:
Font fonte = new Font(“Arial”, Font.BOLD, 14)
2.2 - COMPONENTES
2.2.1. - Janelas
A janela mais comum utilizada deriva da classe JFrame. Um componente
JFrame é um contêiner estendido da casse Frame do pacote AWT e a adição de um
componente neste contêiner é feita da seguinte forma:
JFrame frame = new JFrame();

Frame.getContentPane().add(<nome do componente>);
Exemplo: O código abaixo realiza a construção de uma Janela:
1 import java.awt.Color;
2 import java.awt.Dimension;
3 import javax.swing.JFrame;
4
5 public class Janela extends JFrame
6 {
7 public Janela(String titulo, Dimension tamanho)
8 {
9 setTitle(titulo);
10 setSize(tamanho);
11 getContentPane().setLayout(null);
12 getContentPane().setBackground(new Color(200,220,200));
13 }
14 public static void main(String[] args)
15 {
16 Janela janela = new Janela("IFPA - Instituto Federal de Ensino, CIência e
17 Tecnologia",new Dimension(400,200));
18 janela.show();
19 }
20 }
Entre as linhas 7 e 13 foram definidos os parâmetros para a construção da

janela utilizando alguns métodos, dentre eles setTitle() (ajuste do título da Janela),
setSize() (ajuste da dimensão da janela), setLayout(null) (ajuste do layout, que será
visto mais tarde no item gerenciadores de layout), setBackGround(new
Color(200,220,200)) que ajusta a cor de fundo da janela. Outro ponto importante é
que esta classe é uma sub-classe da classe JFrame, como pode ser visto na linha 5.
Resultado final está na fig. 12.
Fig 1 - Exemplo da Construção de uma Janela
2.2.1.1. – Gerenciadores de Layout

Para realizar o posicionamento de um elemento em uma Janela pode ser
utilizado os métodos setSize(), setLocation() e setBounds() que através de
coordenadas x e y posiciona com uma precisão manual. Todavia, existem recursos
que aplicam um conjunto de regras predefinidas, determinando o tamanho e a
posição de cada componente em um contêiner (SANTOS, 2004, pág. 367). Estes
recursos chamam-se gerenciadores de layout. Dentre os gerenciadores de layout,
destacam-se:
a) Layout de Fluxo
A classe FlowLayout representa o layout que alinha os componentes da
esquerda para a direita e de cima para baixo, como um texto em parágrafo. Ele se
faz presente no pacote Java.awt. FlowLayout (Fig.13).
Fig 2 - Estilo de Layout FlowLayout
b) Layout de Bordas
A classe BorderLayout posiciona os componentes em cinco regiões no
contêiner, são elas:
BorderLayout.NORTH: Posiciona na parte superior do contêiner;

BorderLayout.SOUTH: Posiciona na parte inferior do contêiner;
BorderLayout.EAST: Posiciona na região à direita;
BorderLayout.WEST: Posiciona n região à esquerda;
BorderLayout.CENTER: Posiciona na região central.
Esta classe se encontra no pacote Java.awt.BorderLayout e a sua divisão se dá

como se pode ver na fig.14.
Fig 3 - Divisão do Layout través do Border Layout

c) Layout de Grade
Neste tipo de layout, o contêiner é dividido em células retangulares de
tamanhos iguais e cada componente irá ocupar uma célula diferente (Fig.15). Este
layout é representado pela classe GridLayout, do pacote Java.awt.GridLayout.
Fig 4 - Ajuste dos componentes de acordo com o GridLayout
d) Layout de Ficha
Um Gerenciador de Layout de fichas trata cada componente que pertence ao
contêiner como uma ficha ou um cartão (SANTOS, 2004, pág.373). O Contêiner age
como uma pilha de fichas, exibindo o primeiro componente que foi adicionado na
primeira vez que a janela for exibida.
O representante desse layout é a classe CardLayout que está presente no
pacote Java.awt.CardLayout.
e) Layout Flexível
Existe um layout que deixa bem flexível o posicionamento dos componentes,
permitindo que estes sejam posicionados de forma horizontal e vertical sem que seja
necessário que estejam com o mesmo tamanho. O representante desse layout é o
GridBagLayout, que se encontra na classe java.awt.GridBagLayout.
Pode-se trabalhar com o contêiner sem um layout definido, como foi feito na
linha 11 do código anterior, porém isso pode acarretar problemas na portabilidade
das janelas, já que os componentes dimensionados e posicionados com valores
absolutos podem ter diferentes comportamentos para cada plataforma.
2.2.2 - Rótulos
Para ser adicionado um texto curto, uma imagem ou ambos, utiliza-se um
rótulo que deriva da classe javax.swing.JLabel que por sua vez, deriva da classe
javax.swing.JComponent.
O rótulo por exibir uma linha de texto, normalmente o seu conteúdo não é
modificado.
JLabel l1 = new JLabel();

l1.setText(“Universidade da Amazõnia”);
l1.setSize(370,50);
l1.setBackground(new Color(0,255,0));
Exemplo na aplicação:
3 import java.awt.Font;
5 import javax.swing.JLabel;
6
8 {
10 {
11 JLabel L1 = new JLabel();
13
14 L1.setText("Nome do Usuário:");
15 L1.setLocation(10,10);
16 L1.setFont( new Font("Arial",Font.BOLD,21));
17 L1.setForeground(new Color(0,0,170));
18 L1.setSize(370,50);
19
20 L2.setText("Senha:");
24 L2.setSize(370,50);
25
26 setTitle(titulo);
30
31 getContentPane().add(L1);
33 }
34
35
37 {
38
41 janela.show();
42
43 }
44 }
45
46 }
Nas linhas 11 e 12 foram instanciados dois objetos de Rótulo L1 e L2, que

tiveram os ajustes em seus atributos entre as linhas 14 e 24 e foram adicionados ao
contêiner da Janela nas linhas 31 e 32. Resultado pode ser visto na fig. 16.
Fig 5 - Janela com o JLabel
2.2.3 – Botões
Um botão é um componente que pode ser pressionado pelo usuario

(SANTOS,2004, pág.350) e n pacote swing, tem-se o seu representante a classe
JButton.
JButton b1 = new JButton();

b1.setText(“Confirmar”);
b1.setBounds(50,30,100,30);
b1.setBackground(new Color(0,0,170));
b1.setIcon(new ImageIcon(“Confirmar.gif”));
Alguns métodos da classe JButton podem ser vistos no Quadro 2.
Quadro 1 - Métodos da classe JButton

setText() Define o texto
setBackground() Define a cor de fundo
setBounds() Define o tamanho e a posição do
contêiner
setForeground() Define a cor do texto.
setFont() Define o tipo, o estilo e o tamanho da
fonte
setToolTipText() Define uma dica
setIcon() Define um ícone para o botão
setHorizontalAlignment() Define o alinhamento horizontal do
conteúdo
setVerticalAlignment() Define o alinhamento vertical do
conteúdo
Exemplo na Aplicação:
4 import javax.swing.JButton;
7
9 {
11 {
14
15 JButton B1 = new JButton();
17
22 L1.setSize(370,50);
23
28 L2.setSize(370,50);
29
30 B1.setText("Entrar");
1 B1.setBounds(50,120,100,30);
2 B1.setBackground(new Color(150,150,150));
3 B1.setForeground(Color.WHITE);
4
5 B2.setText("Sair");
6 B2.setBounds(250,120,100,30);
9
10
15
18 getContentPane().add(B1);
20
21 }
22
24 {
25
28 janela.show();
29 }
30
31 }
O Resultado pode ser visto na Fig. 17.
Fig 6- Uma janela com Botões e Rótulos
2.2.4. – Painéis
Servem para dividir a janela, possibilitando assim maior controle da
organização de interfaces gráficas mais complexas e, juntamente com o gerenciador
de layout, auxiliam no posicionamento dos componentes. A classe mais utilizada na
construção do Panel é a classe JPanel do pacote swing.
JPanel p1 = new JPanel();

p1.setLayout(null);
p1.setBounds(10,10,170,70);
p1.setBackground(Color.green);
Para adicionar um elemento:
p1.add(<componente1>);
p1.add(<componente2>);
2.2.5 – Campos de Texto.
Para a entrada de Texto, é comum ser utilizada a classe JTextField do pacote

javax.swing.JTextField e que deriva da classe JTextComponent. Tem-se o código
abaixo:
4 import java.awt.GridLayout;
8 import javax.swing.JTextField;
9
11 {
13 {
16
19
20 JTextField T1 = new JTextField();
22
23 T1.setText("");
24 T1.setHorizontalAlignment(JTextField.CENTER);
25
26 T2.setDisabledTextColor(Color.red);
27 T2.setBackground(Color.WHITE);
28
33 L1.setSize(370,50);
34
39 L2.setSize(370,50);
40
42 B1.setBounds(50,120,100,30);
45
47 B2.setBounds(250,120,100,30);
50
51
54 getContentPane().setLayout(new GridLayout(3,2,5,5));
56
58 getContentPane().add(T1);
63
64 }
65
67 {
70 janela.show();
71 }
72 }
Nas linhas 20 e 21 são instanciados dois objetos da classe JTextField que
terão os valores de seus atributos ajustados nas linhas 23 a 27. Estes componentes
são adicionados no contêiner nas linhas 58 e 60.
REFLEXÂO
Este código está utilizando um gerenciador de layout do formato de
GridLayout (linha 54), dividindo em 4 espaços. Analise a razão dos elementos serem
adicionados na seqüência que ficarão na janela (linhas 57 a 62).
Resultado do código acima:
Fig 7 - Janela com um Layout e com JTextFields
2.2.6 – CAMPOS DE SENHA
Para se tenha uma caixa de entrada ocultando a informação que é digitada,

deve-se utilizar o componente JPasswordField que tem compatibilidde com o
componente JTextField. Para escolher o símbolo que irá ocultar a mensagem,
utiliza-se o método serEchoChar(). Exemplo da utilização do JPasswordField na
Janela acima:
8 import javax.swing.JPasswordField;
9 import javax.swing.JTextField;
10
12 {
14 {
17
20
22 JPasswordField T2 = new JPasswordField();
23
24 T1.setText("");
26
27
30 T2.setEchoChar('&');
31
36 L1.setSize(370,50);
37
42 L2.setSize(370,50);
43
45 B1.setBounds(50,120,100,30);
48
50 B2.setBounds(250,120,100,30);
53
58
65 }
66
68 {
69
72 janela.show();
73 }
74 }
O Resultado deste código pode ser visto na fig.19.
Fig 8 - Janela com JPsswordField
2.2.7 – ÁREA DE TEXTO

Quando é necessário capturar um texto com múltiplas linhas, pode-se utilizar
um componente chamado JTextArea, que, por possuir a mesma superclasse das
classes JTextField e JPasswordField, algumas de suas características são comuns a
estas duas classes.
Exemplo da utilização da área de Texto:
5 import javax.swing.*;
6
7 public class Janela2 extends JFrame
8 {
9 public Janela2(String titulo, Dimension tamanho)
10 {
12 JTextArea A1 = new JTextArea();
14
15 L1.setText("Deixe a sua opinião aqui sobre o guia de Programação II:");
19 L1.setSize(600,50);
20
21 A1.setBackground(Color.WHITE);
22 A1.setBounds(10,70,570,100);
23
24 B1.setText("Enviar");
25 B1.setBounds(250,180,100,30);
28
33
35 getContentPane().add(A1);
37 }
38
40 {
41 Janela2 janela = new Janela2("IFPA - Instituto Federal de Ensino, CIência e
43 janela.show();
44 }
45
46 }
Na Fig.20, tem-se o resultado do código acima.

Fig 9 - Janela com um JTextArea
2.2.8 – BARRAS DE ROLAGEM
Para implementar uma barra de rolagem comum, deve-se utilizar o

componente JScrollBar que facilita a exibição do conteúdo de uma janela.
1 import java.awt.BorderLayout;
5
7 {
9 {
10 JScrollBar S1 = new JScrollBar(JScrollBar.HORIZONTAL,0,0,0,300);
11 JScrollBar S2 = new JScrollBar(JScrollBar.VERTICAL,0,0,0,150);
12
15 getContentPane().setLayout(new BorderLayout());
17
18 getContentPane().add(S1,BorderLayout.SOUTH);
19 getContentPane().add(S2,BorderLayout.EAST);
20
21 }
22
24 {
27 janela.show();
28 }
29
30 }
O Resultado do código anterior, na Fig.21.
Fig 10 - Janela com o JScrollBar
2.2.9 – PAINÈIS DE ROLAGEM

Os painéis de rolagem servem para que se possa ser visualizado o conteúdo
de um componente de texto, adicionando-o a ele. O represente desse componente é
o JScrollPane, da classe javax.swing.JScrollPane. O Código Abaixo irá gerar um
componente JTextArea com um Painel de Rolagem:
5
7 {
9 {
10 JTextArea A1 = new JTextArea();
11 JScrollPane P1 = new
12 JScrollPane(A1,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.H
13 ORIZONTAL_SCROLLBAR_ALWAYS);
14
19 getContentPane().add(P1);
20 }
22 {
25 janela.show();
26 }
27 }
O resultado estará na figura abaixo:
Fig 11 - Uma Janela com JTextArea
2.2.10 – CAIXA DE CHECAGEM
São Componentes que podem ser marcados ou desmarcados. A classe que

representa esse componente é a JCheckBox, do pacote Swing.Um Exemplo da
caixa de checagem:
2 import java.awt.*;
3
5 {
7 {
9 JCheckBox C1 = new JCheckBox();
10 JCheckBox C2 = new JCheckBox();
11
12 L1.setText("Informe a sua Esolha:");
13 L1.setBounds(0,0,300,30);
14 L1.setFont(new Font("Arial",Font.BOLD,14));
15
16 C1.setText("Já sei programar de forma Orientada a Objetos");
17 C1.setSelected(true);
18 C1.setBounds(20,40,550,40);
19 C1.setFont(new Font("Arial",Font.BOLD,14));
20
21 C2.setText("Ainda Não sei Programar de forma Orientada a Objetos");
22 C2.setSelected(false);
23 C2.setBounds(20,80,550,40);
24 C2.setFont(new Font("Arial",Font.BOLD,14));
25
31 getContentPane().add(C1);
33 }
35 {
38 janela.show();
39 }
40
41 }
Resultado do código acima (Fig.23)
Fig 12 - Caixa de Checagem em uma Janela
DICA
Para informar se a caixa de checagem está ou não marcada, utiliza-se o método
setSelected(), como nas linhas 17 e 22.
2.2.11 – BOTÕES DE RADIO
São componentes semelhantes a caixa de checagem e que são
representados pela classe JRadioButton. A diferença entre a caixa de checagem e
os botões de radio é que estes podem trabalhar em conjunto com uma outra classe,
a ButtonGroup, que impede que mais de um item sejam selecionados ao mesmo
tempo. Tem-se o exemplo abaixo:
3
5 {
7 {
9 JRadioButton R1 = new JRadioButton();
10 JRadioButton R2 = new JRadioButton();
11
12 L1.setText("Informe a sua Esolha:");
13 L1.setBounds(0,0,300,30);
15
16 R1.setText("Já sei programar de forma Orientada a Objetos");
17 R1.setSelected(true);
18 R1.setBounds(20,40,550,40);
19 R1.setFont(new Font("Arial",Font.BOLD,14));
20
21 R2.setText("Ainda Não sei Programar de forma Orientada a Objetos");
22 R2.setSelected(false);
23 R2.setBounds(20,80,550,40);
24 R2.setFont(new Font("Arial",Font.BOLD,14));
25
26 ButtonGroup G1 = new ButtonGroup();
27 G1.add(R1);
28 G1.add(R2);
29
35 getContentPane().add(R1);
36 getContentPane().add(R2);
37 }
38
40 {
43 janela.show();
44 }
45 }
Entre as linhas 26 a 28 tem-se a declaração de um objeto ButtonGroup que

adiciona os componentes R1 e R2 e não permite que mais de um deles sejam
selecionados. O Resultado do código acima pode ser visto na figura 24.
Fig 13 - Botões de Radio
2.2.12 – CAIXAS DE COMBINAÇÃO

Em Java, a classe que representa uma caixa de combinação é a classe JComboBox,
que nada mais é que um componente que combina um botão com uma lista
suspensa. Exemplo de uma caixa de combinação:
3
5 {
6
8 {
9 String[] Disciplinas = {"Programação I", "Programação II", "Programação
10 III", "Programação IV"};
12 JComboBox C1 = new JComboBox(Disciplinas);
13
14 L1.setText("Disciplina preferida :");
15 L1.setBounds(0,0,300,30);
17
18 C1.setMaximumRowCount(5);
19 C1.setBounds(40,40,300,30);
20
27 }
28
30 {
33 janela.show();
34 }
35 }
O que foi adicionado ao componente foi um vetor de String, chamado

disciplina e foi utilizado o método setMaximumRowCount() na linha 19 para informar
a qualtidade máxima de elementos que ele poderia exibir. O Resultado ser visto na
figura 25.
Fig 14 – Caixa de Combinação
2.2.13 – LISTA
As listas são componentes que permitem ao usuário escolher uma ou mais

opções predefinidas (SANTOS, 2004, pág.402). O representante em java de uma
lista é a classe JList, pertencente ao pacote javax.swing.JList. Exemplo da utilização
de uma Lista:
3
5 {
7 {
8 String[] Disciplinas = {"Programação I", "Programação II", "Programação
9 III", "Programação IV"};
11 JList LT1 = new JList(Disciplinas);
12
13 L1.setText("Disciplina preferida :");
14 L1.setBounds(0,0,300,30);
16
17 LT1.setBounds(40,40,300,70);
18
24 getContentPane().add(LT1);
25 }
26
28 {
31 janela.show();
32 }
33
34 }
O resultado será como pode ser visto na Fig. 26.
Fig 15 - Uma Janela com uma Lista

2.2.14 – MENU SUSPENSO
Para a construção de um menu suspenso, é necessário o estudar cinco
classes distintas: JMenuBar, JMenu, JMenuItem, JRadioButtonMenuItem e
JCheckBoxMenuItem.
Alguns pontos importantes:
a) A Barra de Menu é representada pela classe JMenuBar;

b) Os Menus são representados pela classe JMenu;
c) Cada item do menu é representado pela classe JMenuItem, que pode ter, além
de sua variação padrão, uma forma de Botão de adio (JRadioButtonMenuItem)
ou de uma caixa de checagem (JCheckBoxMenuItem).
Exemplo da Construção de um Menu:
3
5 {
7 {
8 JMenuBar barra = new JMenuBar();
9 JMenu M1 = new JMenu("Arquivo");
10 JMenu M2 = new JMenu("Editar");
11 JMenu M3 = new JMenu("Exibir");
12 JMenu M4 = new JMenu("Ferramentas");
13 JMenu M5 = new JMenu("Sobre");
14 JMenu M6 = new JMenu("Ajuda");
15 JMenuItem MI1 = new JMenuItem("Calculadora");
16 M4.add(MI1);
17 barra.add(M1);
18 barra.add(M2);
19 barra.add(M3);
20 barra.add(M4);
21 barra.add(M5);
22 barra.add(M6);
23
28 setJMenuBar(barra);
29 }
30
32 {
35 janela.show();
36 }
37 }
Percebe-se que para formar a hierarquia do menu, o objeto barra adiciona os

objetos Menus e os Itens de Menus são adicionados aos Menus. O Resultado está
na figura 27.
Fig 16 - Menu Suspenso
DICA
Na Linha 28, como o objeto estende de um JFrame, basta ajustar o
setJMenubar() com o parâmetro do componente de menu que ele irá possuir.
2.2.15 – GRADE
Toda vez que se é necessário trabalhar com uma estrutura de dados na forma de
linha e coluna, tem-se que trabalhar com uma Grade, que, em Java, é representada
pela classe JTable, do pacote javax.swing.JTable.
Exemplo de uma grade em Java:
3
5 {
7 {
8 String[] cabeca = {"Disciplina","Nota"};
9 Object[][] itens = {{"Matemática II","9,0"},
10 {"Aplicações em MicroInformática","10,0"},
11 {"Engenharia de Software I","8,0"},
12 {"Programação II","7,0"},
13 {"Rede de Computadores","6,5"},
14 {"Atividades Complementares","10,0"}};
15
16 JTable tabela = new JTable(itens,cabeca);
17 tabela.setBounds(0,0,350,100);
18 tabela.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
19 tabela.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
20 tabela.setCursor(new Cursor(Cursor.HAND_CURSOR));
21
22 JScrollPane P1 = new JScrollPane(tabela);
23
28 getContentPane().add(P1);
29 }
30
32 {
35 janela.show();
36 }
37 }
Para instanciar um objeto do tipo JTable, é necessário que sejam passados dois
parâmetros, um para o título e outro para os itens, que é um vetor bidimensional.
Todavia, não se deve esquecer de associar a grade a um Painel móvel, como foi
feito na linha 22. Resultado do código acima está na figura 28.
Fig 17 - Grade em uma Janela
2.3 - EVENTOS
Para que exista a manipulação dos objetos e que eles possam reagir às
ações do usuário, deverá ocorrer um disparo para cada ação, que serão
representados pelos eventos. Uma das formas de declarar um evento é implementar
os métodos da interface ActionListener que ouve os eventos de ação e pode ser
registrada com a maioria dos componentes do aplicativo (SILVA, 2004, pág.60).
3 import java.awt.event.*;
4
6 {
7
9 JPasswordField T2 = new JPasswordField();
10
12 {
15
18
19 T1.setText("");
21
22
25 T2.setEchoChar('&');
26
31 L1.setSize(370,50);
32
37 L2.setSize(370,50);
38
40 B1.setBounds(50,120,100,30);
43
44 B1.addActionListener(new ActionListener()
45 {
46 public void actionPerformed(ActionEvent e)
47 {
48 if ((T1.getText().trim().equals("unama")) &&
49 (T2.getText().trim().equals("senha")))
50 JOptionPane.showMessageDialog(null, "Usuário e senhas
51 válidos");
52 else JOptionPane.showMessageDialog(null,"usuário e senhas
53 inválidos");
54 }
55 });
56
58 B2.setBounds(250,120,100,30);
61
62 B2.addActionListener(new ActionListener()
63 {
64 public void actionPerformed(ActionEvent e)
65 {
66 dispose();
67 }
68 });
69
74
81
82 }
83
85 {
86
89 janela.show();
90 }
91
92 }
Entre as linhas 44 e 55 foi adicionado ao botão B1 um evento para
realizar a validação do usuário e senha que neste formulário será inserido.
Para isso, dentro da ação addActionListener() foi instanciado um novo objeto
ActionListener onde é possível alterar o seu método actionPerformed() que irá
implementar a reação ao estimulo que o objeto sofreu. Com a adição de
eventos, as janelas começam a ganhar vida e assim um sistema poderá ser
implementado.
2.4. – PROGRAMAÇÃO COM INTERFACE GRÁFICA UTILIZANDO O

NETBEANS 5.0.
Nesta seção será desenvolvido um tutorial de como trabalhar com a

programação de interface gráfica utilizando a IDE NetBeans.
1 º Passo:
Ao iniciar um projeto, o NetBeans permite que seja crida uma classe já
com a extensão com a classe JFrame e ainda disponibiliza os componentes
citados anteriormente na seção 2.2 de forma visual, como se pode ver na
figuras:
Opção de JFrame Form
Fig 18 - a Opção de JFrame Form no NetBeans 5.0

Alterner Código / Design
Componentes
Área de Design da Janela
Janela da Hierarquia Atributos dos Componentes

dos Objetos na Janela
Fig 19 - Região onde é permitido realizar o design das Janelas
2º Passo:
Sempre é bom ajustar logo o Layout da Janela de acordo com o
Gerenciador escolhido, que poderá ser feito clicando com o botão inverso do
mouse em cima do JFrame e escolher a opção set Layout, como mostra a Fig
31.
Fig 20 - Escolha do Layout da Janela
3º Passo:
Dependendo do Layout escolhido, o desenvolvedor poderá implementar
a interface gráfica que desejar, dispondo os componentes na região destinada
ao design,como mostra a Fig. 32.
Fig 21 - Janela desenhada

4º Passo:
Para adicionar um evento a um objeto, basta clicar com o botão inverso
do mouse nele e escolher a opção Events, como na fig.33, e assim é possivel
declarar algum tipo de evento.
Fig 22 - Escolha de um evento para um objeto
DICA
Para verificar o código da classe, basta clicar na opção Source, que o
NetBeans irá exibir e permitir que seja editado.
SÍNTESE DA UNIDADE
A criação de componentes gráficos em Java é um misto entre os

pacotes AWT e SWING, sendo que o segundo possui versões mais atualizadas
de alguns componentes do primeiro. Os contêineres são de fundamental
importância para a classe já que sem estes componentes, não é possível
armazenar os componentes gráficos na forma de botões, rótulos, de seleção
entre outros, e, de acordo com a escolha do Layout do contêiner, os
componentes poderão ter uma forma diferente de posicionamento. Os eventos
são agregados aos componentes e têm a função de permitir que aja troca de
mensagens entre eles.

Componentes GUI - JAVA

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Componentes GUI - JAVA

Transféré par

Droits d'auteur :

Formats disponibles

UNIDADE II – PROGRAMAÇÃO UTILIZANDO AMBIENTE VIRTUAL EM JAVA

Quando se fala em Interfaces Gráficas em Java, deve-se ter em mente dois

2.1 - CLASSES ESSENCIAIS DO AWT

JFrame frame = new JFrame();

Exemplo: O código abaixo realiza a construção de uma Janela:

Entre as linhas 7 e 13 foram definidos os parâmetros para a construção da

Fig 1 - Exemplo da Construção de uma Janela

2.2.1.1. – Gerenciadores de Layout

Fig 2 - Estilo de Layout FlowLayout

BorderLayout.NORTH: Posiciona na parte superior do contêiner;

Esta classe se encontra no pacote Java.awt.BorderLayout e a sua divisão se dá

Fig 3 - Divisão do Layout través do Border Layout

Fig 4 - Ajuste dos componentes de acordo com o GridLayout

JLabel l1 = new JLabel();

Nas linhas 11 e 12 foram instanciados dois objetos de Rótulo L1 e L2, que

Fig 5 - Janela com o JLabel

Um botão é um componente que pode ser pressionado pelo usuario

JButton b1 = new JButton();

Quadro 1 - Métodos da classe JButton

O Resultado pode ser visto na Fig. 17.

Fig 6- Uma janela com Botões e Rótulos

JPanel p1 = new JPanel();

Para adicionar um elemento:

2.2.5 – Campos de Texto.

Para a entrada de Texto, é comum ser utilizada a classe JTextField do pacote

Resultado do código acima:

Fig 7 - Janela com um Layout e com JTextFields

2.2.6 – CAMPOS DE SENHA

Para se tenha uma caixa de entrada ocultando a informação que é digitada,

O Resultado deste código pode ser visto na fig.19.

Fig 8 - Janela com JPsswordField

2.2.7 – ÁREA DE TEXTO

Exemplo da utilização da área de Texto:

Na Fig.20, tem-se o resultado do código acima.

2.2.8 – BARRAS DE ROLAGEM

Para implementar uma barra de rolagem comum, deve-se utilizar o

O Resultado do código anterior, na Fig.21.

Fig 10 - Janela com o JScrollBar

2.2.9 – PAINÈIS DE ROLAGEM

O resultado estará na figura abaixo:

Fig 11 - Uma Janela com JTextArea

2.2.10 – CAIXA DE CHECAGEM

São Componentes que podem ser marcados ou desmarcados. A classe que

Resultado do código acima (Fig.23)

Fig 12 - Caixa de Checagem em uma Janela

Entre as linhas 26 a 28 tem-se a declaração de um objeto ButtonGroup que

Fig 13 - Botões de Radio

2.2.12 – CAIXAS DE COMBINAÇÃO

O que foi adicionado ao componente foi um vetor de String, chamado

Fig 14 – Caixa de Combinação

As listas são componentes que permitem ao usuário escolher uma ou mais

O resultado será como pode ser visto na Fig. 26.

Fig 15 - Uma Janela com uma Lista

Alguns pontos importantes:

a) A Barra de Menu é representada pela classe JMenuBar;

Exemplo da Construção de um Menu:

Percebe-se que para formar a hierarquia do menu, o objeto barra adiciona os

Fig 16 - Menu Suspenso

Exemplo de uma grade em Java:

2.4. – PROGRAMAÇÃO COM INTERFACE GRÁFICA UTILIZANDO O

Nesta seção será desenvolvido um tutorial de como trabalhar com a

Fig 18 - a Opção de JFrame Form no NetBeans 5.0

Área de Design da Janela

Janela da Hierarquia Atributos dos Componentes