Apostila de Java Avançado

1
Índice
1 - Programação Visual – Swing.........................................................................................................................2
1.1) Introdução.................................................................................................................................................2
1.2) Componentes do Swing............................................................................................................................3
1.3) Execute 1: Documentação do Swing.........................................................................................................5
1.4) Criando uma interface...............................................................................................................................5
1.5) Desenvolvendo uma estrutura ..................................................................................................................6
1.6) Execute 2 Desenvolvendo uma estrutura..................................................................................................6
1.7) Criando Botões..........................................................................................................................................7
1.8) Execute 3: Criando botões.........................................................................................................................7
1.9) Criando Rótulos.........................................................................................................................................8
1.10) Execute 4: Criando Rótulos.....................................................................................................................8
1.11) Criando Campos de Texto.......................................................................................................................9
1.12) Execute 5: Criando campos de texto.....................................................................................................10
1.13) Criando Áreas de texto..........................................................................................................................11
1.14) Execute 6: Criando Áreas de Texto.......................................................................................................11
1.15) Criando Painéis deslizantes...................................................................................................................13
1.16) Execute 7: Criando painéis deslizantes................................................................................................14
1.17) Criando Barras de rolagem....................................................................................................................15
1.18) Execute 8: Criando Barras de Rolagem................................................................................................15
1.19) Criando Caixas de verificação...............................................................................................................16
1.20) Execute 9: Criando caixa de verificação...............................................................................................17
1.21) Criando botões de rádio.........................................................................................................................18
1.22) Execute 10: Criando botões de escolha.................................................................................................18
1.23) Listas suspensas e caixas de combinação..............................................................................................19
1.24) Execute 11: Criando listas suspensas....................................................................................................20
1.25) Caixas de Diálogo de confirmação........................................................................................................21
1.26) Execute 12: Caixa de diálogo de confirmação......................................................................................21
1.27) Caixas de diálogo de entrada.................................................................................................................22
1.28) Execute 13: Caixa de diálogo de entrada..............................................................................................22
1.29) Caixas de diálogo de mensagem...........................................................................................................22
1.30) Execute 14: Caixa de diálogo de mensagem.........................................................................................23
1.31) Caixas de diálogo de opção...................................................................................................................23
1.32) Execute 15: Caixa de diálogo de opção.................................................................................................24
1.33) Controles deslizantes.............................................................................................................................25
1.34) Execute 16: Controles deslizantes.........................................................................................................25
2 - Organizando componentes em uma interface com o usuário.......................................................................27
2.1) Layout de Fluxo......................................................................................................................................27
2.2) Execute 17: Gerenciador FlowLayout.....................................................................................................27
2.3) Layout de grade.......................................................................................................................................28
2.4) Execute 18: Gerenciador GridLayout.....................................................................................................28
2.5) Layout de Borda......................................................................................................................................29
2.6) Execute 19: Gerenciador BorderLayout..................................................................................................30
3 - Respondendo à entrada do usuário...............................................................................................................31
3.1) Receptores de evento..............................................................................................................................31
3.2) Configurando componentes.....................................................................................................................32
3.3) Evento de Ação........................................................................................................................................33
3.4) Execute 20: Evento de Ação....................................................................................................................33
3.5) Eventos de foco.......................................................................................................................................35
3.6) Execute 21: Evento de foco.....................................................................................................................35
3.7) Eventos de tecla.......................................................................................................................................36
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

CEP - 70331-550 Brasília - DF
2
3.8) Execute 22: Evento de tecla....................................................................................................................36

3.9) Eventos de mouse....................................................................................................................................38
3.10) Execute 23: Evento de mouse...............................................................................................................38
3.11) Eventos de movimento de mouse..........................................................................................................40
3.12) Execute 24: Evento de Movimento do Mouse......................................................................................40
3.13) Eventos de janela...................................................................................................................................41
3.14) Execute 25: Evento de Janela................................................................................................................41
3.15) Criando Menus......................................................................................................................................43
3.16) Execute 26: Criando Menus..................................................................................................................43
3.17) Criando Barra de Ferramentas...............................................................................................................46
3.18) Execute 27: Criando barra de ferramentas............................................................................................46
3.19) Exercícios de Revisão do capitulo I......................................................................................................48
4 - Aplicações e Primitiva Gráficas...................................................................................................................51
4.1) Linhas.....................................................................................................................................................51
4.2) Execute 28:Criando Linhas.....................................................................................................................51
4.3) Retângulos e Quadrados..........................................................................................................................52
4.4) Execute 29:Criando Retângulos e Quadrados.........................................................................................52
4.5) Elipses e Circunferências.......................................................................................................................53
4.6) Execute 30: Criando Elipse e Circunferências........................................................................................53
4.7) Polígonos................................................................................................................................................54
4.8) Execute 31: Criando Elipse e Circunferências........................................................................................55
4.9) Melhorando as Aplicações usando primitivas gráficas..........................................................................56
4.10) Execute 32Criando Linhas e Elipse.......................................................................................................56
4.11) Execute 33Criando Retângulos com gráficos........................................................................................57
4.12) Execute 34Criando Retângulos com gráficos.......................................................................................58
5 - Threads.........................................................................................................................................................60
5.1) O que são threads? .................................................................................................................................60
5.2) Os estados de uma thread.......................................................................................................................61
5.3) Threads em Applets................................................................................................................................63
5.4) Herdando de Thread x Implementando Runnable...................................................................................64
5.5) Execute 35: Trabalhando com Thread.....................................................................................................64
5.6) Execute 36:Trabalhando com Thread......................................................................................................66
5.9) Execute 39Trabalhando com Thread.......................................................................................................72
6 - Acessando Banco de Dados..........................................................................................................................75
6.1) Acessando bancos de dados em JDBC ..................................................................................................76
6.2) Execute 40- Trabalhando com Banco de Dados......................................................................................78
6.3) Execute 41- Trabalhando com Banco de Dados......................................................................................81
6.4) Execute 42: Trabalhando com Banco de Dados......................................................................................86
7 - JSP (Java Server Page).................................................................................................................................98
7.1) O que é JSP?............................................................................................................................................98
1 - Programação Visual – Swing
1.1) Introdução
O Swing é um biblioteca de classes para a construção de interface gráfica baseada em
componentes leves.
3
O Swing, que faz parte da biblioteca Java Foundation Classes, oferece uma maneira de
fornecer uma interface gráfica com o usuário em seus programas Java e de receber
entradas do usuário com o teclado, o mouse ou outros dispositivos de entrada.
De acordo com a Sun o nome correto é “JFC Project Swing” padrão na plataforma Java 2
(1.2).
A biblioteca Swing é uma extensão do Abstract Windowing Toolkit (awt), o pacote que
oferecia suporte limitado para programação gráfica na linguagem Java 1.0.
O Swing oferece uma funcionalidade bastante aprimorada em relação ao seu antecessor:
novos componentes, recursos de componente expandidos, melhor tratamento de eventos,
aparência e comportamento selecionáveis.
Vantagens do Swing:
Swing tem um rico conjunto de componentes (muito mais que a AWT);
Swing depende muito menos da plataforma nativa;
Swing mantém o mesmo padrão entre várias plataformas.
Desvantagem do Swing:
Compatibilidade: requer Java 1.2 ou superior;
Desempenho: componentes são desenhados em Java.
1.2) Componentes do Swing

Os componentes podem ser divididos da seguinte forma:
Componentes Superiores:
JFrame: janelas que possuem uma barra de título, botões de maximização e fechamento.
JDialog: janelas usadas para fornecer diálogos com os usuários;
JApplet: aplicações que serão mostradas em um browser;
Componentes Intermediários:
JPanel: painéis que podem ser adicionados em janelas para facilitar a disposição dos
componentes de uma interface.
JScrollPane: painéis que podem ser adicionados em janelas e que possuem barras de
rolagens.
JToolBar: barras de ferramentas que podem ser adicionadas em janelas.
JInternalFrame: frames que podem ser adicionados internamentes a outros frames.
Componentes Internos:
JLabel: componente usado para mostrar rótulos (textos) ou elementos gráficos que
fornecem informações;
JButton: regiões clicáveis com texto ou elementos gráficos que indicam seu objetivo;
JTextField: campo de textos que recebem entradas do teclado e permitem que o texto
seja editado;
JComboBox: grupos de itens relacionados que podem ser selecionados a partir de menus
suspensos;
JRadioButton: botões de escolha em círculos que podem ser marcados ou desmarcados.
JCheckBox: caixas de verificação que podem ser marcadas ou desmarcadas.
JButtonGroup: agrupar componentes de caixa de verificação e botões de escolha;
4
JList: grupos de itens relacionados que podem ser selecionados a partir de janelas
rolantes;
JTextArea: áreas de texto que recebem entradas do teclado e permitem que o texto seja
editado;
JSlider: controles deslizantes horizontais;
JProgressBar: barras de progresso;
JMenuBar: barras de menus;
JMenu; componentes para inserir menus em um barra de menu;
JMenuITem: componentes para inserir itens de menus em um menu.

5
1.3) Execute 1: Documentação do Swing
1) Abra o meu computador

2) Duplo clique no Disco local C:
3) Duplo clique na pasta do SDK do java: j2sdk1.4.2_04
4) Duplo clique na pasta docs
5) Duplo clique no arquivo index.html
6) Clique no link API & Language, clique no link Java 2 Platform API Specification
7) A seguinte tela é mostrada:
8) Clique no link do pacote Swing: javax.swing

9) Veja os componentes do swing.
1.4) Criando uma interface

O primeiro passo na criação de um aplicativo Swing é gerar uma classe que represente a
interface com o usuário. Um objeto dessa classe servirá como contêiner, o componente
que contém todos os outros componentes que serão apresentados.
Em muitos projetos, o principal objeto da interface será uma janela simples (Jwindow) ou
uma janela mais especializada chamada de quadro (JFrame).

6
Uma janela é um contêiner que pode ser apresentado na área de trabalho do usuário.
1.5) Desenvolvendo uma estrutura
Uma maneira de criar um aplicativo gráfico Swing é tornar a interface uma sub-classe de
JFrame.
1.6) Execute 2 Desenvolvendo uma estrutura

1) Abra o Jcreator;
2) Digite o seguinte código:
// ExemploFrame.java
import javax.swing.*;
public class ExemploFrame extends JFrame { // sub-classe JFrame
// construtor
public ExemploFrame(){
super("Exemplo de Frame"); // construir uma janela com o título
setSize(300,100); // uma janela com 300 x 100
setDefaultCloseOperation(EXIT_ON_CLOSE); // método para fechar janela
setVisible(true); // método para tornar a janela visível
}
public static void main (String[] a){

ExemploFrame e = new ExemploFrame();
}
}
3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

7
Todo quadro tem botões de maximização, minimização e fechamento na barra de título

sob controle do usuário (os mesmos controles presentes na interface de outros programas
de software que estejam em execução em seu sistema). Na linguagem Java, o
comportamento normal quando um quadro é fechado é continuar a execução do
aplicativo.
Para mudar isso, você deve chamar o método setDefaultCloseOperation() do quadro com
uma das quatro variáveis de classe JFrame como argumento:
EXIT_ON_CLOSE: Sai do programa quando o quadro é fechado.
DISPOSE_ON_CLOSE: fecha o quadro, desfaz-se do objeto quadro e continua
executando o aplicativo.
DO_NOTHING_ON_CLOSE: mantém o quadro aberto e contínua executando.
HIDE_ON_CLOSE: fecha o quadro e continua executando.
1.7) Criando Botões

Um botão do Swing pode apresentar um rótulo de texto, um ícone gráfico ou uma
combinação de ambos.
Os métodos construtores que você pode usar incluem:
JButton(String): cria um botão rotulado com o texto especificado.
JButton(Icon): cria um botão que apresenta o ícone especificado.
JButton(String,Icon): cria um botão com o texto e o ícone especificados.
1.8) Execute 3: Criando botões
1) Abra o Jcreator
2) Digite o código abaixo:
// ExemploBotao.java
public class ExemploBotao extends JFrame {

// atributos
private JButton rotulo = new JButton("Botões Rótulados");
private JButton rotuloicone = new JButton("Botões Rótulados e Ícones",new
ImageIcon("logo.gif"));
private JButton icone = new JButton(new ImageIcon("logo.gif"));
private JPanel painel = new JPanel();
// construtor
public ExemploBotao(){
super("Exemplo Botão");
setSize(200,130);
setDefaultCloseOperation(EXIT_ON_CLOSE);
// adicionar os botões no painel
painel.add(rotulo);
8
painel.add(rotuloicone);
painel.add(icone);
setContentPane(painel);
show();
}
public static void main(String[] argumentos){

ExemploBotao b = new ExemploBotao();
}
}
1.9) Criando Rótulos

