Interface Gráfica em JAVA

Alunos
Gustavo de Almeida Neves
Rafael Santos Leite
Tarcísio Santos

Professor
Eduardo Manuel de Freitas Jorge


Interface Gráfica de JAVA
Para que o usuário possa interagir com a aplicação é necessário que haja uma interface para que este acione as funcionalidades do programa. JAVA fornece classes que são utilizadas para construir interfaces gráficas com usuário que ajudam na interação deste com a máquina e deixam os programas mais robustos e elegantes.
Essas classes encontram-se agrupadas em dois grandes pacotes: java.awt e javax.swing, onde encontramos classes de janelas, botões, menus, painéis, botões de opções, entre outros componentes, que podem ser estendidos e utilizados em nossas aplicações.
Neste tutorial será discutido alguns dos componentes mais importantes do pacote javax.swing, além dos layouts utilizados e de como é feito o tratamento de evento. Os itens abordados neste tutorial são descritos abaixos:

• JFrame
• JPanel
• JLabel
• JButton
• JTextField
• JTextArea
• JScrollPane
• JCheckBox
• JCheckBox
• JComboBox
• JList
• JTable
• JToolBar
• JMenuItem, JMenu e JMenuBar
• JDialog, JInternalFrame e JDesktopPane
• JOptionPane: showMessageDialog e showConfirmDialog
• Layouts: FlowLayout, GridLayout, BorderLayout e GridBagLayout
• Tratamento de Eventos

Para melhor compreensão do conteúdo, este tutorial apresentará dois experimentos práticos. No primeiro experimento serão utilizados os componentes básicos do pacote javax.swing, e no segundo será montada uma interface de uma aplicação desktop simples, que implementa uma agenda, e neste experimento será posto em prática os conceitos visto neste tutorial.

Definindo uma janela

Definição de uma janela é dada através da classe JFrame, que serve como container para outros componentes, como botões, imagens ou painéis.
O JFrame possui atributos que definem uma janela, como barra de título e borda.
O código abaixo cria um objeto do tipo JFrame.

Exemplo 1: Instanciando um JFrame.

import javax.swing.*;

public class JanelaJFrame {
public static void main(String[] args){

instancia um objeto do tip o JFrame
JFrame janela = new JFrame("Minha Primeira Janela");

/*setDefaultCloseOperation defini o que fazer quando
* a janela for fechada:
* EXIT_ON_CLOSE finaliza o aplicativo
* DISPOSE_ON_CLOSE devolve os recursos ao sistema
* HIDE_ON_CLOSE oculta a janela
* DO_NOTHING_ON_CLOSE usuário indica se a janela será fechada*/
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
janela.setSize(800,600);
define o tamanho da janela
janela.setVisible(true);//exibe a janela
}
}

Definindo um container

Para acrescentar componentes em uma janela é necessário um container. O container mais simples é o JPanel.

Exemplo 2: Utilizando o JPanel.


public class JanelaJFrame extends JFrame {

public janelaJFrame(){
JPanel pane = new JPanel();

this.setContentPane(pane); //define um container para o JFrame
this.setSize(800, 600);
this.setVisible(true);
}
public static void main(String[] args){
JFrame janela = new JFrame("Minha Primeira Janela");
}
}

Criando componentes

JLabel : Utilizado como rótulo para exibição de texto e ícones.

Exemplo 3: Montando uma interface com o JLabel.

import java.awt.*;
import javax.swing.*;
public class JanelaJFrame extends JFrame {
JLabel label1;
JLabel label2;
JLabel label3;
JLabel label4 = new JLabel("Rótulo 4", JLabel.CENTER);

public JanelaJFrame(){

label1 = new JLabel("Testando rótulos com JAVA"); texto no construtor

//texto com posição definida
label2 = new JLabel("Texto Centralizado", JLabel.CENTER);

/*getClass().getResource(arg) procura por um arquivo na pasta onde
* o aplicativo é chamado. Geralmente esse local é onde contém os
* arquivos .class que são os arquivo compilados para bytecode
* ImageIcon é um objeto que armazena uma imagem*/
ImageIcon img = new ImageIcon(this.getClass().getResource("JAVA.png"));

//texto com imagem
label3 = new JLabel("JAVA - Interface Gráfica", img, JLabel.RIGHT);

Container pane = this.getContentPane(); //captura o painel do JFrame
pane.setLayout(new GridLayout(4, 1));
define o layout do painel
pane.add(label1);
pane.add(label2);
pane.add(label3);
pane.add(label4);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(300, 200);
this.setVisible(true);
}

public static void main(String[] args){
JanelaJFrame janela = new JanelaJFrame();
}
}

2559339010_3823961801.jpg

Figura 1: funcionamento do JLabel

JButton: Componente que representa um botão. Utilizado para executar comandos.

Exemplo 4: Utilizando o JButton.

import java.awt.*;
import javax.swing.*;

public class JanelaJFrame extends JFrame {
JButton button1 = new JButton("Abrir");
JButton button2 = new JButton("Novo");
JButton button3 = new JButton("Fechar");

public JanelaJFrame(){

Container pane = this.getContentPane(); //captura o painel do JFrame
pane.setLayout(new FlowLayout(FlowLayout.CENTER)); //define o layout

pane.add(button1);
pane.add(button2);
pane.add(button3);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(300, 150);
this.setVisible(true);
}

public static void main(String[] args){
JanelaJFrame janela = new JanelaJFrame();
}
}

2558515501_5b990621be.jpg

Figura 2: funcionamento do JButton

JTextField: Componente utilizado como campo de texto.

Exemplo 5: Instanciando e utilizando o JTextField.

impo

rt java.awt.*;
import javax.swing.*;

public class JanelaJFrame extends JFrame {

//caixa de texto com tamanho especificado
JTextField texto1 = new JTextField(10);
JTextField texto2 = new JTextField(25);

//caixa de texto com texto inicial
JTextField texto3 = new JTextField("ESCREVA SEU TEXTO AQUI!!", 30);


public JanelaJFrame(){

Container pane = this.getContentPane(); //captura o painel do JFrame
pane.setLayout(new FlowLayout(FlowLayout.LEFT)); //define o layout

pane.add(texto1);
pane.add(texto2);
pane.add(texto3);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(360, 150);
this.setVisible(true);
}

public static void main(String[] args){
JanelaJFrame janela = new JanelaJFrame();
}
}

2559339094_5cb13a8e0a.jpg

Figura 3: utilização do JTextField

JTextArea: Campos de texto que podem possuir mais de uma linha.

Exemplo 6: Utilização do JTextArea.

import java.awt.*;
import javax.swing.*;

public class JanelaJFrame extends JFrame {

//define o número de linhas e o número de colunas do JTextArea
JTextArea texto1 = new JTextArea(5, 30);

//coloca um texto inicial
JTextArea texto2 = new JTextArea("Comentários", 10, 30);


public JanelaJFrame(){

Container pane = this.getContentPane(); //captura o painel do JFrame
pane.setLayout(new FlowLayout(FlowLayout.CENTER)); //define o layout

pane.add(texto1);
pane.add(texto2);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(360, 320);
this.setVisible(true);
}

public static void main(String[] args){
JanelaJFrame janela = new JanelaJFrame();
}
}

