Características conforme a profissão

1. Gerente de projeto é alguém que pensa que nove mulheres podem produzir um bebê em um mês.

2. Projetista é alguém que pensa que um bebê leva 18 meses para ser produzido.

3. Gerente de Produção é alguém que acredita que uma única mulher pode produzir nove bebês em um mês.

4. Cliente é aquele que não sabe por que quer um bebê.

5. Gerente de marketing é alguém que afirma que vai entregar um bebê mesmo sem ter nem homem nem mulher disponíveis.

6. Equipe de otimização de recursos é um grupo que não precisa de homem ou mulher porque vai produzir um bebê a partir do zero.

7. Equipe de documentação é um grupo que não se importa se o bebê vai ser entregue; apenas vão documentar os nove meses.

8. Auditor de qualidade é alguém que nunca está satisfeito com o processo usado para produzir um bebê.

Interface Gráfica em JAVA

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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 < exemplo =" new">

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(); } }

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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.

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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 < codigo =" tabela.getValueAt(linha," nome =" tabela.getValueAt(linha,1).toString();" telefone =" tabela.getValueAt(linha," email =" tabela.getValueAt(linha," endereco =" tabela.getValueAt(linha," formcadagenda=" new" resposta =" JOptionPane.showConfirmDialog(this," resposta ="=" linha =" tabela.getSelectedRow();" coluna =" 0;" codigo =" tabela.getValueAt(linha," ret =" JOptionPane.showConfirmDialog(this," ret ="=" ret =" JOptionPane.showConfirmDialog(this," ret ="=" instance ="=" instance =" new">
//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 <>
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 < look =" UIManager.getInstalledLookAndFeels();">

Figura 22: Resultado do experimento prático

Figura 23: Resultado do experimento prático

Configurando Driver Mysql no java

Boa tarde, seguindo o assunto que meu amigo Claudio abordou no post anterior vou mostrar como se deve configurar uma conexão entre o Java e o Mysql.

Primeiramente precisamos ter uma classe Conecta.

Segue o exemplo da classe:


import java.sql.*; //importa as classes referentes a conexão

class Conecta{
Connection con = null; //inicia a variavel con

public void banco(){
try{
String server="localhost";
String base="dbteste";
String user="root";
String senha="";
Class.forName("com.mysql.jdbc.Driver"); //importa o driver para a conexão
con = DriverManager.getConnection("jdbc:mysql://"+server+"/"+base,user,senha);
}
catch(Exception e){
e.printStackTrace();

}
}



}

Acima como vocês podem ver, está o exemplo so que para que isso funcione é preciso do driver mysql-connector-java-5.0.7-bin.jar que pode ser baixado no site http://dev.mysql.com/downloads/connector/j/5.1.html . Esse arquivo deve ser gravado dentro do diretorio C:\Arquivos e Programas\Java\jre1.6.0\lib\ext\ para que funcione.

Agora segue abaixo um exemplo de uma classe consulta:


import java.sql.*;

class consulta{
public static void main (String[] args) {
Conecta teste=new Conecta();
int id=0;
try{
teste.banco();
Statement stm=null;
stm=teste.con.createStatement();
ResultSet rs=stm.executeQuery("select * from usuarios;"); /*criando a query de consulta e ja jogando na variavel rs */





while(rs.next()){
id=Integer.parseInt(rs.getString("id")); //Integer.parseInt: Converte String para Int
System.out.println(rs.getString("id")); /* o metodo getString é usado para retornar a coluna da base de dados */
System.out.println(rs.getString("nome"));
System.out.println(rs.getString("senha"));

}
/* Para fazer um update na base se deve usar o metodo executeUpdate(); como vou mostra no exemplo abaixo */
stm.executeUpdate("update usuarios set nome='Rodrigo',senha='mysql' where id='"+id+"');
}
catch(Exception e){
e.printStackTrace();

}


}
}

É isso pessoal, espero que ajude.

Att.

Update nas base em MySQL

Sintaxe UPDATE

UPDATE [LOW_PRIORITY] [IGNORE] nome_tabela
   SET nome_coluna1=expr1 [, nome_coluna2=expr2 ...]
   [WHERE definição_where]
   [ORDER BY ...]
   [LIMIT row_count]

ou

UPDATE [LOW_PRIORITY] [IGNORE] nome_tabela [, nome_tabela ...]
   SET nome_coluna1=expr1 [, nome_coluna2=expr2 ...]
   [WHERE definição_where]

UPDATE atualiza uma coluna em registros de tabelas existentes com novos valores. A cláusula SET indica quais colunas modificar e os valores que devem ser dados. A cláusula WHEREi, se dada, especifica quais linhas devem ser atualizadas. Senão todas as linhas são atualizadas. Se a cláusula ORDER BY é especificada, as linhas serão atualizada na ordem especificada.
Se você especificar a palavra-chave LOW_PRIORITY, a execução de UPDATE e atrasada até que nenhum outro cliente esteja lendo da tabela.
Se você especificar a palavra-chave IGNORE, a instrução não será abortada memso se nós obtermos erros de chaves duplicadas durante a atualização. Linhas que causem conflitos não serão atualizadas.
Se você acessa um coluna de nome_tabela em uma expressão, UPDATE utiliza o valor atual da coluna. Por exemplo, a seguinte instrução define a coluna age com o valor atual mais um:

mysql> UPDATE persondata SET age=age+1;

Atribuiçãoes UPDATE são avaliadas da esquerda para a direitat. Por exemplo, a seguinte instrução dobra a coluna age e então a incrementa:

mysql> UPDATE persondata SET age=age*2, age=age+1;

Se você define uma coluna ao valor que ela possui atualmente, o MySQL notará isto é não irá atualizá-la.

UPDATE retorna o número de linhas que forma realmente alteradas. No MySQL Versão 3.22 ou posterior, a função mysql_info() da API C retorna o número de linhas encontradas e atualizadas e o número de avisos que ocorreram durante o UPDATE.
A partir do MySQL versão 3.23, você pode utilizar LIMIT row_count para restringir o escopo do UPDATE. Uma cláusula LIMIT funciona da seguinte forma:

• Antes do MySQL 4.0.13, LIMIT é uma restrição que afeta as linhas. A instrução para assim que altera row_count linhas que satisfaçam a cláusula WHERE.
• Da versão 4.0.13 em diante, LIMIT é uma restrição de linhas correspondentes. A instrução para assim que ela encontrar row_count linhas que satisfaçam a cláusula WHERE, tendo elas sido alteradas ou não.

Se uma cláusula ORDER BY é utilizada (disponível no MySQL 4.0.0), as linhas serão atualizadas nesta ordem. Isto só é util em conjunto com LIMIT.
A partir da MySQL Versão 4.0.4, você também pode realizar operações UPDATE que cobrem múltiplas tabelas:

UPDATE items,month SET items.price=month.price
WHERE items.id=month.id;

O exemplo mostra um inner join usando o operador de vírgula, mas instruções UPDATE multi-tabelas podem usar qualquer tipo de join permitida na instrução SELECT, como LEFT JOIN.
Nota: você não pode utilizar ORDER BY ou LIMIT com multi-tabelas UPDATE.

Remover o virus que causa LogOn LogOff

O virus que causa o logoff imediatamente a se logar na maquina fica armazenado ou remove o arquivo userinit.exe.

Para solucionar o problema você terá que bootar por um disco de inicialização, e colocar o arquivo dentro da pasta system32 do widows.

download - userinit.exe

Quem não conseguir o arquivo, é só deixar o e-mail que será entregue no e-mail.