Você está na página 1de 98

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.7) Execute 37: Trabalhando com Thread.....................................................................................................69
5.8) Execute 38: Trabalhando com Thread.....................................................................................................70
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.
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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;
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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.

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


CEP - 70331-550 Brasília - DF
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).

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


CEP - 70331-550 Brasília - DF
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:

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


CEP - 70331-550 Brasília - DF
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
import javax.swing.*;

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);
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
8

painel.add(rotuloicone);
painel.add(icone);
setContentPane(painel);
show();
}

public static void main(String[] argumentos){


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

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
2) Digite o código abaixo:

// ExemploRotulo.java
import javax.swing.*;

public class ExemploRotulo extends JFrame {


SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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);
private JPanel painel = new JPanel();

// construtor
public ExemploRotulo(){
super("Exemplo Rótulos");
setSize(350,150);
setDefaultCloseOperation(EXIT_ON_CLOSE);
// adicionando os rótulos no painel
painel.add(texto);
painel.add(textoalinhar);
painel.add(textoicone);
setContentPane(painel);

show();
}

public static void main(String[] argumentos){


ExemploRotulo r= new ExemploRotulo();
}
}

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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.
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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
import javax.swing.*;

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);
private JPanel painel = new JPanel();

// construtor
public ExemploCampoTexto(){
super("Exemplo Campo Texto");
setSize(350,150);
setDefaultCloseOperation(EXIT_ON_CLOSE);
// adicionando os campos de texto no painel
painel.add(vazio);
painel.add(largura);
painel.add(textolargura);
setContentPane(painel);

show();
}

public static void main(String[] argumentos){


ExemploCampoTexto t= new ExemploCampoTexto();
}
}

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código:

// ExemploAreaTexto.java
import javax.swing.*;

public class ExemploAreaTexto extends JFrame {


// atributos
private JTextArea lincol = new JTextArea(5,30);
private JTextArea textolincol = new JTextArea("Digite o texto aqui",12,40);
private JPanel painel = new JPanel();

// construtor
public ExemploAreaTexto(){
super("Exemplo Area de Texto");
setSize(450,350);
setDefaultCloseOperation(EXIT_ON_CLOSE);
// adicionando area de texto no painel
painel.add(lincol);
painel.add(textolincol);
setContentPane(painel);

show();
}
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
12

public static void main(String[] argumentos){


ExemploAreaTexto a= new ExemploAreaTexto();
}
}

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


CEP - 70331-550 Brasília - DF
13

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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

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


CEP - 70331-550 Brasília - DF
14

1.16) Execute 7: Criando painéis deslizantes

1) Abra o Jcreator
2) Digite o código abaixo:

//ExemploPaineisdes.java

import javax.swing.*;

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

public static void main(String a[]){


ExemploPaineisdes p = new ExemploPaineisdes();
}
}

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


CEP - 70331-550 Brasília - DF
15

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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
2) Digite o código:

//ExemploBarraRola.java

import javax.swing.*;

public class ExemploBarraRola extends JFrame {


JScrollBar bvertical = new JScrollBar(JScrollBar.VERTICAL);
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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);
setDefaultCloseOperation(EXIT_ON_CLOSE);
painel.add(bvertical);
painel.add(bhorizontal);
painel.add(barrarola);
setContentPane(painel);

show();
}

public static void main(String a[]){

ExemploBarraRola r = new ExemploBarraRola();


}
}

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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

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


CEP - 70331-550 Brasília - DF
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
que é selecionada se o segundo argumento for true

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

1) Abra o Jcreator
2) Digite o código:

// ExemploCheckBox.java

import javax.swing.*;

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);
setDefaultCloseOperation(EXIT_ON_CLOSE);
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);

JPanel painel = new JPanel();


painel.add(lensino);
for (int i=0;i<4;i++){
painel.add(ensino[i]);
}

setContentPane(painel);
show();
}

public static void main(String[] a){

ExemploCheckBox b = new ExemploCheckBox();


}

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


CEP - 70331-550 Brasília - DF
18

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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
que é selecionada se o segundo argumento for true
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
2) Digite o código:

//ExemploRadioButton.java

import javax.swing.*;