2559339184_3dd18a6e6b.jpg

Figura 4: criando interfaces com o JTextArea

JScrollPane: São painéis de rolagem que permitem que os componentes exibam mais conteúdo do que o espaço ocupado.
Exemplo 8: Mostrando o funcionamento do JScrollPane.

import java.awt.*;
import javax.swing.*;

public class JanelaJFrame extends JFrame {

//define o número de linhas e o número de colunas do JTextArea
JTextArea texto1 = new JTextArea(15, 30);

//Painel de Rolagem
JScrollPane scrollpane = new JScrollPane(texto1);


public JanelaJFrame(){

Container pane = this.getContentPane(); //captura o painel do JFrame
pane.setLayout(new FlowLayout(FlowLayout.CENTER)); //define o layout

//quebra de linha automática
texto1.setLineWrap(true);


//define a política de utilização da barra de rolagem horizontal
scrollpane.setHorizontalScrollBarPolicy(
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);

//define a política de utilização da barra de rolagem vertical
scrollpane.setVerticalScrollBarPolicy(
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

pane.add(scrollpane);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(360, 320);
this.setVisible(true);
}

public static void main(String[] args){
JanelaJFrame janela = new JanelaJFrame();
}
}

2558515663_73d7b68eb0.jpg

Figura 5: utilizando o JScrollPane

Experimento prático 1:

Neste experimento será colocado em prática os conhecimentos adquiridos até o momento, mostrando de forma simples o projeto de uma interface gráfica utilizando os componentes básicos do pacote javax.swing.

import java.awt.*;
import javax.swing.*;

public class JFrameLog extends JFrame{
private JLabel labelNome;
private JLabel labelSenha;
private JLabel labelComent;
private JTextField textNome;
//Cria um campo de texto que exibe um caracter no lugar do texto digitado
//geralmente utilizado como campo de senha
private JPasswordField textSenha;
private JTextArea textComent;
private JButton buttonOk;
private JButton buttonCancelar;
private JScrollPane paneComent;

public JFrameLog(){

super("Exemplo prático - Interface Login");
//Rótulos
labelNome = new JLabel("Nome");
labelSenha = new JLabel("Senha");
labelComent = new JLabel("Comentário");
//Campos de Texto
textNome = new JTextField(25);
textSenha = new JPasswordField(25);
//define qual caracter será exibido
//no lugar do texto digitado
textSenha.setEchoChar('*');
textComent = new JTextArea(10, 25);
textComent.setLineWrap(true);
//Painel de rolagem
paneComent = new JScrollPane(textComent,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
//Botões
buttonOk = new JButton("OK");
buttonCancelar = new JButton("Cancelar");
//Captura painel do JFrame
Container pane = this.getContentPane();
//define o layout
pane.setLayout(new FlowLayout(FlowLayout.LEFT));
//adiciona componentes ao painel

pane.add(labelNome);
pane.add(textNome);
pane.add(labelSenha);
pane.add(textSenha);
pane.add(labelComent);
pane.add(paneComent);
pane.add(buttonOk);
pane.add(buttonCancelar);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 380);
this.setResizable(false); //não pode ter seu tamanho redefinido
this.setVisible(true);
}

public static void main(String[] args){
JFrameLog log = new JFrameLog();
}
}

2558515763_c068803bdc.jpg

Figura 6: Resultado obtido no experimento prático 1

JCheckBox: é um tipo de caixa de seleção.
Exemplo 9: Utilizando o JCheckBox.

import java.awt.*;
import javax.swing.*;

public class JFrameExemplo extends JFrame{
private JLabel label = new JLabel("Linguagem em que programo:");
private JCheckBox checkJava;
private JCheckBox checkCSharp;
private JCheckBox checkVB;

public JFrameExemplo(){

//O JCheckBox possui vários construtores:
//JCheckBox(String)define o texto
//JCheckBox(String, boolean) define o texto e o estado
//JCheckBox(Icon) define uma imagem
//JCheckBox(Icon, boolean) define uma imagem e o estado
//JCheckBox(String, Icon) define o texto e uma imagem
//JCheckBox(String, Icon, boolean) define o texto, imagem e o estado

checkJava = new JCheckBox("Java");
checkCSharp = new JCheckBox("CSharp");
checkVB = new JCheckBox("Visual Basic");

Container pane1 = this.getContentPane();
JPanel pane2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
JPanel pane3 = new JPanel(new FlowLayout(FlowLayout.CENTER));

pane1.setLayout(new GridLayout(2, 1));

pane2.add(label);
pane3.add(checkJava);
pane3.add(checkCSharp);
pane3.add(checkVB);

pane1.add(pane2);
pane1.add(pane3);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 120);
this.setResizable(false); //formulário não pode ter seu tamanho
//redefinido
this.setVisible(true);
}

public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2558515825_3a42c073bf.jpg

Figura 7: utilização do JCheckBox

JRadioButton: Tipo de caixa de opção.

Exemplo 10: Utilizando o JRadioButton.

import java.awt.*;
import javax.swing.*;

public class JFrameExemplo extends JFrame{
private JLabel label = new JLabel("Qual linguagem você tem mais conhecimento: ");

//JRadioButton possui os mesmos construtores de JCheckbox
private JRadioButton[] linguagem = new JRadioButton[3];

//o buttongroup agrupa componentes
//se o componentes possui o atributo Selected então
//apenas um componente dentro desse buttongroup poderá ter
//o estado Selected como verdadeiro

private ButtonGroup group = new ButtonGroup();

public JFrameExemplo(){

linguagem[0] = new JRadioButton("JAVA");
linguagem[1] = new JRadioButton("C#");
linguagem[2] = new JRadioButton("VB");

Container pane = this.getContentPane();

pane.setLayout(new GridLayout(4, 1));

pane.add(label);

for (int i = 0; i < linguagem.length; i++){
group.add(linguagem[i]);
pane.add(linguagem[i]);
}

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 200);
this.setResizable(false); //formulário não pode ter seu tamanho redefinido
this.setVisible(true);

}

public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2559339472_d612b13956.jpg

Figura 8: Interface com JRadioButton

JComboBox: É uma caixa de combinação que fornece uma lista drop-down que mostra as opções e permite a escolha de apenas um item.

Exemplo 11: Utilizando o JComboBox

import javax.swing.*;

public class JFrameExemplo extends JFrame{

private JLabel labelMes = new JLabel("Informe o Mês:");
private JLabel labelAno = new JLabel("Informe o Ano:");
/*JComboBox apresenta uma lista drop-down com as opções. O JComboBox pode ter seu texto editado ou não Quando ele não editado os únicos valores que ele aceita são os valores presentes na lista drop-down*/
private JComboBox comboMes = new JComboBox();
private JComboBox comboAno = new JComboBox();

public JFrameExemplo(){
super("Testando JComboBox");
Container pane1 = this.getContentPane();
pane1.setLayout(new GridLayout(2,1));

JPanel pane2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
JPanel pane3 = new JPanel(new FlowLayout(FlowLayout.LEFT));

comboMes.addItem("JANEIRO"); comboMes.addItem("FEVEIRO");
comboMes.addItem("MARÇO"); comboMes.addItem("ABRIL");
comboMes.addItem("MAIO"); comboMes.addItem("JUNHO");
comboMes.addItem("JULHO"); comboMes.addItem("AGOSTO");
comboMes.addItem("SETEMBRO"); comboMes.addItem("OUTUBRO");
comboMes.addItem("NOVEMBRO"); comboMes.addItem("DEZEMBRO");

for (int i = 1990; i <= 2020; i++) comboAno.addItem(i);
comboAno.setEditable(true); //O texto da caixa pode ser alterado

pane2.add(labelMes);
pane2.add(comboMes);
pane3.add(labelAno);
pane3.add(comboAno);
pane1.add(pane2);
pane1.add(pane3);

//o método getItemAt(int) retorna o valor do item através do índice
//o índice é igual ao de um array, onde o primeiro item é igual a 0
System.out.println(comboMes.getItemAt(6) + "/" +
comboAno.getItemAt(18));

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 120);
this.setResizable(false);
this.setVisible(true);

} public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2558515943_9919bdc0f4.jpg

Figura 9: Interface com o JComboBox

JList: Lista que agrupa itens que são selecionadas pelo usuário.

Exemplo 12: Utilizando o JList.

import java.awt.*;
import javax.swing.*;

public class JFrameExemplo extends JFrame{

//exemplo que cria um JList
private JList listEstados;
private JScrollPane scrollpane;

public JFrameExemplo(){
super("JList");

Container pane = this.getContentPane();

String[] estados = {"Amazonas", "Bahia", "Goiás",
"Rio de Janeiro", "Santa Catarina" ,
"São Paulo", "Sergipe", "Tocantins"};

//no construtor é passado um vetor com os itens
//que serão apresentados pelo JList
listEstados = new JList(estados);
scrollpane = new JScrollPane(listEstados);

pane.add(scrollpane);


this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 150);
this.setResizable(false); //formulário não pode ter seu tamanho redefinido
this.setVisible(true);

}

public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2558516015_56c9f22636.jpg

Figura 10: Interface com o JList

JTable: Tabela utilizada para exibir dados. Bastante utilizada para representar os dados de um banco de dados.

Exemplo 13: Utilizando o JTable.

import java.awt.*;
import javax.swing.*;

public class JFrameExemplo extends JFrame{

//define a tabela como tendo 3 colunas
String[] coluna = {"Nome", "Cidade", "Estado"};

//os dados que serão exibidos na tabela
//a tabela possuirá o cabeçalho e 4 linhas
String[][] dados = {{"Eduardo Jorge", "Salvador", "Bahia"},
{"Gustavo Neves", "Caetité", "Bahia"},
{"Tarcísio Araújo", "Mutuípe", "Bahia"},
{"Rafael", "Campinas", "São Paulo"}
};
//Passe os arrays como parâmetro no construtor
//e o JTable define o seu modelo de acordo o
//array de coluna e o de dados
private JTable listEstados = new JTable(dados, coluna);
private JScrollPane scrollpane = new JScrollPane(listEstados);

public JFrameExemplo(){
super("JTABLE");

this.getContentPane().add(scrollpane);


this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 150);
this.setVisible(true);

}

public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2558516093_cc5cf18263.jpg

Figura 11: Interface com o JTable

JToolBar: Container que serve para agrupar botões em uma orientações especifica. É conhecido como barra de ferramentas.

Exemplo 14: Utilizando o JToolBar.

import java.awt.*;
import javax.swing.*;

public class JFrameExemplo extends JFrame{

//toolbar
private JToolBar toolbar = new JToolBar();

public JFrameExemplo(){
super("TOOLBAR");

toolbar.add(new JButton("Abrir"));
toolbar.add(new JButton("Novo"));
toolbar.add(new JButton("Salvar"));
toolbar.add(new JButton("Fechar"));

Container pane = this.getContentPane();
//define como layout o layout de borda
pane.setLayout(new BorderLayout());

//adiciona o toolbar no topo
pane.add(BorderLayout.NORTH, toolbar);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 360);
this.setVisible(true);

}

public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2559339730_1a0157682d.jpg

Figura 12: Interface com o JToolBar

Criando Barra de Menus

Para criação de de barras de menus é necessário a utilização de 3 componentes que trabalham em conjunto.

JMenuItem: Um item de menu;

JMenu: Container representado através de um menu drop-down que server para agrupar outros JMenu e componentes como JMenuItem, separados entre outros;

JMenuBar: Container que agrupa um ou mais JMenu.

Exemplo 15: Utilizando o JMenuItem, JMenu e o JMenuBar.

import java.awt.*;
import javax.swing.*;

public class JFrameExemplo extends JFrame{

private JMenuItem menuItemAbrir = new JMenuItem("Abrir");
private JMenuItem menuItemNovo = new JMenuItem("Novo");
private JMenuItem menuItemSalvar = new JMenuItem("Salvar");
private JMenuItem menuItemFechar = new JMenuItem("Fechar");

private JMenuItem menuItemColar = new JMenuItem("Colar");
private JMenuItem menuItemCopiar = new JMenuItem("Copiar");
private JMenuItem menuItemRecortar = new JMenuItem("Recortar");

private JMenuItem menuItemSubstituir = new JMenuItem("Substituir");
private JMenuItem menuItemLocalizar = new JMenuItem("Localizar");

private JMenu menuArquivo = new JMenu("Arquivo");

private JMenu menuEditar = new JMenu("Editar");

private JMenuBar menuBar = new JMenuBar();

public JFrameExemplo(){
super("MENUS");

//adicona os JMenuItem no JMenu
menuArquivo.add(menuItemAbrir);
menuArquivo.add(menuItemNovo);
menuArquivo.add(menuItemSalvar);
menuArquivo.addSeparator();
menuArquivo.add(menuItemFechar);

menuEditar.add(menuItemColar);
menuEditar.add(menuItemCopiar);
menuEditar.add(menuItemRecortar);
menuEditar.addSeparator();
menuEditar.add(menuItemLocalizar);
menuEditar.add(menuItemSubstituir);

//adiciona o JMenu no JMenuBar
menuBar.add(menuArquivo);
menuBar.add(menuEditar);

this.setJMenuBar(menuBar); //atribui um JMenuBar para o frame
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(310, 200);
this.setVisible(true);
}

public static void main(String[] args){
JFrameExemplo exemplo = new JFrameExemplo();
}
}

2559339796_96061a77d7.jpg

Figura 13: Interface com barra de menus

JDialog e JInternalFrame

JDialog: utilizada na criação de caixa de diálogos mais elaboradas. Com ele podemos criar nossas próprias caixas de diálogo. Para tanto é necessário definir a propriedade setModal como true, fazendo com que o JDialog fique por cima das outras janelas do programa.

Exemplo 16: Utilizando o JDialog.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class JDialogExemplo extends JDialog{
public JDialogExemplo(String msg){
JLabel texto = new JLabel(msg);
JButton ok = new JButton("OK");
//adiconando um evento ao componente JButton
//os eventos serão explicados no decorrer do tutorial
ok.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
System.exit(0);
}
});
JPanel pane1 = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel pane2 = new JPanel(new FlowLayout(FlowLayout.CENTER));
pane1.add(texto);
pane2.add(ok);
this.getContentPane().setLayout(new GridLayout(2, 1));
this.getContentPane().add(pane1);
this.getContentPane().add(pane2);

}
public static void main(String[] args){
JDialogExemplo e = new JDialogExemplo("Testando o JDialog");
e.pack(); //define um tamanho que exiba todos os componentes na
e.setModal(true);
e.setResizable(false);
e.setVisible(true);
}
}