Um rótulo é um componente de usuário que contém texto informativos, um ícone ou
ambos. Criado a partir da classe JLabel, um rótulo é usado muitas vezes para identificar o
objetivos de outros componentes em uma interface. O rótulo não pode ser editado
diretamente por um usuário.
Para criar um rótulo, você pode usar os seguintes construtores:
JLabel (String): um rótulo com o texto especificado.
JLabel (String, Int): um rótulo com o texto e o alinhamento especificados
JLabel (String, Icon, Int): um rótulo com o texto, o ícone e o alinhamento especificados
O alinhamento de um rótulo determina como seu texto ou ícone esta alinhado em relação
área ocupada na janela. Três alinhamentos podem ser usados: LEFT, CENTER ou
RIGHT. Caso não seja especificado o alinhamento o padrão é CENTER.
1.10) Execute 4: Criando Rótulos
1) Abra o Jcreator
// ExemploRotulo.java
public class ExemploRotulo extends JFrame {

9
// atributos
private JLabel texto = new JLabel("Rótulo com texto alinhamento centralizado
");
private JLabel textoalinhar = new JLabel("Rótulo com texto alinhado a
esquerda",JLabel.LEFT);
private JLabel textoicone = new JLabel("Rótulo com texto, Ícone alinhado a
direita",new ImageIcon("logo.gif"),JLabel.RIGHT);
// construtor
public ExemploRotulo(){
super("Exemplo Rótulos");
setSize(350,150);
// adicionando os rótulos no painel
painel.add(texto);
painel.add(textoalinhar);
painel.add(textoicone);
show();
}

ExemploRotulo r= new ExemploRotulo();
}
}
1.11) Criando Campos de Texto

Um campo de texto é uma área em uma interface onde um usuário pode introduzir e
modificar texto com um teclado. Ele, que é representado pela classe JTextField, pode
manipular uma linha de entrada.
10
Os métodos construtores incluem o seguinte:

JTextField(): um campo de texto vazio
JTextField(int): um campo de texto com largura especificada
JTextField(String, int): um campo de texto com o texto e a largura especificados
1.12) Execute 5: Criando campos de texto

1) Abra o jcreator
2) Digite o código:
// ExemploCampoTexto.java
public class ExemploCampoTexto extends JFrame {

// atributos
private JTextField vazio = new JTextField();
private JTextField largura = new JTextField(30);
private JTextField textolargura = new JTextField("Hytec Informática",25);
// construtor
public ExemploCampoTexto(){
super("Exemplo Campo Texto");
setSize(350,150);
// adicionando os campos de texto no painel
painel.add(vazio);
painel.add(largura);
painel.add(textolargura);
show();
}

ExemploCampoTexto t= new ExemploCampoTexto();
}
}

11
1.13) Criando Áreas de texto

As áreas de texto, campos de texto editável que manipulam mais de uma linha de
entrada, são implementados com a classe JTextArea.
Essa classe inclui os seguintes métodos construtores:
JTextArea(int, int): uma área de texto com o número especificado de linhas e colunas
JTextArea(String, int, int): uma área de texto com o texto, as linhas e as colunas
especificados
1.14) Execute 6: Criando Áreas de Texto
1) Abra o Jcreator
// ExemploAreaTexto.java
public class ExemploAreaTexto extends JFrame {

// atributos
private JTextArea lincol = new JTextArea(5,30);
private JTextArea textolincol = new JTextArea("Digite o texto aqui",12,40);
// construtor
public ExemploAreaTexto(){
super("Exemplo Area de Texto");
setSize(450,350);
// adicionando area de texto no painel
painel.add(lincol);
painel.add(textolincol);
show();
}
12

ExemploAreaTexto a= new ExemploAreaTexto();
}
}

13
1.15) Criando Painéis deslizantes

As áreas de texto no Swing não incluem barras de rolagem horizontal ou vertical e não
existem maneiras de incluí-las usando o componente sozinho. Essa é uma diferença entre
as áreas de texto do Swing e suas equivalentes no AWT.
O motivo da mudança é que Swing introduz um novo contêiner que pode ser usado para
conter qualquer componente que possa se rolado: JScrollPane.
Um painel deslizante é associado a um componente no método construtor do painel. Você
pode usar o seguinte:
JScrollPane(Component): um painel deslizante que contém o componente especificado
JScrollPane(Component, int, int): um painel deslizante com o componente, a configuração
da barra de rolagem vertical e a configuração da barra de rolagem horizontal
especificados
As barras de rolagens são configuradas usando:

VERTICAL_SCROLLBAR_ALWAYS ou HORIZONTAL_SCROLLBAR_ALWAYS: sempre
colocar a barra de rolagem
VERTICAL_SCROLLBAR_AS_NEED ou HORIZONTAL_SCROLLBAR_AS_NEED:
colocar quando for necessário a utilização das barras na janela
VERTICAL_SCROLLBAR_NEVER ou HORIZONTAL_SCROLLBAR_NEVER: não colocar
a barra de rolagem

14
1.16) Execute 7: Criando painéis deslizantes
1) Abra o Jcreator
//ExemploPaineisdes.java
public class ExemploPaineisdes extends JFrame {
JPanel pane = new JPanel();

JTextArea letras = new JTextArea(5,15);
JScrollPane rolar = new
JScrollPane(letras,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZO
NTAL_SCROLLBAR_NEVER);
public ExemploPaineisdes(){
super("Exemplo de Paineis Deslizantes");
setSize(300,300);
pane.add(rolar);
setContentPane(pane);
show();
}
public static void main(String a[]){

ExemploPaineisdes p = new ExemploPaineisdes();
}
}

15
1.17) Criando Barras de rolagem

As barras de rolagem são componentes que permitem selecionar um valor através da
movimentação de um elevador entre duas setas. Vários componentes tem funcionalidade
de barra de rolagem interna, incluindo áreas de texto e listas rolantes.
Normalmente, as barras de rolagem são criadas especificando os valores mínimos e
máximo que podem ser configurados com o componente.
Você pode usar os seguintes métodos contrutores:
JScrollBar(int): uma barra de rolagem com a orientação especificada
JScrollBar(int, int, int, int, int): uma barra de rolagem com a orientação, o valor inicia, o
tamanho do elevador, o valor mínimo e o valor máximo especificados.
A orientação é indicada pelas variáveis de classe JScrollBar, HORIZONTAL e VERTICAL.
1.18) Execute 8: Criando Barras de Rolagem
1) Abra o Jcreator
//ExemploBarraRola.java
public class ExemploBarraRola extends JFrame {

JScrollBar bvertical = new JScrollBar(JScrollBar.VERTICAL);
16
JScrollBar bhorizontal = new JScrollBar(JScrollBar.HORIZONTAL);

JScrollBar barrarola = new JScrollBar(JScrollBar.HORIZONTAL,33,0,10,50);
JPanel painel = new JPanel();
public ExemploBarraRola(){
super("Exemplo de Barra de Rolagem");
setSize(400,200);
painel.add(bvertical);
painel.add(bhorizontal);
painel.add(barrarola);
show();
}
ExemploBarraRola r = new ExemploBarraRola();

}
}
1.19) Criando Caixas de verificação

A caixas de verificação é componente que tem apenas dois valores possíveis:
selecionado ou não selecionado. Pode ser agrupado de modo que apenas um
componente em um grupo possa ser selecionado por vez.
As caixas de verificação (a classe JCheckBox) são caixas rotuladas, ou não, que contêm
uma marca de seleção quando estão selecionadas e nada no caso contrário.
Este componente costuma ser usado para fazer uma escolha simples do tipo sim-não ou
ligado-desligado em um programa.
A classe JChecBox, inclui os seguintes métodos construtores:
JCheckBox(String): uma caixa de verificação com o rótulo de texto especificado

17
JCheckBox(String,boolean): uma caixa de verificação com o rótulo de texto especificado

que é selecionada se o segundo argumento for true
JCheckBox(Icon): uma caixa de verificação com rótulo de ícone especificado
JCheckBox(Icon,boolean): uma caixa de verificação com o rótulo de ícone especificado
1.20) Execute 9: Criando caixa de verificação
1) Abra o Jcreator
// ExemploCheckBox.java
public class ExemploCheckBox extends JFrame {
JCheckBox[] ensino = new JCheckBox[4];

JLabel lensino = new JLabel("Ensino: ");
public ExemploCheckBox(){
super("Exemplo de Caixa de Verificação");

setSize(400,100);
ensino[0] = new JCheckBox("Fundamental",true);
ensino[1] = new JCheckBox("Médio",false);
ensino[2] = new JCheckBox("Superior",false);
ensino[3] = new JCheckBox("Técnico",false);

painel.add(lensino);
for (int i=0;i<4;i++){
painel.add(ensino[i]);
}
show();
}
public static void main(String[] a){
ExemploCheckBox b = new ExemploCheckBox();

}

18
1.21) Criando botões de rádio

Os botões de rádio são componentes que têm apenas dois valores possíveis: selecionado
ou não selecionado. Podem ser agrupado de modo que apenas um componente em um
grupo possa ser selecionado por vez.
Os botões de rádio (a classe JRadioButton) são círculos que contêm um ponto quando
selecionados e, do contrário, também ficam vazios.
Esse componente costumam ser usados para fazer uma escolha simples do tipo sim-não
ou ligado-desligado em um programa.
Os seguintes construtores estão disponíveis para a classe JRadioButton:
JRadioButton(String): um botão de escolha com o rótulo de texto especificado
JRadioButton(String,boolean): um botão de escolha com o rótulo de texto especificado
JRadioButton(Icon): um botão de escolha com rótulo de ícone especificado
JRadioButton(Icon,boolean): um botão de escolha com o rótulo de ícone especificado que
é selecionada se o segundo argumento for true
O objeto ButtonGroup controla todos os botões de escolha em seu grupo. Chame o
método add(Component) do grupo para incluir o componente especificado nele.
1.22) Execute 10: Criando botões de escolha
1) Abra o Jcreator
//ExemploRadioButton.java
public class ExemploRadioButton extends JFrame {

JLabel lsexo = new JLabel("Sexo:");
JRadioButton feminino = new JRadioButton("Feminino");

19
JRadioButton masculino = new JRadioButton("Masculino");

ButtonGroup grupo = new ButtonGroup();
public ExemploRadioButton(){
super("Exemplos de Botões de Escolha");
setSize(300,100);
grupo.add(feminino);
grupo.add(masculino);
painel.add(lsexo);
painel.add(feminino);
painel.add(masculino);
show();

ExemploRadioButton r = new ExemploRadioButton();
}
}
1.23) Listas suspensas e caixas de combinação

A classe JcomboBox de Swig pode ser usada para criar dois tipos de componentes de
interface com o usuário: listas suspensas e caixas de combinação.
As listas suspensas, também chamadas de listas de ecolha, são componentes que
permitem que um único item seja escolhido em uma lista. Esta, pode ser configurada para
que apareça apenas quando um usuário clicar no componente, ocupando menos espaço
em uma interface gráfica com o usuário.
As caixas de combinação são lista suspensas com um recurso extra: um campo de texto
que também pode ser usado para fornecer uma resposta.
As etapas a seguir mostram como uma lista suspensa poder ser criada:
O construtor JcomboBox() é usado sem argumentos.
O método addItem(Object) da caixa de combinação inclui itens na lista.

20
1.24) Execute 11: Criando listas suspensas
1) Abra o Jcreator
//ExemploLista.java
import javax.swing.*
public class ExemploLista extends JFrame {
JComboBox mes = new JComboBox();
JComboBox ano = new JComboBox();
public ExemploLista(){
super(“Exemplo de Listas suspensas”);
setSize(220,90);
JLabel niver = new JLabel(“Aniversário: ”);
painel.add(niver);
for (int i=1; i<13;i++){
mes.addItem(“”+i);
}
for (int i=1900;i < 2100;i++){
ano.addItem(“”+i);
}
painel.add(mes);
painel.add(ano);
show();
}
public static void main (String a[]){

ExemploLista l = new ExemploLista();
}
}
3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

21
1.25) Caixas de Diálogo de confirmação

A classe JOptionPane oferece vários métodos que podem ser usados para criar caixas de
diálogo padrão: pequenas janelas que fazem uma pergunta, avisam o usuário ou
fornecem uma breve mensagem importante.O modo mais fácil de criar uma caixa de
diálogo do tipo Yes/No/Cancel é com a chamada de método
ShowConfirmDialog(Component, Object). O argumento Component especifica o contêiner
que deve ser considerado a origem da caixa de diálogo e essa informação é usada para
determinar o local na tela no qual a janela de diálogo e essa informação é usada para
determinar o local na tal no qual a janela de diálogo deve ser apresentada. Se null for
usado, ou se o contêiner não for um objeto Frame, a caixa de diálogo ficará centralizada
na tela. O segundo argumento, Object, pode ser uma string, um componente ou um objeto
Icon. Se for uma string, o texto será apresentando na caixa de diálogo. Se for um
componente ou um ícone, o objeto será apresentado no lugar de uma mensagem de
texto.
Esse método retorna um de três valores inteiros possíveis e cada um deles é uma variável
de classe de JOptionPane: YES_OPTION, NO_OPTION e CANCEL_OPTION.
1.26) Execute 12: Caixa de diálogo de confirmação
1) Abra o Jcreator
// ExemploConfirma.java
public class ExemploConfirma extends JFrame {
public ExemploConfirma(){
int resposta;
resposta = JOptionPane.showConfirmDialog(null,"Tem Certeza que desja sair?");
if (resposta == 0)
System.exit(0);
}

ExemploConfirma c = new ExemploConfirma();
}
}