public class ExemploRadioButton extends JFrame {


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

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


CEP - 70331-550 Brasília - DF
19

JRadioButton masculino = new JRadioButton("Masculino");


ButtonGroup grupo = new ButtonGroup();
JPanel painel = new JPanel();

public ExemploRadioButton(){
super("Exemplos de Botões de Escolha");
setSize(300,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);

setContentPane(painel);
grupo.add(feminino);
grupo.add(masculino);

painel.add(lsexo);
painel.add(feminino);
painel.add(masculino);

show();

public static void main(String a[]){


ExemploRadioButton r = new ExemploRadioButton();
}
}

3) Quando você compilar e executar o aplicativo, deverá ver a janela ilustrada a seguir:

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.

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


CEP - 70331-550 Brasília - DF
20

1.24) Execute 11: Criando listas suspensas

1) Abra o Jcreator
2) Digite o código abaixo:

//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);
setDefaultCloseOperation(EXIT_ON_CLOSE);
JPanel painel = new JPanel();
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);
setContentPane(painel);
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:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

// ExemploConfirma.java

import javax.swing.*;
public class ExemploConfirma extends JFrame {
public ExemploConfirma(){
int resposta;
resposta = JOptionPane.showConfirmDialog(null,"Tem Certeza que desja sair?");
if (resposta == 0)
System.exit(0);
}

public static void main(String[] a){


ExemploConfirma c = new ExemploConfirma();
}
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//ExemploEntrada.java
import javax.swing.*;
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();
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//ExemploMens.java
import javax.swing.*;
public class ExemploMens extends JFrame {
public ExemploMens(){
JOptionPane.showMessageDialog(null, "Instalação Concluída");
}

public static void main(String [] a){


ExemploMens m = new ExemploMens();
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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.
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//ExemploOpcao.java
import javax.swing.*;
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]);
}

public static void main(String [] a){


ExemploOpcao o = new ExemploOpcao();
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//ExemploSlider.java
import javax.swing.*;

public class ExemploSlider extends JFrame{

public ExemploSlider(){
super("Exemplo de Slider");
setSize(400,100 );
setDefaultCloseOperation(EXIT_ON_CLOSE);

JSlider num = new JSlider(JSlider.HORIZONTAL, 0,30,5);


JPanel painel = new JPanel();

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


CEP - 70331-550 Brasília - DF
26

num.setMajorTickSpacing(10);
num.setMinorTickSpacing(1);
num.setPaintTicks(true);
num.setPaintLabels(true);

painel.add(num);
setContentPane(painel);
show();
}

public static void main(String a[]){


ExemploSlider s = new ExemploSlider();
}
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//ExemploFlowLayout.java
import javax.swing.*;
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);
setDefaultCloseOperation(EXIT_ON_CLOSE);
JPanel painel = new JPanel();
FlowLayout l = new FlowLayout(FlowLayout.LEFT);
painel.setLayout(l);
painel.add(b1);

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


CEP - 70331-550 Brasília - DF
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);
setContentPane(painel);
show();
}

public static void main(String[] a){


ExemploFlowLayout f = new ExemploFlowLayout();
}
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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
2) Digite o código abaixo:

//ExemploGridLayout.java

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

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


CEP - 70331-550 Brasília - DF
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);
setDefaultCloseOperation(EXIT_ON_CLOSE);
JPanel painel = new JPanel();
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);
setContentPane(painel);
show();
}

public static void main(String[] a){


ExemploGridLayout f = new ExemploGridLayout();
}
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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.

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


CEP - 70331-550 Brasília - DF
30

2.6) Execute 19: Gerenciador BorderLayout

1) Abra o Jcreator
2) Digite o código abaixo:

//ExemploBorder.java

import javax.swing.*;
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);
setDefaultCloseOperation(EXIT_ON_CLOSE);
JPanel painel = new JPanel();
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

setContentPane(painel);
show();
}

public static void main(String[] a){


ExemploBorderLayout eb = new ExemploBorderLayout();
}
}

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


CEP - 70331-550 Brasília - DF
31

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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

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


CEP - 70331-550 Brasília - DF
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

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//EventoAcao
import javax.swing.*;
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);
setDefaultCloseOperation(EXIT_ON_CLOSE);

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");


SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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);
}

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


CEP - 70331-550 Brasília - DF
35

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


public static void main(String a[]){
EventoAcao e = new EventoAcao();
}
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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
2) Digite o código abaixo:

