75759005 Apostila Java I

Escola Técnica de Brasília Curso de Java I

1

APOSTILA DE JAVA I


2

SUMÁRIO

PARTE 1 - SWING ........................................................................................................................................................... 3 Exemplo 1: Frame/AWT. .............................................................................................................................................. 6 Exemplo 2: JFrame. ..................................................................................................................................................... 8 Exemplo 3: JButton, JPanel ....................................................................................................................................... 10 Exemplo 4: ImageIcon. .............................................................................................................................................. 12 Exemplo 5: JLabel, JTextField, JTextArea. ............................................................................................................... 15 Exemplo 6: JScrollPane. ............................................................................................................................................ 17 Exemplo 7: JRadioButton, ButtonGroup. ................................................................................................................... 19 Exemplo 8: JComboBox. ........................................................................................................................................... 21 Exemplo 9: JList. ........................................................................................................................................................ 23 Exemplo 10: JOptionPane, UIManager. .................................................................................................................... 27 Exemplo 11: JSlider. .................................................................................................................................................. 31 Exemplo 12: JToolBar. ............................................................................................................................................... 34 Exemplo 13: JProgessBar. ........................................................................................................................................ 36 Exemplo 14: JMenuBar, JMenu, JMenuItem. ............................................................................................................ 38 Exemplo 15: JTabbedPane....................................................................................................................................... 42

PARTE 2 - LAYOUT ....................................................................................................................................................... 44 Exemplo 1: FlowLayout .............................................................................................................................................. 46 Exemplo 2: BoxLayout. .............................................................................................................................................. 48 Exemplo 3: GridLayout. ............................................................................................................................................. 50 Exemplo 4: BorderLayout. ......................................................................................................................................... 52 Exemplo 5: CardLayout. ............................................................................................................................................ 54 Exemplo 5: Executora CardLayout ............................................................................................................................ 56 Exemplo 6: GridBagLayout ........................................................................................................................................ 60 Exemplo 6: Executora GridBagLayout ....................................................................................................................... 61

PARTE 3 - EVENTOS .................................................................................................................................................... 64 Exemplo 1: ActionListener ......................................................................................................................................... 67 Exemplo 2: FocusListener. ........................................................................................................................................ 84 Exemplo 3: ItemListener ............................................................................................................................................ 86 Exemplo 4: MouseMotionListener ............................................................................................................................. 97 Exemplo 5: KeyAdapter. .......................................................................................................................................... 106

Parte 4 - Banco de Dados com Java ........................................................................................................................... 108 Exemplo 1. ............................................................................................................................................................... 112 Exemplo 2. ............................................................................................................................................................... 115 Exemplo 3. ............................................................................................................................................................... 116 Exemplo 4. ............................................................................................................................................................... 118 Exemplo 5. ............................................................................................................................................................... 122 Exemplo 6. ............................................................................................................................................................... 125


3

PARTE 1 - SWING


4

CLASSES GRÁFICAS

A Graphical User Interface (Interface Gráfica com o usuário) fornece detalhes sobre as aparências de um projeto atual, seguem a determinados padrões dando ao usuário um nível básico de familiaridade com um programa sendo que ele jamais o tenha visto ou mesmo utilizado. Isto reduz o tempo do usuário em aprendizado e aumenta a sua habilidade produtiva. As classes atuais que criam os componentes GUI em Java, fazem parte do pacote chamado SWING, encontradas em javax.swing. Antigamente os componentes faziam parte do pacote chamado Abstract Windows Toolkit (também chamada por AWT) a maior vantagem deste pacote era que quando os componentes eram chamados pelo SO Windows, por exemplo, eles mantinham a aparência deste, o mesmo sistema ao ser chamado pelo SO Solaris mudava automaticamente e assim sucessivamente. A SWING nasceu com o intuito de melhorar os objetos da AWT dotando-lhes de capacidades que os mesmos não possuem, todos eles seguem os mesmo padrões de comportamento. Principais componentes:

· Frames – Janelas que podem incluir uma barra de títulos e uma barra de menus, além de botões para maximizar, minimizar e fechar.

· Contêineres – Elementos da interface que podem manter outros componentes. · Botões – Regiões clicáveis, com texto ou gráficos indicando sua finalidade. · Rótulos – Texto ou gráficos que oferecem informações. · Campos de texto e áreas de texto – Janelas que aceitam entrada do teclado e permitem que o texto seja

editado. · Listas drop-down – Grupos de itens relacionados, que podem ser selecionados a partir de menus drop-

down ou janelas roláveis. · Caixas de seleção e botões de opção – Pequenas janelas ou círculos que podem ser marcados ou

desmarcados. Dois outros pacotes usados com a programação da interface gráfica com o usuário são o java.awt e o

java.awt.event, classes de tratamento de eventos que tratam da entrado do usuário. Todos os componentes do Swing são subclasses da classe abstrata JComponent, que inclui métodos para

definir o tamanho de um componente, alterar a cor de fundo, definir a fonte usada em todo texto exibido e configurar as ToolsTips – texto explanatório que aparece quando um usuários repousa o mouse por alguns segundos sobre o componente.

Para que os componentes possam ser exibidos em uma interface com o usuário, eles devem ser acrescentados a um contêiner, um componente que pode conter outros componentes.

CONTÊINERS JFrame – Uma janela como se conhece com todos os botões. JDialog – Uma janela de diálogo com o usuário, a mesma que aparece quando utilizamos a JOptionPane. JWindow – Uma janela simples, sem barra de títulos. JPanel – Agrupa um ou mais objetos dentro de uma janela, especificando uma área de atuação JApplet – É um panel para ser utilizado na Internet.

O primeiro passo na criação de uma aplicação Swing é criar uma classe que representa a interface gráfica com o usuário. Um objeto dessa classe serve como um contêiner que mantém todos os outros componentes a serem exibidos. Em muitos projetos, o objeto de interface principal é uma janela simples (a classe window) ou uma janela mais especializada, chamada de frame (a classe JFrame). Uma janela simples não possui uma barra de títulos; botões para maximizar, minimizar e fechar; ou outros recursos que você vê na maioria das janelas abertas no sistema operacional de uma interface gráfica com o usuário. As janelas que possuem esses recursos de gerenciamento de janela são chamados frames. Um modo de criar uma aplicação gráfica Swing é tornar a interface uma subclasse de JFrame, como na declaração de classe a seguir: public class Janela extends JFrame {


5

// ... } O construtor da classe deve tratar das seguintes tarefas:

· Chamar o construtor de uma superclasse para dar um título ao frame e tratar de outros procedimentos de configuração.

· Definir o tamanho da janela de um frame, especificando a largura e a altura em pixels ou deixando o Swing escolher o tamanho certo.

· Decidir o que fazer se um usuário fechar a janela. · Exibir o frame. Construtores: JFrame( ) - deixa a barra de título vazia JFrame(Texto) - define a barra de títulos do frame para o texto especificado. Métodos: setTitle(Texto) – defini um título para o frame. setSize(int,int) - defini o tamanho com a largura e a altura como argumentos. O tamanho de um frame é

indicado em pixels, de modo que, se você chamasse setSize(600,600), o frame ocuparia, quando exibido, a maior parte de toda a tela na resolução de 800 x 600.

Podemos também chamar o método setSize(Dimension) para definir o tamanho de um frame. Dimension é uma classe java.awt que representa a largura e a altura de um componente da interface com o usuário. A chamada do construtor Dimension(int,int) cria um objeto Dimension representando a largura e a altura especificados como argumentos.

pack( ) - outra alternativa para definir o tamanho, isso redimensiona o frame com base no tamanho dos seus componentes. Se o frame for maior do que precisa ser, pack( ) o encolherá ao tamanho mínimo necessário para exibir os componentes. Se o frame for muito pequeno (ou o tamanho não tiver sido definido), pack( ) o expandirá para o tamanho exigido. show ( ) - Os frames são invisíveis quando criados. Este método é utilizado para torná-los visíveis.

setVisible(boolean) - Tornar visível ou não um frame, dependendo dos valores true ou false. hide ( ) - ocultam um frame


6

Exemplo 1: Frame/AWT.

import java.awt.*;

public class Janela{ public static void main (String args[]) { Frame tela= new Frame( ); tela.setTitle("Janela"); tela.setSize(200,200); tela.setBackground(Color.black); tela.setVisible(true); }

} Exercício 1:

1) Qual é a vantagem de se utilizar a AWT? 2) Explique o método setBackground(Color.black).

Extra 1: JWindow

import javax.swing.*; public class Janela2 extends JWindow{ public Janela2(){ super(); setBounds(50,50,10,10); setVisible(true); } public static void main(String args[]){ Janela2 j = new Janela2(); for (int i=10;i<400;i++){ j.setBounds(40-(i/2),50-(i/2),i,i); } } }


7

Cada frame possui botões de maximizar, minimizar e fechar na barra de títulos, para o controle do usuário. Em Java, o comportamento normal quando um frame é fechado é que a aplicação continue em execução. Para mudar isso, você precisa chamar o método setDefaultCloseOperation( ) com uma das quatro variáveis estáticas da classe JFrame como argumento:

· EXIT_ON_CLOSE – Sai do programa quando o frame é fechado. · DISPOSE_ON_CLOSE – Fecha o frame, descarta o objeto de frame e continua executando a aplicação. · DO_NOTHING_ON_CLOSE – Mantém o frame aberto e continua executando. · HIDE_ON_CLOSE – Fecha o frame e continua executando.


8

Exemplo 2: JFrame.

import javax.swing.JFrame; public class Janela3 extends JFrame{ public Janela3 ( ){ super("Título da Janela"); setSize(300,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); } public static void main (String [] arguments){ Janela3 janela = new Janela3( ); } } Obs.: Se não tivéssemos exibo o frame quando este foi criado, poderíamos chamar fs.setVisible(true) no método

main para exibir o frame. Exercício 2: 1) Como se faz herança em Java? 2) O que é um método construtor? 3) Qual é a vantagem de se utilizar um método construtor?


9

JButton - JPanel Para criar um componente de interface em Java, crie um objeto da classe do componente. Um botão Swing pode conter um rótulo de texto, um ícone gráfico ou uma combinação de ambos. Os métodos construtores que você pode usar para os botões incluem o seguinte:

· JButton(Texto) – Um botão rotulado com o texto especificado. · JButton(Icon) – Um botão que apresenta o ícone especificado. · JButton(Texto, Icon) – Um botão com o texto e o ícone especificados. Exemplo: JButton ok = new JButton(“ok”);

Antes que possamos exibir um componente da interface com o usuário, como um botão em um programa

precisamos acrescentá-lo a um contêiner e exibir esse contêiner. Para acrescentar um componente a um contêiner simples, chamamos o método add(Componente) do contêiner

com o componente como argumento (todos os componentes da interface com o usuário Swing herdam de java.awt.Component).

O contêiner Swing mais simples é o painel (a classe JPanel). O exemplo a seguir cria um botão e o acrescenta a um painel:

JButton sair = new JButton(“Sair”); JPanel painel = new JPanel( ); painel.add(Sair);


10

Exemplo 3: JButton, JPanel

import javax.swing.*; public class Botoes extends JFrame { JButton salvar = new JButton ("Salvar"); JButton cancelar = new JButton ("cancelar"); JButton limpar = new JButton ("Limpar"); public Botoes(){ super("Janela com Botões"); setSize(300,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); painel.add(salvar); painel.add(cancelar); painel.add(limpar); add(painel); // torna o painel de conteúdo do frame setVisible(true); } public static void main (String [] arguments){ Botoes b = new Botoes(); } }

Exercício 3: 1) Acrescente mais três botões na interface acima. 2) O que é um objeto de classe e um objeto de método?


11

JComponent Todos os componentes Swing compartilham uma superclasse comum, javax.swing.JComponent, da qual

herdam vários métodos úteis aos programas. · setEnable(boolean) determina se um componente pode receber entrada do usuário. Os componentes

estão ativados por padrão e precisam estar ativados para que recebam a entrada do usuário. Muitos componentes desativados mudam de aparência para indicar que não podem ser usados atualmente – por exemplo, um JButton desativado possui bordas cinza claro e texto cinza.

· isEnable( ) – utilizado para verificarmos se um componente está ativo, retorna um valor boolean. · isVisible( ) - utilizado para verificarmos se um componente está visível, retorna um valor boolean. · getSize( ) - retorna um objeto Dimension com as dimensões nas variáveis de instância height e width.

ImageIcon O Swing oferece suporte ao uso de objetos gráficos ImageIcon em botões e outros componentes em que pode ser fornecido um rótulo. Um ícone é um pequeno gráfico que pode ser posicionado no botão, rótulo ou outro elemento da interface com o usuário para identificá-lo. Um objeto ImageIcon pode ser criado especificando o nome de arquivo de um gráfico como o único argumento para o construtor. Exemplo: ImageIcon iconenovo = new ImageIcon (“novo.gif”);

JButton botão = new JButton (iconenovo); JPanel painel = new JPanel( ); painel.add(botão); add(painel); setVisible(true);


12

Exemplo 4: ImageIcon.

