Material de Apoio

de Programação
Orientada a Objetos
Professor: Wilson da Silva Lourenço

1
CONTEÚDO

INTRODUÇÃO À ORIENTAÇÃO A OBJETOS ............................................................................................. 6

Definições ................................................................................................................................................ 6

Abstração ................................................................................................................................................. 6

Encapsulamento....................................................................................................................................... 7

Herança ................................................................................................................................................... 7

Polimorfismo ............................................................................................................................................ 8

INTRODUÇÃO AO JAVA ............................................................................................................................11

O que é JAVA? .......................................................................................................................................11

Criando uma APLICAÇÃO.......................................................................................................................11

O código fonte .....................................................................................................................................11

Compilando a aplicação .......................................................................................................................11

Informações Básicas ...............................................................................................................................12

Variáveis e tipos de dados ...................................................................................................................12

JAVA ..........................................................................................................................................................13

Conhecendo o ambiente..........................................................................................................................13

Funcionamento .......................................................................................................................................13

A máquina virtual Java (JVM) ..................................................................................................................13

A plataforma JAVA ..................................................................................................................................14

Primeiro programa: teste.java ..................................................................................................................14

Compilando e executando....................................................................................................................14

Entendendo a nomenclatura do Java ...................................................................................................14

Convenções ............................................................................................................................................17

Comentários............................................................................................................................................17

Ponto-e-vírgula, blocos e espaços em branco..........................................................................................17

Identificadores .........................................................................................................................................18

Palavras reservadas ................................................................................................................................18

Variáveis .................................................................................................................................................19

Declaração de variáveis e constantes ..................................................................................................19

Operadores .............................................................................................................................................19

Operadores Aritméticos .......................................................................................................................19

2
 Operadores Relacionais .......................................................................................................................20

Operadores Lógicos .............................................................................................................................20

Controle de fluxo .....................................................................................................................................20

Controle de Fluxo - IF ..........................................................................................................................21

Controle de Fluxo - WHILE ..................................................................................................................21

Controle de Fluxo - FOR ......................................................................................................................22

Controle de Fluxo - SWITCH ................................................................................................................23

MÉTODOS ACESSORES: GET E SET .......................................................................................................26

Set ..........................................................................................................................................................26

Get ..........................................................................................................................................................26

Is.............................................................................................................................................................26

ARRAYS E DIÁLOGOS ..............................................................................................................................28

Arrays .....................................................................................................................................................28

CONTAINERS ............................................................................................................................................35

Gerenciadores de Layout ........................................................................................................................40

Look And Feel .........................................................................................................................................41

CRIANDO MENUS .....................................................................................................................................42

JFormattedTextField ...................................................................................................................................44

ESCOPO ....................................................................................................................................................46

Modificadores de acesso .........................................................................................................................46

Acesso Padrão (Default) ......................................................................................................................47

Acesso Público (public) ........................................................................................................................47

Acesso Protegido (Protected)...............................................................................................................47

Acesso Particular (private) ...................................................................................................................48

CHECKBOX ...............................................................................................................................................50

POLIMORFISMO ........................................................................................................................................51

FormattedSample .......................................................................................................................................52

GRID ..........................................................................................................................................................53

NETBEANS ................................................................................................................................................54

Instalando o Netbeans.............................................................................................................................54

Conhecendo a IDE ..................................................................................................................................56

Criando uma Aplicação MDI: ................................................................................................................56

Componentes da Janela em modo de Trabalho ...................................................................................62

3
 Trabalhando com componentes ...........................................................................................................63

Telas do NetBeans – versão 4.................................................................................................................65

Aplicações Gráficas com Swing ...............................................................................................................70

Gerenciadores de Layout .....................................................................................................................72

Aplicações Gráficas com Swing Construindo Aplicações com o NetBeans ...............................................74

Utilizando JLabel, JTextField e JButton com o NetBeans .....................................................................74

Utilizando JCombobox/Jlist e JRadioButton .............................................................................................80

JCombobox/JList .................................................................................................................................80

Utilizando JRadioButton com o NetBeans ............................................................................................82

Aplicações Gráficas com Swing Componentes Especializados ................................................................83

JOptionPane ........................................................................................................................................83

JFileChooser........................................................................................................................................85

JEditorPane .........................................................................................................................................88

Trabalhando Múltiplos Formulários - Menus ............................................................................................89

Banco de Dados No NetBeans ................................................................................................................94

Acessando Bancos de Dados ..............................................................................................................94

Arquitetura ...........................................................................................................................................94

Principais Comandos SQL ...................................................................................................................96

Construção de Aplicações - Acessando um Banco de Dados Access ...................................................96

JDBC no NetBeans ..............................................................................................................................97

COMPONENTES GRÁFICOS...................................................................................................................106

Usando Componentes Gráficos no NetBeans ........................................................................................108

Tarefa 1: A Interface Gráfica da Aplicação .........................................................................................112

Eventos .................................................................................................................................................112

Tratamento de Eventos no NetBeans .................................................................................................113

IMPLEMENTANDO COMPONENTES BÁSICOS COM SWING, UTILIZANDO NETBEANS ......................117

Item 1: Criando um JFrame. .................................................................................................................117

Item 2: Construindo a Interface.............................................................................................................118

Item 3: passo-a-passo ..........................................................................................................................119

Item 4: Manipulando o código ...............................................................................................................120

Item 5: Exibindo Dados .........................................................................................................................124

CONEXÃO COM BANCO DE DADOS ......................................................................................................126

Arquitetura JDBC ..................................................................................................................................126

4
 Conexão com o banco de dados ...........................................................................................................126

Etapa 1 — Importar as classes JDBC ................................................................................................126

Etapa 2 — Carregar o driver JDBC ....................................................................................................127

Etapa 3 - Especificar um banco de dados ..........................................................................................127

Etapa 4 – Abrir a conexão ..................................................................................................................127

Etapa 5 - Criar um Statement .............................................................................................................127

Etapa 6 - Submeter um comando SQL ...............................................................................................128

Etapa 7 - Receber os resultados ........................................................................................................128

CONEXÃO DO JAVA COM O ORACLE....................................................................................................130

ANEXOS ..................................................................................................................................................131

Configuração do JDK no Windows 7 ......................................................................................................131

Como conectar o Java ao MySQL usando o NetBeans ..........................................................................133

CÓDIGO DO SISTEMA “AGENDA DE TELEFONE” .................................................................................138

Modelo de Banco de Dados para a Agenda de Telefone ....................................................................142

5
INTRODUÇÃO À ORIENTAÇÃO A OBJETOS

A Programação Orientada ao Objeto (POO) pode ser considerada como uma extensão quase natural da
Programação Modular; entretanto a sigla POO tem causado certa inquietação entre a comunidade de
Informática, nos últimos anos. Na verdade, isto não deveria acontecer, uma vez que a POO foi concebida há
muito tempo atrás (no inicio da década de 70). A sua origem vem da linguagem Simula, concebida na
Noruega no início da década de 60, e como o nome indica, foi criada para fazer simulações; entretanto, seu
uso alavancou um conceito que até então passava "despercebido" pela maioria dos projetistas: a
similaridade com o mundo real.

DEFINIÇÕES

Um objeto é uma entidade do mundo real que tem uma identidade. Objetos podem representar entidades
concretas (um arquivo no meu computador, uma bicicleta) ou entidades conceituais (uma estratégia de jogo,
uma política de escalonamento em um sistema operacional). Cada objeto ter sua identidade significa que
dois objetos são distintos mesmo que eles apresentem exatamente as mesmas características.
Embora objetos tenham existência própria no mundo real, em termos de linguagem de programação um
objeto necessita um mecanismo de identificação. Esta identificação de objeto deve ser única, uniforme e
independente do conteúdo do objeto. Este é um dos mecanismos que permite a criação de coleções de
objetos, as quais são também objetos em si. Por exemplo, um objeto é um formulário, um botão, caixa de
texto.
Um objeto consiste em:
Propriedades - a capacidade de definir e/ou obter um valor do estado referenciado por um objeto. (Ex:
form1.width )
Métodos - rotinas disponíveis que permitem o processamento no interior do objeto. (Ex: form1.show ,
form1.hide)
A estrutura de um objeto é representada em termos de atributos. O comportamento de um objeto é
representado pelo conjunto de operações que podem ser executadas sobre o objeto. Objetos com a mesma
estrutura e o mesmo comportamento são agrupados em classes. Uma classe é uma abstração que
descreve propriedades importantes para uma aplicação e simplesmente ignora o resto.
Cada classe descreve um conjunto (possivelmente infinito) de objetos individuais. Cada objeto é uma
instância de uma classe. Assim, cada instância de uma classe tem seus próprios valores para cada atributo.
Formalmente, para ser considerada uma linguagem OO, esta precisa implementar quatro conceitos básicos:
abstração, encapsulamento, herança e polimorfismo

ABSTRAÇÃO

É considerada como a habilidade de modelar características do mundo real do problema que o programador
esteja tentando resolver. Podemos demonstrar o uso de abstração facilmente, quando fechamos os olhos e
pensamos em uma mesa; esta mesa imaginária provavelmente não vai ser igual à outra imaginada por
outras pessoas, mas o que importa é que todas as pessoas que imaginaram uma mesa colocaram nessa as
6
informações que para elas são necessárias para a sua função (de ser uma mesa). Não importa se a mesa é
de três pés ou quatro, ou se o tampão é de vidro, madeira ou mármore; o que importa é que a imagem que
idealizamos em nossa cabeça é de uma mesa e tenha as informações necessárias para cumprir sua função.
O uso apropriado de abstração permite que um mesmo modelo conceitual (orientação a objetos) seja
utilizado para todas as fases de desenvolvimento de um sistema, desde sua análise até sua documentação.

ENCAPSULAMENTO

O encapsulamento é a base de toda a abordagem da Programação Orientada ao Objeto, isto porque

contribui fundamentalmente para diminuir os malefícios causados pela interferência externa sobre os dados.
Partindo desse princípio, toda e qualquer transação feita com esses dados só pode ser feita através de
procedimentos colocados "dentro" desse objeto, pelo envio de mensagens. Desta maneira, dizemos que um
dado está encapsulado quando envolvido por código de forma que só é visível na rotina onde foi criado; o
mesmo acontece com uma rotina, que, sendo encapsulada, suas operações internas são invisíveis às
outras rotinas. No encapsulamento podemos visualizar a sua utilidade pensando em um vídeo cassete,
onde temos os botões de liga-desliga, para frente, para traz, etc. Estes botões executam uma série de
operações existentes no aparelho, onde são executadas pelos componentes existentes dentro do aparelho
(transistores, cabos, motores, etc.) Não interessa ao operador saber como é o funcionamento interno do
equipamento; esta informação só é relevante para os projetistas do aparelho. As informações pertinentes ao
usuário do equipamento são as existentes no meio externo (botões, controle remoto) que ativam as
operações internas do equipamento. Desta maneira o aparelho de vídeo cassete pode evoluir com os
avanços tecnológicos, e as pessoas que o utilizam continuam sabendo utilizar o equipamento, sem a
necessidade de um novo treinamento. Na área de software acontece o mesmo: as classes podem continuar
evoluindo, com aumento de tecnologia, e os programas que utilizam essas classe continuam compatíveis.
Isto ocorre porque a esses programas não interessa saber como é o funcionamento interno da classe e sim
sua função, para que ele possa executar, conforme ela evolui, novas funções colocadas à sua disposição.
O uso do encapsulamento permite que a implementação de um objeto possa ser modificada sem afetar as
aplicações que usam este objeto. Motivos para modificar a implementação de um objeto podem ser, por
exemplo, melhoria de desempenho, correção de erros e mudança de plataforma de execução.

HERANÇA

Herança é um mecanismo que, se for bem empregado, permite altos graus de reutilização de código. Do
ponto de vista prático, pode ser entendido como sendo um conjunto de instâncias criadas a partir de outro
conjunto de instâncias com características semelhantes, e os elementos desse subconjunto herdam todas
as características do conjunto original. A idéia é fornecer um mecanismo simples (mas muito poderoso) para
que se definam novas classes a partir de uma já existente. Assim sendo, dizemos que essas novas classes
herdam todos os membros (propriedades+métodos) da classe-mãe; isto torna o mecanismo de herança
uma técnica muito eficiente para construir, organizar e reutilizar código. Por isso, nas linguagens que não
suportam esse mecanismo, as classes são criadas como unidades independentes: cada uma com seus

7
membros concebidos do zero (sem vínculo direto com outras classes), o que torna o processo mais
demorado e com códigos, às vezes, redundantes.
Esta capacidade de fatorar as propriedades comuns de diversas classes em uma superclasse pode reduzir
dramaticamente a repetição de código em um projeto ou programa, sendo uma das principais vantagens da
abordagem de orientação a objetos.

POLIMORFISMO

Na Informática, e em particular no universo da POO, é definido como sendo um código que possui "vários
comportamentos" ou que produz "vários comportamentos"; em outras palavras, é um código que pode ser
aplicado à várias classes de objetos. A mesma mensagem é enviada a objetos de classes distintas e eles
poderão reagir de maneiras diferentes. Um método polimórfico é aquele que pode ser aplicado à várias
classes de objetos sem que haja qualquer inconveniente. É o caso, por exemplo, do método Clear em
Delphi®, que pode ser aplicado tanto à classe TEdit como à classe TListBox; nas duas situações o
conteúdo desse objetos são limpos, mesmo pertencendo, ambos, à classes distintas. Um exemplo simples é
dado por um simples moedor de carne. Esse equipamento tem a função de moer carne, produzindo carne
moída para fazer bolinhos. Desse modo, não importa o tipo (classe) de carne alimentada; o resultado será
sempre carne moída, não importa se de boi, de frango ou de qualquer outro tipo. As restrições impostas
pelo processo estão no próprio objeto, definidas pelo seu fabricante e não pelo usuário do produto.
Outro exemplo, a operação move quando aplicada a uma janela de um sistema de interfaces tem um
comportamento distinto do que quando aplicada a uma peça de um jogo de xadrez. Um método é uma
implementação específica de uma operação para certa classe.
Polimorfismo também implica que uma operação de uma mesma classe pode ser implementada por mais de
um método. O usuário não precisa saber quantas implementações existem para uma operação, ou explicitar
qual método deve ser utilizado: a linguagem de programação deve ser capaz de selecionar o método
correto a partir do nome da operação, classe do objeto e argumentos para a operação. Desta forma, novas
classes podem ser adicionadas sem necessidade de modificação de código já existente, pois cada classe
apenas define os seus métodos e atributos.