JInternalFrame: esta classe é utilizada na criação de interfaces de múltiplos documentos. Para isso é necessário utilizar em conjunto a classe JDesktopPane.
Adiciona-se os JInternalFrame no JDesktopPane, e o JDesktopPane é adicionado ao painel do JFrame pai.

2558516351_ed5d42f63e.jpg

Figura 15: Interface com JInternalFrame|

JOptionPane

showMessageDialog: Caixa de dialógo utilizada para exibir uma messagem para o usuário.

showConfirmDialog: Caixa de dialógio utilizada tanto para exibir uma messagem do usuário como para capturar uma resposta do usuário.

Exemplo 17: utilizando o JOptionPane.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TesteJOptionPane extends JFrame {
private JButton mensagem;
private JButton fechar;

public TesteJOptionPane(){
super("TESTE DE OptionPane");

mensagem = new JButton("Mensagem");
fechar = new JButton("Fechar");

Container pane = this.getContentPane();

pane.add(mensagem);
pane.add(fechar);

pane.setLayout(null);
// Seta na Janela (Posição X, Posição Y, Largura, Altura)

mensagem.setBounds(10, 30, 100,22);
fechar.setBounds(10, 60, 100, 22);


// Adiciona uma ação ao clicar no botão
mensagem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
buttonMensagemActionPerformed(e);
// chama o Método buttonMensagemActionPerformed.
}
});