import javax.swing.*; public class Icones extends JFrame{

JButton salvar, salvarcomo, salvarcopia, localizar; public Icones( ){

super("Botão com Ícone"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); // cria os ícones ImageIcon iconesalvar = new ImageIcon("c:/Ícones/save.png"); ImageIcon iconesalvarcomo = new ImageIcon("c:/Ícones/save

as.png"); ImageIcon iconesalvarcopia = new ImageIcon("c:\\Ícones\\save

copy.png"); ImageIcon iconelocalizar = new ImageIcon("c:\\Ícones\\search

2.png"); // cria os botões salvar = new JButton ("Salvar", iconesalvar); salvarcomo = new JButton ("Salvar Como", iconesalvarcomo); salvarcopia = new JButton ("Salvar Como Cópia",

iconesalvarcopia); localizar = new JButton ("Localizar", iconelocalizar); // acrescenta botões ao painel painel.add(salvar); painel.add(salvarcomo); painel.add(salvarcopia); painel.add(localizar); //acrescenta o painel a um frame add(painel); pack(); setVisible(true); } public static void main(String[] arguments){ Icones ico = new Icones(); } } Obs.: Se estiver procurando ícones para experimentar nas aplicações Swing, poderá encontrá-los no seguinte

endereço: http://developer.java.sun/developer/techDocs/hi/repository Exercício 4: 1) Modifique o método construtor dos botões para que o mesmo apresente somente os ícones.


13

JLabel Um rótulo é um componente do usuário que contém texto informativo, um ícone ou ambos. Os rótulos criados

a partir da classe JLabel, normalmente são usados para identificar a finalidade de outros componentes de uma interface. Eles não podem ser editados diretamente por um usuário.

Construtores: · JLabel(Texto) – Um rótulo com o texto especificado. · JLabel(Texto, int) – Um rótulo com texto e alinhamento especificados. · JLabel(Texto, Icon, int) – Um rótulo com o texto, ícone e alinhamento especificados. O alinhamento de um rótulo determina como seu texto ou ícone é alinhado em relação à área tomada pela

janela. Três variáveis de classe estáticas da interface SwingConstants são usadas para especificar o alinhamento: LEFT, CENTER e RIGHT.

O conteúdo de um rótulo pode ser definido com os métodos setText(Texto) ou setIcon(Ícone). Podemos também utilizar os métodos getText( ) e getIcon( ).

Exemplos: JLabel nome = new JLabel (“Nome”, SwingConstants.LEFT); JLabel sexo = new JLabel (“Sexo”, SwingConstants.CENTER); JLabel cpf = new JLabel (“CPF”, SwingConstants.RIGHT);

JTextField Um campo de texto é um local em uma interface em que um usuário pode entrar e modificar texto usando o

teclado. Os campos de texto são representados pela classe JTextField e podem tratar de uma linha de entrada. Construtores:

· JTextField( ) – Um campo de texto vazio. · JTextField(int) – Um campo de texto com largura especificada. · JTextField(Texto, int) – Um campo de texto com texto e a largura especificados.

O atributo de largura de um campo de texto só tem relevância se a interface for organizada de uma maneira que não redimensione componentes.

Exemplos: JTextField url = new JTextField(60); JTextField url2 = new JTextField(“Entre com sua url aqui”, 60); Os campos de texto e as áreas de texto herdam da superclasse JTextComponent e compartilham muitos

métodos comuns. · setEditable(boolean) - determina se um componente de texto pode ser editado. · isEditable( ) – verifica se um componente está habilitado, retorna um valor boolean correspondente. · setText(Texto) - muda o texto para a string especificada · getText( ) - retorna o texto atual do componente como uma string · getSelectedText( ) - pega apenas o texto que um usuário destacou no componente.

Campos de senha são campos de texto que escondem os caracteres que um usuário está digitando no campo. Eles são representados pela classe JPasswordField, uma subclasse de JTextField. Podemos utilizar o método setEchoChar(Caractere) para ocultar a entrada, substituindo cada caractere pelo caractere especificado.

Exemplo: JPasswordField senha = new JPasswordField(20); senha.setEchoChar(‘#’);


14

JTextArea As área de texto, os campos de texto editáveis que podem lidar com mais de uma linha de saída, são

implementadas com a classe JTextArea. JTextArea inclui os seguintes métodos construtores:

· JTextArea(int,int) – Uma área de texto com o número de linhas e colunas especificado. · JTextArea(Texto, int, int) – Uma área de texto com o texto, linhas e colunas especificados.

Podemos usar os métodos getText( ), getSelectedText( ) e setText(Texto). Temos, ainda, os métodos:

· append(Texto) – acrescenta o texto especificado no final do texto atual. · insert(Texto, int) – insere o texto especificado na posição indicada. · setLineWrap(boolean) – determina se o texto quebrará para a linha seguinte quando atingir a

margem do componente. Chame setLineWrap(true) para que ocorra a quebra de linha. · setWrapStyleWord(boolean) – determina o que será quebrado para a linha seguinte – ou a palavra

atual (um argumento true) ou o caractere atual(false).


15

Exemplo 5: JLabel, JTextField, JTextArea.

import javax.swing.*; public class Logon extends JFrame{ JTextField usuario = new JTextField(15); JPasswordField senha = new JPasswordField(15); JTextArea comentarios = new JTextArea(4,15); JButton ok = new JButton("OK"); JButton cancelar = new JButton("Cancelar"); public Logon(){ super("Logon"); setSize(200,280); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); JLabel usuariorotulo = new JLabel("Usuário"); JLabel senharotulo = new JLabel("Senha"); JLabel comentariosrotulo = new JLabel("Comentários"); comentarios.setLineWrap(true);// quebra de linha comentarios.setWrapStyleWord(true); // quebra na palavra painel.add(usuariorotulo); painel.add(usuario); painel.add(senharotulo); painel.add(senha); painel.add(comentariosrotulo); painel.add(comentarios); painel.add(ok); painel.add(cancelar); add(painel); setVisible(true); } public static void main (String args[]){ Logon log = new Logon( ); } }


16

JScrollPane O Swing oferece suporte a barras de rolagem por meio de um novo contêiner que pode ser usado para conter

qualquer componente rolável: JScrollPane. Um painel rolável é associado a um componente no método construtor do painel. Podemos usar um dos

seguintes construtores: · JScrollPane(Componente) – Um painel rolável que contém o componente especificado. · JScrollPane(Componente, int, int) – Um painel rolável com o componente especificado, configuração

da barra de rolagem vertical e configuração da barra de rolagem horizontal. As barras de rolagem são configuradas por meio de variáveis de classe estáticas da interface

ScrollPaneConstants. É possível usar cada uma das seguintes barras de rolagem verticais: · VERTICAL_SCROLLBAR_ALWAYS · VERTICAL_SCROLLBAR_AS_NEEDED · VERTICAL_SCROLLBAR_NEVER

Há também três variáveis com nomes semelhantes para as barras de rolagem horizontais. Depois de criar um painel rolável contento um componente, o painel deverá ser acrescentado aos contêineres

no local desse componente. Exemplo: cria uma área de texto com uma barra de rolagem vertical e nenhuma barra de rolagem horizontal e

depois acrescenta a um painel de conteúdo. JPanel painel = new Panel( ); JTextArea texto = new JTextArea(5,15); JScrollPane rolagem = new JScrollPane(texto, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER); painel.add(rolagem); setContentPane(painel);


17

Exemplo 6: JScrollPane.

import javax.swing.*; import javax.swing.*; public class Logon2 extends javax.swing.JFrame { JTextField usuario = new JTextField(15); JPasswordField senha = new JPasswordField(15); JTextArea comentarios = new JTextArea(4, 15); JButton ok = new JButton("OK"); JButton cancelar = new JButton("Cancel"); public Logon2() { super("Logon"); setSize(200, 280); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); JLabel rotulousuario = new JLabel("Usuário: "); JLabel rotulosenha = new JLabel("Senha: "); JLabel rotulocomentarios = new JLabel("Comentários: "); comentarios.setLineWrap(true); comentarios.setWrapStyleWord(true); JScrollPane rolagem = new JScrollPane(comentarios, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER); painel.add(rotulousuario); painel.add(usuario); painel.add(rotulosenha); painel.add(senha); painel.add(rotulocomentarios); painel.add(rolagem); painel.add(ok); painel.add(cancelar); add(painel); setVisible(true); } public static void main(String[] arguments) { Logon2 log2 = new Logon2(); } }


18

JCheckBox - JRadioButton São componentes que possuem apenas dois valores possíveis: selecionado ou não-selecionado. As caixas de seleção normalmente são usadas para fazer escolhas simples em um programa, do tipo sim/não

ou ligado/desligado. Os botões de opção são agrupados juntos para que apenas um botão seja selecionado por vez. As caixas de seleção( a classe JCheckBox) aparecem como caixas rotuladas ou não-rotuladas, que contêm

uma marca de seleção quando são selecionadas e nada, em caso contrário. As classes JCheckBox e JRadioButton possuem vários métodos úteis, herdados de sua superclasse comum: · setSelect(boolean) – Seleciona o componente se o argumento for true e remove a seleção se for false. · isSelected( ) – Retorna um boolean indicando se o componente está atualmente selecionado. Os seguintes construtores estão disponíveis para a classe JCheckBox: · JCheckBox(Texto) – Uma caixa de seleção com o rótulo de texto especificado. · JCheckBox(Texto, boolean) – Uma caixa de seleção com o rótulo de texto especificado, que é selecionado

se o segundo argumento for true. · JCheckBox(Icon) – Uma caixa de seleção com o rótulo de ícone especificado. · JCheckBox(Icon, boolean) – Uma caixa de seleção com o rótulo de ícone especificado, que está

selecionado se o segundo argumento for true. · JCheckBox(Texto,Ícone) – Uma caixa de seleção com o rótulo de texto e rótulo de ícone especificados. · JCheckBox(Texto, Ícone, boolean) – Uma caixa de seleção com o rótulo de texto e o rótulo de ícone

especificados, selecionada se o terceiro argumento for true. A classe JRadionButton possui construtores com os mesmos argumentos e funcionalidade. As caixas de seleção e os botões de opção, por si sós, são não exclusivos. Para torná-los exclusivos, como os

botões de opção deveriam ser, precisamos organizar os componentes relacionados em grupos. Para tanto podemos criar um objeto da classe ButtonGroup.

Exemplo: ButtonGroup ch = new ButtonGroup( ); Chame o método add(Componente) do grupo para acrescentar o componente especificado ao grupo. Exemplo: ButtonGroup grupo = new ButtonGroup( ); JRadioButton s1 = new JRadion("F",true); grupo.add(s1); JRadioButton s2 = new JRadioButon("M", false); grupo.add(s2); O objeto grupo é usado para agrupar os botões de opção s1 e s2. O objeto s1, rotulado “F”, está selecionado.

Somente um membro do grupo pode ser relacionado de cada vez – se o componente está selecionado, o objeto ButtonGroup garante que todos os outros do grupo não estejam.


19

Exemplo 7: JRadioButton, ButtonGroup.

import javax.swing.*; public class Grupo extends JFrame { JRadioButton[] rb = new JRadioButton[4]; public Grupo() { super("Pesquisa"); setSize(200, 180); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); rb[0] = new JRadioButton("Época"); rb[1] = new JRadioButton("Veja"); rb[2] = new JRadioButton("Super Interessante"); rb[3] = new JRadioButton("Casa e Jardim", true); JPanel painel = new JPanel(); JLabel escolha = new JLabel("Escolha sua revista

preverida."); painel.add(escolha); ButtonGroup grupo = new ButtonGroup(); for (int i = 0; i < rb.length; i++) { grupo.add(rb[i]); painel.add(rb[i]); } add(painel); setVisible(true); } public static void main(String[] arguments) { Grupo g = new Grupo(); } }


20

JComboBox A classe JComboBox do Swing pode ser usada para criar caixas de combinação, componentes que

apresentam um menu drop-dwon a partir do qual um único valor pode ser selecionado. Ocultando-se o menu quando o componente não está sendo usado.

Caixa de combinação: 1. O construtor JComboBox( ) é usado sem argumentos. 2. O método addItem(Object) da caixa de combinação acrescenta itens à lista. Em uma caixa de combinação, os usuários poderão selecionar somente um dos itens do menu drop-down. Se

o método setEditable( ) do componente for chamado com true como argumento, ele também oferecerá suporte à entrada de texto.

Métodos: · getItemAt(int) – Retorna o texto do item de lista na posição de índice especificada pelo argumento inteiro.

Assim com os arrays, o primeiro item de uma lista de escolha está na posição de índice 0. · getItemCount( ) – Retorna o número de itens na lista. · getSelectedIndex( ) – Retorna a posição de índice do item atualmente selecionado na lista. · getSelectedItem( ) – Retorna o texto do item atualmente selecionado. · setSelectedIndex(int) – Seleciona o item na posição de índice indicada. · setSelectedIndex(Object) – Seleciona o objeto especificado na lista.


21

Exemplo 8: JComboBox.

import javax.swing.*; public class Combinacao extends JFrame { String[] opcoes = { "Época", "Veja", "Super Interessante",

"Casa e Jardim" }; JComboBox selecao = new JComboBox(); public Combinacao() { super("Pesquisa"); setSize(220, 150); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); JLabel escolha = new JLabel("Escolha sua revista:"); painel.add(escolha); for (int i = 0; i < opcoes.length; i++) selecao.addItem(opcoes[i]); painel.add(selecao); add(painel); setVisible(true); } public static void main(String[] arguments) { Combinacao c = new Combinacao(); } }


22

JList Utilizamos a classe JList, para permitir que um ou mais valores sejam selecionados em uma lista. As listas podem ser criadas e preenchidas com o conteúdo de um array ou de um vetor. Podemos utilizar os

seguintes construtores: · JList( ) – Cria uma lista vazia · JList(Object[]) – Cria uma lista que contém um array da classe especificada (como String) · JList(Vetor) – Cria uma lista que contém o objeto java.util.Vector especificado.

Métodos: · setListData( ) utilizado para preencher a lista. As listas exibem mais de uma de suas linhas quando são

apresentadas em uma interface com o usuário. · O padrão é exibir oito itens. Para alterar isso, chame setVisibleRowCount(int) com o número de itens a

serem exibidos. · getSelectValues( ) retorna um array de objetos que contém todos os itens selecionados na lista.


23

Exemplo 9: JList.

import javax.swing.*; public class Lista extends JFrame { String[] livros = { "A Mão e a Luva", "A Semana", "Balas de

Estalo", "Bons Dias", "Casa Velha", "Contos","Contos Fluminenses", "Crisálidas", "Dom Casmurro", "Esaú e Jacó" };

JList lista = new JList(livros); public Lista( ) { super("Livros"); setSize(150, 300); JPanel painel = new JPanel(); JLabel escolha = new JLabel("Selecione seu(s) livros:"); painel.add(escolha); lista.setVisibleRowCount(8); JScrollPane rolagem = new JScrollPane(lista); painel.add(rolagem); add(painel); setVisible(true); } public static void main(String[] arguments) { Lista list = new Lista(); } }


24

UIManager

O gerenciamento do estilo é tratado pelo UIManager, uma classe controladora da interface com o usuário do pacote javax.swing. As escolhas para o estilo variam, dependendo do ambiente de desenvolvimento Java usado. Os seguintes estilos estão disponíveis com a Java 2 em uma plataforma Windows: Estilo Windows, Estilo Windows Classic, Sistema Motif x Windows, Plataforma Java Swing, conhecida como Metal.

A classe UIManager possui um método setLookAndFeel(LookAndFeel), que é usado para escolher o estilo de um programa. Para obter um objeto LookAndFeel que você possa usar com setLookAndFeel( ), use um dos seguintes métodos:

· getCrossPlatformLookAndFeelClassName( ) – esse método retorna um objeto LookAndFeel representando o estilo Metal de plataforma cruzada da Java.

· getSystemLookAndFeelClassName( ) – Esse método retorna um objeto LookAndFeel representando o estilo do sistema corrente.

O método setLookAndFeel( ) lança uma exceção UnsupportedLookAndFeelException se não puder definir o estilo.

Depois de chamar esse método é necessário atualizar a interface com a nova aparência chame o método updateComponentTreeUI(Componente) da classe SwingUtilities com o componente da interface principal.

Sob a maior parte das circunstâncias, devemos chamar setLookAndFeel( ) apenas depois que cada componente tiver sido acrescentado à sua interface gráfica com o usuário (em outras palavras, imediatamente antes de tornar a interface visível).

As instruções a seguir montam um componente para empregar o estilo Java: try { UIManager.setLookAndFeel( UIManager.getCrossPlatformLookAndFeelClassName( )); SwingUtilities.updateComponenteTreeUI(this); } catch (Exception e) { System.out.println(“Can’t set look and feel: “ ”+e.getMessage( ))

e.printStackTrace( ); } A palavra-chave this refere-se à classe que contém essas instruções. Se você a usar no final do método

construtor de um JFrame, cada componente desse frame seria exibido com o estilo Java. Linha de código para visualização dos estilos: UIManger.LookAndFeelInfo[] laf = UIManager.getInstalledLookAndFeel( ); for (int i = 0; i < laf.length;i++) { System.out.println(“Class name:”+laf[i].getClassName( )); System.out.printl (“Name:”=laf[i].getName( )+”\n”); } Em um ambiente Windows, essas instruções produzem a seguinte saída: Name: Metal Class name: javax.swing.plaf.metal.MetalLookAndFell Name: CDE:Motif Class name: javax.swing.plaf.motif.MotiflLookAndFell Name: Windows Class name: javax.swing.plaf.windows.WindowsLookAndFell Name: Windows Classic Class name: javax.swing.plaf.windows.WindowsClassicLookAndFell


25

JOptionPane

A classe JOptionPane oferece vários métodos que podem ser usados para criar caixas de diálogos padrão.

As quatro caixas de diálogo padrão são os seguintes: · ConfirmDialog – Faz uma pergunta, com botões para respostas Yes/No/Cancel. · InputDialog – Pedidos de entrado de texto. · MessageDialog –Apresenta uma mensagem. · OptionDialog – Compreende todos os três outros tipos de caixa de diálogo. Se configurarmos um estilo para usar com qualquer uma dessas caixas, deveremos estabelecer antes que a

mesma seja aberta. CAIXAS DE DIÁLOGO DE CONFIRMAÇÃO

Podemos utilizar o método showConfirmDialog(Componente, Objeto). O argumento Componente especifica o contêiner que deve ser considerado o pai da caixa de diálogo, e essa informação é usada para determinar onde a janela de diálogo deverá ser exibida na tela. Se null for usado no lugar de um contêiner, ou se o contêiner não for um objeto JFrame, a caixa de diálogo será centralizada na tela.

O segundo argumento, Object, pode ser uma string, um componente ou um objeto Icon. Se for uma string, esse texto será exibido na caixa de diálogo. Se for um componente ou um Icon, esse objeto será exibido no lugar de uma mensagem de texto.

Esse método retorna um de três valores inteiros possíveis, cada um sendo uma constante de classe de JOptionPane: YES_OPTION, NO_OPTION e CANCEL_OPTION.

Exemplo: int resposta; resposta = JOptionPane.showConfirmDialog(null, “Você quer apagar todos os seus arquivos?”); Podemos utilizar showConfirmDialog(Componente, Objeto, String, int, int). Os três últimos argumentos são

os seguintes: · Uma string que será exibida na barra de título da caixa de diálogo. · Um inteiro que indica quais botões de opção serão mostrados, ele deverá ser igual a uma das constantes

de classe: YES_NO_CANCEL_OPTION ou YES_NO_OPTION. · Um inteiro que descreve o tipo de caixa de diálogo em que se encontra, usando as constantes de classe,

ERROR_MESSAGE, INFORMATION_MESSAGE, PLAIN_MESSAGE, QUESTION_MESSAGE, ou WARNING_MESSAGE. Serve para determinar que ícone deve ser desenhado na caixa de diálogo, junto com a mensagem.

Por exemplo: int resposta = JOptionPane.showConfirmDialog(null, “Erro ao ler o arquivo, gostaria de tentar novamente?”, “Erro de leitura”, JOptionPane.YES_NO_OPTION, JOptionPane.ERROR_MESSAGE);

CAIXAS DE DIÁLOGO DE ENTRADA

Uma caixa de diálogo de entrada faz uma pergunta e usa um campo de texto para armazenar a resposta.

O modo mais fácil de criar uma caixa de diálogo de entrada é com uma chamada ao método showInputDialog(Componente, Objeto). Os argumentos são o componente pai e a string, o componente ou o ícone a exibir a caixa.

A chamada de método da caixa de diálogo de entrada retorna uma string que representa a resposta do usuário.

Exemplo: String resposta = JOptionPane.showInputDialog(null, “Entre com o seu nome:”);


26

Podemos criar uma caixa de diálogo de entrada com o método showInputDialog (Componente, Objeto, String, int). Os dois últimos argumentos são:

· O título a exibir na barra de título da caixa de diálogo. · Uma das cinco constantes de classe descrevendo o tipo de caixa de diálogo: ERROR_MESSAGE,

INFORMATION_MESSAGE, PLAIN_MESSAGE, QUESTION_MESSAGE, ou WARNING_MESSAGE.

Exemplo: String resposta = JOptionPane.showInputDialog(null, “Qual é o seu CEP?”, “Entre com o CEP”, JOptionPane.QUESTION_MESSAGE);

CAIXAS DE DIÁLOGO DE MENSAGEM

É uma janela simples, que mostra informações para tanto invocamos o método showMessageDialog

(Componente, Objeto). Exemplo: JOptionPane.showMessageDialog(null, “O programa foi desinstalado”); Podemos utilizar também o método showMessageDialog (Componente, Objeto, String, int). Exemplo: JOptionPane.showMessageDialog(null, “Um asteróide irá destruir a Terra.”, “Alerta de destruição”, JOptionPane.WARNING_MESSAGE);

CAIXAS DE DIÁLOGO DE OPÇÃO É a mais completa, pode ser criada através do método showOptionDialog(Componente, Objeto, String, int,

int, Icon, Object[], Object). Os argumentos desse método são os seguintes: · O componente pai da caixa de diálogo. · O texto, ícone ou componente a exibir. · Uma string para exibir na barra de títulos. · O tipo de caixa, usando as constantes de classe YES_NO_OPTION ou YES_NO_CANCEL_OPTION, ou a

literal 0 se outros botões forem usados em vez disso. · O ícone a exibir, usando as constantes de classe ERROR_MESSAGE, INFORMATION_MESSAGE,

PLAIN_MESSAGE, QUESTION_MESSAGE ou WARNING_MESSAGE, ou a literal 0, se nenhum desses tiver de ser usado.

· Um objeto Icon para exibir no lugar de um dos ícones no argumento anterior. · Um array de objetos mantendo os componentes ou outros objetos que representam as opções na caixa de

diálogo, se YES_NO_OPTION e YES_NO_CANCEL_OPTION não estiverem sendo usados. · O objeto representando a seleção padrão, se as opções YES_NO_OPTION e YES_NO_CANCEL não

estiverem sendo usadas. Os dois últimos argumentos permitem criar uma grande variedade de opções para caixa de diálogo. Podemos

criar um array de strings que mantenha o texto de cada botão para exibir na caixa de diálogo. Exemplo: String[] sexo = {“Masculino”, “Feminino”}; int resposta = JOptionPane.showOptionDialog(null, “Qual é o seu sexo?”, “Sexo?”, 0,

JOptionPane.INFORMATION_MESSAGE, null, sexo, sexo[1]);


27

Exemplo 10: JOptionPane, UIManager.

import java.awt.GridLayout; import java.awt.event.*; import javax.swing.*; public class Caixas extends JFrame { private JLabel rotulonome = new JLabel("Nome: ",

SwingConstants.RIGHT); private JTextField nome; private JLabel rotulorevista = new JLabel("Revista: ",

SwingConstants.RIGHT); private JTextField revista; private JLabel rotuloavaliacao = new JLabel("Avaliação: ",

SwingConstants.RIGHT); private JTextField avaliacao; public Caixas() { super("Pesquisa"); setSize(280, 105); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLookAndFeel(); String resp1 = JOptionPane.showInputDialog(null,"Digite seu

nome:"); nome = new JTextField(resp1, 20); String resp2 = JOptionPane.showInputDialog(null, "Digite o

nome de sua revista preferida:"); revista = new JTextField(resp2, 20); String[] notas = { "0-3", "3-6", "6-10" }; int resp3 = JOptionPane.showOptionDialog(null, "Qual é sua

avaliação sobre esta revista?", "Avaliação", 0,


28

JOptionPane.QUESTION_MESSAGE, null, notas, notas[0]); // designa o primeiro elemento do array como

seleção padrão da caixa de diálogo avaliacao = new JTextField(notas[resp3], 20); setLayout(new GridLayout(3, 2,10,1)); add(rotulonome); add(nome); add(rotulorevista); add(revista); add(rotuloavaliacao); add(avaliacao); setLookAndFeel(); setVisible(true); } private void setLookAndFeel() { try { UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName()); SwingUtilities.updateComponentTreeUI(this); } catch (Exception e) { System.err.println("Couldn't use the system " + "look and feel: " + e); } } public static void main(String[] arguments) { Caixas frame = new Caixas(); } }


29

Extra: JOptionPane

import javax.swing.JOptionPane; public class Dialogos{

public static void main(String args[]){ String tituloDialogo = "Título da caixa de Diálogo"; String msg = "Mensagem"; JOptionPane.showMessageDialog(null,msg); JOptionPane.showMessageDialog(null,msg,tituloDialogo,JOptionPane.PL

AIN_MESSAGE); JOptionPane.showMessageDialog(null,msg,

tituloDialogo,JOptionPane.INFORMATION_MESSAGE); JOptionPane.showMessageDialog(null,msg,

tituloDialogo,JOptionPane.WARNING_MESSAGE); JOptionPane.showMessageDialog(null,msg,

tituloDialogo,JOptionPane.ERROR_MESSAGE); msg = "Você gosta de Java"; Object [] opcoes = {"Sim","Não","Mais ou Menos"}; int resp = JOptionPane.showOptionDialog (null,msg,"Pergunta",

JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE,null,opcoes,opcoes[2]);

System.out.println("Resposta:"+opcoes[resp].toString()); String nome = JOptionPane.showInputDialog("Digite o seu

nome:"); System.out.println("nome:"+nome); System.exit(0); } }


30

JSlider São implementados com a classe JSlider, permitem que o usuário defina um número deslizando um controle

dentro do intervalo de um valor mínimo e máximo. Em muitos casos, um controle deslizante pode ser usado para a entrada numérica em vez de um campo de texto e tem a vantagem de restringir a entrada a um intervalo de valores aceitáveis.

Os controles deslizantes são horizontais por padrão. A orientação pode ser definida explicitamente usando duas constantes de classe da interface SwingConstants: HORIZONTAL ou VERTICAL.

Podemos utilizar um dos seguintes métodos construtores: · JSlider(int, int) – Um controle deslizante com valores mínimos e máximo especificados. · JSlider(int, int, int) – Um controle deslizante com mínimo, máximo e inicial especificados. · JSlider(int, int, int, int) – Um controle deslizante com orientação, valor mínimo, valor máximo e valor

inicial especificados. Os componentes de controle deslizante possuem um rótulo opcional que pode ser usado para indicar o valor

mínimo, valor máximo e dois conjuntos diferentes de marcas de tique variando entre os valores. Os valores padrão são um mínimo de 0, máximo de 100, valor inicial de 50 e orientação horizontal.

Os elementos desse rótulo são estabelecidos chamado vários métodos de JSlider: · setMajorTickSpacing(int) – Esse método separa as marcas de tique principais pela distância

especificada. A distância não está em pixels, mas em valores entre os valores mínimos e máximo representados pelo controle deslizante.

· setMinorTickSpacing(int) – Esse método separa as marcas de tique secundárias pela distância especificada. As marcas de tique secundárias aparecem como metade do tamanho das marcas principais.

· setPaintTicks(boolean) – Esse método determina se as marcas de tique tiverem de ser exibidas (um argumento true) ou não (um argumento false).

· setPaintLabels(boolean) – Esse método determina se o rótulo numérico do controle deslizante deve ser exibido (ter) ou não (false).

Esses métodos devem ser chamados no controle deslizante antes que sejam acrescentados a um contêiner.


31

Exemplo 11: JSlider.

import javax.swing.*; public class Video extends JFrame { public Video() { super("Vídeo"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JSlider barra = new JSlider(JSlider.HORIZONTAL, 1, 10, 1); barra.setMajorTickSpacing(2); barra.setMinorTickSpacing(1); barra.setPaintTicks(true); barra.setPaintLabels(true); add(barra); } public static void main(String[] args) { Video vid = new Video(); vid.pack(); vid.setVisible(true); } }


32

JScrollPane Aparecem quando o texto no componente ocupa mais espaço do que este poderia exibir. As barras de rolagem poderiam ser usadas na direção vertical ou horizontal para rolar pelo texto. Para que um componente possa rolar, ele precisa ser acrescentado a um contêiner JScrollPane. Esse contêiner JScrollPane é acrescentado a um contêiner no lugar do componente rolável. Os painéis de rolagem podem ser criados usando o construtor JScrollPane(Objeto), onde o objeto representa o componente que pode ser rolado. Exemplo: Cria uma área de texto em um painel de rolagem e acrescenta o painel de rolagem, scroller, a um contêiner chamado mainPane: textBox = new JTextArea(7, 30); JScrollPane scroller = new JScrollPane(textBox); mainPane.add(scroller); Enquanto trabalhamos com painéis pode ser útil indicar o tamanho que gostaríamos que eles ocupassem na interface. Isso é feito chamando o método setPreferredSize(Dimension) do painel de rolagem antes de ser acrescentado a um contêiner. O objeto Dimension representa a largura e altura do tamanho predefinido, representado em pixels. Exemplo: Definindo o tamanho Dimension pref = new Dimension(350,100); scroller.setPreferredSize(pref); Isso deverá ser tratado antes que scroller seja acrescentado a um contêiner.

Por padrão, um painel de rolagem não apresenta barra de rolagem, a menos que sejam necessárias. Se o componente dentro do painel não for maior do que o próprio painel, as barras não aparecerão. No caso de componentes como áreas de texto, onde o tamanho do componente pode aumentar enquanto o programa é usado, as barras aparecem automaticamente quando são necessárias e desaparecem quando não são.

Para redefinir esse comportamento podemos definir uma política para um componente JScrollBar quando ele for criado. Para tanto podemos utilizar as seguintes constantes da classe SrcollPaneConstants:

· HORIZONTAL_SCROLLBAR_ALWAYS · HORIZONTAL_SCROLLBAR_AS_NEEDED · HORIZONTAL_SCROLLBAR_NEVER · VERTICAL_SCROLLBAR_ALWAYS · VERTICAL_SCROLLBAR_AS_NEEDED · VERTICAL_SCROLLBAR_NEVER Essas constantes de classe são usadas com o construtor JScrollPane(Objeto, int, int), que especifica o

componente no painel, a política da barra de rolagem vertical e a política da barra de rolagem horizontal.

JToolBar Uma barra de ferramentas é um contêiner da classe JToolBar que agrupa vários componentes em um linha ou coluna. Esses componentes normalmente são botões. As barras de ferramentas são linhas ou colunas de componentes que agrupam as opções de programa mais comumente usadas. As barras de ferramentas muitas vezes contêm botões e listas e podem ser usadas como alternativa para o uso de menus pull-down ou teclas de atalho. As barras de ferramentas são horizontais por padrão, mas a orientação é definida explicitamente com as variáveis de classe HORIZONTAL ou VERTICAL da interface SwingConstants. Os métodos construtores incluem o seguinte:

· JToolBar( ) – Cria uma nova barra de ferramentas. · JToolBar(int) – Cria uma nova barra de ferramentas com a orientação especificada. Quando criamos uma barra de ferramentas podemos acrescentar componentes a ela, usando o método

add(Objeto) da barra de ferramentas.


33

Muitos programas que usam barras de ferramentas permitem que o usuário mova as barras. Essas são chamadas barra de ferramentas encaixáveis, pois podemos encaixá-las nas bordas da tela. As barras de ferramentas do Swing também podem ser encaixadas em uma nova janela, separada da original.

Para obter melhores resultados, um componente JToolBar encaixável deve ser arrumado em um contêiner usando o gerenciador BorderLayout. Um layout de borda divide um contêiner em cinco áreas: norte, sul, leste, oeste e centro. Cada um dos componentes direcionais ocupa o espaço que ele precisar, e o restante é alocado ao centro.

A barra de ferramentas deverá ser alocada em uma das áreas direcionais do layout de borda. A única outra área do layout que pode ser preenchida é o centro.


34

Exemplo 12: JToolBar.

import java.awt.*; import javax.swing.*; public class Barra extends JFrame { public Barra() { super("Barra de Ferramentas"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ImageIcon iconenovo = new ImageIcon("c:\\Ícones\\novo.png"); ImageIcon iconesalvar = new ImageIcon("c:\\Ícones\\disk.png"); ImageIcon iconejustificado = new

ImageIcon("c:\\Ícones\\text_align_justify.png"); ImageIcon iconeesquerda = new

ImageIcon("c:\\Ícones\\text_align_left.png"); ImageIcon iconedireita = new

ImageIcon("c:\\Ícones\\text_align_right.png"); JButton novo = new JButton(iconenovo); JButton salvar = new JButton(iconesalvar); JButton justificado = new JButton(iconejustificado); JButton esquerda = new JButton(iconeesquerda); JButton direita = new JButton(iconedireita); JToolBar bar = new JToolBar(); bar.add(novo); bar.add(salvar); bar.add(justificado); bar.add(esquerda); bar.add(direita); JTextArea area = new JTextArea(8, 40); JScrollPane rolagem = new JScrollPane(area); BorderLayout borda = new BorderLayout(); setLayout(borda); add("North", bar); add("Center", rolagem); pack(); setVisible(true); } public static void main(String[] arguments) { Barra barra = new Barra(); } }


35

JProgressBar São componentes usados para mostrar quanto tempo falta para a conclusão de uma tarefa. São implementadas através da classe JProgressBar. As barras de progresso são usadas para rastrear o progresso de uma tarefa que pode ser representada numericamente. Elas são criadas especificando um valor mínimo e um máximo, que representam os pontos em que a tarefa está começando e terminando.

Uma instalação de software que consiste em 355 arquivos diferentes é um bom exemplo de uma tarefa que pode ser quantificada numericamente. O número de arquivos transferidos pode ser usado para monitorar o progresso da tarefa. O valor mínimo é 0 e o valor máximo é 355.

Os métodos construtores incluem os seguintes: · JProgressBar( ) – Cria uma nova barra de progresso · JProgressBar(int, int) – Cria uma nova barra de progresso com valores mínimos e máximo

especificados · JProgressBar(int, int, int) – Cria uma nova barra de progresso com a orientação, valores mínimos e

máximos especificados. A orientação de uma barra de progresso pode ser estabelecida com as constantes de classe

SwingConstants.VERTICAL e SwingConstants.HORIZONTAL. As barras de progresso são horizontais por padrão.

Os valores mínimo e máximo também podem ser configurados chamando-se os valores setMinimum(int) e setMaximum(int) da barra de progresso com os valores indicados.

Para atualizar uma barra de progresso, chamamos o método setValue(int) com um valor indicando em que ponto a tarefa se encontra no momento. Esse valor deverá ser algo entre os valores mínimo e máximo estabelecidos pela barra.

Exemplo: Apresenta uma barra de progresso install, do exemplo de instalação de software, quantos arquivos tiveram upload até aqui:

int filesDone = getNumber0Files( ) representa algum código que poderia ser usado para registrar quantos arquivos foram copiados até aqui durante a instalação.

Quando esse valor é passado para a barra de progresso pelo método setValue( ), a barra é atualizada imediatamente para representar a porcentagem que foi completada.

As barras de progresso normalmente incluem um rótulo de texto além do gráfico de um caixa vazia sendo preenchida. Esse rótulo apresenta a porcentagem da tarefa que foi completada, e podemos configurá-lo para uma barra chamando o método setStringPainted(boolean) com um valor true.


36

Exemplo 13: JProgessBar.

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Progresso extends JFrame { JProgressBar barra; Thread runner; int num = 0; public Progresso() { setTitle("Progresso"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new FlowLayout()); barra = new JProgressBar(0, 2000); // Valor mínimo e máximo barra.setValue(0); barra.setStringPainted(true); add(barra); pack(); setVisible(true); } public void evolucao() { //se repete enqto num é menor que 2000

e aumenta em 95 a cada iteração while (num < 2000) { barra.setValue(num); // faz com que a barra use o valor

ao desenhar o progresso. try { Thread.sleep(1000); } catch (InterruptedException e) { } num += 95; } } public static void main(String args[]) { Progresso prog = new Progresso(); prog.evolucao(); } }


37

JMenuBar - JMenu - JMenuItem Os menus normalmente duplicam as mesmas tarefas que poderíamos realizar utilizando botões e outros

componentes da interface com o usuário, oferecendo duas maneiras de realizar o mesmo trabalho. Os menus em Java são aceitos por três componentes que trabalham em conjunto um com o outro: · JMenuItem – Um item em um menu · JMenu – Um menu drop-down que contém um ou mais componentes JMenuItem, outros componentes

de interface e separadores. · JMenuBar – Um contêiner que mantém um ou mais componentes JMenu e apresenta seus nomes. Um componente JMenuItem é como um botão que pode ser configurado por meio de métodos construtores,

como um componente JButton. Chame-o com JMenuItem(String) para o item de texto, JMenuItem(Icon) para um item que mostra um arquivo gráfico ou JMenuItem(String, Icon) para ambos.

As instruções a seguir criam sete itens de menu: JMenuItem j1 = new JMenuItem(“Open”); JMenuItem j2 = new JMenuItem(“Save”); JMenuItem j3 = new JMenuItem(“Save as Template”); JMenuItem j4 = new JMenuItem(“Page Setup”); JMenuItem j5 = new JMenuItem(“Print”); JMenuItem j6 = new JMenuItem(“Use as Default Message Style”); JMenuItem j7 = new JMenuItem(“Close”); Um contêiner JMenu mantém todos os itens de menu para um menu drop-down. Para criá-lo, chame o

construtor JMenu(String) com o nome do argumento. Esse nome aparecerá na barra de menus. Depois de criar um contêiner JMenu, chame seu método add(JMenuItem) para acrescentar um item de menu

a ele. Novos itens são colocados no final do menu. O item colocado em um menu não precisa ser um item de menu. Chame o método add(Componente) com

um componente da interface com o usuário como argumento. Um que normalmente aparece em um menu é uma caixa de seleção (a classe JCheckBox em Java).

Para acrescentar um separador de linha ao final do menu, chame o método addSeparator( ). Os separadores normalmente são usados para agrupar vários itens relacionados visualmente em um menu.

Exemplo: JMenu m1 = new JMenu(“File”); m1.add(j1); m1.add(j2); m1.add(j3); m1.addSeparator( ); m1.add(j4); m1.add(j5); m1.addSeparator( ); m1.add(j6); m1.addSeparator( ); m1.add(j7); Um contêiner JMenuBar mantém um ou mais contêineres JMenu. Para criar uma barra de menus, chame o

método construtor JMenuBar( ) sem argumentos. Acrescente menus ao final de uma barra chamando seu método add(JMenu).

Depois de criar todos os itens, acrescentá-los aos menus e os menus a uma barra, estaremos prontos para incluí-los a um frame. Chame o método setJMenuBar(JMenuBar) do frame.

Exemplo: JMenuBar bar = new JMenuBar( ); bar.add(m7); gui.setJMenuBar(bar);


38

Exemplo 14: JMenuBar, JMenu, JMenuItem.

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Menus extends JFrame { public Menus() { super("Menus"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ImageIcon iconenovo = new

ImageIcon("c:\\Ícones\\novo.png"); ImageIcon iconeabrir = new

ImageIcon("c:\\Ícones\\abrir.png"); ImageIcon iconesalvar = new

ImageIcon("c:\\Ícones\\salvar.png"); ImageIcon iconesalvarcomo = new

ImageIcon("c:\\Ícones\\salvarcomo.png"); JButton novo = new JButton("Novo", iconenovo); JButton abrir = new JButton("Abrir", iconeabrir); JButton salvar = new JButton("Salvar", iconesalvar); JButton salvarcomo = new JButton("Salvar Como",

iconesalvarcomo); JToolBar bar = new JToolBar(); bar.add(novo); bar.add(abrir); bar.add(salvar); bar.add(salvarcomo); JMenuItem j1 = new JMenuItem("Novo"); JMenuItem j2 = new JMenuItem("Abrir"); JMenuItem j3 = new JMenuItem("Salvar"); JMenuItem j4 = new JMenuItem("Salvar como"); JMenuBar menubar = new JMenuBar(); JMenu menu = new JMenu("Arquivo"); menu.add(j1); menu.add(j2); menu.addSeparator(); menu.add(j3); menu.add(j4); menubar.add(menu); JTextArea edit = new JTextArea(8, 40);


39

JScrollPane scroll = new JScrollPane(edit); BorderLayout borda = new BorderLayout(); setLayout(borda); add("North", bar); add("Center", scroll); setJMenuBar(menubar); pack(); setVisible(true); } public static void main(String[] arguments) { Menus men = new Menus(); } }


40

Extra: JMenuBar, JMenu, JMenuItem

import javax.swing.*; import java.awt.*; import java.awt.event.*; public class Menu{ public static void main(String args[]){ JFrame f1 = new JFrame ("Menu"); f1.setSize(500,400); JMenu sm = new JMenu("Novo"); sm.add(new JMenuItem("Texto")); sm.add(new JMenuItem("Dados")); JMenu m1 = new JMenu("Arquivo"); m1.setMnemonic(KeyEvent.VK_A); m1.add(sm); m1.add(new JMenuItem("Abrir...")); m1.add(new JMenuItem("Salvar")); m1.add(new JMenuItem("Salvar como...")); m1.add(new JMenuItem("Fechar")); m1.addSeparator(); m1.add(new JMenuItem("Sair")); JMenu m2 = new JMenu("Exibir"); m2.setMnemonic(KeyEvent.VK_E); m2.add(new JCheckBoxMenuItem("Ferramenta Gráfica", true)); m2.add(new JCheckBoxMenuItem("Ferramenta Matemática")); JMenu m3 = new JMenu("Ajuda"); m3.setMnemonic(KeyEvent.VK_J); m3.add(new JMenuItem("Sobre...")); JMenuBar mp = new JMenuBar(); mp.add(m1); mp.add(m2); mp.add(m3); f1.setJMenuBar(mp); f1.setVisible(true); f1.addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0); } } ); } }


41

JTabbedPane São implementados pela classe JTabbedPane. As guias podem ser organizadas horizontalmente, na parte

inferior do componente, ou verticalmente, ao longo do lado esquerdo ou direito. Os painéis com guias são criados com os três métodos construtores a seguir: · JTabbedPane( ) – Cria um painel vertical com guias no alto, sem rolagem. · JTabbedPane(int) – Cria um painel com guias, sem rolagem e com posicionamento especificado. · JTabbedPane(int, int) – Cria um painel com guias, com o posicionamento especificado (primeiro

argumento) e política de rolagem (segundo argumento). Utilizamos os argumentos: JTabbedPane.TOP, JTabbedPane.BOTTOM, JTabbedPane.LEFT ou

JTabbedPane.RIGHT. A política de rolagem determina como as guias serão exibidas quando houver mais guias do que a

interface pode conter. Um painel com guias que não rola apresenta guias extras em sua própria linha, que pode ser configurada por meio da variável de classe JTabbed.WRAP_TAB_LAYOUT. Um painel em guias que rola apresenta setas de rolagem ao lado das guias. Isso pode ser configurado com JTabbedPane.SCROLL_TAB_LAYOUT.

Depois de cria um painel com guias, poderemos acrescentar componentes a ele, chamando o método addTab(String, Componente) do painel. O argumento String será utilizado como rótulo da guia. O segundo argumento é o componente que comporá uma das guias no painel. È comum utilizar um objeto JPanel para essa finalidade, mas não é obrigatório.

Exemplo: As instruções a seguir criam cinco painéis e os acrescentam a um painel com guias: JPanel mainSettings = new JPanel( ); JPanel advancedSettings = new JPanel( ); JPanel privacySettings = new JPanel( ); JPanel emailSettings = new JPanel( ); JPanel securitySettings = new JPanel( ); JTabbedPane tabs = new JTabbedPane( ); tabs.addTab(“Main”, mainSettings); tabs.addTab(“Advanced”, advancedSettings); tabs.addTab(“Privacy”, privacySettings); tabs.addTab(“E-mail”, emailSettings); tabs.addTab(“Security”, securitySettings); Depois de acrescentar todos os painéis e outros componentes a um painel com guias, o painel pode

ser acrescentado a outro contêiner.


42

Exemplo 15: JTabbedPane.

import java.awt.*; import javax.swing.*; import java.awt.event.*; public class Guias extends JFrame { JTabbedPane guias = new JTabbedPane(SwingConstants.BOTTOM); Painelcadastro cad = new Painelcadastro(); Painelconsulta con = new Painelconsulta(); public Guias() { setTitle("Gestão de Recursos Humanos"); setSize(650,300); guias.setTabPlacement(JTabbedPane.TOP); // local das orelhas guias.add(cad, "CADASTRO"); // adiciona o painel na orelha

CADASTRO guias.add(con, "CONSULTA"); // adiciona o painel na orelha

CADASTRO setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); this.getContentPane().add(guias); } public static void main(String[] args) { Guias g = new Guias(); } public class Painelcadastro extends JPanel{ JLabel rotulonome = new JLabel("Nome", SwingConstants.LEFT); JTextField camponome = new JTextField(40); String[] opcoes = { "Médico", "Professor", "Engenheiro",

"Outros" }; JLabel escolha = new JLabel("Escolha sua profissão:"); JComboBox selecao = new JComboBox(); public Painelcadastro(){ JPanel p1 = new JPanel(); p1.add(rotulonome); p1.add(camponome); p1.add(escolha); for (int i = 0; i < opcoes.length; i++) selecao.addItem(opcoes[i]); p1.add(selecao); p1.setLayout(new GridLayout(2,2,-300,1)); add(p1);


43

setVisible(true); } } public class Painelconsulta extends JPanel{ JLabel rotulonome = new JLabel("Nome", SwingConstants.LEFT); JTextField camponome = new JTextField(40); public Painelconsulta(){ JPanel p1 = new JPanel(); p1.add(rotulonome); p1.add(camponome); add(p1); setVisible(true); } } }

Exercício 15:

1) Crie as classes Painelcadastro e Painelconsulta no pacote. Observe que estas classes não contém um método principal.

2) Acrescene mais componentes as classes Painelcadastro e Painelconsulta.


44

PARTE 2 - LAYOUT


45

Gerenciadores de Layout Podemos utilizar os gerenciadores de layout que organizam como os componentes serão organizados quando

são incluídos em um contêiner. O gerenciador de layout padrão para painéis é a classe FlowLayout. Essa classe permite que os

componentes fluam da esquerda para a direita na ordem em que são acrescentados a um contêiner. Quando não houver mais espaço, uma nova fileira de componentes começa imediatamente abaixo da primeira.

Java inclui vários gerenciadores de layout para diversos propósitos: BorderLayout, BoxLayout, CardLayout, FlowLayout e GridBagLayout. Para criar um gerenciador de layout para um contêiner, chame o construtor do gerenciador de layout, como o exemplo a seguir:

FlowLayout flo = new FlowLayout( ); Depois de criar um gerenciador de layout, tornamos o gerenciador de layout para um contêiner usando o

método setLayout( ). O gerenciador de layout precisa ser estabelecido antes que qualquer componente seja adicionado ao contêiner. Se o gerenciador de layout não for especificado, seu layout padrão será usado – FlowLayout para painéis e BorderLayout para frames e janelas.

Exemplo: import java.awt.*; public class Layout extends javax.swing.JFrame; public Layout( ){ FlowLayout fl = new FlowLayout( ); setLayout(fl); // adição dos componentes }}

FLOWLAYOUT Dispõe os componentes de uma forma semelhante ao modo como as palavras são dispostas em uma

página- da esquerda para a direita até que não haja mais espaço, e depois na linha seguinte. Por padrão, os componentes em cada linha serão centralizados quando você usa o construtor FlowLayout(

) sem argumentos. Se quisermos que os componentes sejam ALINHADOS na margem esquerda ou direita do contêiner, a variável FlowLayout.LEFT ou FlowLayout.RIGHT deverá ser o único argumento do construtor, como na instrução abaixo:

FlowLayout right = new FlowLayout(FlowLayout.RIGHT); A variável de classe FlowLayout.CENTER é usada para especificar componentes centralizados.


46

Exemplo 1: FlowLayout

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Nomes extends JFrame { JButton a = new JButton("Amanda"); JButton b = new JButton("Bianca"); JButton c = new JButton("Carla"); JButton d = new JButton("Débora"); JButton e = new JButton("Eveline"); JButton f = new JButton("Fabiane"); public Nomes() { super("Nomes"); setSize(360, 120); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); FlowLayout lm = new FlowLayout(FlowLayout.LEFT); setLayout(lm); add(a); add(b); add(c); add(d); add(e); add(f); setVisible(true); } public static void main(String[] arguments) { Nomes n = new Nomes(); } }


47

O gerenciador de layout acima utiliza o INTERVALO de cinco pixels entre cada componente em uma fileira e um intervalo de cinco pixels entre cada linha. Podemos mudar o intervalo horizontal e vertical entre componentes com alguns argumentos extras ao construtor FlowLayout( ). O construtor FlowLayout(int, int, int) utiliza os três argumentos a seguir, em ordem:

· O alinhamento, que precisa ser FlowLayout.CENTER, FlowLayout.LEFT ou FlowLayout.RIGHT · O intervalo horizontal entre componentes, em pixels. · O intervalo vertical, em pixels. Exemplo: gerenciador de fluxo com componentes centralizados, um intervalo horizontal de 30 pixels e um

intervalo vertical de 10 pixels. FlowLayout flo = new FlowLayout(FlowLayout.CENTER, 30, 10);

BOXLAYOUT Pode ser utilizado para empilhar componentes de cima para baixo ou da esquerda para a direita. O layout

de caixa, gerenciado pela classe BoxLayout no pacote javax.swing, especializa o layout de fluxo CERTIFICANDO-SE de que os componentes sempre se alinham vertical ou horizontalmente – independente de como o contêiner é redimensionado.

Um gerenciador de layout de caixa deve ser criado com dois argumentos para seu construtor: o contêiner que gerenciará e a variável de classe que estabelece o alinhamento vertical ou horizontal.

O alinhamento, especificada com uma variável da classe BoxLayout, pode ser X_AXIS para alinhamento horizontal da esquerda para a direita e Y_AXIS para alinhamento vertical de cima para baixo.

O código a seguir configura um painel para uso do layout de caixa vertical: JPanel optionPane = new JPanel( ); BoxLayout box = new BoxLayout(optionPane, BoxLayout.Y_AXIS); Os componentes adicionados ao contêiner se alinharão com o eixo especificado e serão exibidos em seus

tamanhos preferidos. No alinhamento horizontal, o gerenciador do layout de caixa tenta deixar todos os componentes com a mesma altura. No alinhamento vertical, ele procura usar a mesma largura para todos.


48

Exemplo 2: BoxLayout.

import java.awt.*; import javax.swing.*; public class LayoutCaixa extends JFrame { public LayoutCaixa() { super("BoxLayout"); setSize(500,245); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); BoxLayout horizontal = new BoxLayout(painel,

BoxLayout.X_AXIS); painel.setLayout(horizontal); JButton novo = new JButton("Novo"); JButton abrir = new JButton("Abrir"); JButton salvar = new JButton("Salvar"); JButton salvarcomo = new JButton("Salvar Como"); painel.add(novo); painel.add(abrir); painel.add(salvar); painel.add(salvarcomo); JTextArea area = new JTextArea(10, 43); JScrollPane rolagem = new JScrollPane(area); FlowLayout fluxo = new FlowLayout(); setLayout(fluxo); add(painel); add("SOUTH",rolagem); setVisible(true); } public static void main(String args[]) { LayoutCaixa caixa = new LayoutCaixa(); } }


49

GRIDLAYOUT Este gerenciador arruma os componentes em uma grade de linhas e colunas. Os componentes são

acrescentados primeiro na fileira superior da grade, começando com a célula mais à esquerda e continuando para a direita. Quando todas as células na fileira de cima estiverem completas, o próximo componente será acrescentado à célula mais à esquerda na segunda fileira da grade – se houver uma segunda linha – e assim por diante.

Os layouts de grade são criados com a classe GridLayout. Dois argumentos são enviados ao construtor GridLayout – o número de linhas na grade e o número de colunas. A instrução a seguir cria um gerenciador de layout de grade com 10 linhas e 3 colunas:

GridLayout gr = new GridLayout(10, 3); Assim como no layout de fluxo, podemos especificar um intervalo vertical e horizontal entre componentes

com dois argumentos extras. A instrução a seguir cria um layout de grade com 10 linhas e 3 colunas, um intervalo horizontal de 5 pixels e

um intervalo vertical de 8 pixels: GridLayout gr2 = new GridLayout(10,3,5,8); O intervalo padrão entre os componentes sob o layout de grade é de 0 pixel em direções vertical e horizontal.


50

Exemplo 3: GridLayout.

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class LayoutGrade extends JFrame { JButton zero = new JButton("0"); JButton maismenos = new JButton("+/-"); JButton ponto = new JButton(","); JButton soma = new JButton("+"); JButton um = new JButton("1"); JButton dois = new JButton("2"); JButton tres = new JButton(3"); JButton sub = new JButton("-"); JButton quatro = new JButton("4"); JButton cinco = new JButton("5"); JButton seis = new JButton("6"); JButton mult = new JButton("*"); JButton sete = new JButton("7"); JButton oito = new JButton("8"); JButton nove = new JButton("9"); JButton div = new JButton("/"); public LayoutGrade() { super("GridLayout"); setSize(260, 260); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel painel = new JPanel(); GridLayout grade = new GridLayout(4, 4,2,2); painel.setLayout(grade); painel.add(zero); painel.add(maismenos); painel.add(ponto); painel.add(soma); painel.add(um); painel.add(dois); painel.add(tres); painel.add(sub); painel.add(quatro); painel.add(cinco); painel.add(seis); painel.add(mult); painel.add(sete); painel.add(oito); painel.add(nove); painel.add(div); add(painel); setVisible(true); } public static void main(String[] arguments) { LayoutGrade grade = new LayoutGrade(); } }


51

Devemos observar que os botões se expandem para preencher o espaço disponível em cada célula. Essa é uma diferença importante entre layout de grade e alguns dos outros gerenciadores de layout.

BORDERLAYOUT São criados usando a classe BorderLayout em java.awt, o gerenciador divide o contêiner em cinco

seções: norte, sul, leste, oeste e centro. Sob o layout de borda, os componentes nos quatro pontos de bússola ocupam o máximo de espaço que

precisarem – o centro recebe qualquer espaço restante. Normalmente, isso resultará em uma arrumação com um grande componente central e quatro componentes finos em torno dele.

Um layout de borda é criado com os construtores BorderLayout( ) ou BorderLayout(int, int). O primeiro construtor cria um layout de borda sem intervalo entre qualquer um dos componentes. O segundo construtor especifica o intervalo horizontal e o vertical, respectivamente.

Depois de criar um layout de borda e configurá-lo como o gerenciador de layout de um contêiner, os componentes serão acrescentados usando uma chamada ao método add( ), que é diferente do que vimos anteriormente.

O primeiro argumento é o que deve ser adicionado ao contêiner. O segundo argumento é uma variável de classe BorderLayout que indica a qual parte do layout de borda

atribuir o componente. As variáveis NORTH, SOUTH, EAST e CENTER podem ser usadas. O segundo, argumento para esse método é o componente que deve ser adicionado ao contêiner.


52

Exemplo 4: BorderLayout.

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class LayoutBorda extends JFrame { JButton norte = new JButton("Norte"); JButton sul = new JButton("Sul"); JButton leste = new JButton("Leste"); JButton oeste = new JButton("Oeste"); JButton centro = new JButton("Centro"); public LayoutBorda() { setTitle("BorderLayout"); setSize(240, 280); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new BorderLayout()); add(norte, BorderLayout.NORTH); add(sul, BorderLayout.SOUTH); add(leste, BorderLayout.EAST); add(oeste, BorderLayout.WEST); add(centro, BorderLayout.CENTER); setVisible(true); } public static void main(String args[]) { LayoutBorda borda = new LayoutBorda(); } }


53

MISTURANDO OS GERENCIADORES DE LAYOUT Isso é feito colando-se vários contêineres dentro de um contêiner maior (como um frame) e dando a

cada contêiner menor seu próprio gerenciador de layout. O contêiner a ser usado para esses contêineres menores é o painel, que é criado a partir do painel JPanel. Os

painéis são contêineres usados para agrupar componentes. Ao trabalhar com painéis, deve se ter em mente: · O painel é preenchido com componentes antes que seja colocado em um contêiner maior. · O painel possui seu próprio gerenciador de layout. O método de layout é definido para um painel com a chamada ao método setLayout( ).

CARDLAYOUT Os layouts de ficha diferem dos outros porque escondem alguns componentes. Um layout de ficha é um

grupo de contêineres ou componentes que são EXIBIDOS UM DE CADA VEZ. Cada contêiner no grupo é chamado de ficha.

O modo mais comum de usar um layout de ficha é usar um painel para cada ficha. Primeiro, os componentes são acrescentados aos painéis, e depois os painéis são acrescentados ao contêiner definido para utilizar o layout de ficha.

Um layout de ficha é utilizado a partir da classe CardLayout(no pacote java.awt) com uma chamada simples ao construtor:

CardLayout cc = new CardLayout( ); O método setLayout( ) é usado para tornar este gerenciador de layout para o contêiner, como na instrução

abaixo: setLayout(cc); Depois de definir um contêiner para usar o gerenciador de layout de ficha, terá de usar uma chamada de

método add( ) ligeiramente diferente para adicionar fichas ao layout. O método a ser usado é add(Componente, String). O primeiro argumento especifica o conteiner ou o

componente que é a ficha. Se for um contêiner, todos os componentes precisam ter sido acrescentados a ele antes que a ficha seja acrescentada.

O segundo argumento do método add( ) é uma string que representa o nome da ficha. Pode ser qualquer coisa que você queira chamar. Poderíamos numerar as fichas de alguma maneira e usar o número no nome, com em “Ficha 1”, “Ficha 2”, e assim por diante.

Exemplo: Acrescenta um painel chamado options a um contêiner e dá a essa ficha o nome “Cartão de Opções”:

add(options, “Cartão de Opções”); Quando um contêiner usando um layout de ficha for exibido pela primeira vez, a ficha visível será a

primeira acrescentada ao contêiner. Fichas subseqüentes poderão ser exibidas chamando o método show( ) do gerenciador de layout, que

utiliza dois argumentos: · O contêiner com todas as fichas · O nome da ficha Exemplo: Chamada ao método show( ) de um gerenciador de layout de ficha chamado cc: cc.show(this, “Cartão”); A palavra-chave this refere-se ao objeto dentro do qual a instrução cc.show aparece. “Cartão” é o nome da

ficha a revelar. Quando a ficha é mostrada, a ficha exibida anteriormente é obscurecida. Somente uma ficha de um layout de ficha pode ser vista de cada vez.

Em um programa que usa o gerenciador do layout de ficha, uma mudança de ficha normalmente será disparada pela ação de um usuário.


54

Exemplo 5: CardLayout.

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class LayoutCard extends JPanel implements ActionListener { int cartao = 0; CardLayout cartoes = new CardLayout(); Componentes[] pergunta = new Componentes[3]; public LayoutCard() { super(); setSize(240, 140); setLayout(cartoes); String questao1 = "Qual é o seu sexo?"; String[] resposta1 = { "Masculino", "Feminino", "Não

responderei" }; pergunta[0] = new Componentes(questao1, resposta1, 2); String questao2 = "Qual é a sua idade?"; String[] resposta2 = { "Menos que 25", "25-34", "35-54",

"Mais que 54" }; pergunta[1] = new Componentes(questao2, resposta2, 1); String questao3 = "Quantas vezes você faz exercício por

semana?"; String[] resposta3 = { "Nunca", "1-3 vezes", "Mais que 3"

}; pergunta[2] = new Componentes(questao3, resposta3, 1); pergunta[2].setQuestaoFinal(true); for (int i = 0; i < pergunta.length; i++) { pergunta[i].proximo.addActionListener(this); pergunta[i].fim.addActionListener(this); add(pergunta[i], "Card " + i); } }


55

public void actionPerformed(ActionEvent evt) { cartao++; if (cartao >= pergunta.length) { System.exit(0); } cartoes.show(this, "Card " + cartao); } } class Componentes extends JPanel { JLabel questao; JRadioButton[] resposta; JButton proximo = new JButton("Próximo"); JButton fim = new JButton("Fim"); Componentes(String ques, String[] resp, int def) { super(); setSize(160, 110); questao = new JLabel(ques); resposta = new JRadioButton[resp.length]; JPanel sub1 = new JPanel(); ButtonGroup grupo = new ButtonGroup(); JLabel rotulo = new JLabel(ques); sub1.add(rotulo); JPanel sub2 = new JPanel(); for (int i = 0; i < resp.length; i++) { if (def == i) { resposta[i] = new JRadioButton(resp[i], true); } else { resposta[i] = new JRadioButton(resp[i], false); } grupo.add(resposta[i]); sub2.add(resposta[i]); } JPanel sub3 = new JPanel(); proximo.setEnabled(true); sub3.add(proximo); fim.setEnabled(false); sub3.add(fim); GridLayout grade = new GridLayout(3, 1); setLayout(grade); add(sub1); add(sub2); add(sub3); } void setQuestaoFinal(boolean questaofinal) { if (questaofinal) { proximo.setEnabled(false); fim.setEnabled(true); } } }


56

Exemplo 5: Executora CardLayout import java.awt.*; import javax.swing.*; public class PrincipalCard extends JFrame { public PrincipalCard( ) { super("Cartões"); setSize(290, 140); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); LayoutCard lc = new LayoutCard(); add(lc); setVisible(true); } public static void main(String[] arguments) { PrincipalCard pc = new PrincipalCard(); }} Extra: CardLayout, ActionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0920 extends JFrame implements ActionListener { JPanel painelBotoes ,painelCard,P1,P2,P3; JButton B1,B2,B3,B4,B5,B6,btpainel1,btpainel2,btpainel3; JLabel L1,L2,L3; JTextField T1,T2; public Exemplo0920() { setTitle("Uso do gerenciador CardLayout"); setSize(280,170); setLocation(50,50); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setBackground(new Color(0,128,128)); getContentPane().setLayout(new BorderLayout()); B1 = new JButton("Botão 1"); B2 = new JButton("Botão 2"); B3 = new JButton("Botão 3"); B4 = new JButton("Botão 4"); B5 = new JButton("Botão 5"); B6 = new JButton("Botão 6"); L1 = new JLabel("Esse é o painel 1",JLabel.CENTER); L2 = new JLabel("Esse é o painel 2",JLabel.CENTER); L3 = new JLabel("Esse é o painel 3",JLabel.CENTER); T1 = new JTextField("Linguagem",20); T2 = new JTextField("Java",10); btpainel1 = new JButton("Painel 1"); btpainel1.addActionListener(this); btpainel2 = new JButton("Painel 2"); btpainel2.addActionListener(this);


57

btpainel3 = new JButton("Painel 3"); btpainel3.addActionListener(this); painelCard = new JPanel(); painelCard.setLayout(new CardLayout()); painelBotoes = new JPanel(); painelBotoes .setLayout(new GridLayout(1,3)); P1 = new JPanel(); P1.setLayout(new FlowLayout()); P1.add(L1);P1.add(T1);P1.add(T2); P2 = new JPanel(); P2.setLayout(new GridLayout(4,1)); P2.add(L2);P2.add(B1);P2.add(B2);P2.add(B3); P3 = new JPanel(); P3.setLayout(new BorderLayout()); P3.add("North",B4);P3.add("Center",L3); P3.add("East",B5);P3.add("South",B6); painelBotoes .add(btpainel1); painelBotoes .add(btpainel2); painelBotoes .add(btpainel3); painelCard.add(P1,"p1"); painelCard.add(P2,"p2"); painelCard.add(P3,"p3"); getContentPane().add("North",painelBotoes ); getContentPane().add("South",painelCard); setVisible(true); } public void actionPerformed(ActionEvent e){ CardLayout cl = (CardLayout) painelCard.getLayout(); if (e.getSource()==btpainel1) cl.show(painelCard,"p1"); if (e.getSource()==btpainel2) cl.show(painelCard,"p2"); if (e.getSource()==btpainel3) cl.show(painelCard,"p3"); } public static void main(String args[]) { JFrame Janela=new Exemplo0920(); } }