22
1.27) 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(Component, Object). Os argumentos são o
componente de origem e a string, o componente ou ícone a ser apresentado na caixa.
A chamada de método da caixa de diálogo de entrada retorna uma string que representa
a resposta do usuário.
1.28) Execute 13: Caixa de diálogo de entrada
1) Abra o Jcreator
//ExemploEntrada.java
public class ExemploEntrada extends JFrame {
public ExemploEntrada(){
String resposta = JOptionPane.showInputDialog(null, "Entre seu nome:");
}
public static void main(String [] a){

ExemploEntrada e = new ExemploEntrada();
}
1.29) Caixas de diálogo de mensagem

Uma caixa de diálogo de mensagem é uma janela simples que apresenta informações.
Ela pode ser criada com uma chamada ao método showMessageDialog(Component,
Object). Assim como nas outras caixas de diálogo, os argumentos são os componentes

23
de origem e a string, o componente ou ícone que será apresentado. Ao contrário das

outras, as caixas de diálogo de mensagem não retorna nenhum tipo de valor de reposta.
1.30) Execute 14: Caixa de diálogo de mensagem
1) Abra o Jcreator
//ExemploMens.java
public class ExemploMens extends JFrame {
public ExemploMens(){
JOptionPane.showMessageDialog(null, "Instalação Concluída");
}

ExemploMens m = new ExemploMens();
}
1.31) Caixas de diálogo de opção

A mais complexa das caixas de diálogo é a caixa de diálogo de opção, que combina os
recursos de todas. Ela pode ser criada com o método showOptionDialog(Component,
Object, String, int, int,Icon, Object[],Object). Os argumentos desse método são os
seguintes:
O componente de origem da caixa de diálogo
O texto, ícone ou componente que será apresentado.
Uma string que será apresentada na barra de título.
O tipo de caixa , usando as variáveis de classe YES_NO_OPTION,
YES_NO_CANCEL_OPTION ou o literal 0 se outros botões forem usados no lugar
desses.
O ícone que será apresentado, usando as variáveis de classe ERRO_MESSAGE,
INFORMATION_MESSAGE, PLAIN_MESSAGE, QUESTION_MESSAGE ou
WARNING_MESSAGE ou o literal 0 se nenhuma dessas deve ser usada.
24
Um objeto Icon que será apresentado no lugar de um dos ícones do argumento anterior.
Um array de objetos contendo os componentes ou outros objetos que representem as
opções da caixa de diálogo, caso YES_NO_OPTION e YES_NO_CANCEL_OPTION não
estejam sendo usadas.
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 último argumentos permitem que você crie uma ampla gama de opções para a
caixa de diálogo. É possível criar um array de botões, rótulos, campos de texto ou mesmo
uma mistura de diferentes componentes como um array de objetos. Esses componentes
são apresentados usando o gerenciador de layout de fluxo – não existe um modo de
especificar um gerenciador diferente dentro da caixa de diálogo.
1.32) Execute 15: Caixa de diálogo de opção
1) Abra o Jcreator
//ExemploOpcao.java
public class ExemploOpcao extends JFrame {
public ExemploOpcao(){
JButton[] sexo = new JButton[3];
sexo[0] = new JButton("Feminino");
sexo[1] = new JButton("MAsculino");
sexo[2] = new JButton("Não Responder");
int reposta = JOptionPane.showOptionDialog(null, "Qual o sexo?","Sexo",
0,JOptionPane.INFORMATION_MESSAGE, null,sexo,sexo[2]);
}

ExemploOpcao o = new ExemploOpcao();
}

25
1.33) Controles deslizantes

Os controles deslizantes, ques são implementados no Swing com a classe JSlider,
permitem que um número seja configurado através da movimentação de um controle
dentro do intervalo de um valor mínimo e um máximo. Em muitos casos, eles podem ser
usados para entrada numérica no lugar de uma caixa de texto e têm a vantagem de
restringir a entrada a um intervalo de valores aceitáveis. Os controles deslizantes são
horizontais por padrão. Você poder usar os seguintes métodos contrutores:
JSlider(int, int): um controle deslizante com os valores mínimo e máximo especificados.
JSlider(int, int, int): um controle deslizante com o valor mínimo. o máximo e o inicial
especificados.
JSlider(int, int, int, int): um controle deslizante com a orientação e os valores mínimos,
máximo e inicial especificados.
Os elementos do rótulo do componente são estabelecidos através da chamada de vários

métodos de JSlider:
setMajorTickSpacing(int): separa as marcas de seleção principais pela distância
especificada. A distância não é um pixels, mas em valores entre o mínimo e o máximo
representados pelo controle deslizante.
setMinorTickSpacing(int): separa marcas de seleçaõ scundárias pela distância
especificada. Elas são apresentadas com a metade da altura das principais.
setPaintTicks(boolean): determina se as marcas de seleção devem ser apresentadas (um
argumento true) ou não (um argumento false).
setPaintLabels(boolean): determinase o rótulo numéricodo controle deslizante deve ser
apresentado (true) ou não (false).
Esses métodos devem ser chamados no controle deslizante antes que ele seja inserido
em um contêiner.
1.34) Execute 16: Controles deslizantes
1) Abra o Jcreator
//ExemploSlider.java
public class ExemploSlider extends JFrame{
public ExemploSlider(){
super("Exemplo de Slider");
setSize(400,100 );
JSlider num = new JSlider(JSlider.HORIZONTAL, 0,30,5);


26
num.setMajorTickSpacing(10);
num.setMinorTickSpacing(1);
num.setPaintTicks(true);
num.setPaintLabels(true);
painel.add(num);
show();
}

ExemploSlider s = new ExemploSlider();
}
}

27
2 - Organizando componentes em uma interface com o usuário

Para impor algum tipo de forma um uma interface na linguagem Java, você deve usar um
conjunto de classes chamadas gerenciadores de layout. Um gerenciador de layout
determina como os componentes serão organizados ao serem inseridos em um contêiner.
O gerenciador de layout padrão para painéis é a classe FlowLayout. O gerenciador de
layout padrão para os frames é a Classe BorderLayout.
2.1) Layout de Fluxo

A classe FlowLayout representa o mais simples dos gerenciadores de layout. Ela dispõe
os componentes de maneira 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
próxima linha. Por padrão, os componentes de cada linha serão centralizados quando
você usar o construtor FlowLayout() sem argumentos. Se quizer que os componentes
fiquem alinhados na margem esquerda ou direita do contêiner, a variável de classe
FlowLayout.LEFT ou FlowLayout.RIGHT deve ser o único argumento do construtor.
2.2) Execute 17: Gerenciador FlowLayout
1) Abra o Jcreator
//ExemploFlowLayout.java
import java.awt.*;
public class ExemploFlowLayout extends JFrame {

JButton b1 = new JButton("Um");
JButton b2 = new JButton("Dois");
JButton b3 = new JButton("Três");
JButton b4 = new JButton("Quatro");
JButton b5 = new JButton("Cinco");
JButton b6 = new JButton("Seis");
JButton b7 = new JButton("Sete");
JButton b8 = new JButton("Oito");
JButton b9 = new JButton("Nove");
public ExemploFlowLayout(){
super("Exemplo FlowLayout");
setSize(360,120);
FlowLayout l = new FlowLayout(FlowLayout.LEFT);
painel.setLayout(l);
painel.add(b1);

28
painel.add(b2);
painel.add(b3);
painel.add(b4);
painel.add(b5);
painel.add(b6);
painel.add(b7);
painel.add(b8);
painel.add(b9);
show();
}

ExemploFlowLayout f = new ExemploFlowLayout();
}
}
2.3) Layout de grade

O gerenciador de layout de grade organiza os componentes em uma grade de linhas e
colunas. Os componentes são incluídos primeiro na linha superior da grade, começando
pela célula mais às esquerda e continuando para direta da grade. Quando todas as
células da linha superior estiverem preenchidas, o próximo componente será inserido na
célula mais à esquerda da segunda linha da grade – se houver – e assim por diante. Os
layout de grade são criados com a Classe GridLayout. Dois argumentos são enviados
para o construtor GridLayout – o número de linhas na grade e o número de colunas.
2.4) Execute 18: Gerenciador GridLayout
1) Abra o Jcreator
//ExemploGridLayout.java
import java.awt.*;

29
public class ExemploGridLayout extends JFrame {

JButton b1 = new JButton("Um");
JButton b2 = new JButton("Dois");
JButton b3 = new JButton("Três");
JButton b4 = new JButton("Quatro");
JButton b5 = new JButton("Cinco");
JButton b6 = new JButton("Seis");
JButton b7 = new JButton("Sete");
JButton b8 = new JButton("Oito");
JButton b9 = new JButton("Nove");
public ExemploGridLayout(){
super("Exemplo GridLayout");
setSize(360,120);
GridLayout g = new GridLayout(3,3);
painel.setLayout(g);
painel.add(b1);
painel.add(b2);
painel.add(b3);
painel.add(b4);
painel.add(b5);
painel.add(b6);
painel.add(b7);
painel.add(b8);
painel.add(b9);
show();
}

ExemploGridLayout f = new ExemploGridLayout();
}
}
2.5) Layout de Borda

Os layouts de borda, que são criados usando a classe BorderLayout, dividem um
contêiner em cinco seções: norte, sul, leste, oeste e centro.

30
2.6) Execute 19: Gerenciador BorderLayout
1) Abra o Jcreator
//ExemploBorder.java
import java.awt.*;
public class ExemploBorderLayout extends JFrame {

JButton btnorte = new JButton("Norte");
JButton btsul = new JButton("Sul");
JButton btleste = new JButton("Leste");
JButton btoeste = new JButton("Oeste");
JButton btcentro= new JButton("Centro");
public ExemploBorderLayout(){
super("Exemplo BorderLayout");
setSize(360,360);
BorderLayout b = new BorderLayout();
painel.setLayout(b);
painel.add(btnorte,BorderLayout.NORTH); // botão norte
painel.add(btsul,BorderLayout.SOUTH); // botão sul
painel.add(btleste,BorderLayout.EAST); // botão leste
painel.add(btoeste,BorderLayout.WEST); // botão oeste
painel.add(btcentro,BorderLayout.CENTER); // botão centro
show();
}

ExemploBorderLayout eb = new ExemploBorderLayout();
}
}

31
3 - Respondendo à entrada do usuário

Para transformar uma interface Java em um programa que funcione, você precisa tornar a
interface receptiva aos eventos de usuário.
O Swing manipula eventos com um conjunto de interfaces chamadas receptores de
evento. Um objeto receptor é criado e associado ao componente de interface com o
usuário que esta sendo recebido.
3.1) Receptores de evento

Se uma classe quiser responder a um evento de usuário no sistema de tratamento de
eventos da linguagem Java 2, deverá implementar a interface que trata dos eventos.
Essas interfaces são chamadas de receptores de evento.
Cada receptor lida com um tipo específico de evento e uma classe pode implementar
quantos forem necessários.
Os receptores de evento da linguagem Java incluem cada uma das seguintes interfaces:
ActionListener: Eventos de ação, que são gerados por um usuário agindo sobre um
componente, como um clique de mouse em um botão
AdjustmentListener: Eventos de ajuste, que são gerados quando um componente é
ajustado, como quando uma barra de rolagem é movida

32
FocusListener: Eventos de foco de teclado, que são gerados quando um componente,

como um campo texto, ganha ou perde o foco
ItemListener: Eventos de item, que são gerados quando um item, como uma caixa de
verificação, é alterado
KeyListener: Eventos de teclado, que ocorrem quando um usuário digita texto no teclado
MouseListener: Eventos de mouse, que são gerados por cliques de mouse, por um mouse
entrando na área de um componente e por um mouse deixando a área de um
componente
MouseMotionListener: Eventos de movimentos do mouse, que controlam toda a

movimentação de um mouse sobre um componente
TextListener: Eventos de texto, que controlam todas a ação efetuada em um texto
WindowListener: Eventos de janela, que são gerados por uma janela (como a janela
principal do aplicativo) ao ser minimizada, maximizada, movida ou fechada
A classe a seguir declara de modo a poder tratar de eventos de ação e de texto:
public class Tratamento extends Jframe implements ActionListener, TextListener {
//....
Ao colocar o implements é usada as interface ActionListener e TextListener para tratar os

eventos de ação e de texto.
3.2) Configurando componentes

Ao transformar um classe em um receptor de evento, é preciso configurar um tipo
específico de evento que será captado por essa classe. Isso acontecerá se você não der
um segundo passo: um receptor correspondente dever ser incluído no componente.
Ele gerará os eventos quando o componente for usado.
Depois que um componente for criado, você pode chamar um dos seguintes métodos
para associar um receptor a ele:
addActionListener(): Componentes Jbutton, JcheckBox, JcomboBox, JtextField e
JRadionButton
addAdjustmentListener(): Componentes JscrollBar
addFocusListener: Todos os componentes Swing
addITemListener: Componentes Jbutton, JcheckBox, JcomboBox e JradioButton
addKeyListener: Todos os componentes do Swing
addMouseListener: Todos os componentes do Swing
addMouseMotionListener: Todos os componentes do Swing