fechar.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
buttonConfirmaActionPerformed(e);
}
});

// Aqui setaremos o Tamanho da Janela e visibilidade.
this.setSize(250, 210);
this.setContentPane(pane);
this.setVisible(true);
}

private void buttonMensagemActionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this, "ISSO EH UM TESTE",
"FUNCIONA!", JOptionPane.INFORMATION_MESSAGE);

/*Esse método é o responsável por mostrar uma Dialog
* ao clicar no botão MENSAGEM.

*
*/
}

private void buttonConfirmaActionPerformed(ActionEvent e){
int ret = JOptionPane.showConfirmDialog(this,
"Deseja Fechar?",
"Fechar",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);

if (ret == JOptionPane.OK_OPTION){
System.exit(0);
}
}

public static void main(String[] args) {
TesteJOptionPane p = new TesteJOptionPane();
}
}

2559499780_e119d4d3fa.jpg

Definindo Layouts

Para definir os layouts é necessário utilizar classes que são conhecidas como gerenciadores de layout. Esses gerenciadores definem a disposição dos componentes nos paineis.

FlowLayout: Layout de fluxo. Os componentes ficam na ordem em que foram inseridos, da esquerda para direita, e quando acabar o espaço na linha, passam para a próxima linha.
Com o FlowLayout, defini-se o alinha dos componentes, se é centralizado, alinha a esquerda, entre outros.
O FlowLayout foi bastante utilizado nos exemplos deste tutorial.

Exemplo 18: Utilizando FlowLayout.

import java.awt.*;
import javax.swing.*;

public class ExemploLayout {

public ExemploLayout(){
FlowLayout layout = new FlowLayout(FlowLayout.CENTER);

JPanel pane = new JPanel(layout);

pane.add(new JButton("Teste1"));
pane.add(new JButton("Teste2"));
pane.add(new JButton("Teste3"));
pane.add(new JButton("Teste4"));
pane.add(new JButton("Teste5"));
pane.add(new JButton("Teste6"));
pane.add(new JButton("Teste7"));
pane.add(new JButton("Teste8"));
pane.add(new JButton("Teste9"));

JFrame frame = new JFrame("Testanto Interface");

frame.setContentPane(pane);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 300);
frame.setVisible(true);
}

public static void main(String[] args){
ExemploLayout e = new ExemploLayout();
}

}

2558675005_0449dc5974.jpg
Figura 18: Layout do tipo FlowLayout

GridLayout: Arruma os componentes como uma tabela, com linhas e colunas. Os componentes são adicionados da esquerda para direita, de baixo para cima.

Exemplo 19: Utilizando GridLayout

import java.awt.*;
import javax.swing.*;

public class ExemploLayout {

public ExemploLayout(){
/*um GridLayout com 4 linha e 3 colunas
* o GridLayout também pode especificar o intervalo veritical
* e horizontal entre as células*/
GridLayout layout = new GridLayout(4, 3);

//instancia um objeto do JPanel
JPanel pane = new JPanel(layout);

pane.add(new Label("Col 1 Lin 1"));
pane.add(new Label("Col 2 Lin 1"));
pane.add(new Label("Col 3 Lin 1"));
pane.add(new Label("Col 4 Lin 1"));
pane.add(new Label("Col 1 Lin 2"));
pane.add(new Label("Col 2 Lin 2"));
pane.add(new Label("Col 3 Lin 2"));
pane.add(new Label("Col 4 Lin 2"));
pane.add(new Label("Col 1 Lin 3"));
pane.add(new Label("Col 2 Lin 3"));
pane.add(new Label("Col 3 Lin 3"));
pane.add(new Label("Col 4 Lin 3"));

JFrame frame = new JFrame("Testanto Interface");

frame.setContentPane(pane);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 300);
frame.setVisible(true);
}

public static void main(String[] args){
ExemploLayout e = new ExemploLayout();
}

}

2558675093_888137d8be.jpg

Figura 19: Layout do tipo GridLayout

BorderLayout: Gerenciador de Layout que divide o conteiner um 5 seções, norte, sul, leste, oeste, centro.

Exemplo 20: Utilizando o BorderLayout

import java.awt.*;
import javax.swing.*;

public class ExemploLayout {

public ExemploLayout(){

BorderLayout layout = new BorderLayout();

//instancia um objeto do JPanel
JPanel pane = new JPanel(layout);

/*quando o layout é do tipo border layout os componente
* são adicinados com a informação sobre sua localização no conteiner*/
pane.add(BorderLayout.CENTER, new JButton("Centro"));
pane.add(BorderLayout.NORTH, new JButton("Norte"));
pane.add(BorderLayout.SOUTH, new JButton("Sul"));
pane.add(BorderLayout.EAST, new JButton("Leste"));
pane.add(BorderLayout.WEST, new JButton("Weste"));

JFrame frame = new JFrame("Testanto Interface");

frame.setContentPane(pane);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 250);
frame.setVisible(true);
}

public static void main(String[] args){
ExemploLayout e = new ExemploLayout();
}
}

Figura 20: Layout do tipo BorderLayout