Abaixo temos um exemplo que mostra a criação da superclasse Mamífero e de três subclasses: Homem,
Cão e Gato. Usando o conceito de herança, o método Comunicar (originário da classe Mamífero) é herdado
pelas subclasses; e através do conceito de polimorfismo, esse método é redefinido facilmente para as
subclasses, (falar para o homens, latir para os cães e miar para os gatos) mostrando o quanto se ganha em
produtividade na criação de sistemas com a reutilização de código (vide Figura 1).
O exemplo criado foi idealizado com a necessidade de se projetar um conjunto de classes de fácil
entendimento e que permitisse o uso dos conceitos de herança e polimorfismo, sendo este exemplo tirado
do mundo real, originando a classe Mamífero. Primeiramente buscou-se identificar elementos em comum às
classes Homem, Cão e Gato, para que estes fossem adicionados à classe Mamífero, que passou a ser a
superclasse do exemplo.

8
public abstract class OperacaoMatematica
{
public abstract double calcular(double x, double y);
}

____________________________________________________________

public class Contas

{
public static void MostrarCalculo
(OperacaoMatematica operacao, double x, double y)
{
System.out.println("O resultado é: " + operacao.calcular(x, y));
}
public static void main(String args[])
{
//Primeiro calculamos uma soma
Contas.MostrarCalculo(new Soma(), 5, 5);
//Imprime o resultado é: 10
Contas.MostrarCalculo(new Subtracao(), 5, 5);
//Imprime o resultado é: 0
}
}

____________________________________________________________

9
public class Soma extends OperacaoMatematica
{
public double calcular(double x, double y)
{
return x+y;
}
}

10
INTRODUÇÃO AO JAVA

O QUE É JAVA?

Java é uma linguagem de programação orientada a objetos desenvolvida pela Sun Microsystems. Modelada
depois de C++, a linguagem Java foi projetada para ser pequena simples e portável a todas as plataformas
e sistemas operacionais, tanto o código fonte como os binários. Esta portabilidade é obtida pelo fato da
linguagem ser interpretada, ou seja, o compilador gera um c ó digo independente de m á quina chamado
byte-code. No momento da execução este byte-code é interpretado por uma máquina virtual instalado na
máquina. Para portar Java para uma arquitetura específica, basta instalar a máquina virtual (interpretador).
Além de ser integrada à Internet, Java também é uma excelente linguagem para desenvolvimento de
aplicações em geral. Dá suporte ao desenvolvimento de software em larga escala.

CRIANDO UMA APLICAÇÃO

Para começar, criaremos uma simples aplicação em Java: a clássica “Hello World!”, o exemplo que todos os
livros de linguagens usam.

O CÓDIGO FONTE

Como todas as linguagens de programação, o código fonte será criado em um editor de texto ASCII puro.
No Windows, notepad ou dosedit também servem.

A seguir, o código da aplicação “Hello World!” (arquivo: HelloWorld.java):

class HelloWorld
{
public static void main (String args[])
{
System.out.println(“Hello World!”);
}
}

COMPILANDO A APLICAÇÃO

Para compilar a aplicação, basta digitar o comando no prompt do DOS: javac HelloWorld.java
Este comando vai gerar o arquivo HelloWorld.class, que é o byte-code da aplicação.
Para executar o byte-code basta digitar java HelloWorld

11
INFORMAÇÕES BÁSICAS

VARIÁVEIS E TIPOS DE DADOS

Variáveis são alocações de memória nas quais podemos guardar dados. Elas têm um nome, tipo e valor.
Toda vez que necessite usar de uma variável você precisa declará-la e só então poderá atribuir valores a
mesma.

DECLARANDO VARIÁVEIS

As declarações de variáveis consistem de um tipo e um nome de variável: como segue o exemplo:

int idade;
String nome;
boolean existe;

Os nomes de variáveis podem começar com uma letra, um sublinhado ( _ ), ou um cifrão ($). Elas não
podem começar com um número. Depois do primeiro caractere pode-se colocar qualquer letra ou número.

TIPOS DE VARIÁVEIS

Toda variável deve possuir um tipo. Os tipos que uma variável pode assumir uma das três “coisas” a seguir:

 Uma das oito primitivas básicas de tipos de dados

 O nome de uma classe ou interface
 Um Array

Veremos sobre o uso de arrays e classes mais a frente.

Os tipos de dados básicos são:

 Inteiros
 Números de ponto-flutuante
 Caracteres
 Booleanos (verdadeiro ou falso)

12
JAVA

CONHECENDO O AMBIENT E

O usuário deve instalar o JDK apropriado para o seu ambiente computacional. A última versão homologada
encontra-se em: www.java.sun.com/downloads
Deve-se ainda, configurar as variáveis de ambiente:
 Colocar o c:\j2sdk1.4.2_06\bin no Path
 Colocar o diretório corrente “.” no CLASSPATH

FUNCIONAMENTO

A MÁQUINA VIRTUAL JAVA (JVM)

É uma máquina imaginária que é implementada pela emulação de um software sobre uma máquina real.
Sua função é prover uma especificação de plataforma de hardware no qual todos os códigos Java são
compilados. Essa especificação faz com que os programas Java sejam independentes da plataforma do
usuário do sistema, porque toda compilação é feita para uma máquina virtual.

13
A PLATAFORMA JAVA

PRIMEIRO PROGRAMA: T ESTE.JAVA

COMPILANDO E EXECUTANDO

Crie o arquivo acima em um diretório qualquer e salve com o nome: teste.java

Chame o compilador Java para este arquivo usando o MS DOS: C:\> javac teste.Java
Seu diretório deve ter recebido um novo arquivo após essa compilação: teste.class
Chame o interpretador Java para este arquivo (omita a extensão .class de arquivo): java teste
Observe o resultado na tela: Meu primeiro teste!

ENTENDENDO A NOMENCLATURA DO JAVA

14
class é a palavra reservada que marca o início da declaração de uma classe.
public é um especificador, por enquanto guarde public class como o início da declaração de uma classe.
Toda classes serão declaradas assim por enquanto.
teste é o nome dado a esta classe.
O “abre chaves” marca o início das declarações da classe que são os atributos e métodos. Esta classe só
possui uma declaração, a do método main. Note que um método só pode ser declarado {internamente} a
classe a qual pertence.
Desta forma, todo pedaço de código em Java deve pertencer ao abre chaves, fecha chaves da definição de
uma classe.

Já o seguinte trecho do programa:

public static void main (String args[])

{
System.out.println(“Meu primeiro teste!");
}

public é um qualificador do método que indica que este é acessível externamente a esta classe (para
outras classes que eventualmente seriam criadas), não se preocupe com ele agora, apenas declare todos
os métodos como public

static é outro qualificador ou “specifier”, que indica que o método deve ser compartilhado por todos os
objetos que são criados a partir desta classe.
Os métodos static podem ser invocados, mesmo quando não foi criado nenhum objeto para a classe. Para
tal deve-se seguir a sintaxe:

<NomeClasse>.<NomeMetodoStatic>(argumentos);

Retornaremos a esta explicação mais tarde, por hora você precisa saber que o método main precisa ter
essa qualificação porque ele é chamado sem que se crie nenhum objeto de sua classe (a classe teste).

void é semelhante ao void C++ ou C. É o valor de retorno da função, quando a função não retorna nenhum
valor ela retorna void, uma espécie de valor vazio que tem que ser especificado.

main é um nome particular de método que indica para o compilador o início do programa. É dentro deste
método e através das iterações entre os atributos, variáveis e argumentos visíveis nele que o programa se
desenvolve.

(String args[]) é o argumento do método main e por conseqüência do programa todo, ele é um array de
Strings que é formado quando são passados ou não argumentos através da invocação do nome do
programa na linha de comando do sistema operacional, exemplo:

15
C:\>java teste cadela falecida saudades
args[0]=cadela
args[1]=falecida
args[2]=saudades

{ ... } “Abre chaves” e “fecha chaves”. Para quem não conhece C ou C++, eles podem ser entendidos como
algo semelhante ao BEGIN END de Pascal, ou seja: delimitam um bloco de código.

System.out.println("Meu primeiro teste!"); chamada do método println para o atributo out da classe
System, o argumento é uma constante do tipo String para imprimir a cadeia “Meu primeiro teste!” e
posicionar o cursor na linha abaixo.
Por hora guardem esta linha de código como o comando para imprimir mensagens na tela, onde o
argumento que vem entre aspas é a String a ser impressa.

EXERCÍCIOS

1) Escreva o mesmo exemplo do teste.java utilizando recursos gráficos do Swing. Para tal inclua no início
a instrução:
import javax.swing.JOptionPane;
E no lugar do System.out escreva a seguinte instrução:
JOptionPane.showMessageDialog(null, “Meu Primeiro teste!” );

RESOLUÇÃO 1:

2) Escreva uma classe ebico.java que receba da linha de comando dois parâmetros uma String com o
nome da pessoa e um int com a idade da pessoa.
Mostre na saída padrão com System.out ou JOptionPane a frase “Bom dia ”+args[0]+” você tem
“+args[1]+” anos de idade”);

16
RESOLUÇÃO 2:

CONVENÇÕES

Abaixo temos algumas convenções que são usadas a fim de padronizar o desenvolvimento em Java e evitar
qualquer tipo de problema:
 Variáveis e métodos iniciam com letras minúsculas.
 Classes iniciam com letras maiúsculas
 Nome composto: utilizar letras maiúsculas para as iniciais das palavras que seguem a primeira
 Letras maiúsculas para as constantes

COMENTÁRIOS

Há três formas de inserir comentários:

// comentários em uma linha
/* comentários em uma ou mais linhas */
/** documentando comentários */
Quando colocado imediatamente antes da declaração (de uma função ou variável), indica que o comentário
poderá ser incluído automaticamente em uma página html (gerado pelo comando javadoc).

PONTO-E-VÍRGULA, BLOCOS E ESPAÇOS EM BRANCO

 Os comandos sempre são terminados com ponto-e-vírgula.

 Um bloco é delimitado por chaves { e } e constitui um comando composto.
 O espaço em branco é permitido entre elementos do código fonte, em qualquer lugar e em qualquer
quantidade. São considerados espaço em branco o espaço, o tab (\t) e mudança de linha (\n).

17
 {
int x;
x = 23 * 54;
}

IDENTIFICADORES

O identificador começa com uma letra, hífen-caixa-baixa (_), ou símbolo dólar ($). Os subsequentes
caracteres podem conter dígitos. Caracteres maiúsculo e minúsculo são diferentes e não tem tamanho
máximo.
Identificadores válidos:
 identifier
 userName
 User_name
 userName
 _sys_var1
 $change

Utilizar somente caracteres ASCII (porque o Unicode pode suportar caracteres diferentes com a mesma
representação), não utilizar palavra reservada e evitar nome iniciados com $ (por causa das variáveis de
ambiente do Sistema Operacional).

PALAVRAS RESERVADAS

Abaixo temos uma tabela com as palavras reservadas, ou seja, palavras usadas exclusivamente pela
linguagem de programação e que não podem ser usadas para nomear variáveis, constantes, classes, etc.:

abstract do implements
boolean double import
break else instanceof
byte extends int
case f alse interf ace
catch f inal long
char f inally native
class f loat new
continue this f or
def ault if package

18
Nota: atualmente as seguintes palavras reservadas não são utilizadas: cast, const, future, generic, goto,
inner, operator, outer, rest, var.

VARIÁVEIS

Tipo Primitivo Tamanho Wrapper

Boolean 1-bit Boolean
char 16-bit Character
byte 8-bit Byte
short 16-bit Short
int 32-bit Integer
long 64-bit Long
float 32-bit Float
double 64-bit Double
void – Void

DECLARAÇÃO DE VARIÁVEIS E CONSTANTES

int x, y; // declarando variáveis inteiras

x = 6; y=1000; // atribuindo valores a variável
float z = 3.414f; // ponto flutuante
double w = 3.1415; // declarando e atribuindo double
boolean truth = true; // booleano
char c; // declarando variável caracter
c = ‘A’; // atribuindo um valor char
final int MAX = 2; // Constantes
final int CONSTANTE; CONSTANTE = 1; // somente admite uma atribuição

OPERADORES

OPERADORES ARITMÉTICOS

Operador Uso Descrição

+ op1 + op2
- op1 - op2
* op1 * op2
/ op1 / op2
% op1 % op2
Retorna a soma de op1 e op2.
Retorna a subtração de op1 por op2.
Retorna a multiplicação de op1 por op2.
Retorna a divisão de op1 por op2.
Retorna o resto da divisão de op1 por op2.

19
Operador Uso Descrição
+ +op Promove op para int, se for byte, short ou char.
- -op Retorna op aritmeticamente negado.
++ op++ Retorna o valor de op, depois o incrementa de 1.
++ ++op Incrementa op de 1,depois retorna o valor.
-- op-- Retorna o valor de op, depois o decrementa de 1.
-- --op Decrementa op de 1,depois retorna o valor.

OPERADORES RELACIONAIS

Operador Uso Retorna verdadeiro se

> op1 > op2 op1 for maior que op2.
>= op1 >= op2 op1 for maior que ou igual ao op2.
< op1 < op2 op1 for menor que op2.
<= op1 <= op2 op1 for menor que ou igual ao op2.
== op1 == op2 op1 igual ao op2.
!= op1 != op2 op1 diferente do op2.

OPERADORES LÓGICOS

Operador Uso Retorna verdadeiro se

&& op1 && op2 op1 e op2 forem true. Só avalia op2, se op1 for true.
|| op1 || op2 op1 ou op2 for true (ou ambos).Só avalia op2, se op1 for false.
! ! op op for false.
& op1 & op2 op1 e op2 forem true. Sempre avalia op1 e op2.
| op1 | op2 op1 ou op2 for true (ou ambos). Sempre avalia op1 e op2.
!= op1 != op2 op1 diferente do op2.

CONTROLE DE FLUXO

Categoria Comando
Decisão if-else, switch-case
Loop for, while, do-while
Diversos break, continue, label:, return

20
CONTROLE DE FLUXO - IF

if (expressão booleana)
comando ou bloco
else
comando ou bloco

Exemplo:

CONTROLE DE FLUXO - W HILE

while (expressão booleana)

comando ou bloco
do
comando ou bloco
while(expressão booleana);

Exemplo while:

21
Exemplo do-while:

CONTROLE DE FLUXO - FOR

for (expressão inicial; expressão booleana; expressão de iteração)

comando ou bloco
expressão inicial;
while (expressão booleana)
{
comando ou bloco
expressão de iteração;
}
22
Exemplo:

CONTROLE DE FLUXO - SW ITCH

switch (expressão1)
{
case expressão2:
comando ou bloco
break;
...
case expressão n:
comando ou bloco
break;
default:
comando ou bloco
break;
}

Exemplo:

23
EXERCÍCIO

3) Crie uma classe java com o nome “ValorChar” que mostre na tela os chars correspondentes aos
números de 32 a 150.
 Dica para resolução: utilize a seguinte notação para transformar um int em char (por enquanto não
se preocupe com o significado desta notação): (char) valorInteiro
 Lembrete: convertendo um int (32 bits) para um char (16 bits) você terá perda caso o valor do int