import java.awt.event.*;
import javax.swing.*;
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");
setDefaultCloseOperation(EXIT_ON_CLOSE);
escolha.addItemListener(this);
escolha.addItem("Navigator");
escolha.addItem("Internet Explorer");
escolha.addItem("Opera");
escolha.setEditable(false);

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


CEP - 70331-550 Brasília - DF
36

resultado.setHorizontalAlignment(SwingConstants.CENTER);
resultado.setEditable(false);
JPanel painel = new JPanel();
painel.setLayout(borda);
painel.add(resultado, "South");
painel.add(escolha,"Center");

setContentPane(painel);
}

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) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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
2) Digite o código abaixo:

import java.awt.event.*;
import javax.swing.*;
import java.awt.*;
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
37

public class EventoTecla extends JFrame implements KeyListener {


JTextField digite = new JTextField(20);
JPanel painel = new JPanel();

public EventoTecla(){
super("Exemplo de Evento de tecla");
setLocation(100,100);
setSize(300,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);

painel.add(digite,"Center");
digite.addKeyListener(this);

setContentPane(painel);

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

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

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

public class EventoMouse extends JFrame implements MouseListener {


JButton btclicar = new JButton("Clique");
JButton btapontar = new JButton("Aponte");
JPanel painel = new JPanel();

public EventoMouse(){
super("Exemplo de Evento de Mouse");
setLocation(100,100);
setSize(300,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);

painel.add(btclicar,"Center");
btclicar.addMouseListener(this);

painel.add(btapontar,"Center");
btapontar.addMouseListener(this);

setContentPane(painel);

show();

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


CEP - 70331-550 Brasília - DF
39

public void mouseReleased(MouseEvent evento){


if (evento.getSource()== btclicar){
JOptionPane.showMessageDialog(null,"Voce atualizou mouse");
}

public void mousePressed(MouseEvent evento){

if (evento.getSource()== btclicar){
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){


if (evento.getSource()== btapontar){
JOptionPane.showMessageDialog(null,"Voce apontou para mim");
}

public void mouseClicked(MouseEvent evento){

if (evento.getSource()== btclicar){
JOptionPane.showMessageDialog(null,"Voce clicou em mim");
}

}
public static void main(String a []){
EventoMouse mouse = new EventoMouse();
}
}

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


CEP - 70331-550 Brasília - DF
40

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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
2) Digite o código abaixo:

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

public class EventoMovMouse extends JFrame implements MouseMotionListener {

JButton btapontar = new JButton("Aponte");


JButton btarrastar = new JButton("Arrastar");
JPanel painel = new JPanel();

public EventoMovMouse(){
super("Exemplo de Evento de Movimento do Mouse");
setLocation(100,100);
setSize(300,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);

painel.add(btapontar,"Center");
btapontar.addMouseMotionListener(this);

painel.add(btarrastar,"Center");
btarrastar.addMouseMotionListener(this);

setContentPane(painel);

show();
}
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
41

public void mouseMoved(MouseEvent evento){


if (evento.getSource()== btapontar){
JOptionPane.showMessageDialog(null,"Voce moveu o mouse em mim");
}

public void mouseDragged(MouseEvent evento){

if (evento.getSource()== btarrastar){
JOptionPane.showMessageDialog(null,"Voce tentou arrastar");
}

public static void main(String a []){


EventoMovMouse mouse = new EventoMovMouse();
}
}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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
2) Digite o código abaixo:
import java.awt.event.*;
import javax.swing.*;
import java.awt.*;

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


CEP - 70331-550 Brasília - DF
42

public class EventoJanela extends JFrame implements WindowListener {

public EventoJanela(){
super("Exemplo de Evento de Janela");
setLocation(100,100);
setSize(300,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
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");
}

public static void main(String a []){


EventoJanela mouse = new EventoJanela();
}
}

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


CEP - 70331-550 Brasília - DF
43

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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
2) Digite o código abaixo:

import javax.swing.*;

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


CEP - 70331-550 Brasília - DF
44

import java.awt.event.*;
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);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);

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

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


CEP - 70331-550 Brasília - DF
45

show();

public void actionPerformed(ActionEvent evento){

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");
}
}
public static void main(String a[]){

CriarMenu cm = new CriarMenu();


}

3) Quando você compilar e executar o aplicativo deverá ver a janela ilustrada a seguir:

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

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

public class CriarFerramentas extends JFrame implements ActionListener{

JToolBar barraferra = new JToolBar();


JButton b1 = new JButton(new ImageIcon("botao1.gif"));
JButton b2 = new JButton(new ImageIcon("botao2.gif"));
JButton b3 = new JButton(new ImageIcon("botao3.gif"));

public CriarFerramentas(){
super();
setSize(500,500);

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


CEP - 70331-550 Brasília - DF
47

setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);

getContentPane().add(barraferra,BorderLayout.NORTH);
barraferra.add(b1);
b1.addActionListener(this);
barraferra.add(b2);
b2.addActionListener(this);
barraferra.add(b3);
b3.addActionListener(this);

show();
}

public void actionPerformed(ActionEvent evento){

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

}
public static void main(String a[]){
CriarFerramentas cr = new CriarFerramentas();
}
}

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


CEP - 70331-550 Brasília - DF
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:

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


CEP - 70331-550 Brasília - DF
49

2) Desenvolva uma aplicação com a seguinte tela:

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.