33
addWindowListener: Todos os componentes Jwindow e JFrame
O exemplo a seguir cria um objeto Jbutton e associa um receptor de evento de ação a ele:
JButton excluir = new JButton(“Excluir”);
excluir.addActionListener(this).
O this é usado para definir o receptor de eventos dessa classe.
3.3) Evento de Ação

Ocorrem quando um usuário conclui uma ação utilizando um dos seguintes componentes:
JButton, JCheckBox, JComboBox, JTextField ou JRadionButton. Uma classe precisa
implementar a interface ActionListener para trarar desses eventos.
3.4) Execute 20: Evento de Ação
1) Abra o Jcreator
//EventoAcao
import java.awt.*;
import java.awt.event.*; // pacote para tratamento de eventos
public class EventoAcao extends JFrame implements ActionListener {

private JButton btinserir,btfechar,btlimpar;
private JTextField tfentrada,tfsaida;
private JLabel lbentrada,lbsaida;
private JPanel pncentro,pnsul,pndireita;
// construtor da classe
public EventoAcao(){
super("Tratamento de Eventos de Ação");
setSize(500,100);
setLocation(100,100);
pncentro = new JPanel();

pndireita = new JPanel();
pnsul = new JPanel(new GridLayout(1,3));
btinserir = new JButton("Inserir");

btinserir.addActionListener(this); // receptor de evento
btfechar = new JButton("Fechar");

34
btfechar.addActionListener(this);
btlimpar = new JButton("Limpar");

btlimpar.addActionListener(this);
lbentrada = new JLabel("Digite Algo: ");

lbsaida = new JLabel("Texto inserido: ");
tfentrada = new JTextField(10);

tfentrada.addActionListener(this); //receptor de evento
tfsaida = new JTextField(10);

tfsaida.addActionListener(this); //receptor de evento
tfsaida.setEditable(false);
getContentPane().add(pncentro, BorderLayout.CENTER);
getContentPane().add(pndireita,BorderLayout.EAST);
getContentPane().add(pnsul,BorderLayout.SOUTH);
pncentro.add(lbentrada);
pncentro.add(tfentrada);
pndireita.add(lbsaida);
pndireita.add(tfsaida);
pnsul.add(btlimpar);
pnsul.add(btinserir);
pnsul.add(btfechar);
show();
}
// método da Interface Action Listener

public void actionPerformed(ActionEvent evento){
if (evento.getSource()==btinserir){
tfsaida.setText(tfentrada.getText());
}
else if (evento.getSource()==btlimpar){
tfsaida.setText("");
tfentrada.setText("");
}
else if (evento.getSource()==btfechar){
System.exit(0);
}

35
// método para rodar a aplicação

EventoAcao e = new EventoAcao();
}
}
3.5) Eventos de foco

Ocorrem quando qualquer componente ganha ou perde o foco de entrada em uma
interface gráfica com o usuário. O foco descreve o componente que está ativo no
momento para entrada via teclado.
3.6) Execute 21: Evento de foco
1) Abra o Jcreator
import java.awt.event.*;
import java.awt.*;
public class SelecionaItem extends JFrame implements ItemListener {

BorderLayout borda = new BorderLayout();
JTextField resultado = new JTextField(27);
JComboBox escolha = new JComboBox();
public SelecionaItem(){
super("Seleciona Item");
escolha.addItemListener(this);
escolha.addItem("Navigator");
escolha.addItem("Internet Explorer");
escolha.addItem("Opera");
escolha.setEditable(false);

36
resultado.setHorizontalAlignment(SwingConstants.CENTER);
resultado.setEditable(false);
painel.setLayout(borda);
painel.add(resultado, "South");
painel.add(escolha,"Center");
}
public static void main(String [] argumentos){

SelecionaItem i = new SelecionaItem();
i.pack();
i.setVisible(true);
}
public void itemStateChanged(ItemEvent evt){

if (evt.getSource()==escolha){
resultado.setText(evt.getItem().toString()+ " esta selecionado.");
}
repaint();
}
}
3.7) Eventos de tecla

Ocorrem quando uma tecla é pressionada no teclado. Qualquer componente pode gerar
esses eventos e uma classe precisa implementar a interface KeyListener para oferecer
suporte a eles.
3.8) Execute 22: Evento de tecla
1) Abra o Jcreator
import java.awt.*;
37
public class EventoTecla extends JFrame implements KeyListener {

JTextField digite = new JTextField(20);
public EventoTecla(){
super("Exemplo de Evento de tecla");
setSize(300,100);
painel.add(digite,"Center");
digite.addKeyListener(this);
show();
}
public void keyPressed(KeyEvent evento){

if (evento.getSource()== digite){
JOptionPane.showMessageDialog(null,"Voce teclou: "+evento.getKeyChar());
}
}
public void keyReleased(KeyEvent evento){
public void keyTyped(KeyEvent evento){
public static void main(String a []){

EventoTecla tecla = new EventoTecla();
}
}

38
3.9) Eventos de mouse

São gerados por vários tipos diferentes de interação do usuário: um clique de mouse, um
mouse que entra na área de um componente, um mouse que deixa a área de um
componente. Qualquer componente pode gerar esses eventos, os quais são
implementados por uma classe através da interface MouseListener.
3.10) Execute 23: Evento de mouse
1) Abra o Jcreator
import java.awt.*;
public class EventoMouse extends JFrame implements MouseListener {

JButton btclicar = new JButton("Clique");
JButton btapontar = new JButton("Aponte");
public EventoMouse(){
super("Exemplo de Evento de Mouse");
setSize(300,100);
painel.add(btclicar,"Center");
btclicar.addMouseListener(this);
painel.add(btapontar,"Center");
btapontar.addMouseListener(this);
show();

39
public void mouseReleased(MouseEvent evento){

if (evento.getSource()== btclicar){
JOptionPane.showMessageDialog(null,"Voce atualizou mouse");
}
public void mousePressed(MouseEvent evento){
JOptionPane.showMessageDialog(null,"Voce pressionou o botão do mouse");
}
public void mouseExited(MouseEvent evento){

if (evento.getSource()== btapontar){
JOptionPane.showMessageDialog(null,"Voce deixou de apontar para mim");
}
public void mouseEntered(MouseEvent evento){

JOptionPane.showMessageDialog(null,"Voce apontou para mim");
}
public void mouseClicked(MouseEvent evento){
JOptionPane.showMessageDialog(null,"Voce clicou em mim");
}
}
EventoMouse mouse = new EventoMouse();
}
}

40
3.11) Eventos de movimento de mouse

Ocorrem quando um mouse é movido sobre um componente. Assim como nos outros
eventos de mouse, qualquer componente pode gerar eventos desse tipo. Para oferecer
suporte para eles, uma classe precisa implementar a interface MouseMotionListener.
3.12) Execute 24: Evento de Movimento do Mouse
1) Abra o JCreator
import java.awt.*;
public class EventoMovMouse extends JFrame implements MouseMotionListener {
JButton btapontar = new JButton("Aponte");

JButton btarrastar = new JButton("Arrastar");
public EventoMovMouse(){
super("Exemplo de Evento de Movimento do Mouse");
setSize(300,100);
painel.add(btapontar,"Center");
btapontar.addMouseMotionListener(this);
painel.add(btarrastar,"Center");
btarrastar.addMouseMotionListener(this);
show();
}
41
public void mouseMoved(MouseEvent evento){

JOptionPane.showMessageDialog(null,"Voce moveu o mouse em mim");
}
public void mouseDragged(MouseEvent evento){
if (evento.getSource()== btarrastar){
JOptionPane.showMessageDialog(null,"Voce tentou arrastar");
}

EventoMovMouse mouse = new EventoMovMouse();
}
}
3.13) Eventos de janela

Ocorrem quando um usuário abre ou fecha um objeto janela, como JFrame ou JWindow.
Qualquer componete pode gerar esses eventos e uma classe precisa implementar a
interface WindowListener para oferecer suporte a eles.
3.14) Execute 25: Evento de Janela
1) Abra o JCreator
import java.awt.*;

42
public class EventoJanela extends JFrame implements WindowListener {
public EventoJanela(){
super("Exemplo de Evento de Janela");
setSize(300,100);
addWindowListener(this);
show();
}
public void windowClosing(WindowEvent evento){

JOptionPane.showMessageDialog(null,"A janela foi fechada");
}
public void windowIconified(WindowEvent evento){

JOptionPane.showMessageDialog(null,"A janela virou um icone");
}
public void windowDeiconified(WindowEvent evento){

JOptionPane.showMessageDialog(null,"A janela deixou de ser icone");
}
public void windowActivated(WindowEvent evento){

JOptionPane.showMessageDialog(null,"A janela esta ativa");
}
public void windowDeactivated(WindowEvent evento){

JOptionPane.showMessageDialog(null, "A janela esta desativada");
}
public void windowOpened(WindowEvent evento){

JOptionPane.showMessageDialog(null, "A janela esta aberta");
}
public void windowClosed(WindowEvent evento){

JOptionPane.showMessageDialog(null, "A janela esta fechada");
}

EventoJanela mouse = new EventoJanela();
}
}

43
3.15) Criando Menus

Como esperado, a Swing oferece suporte bastante completo para criação de aplicações
utilizando barras de menus, menus suspensos e menus independente através de um
conjunto de classes resumidamente descrito a seguir:
Classe Descrição
JMenuItem Classe que define uma entrada simples de
menu
JMenuBar Classe que define uma barra de menus para
uma aplicação
JMenu Classe que define um menu suspenso
Adicionar uma barra de menus contendo menus e itens de menus são bastante simples
no Java. Basta seguir intuitivamente a estrutura visual apresentada:
• Adicionar uma barra de menu a janela;
• Adicionar os menus suspensos a barra de menu;
• Adicionar os itens de menus desejados ou a cada um dos menus suspensos e
• Adicionar os listener necessários para ser possível que os menus e itens de menus
exibam funcionalidades.
3.16) Execute 26: Criando Menus
1) Abra o JCreator

44
public class CriarMenu extends JFrame implements ActionListener{
JMenuBar barramenu = new JMenuBar();
JMenu marquivo = new JMenu("Arquivo");

JMenu meditar = new JMenu("Editar");
JMenu mformatar = new JMenu("Formatar");
JMenu mifonte = new JMenu("Fonte");
JMenuItem misalvar = new JMenuItem("Salvar");

JMenuItem mifechar = new JMenuItem("Fechar");
JMenuItem micopiar = new JMenuItem("Copiar");
JMenuItem micolar = new JMenuItem("Colar");
JMenuItem micor = new JMenuItem("Cor");

JMenuItem mitamanho= new JMenuItem("Tamanho");
public CriarMenu(){
super("Criando Menus");
setSize(500,500);
getContentPane().add(barramenu);
barramenu.add(marquivo);
barramenu.add(meditar);
barramenu.add(mformatar);
marquivo.add(misalvar);
misalvar.addActionListener(this);
marquivo.add(mifechar);
mifechar.addActionListener(this);
meditar.add(micopiar);
micopiar.addActionListener(this);
meditar.add(micolar);
micolar.addActionListener(this);
mformatar.add(mifonte);
mifonte.add(micor);
micor.addActionListener(this);
mifonte.add(mitamanho);
mitamanho.addActionListener(this);
setJMenuBar(barramenu);

45
show();
if (evento.getSource()==misalvar){
JOptionPane.showMessageDialog(null,"Você clicou na opção salvar do
menu arquivo");
} else if (evento.getSource()==mifechar){
System.exit(0);
} else if (evento.getSource()==micopiar){
JOptionPane.showMessageDialog(null,"Você clicou na opção copiar do
menu editar");
} else if (evento.getSource()==micolar){
JOptionPane.showMessageDialog(null,"Você clicou na opção colar do
menu editar");
} else if (evento.getSource()==micor){
JOptionPane.showMessageDialog(null,"Você clicou na opção cor do menu
formatar, fonte");
} else if (evento.getSource()==mitamanho){
JOptionPane.showMessageDialog(null,"Você clicou na opção tamanho do
menu formata, fonte");
}
}
CriarMenu cm = new CriarMenu();

}

46
3.17) Criando Barra de Ferramentas

O pacote Swing também oferece recursos para criação de barras de ferramentas
possibilitando criar aplicações que possui ferramentas para serem acessadas agilizando,
portanto a utilização do sistema. Para criar uma barra de ferramentas basta adicionar a
barra de ferramenta à janela (através da classe JToolBar) e adicionar botões a barra de
ferramentas (através da classe JButton).
3.18) Execute 27: Criando barra de ferramentas
1) Abra o JCreator
import java.awt.*;
public class CriarFerramentas extends JFrame implements ActionListener{
JToolBar barraferra = new JToolBar();

JButton b1 = new JButton(new ImageIcon("botao1.gif"));
public CriarFerramentas(){
super();
setSize(500,500);

47
getContentPane().add(barraferra,BorderLayout.NORTH);
barraferra.add(b1);
b1.addActionListener(this);
barraferra.add(b2);
barraferra.add(b3);
show();
}
if (evento.getSource()==b1){
JOptionPane.showMessageDialog(null,"Você clicou no primeiro botão");
} else if (evento.getSource()==b2){
JOptionPane.showMessageDialog(null,"Você clicou no segundo botão");
} else if (evento.getSource()==b3){
JOptionPane.showMessageDialog(null,"Você clicou no terceito botão");
}
}
CriarFerramentas cr = new CriarFerramentas();
}
}