supere o limite do char (65545).

RESOLUÇÃO:

24
25
MÉTODOS ACESSORES: GET E SET

Como visto anteriormente, o encapsulamento "protege" os atributos ou métodos dentro de uma classe,
portanto devemos prover meios para acessar tais membros quando eles são particulares, ou seja, quando
possuem o modificador private. O que torna isso possível é a criação de métodos.
Em programação orientada a objetos, esses métodos são chamados de métodos acessores ou getters e
setters, pois eles provêm acesso aos atributos da classe, e geralmente, se iniciam com get ou set, daí a
origem de seu nome.
Na verdade, não há nada de diferente entre os métodos comuns e os métodos acessores. A única
importância está no fato da orientação a objeto. Pois, sempre que formos acessar um membro em Java
usaremos get ou set.

SET

Nomeamos um método acessor com set toda vez que este método for modificar algum campo ou atributo
de uma classe, ou seja, se não criarmos um método acessor set para algum atributo, isso quer dizer que
este atributo não deve ser modificado.
Portanto, como o valor de um atributo da classe será modificado, não é necessário que este método retorne
nenhum valor, por isso, os métodos setters são void. Porém, obrigatoriamente, eles tem que receber um
argumento que será o novo valor do campo.

GET

Nomeamos um método acessor com get toda vez que este método for verificar algum campo ou atributo de
uma classe.
Como este método irá verificar um valor, ele sempre terá um retorno como String, int, float, etc. Mas não
terá nenhum argumento.

IS

Nomeamos um método acessor com is toda vez que este método for verificar algum campo ou atributo de
uma classe que tenha retorno do tipo boolean.

Levando em consideração as informações acima, vamos criar uma classe de exemplo TV:

26
27
ARRAYS E DIÁLOGOS

ARRAYS

Assim como na maioria das linguagens modernas (C, Pascal, etc.), os arrays em Java são estruturas de
dados que armazenam diversas "coisas" do mesmo tipo. Essas coisas podem ser tipos primitivos (int, char,
etc.) ou objetos.
A declaração de um array em Java é realizada da seguinte maneira:

int valores[] = new int[20];

No exemplo acima, será criado um array com 20 posições, numeradas de 0 a 19. Cada posição pode ser
acessada individualmente, utilizando o operador [ ].
É possível também inicializar automaticamente um array com valores determinados:

int valores[] = { 1, 2, 4, 8, 16, 32, 64, 128 };

Este tipo de inicialização também funciona para Strings:

String nomes[] = { "Ana", "Carlos", "Felipe", "Pedro" };

Observe que uma vez inicializado, o tamanho de um array não pode ser alterado!
Arrays são inteligentes: sabem seu tamanho. Isso é fundamental, pois é essencial haver uma maneira de
descobrir o espaço solicitado para o array:

Int TAM_array = nomes.length;

A linguagem Java oferece diversas formas de interação com o usuário, a grande maioria em janelas. Para
evitar a criação de uma interface completa, pode-se utilizar as chamadas caixas de diálogo.
Se olharmos com atenção na documentação da API, observaremos que as classes estão agrupadas em
pacotes (packages). Os pacotes servem para reunir um conjunto de classes com função semelhante. Então,
se quisermos utilizar uma classe específica, devemos informar ao compilador Java onde (em qual pacote)
essa classe deve ser encontrada.

28
A classe que implementa as caixas de diálogo, JOptionPane, se encontra no pacote javax.swing, que
contém diversas outras classes para interface com o usuário. Para utilizar essa classe, utiliza-se o comando
import:

import javax.swing.JOptionPane;

Observação: algumas classes como String, System, Integer e outras são parte de um pacote especial,
denominado java.lang. Esse pacote nunca precisa ser importado, pois são as classes primitivas que
compõem a linguagem Java.
A classe JOptionPane oferece diversos métodos, para criar diversos tipos de caixas de diálogo. Por
exemplo, se quisermos exibir uma caixa de mensagem para informar o usuário, usamos o método
showMessageDialog(...):

O primeiro parâmetro por enquanto deve ser null. Repare que o método showMessageDialog(...) é um
método estático (de classe) de JOptionPane! Por esse motivo, não é necessário instanciar objetos a partir
de JOptionPane. Observe também a chamada para o método System.exit(0): este método é geralmente
utilizado para encerrar um programa que utilize interface gráfica.

Há outra forma de chamada para o método showMessageDialog, a qual permite melhorarmos o visual da
caixa de mensagem:

29
O terceiro parâmetro é o título que será exibido na janela (ao invés de "Message") e o quarto parâmetro
controla o ícone apresentado à esquerda da janela:
 JOptionPane.PLAIN_MESSAGE - nenhum ícone

 JOptionPane.ERROR_MESSAGE - ícone de erro

 JOptionPane.INFORMATION_MESSAGE - ícone de informação

 JOptionPane.WARNING_MESSAGE - ícone de aviso

 JOptionPane.QUESTION_MESSAGE - ícone de interrogação

Existe um método para exibir uma caixa de entrada: showInputDialog. Esse método retorna sempre a String
que foi digitada pelo usuário. Exemplo:

Assim como no método showMessageDialog, há uma variação mais completa:

30
Se você estiver curioso, consulte a documentação da API Java. Há MUITAS outras variações, tanto para
entrada como para saída.
Você deve estar se perguntando: mas eu vou fazer programas baseados somente em caixas de diálogo ?
Isso não é meio chato para o usuário? Sim, com certeza! A interação baseada em diálogos é útil quando
queremos informar o usuário de uma situação urgente ou quando se deseja chamar a atenção, mas não
deve ser utilizada excessivamente.
Normalmente o que temos é uma interface gráfica o tempo todo na tela, na forma de uma ou mais janelas
com diversos componentes, como botões, listas, etc. Como ainda é cedo para fazermos isso, está
disponível uma classe para exibição de mensagens na tela, denominada JanelaBasica. Esta classe
apresenta simplesmente uma janela onde existe uma área de texto, com o objetivo de substituir o console.
Para utilizá-la, primeiramente copie o arquivo JanelaBasica.java para o diretório onde estão as classes do
seu projeto atual. Se você quiser olhar este arquivo, fique à vontade. Note que não serão dadas explicações
sobre o conteúdo deste arquivo, pelo menos por enquanto. Coisas da vida, mas é para o bem de vocês.
A utilização é extremamente simples: crie uma instância de JanelaBasica, utilizando o seguinte construtor:

O primeiro parâmetro é o título da janela que será exibida. A classe oferece dois métodos para a exibição de
mensagens: print(...) e println(...), cujas utilizações são óbvias...
Exemplo: criaremos um programa muito útil para somar dois números. A entrada de dados será realizada
através de caixas de diálogo.

31
32
O aluno(a) mais atento(a) irá notar o desaparecimento da chamada System.exit(0). Há um bom motivo:
como estamos utilizando uma janela gráfica não modal, isto é, que permanece o tempo todo na tela, a única

33
forma de encerrar o programa é fechando-se a janela. Se houvesse a chamada para exit(0) no final do
programa, não seria possível enxergar a resposta a tempo.

34
CONT AINERS

A maioria das aplicações gráficas do mundo têm, em algum momento, algum formulário para entrada de
dados. Vamos criar então um formulário bem simples utilizando Swing.
A API do Swing traz uma série de componentes visuais prontos para uso. São campos de texto, botões,
checkboxes, labels, tabelas, árvores e muitos outros. Para começar nosso formulário iremos usar dois
componentes: um campo de texto (JTextField) e uma etiqueta/label (JLabel):

// O JLabel recebe o texto a ser exibido

JLabel label = new JLabel("Seu nome:");

// O JTextField recebe o tamanho do campo

JTextField textField = new JTextField(20);

Todo componente Swing deve ser adicionado a um contêiner (Container) que administrará o agrupamento e
exibição dos mesmos. Usaremos o container mais comum, um Jpanel (algo como um painel de
componentes). Através de seu método add conseguimos adicionar nossos componentes:

// Cria um JPanel (container)

JPanel panel = new JPanel();

// adiciona os componentes
panel.add(label);
panel.add(textField);

Por último, para exibirmos nosso formulário simples, precisamos colocar nosso Jpanel em uma janela.
Usaremos a classe JFrame, que representa uma janela simples.

// Criamos um JFrame passando o título da janela

JFrame frame = new JFrame("Meu primeiro formulário");

// Adicionamos nosso JPanel

frame.add(panel);

35
 // Preparamos o JFrame para exibição
frame.pack();
frame.setVisible(true);

O método pack() de JFrame, chamado acima, serve para redimensionar nosso frame para um tamanho
adequado baseado nos componentes que ele tem. E o setVisible recebe um boolean indicando se
queremos que a janela seja visível ou não.
Vamos apenas adicionar um último comando que indica ao nosso frame que a aplicação deve ser terminada
quando o usuário fechar a janela.

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

No exemplo completo abaixo, colocamos todas as variáveis como atributos e criamos um método chamado
montaFormulario com todo o código explicado antes. No método main, criamos um novo Formulário e
chamamos o método montaFormulario():

36
Ao rodar este programa, teremos a seguinte tela para digitação do nome:

O formulário anterior até que é interessante para começar a aprender Swing, mas ele é totalmente inútil,
não faz nada. Queremos ser capazes de recuperar o valor digitado pelo usuário para efetuar alguma
operação (salvar no banco de dados, exibir, enviar via rede, mandar um email etc.).
Para fazermos efetivamente alguma coisa, trabalhamos com eventos que são disparados pelo usuário. O
Swing possui uma forma muito elegante de trabalhar com eventos (através de interfaces). O usuário pode
disparar eventos ao digitar, ao clicar, ao passar o mouse e muitas outras situações.
No nosso formulário, usaremos um botão (componente) que, quando clicado pelo usuário (evento),
disparará um método (tratador/handler). Neste método, vamos recuperar o texto digitado pelo usuário e
efetuar alguma ação.
O componente Swing que representa um botão é o Jbutton. Precisamos criar um botão e colocá-lo no nosso
container (o JPanel):

// cria o JButton passando o texto do botão

JButton button = new JButton("Exibir");
// adiciona o botão ao JPanel
panel.add(button);

Isso acrescentará o botão ao formulário, mas como disparar um método quando o botão for clicado? O
Swing nos traz o conceito de Listeners (ouvintes), que são interfaces que implementamos com métodos
para serem disparados por eventos.
No nosso caso, para fazer um método disparar ao clique do botão, usamos a interface ActionListener. Essa
interface nos dá um método actionPerformed:

public void actionPerformed(ActionEvent e)

{
// implementação aqui...
}

Vamos fazer então nossa própria classe formulário implementar essa interface e esse método. Queremos,
quando o botão for clicado, pegar o texto digitado pelo usuário e exibir na tela (vamos usar o JOptionPane
para isso). Nosso método actionPerformed fica desta forma:

37
 public void actionPerformed(ActionEvent e)
{
// pega o texto do JTextField
String texto = textField.getText();

// exibe usando o JOptionPane

JOptionPane.showMessageDialog(frame, texto);

// aqui usamos o frame como componente pai do messageDialog

}

O último detalhe que falta é indicar que essa ação (esse ActionListener) deve ser disparado quando o botão
for clicado. Fazemos isso através do método addActionListener chamado no botão. Ele recebe como
argumento um objeto que implementa ActionListener (no nosso caso, o próprio Formulário, o this):

button.addActionListener(this);

O código final de nosso formulário deve estar assim:

38
Ao rodar esse programa, você verá nosso formulário com um label, um campo de texto e um botão. Depois
de digitar algo, ao clicar no botão, você verá uma mensagem com o texto do campo de texto:

39
GERENCIADORES DE LAYOUT

Quando adicionamos novos componentes, como o Java sabe onde posicioná-los?

Porque sempre são adicionados do lado direito? Se redimensionarmos a tela (teste) os elementos “fluem”
para a linha de baixo, por quê?
Essas e outras perguntas são respondidas pelo Layout Manager, o gerenciador de layout do Swing. O Java
vem com uma série de Layouts diferentes, que determinam como os elementos serão dispostos na tela,
seus tamanhos preferenciais, como eles se comportarão quando a janela for redimensionada e muitos
outros aspectos.
Ao escrever uma aplicação Swing você deve indicar qual o Layout Manager que deseja utilizar. Por padrão,
é utilizado o FlowLayout que especifica justamente que os elementos devem ser justapostos, que eles
devem “fluir” um para baixo do outro quando a tela for redimensionada e etc.
Poderíamos usar outro Layout Manager como o GridLayout, por exemplo. Nossa aplicação ficaria da
seguinte forma:

Note como os elementos parecem estar dispostos em uma grade (um grid). Ao redimensionar essa tela, por
exemplo, os elementos não fluem como antes; eles são redimensionados para se adaptarem ao novo
tamanho do grid.
Ou ainda, usando o BoxLayout pelo eixo y:

Há uma série de Layout Managers disponíveis no Java, cada um com seu comportamento específico. Há
inclusive Layout Managers de terceiros (não oficiais do Java) que você pode baixar; o projeto Jgoodies, por
exemplo, tem um excelente Layout Manager otimizado para trabalhar com formulários, o FormLayout.

Para saber mais sobre Layout Managers, quais são e como usar cada um deles, consulte a documentação
do Swing.

40
LOOK AND FEEL

Look-and-Feel (ou LaF) é o nome que se dá à “cara” da aplicação (suas cores, formatos e etc.). Por
padrão, o Java vem com um lookandfeel próprio que se comporta exatamente da mesma forma em todas as
plataformas suportadas.
Mas às vezes esse não é o resultado desejado. Quando rodamos nossa aplicação no Windows, por
exemplo, é bastante gritante a diferença em relação ao visual das aplicações nativas. Por isso é possível
alterar qual o lookandfeel
a ser usado em nossa aplicação.
Além do padrão do Java, o JRE 5 da Sun ainda traz LaF nativos para Windows e Mac OS, além do Motif e
GTK. E, fora esses, você ainda pode baixar diversos LaF na Internet ou até desenvolver o seu próprio.
Veja esses screenshots da documentação do Swing mostrando a mesma aplicação rodando com 4 LaF
diferentes:

Para saber mais:

1) Consultar o javadoc do Swing pode não ser muito simples. Por isso a Sun disponibiliza um ótimo tutorial
online sobre Swing em seu Site:

http://java.sun.com/docs/books/tutorial/uiswing/

41
CRIANDO MENUS

42
43
JFORMATT EDTEXTFIELD

44
45
ESCOPO

Partindo dos conceitos aplicados sobre classes. Defina uma classe referente a um Funcionário.

Classe funcionário:

MODIFICADORES DE ACESSO

Há quatro diferentes tipos de modificadores de acesso:

 public
 private
 protected