3) Desenvolva uma aplicação com a seguinte tela:

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


CEP - 70331-550 Brasília - DF
50

4) Desenvolva uma aplicação com a seguinte tela:

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.

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

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

public class Linhas extends JFrame {


public Linhas(){
super("Criando Linhas");
setSize(300,300);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
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);
int x2 = (int) Math.round(Math.random()*300);
int y2 = (int) Math.round(Math.random()*300);
g.drawString("("+x2+","+y2+")",x2, y2);

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

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


CEP - 70331-550 Brasília - DF
52

public static void main(String a[]){


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
2) Digite o código abaixo:

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

public class Retangulos extends JFrame {

public Retangulos(){
super("Criando Retângulos");
setSize(300,300);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
}

public void paint(Graphics g){

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


CEP - 70331-550 Brasília - DF
53

int x1 = (int) Math.round(Math.random()*300);


int y1 = (int) Math.round(Math.random()*300);

int x2 = (int) Math.round(Math.random()*300);


int y2 = (int) Math.round(Math.random()*300);

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

public static void main(String a[]){


Retangulos l = new Retangulos();
}

3) Compilar e executar.

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
2) Digite o código abaixo:

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

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


CEP - 70331-550 Brasília - DF
54

public class Elipse extends JFrame {

public Elipse(){
super("Criando Elipse");
setSize(300,300);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
}

public void paint(Graphics g){


int x1 = (int) Math.round(Math.random()*300);
int y1 = (int) Math.round(Math.random()*300);

int x2 = (int) Math.round(Math.random()*300);


int y2 = (int) Math.round(Math.random()*300);

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

public static void main(String a[]){


Elipse l = new Elipse();
}

3) Compilar e executar.

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.

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

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

public class Poligono extends JFrame {

public Poligono(){
super("Criando Poligonos");
setSize(300,300);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
}

public void paint(Graphics g){


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

x[1] = (int) Math.round(Math.random()*300);


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

x[2] = (int) Math.round(Math.random()*300);


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

x[3] = (int) Math.round(Math.random()*300);


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

g.drawPolygon(x,y,4);

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


CEP - 70331-550 Brasília - DF
56

public static void main(String a[]){


Poligono l = new Poligono();
}

3) Compilar e executar.

4.9) Melhorando as Aplicações usando primitivas gráficas

4.10) Execute 32Criando Linhas e Elipse


1) Abra o JCreator
2) Digite o código abaixo:

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

public class Grafica1 extends JFrame {

public Grafica1(){
super();
setSize(205,205);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
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);
}

public static void main(String a[]){


Grafica1 g = new Grafica1();
}
}

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


CEP - 70331-550 Brasília - DF
57

3) Compilar e executar.
4) A janela será exibida:

4.11) Execute 33Criando Retângulos com gráficos


1) Abra o JCreator
2) Digite o código abaixo:

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

public class Grafica2 extends JFrame {


JLabel lbestat = new JLabel("Estatistica Atual:");
Graph gstat = new Graph();

public Grafica2() {
super();
setSize(260,240);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
getContentPane().add("North", lbestat);
getContentPane().add("Center", gstat);
show();
}

public static void main(String a[]){


Grafica2 g = new Grafica2();
}
}