48
3.19) Exercícios de Revisão do capitulo I

1) Desenvolva uma aplicação com a seguinte tela:
Funcionalidades:
• botão Limpar: quando clicar neste botão todas as caixas de textos e label imc serão
limpos.
• botão Calcular IMC: quando clicar neste botão deverá ser mostrado no label imc o
cálculo do imc (índice de massa corpórea ). O imc é calculado da seguinte forma:
peso dividido pela altura (metros) ao quadrado. A tabela abaixo define a situação do
IMC:
IMC Situação
abaixo de 20 abaixo do peso normal
20 até 25 peso normal
acima de 25 até 30 sobrepeso
acima de 30 até 35 obesidade
acima de 35 obesidade mórbida
• No label imc deverá ser apresentado o valor do imc e a situação. Veja o exemplo:

49
Funcionalidades:
• Botão +: quando clicar nesse botão será efetuado a soma entre os dois números e
mostrar o resultado no label resultado.
• Botão /: quando clicar nesse botão será efetuado a divisão entre os dois números e
mostrar o resultado no label resultado.
• Botão *: quando clicar nesse botão será efetuado a multiplicação entre os dois
números e mostrar o resultado no label resultado.
• Botão -: quando clicar nesse botão será efetuado a subtração entre os dois números.
• Botão Limpar: quando clicar nesse botão limpar os TextFields e o label resultado.

50
A tela mostrada acima posui:

• Uma barra de menu;
• Dois menus: Exemplos e Sair.
• O menu Exemplos possui 3 itens: Calculo IMC, Calculadora e Exemplos de Vários
Objetos
• O menu Sair possui 2 itens: Sim e Não.
Funcionalidades:
• Quando clicar no item de menu Calculo IMC será executado a aplicação do
exercício 1 (Calculo IMC).
• Quando clicar no item de menu Calculadora será executado a aplicação do

exercício 2 (Calculadora).
• Quando clicar no item de menu Exemplos de Vários Objetos será executado a

aplicação do exercício 3 (Exemplos de Vários Objetos).
• Quando clicar no item de menu sim: deverá sair da aplicação.

51
4 - Aplicações e Primitiva Gráficas

A linguagem Java contem um numero grande de primitivas gráficas que
possibilitam ao usuário criar gráficos facilmente e rapidamente. Abaixo uma pequena
relação dos métodos mais úteis da classe Graphics (java.awt.Graphics):
4.1) Linhas
O método drawLine pode ser usado para desenhar linhas retas entre dois pontos (x1,y1) e
(x2,y2) dados.
drawLine(int x1, int y1, int x2, int y2)
int x1 ⇒ coordenada x inicial
int y1 ⇒ coordenada y inicial
int x2 ⇒ coordenada x final
int y2 ⇒ coordenada y final
4.2) Execute 28:Criando Linhas
1) Abra o JCreator
//Linhas.java
import java.awt.*;
public class Linhas extends JFrame {

public Linhas(){
super("Criando Linhas");
setSize(300,300);
show();
}
public void paint(Graphics g){

int x1 = (int) Math.round(Math.random()*300);
int y1 = (int) Math.round(Math.random()*300);
g.drawString("("+x1+","+y1+")",x1, y1);
g.drawString("("+x2+","+y2+")",x2, y2);
g.drawLine(x1,y1,x2,y2);

52

Linhas l = new Linhas();
}
3) Compilar e executar.
4.3) Retângulos e Quadrados

O método drawRect pode ser utilizado para desenhar retângulos ou quadrados através da
definição da localização de seu vértice superior esquerdo (x,y) e da definição de sua
largura width e altura height.
drawRect(int x, int y, int width, int height)

desenha um retângulo
int x ⇒ coordenada x inicial
int y ⇒ coordenada y inicial
int width ⇒ largura
int height ⇒ altura
4.4) Execute 29:Criando Retângulos e Quadrados
1) Abra o JCreator
//Retangulos.java
import java.awt.*;
public class Retangulos extends JFrame {
public Retangulos(){
super("Criando Retângulos");
setSize(300,300);
show();
}

53


g.drawRect(x1,y1,x2,y2);

Retangulos l = new Retangulos();
}
4.5) Elipses e Circunferências

O método drawOval pode ser usado para desenhar elipses ou circunferências de foma
análoga ao método drawRect, ou seja, através da definição da localização do vértice
superior esquerdo (x,y) do retângulo onde se inscreve a elipse e da definição de sua
largura width e altura height.
drawOval(int x, int y, int width, int height)

desenha um circulo
int x ⇒ coordenada x inicial
int y ⇒ coordenada y inicial
int width ⇒ largura
int height ⇒ altura
4.6) Execute 30: Criando Elipse e Circunferências
1) Abra o JCreator
//Elipse.java
import java.awt.*;

54
public class Elipse extends JFrame {
public Elipse(){
super("Criando Elipse");
setSize(300,300);
show();
}


g.drawOval(x1,y1,x2,y2);

Elipse l = new Elipse();
}
4.7) Polígonos
Para desenhar polígonos regulares ou irregulares utilizamos os métodos drawPolygon ou
fillPolygon que permite a obtenção de figuras vazadas ou sólidas respectivamente. Estes
métodos podem receber dois vetores comuns que contem as coordenadas x e y de cada
ponto do polígono e um valor inteiro que define a quantidade de pontos. Com essas
informações os métodos desenham um polígono fechado.
drawPolygon(int xPoints[], int yPoints[], int nPoints)

desenha um polígono. Qualquer polígono criado tem que conter um ponto que o fecha.
Java não cria polígonos fechados automaticamente, então tenha sempre certeza que os
pontos inicial e final são iguais.

55
int xPoints[]⇒ array de coordenadas x

int yPoints[]⇒ array de coordenadas y
int nPoints[]⇒ numero de pontos
4.8) Execute 31: Criando Elipse e Circunferências
1) Abra o JCreator
//Poligono.java
import java.awt.*;
public class Poligono extends JFrame {
public Poligono(){
super("Criando Poligonos");
setSize(300,300);
show();
}

int x[] = new int[4];
int y[] = new int[4];
x[0] = (int) Math.round(Math.random()*300);

y[0] = (int) Math.round(Math.random()*300);



g.drawPolygon(x,y,4);

56

Poligono l = new Poligono();
}
4.9) Melhorando as Aplicações usando primitivas gráficas
4.10) Execute 32Criando Linhas e Elipse

1) Abra o JCreator
//Grafica1.java
import java.awt.*;
public class Grafica1 extends JFrame {
public Grafica1(){
super();
setSize(205,205);
show();
}
public void paint(Graphics tela) {
setBackground(Color.white);
tela.setColor(Color.black);
for (int i = 0; i <= 200; i += 20) {
tela.drawLine(0, i, 200, i);
tela.drawLine(i, 0, i, 200);
}
tela.setColor(Color.red);
tela.fillOval(30, 30, 160, 160);
}

Grafica1 g = new Grafica1();
}
}

57
4) A janela será exibida:
4.11) Execute 33Criando Retângulos com gráficos

1) Abra o JCreator
//Grafica2.java
import java.awt.*;

JLabel lbestat = new JLabel("Estatistica Atual:");
Graph gstat = new Graph();
public Grafica2() {
super();
setSize(260,240);
getContentPane().add("North", lbestat);
getContentPane().add("Center", gstat);
show();
}

}
}
class Graph extends java.awt.Canvas {

int[] pontos = { 1, 10, 3, 5, 8, 7, 2, 2, 5, 9 };

58
for (int i = 0; i < 10; i++) {

Color corazul = new Color(0, 0, 255 - (i*20));
tela.setColor(corazul);
tela.fillRect(20, i * 20, pontos[i] * 20, 17);
}
}
}
4) A tela será mostrada:
4.12) Execute 34Criando Retângulos com gráficos

1) Abra o JCreator
//Grafica3.java
import java.awt.*;
public Grafica3(){
super();
setSize(350,370);
show();
}

setBackground(Color.blue);

59
tela.setColor(Color.white);
for (int ax = 10; ax < 340; ax += 10)
for (int ay = 30; ay < 340 ; ay += 10) {
tela.drawArc(ax, ay, 10, 10, 0, -180);
}
tela.setColor(Color.green);
Polygon fl = new Polygon();
fl.addPoint(10, 12);
tela.fillPolygon(fl);
tela.setColor(Color.black);
tela.fillOval(235, 140, 15, 15);
tela.fillOval(225, 130, 15, 15);
tela.fillOval(245, 130, 15, 15);
}

}
}

60
4) A tela será mostrada:
5 - Threads
Threads constituem uma característica bastante relevante da linguagem Java. A
incorporação dos conceitos de sincronização e variáveis de condição dentro da própria
linguagem permite que programadores médios consigam utilizar conceitos de computação
concorrente de forma bem facilitada, o que possibilita uma melhoria de performance dos
programas. Neste capítulo veremos o que são threads, analisaremos seus estados e
métodos básicos e aprenderemos a inserir threads em applets.
5.1) O que são threads?

Uma thread pode ser definido como “um fluxo de controle seqüencial isolado dentro de
um programa”. Como um programa seqüencial qualquer, uma thread tem um começo, um
fim e uma seqüência de comandos. Entretanto, uma thread em Java não é um programa,
não executa sozinho, executa dentro de um programa.
Threads permitem que um programa simples possa executar várias tarefas diferentes ao
mesmo tempo, independentemente umas das outras.
Programas multithreaded são programas que contém várias threads, executando tarefas
distintas, simultaneamente.
Em Java, threads são cidadãos de primeira ordem, se constituindo de instâncias da

classe Thread que fornecem suporte a comunicação concorrente. A classe Thread provê
os métodos necessários para criar e controlar threads (independentemente da plataforma
usada) e executá-los concorrentemente. A real implementação de threads é feita pelo
sistema operacional.

61
O corpo de uma thread é o seu método run(), e é nele que são executadas as tarefas às
quais thread se destina. Podemos implementar threads de duas maneiras (ambas
suportadas pelos construtores da classe Thread):
• Criando uma subclasse da classe Thread e definindo o seu método run() de

maneira adequada à realização da tarefa do thread.
• Criando uma instância de Thread que recebe como parâmetro um objeto que
implemente a interface Runnable - esse objeto providenciará o método run() para
a thread.
A linguagem Java fornece meios para criarmos threads como daemons, agruparmos
threads, sincronizá-los e controlar suas prioridades.
5.2) Os estados de uma thread
• New Thread
Inicialização da thread - feita através do construtor Thread().
class MyThreadClass extends Thread {

...
}
...
MyThreadClass myThread = new MyThreadClass();
Neste estado, nenhum recurso do sistema foi alocado para o thread ainda, assim, a partir
daqui, tudo que você pode fazer é um start(), para ativar a thread, ou um stop(), para
“matá-lo”. A chamada de qualquer outro método não faz sentido e levantará a exceção
IllegalThreadStateException.

62
• Runnable
Este é o estado em que o thread está pronto para rodar. O método start() requisita os
recursos do sistema necessários para rodar a thread e chama o seu método run(). O
método run() é a “alma” de um thread; é neste método que definimos o que a thread vai
executar.
Thread myThread = new MyThreadClass();

myThread.start();
Falamos em Runnable, ao invés de Running, porque a thread pode não estar realmente
sendo executada. Imagine um computador com um único processador - seria impossível
executar todas as threads ao mesmo tempo. O que ocorre é que a CPU deve ser
escalonada entre as várias threads. Quando uma thread está Running, ela está também
Runnable, as instruções do seu método run() é que estão sendo executadas pela CPU.
• Not Runnable
O estado Not Runnable significa que a thread está impedida de executar por alguma
razão. Existem 4 maneiras de uma thread ir para o estado Not Runnable.
1. receber a mensagem suspend();

2. receber a mensagem sleep();
3. a thread bloqueia, esperando I/O;
4. a thread usa seu método wait() para esperar por uma variável de condição.
O exemplo abaixo coloca o applet myThread para dormir por 10 segundos:
Thread myThread = new MyThreadClass();

myThread.start();
try {
myThread.sleep(10000);
} catch (InterruptedException e) { }
Cada uma destas maneiras tem a sua forma específica de sair do estado Not Runnable.
1. se a thread foi suspensa, alguém precisa mandar-lhe a mensagem resume();
2. se a thread foi posta para dormir, ela voltará a ser Runnable quando o número de
milisegundos determinado passar;
3. se a thread está bloqueada, esperando por I/O, a operação precisa ser
completada;
4. se a thread está esperando por uma variável de condição, o objeto que a retém
precisa liberá-la, através de um notify() ou de um notifyAll()
• Dead
Uma thread pode morrer de “causas naturais” (quando o seu método run() acaba
normalmente) ou pode ser morto pelo método stop().