46
  default

public, protected e private são escritos explicitamente na instrução para indicar o tipo de acesso.
default não deve ser escrito.

ACESSO PADRÃO (DEFAULT)

Especifica que os elementos da classe são acessíveis somente aos métodos internos da classe e às suas
subclasses.
Não há palavra-chave para o modificador default; sendo aplicado na ausência de um modificador de acesso

Exemplo:

ACESSO PÚBLICO (PUBLIC)

Especifica que os elementos da classe são acessíveis seja internamente e externamente à classe.
Qualquer objeto que interage com a classe pode ter acesso aos elementos públicos da classe.
Palavra-chave: public

Exemplo:

ACESSO PROTEGIDO (PROTECTED)

Especifica que somente classes no mesmo pacote podem ter acesso aos atributos e métodos da classe.
Palavra-chave: protected

47
Exemplo:

ACESSO PARTICULAR (PRIVATE)

Especifica que os elementos da classe são acessíveis apenas pela classe que os definiram.
Palavra-chave: private

Exemplo:

RELEMBRANDO:

Encapsulamento: Na OO, encapsulamento é o mecanismo utilizado para disponibilizar métodos que

operam sobre os dados e que protegem o acesso direto indevido aos atributos de uma instância fora da
classe onde estes foram declarados.
Esta proteção consiste em se usar modificadores de acesso mais restritivos sobre os atributos definidos na
classe e fornecendo métodos que alteram os valores destes atributos de alguma forma.
O encapsulamento ajuda a prevenir o problema de interferência externa indevida sobre os dados de um
objeto, como objetos que possam alterar os dados de outros objetos indevidamente.

Métodos de acesso (get): Métodos de acesso são usados para ler valores de atributos de objeto ou de
classe.
O método de acesso recebe o nome de get<NomeDoAtributo> e retorna um valor.

48
Métodos modificadores (set): Para que outros objetos possam modificar os nossos dados,
disponibilizamos métodos que possam gravar ou modificar os valores dos atributos de objeto ou de classe.
Chamamos a estes métodos modificadores. Este método é escrito como:
set<NomeDoAtributoDeObjeto>.

49
CHECKBOX

50
POLIMORFISMO

51
FORMATTEDSAMPLE

52
GRID

53
NETBEANS

O Netbeans é um ambiente integrado de desenvolvimento (IDE) que permite ao programador criar

programas utilizando recursos gráficos.
Para trabalhar com o NetBeans é necessário ter instalado, anteriormente em sua máquina uma das versões
do JDK (Java), preferencialmente uma versão igual ou superior a J2SDK1.3.1.

INSTALANDO O NETBEANS

No site http://java.sun.com/ , faça também o download do NetBeans, caso não tenha um CD de instalação.
Após o download, dê um duplo clique no ícone criado e siga os passos mantendo os padrões de instalação.
Segue como exemplo algumas ilustrações da instalação da versão 3.5.1, a versão 4.0 segue o mesmo
padrão:

54
55
CONHECENDO A IDE

Depois de instalado, execute o NetBeans clicando no ícone na área de trabalho ou clicando no menu iniciar
Programas NetBeans NetBeans.
O mesmo deverá exibir uma tela como a mostrada a seguir ou algo parecido, isto vai depender do tipo da
instalação/ SO/ Número de vezes que o mesmo já tenha sido executado:

CRIANDO UMA APLICAÇÃO MDI:

Composta de:
 Um Formulário principal
 Um Menu
Passos:
1º - Clique no menu File New: será exibida uma tela como esta:

56
2º - Dê um duplo clique em Java GUI Forms ou clique na respectiva Lupa:
3º - Selecione Sample Form MDI Aplication com isto criaremos uma aplicação composta de um formulário
com um menu e que aceita a abertura de outros formulários
4º - Clique no botão NEXT:

57
5º - Dê um nome para o seu Aplicativo e no Campo Folder entre com um nome que será a pasta onde a
aplicação ficará armazenada - Package. Clique no botão Create Next:

6º - Será mostrada uma tela informando o nome da Aplicação e o nome do Package criado, a superclasse
que será estendida e as classes a serem implementadas. Não mude as opções padrão, clique no botão
Next:

58
7º - Clique no botão Next:

59
8º - Clique no botão Next:

9º - Clique no botão Finish:

60
A IDE abrirá uma tela como a que se segue. O NetBeans trabalha com várias mini-telas com finalidades
especificas, todas de forma integradas a janela principal, a barra de menu.
 Caso queira aumentar ou diminuir a área de visualização de uma destas basta passar o mouse e
redimensioná-las de acordo com a necessidade do programa.
 Para visualizar uma destas janelas clique no Menu View e selecione a Janela desejada. Ex: Source
Editor ou Form Editor

10º - Feche a Janela Explorer (File System) clique no X, para aumentar a área do formulário de Trabalho.

61
COMPONENTES DA JANELA EM MODO DE TRABALHO

Compilando: Clique no Menu Build Compile ou Pressione F9

Executando: Clique no Menu Build Execute ou Pressione F6

Na execução da aplicação o formulário / janela abre exibindo apenas o menu, isto porque não tem nenhum
componente, verifique o menu sair, observe que o mesmo já foi implementado pelo NetBeans. Agora vamos

62
inserir alguns componentes, procure deixar a sua aplicação parecida com a seguinte Tela no modo
formulário. (Lembre-se que é possível alternar entre as telas de código e formulário clicando no menu View
e selecione Form Editor/Source Editor):

TRABALHANDO COM COMPONENTES

Na janela no canto superior direito, que mostra os componentes da aplicação, clique o Botão direito do
mouse sobre BorderLayout e selecione Set Layout AbsolutLayout
Esta mesma operação pode ser efetuada clicando-se com o botão direito do mouse sobre a área do
Formulário e selecionando SetLayout AbsolutLayout.
É necessário modificar o Layout para que se possa colocar os componentes (botões, Labels, etc.) na
posição desejada, isto porque o Formulário (JFrame/Frame) quando é criado tem como padrão o Layout
BorderLayout que trabalha de forma diferente. Mais a frente será abordado de uma forma melhor sobre os
Layout.

63
Passe o mouse sobre os componentes da Aba Swing e observe que os mesmos são selecionados, clique
no correspondente ao JLabel e clique no Formulário:

Na Janela Propriedades clique em Text e insira o texto que deseja que apareça no JLabel

Insira outros componentes e mude suas propriedades realizando experiências, compilando e executando,
para visualizar os resultados

64
TELAS DO NETBEANS – VERSÃO 4

Tela de Inicialização/Abertura

Criando uma Aplicação: - primeiro é necessário criar um projeto

65
Selecione General Java Application Next

Em Project digite o nome Desejado

66
Criando um Programa: File  New File  Java GUI Form  JFrame  Next

67
Na nova janela que se abre digite o nome do Programa e clique no Botão Finish.
Insira os componentes desejados.

68
Compile e Execute: Menu “Build”  Compile
Para executar Menu “Run”  Run Other

69
APLICAÇÕES GRÁFICAS COM SW ING

Nova família de componentes com funcionalidade ampliada e grande capacidade de configuração.

O seu propósito é permitir a criação de interfaces versáteis e sofisticadas. Surgiu em 1997 com a JFC ( Java
Foundation Classes), com o Java 2, que engloba:
 Componentes Swing
 Compatibilidade com múltiplas “Look and Feel”
 Biblioteca de acessibilidade monitores e teclados especiais
 Biblioteca Java 2D
 Compatibilidade com “Drag and Drop”

70
Principais componentes:

 Os seus componentes são semelhantes ao da AWT (Abstract Window Toolkit), pois o modelo de
eventos é o mesmo.
 Diferenças: Componentes Swing são mais flexíveis e mais numerosos
 Não utilizam código nativo, seus nomes iniciam com um J
 A base para uma aplicação é o JFrame ou JWindow ( janela) ou a classe JApplet (miniapplicativos).
 JFrame não é um mero container, mas um painel especial que agrega três outros componentes em
camadas
 Destes o que nos interessa é o ContentPane (painel de conteúdo), onde vamos inserir os demais
componentes:
Container conteudo= getContePane();

JLabel: rótulo de texto.

Métodos específicos:

String getText()  retorna o texto do label

void setText(String lbl)  ajusta o texto do label para lbl

JButton: é um botão simples que pode ser criado com ou sem rótulo.
Métodos específicos:

String getText()  retorna o label(etiqueta) do botão

void setText(String etiq)  ajusta label do botão para o conteúdo de etiqueta

JTexField e JTextArea
TextField: caixa de entrada de texto, possibilita a entrada e a edição de uma linha de texto.
TextArea: caixa de entrada de texto com múltiplas linhas. Exibe barra de rolagem horizontal e vertical.
Principais métodos:

71
 String getText()  retorna o texto contido no TextField
void setText(String txt)  ajusta o texto da TextField para txt

JList e JCombobox
JList: caixa de lista que permite a exibição de uma lista de itens que não podem ser editados diretamente
pelo usuário.
JCombobox: implementa uma lista de itens em que um único item selecionado é exibido.
Principais métodos:

int getSelectedIndex();  retorna índice do item selecionado

String getSelectedItem();  retorna o nome do item selecionado
void select(String str);  ajusta o item selecionado para str

Métodos comuns a todos os componentes:

 void resize(int width, int height)  Tamanho do componente

 void move(int x, int y)  Mover componente
 void setForeground(Color x)  Cor do componente
 void setBackground(Color y)  Cor de Fundo do componente
 void disable()  Desabilitando componente
 void enable()  Habilitando componente

GERENCIADORES DE LAYOUT

Gerenciamento de layout ( Layout Management ) é o processo de determinar o tamanho e a posição dos

componentes na janela gráfica do programa, ou seja determinar onde os componentes irá ficar guiando a
maneira como os elementos de interface serão dispostos dentro do container (Frame, Panel,Window).
Existem basicamente os seguintes tipos de layout:
a) FlowLayout
b) BorderLayout
c) CardLayout
d) GridLayout
e) GridBagLayout

A escolha do gerenciador de layout depende muito das necessidades do programa.

72
a) FlowLayout: Simplesmente posiciona os componentes da esquerda para a direita, criando novas linhas
se necessário.

b) BorderLayout: É o Padrão: Divide a janela em cinco áreas nas quais os componentes podem ser
exibidos: norte, sul, leste, oeste e centro.

c) CardLayout: Permite apresentar dois ou mais componentes (geralmente painéis) compartilhando o

mesmo espaço de apresentação. Funciona como uma pilha de cartas onde apenas uma fica visível.
Cria-se um Painel fixo de Controle e um genérico (CardLayout) para conter outros painéis

d) GridLayout: Deixa todos os componentes com igual tamanho, exibindo-os como uma tabela (linhas e
colunas). EX: substitua a linha 9 do Programa Panel.java por: setLayout( new GridLayout(3,1));

73
e) GridBagLayout: É o mais flexível dos gerenciadores de layout, permite colocar componentes em grades
de colunas, sendo possível um componente ocupar mais de uma coluna ao mesmo tempo. As linhas
também não precisam necessariamente ter os mesmos tamanhos, ou seja, você pode configurar diferentes
larguras e alturas de acordo com a necessidade. No entanto, é o mais difícil de ser implementado.

APLICAÇÕES GRÁFICAS COM SW ING CONSTRUINDO APLICAÇÕES COM O NETBEANS

UTILIZANDO JLABEL, JTEXTFIELD E JBUTTON COM O NETBEANS

1. Crie uma aplicação para somar os valores de duas Notas Fiscais a serem informados pelo usuário:
 Nesta Aplicação utilizaremos dois JTextField (onde o usuário irá digitar os valores) um JLabel
(mostrar o resultado da soma) e um botão a ser clicado para efetuar a soma
 Abra o NetBeans  Clique no Menu File  New  Dê um Duplo clique em Java GUI Forms 
Selecione JFrame Form  Clique no Botão Next

 Na nova janela que se abre Digite JCalculadora"  Clique no Botão Finish - seu projeto será
iniciado

74
  Antes de inserir os componentes, devemos modificar o Layout para AbsoluteLayout ou para
NullLayout, para podemos criar o nosso Layout.

NOTA:
O AbsoluteLayout é um gerenciador de Layout criado especificamente para o NetBeans, portanto se
for utiliza-lo sem o NetBeans terá de acrescentar o respectivo pacote e distribuí-lo juntamente com o
seu programa. Caso contrário o mesmo não executará corretamente.
O Null Layout não é um gerenciador de Layout, mas corresponde à situação em é desativado uso dos
gerenciadores, neste caso a posição dos componentes é explicitamente definida através de métodos
específicos que a ferramenta se encarrega de manipular, mas os mesmo não vale para o Formulário
(Frame/JFrame), onde se faz necessário a utilização do método setBounds:
Ex: setBounds(10,10,300,400);
// abre o tela na posição largura 10, altura 10, com um largura de 300 e altura 400.

 Na janela, no canto superior direito, Clique com o botão direito do mouse sobre JFrame 
setLayout  clique em NullLayout

 Na janela do Centro do vídeo, embaixo da Aba Swing , existem vários ícones representando os
respectivos componentes, passe o mouse sobre os mesmos e aparecerá o nome, clique no
primeiro, JLabel", e clique no Form, Clique no segundo, JButton , e clique no Form, Clique no nono,
JTextField , e clique no Form (dois JTextField), insira mais dois JLabel e outro JtextField.
 Na janela Propriedade modifique as propriedades dos componentes de acordo com a tabela:

75
 A parte visual já foi criada precisamos implementar o código no botão para efetuar a soma ( pegar
os números e somá-los)
 Dê um Duplo clique no botão e na janela de código que aparece digite:

76
 Após digitar os comandos o arquivo de código deverá ficar da seguinte forma:

 Observe que os nomes dos componentes (jLabel3) começam com letras minúsculas.
 Parte do Código com a declaração dos componentes criados:

 A parte do Código que estiver na cor azul não aceita modificações.

 Se for utilizado o Layout AbsoluteLayout basta compilar e executar o programa para o mesmo
funcionar normalmente.
 Mas, como o Layout que está sendo utilizado é o Null Layout, quando o programa for executado a
janela aparecerá mostrando apenas a barra de titulo.
 Para a janela abrir e mostrar todos os componentes, devemos acrescentar o comando com a
localização e tamanho da janela (setBounds(posX,posY,Largura,Altura)), procure a seguinte linha
de código:

77
  Após initComponents(), insira o seguinte comando:
setBounds(10,10,300,400);

 Após o comando o arquivo de código ficará desta forma:

 Se precisar voltar para o modo Form Editor clique no Menu View  Form Editor ou Crt+8
 Para ir para o código clique no menu View  Source Editor ou Crt+3 .
 Compile Menu Build  Compile (F9), execute Menu Build  Execute (F5)

Criando uma Calculadora