class Graph extends java.awt.Canvas {


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

public void paint(Graphics tela) {

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


CEP - 70331-550 Brasília - DF
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);
}
}
}

3) Compilar e executar.
4) A tela será mostrada:

4.12) Execute 34Criando Retângulos com gráficos


1) Abra o JCreator
2) Digite o código abaixo:

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

public class Grafica3 extends JFrame {

public Grafica3(){
super();
setSize(350,370);
setLocation(100,100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
}

public void paint(Graphics tela) {


setBackground(Color.blue);

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


CEP - 70331-550 Brasília - DF
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);
fl.addPoint(234, 15);
fl.addPoint(253, 25);
fl.addPoint(261, 71);
fl.addPoint(344, 209);
fl.addPoint(336, 278);
fl.addPoint(295, 310);
fl.addPoint(259, 274);
fl.addPoint(205, 188);
fl.addPoint(211, 171);
fl.addPoint(195, 174);
fl.addPoint(191, 118);
fl.addPoint(120, 56);
fl.addPoint(94, 68);
fl.addPoint(81, 49);
fl.addPoint(12, 37);
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);
}

public static void main(String a[]){


Grafica3 g = new Grafica3();
}
}

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


CEP - 70331-550 Brasília - DF
60

3) Compilar e executar.
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.

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


CEP - 70331-550 Brasília - DF
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.

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


CEP - 70331-550 Brasília - DF
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().

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


CEP - 70331-550 Brasília - DF
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);
} catch (InterruptedException e) { }
}
}

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:

//RelogioDigital.java
import java.awt.*;
import javax.swing.*;
import java.util.*;

public class RelogioDigital extends JFrame {


Janela j = new Janela();

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

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


CEP - 70331-550 Brasília - DF
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);
} catch (InterruptedException e) { }
}

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:

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


CEP - 70331-550 Brasília - DF
66

5.6) Execute 36:Trabalhando com Thread


1) Abra o JCreator
2) Digite o código abaixo:

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

public class SinalTransito extends JFrame {


LuzSinal luz = new LuzSinal();

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

public static void main(String[] arguments) {


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);
} catch (InterruptedException e) { }

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


CEP - 70331-550 Brasília - DF
67

}
}

public void paintComponent(Graphics comp) {


Graphics2D comp2D = (Graphics2D)comp;
comp2D.setColor(Color.black);
comp2D.fillRect(0, 0, 300, 300);
if (contador == 2)
comp2D.setColor(Color.red);
else
comp2D.setColor(Color.black);
comp2D.fillOval(0, 0, 100, 100);
if (contador == 1)
comp2D.setColor(Color.yellow);
else
comp2D.setColor(Color.black);
comp2D.fillOval(0, 100, 100, 100);
if (contador == 0)
comp2D.setColor(Color.green);

else
comp2D.setColor(Color.black);
comp2D.fillOval(0, 200, 100, 100);
}
}

3) Compilar e executar.
4) A seguinte tela será mostrada mudando o sinal de transito.

observação: neste momento esta sinal amarelo, veja a mudança de sinal.

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


CEP - 70331-550 Brasília - DF
68

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


CEP - 70331-550 Brasília - DF
69

5.7) Execute 37: Trabalhando com Thread


1) Abra o JCreator
2) Digite o código abaixo:
//BannerLinha.java
import java.awt.*;
import javax.swing.*;
import java.util.*;

public class BannerLinha extends JFrame {


BannerPainel novo = new BannerPainel();

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

public static void main(String[] arguments) {


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);
} catch (InterruptedException e) { }
}
}

public void paintComponent(Graphics comp) {


SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
70

Graphics2D comp2D = (Graphics2D)comp;


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

3) Compilar e executar.
4) A seguinte tela será mostrada:

5.8) Execute 38: Trabalhando com Thread


1) Abra o JCreator
2) Digite o código abaixo:

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

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);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel pane = new JPanel();
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);

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


CEP - 70331-550 Brasília - DF
71

painelbotoes.add(btparar);

pane.add(painelbotoes, "South");
setContentPane(pane);
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);
}
}

public static void main(String[] arguments) {


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);
} catch (InterruptedException e) { }
}
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
72