63
É possível controlar a ordem de execução de várias threads definindo prioridades para

eles. O escalonador de threads do Java segue a seguinte regra: a qualquer instante, a
thread corrente é a de maior prioridade. Para que a thread de maior prioridade ceda CPU
a outra thread, ele precisa enviar para si o método yield(), ou, entrar no estado Not
Runnable. Caso contrário, ele irá executar até que termine seu método run().
Para descobrir a prioridade de uma thread, podemos usar o método getPriority() e, para
defini-la setPriority(n), onde n é um inteiro de 1 a 10 (10 representando a prioridade
máxima).
5.3) Threads em Applets

Até agora nós vimos como trabalhar com threads criadas a partir da classe Thread ou de
uma classe que herde da classe Thread. Sabemos que esta classe provê os métodos
básicos para se lidar com threads (run(), start(), stop(), sleep(), etc.).
Suponha que você queira, agora, implementar uma thread dentro de uma applet. Por
exemplo, suponha que você quer fazer uma applet relógio, que atualiza o seu display a
cada segundo. A classe que vai implementar o seu relógio precisa ser uma subclasse da
classe Applet para herdar todas as facilidades oferecidas por ela. Como fazê-la, então,
herdar também da classe Thread? A interface Runnable é a solução!
Qualquer objeto que implemente a interface Runnable pode utilizar o seu método run()
para ser executado como uma thread.
class Clock extends Applet implements Runnable {

....
}
A applet Clock precisa, agora, criar a sua própria thread. Isto é
feito no seu método start()
public void start() {
if ( clockThread == null) {
clockThread = new Thread(this, “Clock”);
clockThread.start();
}
}
Observe a chamada ao construtor Thread(this, “Clock”). O construtor precisa receber

como primeiro argumento um objeto que implemente a interface Runnable, este objeto é
que vai fornecer o método run() da thread clockThread.
public void run() {

while (clockThread != null) {
repaint();
try {
clockThread.sleep(1000);
}
}

64
No método stop() do applet Clock, temos que chamar também o método stop() da thread
clockThread, caso contrário, a thread vai continuar executando e consumindo recursos
mesmo depois que sairmos da página da applet.
public void stop() {

clockThread.stop();
clockThread = null;
}
Se você revisitar a página, o start() da applet Clock é chamado novamente e uma nova
thread é inicializada.
5.4) Herdando de Thread x Implementando Runnable

Existem duas maneiras de implementar threads:
1. Herdando da classe Thread ou de subclasses da classe Thread.
2. Implementando a interface Runnable e criando uma thread (passando o objeto que
implementa Runnable como argumento).
Qual opção utilizar?
Se você precisa estender outra classe (o exemplo mais comum é a classe Applet),
use Runnable. Entretanto, se você está planejando apenas sobrepor o método run(), e
mais nenhum outro método de Thread, use Runnable. Classes não devem herdar de
outras classes, a menos que o programador pretenda modificar ou aprimorar o
comportamento fundamental da classe.
5.5) Execute 35: Trabalhando com Thread

1) Abra o JCreator
//RelogioDigital.java
import java.awt.*;
import java.util.*;
public class RelogioDigital extends JFrame {

Janela j = new Janela();
public RelogioDigital() {
super("Relogio Digital");
setSize(60, 60);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
painel.setLayout(new GridLayout(1, 1, 15, 15));
painel.add(j);
show();
}

65
public static void main(String[] arguments) {

RelogioDigital relogio = new RelogioDigital();
}
}
class Janela extends JPanel implements Runnable {

Thread executa;
Janela() {
if (executa == null) {
executa = new Thread(this);
executa.start();
}
}
public void run() {

while (true) {
repaint();
try {
Thread.sleep(1000);
}
public void paintComponent(Graphics comp) {

Graphics2D comp2D = (Graphics2D)comp;
Font type = new Font("Serif", Font.BOLD, 24);
comp2D.setFont(type);
comp2D.setColor(getBackground());
comp2D.fillRect(0, 0, getSize().width, getSize().height);
Calendar dia = new GregorianCalendar();
String hora =
""+dia.get(Calendar.HOUR)+":"+dia.get(Calendar.MINUTE)+":"+dia.get(Calend
ar.SECOND);
comp2D.setColor(Color.black);
comp2D.drawString(hora, 5, 25);
}
}
3) compilar e executar.
4) A seguinte tela será mostrada:

66
5.6) Execute 36:Trabalhando com Thread

1) Abra o JCreator
//SinalTransito.java
import java.awt.*;
public class SinalTransito extends JFrame {

LuzSinal luz = new LuzSinal();
public SinalTransito() {
super("Sinal de Transito");
setSize(100, 330);
Container pane = getContentPane();
BorderLayout bord = new BorderLayout();
pane.setLayout(bord);
pane.add(luz, "Center");
show();
}

SinalTransito t = new SinalTransito();
}
class LuzSinal extends JPanel implements Runnable {

private Thread executar;
int contador = 0;
LuzSinal() {
if (executar == null); {
executar = new Thread(this);
executar.start();
}
}
public void run() {

Thread novaThread = Thread.currentThread();
while (executar == novaThread) {
contador++;
if (contador > 2)
contador = 0;
repaint();
try {
Thread.sleep(1500);

67
}
}

comp2D.fillRect(0, 0, 300, 300);
if (contador == 2)
comp2D.setColor(Color.red);
else
comp2D.fillOval(0, 0, 100, 100);
if (contador == 1)
comp2D.setColor(Color.yellow);
else
comp2D.fillOval(0, 100, 100, 100);
if (contador == 0)
comp2D.setColor(Color.green);
else
comp2D.fillOval(0, 200, 100, 100);
}
}
4) A seguinte tela será mostrada mudando o sinal de transito.
observação: neste momento esta sinal amarelo, veja a mudança de sinal.

68

69

1) Abra o JCreator
//BannerLinha.java
import java.awt.*;
import java.util.*;
public class BannerLinha extends JFrame {

BannerPainel novo = new BannerPainel();
public BannerLinha() {
super("Banner em linhas");
setSize(420, 100);
pane.setLayout(new GridLayout(1, 1, 15, 15));
pane.add(novo);
show();
novo.rolar();
}

BannerLinha banner = new BannerLinha();
}
}
class BannerPainel extends JPanel {

String[] linhas = {
"Hytec Informática",
"Java Avançado",
"Trabalhando com Threads",
"Sun Microsystem"
};
int y = 76;
void rolar() {
while (true) {
y = y - 1;
if (y < -75)
y = 76;
repaint();
try {
Thread.sleep(250);
}
}

70

Font type = new Font("monospaced", Font.BOLD, 14);
comp2D.setFont(type);
comp2D.setColor(getBackground());
comp2D.fillRect(0, 0, getSize().width, getSize().height);
for (int i = 0; i < linhas.length; i++)
comp2D.drawString(linhas[i], 5, y + (20 * i));
}

1) Abra o JCreator
//Checar.java
import java.awt.*;
public class Checar extends JFrame implements ActionListener {

ChecarPainel checar = new ChecarPainel();
JButton btiniciar = new JButton("Iniciar");
JButton btparar = new JButton("Parar");
public Checar() {
super("Checar");
setSize(210, 170);
BorderLayout border = new BorderLayout();
pane.setLayout(border);
pane.add(checar, "Center");
JPanel painelbotoes = new JPanel();

btiniciar.addActionListener(this);
painelbotoes.add(btiniciar);
btparar.addActionListener(this);
btparar.setEnabled(false);

71
painelbotoes.add(btparar);
pane.add(painelbotoes, "South");
show();
}
public void actionPerformed(ActionEvent evt) {

if (evt.getSource() == btiniciar) {
checar.iniciarAnimacao();
btiniciar.setEnabled(false);
btparar.setEnabled(true);
} else {
checar.pararAnimacao();
btiniciar.setEnabled(true);
btparar.setEnabled(false);
}
}

Checar ck = new Checar();
}
class ChecarPainel extends JPanel implements Runnable {

private Thread executar;
int xPos = 5;
int xMove = 4;
void iniciarAnimacao() {
if (executar == null); {
executar = new Thread(this);
executar.start();
}
}
void pararAnimacao() {
if (executar != null); {
executar = null;
}
}
public void run() {

Thread novaThread = Thread.currentThread();
while (executar == novaThread) {
xPos += xMove;
if ((xPos > 105) | (xPos < 5))
xMove *= -1;
repaint();
try {
Thread.sleep(100);
}
72

comp2D.setColor(Color.white);
comp2D.fillRect(100, 0, 100, 100);
comp2D.setColor(Color.red);
comp2D.fillOval(xPos, 5, 90, 90);
}
}
5.9) Execute 39Trabalhando com Thread

1) Abra o JCreator
//Pete.java
import java.awt.*;
import java.util.*;
public class Pete extends JFrame {

PetePanel pete = new PetePanel();
public Pete() {
super("Pixel Pete");
setSize(452, 146);
pane.setLayout(new GridLayout(1, 1, 15, 15));
pane.add(pete);
show();
}

73

Pete penguin = new Pete();
}
}
class PetePanel extends JPanel implements Runnable {

Thread runner;
Image petePics[] = new Image[6];
Image back;
int current = 0;
int x = -10;
int y = 30;
PetePanel() {
super();
setBackground(Color.black);
String peteSrc[] = { "right1.gif", "right2.gif",
"right3.gif", "stop.gif", "blink.gif",
"wave.gif" };
Toolkit kit = Toolkit.getDefaultToolkit();
for (int i=0; i < petePics.length; i++) {
petePics[i] = kit.getImage(peteSrc[i]);
}
back = kit.getImage("backdrop.gif");
if (runner == null) {
runner = new Thread(this);
runner.start();
}
}

if (back != null)
comp2D.drawImage(back, 0, 0, this);
if (petePics[current] != null)
comp2D.drawImage(petePics[current], x, y, this);
}
public void run() {

while (true) {
walk(-10, 275);
look();
blink(3);
wave(4);
walk(x, getSize().width + 10);
pause(1500);

74
}
}
public void walk(int start, int end) {

int showpic = 0;
for (int i = start; i < end; i += 5) {
x = i;
// swap images
current = showpic;
repaint();
pause(150);
showpic++;
if (showpic > 2)
showpic = 0;
}
}
public void blink(int numtimes) {

for (int i = numtimes; i > 0; i--) {
current = 4;
repaint();
pause(200);
current = 3;
repaint();
pause(1000);
}
}
public void wave(int numtimes) {

for (int i = numtimes; i > 0; i--) {
current = 3;
repaint();
pause(600);
current = 5;
repaint();
pause(1100);
}
}
public void look() {

current = 3;
repaint();
pause(1000);
}
public void pause(int time) {

try {
Thread.sleep(time);

75
}
}
4) Será mostrada a seguinte tela:
6 - Acessando Banco de Dados

Uma funcionalidade essencial em qualquer sistema é a habilidade para comunicar-se com
um banco de dados. Java dispõe de uma API para acessar banco de dados: a Java
DataBase Connectivity API ou JDBC API.
A JDBC implementa em Java a funcionalidade definida pelo padrão SQL Call Level
Interface ou SQLCLI. Um outro exemplo de API que implementa o SQL Call Level
Interface é o popularíssimo ODBC das plataformas Wintel. A maioria dos fornecedores de
bancos de dados oferece uma implementação particular de SQLCLI. A vantagem de
JDBC é a portabilidade da aplicação cliente, inerente da linguagem Java. A especificação
corrente da JDBC API é a 2.1.
A JDBC compreende uma especificação para ambos: os desenvolvedores de drivers

JDBC e os desenvolvedores de aplicações clientes que precisem acessar bancos de
dados em Java. Estaremos dando uma olhada no desenvolvimento de aplicações em
Java, então, é uma boa idéia começar com o suporte de dados.
Existem 4 tipos de diferentes de drivers JDBC:
- Uma vez que ODBC é uma especificação padrão do mundo Wintel, o tipo 1 é um driver
de ponte entre Java e ODBC. O driver de ponte mais conhecido é o fornecido pela Sun o
JDBC-ODBC bridge. Este tipo de driver não é portável, pois depende de chamadas a
funções de ODBC implementadas em linguagem C e compiladas para Wintel, ou outra
plataforma ODBC compatível, as chamadas funções nativas.
- O driver tipo 2 é implementado parcialmente em Java e parcialmente através de funções

nativas que implementam alguma API específica do fornecedor de banco de dados. Este
tipo faz o que se chama de wrap-out, ou seja, provê uma interface Java para uma API
nativa não-Java.