Utilize o programa anterior e acrescente mais 4 (quatro) JButtons:

Dê um duplo clique no botão Diminuir e insira o seguinte código:

78
Repita o processo nos outros botões modificando apenas a operação matemática.
Dê um duplo clique no botão Limpar e digite:

Compile (F9) e execute (F6).

Para criar um arquivo que é executado diretamente pelo Windows basta criar um arquivo .Bat :
 Abra o Bloco de Notas e digite: java JCalculadora
 Salve com um nome qualquer e com a extensão Calculadora.Bat , na mesma pasta do programa:

79
OBS: Lembre-se que o Layout AbsoluteLayout é EXCLUSIVO do NetBeans, sendo que para utilizá-lo
efetivamente na sua aplicação, você deverá incluir no seu projeto o respectivo pacote, senão na execução
ocorrerá erros, ou modifique o Layout para Null Layout e defina o tamanho de seu Frame/JFrame para que
o mesmo possa ser visualizado no tamanho desejado (setBounds()), caso contrário o mesmo aparecerá
mostrando somente a barra de titulo.
OBS2: Para fins de agilizar a construção dos exemplos será utilizado o Layout AbsoluteLayout , mas se for
construir comercialmente um programa, o mesmo deverá ter o Layout Null Layout .

UTILIZANDO JCOMBOBOX/JLIST E JRADIOBUTTO N

JCOMBOBOX/JLIST

a) Criar uma aplicação para informar qual a forma de pagamento selecionada pelo usuário: Cheque, Cartão
ou Dinheiro:
 Clique no Menu File  New  Java GUI Forms  clique em JFrame Form  clique em Next
 Na Janela que se abre digite FormaPaga  clique no botão Finish
 Modifique o Layout para AbsoluteLayout
 Clique no Form e modifique a propriedade Title do Form para Forma de Pagamento
 Clique no sétimo ícone JCombobox" e clique no Form, na Janela Propriedades clique em Model
clique no Botão ... .

80
 Na janela que se abre em Item digite: cheque e clique no botão Add , digite: cartão e clique no
botão Add , digite dinheiro e clique no botão Add , clique no botão OK

 Insira um JLabel: clique no primeiro ícone (JLabel) e clique no Form.

 Insira um JButton: clique no segundo ícone (JButton) e clique no Form

 A parte visual foi criada, falta o código. Para saber qual a opção selecionada utilize o Método:
Object getSelectedItem().
 Dê um duplo clique no botão Escolher :
String S= (String) jComboBox1.getSelectedItem();//converte em String
jLabel1.setText("A opção escolhida foi: " + S); //exibe opção no Jlabel
81
  Compile (F9) e Execute (F6).
 Se desejar também é possível saber o índice: getSelectedIndex()
 A utilização do JList é idêntica a vista a cima, basta substituir o método getSelectedItem(), por
getSelectedValue().

UTILIZANDO JRADIOBUTTON COM O NETBEANS

b) Criar uma aplicação para mostrar o tipo de motor (1.0/1.6/2.0) escolhido pelo usuário

 Crie uma nova Template JFrame Form Motor , clique no Menu File  New ...
 No Form que se abre Clique no sexto ícone ButtonGroup e clique no Form para criar um grupo de
radio e permitir a seleção de apenas uma opção
 Clique no quinto ícone JRadioButton" e clique no Form, na janela Propriedades selecione Text e
digite Motor 1.0 . Selecione a propriedade buttonGroup e clique em buttonGroup1 , repita todo o
processo por duas vezes para criar a opção Motor 1.6 e Motor 2.0
 Insira um JLabel, Text: Opção Escolhida , no Form e um JButton, Escolher

 Para saber qual a opção esta marcada devemos utilizar o Método boolean isSelected(), que
devolve true ou false.
 Dê um duplo clique no botão para inserir o código:

82
  Para saber qual é o Texto exibido pelo JRadioButton basta utilizar o Método: String getText().
Ex: String s=jRadioButton1.getText();

APLICAÇÕES GRÁFICAS COM SW ING COMPONENTES ESPECIALIZADOS

JOPTIONPANE

Janelas de dialogo para informar ou solicitar confirmação de operações ou efetuar a entrada direta de
valores:
 Mensagens
 Entrada de Texto
 Janelas de Confirmação

83
Exemplos:

Nas IDE como NetBeans é possível inserir um objeto visual, mas não é possível controlar as ações dos
respectivos botões.
Se quiser utilizá-los no Netbeans, insira-os dentro de um método actionPerformed de um JButton.
Exemplo: - Criar um Programa contendo um botão que ao ser pressionado exiba informações sobre o
programa:
 Crie uma nova Template JFrame Form Mensagem , Menu File  New ...
 Mude o Layout para AbsoluteLayuot
 Insira um JButton Mensagem , dê um duplo clique para inserir o código:

JOptionPane.showMessageDialog(this,"Programa criado \n utilizando o Netbeans");

// o \n foi utilizado para mostrar como inserir uma quebra de linha.
Este componente pertence ao pacote Swing que deve ser importado através do “import”.
Procure no código o comando que cria a classe, que está no início do programa:
public class Mensagem extends javax.swing.JFrame {
Antes deste comando insira o código:
import javax.swing.*; //importa os componentes do pacote swing.

84
Compile e execute:

Todos os exemplos anteriores poderiam ter utilizado o JOptionPane.showMessageDialog.

ToolTipText: texto explicativo exibido quando o mouse passa sobre o componente:

No Netbeans basta inserir o texto desejado na propriedade ToolTipText dos Componentes (JLabel,
JTextField, JButton ...).

JFILECHOOSER

Janelas de dialogo para seleção de arquivos:

85
  Abrir (Open)
 Salvar (Save)

Exemplo:
Código a ser inserido na ação de um botão “Abrir Arquivo”:

Classe File: suporte para tratamento de arquivos:

 FileReader/FileWrite FileInputStream / FileOutputStream
São usados para ler ou gravar arquivos no sistema:
 FileReader in = new FileReader("Entrada.txt");
 FileWriter out = new FileWriter ("Saida.txt");

Comando para ler e escrever arquivos (Byte e não String/char): read() e write(String s)

86
Exemplo: criar um programa que permita selecionar um arquivo de texto, .txt e mostrar o conteúdo em um
JTextArea:

 Crie uma nova Template, Java Gui Form  JFrame Form

 Insira um JTextArea e um JButton, Abrir Arquivo , e dê um duplo clique no botão, digite:

87
 Insira, antes da declaração da classe public class , no começo do programa:

import java.io.*;
import javax.swing.*;

É possível acrescentar outro botão para salvar novos texto que o usuário pode inserir no JTextArea:
 Acrescente um novo JButton Salvar , dê um duplo clique e digite:

Estes comandos podem ser inseridos em um Menu.

A primeira aplicação criada como exemplo, representa a criação de editor de texto já composto de um
Menu, mas que não possui os respectivos códigos para efetuar as operações de abrir um documento e
salvá-lo. Experimente implementar os respectivos códigos nessa para efetivamente criar um editor de texto.

JEDITORPANE

Painel de Conteúdo é uma área de texto especializada na exibição e edição de vários tipos de conteúdo:
texto simples(text/plain), HTML(text/html) e RTF Rich Text Format(text/rtf).
Exemplo: Criar um Programa que permita exibir um arquivo com extensão.html ou .htm :
 Crie uma nova Template Java GUI Form  JFrame Form
 Insira um objeto JScrollPane no Form e insira dentro deste um objeto JEditorPane, da Aba Swing (Other)

88
 Insira um objeto JButton, Selecionar Página :

 Insira a importação dos pacotes, antes da declaração da classe public class :

import javax.swing.*;
import java.net.*;
import java.io.*;

 Compile e Execute

TRABALHANDO MÚLTIPLO S FORMULÁRIOS - MENUS

Para se construir uma Aplicação contendo vários Formulários é preciso criá-los em separados e chamá-los
em um Formulário Principal através de Botões ou de Menus.
No Formulário Principal a chamada dos outros formulários consiste em se criar instâncias dos respectivos
formulários que se deseja exibir, utilizando o método show(), ou o método setVisible(boolean).

89
Na criação de Formulários utilizando o NetBeans ( e outras IDE), a ferramenta cria os comandos
necessários para o fechamento do Formulários, desta forma se o Formulário Principal chamá-lo e este, após
ser aberto, for fechado provocará o fechamento da aplicação.
Para evitar este problema devemos modificar estes comandos para podermos fechar o formulário sem
fechar a Aplicação.

Exemplo:
Criar uma Aplicação contendo um Menu que exibi os Formulários de Cadastro de Clientes e de Veículos
 Clique no Menu File  New  Java GUI Forms  Botão Next  em Name digite SistLocação 
Clique no Botão Finish

 É preciso criar o Menu

Na Aba Swing, clique no ícone JMenuBar e clique no Form  na Janela Propriedades clique em Text e
digite Cadastro (texto que será exibido pelo Menu)  Clique com o botão direito do mouse sobre o Menu
criado  selecione Add JMenuItem  na janela propriedade clique em Text  digite Clientes  clique

90
novamente com o botão direito do mouse sobre o Menu criado  selecione Add  JMenuItem  clique em
Text e digite Veículos.

Observe que os SubMenus não aparecem no Form este serão exibido na execução do programa, mas
apara o objeto criado no Form.

Os Menus foram criados faltam os Formulários Clientes e Veículos.

Crie um Novo Form  Clique no Menu File  New  clique no Botão Next  em Name digite Clientes 
clique no botão Finish

91
Modifique o Layout para AbsoluteLayout e insira três JLabels para exibir os rótulos “Nome”, “Fone”, “CPF” e
três JTextFields para podermos digitar/exibir os dados.

Devemos modificar o comando responsável pelo fechamento do Form, para que não feche a Aplicação.
Clique com o botão direito do mouse no Form e clique em Goto Source ou pressione Ctrl-3 , procure o
comando, que deve estar antes do método main:
private void exitForm(java.awt.event.WindowEvent evt) {
Apague o comando:
System.exit(0);
E digite no seu lugar:
setVisible(false);

Volte para o primeiro Form (SistLocação), para isto clique na Aba SistLocação, localizada na janela principal
do Form

Dê um duplo clique em JMenuItem1, se o mesmo não estiver aparecendo clique no menu criado, dê um
duplo clique no JMenuItem1, para inserir o evento responsável pela chamada do Form Clientes.

Na janela de código que se abre, procure o seguinte comando:

private void jMenuItem1ActionPerformed

92
Antes deste comando digite:
Clientes FormCliente = new Clientes(); //instanciação do Formulário Clientes
Se tiver criado a Template com outro nome substitua o nome Clientes por este nome.
E dentro do método, depois de // Add your handling code here: , digite:
FormCliente.show(); //exibição do Formulário Clientes
Compile e Execute.

Repita os mesmos passos para criar o Form Veículos e para exibi-lo.

Clique no Menu File New Next digite o Nome Veículos clique no botão Finish
Mude o Layout e insira os componentes (JLabel e JTextField), vá para o código e modifique o comando
System.exit(0) para setVisible(false)
Volte para o Form SistLocação e dê um duplo clique em JMenuItem2, antes do respectivo método
actionPerformed instancie o Form:
Veículos FormVeiculo = new Veículos(); //instanciação do Form
Dentro do método digite o comando para exibição:
FormVeiculo.show();
Compile e Execute.

93
BANCO DE DADOS NO NETBEANS

ACESSANDO BANCOS DE DADOS

A comunicação de código Java puro com Banco de dados é uma tarefa muito difícil, devido a enorme
quantidade de bancos de dados, existente no mercado, com linguagens proprietárias.
A plataforma Java permite o acesso a banco de dados por meio de uma API (Application Programming
Interface) chamada JDBC (Java Database Connectivity).
É uma interface entre a linguagem Java e outra linguagem que todos os bancos de dados suportam.
O Objetivo da JDBC é possibilitar o uso de dados existentes em SGBDR remotos. Utiliza o SQL (Structured
Query Language), linguagem destinada às operações dos SGBDR.

ARQUITETURA

É muito parecida com o padrão ODBC (Open DataBase Connectivity).

A Aplicação para acessar um BD deve utilizar a API JDBC, contida no pacote java.sql.
Por meio da classe DriverManager, seleciona-se o driver de acesso ao BD que será utilizado.O driver passa
a oferece uma interface padronizada para a Aplicação, implementando em Java ou de forma nativa o
acesso ao BD.

Instalação de uma fonte JDBC/ODBC em plataforma Windows:

1. Acessar o painel de controle e ativar o aplicativo Fonte de Dados ODBC;
2. Clicar no botão adicionar (DNS do usuário) para criar uma nova ponte de um banco de dados;
3. Selecionar Driver adequado (Driver do Microsoft Access, por exemplo)
4. Preencher a caixa de diálogo com um nome para a Fonte de Dados do BD e a localização do servidor.
5. Clicar no botão Selecionar para definir o BD a ser usado.

94
Podemos construir uma aplicação usando o seguinte roteiro:

1) Importar o pacote java.sql:

import java.sql.*;

2) Carregar o driver de acesso ao BD : ( ponte JDBC-OBDC)

Class.forName( sun.jdbc.odbc.JdbcObdcDriver );

3) Obter uma conexão com o BD: (BD Access: IJPlanetas)

Connection conexão = DriverManager.getConnection( jdbc:odbc:IJPlanetas );

4) Por meio da conexão realizada, devemos obter uma instância de um objeto Statement,
PreparedStatement ou CallableStatement, para passar comandos SQL ao BD:
Statement stmt= conexão.createStatement();

5) Criar objetos para executar operações no BD (execute (String), executeQuery(String),

ExecuteUpdate(String), executeBatch()):
int reg =stmt.executeUpdate( delete from planeta where nome= Maria );
ResultSet rs = stmt.executeQuery( select nome from planeta );

6) Algumas operações retornam resultados do BD (um objeto Resultset conjunto de registros), os quais
devemos exibir ou processar:
while( rs.next() )
{ //move o curso de registros
String Nome=rs.getString( nome ); // obtém o valor do campo nome da tabela
System.out.println(Nome);
}

7) Quando não precisar mais dos objetos obtidos, libere-os:

rs.close();
stmt.close();

8) Após todas as operações encerre a conexão com BD:

conexão.close();

Exemplos de métodos de ResultSet:

 rs.absolute(3); //move cursor para linha
 rs.updateString( Nome , Maria ); //atualiza nome
 rs.updateRow(): //atualiza linha na tabela
 rs.moveToInserRow(); //insere nova linha
 rs.updateInt(2, 3535); //atualiza coluna 2

95
PRINCIPAIS COMANDOS SQL

Segue exemplos dos principais comandos que serão utilizando em uma aplicação que realizar operações
em um Banco de Dados:

SELECT: - realiza consultas

Select cidade, estado FROM Brasil WHERE pop > 1000;