58

GRID BAG LAYOUT É uma extensão do gerenciador de layout de grade. Difere do layout de grade das seguintes maneiras: · Um componente pode ocupar mais de uma célula na grade. · As proporções entre diferentes linhas e colunas não precisam ser iguais. · Um componente não precisa preencher toda(s) a(s) célula(s) que ele ocupa · Um componente pode ser alinhado a qualquer borda de uma célula. Um layout grid bag requer as classes GridBagLayout e GridBagConstraints, ambas partes do pacote

java.awt.GridBagLayout é o gerenciador de layout e, GridBagConstraints define o posicionamento dos componentes na grade.

O construtor do gerenciador de layout grid bag não possui argumentos e pode ser aplicado a um contêiner, como qualquer outro gerenciador. As instruções a seguir podem ser usadas no método construtor de um frame ou janela para usar o layout grid bag desse contêiner:

Container pane = getContentPane( ); GridBagLayout bag = new GridBagLayout( ); pane.setLayout(bag); Em um layout grid bag, cada componente usa um objeto GridBagConstraints para ditar a(s) célula(s)

que ocupa em uma grade, seu tamanho e outros aspectos de sua apresentação. Um objeto GridBagConstraints possui 11 variáveis de instância que determinam o posicionamento dos

componentes: · gridx – a posição x da célula que contém o componente (caso se estenda por várias células, a posição x

da porção superior esquerda do componente). · gridy – a posição y da célula ou sua porção superior esquerda. · gridwidth – o número de células que o componente ocupa em uma direção horizontal. · gridheight - o número de células que o componente ocupa em uma direção vertical · weightx – um valor que indica o tamanho do componente em relação a outros componentes da mesma