GridBagLayout: Este é um gerenciador de layout bastante complexo. O GridBagLayout é uma extensão do GridLayout, onde no GridBagLayout as linhas e as colunas podem ter tamanhos variados de acordo com a proporção definida. Para utilizar o GridBagLayout é bom que fazer um rascunho na mão de como será o layout do formulário.
O GridBagLayout é utilizado em conjunto com o GridBagConstraints, onde é definido o posicionamento, dimensão e alinhamento dos componentes no container.

Exemplo 21: Utilizando o GridBagLayout.

import java.awt.*;
import javax.swing.*;

public class ExemploLayout {

public ExemploLayout(){

GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints constraints = new GridBagConstraints();

JPanel pane = new JPanel();

pane.setLayout(gridbag);

setConstraints(constraints, 0, 0, 1, 1, 20, 100);
/*restrição fill para define para
* os comonentes que esticam qual direção eles vão esticar*/
constraints.fill = GridBagConstraints.NONE;
a restrição anchor diz onde colocar o componente dentro da célula
constraints.anchor = GridBagConstraints.WEST;
JLabel label1 = new JLabel("Nome");
/*define o posicionamento do componente no gridbag*/
gridbag.setConstraints(label1, constraints);
pane.add(label1);
adiciona o componente

setConstraints(constraints, 1, 0, 1, 1, 80, 100);
constraints.fill = GridBagConstraints.HORIZONTAL;
JTextField text1 = new JTextField();
gridbag.setConstraints(text1, constraints);
pane.add(text1);

setConstraints(constraints, 0, 1, 1, 1, 0, 100);
constraints.fill = GridBagConstraints.NONE;
constraints.anchor = GridBagConstraints.WEST;
JLabel label2 = new JLabel("Telefone");
gridbag.setConstraints(label2, constraints);
pane.add(label2);

setConstraints(constraints, 1, 1, 1, 1, 0, 100);
constraints.fill = GridBagConstraints.HORIZONTAL;
JTextField text2 = new JTextField();
gridbag.setConstraints(text2, constraints);
pane.add(text2);

setConstraints(constraints, 0, 2, 1, 1, 0, 100);
constraints.fill = GridBagConstraints.NONE;
constraints.anchor = GridBagConstraints.WEST;
JLabel label3 = new JLabel("E-mail");
gridbag.setConstraints(label3, constraints);
pane.add(label3);

setConstraints(constraints, 1, 2, 1, 1, 0, 100);
constraints.fill = GridBagConstraints.HORIZONTAL;
JTextField text3 = new JTextField();
gridbag.setConstraints(text3, constraints);
pane.add(text3);

JFrame frame = new JFrame("Testanto Interface");

frame.setContentPane(pane);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 250);
frame.setVisible(true);
}

/*função que recebe como parâmetro um gridbagconstraints
* e define o posicionamento dos componentes*/
private void setConstraints(GridBagConstraints gb, int gridx, int gridy,
int gridwidth, int gridheight,
int weightx, int weighty){

gb.gridx = gridx;coordenada horizontal célular
gb.gridy = gridy;
coordenada vertical célular
gb.gridwidth = gridwidth; //quantas colunas o componente vai ocupar
gb.gridheight = gridheight;
quantas linhas o componente vai ocupar
gb.weightx = weightx; //define a proporção da coluna
gb.weighty = weighty; //define a proporção da linha

}
public static void main(String[] args){
ExemploLayout e = new ExemploLayout();
}
}

2558675233_c5ea3a4abd.jpg

Figura 21: Layout do tipo GridBagLayout

Tratamentos de Eventos

No tratamento de eventos é necessário criar uma classe que implemente um conjunto de interfaces chamadas ouvintes de eventos. Depois de criar a classe ela tem que ser associada ao componente.

As seguintes interfaces podem ser implementadas para associação dos eventos:
ActionListener: Eventos de ação, como clique do botão.
AdjustmentListener: Eventos de ajuste, como o moviemento do botão da barra de rolagem.
FocusListener: Eventos de foco, gerado quando um componente ganha ou perde o foco.
ItemListener: Eventos de item, ocorre quando um item é alterado.
KeyListener: Eventos de teclado, ocorre quando há entrada de texto pelo teclado.
MouseListener: Eventos de mouse, gerado por cliques do mouse.
MouseMotionListener: Eventos de movimento do mouse.
WindowListener: Eventos de janela, gerados através de uma interação com a janela.

Exemplo 22: Forma de tratar eventos 1.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExemploEventos extends JFrame implements ActionListener{

private JButton buttonOk = new JButton("OK");
private JButton buttonCancelar = new JButton("Fechar");
/* Neste exemplo a própria classe implementa ActionListener
* Ela implementa o único método desta interface que é o ActionPerformed*/
public ExemploEventos(){

buttonOk.addActionListener(this);
buttonCancelar.addActionListener(this);

this.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
this.getContentPane().add(buttonOk);
this.getContentPane().add(buttonCancelar);

}

/*actionPerformed é método de ActionListener e responde a eventos
* de ação como um clique em um botão
* ActionEvent é uma classe que possue atributos e métodos
* para tratamento dos eventos em actionPerformed*/
public void actionPerformed(ActionEvent e){
if (e.getSource() == buttonOk)
JOptionPane.showMessageDialog(this,
"Você clicou em Ok!!!",
"Rafola", JOptionPane.INFORMATION_MESSAGE);

else if (e.getSource() == buttonCancelar)
System.exit(0);
}

public static void main(String[] args){
ExemploEventos exemplo = new ExemploEventos();

exemplo.setSize(200, 200);
exemplo.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
exemplo.setVisible(true);
}
}

Exemplo 23: Forma de tratar eventos 2.

/*neste exemplo criamos uma classe que implementa a interface ActionListener*/

public class ExitClass implements ActionListener{
public void actionPerformed(ActionEvent e){
System.exit(0);
}
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExemploEventos extends JFrame{

private JButton buttonCancelar = new JButton("Fechar");

public ExemploEventos(){

ExitClass eventExit = new ExitClass();

buttonCancelar.addActionListener(eventExit);

this.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
this.getContentPane().add(buttonCancelar);

}

public static void main(String[] args){
ExemploEventos exemplo = new ExemploEventos();

exemplo.setSize(100, 100);
exemplo.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
exemplo.setVisible(true);
}
}

** Exemplo 24: Forma de tratar eventos 3.**

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExemploEventos extends JFrame{

private JButton buttonCancelar = new JButton("Fechar");

public ExemploEventos(){

/*evento implementado na hora em que é vinculado ao componente*/
buttonCancelar.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
sairActionPerformed(e);
}
});

this.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
this.getContentPane().add(buttonCancelar);
}

public static void main(String[] args){
ExemploEventos exemplo = new ExemploEventos();

exemplo.setSize(100, 100);
exemplo.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
exemplo.setVisible(true);
}

public void sairActionPerformed(ActionEvent e){;
System.exit(0);
}
}

Experimento prático final