public void paintComponent(Graphics comp) {


Graphics2D comp2D = (Graphics2D)comp;
comp2D.setColor(Color.black);
comp2D.fillRect(0, 0, 100, 100);
comp2D.setColor(Color.white);
comp2D.fillRect(100, 0, 100, 100);
comp2D.setColor(Color.red);
comp2D.fillOval(xPos, 5, 90, 90);
}
}

3) Compilar e executar.
4) A seguinte tela será mostrada:

5.9) Execute 39Trabalhando com Thread


1) Abra o JCreator
2) Digite o código abaixo:

//Pete.java
import java.awt.*;
import javax.swing.*;
import java.util.*;

public class Pete extends JFrame {


PetePanel pete = new PetePanel();

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

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


CEP - 70331-550 Brasília - DF
73

public static void main(String[] arguments) {


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

public void paintComponent(Graphics comp) {


Graphics2D comp2D = (Graphics2D)comp;
if (back != null)
comp2D.drawImage(back, 0, 0, this);
comp2D.setColor(Color.black);
comp2D.fillRect(0, 30, 450, 30);
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);

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


CEP - 70331-550 Brasília - DF
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);

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


CEP - 70331-550 Brasília - DF
75

} catch (InterruptedException e) { }
}
}
3) Compilar e executar.
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.

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


CEP - 70331-550 Brasília - DF
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

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


CEP - 70331-550 Brasília - DF
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();
}

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


CEP - 70331-550 Brasília - DF
78

6.2) Execute 40- Trabalhando com Banco de Dados

1) Abra o JCreator
2) Digite o código abaixo:

// 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";
} catch(SQLException e) {
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);
}
} catch(SQLException e) {
System.out.println("consulta erro");
}

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


CEP - 70331-550 Brasília - DF
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

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


CEP - 70331-550 Brasília - DF
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.

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


CEP - 70331-550 Brasília - DF
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
2) Digite o código abaixo:
import javax.swing.*;
import java.awt.event.*;
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);
setDefaultCloseOperation(EXIT_ON_CLOSE);

// 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");
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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("");

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


CEP - 70331-550 Brasília - DF
83

txcep.setText("");
txcidade.setText("");
txuf.setText("");
}

}
public static void main(String a[]){
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

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


CEP - 70331-550 Brasília - DF
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.

Coloque a fonte de dados


CADCLIENTE

Selecionar o banco de dados


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

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


CEP - 70331-550 Brasília - DF
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.

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


CEP - 70331-550 Brasília - DF
86

6.4) Execute 42: Trabalhando com Banco de Dados


1) Abrir o JCreator
2) Digite o código abaixo:

// Clientes.java
// Inserindo, atualizando e pesquisando dados em um banco de dados
import java.sql.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
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" );


setDefaultCloseOperation(EXIT_ON_CLOSE);

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

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


CEP - 70331-550 Brasília - DF
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();
}
}

4) Salvar e compilar
5) Crie um novo arquivo e digite o código abaixo:
// RotuloClientes.java
// Definição da classe RotuloClientes
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.ScrollPaneLayout;

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 );
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
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 );
}
}

6) Salvar e compilar
7) Cire um novo arquivo e digite o código abaixo:
// BotoesPainel.java
// Definição da classe BotoesPainel
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import javax.swing.*;
import javax.swing.ScrollPaneLayout;

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

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


CEP - 70331-550 Brasília - DF
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 );
}
}

8) Crie um novo arquivo e digite o código abaixo:

// NovoClientes.java
// Definição da classe NovoClientes
import java.awt.*;
import java.awt.event.*;
import javax.swing.ScrollPaneLayout;

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( "" );
}
}
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
90

9) Salvar e compilar
10) Crie um novo arquivo e digite o código abaixo:
// EditarClientes.java
// Definição da classe EditarClientes
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import javax.swing.*;
import javax.swing.ScrollPaneLayout;

public class EditarClientes implements ActionListener {


private RotuloClientes fields;
private JTextArea output;
private Connection connection;

public EditarClientes( Connection c, RotuloClientes f,


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

public void actionPerformed( ActionEvent e )


{
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 {
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
91

JOptionPane.showMessageDialog(
null, "Falha na alteração!" , "Aviso",
JOptionPane.WARNING_MESSAGE );
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( "" );
}

statement.close();
}
else
JOptionPane.showMessageDialog(
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",
JOptionPane.PLAIN_MESSAGE );
}
catch ( SQLException sqlex ) {
sqlex.printStackTrace();
JOptionPane.showMessageDialog(
null, sqlex.toString(), "Aviso",
JOptionPane.WARNING_MESSAGE );
}
}
}