linha de grade. · weighty – um valor que indica seu tamanho em relação aos componentes da mesma coluna da grade. · anchor – um valor que determina onde o componente será exibido dentro de sua célula (se não

preencher a célula toda). · fill – um valor que determina se o componente se expande horizontal ou verticalmente para

preencher sua célula. · insets – um objeto insets que define o espaço em branco em torno do componente dentro de sua

célula. · ipadx – a quantidade a expandir a largura do componente além de seu tamanho mínimo. · ipady – a quantidade a expandir a altura do componente Com exceção de insets, todos esses componentes podem conter valores inteiros. A maneira mais fácil de

usar essa classe é criar um objeto constraints sem argumentos e definir suas variáveis individualmente. As variáveis não definidas explicitamente usam seus valores padrão.

Exemplo: Criação de um layout bag grid e um objeto constraints usado para posicionar os componentes na grade:

Container pane = getContentPane( ); GridBagLayout gridbag = new GridBagLayout( ); GridBagConstraints constraints = new GridBagConstraints( );´ pane.setLayout(gridbag); O objeto constraints pode ser configurador com um conjunto de instruções de atribuições: constraints.gridx = 0; constraints.gridy = 0; constraints.gridwidth = 2; constraints.gridheight = 1; constraints.weightx = 100;


59

constraints.weighty = 100; constraints.fill = GridBagConstraints.NONE; constraints.anchor = GridBagConstraints.CENTER; Esse código configura uma restrição que pode ser usada para colocar um componente na posição de

grade(0,0) que tem duas células de largura e uma célula de altura. O tamanho do componente dentro de sua célula e posição é definido com variáveis de classe de

GridBagConstraints. O componente será centralizado na sua célula (um valor anchor de CENTER) e não se expande para preencher a célula toda (um valor fill de NONE).

Os valores weightx e weighty somente fazem sentido em relação aos mesmos valores para outros componentes.

Um componente é acrescentado a um layout grid bag em duas etapas: 1. O método setConstraints (Componente, GridBagConstraints) do gerenciador de layout é chamado

com o componente e objetos constraints como argumentos. 2. O componente é acrescentado a um contêiner que usa esse gerenciador. Um objeto constraints deve ser definido antes do posicionamento de cada componente na grade. public Cadastro( ){ GridBagLayout gridbag = new GridBagLayout( ); setLayout(gridbag); Jlabel rotulonome = new Jlabel(“Nome:”); GridBagConstraints constraints = new GridBagConstraints( ); constraints.gridx = 0; constraints.gridy = 0; constraints.gridwidth = 1; constraints.gridheight = 1; constraints.weightx = 10; constraints.weighty = 100; constraints.fill = GridBagConstraints.NONE; constraints.gridx = GridBagConstraints.EAST; gridbag.setConstraints(toLabel, constraints( )); add(nome); JTextField to = new JTextField( ); constraints.gridx = 1; constraints.gridy = 0; constraints.gridwidth = 9; constraints.gridheight = 1; constraints.weightx = 90; constraints.weighty = 100; constraints.fill = GridBagConstraints.HORIZONTAL; constraints.gridx = GridBagConstraints.WEST; gridbag.setConstraints(to, constraints( )); add(nome); } Obs.: Verifique que temos que definir novos valores para posicionar cada novo objeto. Isto é extremamente

inviável, a menos que façamos um método para adicionar apenas os valores que desejamos para o componente.


60

Exemplo 6: GridBagLayout

import java.awt.*; import javax.swing.*; public class Cadastro extends JPanel { GridBagLayout gridbag = new GridBagLayout(); public Cadastro() { super(); GridBagConstraints constraints; setLayout(gridbag); JLabel rotulonome = new JLabel("Nome: "); JTextField nome = new JTextField(); JLabel rotulocargo = new JLabel("Cargo: "); JTextField cargo = new JTextField(); JLabel rotulofone = new JLabel("Telefone: "); JTextField fone = new JTextField(); JLabel rotulocep = new JLabel("CEP: "); JTextField cep = new JTextField(); addComponente(rotulonome,0,0,1,1,10,100,GridBagConstraints.NONE,

GridBagConstraints.EAST); addComponente(nome,1,0,9,1,90,100,GridBagConstraints.HORIZONTAL,

GridBagConstraints.WEST); addComponente(rotulocargo,0,1,1,1,10,100,GridBagConstraints.NONE,

GridBagConstraints.EAST); addComponente(cargo,1,1,9,1,90,100, GridBagConstraints.HORIZONTAL,

GridBagConstraints.WEST); addComponente(rotulofone,0,2,1,1,10,100, GridBagConstraints.NONE,

GridBagConstraints.EAST); addComponente(fone,1,2,4,1,40,100, GridBagConstraints.HORIZONTAL,

GridBagConstraints.WEST); addComponente(rotulocep,5,2,1,1,10,100, GridBagConstraints.NONE,

GridBagConstraints.EAST); addComponente(cep,6,2,4,1,40,100, GridBagConstraints.HORIZONTAL,

GridBagConstraints.WEST); } private void addComponente(Component componente, int gridx, int

gridy, int gridwidth, int gridheight, int weightx, int weighty,

int fill, int anchor) {


61

GridBagConstraints constraints = new GridBagConstraints(); constraints.gridx = gridx; constraints.gridy = gridy; constraints.gridwidth = gridwidth; constraints.gridheight = gridheight; constraints.weightx = weightx; constraints.weighty = weighty; constraints.fill = fill; constraints.anchor = anchor; gridbag.setConstraints(componente, constraints); add(componente); } }

Exemplo 6: Executora GridBagLayout

import java.awt.*; import javax.swing.*; public class PrincipalCadastro extends JFrame { public PrincipalCadastro() { super("Cadastro"); setSize(290, 140); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Cadastro cad = new Cadastro(); add(cad); setVisible(true); } public static void main(String[] arguments) { PrincipalCadastro pc = new PrincipalCadastro(); } }

Extra: GridBagLayout