Com as definições e exemplos apresentados no decorrer deste tutorial, estamos preparados para desenvolver um projeto com uma interface gráfica mais elaborada. Neste experimento será desenvolvido uma pequena agenda, que tem como único objetivo colocar em prática os conceitos vistos no conteúdo deste tutorial.
Para implementação dessa agenda será utilizada duas classes auxiliares que formam a estrutura de dados que irá armazenar os dados de nossa agenda, uma classe do tipo JFrame que sevirá como MDI e será pai de uma classe JInternalFrame que irá possuir todas as funcionalidades da agenda.
Além disso iremos demonstrar como utilizar os estilos utilizando a classe LookAndFeel, que armazena o estilos, Metal de Java, Motif do Linux e o estilo do sistema operacional corrente.

Classe Auxiliar Agenda: possui uma coleção do tipo HashMap que é utilizada para armazenar os registros.

import java.util.*;

//classe auxiliar
public class Agenda {

private HashMap cPessoa = new HashMap();
private int novoCodigo = 1;

public void add(Pessoa p){
p.setCodigo(Integer.toString(novoCodigo));
this.cPessoa.put(p.getCodigo(), p);
novoCodigo+=1;
}

public boolean remove(Object codigo){
if (this.cPessoa.containsKey(codigo)){
this.cPessoa.remove(codigo);
return true;
}
else
return false;
}

public Pessoa getPessoa(String cod){
return (Pessoa)this.cPessoa.get(cod);
}

public ArrayList getList(){
return new ArrayList(cPessoa.values());
}
public String toString(){
String str = "";

Iterator it = this.cPessoa.values().iterator();


while (it.hasNext()){
Pessoa p = (Pessoa)it.next();
str += p.toString();
}

return str;
}
}

Classe Pessoa : possui atributos e métodos utilizados para representar um registro da agenda.

import java.util.*;

//classe auxiliar
public class Pessoa {

private String codigo;
private String nome;
private String telefone;
private String email;
private String endereco;

public static final Comparator ORDEM_CODIGO = new Comparator(){
public int compare(Object o1, Object o2){
Pessoa p1 = (Pessoa)o1;
Pessoa p2 = (Pessoa)o2;

return p1.getCodigo().compareTo(p2.getCodigo());
}
};

public Pessoa(String newNome, String newTelefone,
String newEmail, String newEndereco){
this.nome = newNome;
this.telefone = newTelefone;
this.email = newEmail;
this.endereco = newEndereco;
}

public String getCodigo() {
return codigo;
}

public void setCodigo(String newCodigo){
this.codigo = newCodigo;
}

public String getNome() {
return nome;
}

public String getTelefone() {
return telefone;
}

public String getEmail() {
return email;
}

public String getEndereco() {
return endereco;
}

public void setValores(String[] dados){
this.nome = dados[0];
this.telefone = dados[1];
this.email = dados[2];
this.endereco = dados[3];
}

public String toString(){
return "Nome: " + this.getNome() + "\n" +
"Telefone: " + this.getTelefone() + "\n" +
"E-mail: " + this.getEmail() + "\n" +
"Endereco: " + this.getEndereco() + "\n";
}
}

Classe FormCadAgenda: é uma interface para cadastrar e editar registros na agenda.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class FormCadAgenda extends JDialog{

//serão criados os componentes JLabel, JTEXT, e JButton do formulário
private JLabel labelNome = new JLabel("Nome:");;
private JLabel labelTelefone = new JLabel("Telefone:");;
private JLabel labelEmail = new JLabel("Email:");
private JLabel labelEndereco = new JLabel("Endereco:");

private JTextField textNome = new JTextField();
private JTextField textTelefone = new JTextField();
private JTextField textEmail = new JTextField();
private JTextField textEndereco = new JTextField();

private JButton buttonGravar;
private JButton buttonFechar;

private InterfaceAgenda pai;

private String codigo = "";

private boolean edicao = false; /*variável de teste que será entendita mais à frente*/
public FormCadAgenda(InterfaceAgenda newPai){
this.pai = newPai;
}
//Método construtor
public FormCadAgenda(InterfaceAgenda newPai, String codigo, String nome, String telefone,
String email, String endereco){
this(newPai);
this.edicao = true;
this.codigo = codigo;
this.textNome.setText(nome);
this.textTelefone.setText(telefone);
this.textEmail.setText(email);
this.textEndereco.setText(endereco);
}

void inicia(){ //este método é responsável por mostrar o formulário na agenda

this.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE); //oculta a janela ao fechar
buttonGravar = new JButton("Gravar");
buttonFechar = new JButton("Fechar");

Container pane = this.getContentPane(); cria Pane (container)

//neste exemplo o layout é nulo então a disposição
//dos componentes é definida atraves da propriedade setBounds
pane.setLayout(null);

//define posição do formulário(x,y) e altura e largura de cada component.
labelNome.setBounds(10, 10, 50, 20);
labelTelefone.setBounds(10, 41, 80, 20);
labelEmail.setBounds(10, 72, 50, 20);
labelEndereco.setBounds(10, 102, 80, 20);

textNome.setBounds(70, 10, 150, 20);
textTelefone.setBounds(70, 41, 70, 20);
textEmail.setBounds(70, 72, 150, 20);
textEndereco.setBounds(70, 102, 150, 20);

buttonGravar.setBounds(68, 140, 80, 22);
buttonFechar.setBounds(150, 140, 80, 22);

//este método define ação do botao gravar
buttonGravar.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
buttonGravarActionPerformed(e);
ao clicar, chama este método
}
});
//a mesma coisa do método anterior
buttonFechar.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
buttonFecharActionPerformed(e);
}
});
// iremos adicionar os compenentes no container
pane.add(labelNome);
pane.add(labelTelefone);
pane.add(labelEmail);
pane.add(labelEndereco);

pane.add(textNome);
pane.add(textTelefone);
pane.add(textEmail);
pane.add(textEndereco);

pane.add(buttonGravar);
pane.add(buttonFechar);


this.setBounds(40, 60, 250, 210); //seta o posicionamento
this.setContentPane(pane);
this.setVisible(true);
}
//definindo o evento do Botão Gravar
private void buttonGravarActionPerformed(ActionEvent e){
int resposta;
/*verifica se já é um arquivo novo pra inclusão ou apenas edição e um já cadastrado*/
if (edicao == false){
resposta = JOptionPane.showConfirmDialog(this,
"Incluir Registro?",
//sendo falso é porque é novo "Inclusão",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
if (resposta == JOptionPane.OK_OPTION){
//fazendo a inclusão do contato na agenda
Pessoa p = new Pessoa(textNome.getText(),
textTelefone.getText(),
textEmail.getText(),
textEndereco.getText());
Main.minhaAgenda.add(p);

JOptionPane.showMessageDialog(this,
"Inclusão efetuada!!!",
"Inclusão",
JOptionPane.INFORMATION_MESSAGE);

//adiciona uma linha nova de cadastro na tela pricipal da agenda
pai.addRow(new String[]{p.getCodigo(),
p.getNome(),
p.getTelefone(),
p.getEmail(),
p.getEndereco()});

this.dispose();
}
}
else{ //se edicao = true indica que é uma alteração.
resposta = JOptionPane.showConfirmDialog(this,
"Salvar Alterações",
"Edição",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);

if (resposta == JOptionPane.OK_OPTION){
Pessoa p = Main.minhaAgenda.getPessoa(codigo);

p.setValores(new String[]{textNome.getText(),
textTelefone.getText(),
textEmail.getText(),
textEndereco.getText()});

JOptionPane.showMessageDialog(this,
"Edição efetuada!!!",
"Edição",
JOptionPane.INFORMATION_MESSAGE);

pai.atualizaTabela(new String[]{p.getCodigo(),
p.getNome(),
p.getTelefone(),
p.getEmail(),
p.getEndereco()});

this.dispose();
}
}
}
//fecha a janela do formulário.
private void buttonFecharActionPerformed(ActionEvent e){
this.dispose();
}


}