10) Salvar e compilar


11) Crie um novo arquivo e digite o código:
// SalvarClientes.java
// Definição de classe SalvarClientes
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import javax.swing.*;
import javax.swing.ScrollPaneLayout;

public class SalvarClientes implements ActionListener {


private RotuloClientes fields;
private JTextArea output;
private Connection connection;

public SalvarClientes( Connection c, RotuloClientes f,


JTextArea o )
{
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
92

connection = c;
fields = f;
output = o;
}

public void actionPerformed( ActionEvent e )


{
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 )
JOptionPane.showMessageDialog(
null, "A inseção foi um sucesso.", "Aviso",
JOptionPane.PLAIN_MESSAGE );

else {
JOptionPane.showMessageDialog(
null, "A inserção falhou!.", "Aviso",
JOptionPane.WARNING_MESSAGE );

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( "" );
}
}
else{
JOptionPane.showMessageDialog(
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
93

null, "\nDigite o Nome e\n" + "o Sobrenome e aperte\n" +


"o botão Salvar\n" , "Aviso",
JOptionPane.WARNING_MESSAGE );

statement.close();
}
}
catch ( SQLException sqlex ) {
JOptionPane.showMessageDialog(
null, sqlex.toString(), "Aviso",
JOptionPane.WARNING_MESSAGE );

}
}
}

12) Salvar e compilar


13) Crie um novo arquivo e digite o código abaixo:
// PesquisarClientes.java
// Definição da classe PesquisarClientes
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import javax.swing.*;
import javax.swing.ScrollPaneLayout;

public class PesquisarClientes implements ActionListener {


private RotuloClientes fields;
private JTextArea output;
private Connection connection;

public PesquisarClientes( Connection c, RotuloClientes f,


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

public void actionPerformed( ActionEvent e )


{
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(
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
94

"Digite o Sobrenome e aperte Pesquisar" );


}
catch ( SQLException sqlex ) {
JOptionPane.showMessageDialog(
null, sqlex.toString() + "" + 1 , "Aviso",
JOptionPane.WARNING_MESSAGE );
}
}

// 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{
JOptionPane.showMessageDialog(
null, "Registro não encontrado!!" , "Aviso",
JOptionPane.WARNING_MESSAGE );
}
}
catch ( SQLException sqlex ) {
JOptionPane.showMessageDialog(
null, "Registro não encontrado!!" , "Aviso",
JOptionPane.WARNING_MESSAGE );
}
}
}

14) Salvar e compilar


15) Crie um novo arquivo e digite o código abaixo:

// ExcluirClientes.java
// Definição da classe ExcluirClientes
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import javax.swing.*;
SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
95

import javax.swing.ScrollPaneLayout;

public class ExcluirClientes implements ActionListener {


private RotuloClientes fields;
private JTextArea output;
private Connection connection;

public ExcluirClientes( Connection c, RotuloClientes f,


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

public void actionPerformed( ActionEvent e )


{
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
JOptionPane.showMessageDialog(
null, "É preciso ter um registro para apagar!!" , "Aviso",
JOptionPane.WARNING_MESSAGE );
}
catch ( SQLException sqlex ) {
JOptionPane.showMessageDialog(
null, "Registro Apagado!!!", "Aviso",
JOptionPane.PLAIN_MESSAGE );
}
}
}

16) Salvar e compilar


17) Cire um novo arquivo e digite o código abaixo:
// Ajuda.java
// Definição da classe Ajuda
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.ScrollPaneLayout;

public class Ajuda implements ActionListener {


SCRS 504 Bl. – B Ent. – 53 1º Andar Tel.: (61) 3225-7784
CEP - 70331-550 Brasília - DF
96

private JTextArea output;

public Ajuda( JTextArea o )


{
output = o;
}

public void actionPerformed( ActionEvent e )


{
JOptionPane.showMessageDialog(
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",
JOptionPane.PLAIN_MESSAGE );
}
}

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

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


CEP - 70331-550 Brasília - DF
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:

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


CEP - 70331-550 Brasília - DF
98

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

Coloque a fonte de dados


AddressBook

Selecionar o banco de dados


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.

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


CEP - 70331-550 Brasília - DF