import javax.swing.*; import java.awt.*; public class Bag extends JFrame{ public Bag () { GridBagLayout layout = new GridBagLayout(); GridBagConstraints c = new GridBagConstraints(); getContentPane().setLayout(layout); JButton botao1 = new JButton("Botão 1"); JButton botao2 = new JButton("Botão 2");


62

JButton botao3 = new JButton("Botão 3"); JButton botao4 = new JButton("Botão 4"); JButton botao5 = new JButton("Botão 5"); //Configura as propriedades de cada botão //botão 1 c.gridy=0;//primeira linha c.gridx=0;//primeira coluna layout.setConstraints(botao1,c); getContentPane().add(botao1); c.gridy=0;//primeira linha c.gridx=1;//segunda coluna layout.setConstraints(botao2,c); getContentPane().add(botao2); c.gridy=0;//primeira linha c.gridx=2;//terceira coluna layout.setConstraints(botao3,c); getContentPane().add(botao3); c.gridy=1;//segunda linha c.gridx=0;//primeira coluna c.gridwidth=3;//ocupar o espaço de 3 colunas layout.setConstraints(botao4,c); getContentPane().add(botao4); c.gridy=2;//terceira linha c.gridx=1;//segunda coluna c.gridwidth=2; layout.setConstraints(botao5,c); getContentPane().add(botao5); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); pack(); setVisible(true); } public static void main (String args[]){ new Bag(); }}

Extra: GridBagLayout

import javax.swing.*; import java.awt.*; public class FormularioCliente extends JFrame{ private JTextField fId, fNome; private JLabel lId, lNome; private JButton botaoOK, botaoCancela; private JPanel principal, painelBotoes; public FormularioCliente(){ this.setTitle("Formulário de clientes");


63

iniciaComponentes(); } private void iniciaComponentes(){ principal = new JPanel(); painelBotoes = new JPanel(); getContentPane().setLayout(new BorderLayout()); getContentPane().add(principal,BorderLayout.CENTER); getContentPane().add(painelBotoes,BorderLayout.SOUTH); painelBotoes.setLayout(new FlowLayout()); botaoOK = new JButton ("OK"); botaoCancela = new JButton("Cancela"); painelBotoes.add(botaoOK); painelBotoes.add(botaoCancela); principal.setLayout(new GridBagLayout()); fId=new JTextField(4); fNome = new JTextField(40); lId = new JLabel("CPF"); lNome = new JLabel ("Nome"); botaoOK = new JButton("0K"); botaoCancela = new JButton ("Cancela"); addEtiqueta(principal, lId, 1,2,1,1); addCampo(principal, fId, 1,3,2,1); addEtiqueta(principal, lNome,2,2,1,1); addCampo(principal, fNome,2,3,2,1); pack(); setVisible(true); } public void addCampo (JPanel painel, Component componente, int

linha, int coluna, int largura, int altura){ GridBagConstraints posicao = new GridBagConstraints(); posicao.anchor=GridBagConstraints.WEST;

add(painel,componente,linha,coluna,largura,altura,posicao); } public void addEtiqueta(JPanel painel, Component componente,

int linha, int coluna, int largura, int altura){ GridBagConstraints posicao = new GridBagConstraints(); posicao.anchor = GridBagConstraints.CENTER; add(painel, componente,linha, coluna, largura, altura,

posicao); } public void add (JPanel painel, Component componente, int

linha, int coluna, int largura, int altura, GridBagConstraints posicao){ posicao.gridx=coluna; posicao.gridy=linha; posicao.gridwidth=largura; posicao.gridheight=altura; posicao.weightx=1; posicao.weighty=1;

((GridBagLayout)painel.getLayout()).setConstraints(componente,posicao);


64

painel.add(componente); } public static void main (String args []){ FormularioCliente f = new FormularioCliente(); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }

PARTE 3 - EVENTOS


65

EVENTOS Cada ouvinte trata de um tipo específico de evento. O pacote java.awt.event contém todos os ouvintes de eventos básicos, assim como os objetos que

representam eventos específicos. Essas interfaces de ouvinte são as mais comuns: · ActionListener – eventos de ação, que são gerados por um usuário que realiza uma ação sobre um

componente. · AdjustmentListener – eventos de ajuste, que são gerados quando um componente é ajustado, como

quando o botão de uma barra de rolagem é movimentado. · FocusListener – eventos de foco do teclado, que são gerados quando um componente (como um campo

de texto) ganha ou perde foco. · ItemListener – eventos de item, que são gerados quando um item (como uma caixa de seleção) é

alterado. · KeyListener – eventos de teclado, que ocorrem quando um usuário entra com texto no teclado. · MouseListener – eventos de mouse, que são gerados por cliques do mouse, um mouse entrando ou

saindo da área do componente. · MouseMotionListener – eventos de movimento do mouse, que acompanham todo o movimento de um

mouse sobre um componente. · WindowListener – eventos de janela. Uma classe pode implementar quantos ouvintes forem necessários. Exemplo: public class Suspense extends JFrame implements ActionListener, TextListener{ // ...} CONFIGURANDO OS COMPONENTES Depois que um componente é criado, você pode chamar um dos seguintes métodos no componente para

associar um ouvinte a ele: · addActionListener( ) – Componente JButton, JCheckBox, JComboBox, JTextField, JRadioButton e

JMenuItem. · addFocusListener( ) – Todos os componentes Swing. · addItemListener( ) – Componentes JButton, JCheckBox, JComboBox e JRadioButton. · addKeyListener( ) – Todos os componentes Swing. · addMouseListener( ) – Todos os componentes Swing. · addMouseMotionListener( ) – Todos os componentes Swing. · addTextListener( ) – Componentes JTextField e JTextArea. · addWindowListener( ) – Todos os componentes JWindow e JFrame. Exemplo: Cria um objeto JButton e associa um ouvinte de evento de ação a ele: JButton zap = new JButton(“Zap”); zap.addActionListener(this); Todos os métodos add pegam um argumento: o objeto que está escutando eventos desse tipo. O uso de this

indica que a classe atual é o ouvinte de evento. Você precisa especificar um objeto diferente, desde que sua classe implemente a interface de ouvinte correta. MÉTODOS DE TRATAMENTO DE EVENTO Quando associamos uma interface a uma classe, a classe precisa lidar com todos os métodos contidos na interface. No caso dos ouvintes de evento, cada um dos métodos é chamado automaticamente pelo sistema de janela quando ocorre o correspondente evento do usuário.


66

A interface ActionListener possui apenas um método: actionPerformed( ). Todas as classes que implementam ActionListener precisam ter um método com uma estrutura semelhante a esta: public void actionPerformed(ActionEvent evt){ // tratamento do evento} Se somente um componente na interface gráfica com o usuário do programa tiver um ouvinte para eventos de ação, esse método actionPerformed( ) poderá ser usado para responder a um evento gerado por esse componente. Se mais de um componente tiver um ouvinte de evento de ação teremos de usar o método para descobrir detalhes sobre o componente que gerou o evento. ActionEvent e todos os outros objetos de evento fazem parte do pacote java.awt.event e são subclasses da classe EventObject. Cada método de tratamento de evento recebe um objeto de evento de algum tipo. O método getSource( ) do objeto pode ser usado para determinar o componente que enviou o evento.

Exemplo: public void actionPerformed( ){ Object source = evt.getSource( );} O objeto retornado pelo método getSource( ) pode ser comparado com os componentes por meio do operador = =. As instruções a seguir podem ser usadas dentro do exemplo actionPerformed( ) anterior: if (source = = quitButton) quitProgram( ); else if (source = = sortRecords) sortRecords( );} Se o objeto quitButton tiver gerado o evento, será chamado o método quitProgram( ). Se tiver sido o botão sortRecords a gerar o evento, será chamado o método sortRecords( ). Muitos métodos de tratamento de eventos chamam um método diferente para cada tipo de evento ou componente. Isso torna o método de tratamento de evento mais fácil de ser lido. Além disso, se houver mais de um método de tratamento de evento em uma classe, cada um pode chamar os mesmos métodos para realizar o trabalho. O operador instanceof pode ser usado em um método de tratamento de evento para determinar que classe de componente gerou o evento. O exemplo a seguir pode ser usado em um programa com um botão e um campo de texto, cada um deles gerando um evento de ação: void actionPerformed(Action event){ Object source = event.getSource( ); if(source instanceof JTextField) calculeScore( );} else if (source instanceof JButton) quitProgram( ); }}


67

Exemplo 1: ActionListener

import java.awt.event.*; import javax.swing.*; import java.awt.*; public class Alterar extends JFrame implements ActionListener { JButton b1 = new JButton("Eventos"); JButton b2 = new JButton("Java"); public Alterar() { super("Título"); setSize(300,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); b1.addActionListener(this); b2.addActionListener(this); FlowLayout flow = new FlowLayout(); setLayout(flow); add(b1); add(b2); setVisible(true); } public void actionPerformed(ActionEvent evt) { Object source = evt.getSource(); if (source == b1) { setTitle("Eventos"); } else if (source == b2) { setTitle("Java"); } repaint(); } public static void main(String[] arguments) { Alterar a = new Alterar(); } } O método getSource( ) do objeto evt determina a origem do evento. Se for igual ao botão b1, o título do frame

é definido como Eventos; se for igual a b2, o título é definido como Java. Uma chamada a repaint( ) é necessária para que o frame seja redesenhado depois de qualquer mudança de título que possa ter ocorrido no método.


68

TRABALHANDO COM MÉTODOS O método getSource( ) pode ser usado em qualquer objeto de evento para determinar qual objeto gerou

o evento.

ActionListener Os eventos de ação ocorrem quando um usuário completa uma ação usando componentes como botões,

caixas de seleção, itens de menu, campos de texto e botões de opção. Uma classe precisa implementar a interface ActionListener para poder tratar desses eventos. Além do

mais, o método addActionListener( ) precisa ser chamado em cada componente que deva gerar um evento de ação – a menos que você queira ignorar os eventos de ação desse componente.

O método actionPerformed(ActionEvent) é o único método da interface ActionListener. Ele tem o seguinte formato:

public void actionPerformed(ActionEvent event){ // ...} Além do método getSource( ), você pode usar o método getActionCommand( ) no objeto ActionEvent para

descobrir mais informações sobre a origem do evento. O comando de ação, por padrão, é o texto associado ao componente, como o rótulo em um botão. Podemos

definir um comando de ação diferente para um componente, chamando seu método setActionCommand(String). O argumento de string deverá ser o texto desejado do comando de ação.

Por exemplo, as instruções a seguir criam um botão e um item de menu, dando a ambos o comando de ação “Sort Files”:

JButton sort = new JButton(“Sort”); JMenuItem menuSort = new JMenuItem( ); sort.setActionCommand(“Sort Files”); menuSort.setActionCommand(“Sort Files”);

Extra: ActionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0903 extends JFrame implements ActionListener

{ JButton b1,b2; ImageIcon icone = new ImageIcon("C:/Imagens/busca.gif"); public Exemplo0903() { setTitle("Inserindo botoes na janela"); setSize(350,100); setLocation(50,50); getContentPane().setBackground(new Color(180,180,180)); b1 = new JButton("Busca",icone); b1.setHorizontalTextPosition(AbstractButton.LEFT);//posicao do

texto // b1.setVerticalTextPosition(AbstractButton.TOP);//posicao do

texto b1.setBackground(new Color(100,180,180));//cor de fundo do botão


69

b1.setForeground(Color.black);//cor do titulo do botão b1.setFont(new Font("ScriptS",Font.BOLD,20)); //define a fonte

do botão b1.setEnabled(true); b1.addActionListener(this); b1.setToolTipText("Pressione aqui para realizar uma busca"); b1.setMnemonic(KeyEvent.VK_B); // b1.setActionCommand("botao1");//define o nome da acao b2 = new JButton("Cancelar"); b2.addActionListener(this); b2.setMnemonic(KeyEvent.VK_C); b2.setToolTipText("Pressione aqui para cancelar"); getContentPane().setLayout(new FlowLayout()); getContentPane().add(b1); getContentPane().add(b2); } public void actionPerformed(ActionEvent e) { // metodo implementado pelo ActionListener if (e.getSource()==b1) { JOptionPane.showMessageDialog(null,"Botão 1

pressionado"); } if (e.getSource()==b2) { JOptionPane.showMessageDialog(null,"Botão 2

pressionado"); } } public static void main(String args[]) { JFrame Janela = new Exemplo0903(); Janela.show(); //para fechar a janela WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); } }


70


import java.awt.*; import java.awt.event.*; import javax.swing.*; class Calculadora1 extends JFrame implements ActionListener{ JLabel L1,L2,L3; JButton B1, B2, B3, B4, B5; JTextField T1,T2,T3; Calculadora1(){ setTitle("Calculadora"); setSize(350,90); setLocation(50,50); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setBounds(150,250,350,90); getContentPane().setBackground(new Color(150,150,150)); getContentPane().setLayout(new GridLayout(3,4)); L1 = new JLabel("Num.1"); L1.setForeground(Color.black); L1.setFont(new Font("",Font.BOLD,14)); L2 = new JLabel("Num.2"); L2.setForeground(Color.black); L2.setFont(new Font("",Font.BOLD,14)); L3 = new JLabel("Total"); L3.setFont(new Font("",Font.BOLD,14)); B1 = new JButton ("+"); B1.addActionListener(this); B2 = new JButton ("-"); B2.addActionListener(this); B3 = new JButton ("x"); B3.addActionListener(this); B4 = new JButton ("/"); B4.addActionListener(this); B5 = new JButton ("Limpar"); B5.addActionListener(this); B5.setBackground(Color.black); B5.setForeground(Color.white); T1 = new JTextField(); T2 = new JTextField(); T3 = new JTextField(); T3.setEditable(false); //define que o textField como

somente leitura getContentPane().add(L1); getContentPane().add(T1); getContentPane().add(B1); getContentPane().add(B2); getContentPane().add(L2); getContentPane().add(T2); getContentPane().add(B3); getContentPane().add(B4); getContentPane().add(L3); getContentPane().add(T3); getContentPane().add(B5);


71

setVisible(true); } public void actionPerformed(ActionEvent e) { if (e.getSource()==B5) { T1.setText(""); T2.setText(""); T3.setText(""); return; } float N1=0,N2=0,result=0; try { N1 = Float.parseFloat(T1.getText()); N2 = Float.parseFloat(T2.getText()); } catch (NumberFormatException erro) { T3.setText("Erro"); return; } if (e.getSource()==B1) { result = N1 + N2; } if (e.getSource()==B2) { result = N1 - N2; } if (e.getSource()==B3) { result = N1 * N2; } if (e.getSource()==B4) { result = N1 / N2; } T3.setText(""+result); } public static void main(String args[]){ JFrame janela=new Calculadora1(); } }


72


import java.awt.BorderLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.*; public class Calculadora2 extends JFrame implements ActionListener{ JLabel l1 = new JLabel("Número 1"); JLabel l2 = new JLabel("Número 2"); JLabel l3 = new JLabel("Resultado"); JTextField t1 = new JTextField(25); JTextField t2 = new JTextField(25); JButton b1 = new JButton("Somar"); JButton b2 = new JButton("Subtrair"); JButton b3 = new JButton("Dividir"); JButton b4 = new JButton("Multiplicar"); JPanel p1 = new JPanel(); JPanel p2 = new JPanel(); JPanel p3 = new JPanel(); Double t,n1,n2; public Calculadora2(){ super("Calculadora"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); b1.addActionListener(this); b2.addActionListener(this); b3.addActionListener(this); b4.addActionListener(this); p1.setLayout(new GridLayout(2,2,-200,0)); p1.add(l1);p1.add(t1); p1.add(l2);p1.add(t2); p2.add(b1);p2.add(b2);p2.add(b3);p2.add(b4); p3.add(l3); BorderLayout borda = new BorderLayout(); setLayout(borda); add(p1,"North"); add(p2,"Center"); add(p3,"South"); pack(); setVisible(true); } public void actionPerformed(ActionEvent evt){ Object source = evt.getSource(); if(source==b1){ try{ n1=Double.parseDouble(t1.getText());


73

n2=Double.parseDouble(t2.getText()); }catch (NumberFormatException ex){

JOptionPane.showMessageDialog(null,ex.getMessage(),"Erro",JOptionPane.ERROR_MESSAGE);

} t=n1+n2; l3.setText("Resultado:"+t); } else if(source==b2){ try{ n1=Double.parseDouble(t1.getText()); n2=Double.parseDouble(t2.getText()); }catch (NumberFormatException ex){


} t=n1-n2; l3.setText("Resultado:"+t); } else if(source==b3){ try{ n1=Double.parseDouble(t1.getText()); n2=Double.parseDouble(t2.getText()); }catch (NumberFormatException ex){


} t=n1/n2; l3.setText("Resultado:"+t); } else if(source==b4){ try{ n1=Double.parseDouble(t1.getText()); n2=Double.parseDouble(t2.getText()); }catch (NumberFormatException ex){


} t=n1*n2; l3.setText("Resultado:"+t); } } public static void main(String args[]){ Calculadora2 calc = new Calculadora2(); } }


74

Extra: ListSelectionListener, ActionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; public class Exemplo0907 extends JFrame implements

ListSelectionListener, ActionListener{ JLabel L1; JTextField T1; JList lista; JButton bquant,bindice,bclear; DefaultListModel listModel; public Exemplo0907(){ setLocation(300,100); setTitle("Uso do JList"); setSize(200,250); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); T1 = new JTextField(); T1.addActionListener(this); L1 = new JLabel("Sem selecao"); L1.setForeground(Color.black); bquant = new JButton("Quantidade de itens"); bquant.addActionListener(this); bindice = new JButton("Indice selecionado"); bindice.addActionListener(this); bclear = new JButton("Remove item"); bclear.addActionListener(this); listModel = new DefaultListModel(); listModel.addElement("Banana"); listModel.addElement("Pera"); listModel.addElement("Maça"); listModel.addElement("Uva"); lista = new JList(listModel); lista.addListSelectionListener(this); //registra a lista JScrollPane Painel = new JScrollPane(lista); getContentPane().setLayout(new GridLayout(6,1)); getContentPane().add(L1); getContentPane().add(T1); getContentPane().add(Painel); getContentPane().add(bquant); getContentPane().add(bindice);


75

getContentPane().add(bclear); setVisible(true); } public void actionPerformed(ActionEvent e){ if (e.getSource()==T1) { listModel.addElement(T1.getText()); //adiciona

itens a lista T1.setText(""); } if (e.getSource()==bquant) T1.setText("Quantidade: " + listModel.getSize()); if (e.getSource()==bindice) T1.setText("Indice selecionado: " +

lista.getSelectedIndex()); if (e.getSource()==bclear) { int index = lista.getSelectedIndex(); L1.setText("Removido : "+ lista.getSelectedValue()); listModel.remove(index); } } public void valueChanged(ListSelectionEvent e) { L1.setText("Selecionado : "+ lista.getSelectedValue()); } public static void main(String args[]) { JFrame Janela = new Exemplo0907(); } }


76


import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0912 extends JFrame implements ActionListener { JButton B1,B2,B3; JLabel L1; public Exemplo0912() { setBackground(new Color(190,190,190)); setSize(400,100); setTitle("Caixas de confirmacao"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER)); L1=new JLabel("Resposta: "); B1=new JButton("Sim e Nao");

B1.addActionListener(this); B2=new JButton("Sim, Nao e Cancelar");

B2.addActionListener(this); B3=new JButton("Ok e Cancelar");

B3.addActionListener(this); getContentPane().add(B1); getContentPane().add(B2); getContentPane().add(B3); getContentPane().add(L1); setVisible(true); } public void actionPerformed(ActionEvent e){ int resposta=0; if(e.getSource()==B1)


77

resposta=JOptionPane.showConfirmDialog(null,"Erro ao acessar arquivo. Tentar novamente?","Erro de arquivo",JOptionPane.YES_NO_OPTION,JOptionPane.ERROR_MESSAGE);

if(e.getSource()==B2) resposta=JOptionPane.showConfirmDialog(null,"Deseja salvar as

alteracoes?","Salvar o arquivo",JOptionPane.YES_NO_CANCEL_OPTION,JOptionPane.WARNING_MESSAGE);

if(e.getSource()==B3) resposta=JOptionPane.showConfirmDialog(null,"Deseja abrir o

arquivo?","Abrir arquivo",JOptionPane.OK_CANCEL_OPTION,JOptionPane.QUESTION_MESSAGE);

switch(resposta) { case 0: L1.setText("Pressionado o botão Yes / Ok"); break; case 1: L1.setText("Pressionado o botão No"); break; case 2: L1.setText("Pressionado o botão Cancel"); break; } } public static void main(String args[]){ JFrame Janela = new Exemplo0912(); }

} Extra: ActionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0916 extends JFrame implements ActionListener{ JTextArea TA1,TA2; JTextField T1; JButton B1,B2; Exemplo0916() { setSize(480,280); setTitle("Uso do JTextArea"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER)); T1 = new JTextField(40); T1.addActionListener(this); B1 = new JButton("Copia Tudo");


78

B1.addActionListener(this); B2 = new JButton("Copia Selecao"); B2.addActionListener(this); TA1 = new JTextArea("Editor de texto:\n",5,40); TA2 = new JTextArea(5,40); JScrollPane painel1 = new JScrollPane(TA1); JScrollPane painel2 = new JScrollPane(TA2); getContentPane().add(painel1); getContentPane().add(T1); getContentPane().add(B1); getContentPane().add(B2); getContentPane().add(painel2); setVisible(true); } public void actionPerformed(ActionEvent e) { if (e.getSource()==T1) //ao pressionar ENTER no JTextField { TA1.append(T1.getText()); T1.setText(""); } if (e.getSource()==B1) //copia conteúdo de TA1 em TA2 TA2.setText(TA1.getText()); if (e.getSource()==B2) //copia selecao TA2.setText(TA1.getSelectedText()); } public static void main(String args[]) { JFrame Janela = new Exemplo0916(); } }


import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0917 extends JFrame implements ActionListener { JMenuBar M1; JTextField T1; JMenu menuCadastro, menuRelatorio; JMenuItem micliente, mifornecedor, misair, mirlcliente,

mirlfornecedor; public static void main(String args[]) { JFrame Janela=new Exemplo0917(); } Exemplo0917() { setTitle("Uso de Menus"); setSize(270,130); setLocation(50,50);


79

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setBackground(new Color(0,128,128)); T1 = new JTextField(); M1 = new JMenuBar(); //cria a barra de menus menuCadastro = new JMenu("Cadastro"); //cria um novo menu menuCadastro.setMnemonic(KeyEvent.VK_C);//ALT + C menuRelatorio = new JMenu("Relatorios"); micliente = new JMenuItem ("Cliente");//cria um item micliente.addActionListener(this);

micliente.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,ActionEvent.CTRL_MASK));

//CTRL + C mifornecedor = new JMenuItem ("Fornecedor"); mifornecedor.addActionListener(this); misair = new JMenuItem ("Sair do sistema"); misair.addActionListener(this); menuCadastro.add(micliente);//adiciona o item ao menu menuCadastro.add(mifornecedor); menuCadastro.add(misair); mirlcliente = new JMenuItem ("Relação de Clientes"); mirlcliente.addActionListener(this); mirlfornecedor = new JMenuItem ("Relação de Fornecedores"); mirlfornecedor.addActionListener(this); menuRelatorio.add(mirlcliente); menuRelatorio.add(mirlfornecedor); M1.add(menuCadastro);//adiciona o menu na barra de menus M1.add(menuRelatorio); setJMenuBar(M1);//define a barra de menus como padrao getContentPane().add(T1); setVisible(true); } public void actionPerformed(ActionEvent e){ if (e.getSource()==micliente) T1.setText("Escolhido o item Cliente"); if (e.getSource()==mifornecedor) T1.setText("Escolhido o item Fornecedor"); if (e.getSource()==mirlcliente) T1.setText("Escolhido o item Relação de Clientes"); if (e.getSource()==mirlfornecedor) T1.setText("Escolhido o item Relação de Fornecedores"); if (e.getSource()==misair) System.exit(0); } }


80


import javax.swing.*; import java.awt.*; import java.awt.event.*; public class ListTest extends JFrame implements ActionListener{ private JList compra, sel; private Button b1,b2; private String itens[]={"Ford Ka","Ford Fiesta","Ford Fiesta

Sedan", "Ford Fiesta Trail","Ford Focus","Ford Focus Sedan","Ford

Fusion"}; public ListTest() { super("Selecione seu carro"); setSize(300,180); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel p1 = new JPanel(); JPanel p2 = new JPanel(); p1.setLayout(new FlowLayout()); p2.setLayout(new BoxLayout(p2,BoxLayout.Y_AXIS)); compra = new JList(itens); compra.setVisibleRowCount(5); compra.setFixedCellWidth(110); compra.setFixedCellHeight(20);

compra.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); sel = new JList(); sel.setVisibleRowCount(5); sel.setFixedCellWidth(110); sel.setFixedCellHeight(20); b1=new Button(">>"); b1.addActionListener(this); p1.add(new JScrollPane(compra)); p2.add(b1); p1.add(p2); p1.add(new JScrollPane(sel)); add(p1); setVisible(true); } public static void main(String args[]){ ListTest lt = new ListTest(); } public void actionPerformed(ActionEvent evt){ Object source = evt.getSource(); if(source ==b1){ sel.setListData(compra.getSelectedValues());} } }


81

Extra: ActionListener, JInternalFrame, JDesktopPane

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class DesktopTest extends JFrame { private JDesktopPane area; public DesktopTest() { super( "Using a JDesktopPane" ); JMenuBar bar = new JMenuBar(); JMenu addMenu = new JMenu( "Menu" ); JMenuItem newFrame = new JMenuItem( "Internal Frame" ); addMenu.add( newFrame ); bar.add( addMenu ); setJMenuBar( bar ); area = new JDesktopPane(); getContentPane().add(area); newFrame.addActionListener( new ActionListener() { public void actionPerformed( ActionEvent event ) { JInternalFrame frame = new JInternalFrame("Internal

Frame", true, false, true, true ); Container container = frame.getContentPane(); MyJPanel panel = new MyJPanel(); container.add( panel, BorderLayout.CENTER ); frame.pack(); area.add( frame ); frame.setVisible( true ); } } ); setSize( 600, 440 ); setVisible( true ); } public static void main( String args[] ) { DesktopTest application = new DesktopTest(); application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); } } class MyJPanel extends JPanel {


82

private ImageIcon imageIcon; public MyJPanel() { imageIcon = new ImageIcon( "c:/imagens/ford_fusion.jpg" ); } public void paintComponent( Graphics g ) { super.paintComponent( g ); imageIcon.paintIcon( this, g, 0, 0 ); } public Dimension getPreferredSize() { return new Dimension( imageIcon.getIconWidth(), imageIcon.getIconHeight() ); } }


import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ComboBoxTest extends JFrame implements ItemListener{ private JComboBox cb; private JLabel l1; private String

carros[]={"c:/ícones/ford_ka.jpg","c:/ícones/ford_fiesta.jpg","c:/ícones/ford_fiesta_sedan.jpg",

"c:/ícones/ford_fiesta_trail.jpg","c:/ícones/ford_focus.jpg", "c:/ícones/ford_focus_sedan.jpg","c:/ícones/ford_fusion.jpg"}; private String nomescarros[]={"ford ka","ford fiesta","ford

fiesta sedan","ford fiesta trail","ford focus","ford focus sedan","ford fusion"};

private Icon icones[]={new ImageIcon(carros[0]),new ImageIcon(carros[1]),new ImageIcon(carros[2]),new ImageIcon(carros[3]),

new ImageIcon(carros[4]),new ImageIcon(carros[5]),new ImageIcon(carros[6])};

public ComboBoxTest() { super("Selecione seu carro"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(300,300); JPanel p1 = new JPanel(); p1.setLayout(new FlowLayout()); cb = new JComboBox(nomescarros); cb.setMaximumRowCount(3);


83

cb.addItemListener(this); l1=new JLabel(icones[0]); setVisible(true); p1.setBackground(Color.WHITE); p1.add(cb); p1.add(l1); add(p1); } public static void main (String args[]){ ComboBoxTest t = new ComboBoxTest(); } public void itemStateChanged(ItemEvent evt){ Object source = evt.getSource(); if (evt.getStateChange()==ItemEvent.SELECTED) l1.setIcon(icones[cb.getSelectedIndex()]); } }

FocusListener Os eventos de foco ocorrem quando qualquer componente ganha ou perde o foco da entrada em uma interface gráfica com o usuário. Foco descreve o componente que está ativo para entrada pelo teclado. Se um dos campos tiver o foco (em uma interface com o usuário contendo vários campos de texto editáveis), um cursor piscará nesse campo. Qualquer texto inserido entrará nesse componente. O foco se aplica a todos os componentes que podem receber entrada. Em um objeto JButton, um contorno pontilhado aparece no botão que possui o foco. Um componente pode receber o foco chamando seu método requestFocus sem argumentos, como neste exemplo: JButton ok = new JButton(“OK”); ok.requestFocus( ); Para tratar o evento do foco, uma classe precisa implementar a interface FocusListener. Existem dois métodos na interface: focusGained(FocusEvent) e focusLost(FocusEvent). Eles têm os seguintes formatos: public void focusGained(FocusEvent event){ // ...} public void focusLost(FocusEvent event){ // ...} Para determinar qual objeto obteve ou perdeu o foco, o método getSource( ) pode ser chamado no objeto FocusEvent e enviado como argumento para os métodos focusGained( ) e focusLost( ).


84

Exemplo 2: FocusListener.

import java.awt.event.*; import javax.swing.*; import java.awt.*; public class SomaFoco extends JFrame implements FocusListener{ JTextField valor1 = new JTextField("0",5); JLabel soma = new JLabel("+"); JTextField valor2 = new JTextField("0",5); JLabel igual = new JLabel("="); JTextField res = new JTextField("0",5); public SomaFoco(){ super("Somar"); setSize(350,90); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); FlowLayout f = new FlowLayout(FlowLayout.CENTER); setLayout(f); valor1.addFocusListener(this); valor2.addFocusListener(this); res.setEditable(false); add(valor1); add(soma); add(valor2); add(igual); add(res); setVisible(true); } public void focusGained(FocusEvent event){ try{ float total = Float.parseFloat(valor1.getText())+

Float.parseFloat(valor2.getText()); res.setText(""+total); }catch (NumberFormatException nfe){ valor1.setText("0"); valor2.setText("0"); } } public void focusLost(FocusEvent event){ focusGained(event); } public static void main(String[] arguments){ SomaFoco frame = new SomaFoco(); } }


85

ItemListener Ocorrem quando um item é selecionado ou perde a seleção em componentes como botões, caixas de seleção ou botões de opção. Uma classe precisa implementar a interface itemListener para poder tratar desses eventos. itemStateChanged(ItemEvent) é o único método na interface ItemListener. Ele tem o seguinte formato: void itemStateChanged(ItemEvent event){ //...} Para determinar em que item ocorreu o evento, o método getItem( ) pode ser chamado no objeto ItemEvent. Podemos determinar se o item foi selecionado ou se perdeu a seleção, usando o método getStateChange( ).Esse método retorna um inteiro que será igual à variável de classe ItemEvent.DESELECTED ou ItemEvent.SELECTED.


86

Exemplo 3: ItemListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class EventoItem extends JFrame implements ItemListener{ String[] escolha = {"(escolha seu programa)", "MSN Messenger",

"Windows Live Messenger","Ares Galaxy", "AVG Anti-vírus"}; String[] descricao = {"MSN Messenger 8.5.1302 Final","Windows

Live Messenger 2009 14.0.864.206","Ares Galaxy 2.1.1.3035","AVG Anti-Virus Free 8.5 Build 325a1500"};

JComboBox combo = new JComboBox(); JLabel rotulo = new JLabel(""); public EventoItem(){ super("Escolha seu programa"); setSize(420,150); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new BorderLayout()); for (int i=0; i < escolha.length; i++){ combo.addItem(escolha[i]); } combo.addItemListener(this); add(BorderLayout.NORTH, combo); add(BorderLayout.CENTER, rotulo); setVisible(true); } public void itemStateChanged(ItemEvent event){ int pos = combo.getSelectedIndex(); if (pos >0){ rotulo.setText(descricao[pos-1]); } } public Insets getInsets(){ return new Insets(50,10,10,10); } public static void main(String[] arguments){ EventoItem ei = new EventoItem(); } }


87

Extra: ItemListener, ActionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0908 extends JFrame implements ActionListener,

ItemListener{ JLabel L1; JTextField T1,T2,T3; JComboBox combo; JButton B1,B2,B3,B4,B5,B6,B7,B8; Exemplo0908(){ setTitle("Uso do JComboBox"); setSize(400,170); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setBackground(new Color(190,190,190)); L1 = new JLabel("Conteudo"); L1.setForeground(Color.blue); L1.setFont(new Font("Arial", Font.BOLD, 15)); B1 = new JButton("Mostra Texto"); B1.addActionListener(this); B2 = new JButton("Mostra Indice"); B2.addActionListener(this); B3 = new JButton("Adiciona Item"); B3.addActionListener(this); B4 = new JButton("Remove Item"); B4.addActionListener(this); B5 = new JButton("Remove Todos"); B5.addActionListener(this); B6 = new JButton("Quant. Itens"); B6.addActionListener(this); T1 = new JTextField(); T2 = new JTextField(); String[] cores = {"Branco","Vermelho","Azul","Verde"}; combo = new JComboBox(cores); combo.addItemListener(this); getContentPane().setLayout(new GridLayout(5,2)); getContentPane().add(L1); getContentPane().add(combo); getContentPane().add(B1); getContentPane().add(B4); getContentPane().add(B2); getContentPane().add(B5); getContentPane().add(B3); getContentPane().add(T1); getContentPane().add(B6); getContentPane().add(T2); setVisible(true); } public void actionPerformed(ActionEvent e) { if (e.getSource()==B1)//mostra texto


88

L1.setText("Texto: "+combo.getSelectedItem()); if (e.getSource()==B2)//mostra indice L1.setText("Indice: " + combo.getSelectedIndex()); if (e.getSource()==B3)//adiciona item if (T1.getText().length()!=0) { combo.addItem(T1.getText()); T1.setText(""); } if (e.getSource()==B4)//remove item combo.removeItemAt(combo.getSelectedIndex()); if (e.getSource()==B5)//remove todos os itens combo.removeAllItems(); if (e.getSource()==B6)//quantidade de itens T2.setText(""+combo.getItemCount()); } public void itemStateChanged(ItemEvent e) { T1.setText(""+combo.getSelectedItem()); } public static void main(String args[]){ JFrame Janela = new Exemplo0908(); } } Extra: ItemListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0909 extends JFrame implements ItemListener { JLabel L1; JCheckBox C1,C2; static int negrito=0,italico=0; Exemplo0909() { getContentPane().setBackground(new Color(180,180,180)); setTitle("Uso do JCheckBox"); setSize(300,70); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER)); L1 = new JLabel("Java"); L1.setFont(new Font("Arial",Font.PLAIN,20)); L1.setForeground(Color.black); C1 = new JCheckBox("Negrito"); C1.setBackground(new Color(180,180,180)); C1.addItemListener(this); C2 = new JCheckBox("Italico");


89

C2.setBackground(new Color(180,180,180)); C2.addItemListener(this); getContentPane().add(L1); getContentPane().add(C1); getContentPane().add(C2); setVisible(true); } public void itemStateChanged(ItemEvent e) { if(e.getSource()==C1) { if(e.getStateChange()==ItemEvent.SELECTED) negrito=Font.BOLD; else negrito=Font.PLAIN; } if(e.getSource()==C2) { if(e.getStateChange()==ItemEvent.SELECTED) italico=Font.ITALIC; else italico=Font.PLAIN; } L1.setFont(new Font("Arial",negrito+italico,20)); } public static void main(String args[]) { JFrame Janela = new Exemplo0909(); } }

Extra: ItemListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; class Exemplo0910 extends JFrame implements ItemListener{ JLabel L1,L2; float N1=0,result=0; JTextField T1, T2; JPanel P1,P2; JRadioButton radio1,radio2,radio3; ButtonGroup radiogroup; public static void main(String args[]) { JFrame Janela = new Exemplo0910(); } Exemplo0910() { setTitle("Uso de botoes de Radio "); setSize(340,120);


90

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER)); L1 = new JLabel("Digite um valor"); L1.setForeground(Color.blue); L2 = new JLabel("% do Valor :"); L2.setForeground(Color.blue); T1 = new JTextField(5); T2 = new JTextField(5); P1 = new JPanel(); P2 = new JPanel(); T2.setEditable(false); radio1 = new JRadioButton("10% do valor"); radio2 = new JRadioButton("20% do valor"); radio3 = new JRadioButton("30% do valor"); radio1.setMnemonic(KeyEvent.VK_1); radio2.setMnemonic(KeyEvent.VK_2); radio3.setMnemonic(KeyEvent.VK_3); radiogroup = new ButtonGroup(); radiogroup.add(radio1); radiogroup.add(radio2); radiogroup.add(radio3); radio1.addItemListener(this); radio2.addItemListener(this); radio3.addItemListener(this); P1.setLayout(new FlowLayout(FlowLayout.CENTER)); P1.setBackground(new Color(200,200,200)); P2.setLayout(new GridLayout(2,3)); P2.setBackground(new Color(200,200,200)); P1.add(L1); P1.add(T1); P2.add(radio1); P2.add(radio2); P2.add(radio3); P2.add(L2); P2.add(T2); getContentPane().add(P1); getContentPane().add(P2); setVisible(true); } public void itemStateChanged(ItemEvent e) { if (T1.getText().length()==0) return; try { N1 = Float.parseFloat(T1.getText()); if (e.getSource()==radio1) result = (N1 * 10)/100; if (e.getSource()==radio2) result = (N1 * 20)/100; if(e.getSource()==radio3) result = (N1 * 30)/100; } catch(NumberFormatException erro) { T2.setText("Erro"); return; } T2.setText(""+result); } }


91

Extra: ItemListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class RadioButtonTest extends JFrame implements

ItemListener{ private JTextField t1; private Font p,b,i,bi; private JRadioButton rp,rb,ri,rib; private ButtonGroup bg; public RadioButtonTest() { super("Negrito - Itálico"); setSize(350,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel p1 = new JPanel(); p1.setLayout(new FlowLayout()); t1=new JTextField(25); rp=new JRadioButton("Plana",true); rb=new JRadioButton("Negrito",false); ri=new JRadioButton("Itálico",false); rib=new JRadioButton("Negrito - Itálico",false); rp.addItemListener(this); rb.addItemListener(this); ri.addItemListener(this); rib.addItemListener(this); bg = new ButtonGroup(); bg.add(rp);bg.add(rb);bg.add(ri);bg.add(rib); p=new Font("Serif",Font.PLAIN,14); b=new Font("Serif",Font.BOLD,14); i=new Font("Serif",Font.ITALIC,14); bi=new Font("Serif",Font.BOLD+Font.ITALIC,14);

p1.add(t1); p1.add(rp); p1.add(rb); p1.add(ri); p1.add(rib); add(p1); setVisible(true); } public static void main(String args[]){ RadioButtonTest t = new RadioButtonTest(); } public void itemStateChanged(ItemEvent evt){ if(evt.getSource()==rp) t1.setFont(p); else if (evt.getSource()==rb) t1.setFont(b); else if (evt.getSource()==ri) t1.setFont(i); else if(evt.getSource()==rib) t1.setFont(bi); } }


92

KeyListener Ocorrem quando um tecla é pressionada no teclado. Qualquer componente pode gerar eventos, e uma

classe precisa implementar a interface KeyListener para dar suporte a eles. Existem três métodos na interface KeyListener. São eles KeyPressed(KeyEvent), KeyRealeased(KeyEvent)

e KeyTyped(KeyEvent). Eles têm os seguintes formatos: public void keyPressed(KeyEvent event){ // ...} public void keyReleased(KeyEvent event){ // ...} public void KeyTyped(KeyEvent event){ // ...} O método getKeyChar( ) de KeyEvent retorna o caractere da tecla associada ao evento. Se não houver um

caractere Unicode que possa ser representado pela tecla, getKeyChar( ) retornará um valor de caractere igual à variável de classe KeyEvent.CHAR_UNDEFINED.

Para um componente gerar eventos de tecla, ele deverá ser capaz de receber o foco de entrada. Os campos de texto, áreas de texto e outros componentes que usam entrada via teclado oferecem esse suporte automaticamente. No caso de outros componentes, como rótulos e painéis, o método setFocusable(boolean) deve ser chamado com um argumento true:

Container pane = getContentPane(); pane.setFocusable(true);

Extra: KeyListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo1002 extends JFrame implements KeyListener{ JTextField T1,T2; public Exemplo1002() { setTitle("Código das teclas"); setSize(190,65); setResizable(false); setLocation(100,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setLayout(new GridLayout(2,1)); T1 = new JTextField(); T2 = new JTextField(); T1.addKeyListener(this); getContentPane().add(T1); getContentPane().add(T2); setVisible(true); } public void keyPressed(KeyEvent e) { T2.setText(""+e.getKeyCode()); } public void keyReleased(KeyEvent e) {} public void keyTyped(KeyEvent e) {} public static void main(String[] args) { JFrame Janela = new Exemplo1002(); } }


93

Extra: KeyListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class KeyDemo extends JFrame implements KeyListener { private String linha1="",linha2="",linha3=""; private JTextArea ta; public KeyDemo() { super("Eventos de Teclado"); setSize(350,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ta=new JTextArea(10,15); ta.setText("Pressione qualquer tecla"); ta.setEnabled(false); getContentPane().add(ta); addKeyListener(this); setVisible(true); } public void keyPressed(KeyEvent evt){ linha1="Tecla pressionada:

"+evt.getKeyText(evt.getKeyCode()); //getKeyCode - obtém o código de tecla virtual da chave que

foi pressionada //getKeyText - devolve uma string que contém o nome da

tecla que foi pressionada setLinha2and3(evt); } //é chamado quando se solta a tecla depois de qualquer evento

keyPressed ou keyTyped public void keyReleased(KeyEvent evt){ linha1="Tecla solta "+evt.getKeyText(evt.getKeyCode()); setLinha2and3(evt); } public void keyTyped(KeyEvent evt){ linha1="Tecla digitada "+evt.getKeyChar(); //getKeyChar -obtém o valor Unicode do caractere digitado setLinha2and3(evt); } private void setLinha2and3(KeyEvent evt){ linha2="Esta tecla é "+(evt.isActionKey()?"":"não")+" uma

ação de teclado"; //isActionKey - determina se a tecla pressionada é uma

tecla de ação(Exemplo: F1) String temp = evt.getKeyModifiersText(evt.getModifiers()); //getModifiers - chamado para determinar se alguma tecla

modificadora foi pressionada (Exemplo: CTRL)


94

//getKeyModifiersText - produz uma string que contém os nomes das teclas modificadoras pressionadas

linha3="Modificar tecla pressionada "+(temp.equals("")?"nada":temp);

ta.setText(linha1+"\n"+linha2+"\n"+linha3+"\n"); } public static void main(String args[]){ KeyDemo janela = new KeyDemo(); } }

MouseListener Os eventos de mouse são gerados pelos seguintes tipos de interação com o usuário:

· Um clique do mouse · Um mouse entrando na área de um componente · Um mouse saindo da área de um componente Qualquer componente pode gerar esses eventos, que são implementados por uma classe usando a

interface MouseListener. Essa interface possui cinco métodos: · mouseCliked(MouseEvent) · mouseEntered(MouseEvent) · mouseExit(MouseEvent) · mousePressed(MouseEvent) · mouseReleased(MouseEvent) Cada um apanha o mesmo formato básico de mouseReleased(MouseEvent): public void mouseReleased(MouseEvent){ // ...} Os métodos a seguir podem ser usados nos objetos MouseEvent: · getClickCount( ) – Retorna o número de vezes que o mouse foi clicado como um número inteiro · getPoint( ) – Retorna as coordenadas x,y dentro do componente onde o mouse foi clicado como um objeto

Point. · getX( )- Retorna a posição x · getY( ) – Retorna a posição y Extra: MouseListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class MouseDetails extends JFrame { private int xPos, yPos; public MouseDetails() { super("Clique dos botões do mouse"); setSize(350,150); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); addMouseListener(new MouseClickHandler());


95

setVisible(true); } public void paint(Graphics g){ super.paint(g); g.drawString("Clicado em ["+xPos+","+yPos+"]",xPos,yPos); } public static void main(String args[]){ MouseDetails janela = new MouseDetails(); } private class MouseClickHandler extends MouseAdapter{ public void mouseClicked(MouseEvent evt){ xPos = evt.getX(); yPos = evt.getY(); String title = "Clicado "+evt.getClickCount()+" vezes

"; if(evt.isMetaDown()) title+="com o botão direito"; else if(evt.isAltDown()) title+="com o botão central"; else title+="com o botão esquerdo"; setTitle(title); repaint(); } } } Extra: MouseListener, ActionListener, JPopupMenu

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Exemplo0919 extends JFrame implements ActionListener { JPopupMenu mpopup; JMenuItem miCopiar, miColar, miSalvar; JMenuBar M1; JTextField T1; JButton B1,B2; public Exemplo0919() { setTitle("Uso de Menus Popup"); setSize(220,120); setLocation(50,50); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setBackground(new Color(0,128,128)); getContentPane().setLayout(new GridLayout(3,1)); M1 = new JMenuBar(); T1 = new JTextField();


96

B1 = new JButton("Botão 1"); B2 = new JButton("Botão 2"); mpopup = new JPopupMenu(); MouseListener registra = new MostraPopup(); B1.addMouseListener(registra); miCopiar = new JMenuItem ("Copiar"); miCopiar.addActionListener(this); miCopiar.setMnemonic(KeyEvent.VK_C); miColar = new JMenuItem ("Colar"); miColar.addActionListener(this); miColar.setMnemonic(KeyEvent.VK_O); miSalvar = new JMenuItem ("Salvar", new

ImageIcon("MenuSalvar.gif")); miSalvar.addActionListener(this); miSalvar.setMnemonic(KeyEvent.VK_S); mpopup.add(miCopiar); mpopup.add(miColar); mpopup.add(miSalvar); getContentPane().add(B1); getContentPane().add(B2); getContentPane().add(T1); setVisible(true); } public void actionPerformed(ActionEvent e) { if (e.getSource()==miCopiar) T1.setText("Copiar"); if (e.getSource()==miColar) T1.setText("Colar"); if (e.getSource()==miSalvar) T1.setText("Salvar"); } class MostraPopup extends MouseAdapter { public void mousePressed(MouseEvent e) { mpopup.show(e.getComponent(),e.getX(), e.getY()); } } public static void main(String args[]) { JFrame Janela=new Exemplo0919(); } }


97

MouseMotionListener Os eventos de movimento do mouse ocorrem quando um mouse é movimentado sobre um componente. Assim

como em outros eventos de mouse, qualquer componente pode gerar eventos de movimento do mouse. Uma classe precisa implementar a interface MouseMotionListener para que possa dar suporte a eles.

Existem dois métodos na interface MouseMotionListener: mouseDragged(MouseEvent) e mouseMoved(MouseEvent). Eles têm os seguintes formatos:

public void mouseDragged(MouseEvent event){ // ...} public void mouseMoved(MouseEvent event){ // ...} Ao contrário de outras interfaces ouvintes de evento tratadas até esse ponto, MouseMotionListener não

possui seu próprio tipo de evento. Em vez disso, são utilizados objetos MouseEvent. Por causa disso, podemos chamar os mesmos métodos que chamaríamos para eventos do mouse:

getClick( ), getPoint( ), getX( ), getY( ). Exemplo: Demonstra como detectar e responder a eventos de mouse. Contém as classes MousePrank e

PrankPanel, que implementam um botão que tenta evitar que seja clicado. A classe Mouse Prank é um frame que contém dois componentes organizados com layout de borda – o rótulo

“Clique em OK para fechar este programa” e um painel com um botão OK nele.

Exemplo 4: MouseMotionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class MovimentoMouse extends JFrame implements

ActionListener { public MovimentoMouse() { super("Movimento de mouse"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(420, 220); BorderLayout borda = new BorderLayout(); setLayout(borda); JLabel mensagem = new JLabel("Clique em OK para fechar este

programa."); add(BorderLayout.NORTH, mensagem); Mouse mouse = new Mouse(); mouse.ok.addActionListener(this); add(BorderLayout.CENTER, mouse); setVisible(true); } public void actionPerformed(ActionEvent event) { System.exit(0);


98

} public Insets getInsets() { return new Insets(40, 10, 10, 10); } public static void main(String[] arguments) { new MovimentoMouse(); } } class Mouse extends JPanel implements MouseMotionListener { JButton ok = new JButton("OK"); int buttonX, buttonY, mouseX, mouseY; int width, height; Mouse() { super(); setLayout(null); addMouseMotionListener(this); buttonX = 110; buttonY = 110; ok.setBounds(new Rectangle(buttonX, buttonY, 70, 20)); add(ok); } public void mouseMoved(MouseEvent event) { mouseX = event.getX(); mouseY = event.getY(); width = (int)getSize().getWidth(); height = (int)getSize().getHeight(); if (Math.abs((mouseX + 35) - buttonX) < 50) { buttonX = moveButton(mouseX, buttonX, width); repaint(); } if (Math.abs((mouseY + 10) - buttonY) < 50) { buttonY = moveButton(mouseY, buttonY, height); repaint(); } } public void mouseDragged(MouseEvent event) { // não utilizado } private int moveButton(int mouseAt, int buttonAt, int border) { if (buttonAt < mouseAt) { buttonAt--; } else { buttonAt++; } if (buttonAt > (border - 20)) { buttonAt = 10; } if (buttonAt < 0) { buttonAt = border - 80;


99

} return buttonAt; } public void paintComponent(Graphics comp) { super.paintComponent(comp); ok.setBounds(buttonX, buttonY, 70, 20); } } Explicação: Como o botão não se comporta normalmente, ele é implementado com a classe Mouse, uma subclasse de

JPanel. Esse painel inclui um botão desenhado em uma posição especifica no painel em vez de ser posicionado por um gerenciador de layout.

Primeiro o gerenciador do layout é definido como null, o que faz parar usando o layout de fluxo por padrão: setLayout(null); Em seguida, o botão é posicionado no painel usando setBounds(Rectangle), o mesmo método que determina

onde um frame ou janela aparecerá em um desktop. Um objeto Rectangule é criado com quatro argumentos: sua posição x, posição y, largura e altura. Veja como

Mouse desenha o botão: JButton ok = new JButton(“OK”); int buttonX=110; int buttonY=110; ok.setBounds(new Rectangle(buttonX, buttonY, 70, 20)); É mais eficiente criar o objeto Rectangle dentro da chamada de método, pois não precisamos usar o objeto em

nenhum outro lugar na classe. As seguintes instruções fazem o mesmo em duas etapas: Rectangle box = new Rectangle(buttonX, buttonY, 70,20); ok.setBounds(box); A classe possui variáveis de instância que contém a posição x, y do botão, buttonX e buttonY. Elas começam

em 110, 110 e mudam toda vez que o mouse atinge 50 pixels do centro do botão. Os movimentos do mouse são rastreados implementando-se a interface MouseListener e seus dois métodos,

mouseMoved(MouseEvent) e mouseDragged(MouseEvent). O painel usa mouseMoved() e ignora mouseDragged(). Quando o mouse se move, os métodos getX e getY do objeto do evento de mouse retornam sua posição x,y

atual que é armazenada nas variáveis de instância mousex e mousey. O método mouseButton(int, int, int) usa três argumentos: · A posição x ou y do botão · A posição x ou y do mouse · A largura ou altura do painel Esse método move o botão para fora do mouse tanto no sentido vertical como horizontal, dependendo de ter

sido chamado com as coordenadas x e a altura do painel ou com as coordenadas y e a largura. Depois de movido o botão, o método repaint() é chamado, o que faz o método paintComponent(Graphics) do

painel ser chamado. Todo componente possui um métod paintComponent que pode ser redefinido para desenhar o componente. O

método setBounds( ) do botão exibe-os na posição x, y atual.


100

Extra: MouseListener, MouseMotionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class MouseTracker extends JFrame implements MouseListener,

MouseMotionListener { private JLabel statusBar; public MouseTracker() { super("Demostração de Eventos de Mouse"); setSize(275,100); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); statusBar = new JLabel(); getContentPane().add(statusBar,BorderLayout.SOUTH); // o aplicativo espera seus próprios eventos de mouse addMouseListener(this); addMouseMotionListener(this); setVisible(true); } //trata evento quando o mouse é liberado imediatamente após ser

pressionado public void mouseClicked(MouseEvent evt){ statusBar.setText("Clicado em

["+evt.getX()+","+evt.getY()+"]"); } //trata evento quando o mouse é pressionado public void mousePressed(MouseEvent evt){ statusBar.setText("Pressionado

["+evt.getX()+","+evt.getY()+"]"); } //trata evento quando o mouse é liberado após ser arrastado public void mouseReleased(MouseEvent evt){ statusBar.setText("Arrastado

["+evt.getX()+","+evt.getY()+"]"); } //trata event quando o mouse entra na área da janela na tela public void mouseEntered(MouseEvent evt){ JOptionPane.showMessageDialog(null,"O mouse entrou na

janela"); } //trata evento quando o mouse sai da área da janela na tela public void mouseExited(MouseEvent evt){ statusBar.setText("O mouse saiu da janela"); } //tratadores de eventos MouseMotionListener //trata evento quano o usuário arrasta o mouse com o botão

pressionado public void mouseDragged(MouseEvent evt){


101

statusBar.setText("Arrastado ["+evt.getX()+","+evt.getY()+"]");

} //trata evento quando o usuário movimenta o mouse public void mouseMoved(MouseEvent evt){ statusBar.setText("Movimento do mouse

["+evt.getX()+","+evt.getY()+"]"); } public static void main(String args[]){ MouseTracker janela = new MouseTracker(); } }

Extra: MouseMotionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Painter extends JFrame{ private int xValue = -10, yValue= -10; public Painter() { super("Desenhe"); setSize(300,150); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().add(new JLabel("Arraste o mouse para

desenhar"),BorderLayout.SOUTH); addMouseMotionListener( new MouseMotionAdapter(){ public void mouseDragged(MouseEvent evt){ xValue = evt.getX(); yValue = evt.getY(); repaint(); } } ); setVisible(true); } public void paint(Graphics g){ g.fillOval(xValue,yValue,4,4); } public static void main(String args[]){ Painter janela = new Painter(); } }


102

WindowListener Os eventos de janela ocorrem quando um usuário abre ou fecha um objeto janela, como o JFrame ou JWindow. Qualquer componente pode gerar esses eventos, e uma classe precisa implementar a interface WindowListener para oferecer suporte a eles. Existem sete métodos na interface WindowListener:

· windowActivated(WindowEvent) · windowClosed(WindowEvent) · windowClosing(WindowEvent) · windowDeactivated(WindowEvent) · windowDeiconified(WindowEvent) · windowIconified(WindowEvent) · windowOpened(WindowEvent) Todos eles tomam a mesma forma do método windowOpened( ): public void windowOpened(WindowEvent evt){ //...} Os métodos windowClosing( ) e windowClosed( ) são semelhantes, mas um é chamado enquanto a janela

está fechando, e o outro chamado depois que estiver fechada. Na verdade, podemos tomar uma ação em um método windowClosing( ) para evitar que a janela seja fechada. Extra: MouseListener, KeyListener, TextListener, FocusListener, MouseMotionListener

import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; public class Exemplo1001 extends JFrame implements MouseListener,

KeyListener, TextListener, FocusListener, MouseMotionListener { JButton B1; JLabel L1,L2; JTextField T1,T2; TextField T3; static int E=100,T=100; public static void main(String[] args) { JFrame Janela = new Exemplo1001(); Janela.show(); WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); }


103

public void windowActivated(WindowEvent e) { // A Janela foi ativada } public void windowDeactivated(WindowEvent e){ // A Janela foi desativada } public void windowIconified(WindowEvent e) { // A Janela foi minimizada } public void windowDeiconified(WindowEvent e) { // A Janela foi restaurada; } public void windowOpened(WindowEvent e) { mostraMensagem("A Janela foi aberta"); } public void windowClosed(WindowEvent e) { // A Janela foi fechada } }; Janela.addWindowListener(x); ComponentListener y = new ComponentAdapter() { public void componentHidden(ComponentEvent e) { mostraMensagem("A janela tornou-se oculta"); } public void componentMoved(ComponentEvent e) { mostraMensagem("A janela foi movida"); } public void componentResized(ComponentEvent e) { mostraMensagem("A janela foi redimensionada"); } public void componentShown(ComponentEvent e) { mostraMensagem("A janela tornou-se visível"); } }; Janela.addComponentListener(y); } Exemplo1001() { setTitle("Manipulação de Eventos"); setSize(280,200); setLocation(E,T); getContentPane().setLayout(new GridLayout(6,1)); L1 = new JLabel(""); L2 = new JLabel(""); B1 = new JButton ("Eventos do Botão"); T1 = new JTextField(); T2 = new JTextField(); T3 = new TextField(); B1.addMouseListener(this); B1.addMouseMotionListener(this); B1.setBackground(Color.gray); T1.addKeyListener(this); T3.addTextListener(this); T3.addKeyListener(this); T3.addFocusListener(this); getContentPane().add(B1); getContentPane().add(L1); getContentPane().add(L2); getContentPane().add(T1); getContentPane().add(T3); getContentPane().add(T2); } // métodos relativos a MouseListener public void mousePressed(MouseEvent e){


104

L1.setText("O botão do Mouse foi pressionado"); mostraMensagem(""+e.getClickCount() + " " + e.getX()+ " " +

e.getY()); //mostraMensagem(""+e.isLeftMouseButton()+ " "+

e.isControlDown()); } public void mouseClicked(MouseEvent e) { L1.setText("O botão do Mouse foi solto"); } public void mouseEntered(MouseEvent e){ // o ponteiro do mouse

entrou na área B1.setBackground(Color.yellow); } public void mouseExited(MouseEvent e) { // o ponteiro do mouse

saiu da área B1.setBackground(Color.gray); } public void mouseReleased(MouseEvent e) { L1.setText("O ponteiro do Mouse foi arrastado"); } // métodos relativos a MouseMotionListener public void mouseMoved(MouseEvent e) { L2.setText("Mouse se moveu em "+e.getX()+" , "+e.getY()); } public void mouseDragged(MouseEvent e) { L2.setText("Mouse foi arrastado em "+e.getX()+" , "+e.getY());

} // métodos relativos a KeyListener public void keyPressed(KeyEvent e){ // uma tecla foi pressionada if (e.getSource()==T1){ if(e.getKeyCode()==10 || e.getKeyCode()==9){ e.setKeyCode(9); return; } if(e.getKeyCode()==38){ T = T - 5; setLocation(E,T); } if(e.getKeyCode()==40) { T = T + 5; setLocation(E,T); } if(e.getKeyCode()==37) { E = E - 5; setLocation(E,T); } if(e.getKeyCode()==39) { E = E + 5; setLocation(E,T); } } if (e.getSource()==T3){ if(e.getKeyCode()==10 || e.getKeyCode()==9) { e.setKeyCode(9); return; } if(e.getKeyCode()==8) return; if(e.getKeyCode()<96 || e.getKeyCode()>105) { e.setKeyCode(e.VK_ESCAPE); return; } }


105

} public void keyReleased(KeyEvent e){ // uma tecla foi solta } public void keyTyped(KeyEvent e){ // uma tecla Unicode foi pressionada } // método relativo a TextListener public void textValueChanged(TextEvent e){// o conteúdo do

campo texto foi alterado int n1,n2; try{ n1 = Integer.parseInt(T1.getText()); n2 = Integer.parseInt(T3.getText()); T2.setText(""+n1*n2); } catch(NumberFormatException erro){ T2.setText("0"); return; } } public void focusGained(FocusEvent e) { // o objeto recebeu o

foco L1.setText("O objeto T3 recebeu o foco"); } public void focusLost(FocusEvent e) { // o objeto perdeu o foco L1.setText("O objeto T3 perdeu o foco"); } public static void mostraMensagem(String men){

JOptionPane.showMessageDialog(null,men,"Mensagem",JOptionPane.INFORMATION_MESSAGE);

} }


106

CLASSES ADAPTADORAS Uma classe Java que implementa uma interface deve incluir todos os seus métodos, mesmo que não pretenda fazer nada em resposta a alguns deles. Esse requisito poderá tornar necessário o acréscimo de vários métodos vazios quando estivermos trabalhando com uma interface de tratamento de eventos como a windowListener, que possui sete métodos. Como conveniência, a Java oferece adaptadores, classes Java que contêm implementações “do nothing” vazias de interfaces específicas. Fazendo a subclassificação de uma classe de adaptador, podemos implementar somente os métodos de tratamento de eventos necessários, redefinindo esses métodos. O restante herdará os métodos “do-nothing”.

O pacote java.awt.event inclui FocusAdapter, KeyAdapter, MouseAdapter, MouseMotionAdapter e WindowAdapter. Eles correspondem aos ouvintes esperados para eventos de foco, teclado, mouse, movimento do mouse e janela.

Exemplo 5: KeyAdapter.

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Tecla extends JFrame { JLabel keyLabel = new JLabel("Pressione uma tecla"); public Tecla() { super("Digite uma tecla"); setSize(300, 200); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); Teclado tec = new Teclado(this); setFocusable(true); addKeyListener(tec); add(keyLabel); setVisible(true); } public static void main(String[] arguments) { new Tecla(); } } class Teclado extends KeyAdapter { Tecla tecla; Teclado(Tecla tecla) { this.tecla = tecla; } public void keyTyped(KeyEvent event) { tecla.keyLabel.setText("" + event.getKeyChar()); tecla.repaint(); } }


107

Extra : WindowAdapter

import java.awt.*; import java.awt.event.*; import javax.swing.*; class Exemplo0901 extends JFrame { Exemplo0901() { setTitle("Minha primeira Janela em Java"); setSize(400,50); setLocation(150,150); setResizable(false); getContentPane().setBackground(Color.gray); String x = getTitle(); } public static void main(String args[]){ JFrame janela=new Exemplo0901(); janela.show(); //para fechar a janela: WindowListener J = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(J); } }


108

Parte 4 - Banco de Dados com Java


109

Manipulação de Banco de Dados com Java - JDBC

Java Database Connectivity – uma biblioteca de classes que conecta programas Java a banco de dados relacionais.

Uma classe chamada driver age como uma ponte para a origem do banco de dados. Há drivers para cada um dos bancos de dados. JDBC aceita a auilização da linguagem SQL (Structured Query Language).

DRIVERS DE BANCO DE DADOS

A independência de plataforma e banco de dados só é possível por um gerenciador de drivers . JDBC também inclui um driver que se une ao ODBC (interface comum da Microsoft para acessar banco de dados). ODBC é gerenciado em um sistema Windows pelo ODBC Data Source Administrador. O administrador acrescenta drivers ODBC, configura drivers para trabalharem com arquivos de banco de dados

específicos e registra o uso da SQL. ODBC

JDBC-ODBC

A ponte JDBC-ODBC permite que drivers JDBC sejam usados como drivers ODBC, convertendo chamadas de método JDBC em chamada de funções ODBC.

O uso da ponte JDBC-ODBC tem três requisitos: · O driver de ponte JDBC-ODBC – sun.jdbc.odbc.JdbcOdbcDriver, que já vem incluído na JVM · Um driver ODBC · Uma fonte de dados ODBC que esteja associada ao driver usando um software como ODBC Data Source

Administrador Todas as fontes de dados ODBC precisam receber nomes descritivos. O nome será usado dentro dos programas

Java quando uma conexão for feita com o banco de dados ao qual a fonte se refere. Depois de tivermos um arquivo nome.mdb devemos criar uma fonte de dados associada a ele. A primeira tarefa em um programa JDBC é carregar o driver(ou drivers) que será usado para a conexão com uma

fonte de dados. Um driver é carregado com o método Class.forName (String). A método Class.forName(String) faz parte do pacote java.lang . O método forName(String) carrega a classe cujo nome é dado pela string especificada. Uma classe ClassNotFoundException pode ser lançada por esse método Todos os programas que usam uma fonte de dados ODBC utilizam sun.jdbc.odbc.JdbcOdbcDriver

Exemplo: Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Depois que o driver tiver sido carregado poderemos estabelecer uma conexão com a fonte de dados usando a classe DriverManager no pacote java.sql .


110

getConnection(String, String, String) é utilizado para configurar a conexão. Ele retorna uma referência a um objeto Connection representando uma conexão de dados ativa

Os três argumentos desse método são: · Um nome identificando a fonte de dados e o tipo de conectividade de banco de dados usado para alcançá-

la · Um nome de usuário · Uma senha

Os dois últimos argumentos são necessários somente se a fonte de dados for protegida com um nome de usuário e senha. Se não, esses argumentos podem ser strings nulas(“”) — Exemplo: — Connection conexao = DriverManger.getConnection(“jdbc:odbc:Emp”, “Admin”, “123”);

— Banco de Dados: Emp — Usuário: Admin — Senha: 123

Quando tivermos uma conexão podermos reutilizá-la toda vez que quiser apanhar ou armazenar informações da fonte de dados.

O método getConnection() e todos os outros chamados sobre uma fonte de dados lançarão erros SQLException se algo sair errado

Outros drivers: — No MySQL:

§ Class.forName(“com.mysql.jdbc.Driver”); — No Oracle:

§ Class.forName(“oracle.jdbc.driver.OracleDriver”); — No Microsoft SQL Server

§ Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”); — No Sysbase:

§ Class.forName(“com.sysbase.jdbc2.jdbc.SybDriver”); — No Postgre:

§ Class.forName(“org.postgresql.Driver”); — No DB2/Neon:

§ Class.forName(“com.neon.jdbc.Driver”); Uma instrução em Java é representada pelo objeto Statement . Statement é uma interface, de modo que não pode ser instanciada diretamente. Contudo, ela é retornada pelo

método createStatement() de um objeto Connection. — Statement consulta = ver.createStatement();

O objeto Statement retornado por esse método é um objeto que implementa a interface. Depois que tivermos um objeto Statement podemos usá-lo para realizar uma consulta chamando o método

executeQuery(String). — executeQuery(String) – O argumento string deverá ser uma consulta SQL

Exemplo: — ResultSet set = consulta.executeQuery(“select * from aluno”);

Se a consulta SQL tiver sido escrita corretamente, o método executeQuery() retornará um objeto ResultSet mantendo todos os registros obtidos da fonte de dados.

— executeUpdate() – utilizado para atualizar dados Quando um ResultSet é retornado de executeQuery(), ele é posicionado no primeiro registro obtido. Métodos de ResultSet(): — getDate(String) – Retorna o valor Date — getDouble(String) – Retorna o valor double — getFloat(String) – Retorna o valor float — getInt(String) – Retorna o valor int — getLong(String) – Retorna o valor long — getString(String) – Retorna a string


111

Também é possível usar um inteiro como argumento para qualquer um desses métodos, como getString(5). O inteiro indica qual campo obter .

Uma SQLException será lançada se houver um erro de banco de dados. Poderemos usar os métodos getSQLState() e getErrorCode() para descobrir mais sobre os possíveis erros apresentados.

— next() – método do objeto ResultSet utilizado para seguir para o próximo registro — Esse método retorna um valor Booleano false quando tenta ultrapassar o final de um conjunto de

resultados Normalmente, é possível passar uma vez por um conjunto de resultados do início ao fim, depois disso, não é mais

possível recuperar seu conteúdo. — close() – utilizado para fechar a conexão


112

Exemplo 1.

Saída:

import java.sql.*; import javax.swing.*; public class CoalTotals { public static void main(String[] arguments) { String pais=JOptionPane.showInputDialog(null,"Digite um

país:"); String data = "jdbc:odbc:WorldEnergy"; try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection conn = DriverManager.getConnection(data, "",

""); Statement st = conn.createStatement(); ResultSet rec = st.executeQuery( "SELECT * " + "FROM Coal " + "WHERE " + "(Country='" + pais + "') " + "ORDER BY Year"); System.out.println("SIGLA\tPAÍS\t\tANO\t" + "PRODUÇÃO"); while(rec.next()) { System.out.println(rec.getString(1) + "\t" + rec.getString(2) + "\t\t" + rec.getString(3) + "\t" + rec.getString(4)); } st.close(); } catch (SQLException s) { System.out.println("SQL Error: " + s.toString() + " " + s.getErrorCode() + " " + s.getSQLState()); } catch (Exception e) { System.out.println("Error: " + e.toString() + e.getMessage()); } } }


113

O pacote java.sql aceita a criação de uma instrução preparada(uma instrução compilada antes de ser executada).

Isso permite que a instrução retorne dados mais rapidamente e é uma opção melhor se estivermos executando uma instrução SQL repetidamente no mesmo programa. É representada pela classe PreparedStatament

o Obs.: O Access executa melhor as instruções preparadas o prepareStatement(String) – utilizado para criar uma instrução preparada.

Para indicar a estrutura, escreve-se a instrução SQL em que os parâmetros foram substituídos por pontos de interrogação

o Exemplo: § PreparedStatement ps = cc.prepareStatement(“ select * from Coal where(contry=‘?’) order by

year”); § PreparedStatement ps = cc.prepareStatement(“insert into bookdata values(?,?,?,?,?,?,?)”);

? – são marcadores de lugar para os dados. Antes que possamos executar deveremos inserir os dados com métodos da classe PreparedStatement

Para inserir dados em uma instrução preparada, precisamos chamar um método com a posição do marcador seguida pelos dados a inserir — Exemplo:

o Sintaxe: setString(int,String); o setString(1, “Swaziland”); - coloca a string especificada na primeira posição

— Os seguintes métodos estão disponíveis: o setAsciiStream(int, InputStream, int) – na posição indica pelo 1º argumento, insira o InputStream

especificado, que representa um stream de caracteres ASCII. O 3º argumento indica quantos bytes do stream de entrada devem ser inseridos

o setBinaryStream(int, InputStream,int) – na posição indicada pelo 1º argumento, insira o InputStream especificado, que representa um stream de bytes. O 3º argumento indica o nº de bytes a inserir a partir do stream

o setCharacterStream(int, Reader, int) – na posição indicada pelo 1º argumento, insira o Reader especificado, que representa um stream de caracteres. O 3º argumento indica o nº de caracteres para inserir a partir do stream

o setBoolean(int, boolean) – Insira um valor boolean na posição indicada pelo inteiro o setByte(int,byte) o setBytes(int,bytes[]) – uma array de bytes o setDate(int,Date) o setDouble(int, double) o setFloat(int, float) o setInt(int, int) o setLong(int,long) o setShort(int,short) o setString(int,Sring) o setNull(int,int) – armazena um valor nulo

§ O segundo argumento de setNull() deverá ser uma variável de classe a partir da classe Types em java.sql, para indicar que tipo de valor SQL pertence a essa posição

§ Existem variáveis de classe para cada um dos tipos de dados SQL. Exemplos: BIGINT, CHAR, DATE, DECIMAL, DOUBLE, FLOAT, INTEGER, SMALLINT, TINYINT E VARCHAR

ps.setNull(5,Types.CHAR); o Coloca um valor CHAR nulo na quinta posição de uma instrução preparada chamada ps

Métodos adicionais de resultset: o afterLast() – move para um lugar imediatamente após o último registro no conjunto o beforeFirst() – move para um lugar imediatamente antes do primeiro registro no conjunto o first() – move para o primeiro registro do conjunto o last() – move para o último registro do conjunto o previous() – move para o registro anterior no conjunto


114

Essas ações são possíveis quando as políticas de resultados foram especificadas como argumentos para os métodos createStatement e prepareStatement .

Normalmente, createStatement() não usa argumentos, como neste exemplo: Connection payday = DriverManager.getConnection(“ jdbc:odbc:Payroll”, “Doc”, “Irover1”); Statement looksee = payday.CreateStatement(); Para resultados mais flexíveis podemos usar: — Statement looksee = payday.CreateStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_READ_ONLY, ResultSet.CLOSE_CURSORS_AT_COMMIT); — Os mesmos três argumentos podem ser usados no método preparedStatement(String, int, int, int) após o

texto da instrução — A classe ResultSet inclui outras variáveis de classe que oferem mais opções sobre como os conjuntos

podem ser lidos e modificados JDBC Drivers

A primeira etapa e adquirir e instalar um driver JDBC Uma lista de drivers JDBC disponíveis pode ser encontrada no site JDBC da sun em

http://java.sun.com/products/jdbc/jdbc.drives.html As etapas para configurar uma fonte de dados para JDBC

— Criar o banco de dados — Associar o banco de dados a um driver JDBC — Estabelecer uma fonte de dados, o que pode incluir a seleção de um formato de banco de dados,

servidor de banco de dados, nome de usuário e senha


115

Exemplo 2.

import java.sql.*; class Exemplo1302{ public static void main(String args[]){ String url="jdbc:odbc:MeuBanco"; try{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection minhaConexao =

DriverManager.getConnection(url); Statement meuState =

minhaConexao.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);

//Statement possibilita a utilização de um comando SQL //TYPE_SCROLL_SENSITIVE - navegação nos dois sentidos. Alterações

podem ser efetivadas //CONCUR_READ_ONLY - somente leitura ResultSet rs = meuState.executeQuery("select ficodigo,

finome from Filmes"); //Resultado do comando SQL é armazenado e manipulado por meio de um

objeto do tipo ResultSet // System.out.println("Codigo Título"); System.out.println("------ -----------------------

--------------------------------------"); while(rs.next())//enquanto existirem registros { String codigo = rs.getString("FICODIGO");//A String

codigo recebe o conteúdo armazenado no campo Codigo pelo método getString

String titulo = rs.getString("FINOME"); System.out.println(codigo+" "+titulo); } minhaConexao.close(); } catch(ClassNotFoundException erro){ System.out.println("Driver JDBC-ODBC não

encontrado!");} catch(SQLException erro){ System.out.println("Problemas na conexão com o

banco de dados"); } } }


116

Exemplo 3.

import java.sql.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; class ConsultaSQL extends JFrame implements ActionListener{ JLabel label1, label2; JTextField t1, t2; JButton b1; ResultSet rs; Statement meuState; public static void main (String args[]){ JFrame janela = new ConsultaSQL(); janela.setUndecorated(true);

janela.getRootPane().setWindowDecorationStyle(JRootPane.FRAME); janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); janela.setVisible(true); } ConsultaSQL(){ setTitle("Aprendendo consultas com SQL"); setSize(600,170); setResizable(false); getContentPane().setLayout(new

FlowLayout(FlowLayout.LEFT)); label1 = new JLabel("Digite o comando SQL:"); label2 = new JLabel("Resultado do comando:"); t1 = new JTextField(50); t1.addActionListener(this); t2 = new JTextField(50); b1=new JButton("Limpa tela"); b1.addActionListener(this); getContentPane().add(label1); getContentPane().add(t1); getContentPane().add(label2); getContentPane().add(t2); getContentPane().add(b1); String url = "jdbc:odbc:MeuBanco1"; try{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection MinhaConexao =

DriverManager.getConnection(url); meuState = MinhaConexao.createStatement(); }


117

catch(ClassNotFoundException erro){ System.out.println("Driver JDBC-ODBC não

encontrado!"); } catch(SQLException ex){ System.out.println("Problemas na conexão com a

fonte de dados"); } } public void actionPerformed(ActionEvent e){ if(e.getSource()==b1){ t1.setText("");t2.setText(""); for (int i=0;i<25;i++) System.out.println();} else{ try{ rs=meuState.executeQuery(t1.getText()); while(rs.next()) {

try{System.out.println(rs.getString("codigo"));} catch(SQLException erro1){}

try{System.out.println(rs.getString("titulo"));} catch(SQLException erro2){}

try{System.out.println(rs.getString("genero"));} catch(SQLException erro3){}

try{System.out.println(rs.getString("produtora"));} catch(SQLException erro4){}

try{System.out.println(rs.getString("datacompra"));} catch(SQLException erro5){} System.out.println(); } t2.setText("Comando SQL executado com

sucesso!");} catch(SQLException erro){ t2.setText("Comando SQL inválido!"); } }}}


118

Exemplo 4.

import java.sql.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; class Exemplo1303 extends JFrame implements ActionListener{ JLabel L1,L2,L3,L4,L5; JButton b1,b2,b3,b4,b5,b6; JTextField tfCodigo,tfTitulo,tfGenero,tfProdutora,tfDatcom; JPanel p1 = new JPanel(); ResultSet rs; public static void main(String args[]) { JFrame janela = new Exemplo1303(); janela.setUndecorated(true); janela.getRootPane().setWindowDecorationStyle(JRootPane.FRAME); janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); janela.setVisible(true); } Exemplo1303() { p1.setLayout(new FlowLayout(FlowLayout.LEFT)); L1 = new JLabel("Código "); L2 = new JLabel("Título"); L3 = new JLabel("Gênero"); L4 = new JLabel("Produtora"); L5 = new JLabel("Data de Compra "); tfCodigo = new JTextField(10); tfCodigo.addActionListener(this); tfTitulo = new JTextField(35); tfGenero = new JTextField(10); tfProdutora = new JTextField(15); tfDatcom = new JTextField(8); b1=new JButton("Próximo"); b2=new JButton("Anterior"); b3=new JButton("Primeiro"); b4=new JButton("Último"); b5=new JButton("+10 registros"); b6=new JButton("-10 registros"); b1.setBackground(new Color(180,180,250)); b2.setBackground(new Color(180,180,250)); b3.setBackground(new Color(180,180,250)); b4.setBackground(new Color(180,180,250)); b5.setBackground(new Color(180,180,250));


119

b6.setBackground(new Color(180,180,250)); b1.addActionListener(this); b2.addActionListener(this); b3.addActionListener(this); b4.addActionListener(this); b5.addActionListener(this); b6.addActionListener(this); p1.add(L1); p1.add(tfCodigo); p1.add(L2); p1.add(tfTitulo); p1.add(L3); p1.add(tfGenero); p1.add(L4);

p1.add(tfProdutora); p1.add(L5); p1.add(tfDatcom); p1.add(b3); p1.add(b2); p1.add(b1); p1.add(b4);p1.add(b5);p1.add(b6); getContentPane().add(p1); setTitle("Navegação da tabela de Filmes"); setSize(630,120); setResizable(false); String url = "jdbc:odbc:MeuBanco"; try { Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" ); Connection MinhaConexao = DriverManager.getConnection(url); Statement MeuState =

MinhaConexao.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);

//TYPE_SCROLL_SENSITIVE - navegação nos dois sentidos. É permitida a alteração em tempo de execução

//CONCUR_READ_ONLY - somente leitura ou CONCUR_UPDATABLE - leitura e atualização

rs = MeuState.executeQuery("SELECT * FROM Filmes"); rs.first();//posiciona o objeto rs no primeiro registro atualizaCampos(); } catch(ClassNotFoundException ex) { System.out.println("Driver JDBC-ODBC não encontrado!"); } catch(SQLException ex) { System.out.println("Problemas na conexao com a fonte de

dados"); } } public void actionPerformed(ActionEvent e) { try { if (e.getSource()==b1) rs.next(); if (e.getSource()==b2) rs.previous(); if (e.getSource()==b3)


120

rs.first(); if (e.getSource()==b4) rs.last(); if (e.getSource()==b5) rs.relative(10); if (e.getSource()==b6) rs.relative(-10); atualizaCampos(); } catch(SQLException ex) { // tratamento de erros durante a navegação } } public void atualizaCampos() { try { tfCodigo.setText(rs.getString("Ficodigo"));//os nomes dos campos

deveram ser iguais os titulos dos campos na tabela filmes tfTitulo.setText(rs.getString("Finome")); tfGenero.setText(rs.getString("Figenero")); tfProdutora.setText(rs.getString("Fiprodut")); tfDatcom.setText(""+rs.getDate("Fidatcom")); } catch(SQLException ex) { } } }


121

createStatement e ResultSet

As variáveis possíveis de inicialização de um objeto createStatement são: — createStatement() – cria um objeto não navegável, cuja ordem de navegação permitida é apenas para

frente — createStatement(navegação, ação) – cria um objeto com os parâmetros fornecidos, os quais vão definir o

comportamento do objeto Statement, em que: — Navegação pode ser:

§ TYPE_FORWARD_ONLY - navegação apenas para frente § TYPE_SCROLL_INSENSITIVE – navegação nos dois sentidos § TYPE_SCROLL_SENSITIVE – navegação nos dois sentidos

Os últimos dois tipos de navegação são similares. A diferença é que as alterações no conteúdo da tabela realizadas em tempo de execução não refletem no tipo INSENSITIVE — Ação pode ser:

o CONCUR_READ_ONLY – somente leitura o CONCUR_UPDATABLE – leitura e atualização

— Movimentação em Registros: o rs.first() – posiciona no primeiro registro o rs.last() – posiciona no último registro o rs.next() – posiciona no próximo registro o rs.previous() – posiciona no registro anterior o rs.absolute(5) – coloca o ponteiro na quinta posição a partir do primeiro registro o rs.absolute(-5) – coloca o ponteiro na quinta posição anterior a partir do último registro o rs.relative(5) – coloca o ponteiro na quinta posição posterior à posição atual o rs.relative(-5) – coloca o ponteiro na quinta posição anterior à posição atual o rs.beforeFirst() – posiciona o ponteiro antes do início do primeiro registro o rs.afterLast() – posiciona o ponteiro depois do último registro o rs.isBeforeFirst() – usado para verificar se o ponteiro está posicionado no ínicio dos resgistros o rs.isAfterLanst() – usado para verificar se o ponteiro está posicionado no final dos registros


122

Exemplo 5.

import java.sql.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class Exemplo1304 extends JFrame{ Connection conexao; JTable tab; public static void main(String args[]) { JFrame Janela = new Exemplo1304(); Janela.show(); WindowListener x = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }; Janela.addWindowListener(x); } public Exemplo1304() { setTitle( "Tabela de Filmes" ); setSize(600,300); String url = "jdbc:odbc:MeuBanco"; try { Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" ); conexao = DriverManager.getConnection(url, "", "" ); } catch (ClassNotFoundException cne) { System.out.println("Erro ao carregar o driver JDBC/ODBC"); } catch (SQLException sqlne ) {


123

System.out.println("Problemas na Conexão"); } buscaTabela(); } private void buscaTabela() { Statement st; ResultSet res; try { Vector cabecalho = new Vector(); Vector linhas = new Vector(); st = conexao.createStatement(); res = st.executeQuery("SELECT * FROM Filmes"); res.next(); // busca os cabeçalhos ResultSetMetaData rsmd = res.getMetaData(); for ( int i = 1; i <= rsmd.getColumnCount(); ++i ) cabecalho.addElement( rsmd.getColumnName( i ) ); // busca dados das linhas do { linhas.addElement( proximaLinha( res, rsmd ) ); } while ( res.next() ); // Mostra a tabela com cabeçalhos e registros tab = new JTable( linhas, cabecalho ); JScrollPane scroller = new JScrollPane( tab ); getContentPane().add(scroller, BorderLayout.CENTER); validate(); st.close(); } catch (SQLException sqlex) { } } private Vector proximaLinha(ResultSet rs, ResultSetMetaData rsmd

) { Vector LinhaAtual = new Vector(); try { for ( int i = 1; i <= rsmd.getColumnCount(); ++i ) switch( rsmd.getColumnType(i)) { case Types.VARCHAR: LinhaAtual.addElement(rs.getString(i));break; case Types.TIMESTAMP: LinhaAtual.addElement(rs.getDate(i));break; }


124

} catch(SQLException e) {} return LinhaAtual; } } Explicação:

· Vetor cabecalho = new Vetor() – declara cabecalho como um objeto do tipo vetor · Vetor linhas = new Vetor() – armazena todas as linhas que vão compor a tabela · ResultSetMetaData rsmd = res.getMetaData() – res é o objeto que contém o resultado da consulta. Além do

resultado res mantém inclusive o nome das colunas dos campos da tabela consultada. Essa linha contém a utilização da interface ResultSetMetaData usada para realizar a leitura de ipos de dados e propriedades armazenadas em um objeto do tipo ResultSet

· A interface ResultSetMetaData possui uma série de métodos dentre os quais se destacam: o getColumnName() – usado para retornar o nome de uma coluna o getColumnType() – usado para descobrir o tipo de dado armazenado no campo o getColumnCount() – retorna o número de colunas existentes no objeto o addElement – adição dos elementos


125

Exemplo 6.

import java.sql.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; class Exemplo1305 extends JFrame implements ActionListener{ JLabel label1,label2,label3,label4,label5; JButton btGravar,

btAlterar,btExcluir,btNovo,btLocalizar,btCancelar; static JTextField

tfCodigo,tfTitulo,tfGenero,tfProdutora,tfDataCompra; JPanel painel1 = new JPanel(); ResultSet resultSet; Statement statement; public static void main(String args[]) { JFrame janela = new Exemplo1305(); janela.setUndecorated(true); janela.getRootPane().setWindowDecorationStyle(JRootPane.FRAME); janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); janela.setVisible(true); } Exemplo1305() { painel1.setLayout(new FlowLayout(FlowLayout.LEFT)); label1 = new JLabel("Código "); label2 = new JLabel("Título"); label3 = new JLabel("Gênero"); label4 = new JLabel("Produtora"); label5 = new JLabel("Data de Compra "); tfCodigo = new JTextField(10); tfCodigo.addActionListener(this); tfTitulo = new JTextField(35); tfGenero = new JTextField(10); tfProdutora = new JTextField(15); tfDataCompra = new JTextField(8); btGravar=new JButton("Gravar"); btAlterar=new JButton("Alterar"); btExcluir=new JButton("Excluir"); btLocalizar=new JButton("Localizar"); btNovo=new JButton("Novo"); btCancelar=new JButton("Cancelar"); btGravar.setBackground(new Color(180,180,250)); btAlterar.setBackground(new Color(180,180,250)); btExcluir.setBackground(new Color(180,180,250)); btLocalizar.setBackground(new Color(180,180,250)); btNovo.setBackground(new Color(180,180,250));


126

btCancelar.setBackground(new Color(180,180,250)); btGravar.addActionListener(this); btAlterar.addActionListener(this); btExcluir.addActionListener(this); btLocalizar.addActionListener(this); btNovo.addActionListener(this); btCancelar.addActionListener(this); painel1.add(label1); painel1.add(tfCodigo); painel1.add(label2); painel1.add(tfTitulo); painel1.add(label3); painel1.add(tfGenero); painel1.add(label4); painel1.add(tfProdutora); painel1.add(label5); painel1.add(tfDataCompra); painel1.add(btNovo); painel1.add(btLocalizar); painel1.add(btGravar);painel1.add(btAlterar); painel1.add(btExcluir);painel1.add(btCancelar); getContentPane().add(painel1); setTitle("Cadastramento de Filmes"); setSize(610,120); setResizable(false); setBotoes(true,true,false,false,false,false); carregaResultSet(); } public void actionPerformed(ActionEvent e){ if (e.getSource()==btNovo) { limpaCampos(); setBotoes(false,false,true,false,false,true); return; } if (e.getSource()==btCancelar) { limpaCampos(); setBotoes(true,true,false,false,false,false); return; } if (e.getSource()==btGravar) { try { String sql = "INSERT INTO

FILMES(codigo,titulo,genero,"+ "produtora,datacompra)values('"+ tfCodigo.getText()+"','"+ tfTitulo.getText()+"','"+ tfGenero.getText()+"','"+ tfProdutora.getText()+"','"+ tfDataCompra.getText()+"')"; statement.executeUpdate(sql); JOptionPane.showMessageDialog(null,

"Gravação realizada com sucesso!");

setBotoes(true,true,false,true,true,false);


127

} catch(SQLException erro) { if(erro.getMessage().equals("General erro")) JOptionPane.showMessageDialog(null, "Filme

já Cadastrado!"); else JOptionPane.showMessageDialog(null,"Data

Inválida!"); } carregaResultSet(); } //--------------------------Final da Inclusão -------------------

------------- if (e.getSource()==btAlterar) { try { String sql = "UPDATE Filmes SET"+ "codigo='"+tfCodigo.getText()+"',"+ "titulo='"+tfTitulo.getText()+"',"+ "genero='"+tfGenero.getText()+"',"+ "produtora='"+tfProdutora.getText()+"',"+ "datacompra='"+tfDataCompra.getText()+"'"+ "WHERE codigo ='"+tfCodigo.getText()+"'"; int r = statement.executeUpdate(sql); if(r==1) JOptionPane.showMessageDialog(null, "Alteração

realizada com sucesso"); else JOptionPane.showMessageDialog(null,"Problemas na

alteração."); setBotoes(true,true,false,true,true,false); } catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Data

inválida!"); } carregaResultSet(); } //------------------------------Final da Alteração -------------

--------------------- if(e.getSource()==btExcluir) //Excluir um registro { try { String sql = "SELECT codigo, titulo from filmes where

codigo= '"+tfCodigo.getText()+"'"; resultSet = statement.executeQuery(sql);


128

String nome = ""; try { resultSet.next(); nome="Deletar o

Filme:"+resultSet.getString("titulo"); } catch(SQLException ex1) { JOptionPane.showMessageDialog(null,"Filme não

encontrado!"); carregaResultSet(); return; } int n=JOptionPane.showConfirmDialog(null,nome,"

",JOptionPane.YES_NO_OPTION); if(n==JOptionPane.YES_OPTION) { sql="Delete from filmes where codigo='"+ tfCodigo.getText()+"'"; int r = statement.executeUpdate(sql); if(r==1)

JOptionPane.showMessageDialog(null,"Exclusão realizada com sucesso");

else

JOptionPane.showMessageDialog(null,"Não foi possível excluir o filme");

limpaCampos();

setBotoes(true,true,false,false,false,false); } } catch(SQLException erro){} carregaResultSet(); } //------------------------------Final da Exclusão ---------------

----------------------- if (e.getSource()==btLocalizar || e.getSource()==tfCodigo) { try { String SQL = "SELECT * FROM Filmes Where Ficodigo =

'"+tfCodigo.getText()+"'"; resultSet = statement.executeQuery(SQL); resultSet.next(); atualizaCampos(); setBotoes(true,true,false,true,true,false); } catch(SQLException ex) {


129

JOptionPane.showMessageDialog(null,"Filme nao Encontrado!"); carregaResultSet(); return; } } //---------------------------------------Final da localização----

--------------------------------------------- } public void carregaResultSet(){ String url = "jdbc:odbc:MeuBanco"; try { Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" ); Connection minhaConexao = DriverManager.getConnection(url); statement =

minhaConexao.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); resultSet = statement.executeQuery("SELECT * FROM Filmes"); } catch(ClassNotFoundException ex) { System.out.println("Driver JDBC-ODBC não encontrado!"); } catch(SQLException ex) { System.out.println("Problemas na conexao com a fonte de

dados"); } } /*em todas as operações realizadas com a tabela no banco de dados

é usados o mesmo objeto,declarado como resultSet. Este objeto armazena o resultado da operação SQL em memória. Por

esse motivo, a cada operação realizada fisicamente no banco de dados pelos comandos SQL, o objeto resultSet fica

com conteúdo diferente da tabela do banco de dados. Então, todas as vezes que o banco de dados é alterado, o objeto

resultSet precisa ser recarregado com todos os registros da tabela. O método carregaResultSet é responsável por realizar

a conexão com o banco de dados e incializar o objeto resultSet com todos os registros pelo comando "SELECT * FROM

FILMES". */ public static void limpaCampos() { tfCodigo.setText(""); tfTitulo.setText(""); tfGenero.setText(""); tfProdutora.setText(""); tfDataCompra.setText(""); } public void atualizaCampos() { try {


130

tfCodigo.setText(resultSet.getString("Ficodigo")); tfTitulo.setText(resultSet.getString("Finome")); tfGenero.setText(resultSet.getString("Figenero")); tfProdutora.setText(resultSet.getString("Fiprodut")); tfDataCompra.setText(""+resultSet.getDate("Fidatcom")); } catch(SQLException ex) { } } public void setBotoes(boolean bNovo,boolean bLocalizar,boolean

bGravar, boolean bAlterar, boolean bExcluir, boolean bCancelar) { btNovo.setEnabled(bNovo); btLocalizar.setEnabled(bLocalizar); btGravar.setEnabled(bGravar); btAlterar.setEnabled(bAlterar); btExcluir.setEnabled(bExcluir); btCancelar.setEnabled(bCancelar); } }

Documents

75759005 Apostila Java I