Escolar Documentos
Profissional Documentos
Cultura Documentos
de Programação
Orientada a Objetos
Professor: Wilson da Silva Lourenço
1
CONTEÚDO
Definições ................................................................................................................................................ 6
Abstração ................................................................................................................................................. 6
Encapsulamento....................................................................................................................................... 7
Herança ................................................................................................................................................... 7
Polimorfismo ............................................................................................................................................ 8
JAVA ..........................................................................................................................................................13
Conhecendo o ambiente..........................................................................................................................13
Funcionamento .......................................................................................................................................13
Compilando e executando....................................................................................................................14
Convenções ............................................................................................................................................17
Comentários............................................................................................................................................17
Identificadores .........................................................................................................................................18
Variáveis .................................................................................................................................................19
Operadores .............................................................................................................................................19
2
Operadores Relacionais .......................................................................................................................20
Set ..........................................................................................................................................................26
Get ..........................................................................................................................................................26
Is.............................................................................................................................................................26
Arrays .....................................................................................................................................................28
CONTAINERS ............................................................................................................................................35
JFormattedTextField ...................................................................................................................................44
ESCOPO ....................................................................................................................................................46
CHECKBOX ...............................................................................................................................................50
POLIMORFISMO ........................................................................................................................................51
FormattedSample .......................................................................................................................................52
GRID ..........................................................................................................................................................53
NETBEANS ................................................................................................................................................54
Instalando o Netbeans.............................................................................................................................54
JCombobox/JList .................................................................................................................................80
JOptionPane ........................................................................................................................................83
JFileChooser........................................................................................................................................85
JEditorPane .........................................................................................................................................88
Arquitetura ...........................................................................................................................................94
COMPONENTES GRÁFICOS...................................................................................................................106
Eventos .................................................................................................................................................112
ANEXOS ..................................................................................................................................................131
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
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);
}
____________________________________________________________
____________________________________________________________
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.
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.
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 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
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:
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
É 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
COMPILANDO E EXECUTANDO
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.
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
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
OPERADORES
OPERADORES ARITMÉTICOS
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
OPERADORES LÓGICOS
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:
Exemplo while:
21
Exemplo do-while:
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:
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:
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:
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
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:
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):
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:
// 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.
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):
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:
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();
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);
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
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:
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
public, protected e private são escritos explicitamente na instrução para indicar o tipo de acesso.
default não deve ser escrito.
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:
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:
Especifica que somente classes no mesmo pacote podem ter acesso aos atributos e métodos da classe.
Palavra-chave: protected
47
Exemplo:
Especifica que os elementos da classe são acessíveis apenas pela classe que os definiram.
Palavra-chave: private
Exemplo:
RELEMBRANDO:
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
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:
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:
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
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):
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
65
Selecione General Java Application Next
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
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();
JButton: é um botão simples que pode ser criado com ou sem rótulo.
Métodos específicos:
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:
GERENCIADORES DE LAYOUT
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.
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.
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:
77
Após initComponents(), insira o seguinte comando:
setBounds(10,10,300,400);
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)
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:
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 .
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
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().
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();
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:
84
Compile e execute:
No Netbeans basta inserir o texto desejado na propriedade ToolTipText dos Componentes (JLabel,
JTextField, JButton ...).
JFILECHOOSER
85
Abrir (Open)
Salvar (Save)
Exemplo:
Código a ser inserido na ação de um botão “Abrir Arquivo”:
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:
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:
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 :
Compile e Execute
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
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.
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.
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.
93
BANCO DE DADOS NO NETBEANS
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
94
Podemos construir uma aplicação usando o seguinte roteiro:
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();
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);
}
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:
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:
98
Códigos para Alterar:
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)
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 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.
É 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.
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.
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).
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.
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.
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.
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.
118
ITEM 3: PASSO-A-PASSO
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:
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:
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:
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() );
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
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);
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.
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() );
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.
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”);
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
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>.
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.
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();
É 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:
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
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:
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.
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;
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