76
- O tipo 3 é um driver totalmente Java que se comunica com algum tipo de middleware
que então se comunica com o banco de dados
- O tipo 4 é um driver totalmente Java que vai diretamente ao banco de dados.
6.1) Acessando bancos de dados em JDBC
Código:
import java.sql.*;
A primeira coisa a fazer é estabelecer uma conexão com o banco de dados. Fazemos isso
em dois passos: primeiro carregamos o driver para o banco de dados na JVM da
aplicação. Uma vez carregado, o driver se registra para o DriverManager e está disponível
para a aplicação. Utilizamos então a classe DriverManager para abrir uma conexão com o
banco de dados. A interface Connection designa um objeto, no caso con, para receber a
conexão estabelecida:
Código:
try //A captura de exceções SQLException em Java é obrigatória para usarmos JDBC.
{
// Este é um dos meios para registrar um driver
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver")
// Registrado o driver, vamos estabelecer uma conexão

Connection con = DriverManager.getConnection("jdbc:odbc:meusCdsDb","conta","senha");
}
catch(SQLException e)
{
// se houve algum erro, uma exceção é gerada para informar o erro
e.printStackTrace(); //vejamos que erro foi gerado e quem o gerou
}
Estabelecida a conexão, podemos executar comandos SQL para o banco de dados.

Vejamos como realizar uma consulta sobre o título, numero de faixas e o artista de cada
CD no banco de dados. Podemos usar 3 interfaces para executar comandos SQL no
banco de dados. A primeira delas é a interface Statement, que permite a execução dos
comandos fundamentais de SQL (SELECT, INSERT, UPDATE ou DELETE). A interface
PreparedStatement nos permite usufruir de SQL armazenado ou pré-compilado no banco,
quando o banco de dados suportar este recurso. A terceira interface é CallableStatement,
e permite executar procedimentos e funções armazenados no banco quando o banco
suportar este recurso. Vejamos como utilizar a interface Statement.
Código:
// Após estabelecermos a conexão com o banco de dados
// Utilizamos o método createStatement de con para criar o Statement
Statement stm = con.createStatement();
// Vamos executar o seguinte comando SQL :

String SQL = "Select titulo, autor, total_faixas from MeusCDs";
A interface ResultSet permite colher os resultados da execução de nossa query no banco

77
de dados. Esta interface apresenta uma série de métodos para prover o acesso aos
dados:
Código:
// Definido o Statement, executamos a query no banco de dados
ResultSet rs = stm.executeQuery(SQL);
// O método next() informa se houve resultados e posiciona o cursor do banco

// na próxima linha disponível para recuperação
// Como esperamos várias linhas utilizamos um laço para recuperar os dados
while(rs.next())
{
// Os métodos getXXX recuperam os dados de acordo com o tipo SQL do dado:
String tit = rs.getString("titulo");
String aut = rs.getString("autor");
int totalFaixas = rs.getInt("total_faixas");
// As variáveis tit, aut e totalFaixas contém os valores retornados

// pela query. Vamos imprimí-los
System.out.println("Titulo: "+tit+" Autor: "+aut+" Tot. Faixas: "+totalFaixas);

}
E nosso acesso está terminado. O importante agora é liberar os recursos alocados pelo
banco de dados para a execução deste código. Podemos fazer isso fechando o
Statement, que libera os recursos associados à execução desta consulta mas deixa a
conexão aberta para a execução de uma próxima consulta, ou fechando diretamente a
conexão, que encerra a comunicação com o banco de dados. Para termos certeza de que
vamos encerrar esta conexão mesmo que uma exceção ocorra, reservamos o fechamento
para a cláusula finally() do tratamento de exceções.
Código:
try
{
con.close();
}
catch(SQLException onConClose)
{
System.out.println("Houve erro no fechamento da conexão");
onConClose.printStackTrace();
}

78
6.2) Execute 40- Trabalhando com Banco de Dados
1) Abra o JCreator
// MeusCds.java
import java.sql.*;
public class MeusCds {

Connection con;
String SQL;
Statement stm;
public MeusCds(){
// 1º passo:estabelecer uma conexão com o JDBC

try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
} catch(ClassNotFoundException e) {
System.out.println("JDBC erro");
}
// 2º passo: estabelecer conexao com o banco de dados acess

try {
con = DriverManager.getConnection("jdbc:odbc:meusCdsDb");
} catch(SQLException e) {
System.out.println("conexão erro");
}
// 3º passo: executar comandos sql

try {
stm = con.createStatement();
SQL = "Select titulo, autor, total_faixas from MeusCDs";
System.out.println("SQL erro");
}
// 3º passo: colher os resultados da execução de nossa consulta no banco

try {
ResultSet rs = stm.executeQuery(SQL);
while(rs.next()) {
String tit = rs.getString("titulo");
String aut = rs.getString("autor");
int totalFaixas = rs.getInt("total_faixas");
System.out.println(tit+" - "+aut+" - "+totalFaixas);
}
System.out.println("consulta erro");
}

79
// 4º passo: liberar os recursos alocados pelo banco de dados

try {
con.close();
} catch(SQLException onConClose) {
System.out.println("Houve erro no fechamento da conexão");
}
}
// programa principal
public static void main (String a[]){
MeusCds m = new MeusCds();
}
}
3) Acessar o painel de controle do Windows, acessar o ícone ferramentas administrativas,

acessar o ícone fonte de dados ODBC a seguinte janela será apresentada:
Clique no botão
adicionar

80
4) Ao clicar no botão adicionar a seguinte tela será exibida:
Clique em Microsoft
Acess Driver.
Clique em
concluir
5) Ao clicar na opção Microsoft Acess Driver e depois concluir será exibida a seguinte tela:
Coloque a fonte de dados

meusCdsDb
Selecionar o banco de dados

bdcds.mdb que esta dentro da
sua pasta de trabalho do
curso.
6) Clicar no botão nos botões Ok até fechar as janelas, fechar o painel de controle.

81
7) Volte ao seu código fonte MeusCds.java que esta no JCreator.

8) Compilar e executar deverá ser mostrado a seguinte informação:
Diante do Trono I - Igreja Batista Lagoinha - 12
Diante do Trono II - Igrefa Batista Lagoinha - 14
Ao vivo - Carlinhos Felix - 16
Amor I - Varios autores – 20
6.3) Execute 41- Trabalhando com Banco de Dados

1) Abrir no JCreator
import java.awt.*;
public class ApClientes extends JFrame implements ActionListener{

JPanel pacima, pabaixo;
JButton btadicionar, btlimpar;
JLabel lbnome, lbendereco, lbcep, lbcidade,lbuf;
JTextField txnome, txendereco, txcep, txcidade, txuf;
public ApClientes(){
// Criando a janela e configurando
super("Cadastro de Clientes");
setSize(500,150);
setLocation(0,0);
// criando paineis
pacima = new JPanel(new GridLayout(3,4));
pabaixo = new JPanel(new GridLayout(1,2));
// criando botoes
btadicionar = new JButton("Adicionar");
btadicionar.addActionListener(this);
btlimpar = new JButton("Limpar");
btlimpar.addActionListener(this);
// criando labels
lbnome = new JLabel(" Nome");
lbendereco = new JLabel(" Endereço");
lbcep = new JLabel(" CEP");
lbcidade = new JLabel(" Cidade");
lbuf = new JLabel(" UF");
82
// criando caixa de texto

txnome = new JTextField(30);
txendereco = new JTextField(30);
txcep = new JTextField(9);
txcidade = new JTextField(20);
txuf = new JTextField(2);
// Adicionando os objetos
getContentPane().add(pacima,BorderLayout.NORTH);
getContentPane().add(pabaixo,BorderLayout.SOUTH);
pacima.add(lbnome);
pacima.add(txnome);
pacima.add(lbendereco);
pacima.add(txendereco);
pacima.add(lbcep);
pacima.add(txcep);
pacima.add(lbcidade);
pacima.add(txcidade);
pacima.add(lbuf);
pacima.add(txuf);
pabaixo.add(btadicionar);
pabaixo.add(btlimpar);
show();
}
public void actionPerformed(ActionEvent e){

if (e.getSource()==btadicionar){
ConectarBD bd = new ConectarBD("INSERT INTO
Cliente(nome,endereco,cep,cidade,uf) values
('"+txnome.getText()+"','"+txendereco.getText()+"','"+txcep.getText()+"','"+txcidade.getTex
t()+"','"+txuf.getText()+"')");
JOptionPane.showMessageDialog(null,"Gravação concluida!");
txnome.setText("");
txendereco.setText("");
txcep.setText("");
txcidade.setText("");
txuf.setText("");
} else if (e.getSource()==btlimpar){
txnome.setText("");
txendereco.setText("");

83
txcep.setText("");
txcidade.setText("");
txuf.setText("");
}
}
ApClientes ap = new ApClientes();
}
}
3) Acessar o painel de controle do Windows, acessar o ícone ferramentas administrativas,

acessar o ícone fonte de dados ODBC a seguinte janela será apresentada:
Clique no botão
adicionar

84
4) Ao clicar no botão adicionar a seguinte tela será exibida:
Clique em Microsoft
Acess Driver.
Clique em
concluir
5) Ao clicar na opção Microsoft Acess Driver e depois concluir será exibida a seguinte tela:
6) Clicar no botão nos botões Ok até fechar as janelas, fechar o painel de controle.

CADCLIENTE

CR.mdb que esta dentro da
sua pasta de trabalho do
curso.

85
7) No JCretor, digite o seguinte código para a conexão com o banco de dados:

//ConectarBD.java
import java.sql.*;
import java.io.*;
public class ConectarBD {
// string carregar o bd
String dbcarregar = "sun.jdbc.odbc.JdbcOdbcDriver";
// string conectar o bd
String dbconexao = "jdbc:odbc:CADCLIENTE";
// variável para refenciar sql

Statement lesql;
// variável usada para faze a conexao BD

Connection conexao;
public ConectarBD(String comando){
try{
// carregar o driver
Class.forName(dbcarregar); }
catch(ClassNotFoundException e){
System.out.println("Não foi possível carregar o driver");
}
try {
// conectar o driver
conexao = DriverManager.getConnection(dbconexao);
// criar ligacao sql com a conexão

lesql = conexao.createStatement();
lesql.executeUpdate(comando);
lesql.close();
conexao.close();
} catch (SQLException e){
System.out.println("Não foi possível conectar ao BD");
}
}
}
8) Salvar e compilar
9) Acesse o arquivo ApClientes.java
10) Compilar e exceutar
11) Cadastre alguns clientes.
12) Acesse o banco de dados CR.mdb que esta dentro da sua pasta
13) Abra a tabela cliente e veja se os nomes foram cadastrados.

86
6.4) Execute 42: Trabalhando com Banco de Dados