INSERT: - Insere um registro

INSERT INTO Brasil (cidade, estado) VALUES ( Cid, Est )

UPDATE: - Modifica um registro

UPDATE Brasil SET Sit = “Cheio” WHERE Pop > 1000;

DELETE: - Excluir um registro

DELETE FROM Brasil WHERE cidade = “BSB”

CONSTRUÇÃO DE APLICAÇÕES - ACESSANDO UM BANCO DE DADOS ACCESS

Este exemplo realiza uma consulta na tabela denominada Relacao, com os campos Nome e Id. Vamos
partir do princípio de que a ponte JDBC-OBDC já foi criada com o nome BDAccess.

96
JDBC NO NETBEANS

O NetBeans não possui ferramentas que permitam criar visualmente componentes, em um programa, para
manipular os dados de uma tabela, a exemplo dos existentes em outras ferramentas, em outras Linguagens
de programação.
Para trabalhar com Banco de Dados é preciso fazê-lo via código, que deverá ser inserido dentro do método
actionPerformed de um JButton.
Cria-se o Formulário contendo os componentes visuais para mostrar, e manipular, os dados da tabela do
Banco de Dados. Dentre estes componentes estão os botões ou menus, os quais serão os responsáveis
por executar os códigos para realizar uma determinada operação, consulta, inserção, alteração ou exclusão
em um BD.
Depois de criada a parte visual , devem ser implementados os códigos nos botões/menus:
OBS: - Os exemplos que se seguem utilizam uma Fonte de Dados ODBC com o Nome: “PBD_Nomes” que
representa uma conexão com um Banco de Dados Access, contendo uma Tabela com o nome: “TabFicha”,
contendo os campos (Matricula Tipo Número/Chave Primária; Nome Tipo Texto)
Parte Visual do Programa:

97
Códigos para Inserir:

Códigos para Consultar que devem ser inseridos em um JButton/Menu:

98
Códigos para Alterar:

Códigos para Excluir

99
 NOTA: Antes de inserir os códigos é preciso importar os pacotes para trabalhar com Banco de
Dados e exibir caixa de mensagens:
 Localize o código de criação da classe. Ex:
Public Class ...
 Antes deste comando insira os seguintes códigos:
import java.sql.*;
import javax.swing.*;

Exemplo Completo

Crie uma aplicação para cadastrar a Matricula e os Nomes dos Funcionários de uma Empresa.

1. Clique no Menu File  New  Selecione Java GUI Forms  JFrame Forms  clique no botão Next. Na
janela que se abre, no campo Name, digite “SistCadFunc” e clique no Botão Finish.
2. Modifique o Layout do JFrame para AbsoluteLayout e insira os seguintes componentes: dois JLabel
(Nome e Matricula), dois JTextField e um JButton (Salvar)

3. A parte visual esta construída, falta o código para salvar os dados.