Classe InterfaceAgenda: utilizada para exibir os registros cadastrado e permite que e apresenta os usuários botões para incluir, editar e excluir os registros.

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.event.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.*;

public class InterfaceAgenda extends JInternalFrame{
primeiramente criamos os componentes
private JTable tabela;

private JButton buttonNovo = new JButton("Novo");
private JButton buttonEditar = new JButton("Editar");
private JButton buttonRemover = new JButton("Remover");
private JButton buttonFechar = new JButton("Fechar");

private FormCadAgenda formCadAgenda; //objeto do tipo formulário criado
private static InterfaceAgenda INSTANCE = null;
//definindo o modelo da tabela
private DefaultTableModel modelo = new DefaultTableModel();
//Método que constrói a janela da agenda
public InterfaceAgenda(){
super("Agenda", true, true , false, true);
Container pane = this.getContentPane();
pane.setLayout(null);

//define posicionamento do botão na janela
buttonNovo.setBounds(5, 10, 90, 70);
buttonNovo.setHorizontalTextPosition(SwingConstants.CENTER);
buttonNovo.setVerticalAlignment(SwingConstants.TOP);
buttonNovo.setVerticalTextPosition(SwingConstants.BOTTOM);
buttonNovo.setIcon(new
ImageIcon(getClass().getResource("imagens/NOVO.png")));
buttonNovo.addActionListener(new ActionListener(){ //ao clicar…
public void actionPerformed(ActionEvent e){
buttonNovoActionPerformed(e); //chama esse método
}
});

//define posicionamento do botão na janela
buttonEditar.setBounds(95, 10, 90, 70);
buttonEditar.setHorizontalTextPosition(SwingConstants.CENTER);
buttonEditar.setVerticalAlignment(SwingConstants.TOP);
buttonEditar.setVerticalTextPosition(SwingConstants.BOTTOM);
buttonEditar.setIcon(new
ImageIcon(getClass().getResource("imagens/ALTERAR.png")));
buttonEditar.addActionListener(new ActionListener(){
ao clicar…
public void actionPerformed(ActionEvent e){
buttonEditarActionPerformed(e); chama esse método
}
});
//define posicionamento do botão na janela
buttonRemover.setBounds(185, 10, 90, 70);
buttonRemover.setHorizontalTextPosition(SwingConstants.CENTER);
buttonRemover.setVerticalAlignment(SwingConstants.TOP);
buttonRemover.setVerticalTextPosition(SwingConstants.BOTTOM);
buttonRemover.setIcon(new
ImageIcon(getClass().getResource("imagens/REMOVER.png")));
buttonRemover.addActionListener(new ActionListener(){
ao clicar…
public void actionPerformed(ActionEvent e){
buttonRemoverActionPerformed(e); chama esse método
}
});
//define posicionamento do botão na janela
buttonFechar.setBounds(280, 10, 90, 70);
buttonFechar.setHorizontalTextPosition(SwingConstants.CENTER);
buttonFechar.setVerticalAlignment(SwingConstants.TOP);
buttonFechar.setVerticalTextPosition(SwingConstants.BOTTOM);
buttonFechar.setIcon(new
ImageIcon(getClass().getResource("imagens/FECHAR.png")));
buttonFechar.addActionListener(new ActionListener(){
ao clicar…
public void actionPerformed(ActionEvent e){
buttonFecharActionPerformed(e); //chama esse método
}
});

this.addInternalFrameListener(new InternalFrameAdapter(){
public void internalFrameClosing(InternalFrameEvent e){
interfaceAgendaInternalFrameClosing(e);
}
});
//montagem da tabela
tabela = new JTable(modelo);

modelo.addColumn("Codigo");
modelo.addColumn("Nome");
modelo.addColumn("Telefone");
modelo.addColumn("E-mail");
modelo.addColumn("Endereço");

JScrollPane scrollpane = new JScrollPane(tabela);
scrollpane.setBounds(5, 95, 680, 390);

pane.add(buttonNovo);
pane.add(buttonEditar);
pane.add(buttonRemover);
pane.add(buttonFechar);
pane.add(scrollpane);

preencheTabela();

this.setResizable(false);
this.setSize(700, 550);
}
//evento do botão NOVO
private void buttonNovoActionPerformed(ActionEvent e){
formCadAgenda = new FormCadAgenda(this);
formCadAgenda.setModal(true);
formCadAgenda.inicia();
}
//evento do botão editar
private void buttonEditarActionPerformed(ActionEvent e){
// pega a linha selecionada
int linha = tabela.getSelectedRow();

if (linha < 0) //verifica se existe linha
return;
else{
/*atribui os valores da linha selecionada para edição no formulário*/
String codigo = tabela.getValueAt(linha, 0).toString();
String nome = tabela.getValueAt(linha,1).toString();
String telefone = tabela.getValueAt(linha, 2).toString();
String email = tabela.getValueAt(linha, 3).toString();
String endereco = tabela.getValueAt(linha, 4).toString();

formCadAgenda= new FormCadAgenda(this, codigo, nome, telefone, email, endereco);
formCadAgenda.setModal(true);
formCadAgenda.inicia();
}
}

//evento do botão remover
private void buttonRemoverActionPerformed(ActionEvent e){
//mostra o JOptionPane
int resposta = JOptionPane.showConfirmDialog(this,
"Deseja remover registro?",
"Remoção",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
if (resposta == JOptionPane.OK_OPTION){
//seleciona a linha para remoção
int linha = tabela.getSelectedRow();
int coluna = 0;

if (linha < 0)
return;
else{
String codigo = tabela.getValueAt(linha, coluna).toString();
Main.minhaAgenda.remove(codigo); //remove o contato
modelo.removeRow(linha); //remove a linha

JOptionPane.showMessageDialog(this,
"Registro excluído com sucesso!!!",
"Remover", JOptionPane.INFORMATION_MESSAGE);

}
}
}
//evento do botão fechar
private void buttonFecharActionPerformed(ActionEvent e){
//mostra mensagem de confirmação de Fechar
int ret = JOptionPane.showConfirmDialog(this,
"Deseja Fechar?",
"Fechar",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
//fecha a janela da agenda caso clique em OK
if (ret == JOptionPane.OK_OPTION){
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.destroyInstance();
}

}
//evendo ao clicar no “X” de fechar a janela ao em vez do botão
private void interfaceAgendaInternalFrameClosing(InternalFrameEvent e){
int ret = JOptionPane.showConfirmDialog(this,
"Deseja Fechar?",
"Fechar",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
//fecha a janela da agenda caso clique em OK
if (ret == JOptionPane.OK_OPTION){
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
this.destroyInstance();
}else
this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
//método verificar se já existe uma instancia classe InterfaceAgenda
public static InterfaceAgenda getInstance(){
if (InterfaceAgenda.INSTANCE == null){
return INSTANCE = new InterfaceAgenda();
}

return INSTANCE;
}

//método que preenche a JTABLE com os valores passados
public void preencheTabela(){

ArrayList lista = Main.minhaAgenda.getList();
//ordena os contatos por ordem de código
Collections.sort(lista, Pessoa.ORDEM_CODIGO);
Iterator it = lista.iterator();

while (it.hasNext()){
Pessoa p = (Pessoa)it.next();

modelo.addRow(new String[]{
p.getCodigo(),
p.getNome(),
p.getTelefone(),
p.getEmail(),
p.getEndereco()
});
}
}

public void atualizaTabela(String[] dados){

int linha = tabela.getSelectedRow();

tabela.setValueAt(dados[0], linha, 0);
tabela.setValueAt(dados[1], linha, 1);
tabela.setValueAt(dados[2], linha, 2);
tabela.setValueAt(dados[3], linha, 3);
tabela.setValueAt(dados[4], linha, 4);
}

public InterfaceAgenda destroyInstance(){
this.dispose();
return INSTANCE = null;
}

public static boolean isInstance(){
if (INSTANCE == null) return false;

return true;
}
public void addRow(Object[] o){
modelo.addRow(o);
}
}

Classe Main: Classe que serve como porta de entrada para o usuário. Através dela os usuário acessa as outras interfaces, além dela fornecer a opção de mudar o LookAndFeel dos formulários.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.imageio.*;

public class Main extends JFrame{

public static Agenda minhaAgenda = new Agenda(); /*cria um objeto onde será armazenado os contatos*/
//cria-se os componentes da barra de MENU
private JMenuItem menuAbreAgenda = new JMenuItem("Abrir Agenda");
private JMenuItem menuFechaAgenda = new JMenuItem("Fechar Agenda");
private JRadioButtonMenuItem[] menuItemEstilo = new JRadioButtonMenuItem[3];

private JMenu menuAgenda = new JMenu("Agenda");
private JMenu menuEstilo = new JMenu("Estilo");

private JMenuBar menuBar = new JMenuBar();

private InterfaceAgenda agenda = null;

private JDesktopPane desktop; //cria-se a janela principal
private ButtonGroup group = new ButtonGroup();

public static void main(String[] args){
Main m = new Main(); //chama o método q contrói a janela principal do prgrama
}

public Main(){ //método constructor, que monta a janela principal do programa
super("TRABALHO SOBRE INTERFACE GRÁFICA");

desktop = new JDesktopPane(){
//adiciona uma imagem de fundo para o desktop
public void paintComponent(Graphics g){
try{
super.paintComponents(g);

Image img = ImageIO.read(new java.net.URL(
this.getClass().getResource("imagens/DESKTOP.gif"), "DESKTOP.gif"));
if (img != null){
g.drawImage(img, 0, 0, 800, 600, this);
}

}catch(Exception e){
e.printStackTrace();
}
}
};
//cor do fundo do desktop
desktop.setBackground(Color.WHITE);

//seta os ícones dos menus
menuAgenda.setIcon(new
ImageIcon(this.getClass().getResource("imagens/AGENDA2.png")));

menuAbreAgenda.setIcon(new
ImageIcon(this.getClass().getResource("imagens/AGENDA.png")));

menuEstilo.setIcon(new
ImageIcon(this.getClass().getResource("imagens/ESTILO.png")));
//evento do botao do menu Abrir Agenda
menuAbreAgenda.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
menuAgendaActionPerformed(e);
}
});


menuFechaAgenda.setIcon(new
ImageIcon(this.getClass().getResource("imagens/FECHAR.png")));
menuFechaAgenda.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
menuFechaAgendaActionPerformed(e);
}
});