1) Abrir o JCreator
// Clientes.java
// Inserindo, atualizando e pesquisando dados em um banco de dados
import java.sql.*;
import java.awt.*;
import javax.swing.ScrollPaneLayout;
public class Clientes extends JFrame {

private BotoesPainel controls;
private RotuloClientes scrollArea;
private JTextArea output;
private String url;
private Connection connect;
private JScrollPane textpane;
public Clientes() {
super( "Aplicação de Banco de Dados de Agenda de Endereços" );

Container c = getContentPane();
// Inicia o layout da tela

scrollArea = new RotuloClientes();
c.setLayout( new BorderLayout() );
c.add( new JScrollPane( scrollArea ),BorderLayout.CENTER );
// Configura a conexão de banco de dados

try {
url = "jdbc:odbc:AddressBook";
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
connect = DriverManager.getConnection( url );
}
catch ( ClassNotFoundException cnfex ) {
// processa ClassNotFoundExceptions aqui
JOptionPane.showMessageDialog(null, "A conexão falhou!\n" +
cnfex.toString(), "Aviso",JOptionPane.WARNING_MESSAGE );
}
catch ( SQLException sqlex ) {
// processa SQLExceptions aqui
JOptionPane.showMessageDialog(null, "A conexão falhou!\n",
"Aviso",JOptionPane.WARNING_MESSAGE );
}
catch ( Exception ex ) {
// processa Exceptions remanescentes aqui
JOptionPane.showMessageDialog(null, ex.toString(),
"Aviso",JOptionPane.WARNING_MESSAGE );
}

87
// Completa layout de tela

controls = new BotoesPainel( connect, scrollArea, output);
c.add( controls, BorderLayout.NORTH );
setSize( 500, 400 );

move(150, 150);
show();
}
public static void main( String args[] ){

Clientes app = new Clientes();
}
}
5) Crie um novo arquivo e digite o código abaixo:
// RotuloClientes.java
// Definição da classe RotuloClientes
import java.awt.*;
public class RotuloClientes extends JPanel {

private JPanel labelPanel, fieldsPanel;
private String labels[] =
{ "Código:", "Nome:", "Sobrenome:",
"Endereço:", "Cidade:", "Estado:",
"CEP:", "Pais:", "E-mail:",
"Telefone:", "Celular:" };
JTextField id, first, last, address, // accesso de pacote
city, state, zip,
country, email, home, fax;
public RotuloClientes()
{
// Painel de Rótulo
labelPanel = new JPanel();
labelPanel.setLayout(new GridLayout( labels.length, 1 ) );
for ( int i = 0; i < labels.length; i++ )

labelPanel.add( new JLabel( labels[ i ], 0) );
// Painel de TextField
fieldsPanel = new JPanel();
fieldsPanel.setLayout(new GridLayout( labels.length, 1 ) );
id = new JTextField( 20 );
id.setEditable( false );
fieldsPanel.add( id );
first = new JTextField( 20 );
fieldsPanel.add( first );
last = new JTextField( 20 );
88
fieldsPanel.add( last );
address = new JTextField( 20 );
fieldsPanel.add( address );
city = new JTextField( 20 );
fieldsPanel.add( city );
state = new JTextField( 20 );
fieldsPanel.add( state );
zip = new JTextField( 20 );
fieldsPanel.add( zip );
country = new JTextField( 20 );
fieldsPanel.add( country );
email = new JTextField( 20 );
fieldsPanel.add( email );
home = new JTextField( 20 );
fieldsPanel.add( home );
fax = new JTextField( 20 );
fieldsPanel.add( fax );
setLayout( new GridLayout( 1, 2 ) );

add( labelPanel );
add( fieldsPanel );
}
}
7) Cire um novo arquivo e digite o código abaixo:
// BotoesPainel.java
// Definição da classe BotoesPainel
import java.awt.*;
import java.sql.*;
public class BotoesPainel extends JPanel {

private JButton findName, addName,
updateName, deleteName, clear, help;
public BotoesPainel( Connection c, RotuloClientes s,

JTextArea t )
{
setLayout( new GridLayout( 1, 6 ) );
Icon novo = new ImageIcon( "Imagens/Novo.gif" );

clear = new JButton( novo );
clear.addActionListener( new NovoClientes( s ) );
add( clear );
Icon gravar = new ImageIcon( "Imagens/Gravar.gif" );

addName = new JButton( gravar );
addName.addActionListener( new SalvarClientes( c, s, t ) );
add( addName );

89
Icon editar = new ImageIcon( "Imagens/Editar.gif" );

updateName = new JButton( editar );
updateName.addActionListener( new EditarClientes( c, s, t ) );
add( updateName );
Icon excluir = new ImageIcon( "Imagens/Excluir.gif" );

deleteName = new JButton( excluir );
deleteName.addActionListener( new ExcluirClientes( c, s, t ) );
add( deleteName );
Icon localizar = new ImageIcon( "Imagens/Localizar.gif" );

findName = new JButton( localizar );
findName.addActionListener( new PesquisarClientes( c, s, t ) );
add( findName );
Icon ajuda = new ImageIcon( "Imagens/Ajuda.gif" );

help = new JButton( ajuda );
help.addActionListener( new Ajuda( t ) );
add( help );
}
}
// NovoClientes.java
// Definição da classe NovoClientes
import java.awt.*;
public class NovoClientes implements ActionListener {

private RotuloClientes fields;
public NovoClientes( RotuloClientes f )

{
fields = f;
}
//Limpa os campos
public void actionPerformed( ActionEvent e )
{
fields.id.setText( "" );
fields.first.setText( "" );
fields.last.setText( "" );
fields.address.setText( "" );
fields.city.setText( "" );
fields.state.setText( "" );
fields.zip.setText( "" );
fields.country.setText( "" );
fields.email.setText( "" );
fields.home.setText( "" );
fields.fax.setText( "" );
}
}
90
// EditarClientes.java
// Definição da classe EditarClientes
import java.awt.*;
import java.sql.*;
public class EditarClientes implements ActionListener {

private Connection connection;
public EditarClientes( Connection c, RotuloClientes f,

JTextArea o )
{
connection = c;
fields = f;
output = o;
}

{
try {
Statement statement = connection.createStatement();
if ( ! fields.id.getText().equals( "" ) ) {
String query = "UPDATE addresses SET " +
"firstname='" + fields.first.getText() +
"', lastname='" + fields.last.getText() +
"', address='" + fields.address.getText() +
"', city='" + fields.city.getText() +
"', stateorprovince='" +
fields.state.getText() +
"', postalcode='" + fields.zip.getText() +
"', country='" + fields.country.getText() +
"', emailaddress='" +
fields.email.getText() +
"', homephone='" + fields.home.getText() +
"', faxnumber='" + fields.fax.getText() +
"' WHERE id=" + fields.id.getText();
int result = statement.executeUpdate( query );
if ( result == 1 )
JOptionPane.showMessageDialog(
null, "Registro alterado." , "Aviso",
JOptionPane.PLAIN_MESSAGE );
else {
91
null, "Falha na alteração!" , "Aviso",
JOptionPane.WARNING_MESSAGE );
}
statement.close();
}
else
null, "\nUse Alterar somente quando\n " +
"existim registros. Use Pesquisar para\n " +
"localizar um registro, então\n " +
"modifique a informação e\n " +
"pressione Alterar.\n" , "Aviso",
}
sqlex.printStackTrace();
null, sqlex.toString(), "Aviso",
}
}
}

11) Crie um novo arquivo e digite o código:
// SalvarClientes.java
// Definição de classe SalvarClientes
import java.awt.*;
import java.sql.*;
public class SalvarClientes implements ActionListener {

public SalvarClientes( Connection c, RotuloClientes f,

JTextArea o )
{
92
connection = c;
fields = f;
output = o;
}

{
try {
Statement statement = connection.createStatement();
if ( !fields.first.getText().equals( "" ) &&

!fields.last.getText().equals( "" ) ) {
String query = "INSERT INTO addresses (" +
"firstname, lastname, address, city, " +
"stateorprovince, postalcode, country, " +
"emailaddress, homephone, faxnumber" +
") VALUES ('" +
fields.first.getText() + "', '" +
fields.last.getText() + "', '" +
fields.address.getText() + "', '" +
fields.city.getText() + "', '" +
fields.state.getText() + "', '" +
fields.zip.getText() + "', '" +
fields.country.getText() + "', '" +
fields.email.getText() + "', '" +
fields.home.getText() + "', '" +
fields.fax.getText() + "')";
int result = statement.executeUpdate( query );
if ( result == 1 )
null, "A inseção foi um sucesso.", "Aviso",
else {
null, "A inserção falhou!.", "Aviso",
}
}
else{
93
null, "\nDigite o Nome e\n" + "o Sobrenome e aperte\n" +

"o botão Salvar\n" , "Aviso",
statement.close();
}
}
null, sqlex.toString(), "Aviso",
}
}
}

// PesquisarClientes.java
// Definição da classe PesquisarClientes
import java.awt.*;
import java.sql.*;
public class PesquisarClientes implements ActionListener {

public PesquisarClientes( Connection c, RotuloClientes f,

JTextArea o )
{
connection = c;
fields = f;
output = o;
}

{
try {
if ( !fields.last.getText().equals( "" ) ) {
Statement statement =connection.createStatement();
String query = "SELECT * FROM addresses " +
"WHERE lastname = '" +
fields.last.getText() + "'";
ResultSet rs = statement.executeQuery( query );
display( rs );
statement.close();
}
else
fields.last.setText(
94
"Digite o Sobrenome e aperte Pesquisar" );

}
null, sqlex.toString() + "" + 1 , "Aviso",
}
}
// Exibe os resultados da consulta.

public void display( ResultSet rs )
{
try {
rs.next();
int recordNumber = rs.getInt( 1 );
if ( recordNumber != 0 ) {
fields.id.setText( String.valueOf( recordNumber));
fields.first.setText( rs.getString( 2 ) );
fields.last.setText( rs.getString( 3 ) );
fields.address.setText( rs.getString( 4 ) );
fields.city.setText( rs.getString( 5 ) );
fields.state.setText( rs.getString( 6 ) );
fields.zip.setText( rs.getString( 7 ) );
fields.country.setText( rs.getString( 8 ) );
fields.email.setText( rs.getString( 9 ) );
fields.home.setText( rs.getString( 10 ) );
fields.fax.setText( rs.getString( 11 ) );
}
else{
null, "Registro não encontrado!!" , "Aviso",
}
}
null, "Registro não encontrado!!" , "Aviso",
}
}
}

// ExcluirClientes.java
// Definição da classe ExcluirClientes
import java.awt.*;
import java.sql.*;
95
public class ExcluirClientes implements ActionListener {

public ExcluirClientes( Connection c, RotuloClientes f,

JTextArea o )
{
connection = c;
fields = f;
output = o;
}

{
try {
if ( !fields.id.getText().equals( "" ) ) {
Statement statement =connection.createStatement();
String query = "DELETE FROM addresses " +
"WHERE firstname = '" +
fields.first.getText() + "'" + "AND lastname =
'" +
fields.last.getText() + "'";
statement.executeQuery( query );
statement.close();
}
else
null, "É preciso ter um registro para apagar!!" , "Aviso",
}
null, "Registro Apagado!!!", "Aviso",
}
}
}

17) Cire um novo arquivo e digite o código abaixo:
// Ajuda.java
// Definição da classe Ajuda
import java.awt.*;
public class Ajuda implements ActionListener {

96
public Ajuda( JTextArea o )

{
output = o;
}

{
null, "\nClic Pesquisar para localizar um registro.\n" +
"Clic Adicionar para inserir um novo registro.\n" +
"Clic Alterar para alterar " +
"a informação em um registro.\n" +
"Clic Limpar para esvaziar" +
" os campos de registros.\n", "Aviso",
}
}
18)Salvar e compilar
19)Acesse o arquivo Clientes.java.
20) Acessar o painel de controle do Windows, acessar o ícone ferramentas
administrativas, acessar o ícone fonte de dados ODBC a seguinte janela será
apresentada:
Clique no botão
adicionar

97
Ao clicar no botão adicionar a seguinte tela será exibida:
Clique em Microsoft
Acess Driver.
Clique em
concluir
Ao clicar na opção Microsoft Acess Driver e depois concluir será exibida a seguinte tela:

98
Clicar no botão nos botões Ok até fechar as janelas, fechar o painel de controle.

AddressBook

AddressBook.mdb que esta
dentro da sua pasta de
trabalho do curso.
21) Fechar e voltar ao JCreator.

22) Compilar e executar o arquivo Clientes.java
23) Cadastrar alguns amigos
24) Verificar se ficou salvo no banco de dados AddressBook
7 - JSP (Java Server Page)
7.1) O que é JSP?
JSP significa (JAVA Server PAGE). Esta tecnologia é usado para servir conteúdo dinâmico
para o usuário, usando lógica e dados do lado do servidor. JSP faz parte do J2EE (Java 2
Enterprise Edition) e juntamente com Java Servlets e Java Beans podem ser usadas para
desenvolver aplicações Web eficientes,escaláveis e seguras rapidamente.


Apostila de Java Avançado

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Apostila de Java Avançado

Încărcat de

Drepturi de autor:

Formate disponibile

1

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

3.8) Execute 22: Evento de tecla....................................................................................................................36

1 - Programação Visual – Swing

1.2) Componentes do Swing

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.3) Execute 1: Documentação do Swing

1) Abra o meu computador

8) Clique no link do pacote Swing: javax.swing

1.4) Criando uma interface

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.6) Execute 2 Desenvolvendo uma estrutura

public class ExemploFrame extends JFrame { // sub-classe JFrame

public static void main (String[] a){

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

Todo quadro tem botões de maximização, minimização e fechamento na barra de título

1.7) Criando Botões

1.8) Execute 3: Criando botões

public class ExemploBotao extends JFrame {

public static void main(String[] argumentos){

1.9) Criando Rótulos

1.10) Execute 4: Criando Rótulos

public class ExemploRotulo extends JFrame {

public static void main(String[] argumentos){

1.11) Criando Campos de Texto

Os métodos construtores incluem o seguinte:

1.12) Execute 5: Criando campos de texto

public class ExemploCampoTexto extends JFrame {

public static void main(String[] argumentos){

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.13) Criando Áreas de texto

1.14) Execute 6: Criando Áreas de Texto

public class ExemploAreaTexto extends JFrame {

public static void main(String[] argumentos){

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.15) Criando Painéis deslizantes

As barras de rolagens são configuradas usando:

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.16) Execute 7: Criando painéis deslizantes

public class ExemploPaineisdes extends JFrame {

JPanel pane = new JPanel();

public static void main(String a[]){

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.17) Criando Barras de rolagem

A orientação é indicada pelas variáveis de classe JScrollBar, HORIZONTAL e VERTICAL.

1.18) Execute 8: Criando Barras de Rolagem

public class ExemploBarraRola extends JFrame {

JScrollBar bhorizontal = new JScrollBar(JScrollBar.HORIZONTAL);

public static void main(String a[]){

ExemploBarraRola r = new ExemploBarraRola();

1.19) Criando Caixas de verificação

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

JCheckBox(String,boolean): uma caixa de verificação com o rótulo de texto especificado

1.20) Execute 9: Criando caixa de verificação

public class ExemploCheckBox extends JFrame {

JCheckBox[] ensino = new JCheckBox[4];

super("Exemplo de Caixa de Verificação");

JPanel painel = new JPanel();

public static void main(String[] a){

ExemploCheckBox b = new ExemploCheckBox();

SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784

1.21) Criando botões de rádio

1.22) Execute 10: Criando botões de escolha