1/5/2014
Interface Gráfica em JAVA - Java Interface
Java Interface
Create account or Sign in Search this site
example menu
Search
contact
Interface Gráfica em JAVA Java
Update My Java Chitika | Opt out?
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.
http://javainterface.wikidot.com/interfacejava
1/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 http://javainterface.wikidot.com/interfacejava
2/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
* 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){ http://javainterface.wikidot.com/interfacejava
3/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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(); } }
http://javainterface.wikidot.com/interfacejava
4/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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.*; http://javainterface.wikidot.com/interfacejava
5/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 http://javainterface.wikidot.com/interfacejava
6/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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(); } }
http://javainterface.wikidot.com/interfacejava
7/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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); http://javainterface.wikidot.com/interfacejava
8/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 < 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 http://javainterface.wikidot.com/interfacejava
9/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
this.setVisible(true); } public static void main(String[] args){ JFrameExemplo exemplo = new JFrameExemplo(); } }
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); http://javainterface.wikidot.com/interfacejava
10/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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){ http://javainterface.wikidot.com/interfacejava
11/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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(); } }
http://javainterface.wikidot.com/interfacejava
12/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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(); } }
http://javainterface.wikidot.com/interfacejava
13/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 private JMenuItem private JMenuItem private JMenuItem
menuItemAbrir = new JMenuItem("Abrir"); menuItemNovo = new JMenuItem("Novo"); menuItemSalvar = new JMenuItem("Salvar"); 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(); http://javainterface.wikidot.com/interfacejava
14/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
} }
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.
http://javainterface.wikidot.com/interfacejava
15/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 import import import
javax.swing.*; java.awt.*; java.awt.event.ActionEvent; 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(){ http://javainterface.wikidot.com/interfacejava
16/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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. http://javainterface.wikidot.com/interfacejava
17/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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.*; site-name import javax.swing.*;
Edit.wikidot.com History Tags Source » Share Explore on
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.*; http://javainterface.wikidot.com/interfacejava
18/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col pane.add(new Label("Col
1 Lin 1")); 2 Lin 1")); 3 Lin 1")); 4 Lin 1")); 1 Lin 2")); 2 Lin 2")); 3 Lin 2")); 4 Lin 2")); 1 Lin 3")); 2 Lin 3")); 3 Lin 3")); 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 {
http://javainterface.wikidot.com/interfacejava
19/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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); http://javainterface.wikidot.com/interfacejava
20/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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(); } }
http://javainterface.wikidot.com/interfacejava
21/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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); http://javainterface.wikidot.com/interfacejava
22/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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){ http://javainterface.wikidot.com/interfacejava
23/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 = ""; http://javainterface.wikidot.com/interfacejava
24/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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){ http://javainterface.wikidot.com/interfacejava
25/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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); http://javainterface.wikidot.com/interfacejava
26/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
//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); http://javainterface.wikidot.com/interfacejava
27/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
//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 import import import import import
java.awt.*; java.awt.event.*; java.util.*; javax.swing.event.*; javax.swing.table.DefaultTableModel; 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"); http://javainterface.wikidot.com/interfacejava
28/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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); http://javainterface.wikidot.com/interfacejava
29/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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 http://javainterface.wikidot.com/interfacejava
30/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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){ http://javainterface.wikidot.com/interfacejava
31/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
int linha = tabela.getSelectedRow(); tabela.setValueAt(dados[0], tabela.setValueAt(dados[1], tabela.setValueAt(dados[2], tabela.setValueAt(dados[3], tabela.setValueAt(dados[4], }
linha, linha, linha, linha, linha,
0); 1); 2); 3); 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 import import import
java.awt.*; java.awt.event.*; javax.swing.*; 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")); http://javainterface.wikidot.com/interfacejava
32/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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); http://javainterface.wikidot.com/interfacejava
33/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
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(); } } }
http://javainterface.wikidot.com/interfacejava
34/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
Figura 22: Resultado do experimento prático
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
http://javainterface.wikidot.com/interfacejava
35/36
1/5/2014
Interface Gráfica em JAVA - Java Interface
Java Update My Java Java Download Java Com Java Games 2014 Crossover SUVs Chitika | Opt out?
page revision: 7, last edited: 7 Jun 2008, 18:25 (2154 days ago)
Edit
Powered by Wikidot.com
Tags
History
Files
Print
Site tools
+ Options
Help | Terms of Service | Privacy | Report a bug | Flag as objectionable
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License
Other interesting sites
Borderlands Modding Resource
http://javainterface.wikidot.com/interfacejava
SCP Sandbox Wiki II
Portalul Seriei 23
I Hate This World
Sandbox Harder
Facultatea de Matematica si Informatica
The Misanthrope's Website
36/36