100
4. Abra o Access e crie um BD (BDCadastro) com uma Tabela (TabFicha) com os campos: Matricula (Tipo
Numérico/Chave Primária) e Nome (Tipo Texto_.
5. Devemos criar a Ponte JDBC/ODBC: abra o Painel de Controle  Ferramentas Administrativas  Fontes
de Dados ODBC  clique no Botão Add  Selecione o Driver p/ BD Access  clique no botão Concluir 
no campo “Nome da Fonte de Dados” digite “PBD-Nomes”  clique no botão Selecionar  Procure o BD
criado (BDCadastro) e clique no Botão OK  OK  OK

101
6. Criado o BD e a Ponte ODBC, volte para a sua aplicação no NetBeans e dê um duplo clique no JButton
(Salvar) para codificar a conexão:
Depois de private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { , digite:

102
 NOTA: Observe que em alguns momentos
usaremos aspas simples e aspas duplas ao
mesmo tempo.

7. Compile Execute.
8. Realizando operações de Consulta, Alteração e Exclusão em BD:
Insira três Botões para executar as operações restantes no Banco de Dados (Consulta, Alteração e
Exclusão), um JLabel, para exibir o Texto “Nome para Consulta/Exclusão”, supondo que estas operações
serão feitas através do campo “Nome”, e insira também um JTextField para o usuário poder digitar o
“Nome”, ou crie um novo Form contendo os JLabel, JTextField , e JButton, sendo que o mesmo deverá ser
chamado por outro Form através de um JMenuBar.
Supondo que foram inseridos os novos componentes da seguinte forma:

Basta dar um duplo clique no botão desejado e inserir o respectivo código para a respectiva operação:

Consultar

103
Alterar:

104
Excluir:

9. Compile Execute.

OBS: Como os comando de conexão com o Banco de Dados estão se repetido, os mesmos poderiam ser
implementados dentro de uma função e serem executados através de uma chamada desta função quando
se desejar estabelecer uma conexão com o banco de dados para realizar uma determinada operação em
suas tabelas, diminuindo a quantidade de código a ser digitado.

105
COMPONENTES GRÁFICOS

O Java oferece dois pacotes para criação de interfaces gráficas: AWT e Swing. O AWT acompanha o Java
desde as primeiras versões, e o Swing trata-se de um pacote mais completo introduzido posteriormente.
Estes pacotes oferecem contêineres (janelas, painéis e frames) nos quais podem ser inseridos
componentes gráficos (botões, caixas de texto, etc.).
A figura abaixo (do livro Java Foundation Classes in a Nutshell, de David Flanagan, Ed. O´Reilly) mostra as
principais classes do pacote javax.swing.

106
Os contêineres trabalham com o conceito de layout, que define como os componentes são dispostos dentro
do contêiner. Os principais layouts definidos pelo Java são os seguintes:

 Layout de Fluxo (Flow): os componentes são dispostos em seqüência no contêiner, da esquerda

para a direita.

 Layout de Borda (Border): os componentes podem ser colocados em 5 regiões - norte, sul, leste,
oeste e centro.
 Layout de Grade (Grid): cria uma "grade" de X linhas por Y colunas, com X*Y células nas quais os
componentes são colocados.

 Layout de Caixa (Box): empilha os componentes na horizontal ou na vertical.

 Null Layout: sem um layout específico.

É possível colocar dentro de um contêiner outros contêineres com layouts diferentes. No exemplo abaixo
foram criados três painéis (componente JPanel): o primeiro segue o layout Box, o central usa o layout
Border e o último é um Grid 2x2.

107
Além dos layouts padrão, outros tipos de layout podem ser utilizados. O layout Desenho Livre (usado como
layout default pelo NetBeans - o ambiente de desenvolvimento que iremos utilizar) dispõe os componentes
na posição exata na qual eles são colocados no contêiner.

USANDO COMPONENTES G RÁFICOS NO NETBEANS

O NetBeans é um poderoso ambiente para desenvolvimento de aplicativos, com suporte a desenvolvimento

de aplicações em várias linguagens e plataformas, incluindo Java em suas três edições: Micro Edition,
Standard Edition e Enterprise Edition.
Através do NetBeans é possível desenvolver aplicações gráficas em Java utilizando componentes Swing e
AWT, assim como aplicações que utilizem outros componentes desenvolvidos por terceiros.
O NetBeans trabalha com o conceito de projetos de software. Um novo projeto é criado no NetBeans
através do menu Arquivo Novo Projeto. No assistente 'Novo Projeto' pode-se selecionar um entre os
diversos tipos de projetos disponíveis. Por exemplo, o tipo de projeto 'Aplicação de área de trabalho Java'
da Categoria 'Java' corresponde a uma aplicação gráfica do Java Standard Edition. Em seguida é possível
definir o nome do projeto e o diretório no qual o projeto será criado, além de outras opções.

108
O projeto criado será exibido na janela ‘Projetos’.

O projeto criado possui uma classe que representa uma interface gráfica, na qual podem ser adicionados
componentes contidos na paleta de componentes do NetBeans, conforme mostra a figura abaixo. Ao editar
uma interface gráfica, será exibida a tela de edição ‘Projeto’ - o retângulo cinza à esquerda na figura abaixo,
que representa a área de trabalho da janela que está sendo editada - na qual é possível inserir os
componentes disponíveis na janela 'Paleta'. Para isso basta selecionar o componente a ser inserido e
depois clicar no local onde se deseja inseri-lo.

Para visualizar a interface gráfica na forma como esta será exibida na tela, basta pressionar o botão .

109
Também é possível inserir no projeto diversos tipos de classes Java através do menu Arquivo  Novo
Arquivo. Selecionando a categoria ‘Formulários GUI Swing’, pode-se criar quadros (Formulário JFrame),
painéis (Formulário JPanel) e janelas de diálogo (Formulário JDialog), por exemplo. Esses elementos
corresponderão a uma nova classe Java da aplicação, e servirão como contêineres para outros
componentes gráficos.

A forma como o componente se ajusta à tela depende do layout utilizado. O layout default usado pelo
NetBeans é o ‘Desenho Livre’, que mantém a posição original na qual o componente foi inserido. O layout
utilizado pode ser alterado clicando o com o botão da direita do mouse sobre o contêiner na janela
'Inspetor'.

110
Na janela 'Propriedades' é possível definir as propriedades dos componentes. Por exemplo, após adicionar
um item de menu (JMenuItem) a um dos menus da barra de menus da interface gráfica, ao selecioná-lo, é
possível editar o texto mostrado no item de menu alterando a propriedade 'text' na janela de propriedades
do NetBeans.

Cada componente possui um conjunto diferente de propriedades. As propriedades podem ser acessadas
também no código da aplicação, através dos métodos setPropriedade e getPropriedade (por exemplo,
setText(String s) e getText() para a propriedade text do item de menu).
Note que, à medida que você for editando a interface gráfica, o código correspondente a essas alterações
será gerado no arquivo Java. Clique no botão 'Código-Fonte' na tela de edição pra visualizar o código da
classe, e em seguida expanda (clicando no sinal '+') a linha marcada como 'Generated Code' para exibir o
111
código gerado pelo NetBeans. O NetBeans protege este código, marcado em azul, impedindo sua edição.
Note que os componentes adicionados à interface gráfica são criados automaticamente como atributos da
classe que representa a interface gráfica da aplicação.

TAREFA 1: A INTERFACE GRÁFICA DA APLICAÇÃO

Comece a implementar a interface gráfica do aplicativo de controle de acesso a academias utilizando o

NetBeans. Não se preocupe por enquanto em implementar a funcionalidade da aplicação.
Crie um novo projeto do tipo ‘Aplicativo de área de trabalho Java’. Na seqüência, edite os componentes da
janela principal da aplicação. Caso necessário, adicione novos frames e janelas de diálogo ao projeto. Teste
a disposição dos componentes dentro da janela, para que seu aplicativo se comporte de maneira adequada
quando for redimensionado ou maximizado. Durante este processo, pode ser necessário modificar os
layouts e a disposição dos componentes até atingir um resultado satisfatório.
Insira na interface da aplicação os componentes necessários para executar as seguintes funcionalidades:

 Cadastramento de alunos: registrar os dados pessoais do aluno, a foto e o tipo de plano (Obs.: os
planos podem possuir restrições de horário, de dias da semana e de modalidades esportivas).

 Controlar pagamentos: registrar os pagamentos de mensalidades efetuados pelos alunos.

 Controle de acesso: permitir o acesso de alunos somente nos dias e horários permitidos para o tipo
de plano e se a mensalidade não estiver em atraso.
Use a janela de propriedades dos componentes para modificar as propriedades que julgar necessárias,
como por exemplo o texto, o tipo de fonte, a cor, ou ícone dos botões.
Tente compilar e rodar a interface gráfica da aplicação (Shift+F6). A lógica de funcionamento será
implementada em um segundo momento.

EVENTOS

O Java permite que eventos gerados pelo usuário sejam tratados pelos programas utilizando tratadores de
eventos. Eventos produzidos pelo mouse e pelo teclado - das classes MouseEvent e KeyEvent
respectivamente - podem ser tratados criando objetos que implementem as interfaces MouseListener e

112
KeyListener. A API do Java define classes auxiliares para implementação dos tratadores de eventos,
chamadas MouseAdapter e KeyAdapter, que são classes abstratas (com implementações vazias para os
métodos da interface correspondente) usadas como superclasses para tratadores de eventos do mouse e
do teclado respectivamente.
Suponha que queremos tratar os eventos gerados pelo mouse. Um consumidor do evento MouseEvent
gerado pelo componente meuComponente (um botão, por exemplo) deve se registrar para receber os
eventos com o método addMouseListener, e criar um objeto do tipo MouseAdapter. Isto pode ser feito
criando uma classe anônima, na qual deve ser definido o código para tratar o evento correspondente. No
exemplo abaixo foi definido o código do método mouseClicked, que é chamado toda vez que o componente
é clicado com o mouse:

meuComponente.addMouseListener(new java.awt.event.MouseAdapter()
{
public void mouseClicked(java.awt.event.MouseEvent evt)
{
// trata o evento de click do mouse
}
}
);

Outra forma de fazê-lo seria criar uma classe que implemente a interface MouseListener, definir seus
métodos e chamar addMouseListener passando um objeto desta classe como parâmetro.
Outros tipos de eventos também possuem suas classes Listener, Adapter e Event, que são utilizadas de
maneira semelhante.

TRATAMENTO DE EVENTO S NO NETBEANS

A partir da janela de edição do NetBeans é possível criar tratadores de eventos gerados por componentes.
Isso pode ser feito de duas formas: usando o modo de conexão ou definindo os tratadores de eventos.

Para ativar o ‘Modo de conexão’, clique o botão na janela de edição da interface gráfica. Em seguida,
você deve selecionar o componente de origem e o componente de destino da ação. No exemplo abaixo,
selecionamos na janela de projeto da interface gráfica o item de menu ‘File -> New’ da aplicação, e logo
depois a área de texto da aplicação.
No ‘Assistente de conexão’, que será aberto automaticamente, selecione o evento de origem – no caso, o
evento ‘actionPerformed’, que inclui a ativação do menu pelo mouse ou pelo teclado.

113
Logo depois, selecione a operação a ser executada quando o evento ocorrer – nesse caso, limpar a área de
texto, selecionando a propriedade ‘text’ e alterando seu valor para um texto vazio.

114
Ao finalizar o assistente, o seguinte método tratador de eventos será gerado:

Outra forma possível de tratar eventos é associar um tratador de evento a um componente. Ao clicarmos um
componente o botão da direita do mouse, é possível criar um tratador para um evento gerado pelo
componente.

115
Feito isso, pode-se editar o código que será executado quando o evento selecionado ocorrer. A edição de
código é facilitada pelo recurso auto-completar do NetBeans, ativado teclando Ctrl+Espaço. Assim é
possível ter acesso aos atributos e método da classe que está sendo editada. Lembre-se que os
componentes adicionados à interface gráfica são atributos da classe, e seus métodos e atributos também
podem ser visualizados utilizando o recurso auto-completar.

116
IMPLEMENTANDO COMPON ENTES BÁSICOS COM SWING, UTILIZANDO
NETBEANS

Vamos implementar um sistema simples de cadastro com o objetivo de explicar como funcionam os
componentes básicos do framework swing (JTextField, JTextArea, JRadioButton, ButtonGroup,
JCheckBox, JComboBox, etc.), para isso utilizaremos a IDE NetBeans 5.5.1 para construir nossa
interface, aprenderemos como manipular os métodos mais importantes para se trabalhar com estes
componentes, e como manipular suas propriedades.
Uma das partes mais complicadas e chatas para um programador é “desenhar” a interface gráfica, ainda
mais se tiver que fazê-la na mão, linha por linha, para nos poupar trabalho e tempo o NetBeans possui
uma fantástica ferramenta para desenvolvermos nossa interface gráfica no estilo “Drag and drop” - Arrastar
e soltar. Uma paleta com diversos componentes disponíveis, onde você tem apenas que arrastá-la para
dentro de seu Jframe e pronto! O NetBeans gera todo código para você automaticamente. No final deste
tutorial você será capaz de criar seu próprio projeto fazendo uso de inúmeras aplicações possíveis com o
construtor de interface do NetBeans.
Neste exemplo é usado o NetBeans 5.5.1 versão em português.

ITEM 1: CRIANDO UM JF RAME.

Após criar um projeto clique com o botão direito do mouse sobre ele, em novo, escolha a opção
Formulário JFrame como na imagem abaixo.

117
Note que será gerada pra você uma nova tela com uma caixa de edição, onde você irá construir toda sua
interface gráfica, pode redimensioná-la à vontade. Na barra de menu, a direita da tela, terá dois botões:
Propriedades e Paleta. Em paleta estará todos os componentes que você pode usar para criar sua
interface gráfica.

ITEM 2: CONSTRUINDO A INT ERF ACE

Como vamos fazer um sistema simples de cadastro, utilizaremos os seguintes componentes:

 JPanel: Painel criado em cima do JFrame que permite entre outras opções, adicionar cor de fundo
e borda. É utilizado para organizar melhor sua interface.
 JLabel: Permite inserir textos e imagens.
 JTextField: Caixa de texto para que o usuário insira os dados no programa.

É importante salientar que todos os dados inseridos em um JTextField são tratados como String. Portanto
se for inserir um dado numérico é necessária a devida conversão.

 JTextArea: Campo semelhante ao JTextField, normalmente usado para entrada de textos maiores.
Como críticas, sugestões, etc.
 JRadioButton: Botão que permite apenas seleção de uma opção quando relacionado a um
ButtonGroup.
 ButtonGroup: Componente utilizado para criar grupos de JRadioButtons.
 JCheckBox: Caixas de múltiplas seleções, permite o usuário marcar várias opções ao mesmo
tempo.
 JComboBox: Componente semelhante a um vetor, que permite ao usuário escolher apenas uma
opção.
 JButton: Botão onde serão implementados os eventos.

Sabendo os componentes a serem usados, monte a interface abaixo:

118
ITEM 3: PASSO-A-PASSO

No exemplo acima, estamos usando todos os componentes mencionados anteriormente. O JPanel

principal apresenta um título ‘Cadastro’, para colocarmos borda com título a um JPanel você deve ir até o
botão propriedades, a direita da tela, ou clicar com o botão direito do mouse sobre o JPanel e ir até
a propriedade border, clique no botão com ‘...’ várias opções de borda serão exibidas, selecione
TitledBorder, e no campo Título escreva o título que desejar para o seu JPanel, no nosso exemplo
‘Cadastro’. Para o JPanel que contém os JCheckBox o tipo de borda é EtchedBorder.
 Para inserir qualquer componente dentro de um JPanel, você deve primeiro inserir o JPanel, em
seguida os componentes sobre ele. Outra maneira é arrastando os componentes de fora para
dentro do JPanel.
 Para inserir itens no JComboBox da opção ‘Estado’, você deverá ir à opção model em
propriedades, insira o nome do item que você quer que apareça e clique em adicionar.
 Para inserir uma imagem, coloque um JLabel e na opção icon em propriedades, marque ‘Arquivo’,
botão ‘Selecionar Arquivo’ e escolha a imagem que você deseja adicionar a sua interface, de
preferência em .gif, em seguida apague o que estiver escrito na opção text para deixar somente a
imagem.
Ao transferir seu projeto de um computador para outro, certifique-se de que o caminho da imagem seja o
mesmo neste computador.
Para permitir que seja marcada apenas uma opção nos JRadioButtons, da opção Sexo de nosso cadastro,
você deve adicionar ao projeto o componente ButtonGroup, este componente não apresenta nenhum
tipo de interface, ao inseri-lo note que ele será adicionado no inspetor de componentes a esquerda da tela.
119
Em seguida vá até as propriedades dos JRadioButtons, opção buttonGroup e escolha buttonGroup1
(nome padrão para este componente), faça isso para ambos os JRadioButtons.
Para apagar os nomes que vêem dentro dos JTextField, JRadioButtons, JCheckBox e JButtons basta dar
duplo clique sobre eles e apagar o que está escrito, ou então na opção text em propriedades.

ITEM 4: MANIPULANDO O CÓ DI G O

Antes de começar a manipular o código, deve-se alterar o nome de variável de todos os componentes
que serão utilizados para processar os eventos (entenda ‘eventos’, como sendo basicamente a
funcionalidade que você dará a um botão), para que nosso código fique mais legível e organizado.
Para alterar o nome de variável de um componente, clique sobre ele, como o botão direito do
mouse escolha ‘Alterar o nome de variável...’ e insira o nome que você deseja.
Em nosso projeto utilizaremos o seguinte padrão:

 Para JTextField: campoNomeDaOpção – Ex: campoNome

 Para JComboBox: comboNomeDaOpção – Ex: comboEstado
 Para JRadioButton: rbNomeDaOpção – Ex: rbMasculino
 Para JCheckBox: cbNomeDaOpção – Ex: cbMusica
 Para JTextArea: campoNomeDaOpção – Ex: campoBiografia
 Para JButton: btNomeDoBotão – Ex: btSalvar
 JLabels e JPanels não necessitam de alteração pois não serão implementados diretamente no
tratamento de eventos.

Vamos implementar um evento no botão ‘Salvar’, onde os dados contidos em todos os componentes serão
armazenados em um objeto, para isso você deve criar uma classe auxiliar que apresente variáveis para
todas as opções do cadastro (Nome, endereço, sexo, etc.), e instanciar o objeto, você deverá criar
métodos set e get para todas as variáveis (utilizaremos apenas 1 cadastro, mas você pode fazer
utilizando vetores ou arquivos), como disse anteriormente, o objetivo é ensinar os métodos
necessários a implementação dos componentes.
Para inserir um evento de clique a um botão, clique sobre ele, opção ‘Eventos’ > ‘Action’ >
‘actionPermormed’, veja na imagem abaixo:

120
Repare que o NetBeans leva você até a área de edição de código e gera pra você o cabeçalho do método
que irá tratar o evento:

private void btSalvarActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO adicione seu código de manipulação aqui:
}

Todo código com fundo azul o NetBeans gera automaticamente pra você e não pode ser mudado.
Instancie fora do método criado pelo NetBeans o seu objeto:

ClasseAuxiliar obj = new ClasseAuxiliar();

E comece a implementar o código dentro do método criado pelo NetBeans. Para receber os dados
inseridos em um JTextField você deve utilizar o método getText() da seguinte forma

obj.setText( campoNome.getText() );

Faça o mesmo para os campos Endereço, E-Mail e Fone.

121
Para retornar os campos de um JComboBox você deve utilizar o método getSelectedItem(). Entretanto
para armazenar em uma variável do tipo String você deve convertê-lo para String, ficando assim:

obj.setEstado( (String)comboEstado.getSelectedItem() );

Para retornar o sexo (Masculino ou Feminino) deve ser feita uma verificação de qual JRadioButton foi
marcado pelo usuário, o método utilizado para isso é isSelected(), desta forma:

if ( rbMasculino.isSelected() )
obj.setSexo( "Masculino" );
else
obj.setSexo( "Feminino" );

Vamos agora para os JCheckBox, para saber quais foram marcados, você deve fazer uma verificação
para cada componente. O método utilizado para isso é o mesmo do JRadioButton, isSelected(), vamos
adotar que as variáveis de interesses foram declaradas do tipo boolean em sua classe auxiliar, ficando
desta maneira:

if ( cbMusica.isSelected() )
obj.setMusica( true );

if ( cbCinema.isSelected() )
obj.setCinema( true );

if ( cbEsporte.isSelected() )
obj.setEsporte( true );

if ( cbInformatica.isSelected() )
obj.setInformatica( true );

Muito bem, agora falta apenas o JTextArea, que é implementado igualmente ao JTextField usando o
método getText(), assim:

obj.setBiografia( campoBiografia.getText() );

Após ser implementado todo os componentes no evento do botão salvar, coloque uma mensagem de
confirmação para o usuário utilizando

JOptionPane.showMessageDialog(null,"Cadastro realizado com sucesso");

Não se esqueça dos imports. Pronto o cadastro está completo, agora vamos para os métodos de exibição.
Após os dados serem salvos você deve apagá-los de seus respectivos campos para usar os espaço para
122
exibição (ou se você quiser implementar mais de um cadastro). Para isso pode-se criar um botão ‘Apagar’
ou simplesmente os dados serão apagados após serem salvos, que é como faremos aqui.

Para apagar o JTextField e o JTextArea utilização o método setText(), ficando desta forma:

campoNome.setText( “” );
comboEstado.setText( “” );

Um JComboBox funciona como se fosse um vetor, onde cada item fica em um índice, para desmarcar um
JComboBox utiliza-se o método setSelectedIndex(int i) que recebe como parâmetro um número inteiro
que representa o índice deste JComboBox. Para desmarcar usa-se:

comboEstado.setSelectedIndex(-1);

O -1 indica que nenhum item está selecionado.

Para apagar o JRadioButton selecionado, deve-se apagar o grupo inteiro, ou seja o ButtonGroup, para
isso utilizamos o método clearSelection(), da seguinte forma:

if ( rbMasculino.isSelected() || rbFeminino.isSelected() )
buttonGroup1.clearSelection();

O código acima verifica se algum dos JRadioButtons estão selecionados, se verdadeiro, apaga a seleção.

Agora só falta apagar os JCheckBox que foram marcados, para isso basta verificar cada um para ver se
estão marcados e então, desmarcar. Utilizando o método setSelected( boolean b ), pode-se mudar o
estado de um JCheckBox, onde o parâmetro é do tipo boolean e true representa opção marcada, e false
desmarcada.

If ( cbMusica.isSelected() )
cbMusica.setSelected( false );

If ( cbCinema.isSelected() )
cbMusica.setSelected( false );

If ( cbEsporte.isSelected() )
cbMusica.setSelected( false );

If ( cbInformatica.isSelected() )
cbMusica.setSelected( false );

Todos os campos serão apagados após serem salvos, e agora podemos exibir os dados armazenados.
123
ITEM 5: EXI BI NDO DADOS

Para exibir os dados que foram armazenados usaremos os mesmos campos onde são preenchidos os
dados (os componentes), caso você esteja implementando mais de um cadastro, utilizando vetor ou
arquivos, seria interessante criar dois botões ‘Próximo’ e ‘Anterior’ para navegar entre os cadastros, mas
isso fica para uma próxima oportunidade, como disse anteriormente o objetivo desde tutorial é familiarizar
você com os principais componentes e aprender os métodos necessários para implementá-los.

Primeiramente devemos criar um evento para o botão ‘Limpar’ da mesma forma que foi feito para o botão
‘Salvar’. Dentro do método gerado pelo NetBeans vamos implementar nosso código.

Para exibir em um JTextField e JTextArea, utiliza-se o método setText()

Ex.:
campoNome.setText( obj.getNome() );

Repita isso para todos os JTextField e para o JTextArea. Atenção para o nome de variável do componente.

Para alterar o estado de um JComboBox usamos o método setSelectedItem(), ficando deste jeito:

comboEstado.setSelectedItem( obj.getEstado() );

Para selecionar um JRadioButton e JCheckBox, utilizaremos o método setSelected(), devemos verificar

qual opção sexual foi escolhida no cadastro e quais opções foram marcadas nos Interesses, e então
selecioná-las, nosso código ficará assim:

if ( obj.getSexo() == "Masculino" )
rbMasculino.setSelected(true);
else
rbFeminino.setSelected(true);

O trecho acima verifica se a variável sexo é igual a “Masculino” (como definimos no evento do botão
salvar) , então marca o JRadioButton, senão, marca o JRadionButton referente ao sexo feminino.

Para os JCheckBox:

If ( obj.getMusica == true )
cbMusica.setSelected(true);

If ( obj.getCinema == true )
cbCinema.setSelected(true);

124
If ( obj.getEsporte == true )
cbEsporte.setSelected(true);

If ( obj.getInformatica == true )
cbInformatica.setSelected(true);

Verificamos qual dos interesses foram salvos no cadastro e marcamos para exibição.

125
CONEXÃO COM BANCO DE DADOS

ARQUITETURA JDBC

Para se conectar a um banco de dados, um programa Java utiliza uma API JDBC única, que independe do
BD ou do driver que estiver sendo utilizado. Os drivers para conexão e acesso aos principais banco de
dados existentes são fornecidos pelos seus fabricantes ou por terceiros. O programador apenas precisa
saber utilizar a API JDBC e a forma como o driver adequado se conecta ao banco de dados.
A API JDBC nada mais é do que o pacote java.sql que deve ser importado nos programas Java que utilizam
o JDBC para que possa haver a conexão com os banco de dados. O pacote java.sql contém as classes e
interfaces necessárias para trabalhar com acesso a banco de dados relacionais.
Faz parte do pacote java.sql uma classe chamada DriverManager, peça central da arquitetura JDBC.
Utilizada para abrir uma conexão com um banco de dados através de um driver JDBC. Quando uma
conexão é iniciada, a classe DriverManager escolhe um driver de uma lista de drivers disponíveis para
efetuar a conexão. Uma vez estabelecida a conexão com sucesso, as chamadas para consultas e busca de
resultados são feitas diretamente através do driver JDBC.
Um programa Java pode utilizar simultaneamente vários drivers JDBC, isto é, o programa pode acessar
diferentes bancos de dados, bastando “carregar o driver”. O programador não precisa saber como o driver
foi implementado, bastando saber que ele deve ser registrado na classe DriverManager.
Os drivers JDBC se distinguem em quatro tipos:
1. drivers com acesso a API parcialmente nativa — a API JDBC chama procedimentos do driver nativo
do SGBD instalado na máquina local. Cada estação deve ter instalado o programa cliente;
2. ponte com ODBC — acesso ao banco de dados através de um driver ODBC convencional. A ponte
JDBC aponta para a ponte ODBC;
3. driver com protocolo proprietário escrito em Java — a comunicação entre o cliente e o banco de
dados é através do protocolo do SGBD. E o tipo mais flexível e acessa um servidor usando um
protocolo neutro, por exemplo HTTP. E o servidor que estabelece a conexão com os banco de
dados;
4. driver com protocolo nativo — o driver acessa diretamente o SGBD utilizando o protocolo nativo do
mesmo. Por esta razão, os drivers, são fornecidos pelos fabricantes de banco de dados. São os
chamados thin drivers.

CONEXÃO COM O BANCO DE DADOS

A conexão com o banco de dados segue sete etapas, descritas a seguir:

ETAPA 1 — IMPORTAR AS CLASSES JDBC

Inicialmente deve ser carregado o pacote java.sql para que o programa possa utilizar as classes de conexão
com o banco de dados e os comandos para manipular os dados:
import java.sql.*;
126
ETAPA 2 — CARREGAR O DRIVER JDBC

Pode ser feito de três formas diferentes e para todas é necessário conhecer a classe que implementa o
driver:
 carga dinâmica da classe com o método Class.forName:
Class.forName (“sun. jdbc.odbc. jdbcOdbcDriver”);

 Instanciação de um objeto para forçar a classe:

new sun. jdbc.odbc. jdbcOdbcDriver();

Os exemplos acima estão baseados numa conexão do tipo ponte ODBC. Para utilizar outros drivers JDBC
basta substituir a classe sun.jdbc.odbc.jdbc.OdbcDriver pela classe que implementa o driver desejado.
Após a carga do driver é necessário registrá-lo na classe Driver Manager

Driver drv = new sun.jdbc.odbc.jdbcOdbcDriver();

DriverManager.registerDriver (drv);

ETAPA 3 - ESPECIFICAR UM BANCO DE DADOS

Nesta etapa é definida a URL de conexão específica para cada banco de dados. Normalmente a
documentação da URL de conexão é fornecida junto com o driver. Para obter a conexão, esta deve ser
passada como uma string.
O formato de URL para conexão a um banco de dados Oracle, por exemplo, é jdbc:oracle:<driver>:
@<servidor>:<porta>:<instância>.

ETAPA 4 – ABRIR A CONEXÃO

A conexão deve ser aberta através do método estático getConnection da classe DriverManager, onde o
parâmetro do método é a URL de conexão e o retorno é um objeto que implementa o objeto Connection:
Connection con = DriverManager.getConnection (url, “usuário” , “senha”);
O DriverManager analisa a URL de conexão e tenta conectar com o primeiro driver carregado e, se não
conseguir tenta o driver seguinte. Caso ele não consiga estabelecer conexão com nenhum dos drivers
carregados, então uma exceção é gerada. Uma vez inicializada a conexão, através do objeto Connection é
criada uma linha direta com a base de dados.

ETAPA 5 - CRIAR UM STATEMENT

Um objeto Statement é utilizado para enviar comandos para o banco de dados. Os Statements podem ser
de três tipos:

127
  Statement - utilizado para enviar comandos SQL simples, isto é, que não envolvem parâmetros:
Statement comando = con.createStatement();

 PreparedStatement - o comando SQL é pré-compilado e utilizado posteriormente:

PrepareStatement comando = con.prepareStatement (stringSQL);

 CallableStatement - utilizado para chamar procedimentos SQL armazenados no banco de dados, as

StoredProcedures:
CallableStatement comando = con.prepareCall (stringSQL);

Nos exemplos acima, foi utilizado o objeto con criado na etapa 4.

ETAPA 6 - SUBMETER UM COMANDO SQL

É importante distinguir o tipo de sentença SQL que se deseja utilizar, visto que o método de enviar
consultas (query) difere do envio de atualizações (update, insert, delete,etc.) na base de dados. A principal
diferença é que o método da consulta retoma uma instância da classe reesultSet enquanto que a
atualização retoma um número inteiro.
As consultas são executadas pelo método execute Query do objeto Statement, e as atualizações pelo
método execute Update do mesmo objeto. Os exemplos a seguir tomam o texto mais elucidativo:

ResultSet rs = comando.executeQuery(”select * from EMP”);

int lin = comando.executeUpdate(”delete * from EMP”);

ETAPA 7 - RECEBER OS RESULTADO S

Conforme já foi visto na etapa 6, um comando SQL pode receber como resultado um conjunto de linhas de
uma tabela (chamado resultSet), um número inteiro, parâmetros de saída de uma StoredProcedure ou,
ainda, uma combinação de todos os anteriores:
ResultSet - é um conjunto de registros que retomam de uma consulta. Os registros podem ser acessados
seqüencialmente ou aleatoriamente. As colunas de cada registro podem ser acessadas através de um
índice ou pelo nome da coluna:

128
número inteiro - os comandos de atualização no banco de dados (insert, update ou delete) atingem um
número de linhas na tabela.
O retomo do método executeUpdate fornece esse número:
int lin = comando.executeUpdate(”delete * from EMP”);

parâmetros de saída de Stored Procedures - através dos métodos da classe CallableStatement é possível
indicar quais os parâmetros de saída, quais os de entrada e qual o tipo da procedure.

O desenvolvimento de produtos relacionados a Java já está ocupando boa parte do mercado de sistemas
de informação e, em pouco tempo, deve chegar aos índices de linguagens tradicionais como Delphi e Visual
Basic.
Java deixou de ser uma ferramenta utilizada apenas para construir páginas bonitas na Web. Está se
estabelecendo como uma linguagem de programação séria, à altura das aplicações empresariais mais
sofisticadas. Este fenômeno somente se tornou possível com a possibilidade destas aplicações acessarem
os bancos de dados através da API JDBC.
Neste documento foi apresentada a API JDBC que é utilizada para fazer uma conexão entre os programas
Java e um banco de dados. Esta conexão é feita de forma simples, e com poucos métodos é possível
executar todos os comandos SQL passando-os como parâmetros para o banco de dados.
A utilização desta tecnologia no desenvolvimento de programas Java que tem a pretensão de acessar
banco de dados é o caminho natural da programação.

129
CONEXÃO DO JAVA COM O ORACLE

130
ANEXOS

CONFIGURAÇÃO DO JDK NO W INDOW S 7

A primeira coisa a fazer é localizar e guardar os diretórios de dois arquivos que se encontram dentro da
pasta do jdk que por sua vez está dentro da pasta Java. Então vá à pasta Java e depois na pasta do jdk,
dentro da pasta do jdk de cara você já irá encontrar um dos arquivos que teremos que saber o diretório:
src.rar

Exemplo:
C:\Program Files\Java\jdk1.6.0_17\src.zip

O seu diretório pode ser diferente caso tenha instalado em outro local e/ou se sua versão do jdk for outra,
fique atento a isso, copie e cole o diretório em algum lugar pra ter fácil acesso porque iremos precisar.
O outro arquivo que devemos ir atrás do diretório também está dentro da pasta lib que por sua vez está
dentro da pasta do jdk, o arquivo procurado agora é o tools.jar

Exemplo:
C:\Program Files\Java\jdk1.6.0_17\lib\tools.jar

Guarde novamente o diretório desse arquivo em algum lugar para copiar e colar facilmente porque iremos
precisar.
Clique com botão auxiliar do mouse no ícone "Meu computador" e vá em "Propriedades". Clique em
"Configurações avançadas do sistema" e depois em "Variáveis de ambiente". Em "Variáveis do sistema"
você irá clicar em "Nova".
Coloque no nome da variável: ClassPath
Em valor da variável coloque os endereços guardados anteriormente de modo que fique dessa maneira:
C:\Program Files\Java\jdk1.6.0_17\src.zip;C:\Program Files\Java\jdk1.6.0_17\lib\tools.jar;.

ATENÇÃO: coloque do jeito que está acima, com os ";" (ponto e vírgula) e com o ponto final. O que pode
mudar, como já foi dito anteriormente, são os endereços onde estão localizados os arquivos src.zip e
tools.jar dependendo de onde você instalou e da sua versão do jdk.
Depois de fazer isso clique em Ok. Agora vamos configurar a variável Path que está em Variáveis do
sistema também.
Você seleciona a variável Path e clica em Editar, em Valor da variável você vai ACRESCENTAR (nada de
apagar valores) o seu endereço do jdk, no meu caso ficaria assim:

Exemplo:
C:\Program Files\Java\jdk1.6.0_17\bin

131
ATENÇÃO: o que pode mudar é o endereço do jdk, o ";" é necessário e o "bin" depois do endereço
também! Depois de feito isso clique em Ok e depois em Ok de novo para sair das Variáveis de ambiente e
depois em Aplicar e Ok para sair das Propriedades do sistema.

132
COMO CONECTAR O JAVA AO MYSQL USANDO O NETBEANS

Esse documento parte do pressuposto de que quem for segui-lo tenha o JDK (Java Development Kit)
instalado assim como o MySQL e o NetBeans. Caso você não tenha nenhum deles, você pode baixar e
instalar a partir dos sites oficiais.
O NetBeans possui algumas “facilidades” de conexão a banco de dados bem ao estilo “Next > Next > Ok”.
Após tudo instalado hora de começar a colocar a mão na massa. O Java para se conectar a qualquer banco
de dados precisa de um driver de conexão, esse driver é chamado de JDBC (Java Database Connectivity).
Sem um JDBC não é possível fazer uma conexão a um banco de dados. Cada banco de dados possui seu
próprio JDBC. Por exemplo a Oracle fornece um JDBC para ser usado em bancos Oracle, o PostGRESQL
também fornece um JDBC para ser usado com o PostGRESQL e assim vai. Não é diferente com o MySQL.
O pessoal do MySQL também disponibilizou um JDBC para ser usado em conexão Java – MySQL.
Como o MySQL também nos fornece um JDBC, vamos baixá-lo do site oficial do MySQL. Endereço do
JDBC é: http://dev.mysql.com/downloads/. No menu, clique em Connectors e depois em Connector/J. Agora
é só fazer o download do JDBC. Feito o download descompacte o arquivo.
Serão descompactados vários arquivos como instruções e documentações mas o arquivo que nos interessa
é um que termina com extensão .JAR. Até a finalização desse documento o nome do JDBC do MySQL é
mysql-connector-java-5.1.7-bin.jar
Esse é o JDBC que irá nos conectar a uma base MySQL. Guarde a localização desse arquivo. Agora vamos
criar um banco de exemplo com alguns dados.
Se conecte ao MySQL com sua ferramenta favorita ou pelo console mesmo. Para esse documento eu criei
um banco com uma tabela e três colunas. Tudo bem simples. Se quiser seguir esse exemplo abaixo, vai o
script SQL para a criação. Basta rodar no banco. Fique a vontade para fazer o esquema de banco a sua
maneira, só lembre-se de mais para frente no documento adaptar o seu esquema de banco ao código.
Script SQL:

CREATE TABLE IF NOT EXISTS 'usuarios' (

'nome' varchar(50) NOT NULL,
'email' varchar(50) NOT NULL,
'idade' int(11) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

INSERT INTO usuarios (nome, email, idade) VALUES

('Ricardo', 'ricardo@meuemail.com', 23),
('José', 'jose@seuemail.com', 29);

PRONTO! Banco criado e alguns dados inseridos. Vamos para o NetBeans!

133
Abra a NetBeans e vamos criar nosso projeto. Para isso faça:
Arquivo > Novo Projeto;
Escolha categoria: Java. Projeto: Aplicativo Java;
Clique em Próximo;
Coloque um nome para o projeto e clique em finalizar

Abaixo temos a próxima tela após clicar no botão Próximo. Aqui é onde definiremos o nome para o projeto e
mais algumas configurações.

O projeto foi criado.

Agora vamos adicionar o driver JDBC para que nossa aplicação consiga se conectar ao Banco de Dados.
Para isso:
Clique com o botão direito em cima do Projeto > Propriedades.
Selecione a opção Bibliotecas e clique no botão Adicionar JARs/pasta.
Vá até o JDBC que baixamos do site do MySQL selecione o arquivo .jar
Clique em OK > OK
134
Pronto. O JDBC já foi adicionado a nossa aplicação. Agora vamos fazer um pouco de código. Nós iremos
fazer toda a conexão com banco de dados direto da classe principal que o NetBeans nos forneceu.
Logicamente essa metodologia não segue as melhores práticas da programação e todo o resto, mas serve
para você ter uma idéia de pelo menos como conectar sua aplicação a uma base MySQL. O código gerado
pelo NetBeans está assim: package mysqlconnection;

public class Main {

public static void main(String[] args) {

//O código vai aqui
}
}

Vamos criar a conexão e vamos fazer um select básico no banco. Abaixo segue o código com a conexão,
com o envio do select e o tratamento de exceção. O código está comentado com o que cada linha está
fazendo:

135
package mysqlconnection;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Main {

public static void main(String[] args) {
String driver = "com.mysql.jdbc.Driver"; //Classe do driver JDBC
String banco = "MeuBD"; //Nome do Banco criado
String host = "localhost"; //Maquina onde está o banco
String str_conn = "jdbc:mysql://" + host + ":3306/" + banco; //URL de conexão
String usuario = "root"; //Usuário do banco
String senha = ""; //Senha de conexão
try {
Class.forName(driver); //Carrega o driver
//Obtém a conexão com o banco
Connection conn = DriverManager.getConnection(str_conn, usuario, senha);
//Cria um statement para podermos mandar um SQL para o banco
Statement stmt = conn.createStatement();
//Mandamos o SQL para o banco e obtemos um ResultSet
String sql = "SELECT * FROM usuarios";
ResultSet rs = stmt.executeQuery(sql);
//Percorrendo o ResultSet e obtendo os valores do banco
while (rs.next()) {
System.out.println(rs.getString("nome"));
System.out.println(rs.getString("email"));
System.out.println(rs.getInt("idade"));
System.out.println("====================================");
}
}
catch (ClassNotFoundException ex) {
System.out.println("Não foi possível carregar o driver.");
ex.printStackTrace();
}
catch (SQLException ex) {
System.out.println("Problema com o SQL");
ex.printStackTrace();
}
}
}
136
Repare que na obtenção dos objetos a partir do ResultSet nós usamos como chave o nome da coluna no
banco de dados. Se estiver tudo certo, já podemos executar nosso código. Para isso faça aperte ou clique
no “Play”. Se tudo deu certo e se você utilizou o esquema de banco fornecido nesse post, a saída para
console será assim:
run:

Ricardo
ricardo@meuemail.com
23
====================================
José
jose@seuemail.com
29
====================================
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

137
CÓDIGO DO SISTEMA “AGENDA DE TELEFONE”

138
139
140
141
MODELO DE BANCO DE DADOS PARA A AGENDA DE TELEFONE

142