//adicionando no menu Estilo as opções de estilo
menuItemEstilo[0] = new JRadioButtonMenuItem("Metal");
menuItemEstilo[0].setSelected(true);
menuItemEstilo[0].setIcon(new
ImageIcon(this.getClass().getResource("imagens/JAVA.png")));
menuItemEstilo[1] = new JRadioButtonMenuItem("Motif");
menuItemEstilo[1].setIcon(new
ImageIcon(this.getClass().getResource("imagens/LINUX.png")));
menuItemEstilo[2] = new JRadioButtonMenuItem("Windows");
menuItemEstilo[2].setIcon(new
ImageIcon(this.getClass().getResource("imagens/WINDOWS.png")));
//método que muda o estilo da janela
for (int i = 0; i < menuItemEstilo.length; i++){
group.add(menuItemEstilo[i]);
menuEstilo.add(menuItemEstilo[i]);
menuItemEstilo[i].addItemListener(new ItemListener(){
public void itemStateChanged(ItemEvent e){
menuEstiloItemStateChanged(e);
}
});
}
/* Adicionando os menus à barra */
menuAgenda.add(menuAbreAgenda);
menuAgenda.addSeparator();
menuAgenda.add(menuFechaAgenda);

menuBar.add(menuAgenda);
menuBar.add(menuEstilo);

this.getContentPane().add(desktop);

this.setJMenuBar(menuBar);
this.setExtendedState(JFrame.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
//ação ao clicar mandar Abrir Agenda
private void menuAgendaActionPerformed(ActionEvent e){

agenda = InterfaceAgenda.getInstance();
desktop.remove(agenda);
desktop.add(agenda);
agenda.setVisible(true);

}

private void menuFechaAgendaActionPerformed(ActionEvent e){

//verifica se já existe instancia
if (InterfaceAgenda.isInstance()){
int ret = JOptionPane.showConfirmDialog(this,
"Deseja Fechar?",
"Fechar",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);

if (ret == JOptionPane.OK_OPTION){
agenda.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
agenda.destroyInstance();
}

}
}

private void menuEstiloItemStateChanged(ItemEvent e){

for (int i = 0; i < menuItemEstilo.length; i++){
if (menuItemEstilo[i].isSelected()){
atualizar(i);
}
}
}

public void atualizar(int valor){
UIManager.LookAndFeelInfo[] look = UIManager.getInstalledLookAndFeels();

try{
UIManager.setLookAndFeel(look[valor].getClassName());
SwingUtilities.updateComponentTreeUI(this);
}
catch(Exception e){
e.printStackTrace();
}
}
}

2558675589_c2840be47d.jpg

Figura 22: Resultado do experimento prático

2558675865_dcc31ca0a7.jpg

Figura 23: Resultado do experimento prático

-----------------------------------

Referências

http://www.javafree.com.br
http://www.guj.com.br
http://java.sun.com/
• Aprenda Em 21 Dias Java 2 - Laura Lemay E Rogers Cadenhead
• Java Como Programar - H. M. Deitel, P. J. Deitel

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License