Material de Apoio de Programao Orientada a Objetos

Professor: Wilson da Silva Loureno

CONTEDO

INTRODUO ORIENTAO A OBJETOS ............................................................................................. 6 Definies ................................................................................................................................................ 6 Abstrao ................................................................................................................................................. 6 Encapsulamento....................................................................................................................................... 7 Herana ................................................................................................................................................... 7 Polimorfismo ............................................................................................................................................ 8 INTRODUO AO JAVA ............................................................................................................................11 O que JAVA? .......................................................................................................................................11 Criando uma APLICAO.......................................................................................................................11 O cdigo fonte .....................................................................................................................................11 Compilando a aplicao .......................................................................................................................11 Informaes Bsicas ...............................................................................................................................12 Variveis e tipos de dados ...................................................................................................................12 JAVA ..........................................................................................................................................................13 Conhecendo o ambiente..........................................................................................................................13 Funcionamento .......................................................................................................................................13 A mquina virtual Java (JVM) ..................................................................................................................13 A plataforma JAVA ..................................................................................................................................14 Primeiro programa: teste.java ..................................................................................................................14 Compilando e executando....................................................................................................................14 Entendendo a nomenclatura do Java ...................................................................................................14 Convenes ............................................................................................................................................17 Comentrios............................................................................................................................................17 Ponto-e-vrgula, blocos e espaos em branco..........................................................................................17 Identificadores .........................................................................................................................................18 Palavras reservadas ................................................................................................................................18 Variveis .................................................................................................................................................19 Declarao de variveis e constantes ..................................................................................................19 Operadores .............................................................................................................................................19 Operadores Aritmticos .......................................................................................................................19 2

Operadores Relacionais .......................................................................................................................20 Operadores Lgicos .............................................................................................................................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 MTODOS ACESSORES: GET E SET .......................................................................................................26 Set ..........................................................................................................................................................26 Get ..........................................................................................................................................................26 Is.............................................................................................................................................................26 ARRAYS E DILOGOS ..............................................................................................................................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 Padro (Default) ......................................................................................................................47 Acesso Pblico (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 Aplicao MDI: ................................................................................................................56 Componentes da Janela em modo de Trabalho ...................................................................................62 3

Trabalhando com componentes ...........................................................................................................63 Telas do NetBeans verso 4.................................................................................................................65 Aplicaes Grficas com Swing ...............................................................................................................70 Gerenciadores de Layout .....................................................................................................................72 Aplicaes Grficas com Swing Construindo Aplicaes 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 Aplicaes Grficas com Swing Componentes Especializados ................................................................83 JOptionPane ........................................................................................................................................83 JFileChooser........................................................................................................................................85 JEditorPane .........................................................................................................................................88 Trabalhando Mltiplos Formulrios - Menus ............................................................................................89 Banco de Dados No NetBeans ................................................................................................................94 Acessando Bancos de Dados ..............................................................................................................94 Arquitetura ...........................................................................................................................................94 Principais Comandos SQL ...................................................................................................................96 Construo de Aplicaes - Acessando um Banco de Dados Access ...................................................96 JDBC no NetBeans ..............................................................................................................................97 COMPONENTES GRFICOS...................................................................................................................106 Usando Componentes Grficos no NetBeans ........................................................................................108 Tarefa 1: A Interface Grfica da Aplicao .........................................................................................112 Eventos .................................................................................................................................................112 Tratamento de Eventos no NetBeans .................................................................................................113 IMPLEMENTANDO COMPONENTES BSICOS 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 cdigo ...............................................................................................................120 Item 5: Exibindo Dados .........................................................................................................................124 CONEXO COM BANCO DE DADOS ......................................................................................................126 Arquitetura JDBC ..................................................................................................................................126 4

Conexo 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 conexo ..................................................................................................................127 Etapa 5 - Criar um Statement .............................................................................................................127 Etapa 6 - Submeter um comando SQL ...............................................................................................128 Etapa 7 - Receber os resultados ........................................................................................................128 CONEXO DO JAVA COM O ORACLE....................................................................................................130 ANEXOS ..................................................................................................................................................131 Configurao do JDK no Windows 7 ......................................................................................................131 Como conectar o Java ao MySQL usando o NetBeans ..........................................................................133 CDIGO DO SISTEMA AGENDA DE TELEFONE .................................................................................138 Modelo de Banco de Dados para a Agenda de Telefone ....................................................................142

INTRODUO ORIENTAO A OBJETOS

A Programao Orientada ao Objeto (POO) pode ser considerada como uma extenso quase natural da Programao Modular; entretanto a sigla POO tem causado certa inquietao entre a comunidade de Informtica, nos ltimos anos. Na verdade, isto no deveria acontecer, uma vez que a POO foi concebida h muito tempo atrs (no inicio da dcada de 70). A sua origem vem da linguagem Simula, concebida na Noruega no incio da dcada de 60, e como o nome indica, foi criada para fazer simulaes; entretanto, seu uso alavancou um conceito que at ento passava "despercebido" pela maioria dos projetistas: a similaridade com o mundo real.

DEFINIES

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 estratgia de jogo, uma poltica de escalonamento em um sistema operacional). Cada objeto ter sua identidade significa que dois objetos so distintos mesmo que eles apresentem exatamente as mesmas caractersticas. Embora objetos tenham existncia prpria no mundo real, em termos de linguagem de programao um objeto necessita um mecanismo de identificao. Esta identificao de objeto deve ser nica, uniforme e independente do contedo do objeto. Este um dos mecanismos que permite a criao de colees de objetos, as quais so tambm objetos em si. Por exemplo, um objeto um formulrio, um boto, 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 ) Mtodos - rotinas disponveis 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 operaes que podem ser executadas sobre o objeto. Objetos com a mesma estrutura e o mesmo comportamento so agrupados em classes. Uma classe uma abstrao que descreve propriedades importantes para uma aplicao e simplesmente ignora o resto. Cada classe descreve um conjunto (possivelmente infinito) de objetos individuais. Cada objeto uma instncia de uma classe. Assim, cada instncia de uma classe tem seus prprios valores para cada atributo. Formalmente, para ser considerada uma linguagem OO, esta precisa implementar quatro conceitos bsicos: abstrao, encapsulamento, herana e polimorfismo

ABSTRAO

considerada como a habilidade de modelar caractersticas do mundo real do problema que o programador esteja tentando resolver. Podemos demonstrar o uso de abstrao facilmente, quando fechamos os olhos e pensamos em uma mesa; esta mesa imaginria provavelmente no vai ser igual outra imaginada por outras pessoas, mas o que importa que todas as pessoas que imaginaram uma mesa colocaram nessa as 6

informaes que para elas so necessrias para a sua funo (de ser uma mesa). No importa se a mesa de trs ps ou quatro, ou se o tampo de vidro, madeira ou mrmore; o que importa que a imagem que idealizamos em nossa cabea de uma mesa e tenha as informaes necessrias para cumprir sua funo. O uso apropriado de abstrao permite que um mesmo modelo conceitual (orientao a objetos) seja utilizado para todas as fases de desenvolvimento de um sistema, desde sua anlise at sua documentao.

ENCAPSULAMENTO

O encapsulamento a base de toda a abordagem da Programao Orientada ao Objeto, isto porque contribui fundamentalmente para diminuir os malefcios causados pela interferncia externa sobre os dados. Partindo desse princpio, toda e qualquer transao feita com esses dados s pode ser feita atravs de procedimentos colocados "dentro" desse objeto, pelo envio de mensagens. Desta maneira, dizemos que um dado est encapsulado quando envolvido por cdigo de forma que s visvel na rotina onde foi criado; o mesmo acontece com uma rotina, que, sendo encapsulada, suas operaes internas so invisveis s outras rotinas. No encapsulamento podemos visualizar a sua utilidade pensando em um vdeo cassete, onde temos os botes de liga-desliga, para frente, para traz, etc. Estes botes executam uma srie de operaes existentes no aparelho, onde so executadas pelos componentes existentes dentro do aparelho (transistores, cabos, motores, etc.) No interessa ao operador saber como o funcionamento interno do equipamento; esta informao s relevante para os projetistas do aparelho. As informaes pertinentes ao usurio do equipamento so as existentes no meio externo (botes, controle remoto) que ativam as operaes internas do equipamento. Desta maneira o aparelho de vdeo cassete pode evoluir com os avanos tecnolgicos, 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 compatveis. Isto ocorre porque a esses programas no interessa saber como o funcionamento interno da classe e sim sua funo, para que ele possa executar, conforme ela evolui, novas funes colocadas sua disposio. O uso do encapsulamento permite que a implementao de um objeto possa ser modificada sem afetar as aplicaes que usam este objeto. Motivos para modificar a implementao de um objeto podem ser, por exemplo, melhoria de desempenho, correo de erros e mudana de plataforma de execuo.

HERANA

Herana um mecanismo que, se for bem empregado, permite altos graus de reutilizao de cdigo. Do ponto de vista prtico, pode ser entendido como sendo um conjunto de instncias criadas a partir de outro conjunto de instncias com caractersticas semelhantes, e os elementos desse subconjunto herdam todas as caractersticas do conjunto original. A idia 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+mtodos) da classe-me; isto torna o mecanismo de herana uma tcnica muito eficiente para construir, organizar e reutilizar cdigo. Por isso, nas linguagens que no suportam esse mecanismo, as classes so criadas como unidades independentes: cada uma com seus

membros concebidos do zero (sem vnculo direto com outras classes), o que torna o processo mais demorado e com cdigos, s vezes, redundantes. Esta capacidade de fatorar as propriedades comuns de diversas classes em uma superclasse pode reduzir dramaticamente a repetio de cdigo em um projeto ou programa, sendo uma das principais vantagens da abordagem de orientao a objetos.

POLIMORFISMO

Na Informtica, e em particular no universo da POO, definido como sendo um cdigo que possui "vrios comportamentos" ou que produz "vrios comportamentos"; em outras palavras, um cdigo que pode ser aplicado vrias classes de objetos. A mesma mensagem enviada a objetos de classes distintas e eles podero reagir de maneiras diferentes. Um mtodo polimrfico aquele que pode ser aplicado vrias classes de objetos sem que haja qualquer inconveniente. o caso, por exemplo, do mtodo Clear em Delphi, que pode ser aplicado tanto classe TEdit como classe TListBox; nas duas situaes o contedo desse objetos so limpos, mesmo pertencendo, ambos, classes distintas. Um exemplo simples dado por um simples moedor de carne. Esse equipamento tem a funo de moer carne, produzindo carne moda para fazer bolinhos. Desse modo, no importa o tipo (classe) de carne alimentada; o resultado ser sempre carne moda, no importa se de boi, de frango ou de qualquer outro tipo. As restries impostas pelo processo esto no prprio objeto, definidas pelo seu fabricante e no pelo usurio do produto. Outro exemplo, a operao move quando aplicada a uma janela de um sistema de interfaces tem um comportamento distinto do que quando aplicada a uma pea de um jogo de xadrez. Um mtodo uma implementao especfica de uma operao para certa classe. Polimorfismo tambm implica que uma operao de uma mesma classe pode ser implementada por mais de um mtodo. O usurio no precisa saber quantas implementaes existem para uma operao, ou explicitar qual mtodo deve ser utilizado: a linguagem de programao deve ser capaz de selecionar o mtodo correto a partir do nome da operao, classe do objeto e argumentos para a operao. Desta forma, novas classes podem ser adicionadas sem necessidade de modificao de cdigo j existente, pois cada classe apenas define os seus mtodos e atributos. Abaixo temos um exemplo que mostra a criao da superclasse Mamfero e de trs subclasses: Homem, Co e Gato. Usando o conceito de herana, o mtodo Comunicar (originrio da classe Mamfero) herdado pelas subclasses; e atravs do conceito de polimorfismo, esse mtodo redefinido facilmente para as subclasses, (falar para o homens, latir para os ces e miar para os gatos) mostrando o quanto se ganha em produtividade na criao de sistemas com a reutilizao de cdigo (vide Figura 1). O exemplo criado foi idealizado com a necessidade de se projetar um conjunto de classes de fcil entendimento e que permitisse o uso dos conceitos de herana e polimorfismo, sendo este exemplo tirado do mundo real, originando a classe Mamfero. Primeiramente buscou-se identificar elementos em comum s classes Homem, Co e Gato, para que estes fossem adicionados classe Mamfero, que passou a ser a superclasse do exemplo.

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

____________________________________________________________

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

10

INTRODUO AO JAVA

O QUE JAVA?

Java uma linguagem de programao orientada a objetos desenvolvida pela Sun Microsystems. Modelada depois de C++, a linguagem Java foi projetada para ser pequena simples e portvel a todas as plataformas e sistemas operacionais, tanto o cdigo fonte como os binrios. 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 execuo este byte-code interpretado por uma mquina virtual instalado na mquina. Para portar Java para uma arquitetura especfica, basta instalar a mquina virtual (interpretador). Alm de ser integrada Internet, Java tambm uma excelente linguagem para desenvolvimento de aplicaes em geral. D suporte ao desenvolvimento de software em larga escala.

CRIANDO UMA APLICAO

Para comear, criaremos uma simples aplicao em Java: a clssica Hello World! , o exemplo que todos os livros de linguagens usam.

O CDIGO FONTE Como todas as linguagens de programao, o cdigo fonte ser criado em um editor de texto ASCII puro. No Windows, notepad ou dosedit tambm servem. A seguir, o cdigo da aplicao Hello World! (arquivo: HelloWorld.java):

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

COMPILANDO A APLICAO Para compilar a aplicao, basta digitar o comando no prompt do DOS: javac HelloWorld.java Este comando vai gerar o arquivo HelloWorld.class, que o byte-code da aplicao. Para executar o byte-code basta digitar java HelloWorld 11

INFORMAES BSICAS

VARIVEIS E TIPOS DE DADOS Variveis so alocaes de memria nas quais podemos guardar dados. Elas tm um nome, tipo e valor. Toda vez que necessite usar de uma varivel voc precisa declar-la e s ento poder atribuir valores a mesma.

DECLARANDO VARIVEIS As declaraes de variveis consistem de um tipo e um nome de varivel: como segue o exemplo:

int idade; String nome; boolean existe;

Os nomes de variveis podem comear com uma letra, um sublinhado ( _ ), ou um cifro ($). Elas no podem comear com um nmero. Depois do primeiro caractere pode-se colocar qualquer letra ou nmero.

TIPOS DE VARIVEIS Toda varivel deve possuir um tipo. Os tipos que uma varivel pode assumir uma das trs coisas a seguir:

Uma das oito primitivas bsicas 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 bsicos so: Inteiros Nmeros de ponto-flutuante Caracteres Booleanos (verdadeiro ou falso)

12

JAVA

CONHECENDO O AMBIENT E

O usurio deve instalar o JDK apropriado para o seu ambiente computacional. A ltima verso homologada encontra-se em: www.java.sun.com/downloads Deve-se ainda, configurar as variveis de ambiente: Colocar o c:\j2sdk1.4.2_06\bin no Path Colocar o diretrio corrente . no CLASSPATH

FUNCIONAMENTO

A MQUINA VIRTUAL JAVA (JVM)

uma mquina imaginria que implementada pela emulao de um software sobre uma mquina real. Sua funo prover uma especificao de plataforma de hardware no qual todos os cdigos Java so compilados. Essa especificao faz com que os programas Java sejam independentes da plataforma do usurio do sistema, porque toda compilao feita para uma mquina virtual.

13

A PLATAFORMA JAVA

PRIMEIRO PROGRAMA: T ESTE.JAVA

COMPILANDO E EXECUTANDO Crie o arquivo acima em um diretrio qualquer e salve com o nome: teste.java Chame o compilador Java para este arquivo usando o MS DOS: C:\> javac teste.Java Seu diretrio deve ter recebido um novo arquivo aps essa compilao: teste.class Chame o interpretador Java para este arquivo (omita a extenso .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 incio da declarao de uma classe. public um especificador, por enquanto guarde public class como o incio da declarao de uma classe. Toda classes sero declaradas assim por enquanto. teste o nome dado a esta classe. O abre chaves marca o incio das declaraes da classe que so os atributos e mtodos. Esta classe s possui uma declarao, a do mtodo main. Note que um mtodo s pode ser declarado {internamente} a classe a qual pertence. Desta forma, todo pedao de cdigo em Java deve pertencer ao abre chaves, fecha chaves da definio 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 mtodo que indica que este acessvel externamente a esta classe (para outras classes que eventualmente seriam criadas), no se preocupe com ele agora, apenas declare todos os mtodos como public static outro qualificador ou specifier, que indica que o mtodo deve ser compartilhado por todos os objetos que so criados a partir desta classe. Os mtodos static podem ser invocados, mesmo quando no foi criado nenhum objeto para a classe. Para tal deve-se seguir a sintaxe: <NomeClasse>.<NomeMetodoStatic>(argumentos);

Retornaremos a esta explicao mais tarde, por hora voc precisa saber que o mtodo main precisa ter essa qualificao 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 funo, quando a funo no retorna nenhum valor ela retorna void, uma espcie de valor vazio que tem que ser especificado. main um nome particular de mtodo que indica para o compilador o incio do programa. dentro deste mtodo e atravs das iteraes entre os atributos, variveis e argumentos visveis nele que o programa se desenvolve. (String args[]) o argumento do mtodo main e por conseqncia do programa todo, ele um array de Strings que formado quando so passados ou no argumentos atravs da invocao 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 no conhece C ou C++, eles podem ser entendidos como algo semelhante ao BEGIN END de Pascal, ou seja: delimitam um bloco de cdigo. System.out.println("Meu primeiro teste!"); chamada do mtodo 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 cdigo como o comando para imprimir mensagens na tela, onde o argumento que vem entre aspas a String a ser impressa. EXERCCIOS

1) Escreva o mesmo exemplo do teste.java utilizando recursos grficos do Swing. Para tal inclua no incio a instruo: import javax.swing.JOptionPane; E no lugar do System.out escreva a seguinte instruo: JOptionPane.showMessageDialog(null, Meu Primeiro teste! ); RESOLUO 1:

2) Escreva uma classe ebico.java que receba da linha de comando dois parmetros uma String com o nome da pessoa e um int com a idade da pessoa. Mostre na sada padro com System.out ou JOptionPane a frase Bom dia +args[0]+ voc tem +args[1]+ anos de idade);

16

RESOLUO 2:

CONVENES

Abaixo temos algumas convenes que so usadas a fim de padronizar o desenvolvimento em Java e evitar qualquer tipo de problema: Variveis e mtodos iniciam com letras minsculas. Classes iniciam com letras maisculas Nome composto: utilizar letras maisculas para as iniciais das palavras que seguem a primeira Letras maisculas para as constantes

COMENTRIOS

H trs formas de inserir comentrios: // comentrios em uma linha /* comentrios em uma ou mais linhas */ /** documentando comentrios */ Quando colocado imediatamente antes da declarao (de uma funo ou varivel), indica que o comentrio poder ser includo automaticamente em uma pgina html (gerado pelo comando javadoc).

PONTO-E-VRGULA, BLOCOS E ESPAOS EM BRANCO

Os comandos sempre so terminados com ponto-e-vrgula. Um bloco delimitado por chaves { e } e constitui um comando composto. O espao em branco permitido entre elementos do cdigo fonte, em qualquer lugar e em qualquer quantidade. So considerados espao em branco o espao, o tab (\t) e mudana de linha (\n).

17

{ int x; x = 23 * 54; }

IDENTIFICADORES

O identificador comea com uma letra, hfen-caixa-baixa (_), ou smbolo dlar ($). Os subsequentes caracteres podem conter dgitos. Caracteres maisculo e minsculo so diferentes e no tem tamanho mximo. Identificadores vlidos: identifier userName User_name userName _sys_var1 $change

Utilizar somente caracteres ASCII (porque o Unicode pode suportar caracteres diferentes com a mesma representao), no utilizar palavra reservada e evitar nome iniciados com $ (por causa das variveis de ambiente do Sistema Operacional).

PALAVRAS RESERVADAS

Abaixo temos uma tabela com as palavras reservadas, ou seja, palavras usadas exclusivamente pela linguagem de programao e que no podem ser usadas para nomear variveis, constantes, classes, etc.:

abstract boolean break byte case catch char class continue def ault

do double else extends f alse f inal f inally f loat this if

implements import instanceof int interf ace long native new f or package

18

Nota: atualmente as seguintes palavras reservadas no so utilizadas: cast, const, future, generic, goto, inner, operator, outer, rest, var.

VARIVEIS

Tipo Primitivo Boolean char byte short int long float double void

Tamanho 1-bit 16-bit 8-bit 16-bit 32-bit 64-bit 32-bit 64-bit

Wrapper Boolean Character Byte Short Integer Long Float Double Void

DECLARAO DE VARIVEIS E CONSTANTES int x, y; // declarando variveis inteiras x = 6; y=1000; // atribuindo valores a varivel float z = 3.414f; // ponto flutuante double w = 3.1415; // declarando e atribuindo double boolean truth = true; // booleano char c; // declarando varivel caracter c = A; // atribuindo um valor char final int MAX = 2; // Constantes final int CONSTANTE; CONSTANTE = 1; // somente admite uma atribuio

OPERADORES

OPERADORES ARITMTICOS

Operador + * / %

Uso op1 + op2 op1 - op2 op1 * op2 op1 / op2 op1 % op2

Descrio Retorna a soma de op1 e op2. Retorna a subtrao de op1 por op2. Retorna a multiplicao de op1 por op2. Retorna a diviso de op1 por op2. Retorna o resto da diviso de op1 por op2.

19

Operador + ++ ++ ---

Uso +op -op op++ ++op op---op

Descrio Promove op para int, se for byte, short ou char. Retorna op aritmeticamente negado. Retorna o valor de op, depois o incrementa de 1. Incrementa op de 1,depois retorna o valor. Retorna o valor de op, depois o decrementa de 1. Decrementa op de 1,depois retorna o valor.

OPERADORES RELACIONAIS

Operador > >= < <= == !=

Uso op1 > op2 op1 >= op2 op1 < op2 op1 <= op2 op1 == op2 op1 != op2

Retorna verdadeiro se op1 for maior que op2. op1 for maior que ou igual ao op2. op1 for menor que op2. op1 for menor que ou igual ao op2. op1 igual ao op2. op1 diferente do op2.

OPERADORES LGICOS

Operador && || ! & | !=

Uso op1 && op2 op1 || op2 ! op op1 & op2 op1 | op2 op1 != op2

Retorna verdadeiro se op1 e op2 forem true. S avalia op2, se op1 for true. op1 ou op2 for true (ou ambos).S avalia op2, se op1 for false. op for false. op1 e op2 forem true. Sempre avalia op1 e op2. op1 ou op2 for true (ou ambos). Sempre avalia op1 e op2. op1 diferente do op2.

CONTROLE DE FLUXO

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

20

CONTROLE DE FLUXO - IF if (expresso booleana) comando ou bloco else comando ou bloco Exemplo:

CONTROLE DE FLUXO - W HILE while (expresso booleana) comando ou bloco do comando ou bloco while(expresso booleana); Exemplo while:

21

Exemplo do-while:

CONTROLE DE FLUXO - FOR for (expresso inicial; expresso booleana; expresso de iterao) comando ou bloco expresso inicial; while (expresso booleana) { comando ou bloco expresso de iterao; } 22

Exemplo:

CONTROLE DE FLUXO - SW ITCH

switch (expresso1) { case expresso2: comando ou bloco break; ... case expresso n: comando ou bloco break; default: comando ou bloco break; } Exemplo:

23

EXERCCIO 3) Crie uma classe java com o nome ValorChar que mostre na tela os chars correspondentes aos nmeros de 32 a 150. Dica para resoluo: utilize a seguinte notao para transformar um int em char ( por enquanto no se preocupe com o significado desta notao): (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). RESOLUO:

24

25

MTODOS ACESSORES: GET E SET

Como visto anteriormente, o encapsulamento "protege" os atributos ou mtodos dentro de uma classe, portanto devemos prover meios para acessar tais membros quando eles so particulares, ou seja, quando possuem o modificador private. O que torna isso possvel a criao de mtodos. Em programao orientada a objetos, esses mtodos so chamados de mtodos acessores ou getters e setters, pois eles provm acesso aos atributos da classe, e geralmente, se iniciam com get ou set, da a origem de seu nome. Na verdade, no h nada de diferente entre os mtodos comuns e os mtodos acessores. A nica importncia est no fato da orientao a objeto. Pois, sempre que formos acessar um membro em Java usaremos get ou set.

SET

Nomeamos um mtodo acessor com set toda vez que este mtodo for modificar algum campo ou atributo de uma classe, ou seja, se no criarmos um mtodo acessor set para algum atributo, isso quer dizer que este atributo no deve ser modificado. Portanto, como o valor de um atributo da classe ser modificado, no necessrio que este mtodo retorne nenhum valor, por isso, os mtodos setters so void. Porm, obrigatoriamente, eles tem que receber um argumento que ser o novo valor do campo.

GET

Nomeamos um mtodo acessor com get toda vez que este mtodo for verificar algum campo ou atributo de uma classe. Como este mtodo ir verificar um valor, ele sempre ter um retorno como String, int, float, etc. Mas no ter nenhum argumento.

IS

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

Levando em considerao as informaes acima, vamos criar uma classe de exemplo TV:

26

27

ARRAYS E DILOGOS

ARRAYS

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

int valores[] = new int[20];

No exemplo acima, ser criado um array com 20 posies, numeradas de 0 a 19. Cada posio pode ser acessada individualmente, utilizando o operador [ ]. possvel tambm inicializar automaticamente um array com valores determinados:

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

Este tipo de inicializao tambm funciona para Strings:

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

Observe que uma vez inicializado, o tamanho de um array no pode ser alterado! Arrays so inteligentes: sabem seu tamanho. Isso fundamental, pois essencial haver uma maneira de descobrir o espao solicitado para o array:

Int TAM_array = nomes.length;

A linguagem Java oferece diversas formas de interao com o usurio, a grande maioria em janelas. Para evitar a criao de uma interface completa, pode-se utilizar as chamadas caixas de dilogo. Se olharmos com ateno na documentao da API, observaremos que as classes esto agrupadas em pacotes (packages). Os pacotes servem para reunir um conjunto de classes com funo semelhante. Ento, se quisermos utilizar uma classe especfica, devemos informar ao compilador Java onde (em qual pacote) essa classe deve ser encontrada.

28

A classe que implementa as caixas de dilogo, JOptionPane, se encontra no pacote javax.swing, que contm diversas outras classes para interface com o usurio. Para utilizar essa classe, utiliza-se o comando import:

import javax.swing.JOptionPane;

Observao: algumas classes como String, System, Integer e outras so parte de um pacote especial, denominado java.lang. Esse pacote nunca precisa ser importado, pois so as classes primitivas que compem a linguagem Java. A classe JOptionPane oferece diversos mtodos, para criar diversos tipos de caixas de dilogo. Por exemplo, se quisermos exibir uma caixa de mensagem para informar o usurio, usamos o mtodo showMessageDialog(...):

O primeiro parmetro por enquanto deve ser null. Repare que o mtodo showMessageDialog(...) um mtodo esttico (de classe) de JOptionPane! Por esse motivo, no necessrio instanciar objetos a partir de JOptionPane. Observe tambm a chamada para o mtodo System.exit(0): este mtodo geralmente utilizado para encerrar um programa que utilize interface grfica.

H outra forma de chamada para o mtodo showMessageDialog, a qual permite melhorarmos o visual da caixa de mensagem:

29

O terceiro parmetro o ttulo que ser exibido na janela (ao invs de "Message") e o quarto parmetro controla o cone apresentado esquerda da janela: JOptionPane.PLAIN_MESSAGE - nenhum cone JOptionPane.ERROR_MESSAGE - cone de erro JOptionPane.INFORMATION_MESSAGE - cone de informao JOptionPane.WARNING_MESSAGE - cone de aviso JOptionPane.QUESTION_MESSAGE - cone de interrogao

Existe um mtodo para exibir uma caixa de entrada: showInputDialog. Esse mtodo retorna sempre a String que foi digitada pelo usurio. Exemplo:

Assim como no mtodo showMessageDialog, h uma variao mais completa:

30

Se voc estiver curioso, consulte a documentao da API Java. H MUITAS outras variaes, tanto para entrada como para sada. Voc deve estar se perguntando: mas eu vou fazer programas baseados somente em caixas de dilogo ? Isso no meio chato para o usurio? Sim, com certeza! A interao baseada em dilogos til quando queremos informar o usurio de uma situao urgente ou quando se deseja chamar a ateno, mas no deve ser utilizada excessivamente. Normalmente o que temos uma interface grfica o tempo todo na tela, na forma de uma ou mais janelas com diversos componentes, como botes, listas, etc. Como ainda cedo para fazermos isso, est disponvel uma classe para exibio 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 diretrio onde esto as classes do seu projeto atual. Se voc quiser olhar este arquivo, fique vontade. Note que no sero dadas explicaes sobre o contedo deste arquivo, pelo menos por enquanto. Coisas da vida, mas para o bem de vocs. A utilizao extremamente simples: crie uma instncia de JanelaBasica, utilizando o seguinte construtor:

O primeiro parmetro o ttulo da janela que ser exibida. A classe oferece dois mtodos para a exibio de mensagens: print(...) e println(...), cujas utilizaes so bvias... Exemplo: criaremos um programa muito til para somar dois nmeros. A entrada de dados ser realizada atravs de caixas de dilogo.

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 grfica no 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, no seria possvel enxergar a resposta a tempo.

34

CONT AINERS

A maioria das aplicaes grficas do mundo tm, em algum momento, algum formulrio para entrada de dados. Vamos criar ento um formulrio bem simples utilizando Swing. A API do Swing traz uma srie de componentes visuais prontos para uso. So campos de texto, botes, checkboxes, labels, tabelas, rvores e muitos outros. Para comear nosso formulrio 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 continer (Container) que administrar o agrupamento e exibio dos mesmos. Usaremos o container mais comum, um Jpanel (algo como um painel de componentes). Atravs de seu mtodo 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 formulrio simples, precisamos colocar nosso Jpanel em uma janela. Usaremos a classe JFrame, que representa uma janela simples.

// Criamos um JFrame passando o ttulo da janela JFrame frame = new JFrame("Meu primeiro formulrio");

// Adicionamos nosso JPanel frame.add(panel); 35

// Preparamos o JFrame para exibio frame.pack(); frame.setVisible(true);

O mtodo 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 visvel ou no. Vamos apenas adicionar um ltimo comando que indica ao nosso frame que a aplicao deve ser terminada quando o usurio fechar a janela.

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

No exemplo completo abaixo, colocamos todas as variveis como atributos e criamos um mtodo chamado montaFormulario com todo o cdigo explicado antes. No mtodo main, criamos um novo Formulrio e chamamos o mtodo montaFormulario():

36

Ao rodar este programa, teremos a seguinte tela para digitao do nome:

O formulrio anterior at que interessante para comear a aprender Swing, mas ele totalmente intil, no faz nada. Queremos ser capazes de recuperar o valor digitado pelo usurio para efetuar alguma operao (salvar no banco de dados, exibir, enviar via rede, mandar um email etc.). Para fazermos efetivamente alguma coisa, trabalhamos com eventos que so disparados pelo usurio. O Swing possui uma forma muito elegante de trabalhar com eventos (atravs de interfaces). O usurio pode disparar eventos ao digitar, ao clicar, ao passar o mouse e muitas outras situaes. No nosso formulrio, usaremos um boto (componente) que, quando clicado pelo usurio (evento), disparar um mtodo (tratador/handler). Neste mtodo, vamos recuperar o texto digitado pelo usurio e efetuar alguma ao. O componente Swing que representa um boto o Jbutton. Precisamos criar um boto e coloc-lo no nosso container (o JPanel):

// cria o JButton passando o texto do boto JButton button = new JButton("Exibir"); // adiciona o boto ao JPanel panel.add(button);

Isso acrescentar o boto ao formulrio, mas como disparar um mtodo quando o boto for clicado? O Swing nos traz o conceito de Listeners (ouvintes), que so interfaces que implementamos com mtodos para serem disparados por eventos. No nosso caso, para fazer um mtodo disparar ao clique do boto, usamos a interface ActionListener. Essa interface nos d um mtodo actionPerformed:

public void actionPerformed(ActionEvent e) { // implementao aqui... }

Vamos fazer ento nossa prpria classe formulrio implementar essa interface e esse mtodo. Queremos, quando o boto for clicado, pegar o texto digitado pelo usurio e exibir na tela (vamos usar o JOptionPane para isso). Nosso mtodo 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 ao (esse ActionListener) deve ser disparado quando o boto for clicado. Fazemos isso atravs do mtodo addActionListener chamado no boto. Ele recebe como argumento um objeto que implementa ActionListener (no nosso caso, o prprio Formulrio, o this):

button.addActionListener(this);

O cdigo final de nosso formulrio deve estar assim:

38

Ao rodar esse programa, voc ver nosso formulrio com um label, um campo de texto e um boto. Depois de digitar algo, ao clicar no boto, 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 so adicionados do lado direito? Se redimensionarmos a tela (teste) os elementos fluem para a linha de baixo, por qu? Essas e outras perguntas so respondidas pelo Layout Manager, o gerenciador de layout do Swing. O Java vem com uma srie de Layouts diferentes, que determinam como os elementos sero dispostos na tela, seus tamanhos preferenciais, como eles se comportaro quando a janela for redimensionada e muitos outros aspectos. Ao escrever uma aplicao Swing voc deve indicar qual o Layout Manager que deseja utilizar. Por padro, 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. Poderamos usar outro Layout Manager como o GridLayout, por exemplo. Nossa aplicao ficaria da seguinte forma:

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

H uma srie de Layout Managers disponveis no Java, cada um com seu comportamento especfico. H inclusive Layout Managers de terceiros (no oficiais do Java) que voc pode baixar; o projeto Jgoodies, por exemplo, tem um excelente Layout Manager otimizado para trabalhar com formulrios, o FormLayout. Para saber mais sobre Layout Managers, quais so e como usar cada um deles, consulte a documentao do Swing.

40

LOOK AND FEEL

Look-and-Feel (ou LaF) o nome que se d cara da aplicao (suas cores, formatos e etc.). Por padro, o Java vem com um lookandfeel prprio que se comporta exatamente da mesma forma em todas as plataformas suportadas. Mas s vezes esse no o resultado desejado. Quando rodamos nossa aplicao no Windows, por exemplo, bastante gritante a diferena em relao ao visual das aplicaes nativas. Por isso possvel alterar qual o lookandfeel a ser usado em nossa aplicao. Alm do padro do Java, o JRE 5 da Sun ainda traz LaF nativos para Windows e Mac OS, alm do Motif e GTK. E, fora esses, voc ainda pode baixar diversos LaF na Internet ou at desenvolver o seu prprio. Veja esses screenshots da documentao do Swing mostrando a mesma aplicao rodando com 4 LaF diferentes:

Para saber mais:

1) Consultar o javadoc do Swing pode no 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 Funcionrio. Classe funcionrio:

MODIFICADORES DE ACESSO

H quatro diferentes tipos de modificadores de acesso: public private protected 46

default

public, protected e private so escritos explicitamente na instruo para indicar o tipo de acesso. default no deve ser escrito.

ACESSO PADRO (DEFAULT)

Especifica que os elementos da classe so acessveis somente aos mtodos internos da classe e s suas subclasses. No h palavra-chave para o modificador default; sendo aplicado na ausncia de um modificador de acesso

Exemplo:

ACESSO PBLICO (PUBLIC) Especifica que os elementos da classe so acessveis seja internamente e externamente classe. Qualquer objeto que interage com a classe pode ter acesso aos elementos pblicos da classe. Palavra-chave: public

Exemplo:

ACESSO PROTEGIDO (PROTECTED) Especifica que somente classes no mesmo pacote podem ter acesso aos atributos e mtodos da classe. Palavra-chave: protected

47

Exemplo:

ACESSO PARTICULAR (PRIVATE) Especifica que os elementos da classe so acessveis apenas pela classe que os definiram. Palavra-chave: private

Exemplo:

RELEMBRANDO:

Encapsulamento: Na OO, encapsulamento o mecanismo utilizado para disponibilizar mtodos que operam sobre os dados e que protegem o acesso direto indevido aos atributos de uma instncia fora da classe onde estes foram declarados. Esta proteo consiste em se usar modificadores de acesso mais restritivos sobre os atributos definidos na classe e fornecendo mtodos que alteram os valores destes atributos de alguma forma. O encapsulamento ajuda a prevenir o problema de interferncia externa indevida sobre os dados de um objeto, como objetos que possam alterar os dados de outros objetos indevidamente. Mtodos de acesso (get): Mtodos de acesso so usados para ler valores de atributos de objeto ou de classe. O mtodo de acesso recebe o nome de get<NomeDoAtributo> e retorna um valor.

48

Mtodos modificadores (set): Para que outros objetos possam modificar os nossos dados, disponibilizamos mtodos que possam gravar ou modificar os valores dos atributos de objeto ou de classe. Chamamos a estes mtodos modificadores. Este mtodo 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 grficos. Para trabalhar com o NetBeans necessrio ter instalado, anteriormente em sua mquina uma das verses do JDK (Java), preferencialmente uma verso igual ou superior a J2SDK1.3.1.

INSTALANDO O NETBEANS

No site http://java.sun.com/ , faa tambm o download do NetBeans, caso no tenha um CD de instalao. Aps o download, d um duplo clique no cone criado e siga os passos mantendo os padres de instalao. Segue como exemplo algumas ilustraes da instalao da verso 3.5.1, a verso 4.0 segue o mesmo padro:

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 instalao/ SO/ Nmero de vezes que o mesmo j tenha sido executado:

CRIANDO UMA APLICAO MDI: Composta de: Passos: 1 - Clique no menu File New: ser exibida uma tela como esta: Um Formulrio principal Um Menu

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 aplicao composta de um formulrio com um menu e que aceita a abertura de outros formulrios 4 - Clique no boto NEXT:

57

5 - D um nome para o seu Aplicativo e no Campo Folder entre com um nome que ser a pasta onde a aplicao ficar armazenada - Package. Clique no boto Create Next:

6 - Ser mostrada uma tela informando o nome da Aplicao e o nome do Package criado, a superclasse que ser estendida e as classes a serem implementadas. No mude as opes padro, clique no boto Next:

58

7 - Clique no boto Next:

59

8 - Clique no boto Next:

9 - Clique no boto Finish:

60

A IDE abrir uma tela como a que se segue. O NetBeans trabalha com vrias mini-telas com finalidades especificas, todas de forma integradas a janela principal, a barra de menu. Caso queira aumentar ou diminuir a rea de visualizao 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 formulrio 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 execuo da aplicao o formulrio / janela abre exibindo apenas o menu, isto porque no 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 aplicao parecida com a seguinte Tela no modo formulrio. (Lembre-se que possvel alternar entre as telas de cdigo e formulrio clicando no menu View e selecione Form Editor/Source Editor):

TRABALHANDO COM COMPONENTES Na janela no canto superior direito, que mostra os componentes da aplicao, clique o Boto direito do mouse sobre BorderLayout e selecione Set Layout AbsolutLayout Esta mesma operao pode ser efetuada clicando-se com o boto direito do mouse sobre a rea do Formulrio e selecionando SetLayout AbsolutLayout. necessrio modificar o Layout para que se possa colocar os componentes (botes, Labels, etc.) na posio desejada, isto porque o Formulrio (JFrame/Frame) quando criado tem como padro 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 so selecionados, clique no correspondente ao JLabel e clique no Formulrio:

Na Janela Propriedades clique em Text e insira o texto que deseja que aparea no JLabel

Insira outros componentes e mude suas propriedades realizando experincias, compilando e executando, para visualizar os resultados

64

TELAS DO NETBEANS VERSO 4

Tela de Inicializao/Abertura

Criando uma Aplicao: - primeiro necessrio 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 Boto Finish. Insira os componentes desejados.

68

Compile e Execute: Menu Build Compile Para executar Menu Run Run Other

69

APLICAES GRFICAS COM SW ING

Nova famlia de componentes com funcionalidade ampliada e grande capacidade de configurao. O seu propsito permitir a criao de interfaces versteis e sofisticadas. Surgiu em 1997 com a JFC ( Java Foundation Classes), com o Java 2, que engloba: Componentes Swing Compatibilidade com mltiplas Look and Feel Biblioteca de acessibilidade monitores e teclados especiais Biblioteca Java 2D Compatibilidade com Drag and Drop

70

Principais componentes:

Os seus componentes so semelhantes ao da AWT (Abstract Window Toolkit), pois o modelo de eventos o mesmo. Diferenas: Componentes Swing so mais flexveis e mais numerosos No utilizam cdigo nativo, seus nomes iniciam com um J A base para uma aplicao o JFrame ou JWindow ( janela) ou a classe JApplet (miniapplicativos). JFrame no um mero container, mas um painel especial que agrega trs outros componentes em camadas Destes o que nos interessa o ContentPane (painel de contedo), onde vamos inserir os demais componentes: Container conteudo= getContePane();

JLabel: rtulo de texto. Mtodos especficos: String getText() retorna o texto do label void setText(String lbl) ajusta o texto do label para lbl

JButton: um boto simples que pode ser criado com ou sem rtulo. Mtodos especficos: String getText() retorna o label(etiqueta) do boto void setText(String etiq) ajusta label do boto para o contedo de etiqueta

JTexField e JTextArea TextField: caixa de entrada de texto, possibilita a entrada e a edio de uma linha de texto. TextArea: caixa de entrada de texto com mltiplas linhas. Exibe barra de rolagem horizontal e vertical. Principais mtodos: 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 exibio de uma lista de itens que no podem ser editados diretamente pelo usurio. JCombobox: implementa uma lista de itens em que um nico item selecionado exibido. Principais mtodos:

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

Mtodos 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 posio dos componentes na janela grfica do programa, ou seja determinar onde os componentes ir ficar guiando a maneira como os elementos de interface sero 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 necessrio.

b) BorderLayout: o Padro: 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 painis) compartilhando o mesmo espao de apresentao. Funciona como uma pilha de cartas onde apenas uma fica visvel. Cria-se um Painel fixo de Controle e um genrico (CardLayout) para conter outros painis

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 flexvel dos gerenciadores de layout, permite colocar componentes em grades de colunas, sendo possvel um componente ocupar mais de uma coluna ao mesmo tempo. As linhas tambm no precisam necessariamente ter os mesmos tamanhos, ou seja, voc pode configurar diferentes larguras e alturas de acordo com a necessidade. No entanto, o mais difcil de ser implementado.

APLICAES GRFICAS COM SW ING CONSTRUINDO APLICAES COM O NETBEANS

UTILIZANDO JLABEL, JTEXTFIELD E JBUTTON COM O NETBEANS

1. Crie uma aplicao para somar os valores de duas Notas Fiscais a serem informados pelo usurio: Nesta Aplicao utilizaremos dois JTextField (onde o usurio ir digitar os valores) um JLabel (mostrar o resultado da soma) e um boto 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 Boto Next

Na nova janela que se abre Digite JCalculadora" Clique no Boto 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 contrrio o mesmo no executar corretamente. O Null Layout no um gerenciador de Layout, mas corresponde situao em desativado uso dos gerenciadores, neste caso a posio dos componentes explicitamente definida atravs de mtodos especficos que a ferramenta se encarrega de manipular, mas os mesmo no vale para o Formulrio (Frame/JFrame), onde se faz necessrio a utilizao do mtodo setBounds: Ex: setBounds(10,10,300,400); // abre o tela na posio largura 10, altura 10, com um largura de 300 e altura 400.

Na janela, no canto superior direito, Clique com o boto direito do mouse sobre JFrame setLayout clique em NullLayout

Na janela do Centro do vdeo, embaixo da Aba Swing , existem vrios 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 cdigo no boto para efetuar a soma ( pegar os nmeros e som-los) D um Duplo clique no boto e na janela de cdigo que aparece digite:

76

Aps digitar os comandos o arquivo de cdigo dever ficar da seguinte forma:

Observe que os nomes dos componentes (jLabel3) comeam com letras minsculas. Parte do Cdigo com a declarao dos componentes criados:

A parte do Cdigo que estiver na cor azul no aceita modificaes. 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 localizao e tamanho da janela (setBounds(posX,posY,Largura,Altura)), procure a seguinte linha de cdigo: 77

Aps initComponents(), insira o seguinte comando: setBounds(10,10,300,400);

Aps o comando o arquivo de cdigo ficar desta forma:

Se precisar voltar para o modo Form Editor clique no Menu View Form Editor ou Crt+8 Para ir para o cdigo 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 boto Diminuir e insira o seguinte cdigo:

78

Repita o processo nos outros botes modificando apenas a operao matemtica. D um duplo clique no boto 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 extenso 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 aplicao, voc dever incluir no seu projeto o respectivo pacote, seno na execuo 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 contrrio o mesmo aparecer mostrando somente a barra de titulo. OBS2: Para fins de agilizar a construo 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 aplicao para informar qual a forma de pagamento selecionada pelo usurio: Cheque, Carto 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 boto Finish Modifique o Layout para AbsoluteLayout Clique no Form e modifique a propriedade Title do Form para Forma de Pagamento Clique no stimo cone JCombobox" e clique no Form, na Janela Propriedades clique em Model clique no Boto ... .

80

Na janela que se abre em Item digite: cheque e clique no boto Add , digite: carto e clique no boto Add , digite dinheiro e clique no boto Add , clique no boto 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 cdigo. Para saber qual a opo selecionada utilize o Mtodo: Object getSelectedItem(). D um duplo clique no boto Escolher : String S= (String) jComboBox1.getSelectedItem();//converte em String jLabel1.setText("A opo escolhida foi: " + S); //exibe opo no Jlabel 81

Compile (F9) e Execute (F6). Se desejar tambm possvel saber o ndice: getSelectedIndex() A utilizao do JList idntica a vista a cima, basta substituir o mtodo getSelectedItem(), por getSelectedValue().

UTILIZANDO JRADIOBUTTON COM O NETBEANS b) Criar uma aplicao para mostrar o tipo de motor (1.0/1.6/2.0) escolhido pelo usurio 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 seleo de apenas uma opo 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 opo Motor 1.6 e Motor 2.0 Insira um JLabel, Text: Opo Escolhida , no Form e um JButton, Escolher

Para saber qual a opo esta marcada devemos utilizar o Mtodo boolean isSelected(), que devolve true ou false. D um duplo clique no boto para inserir o cdigo:

82

Para saber qual o Texto exibido pelo JRadioButton basta utilizar o Mtodo: String getText().

Ex: String s=jRadioButton1.getText();

APLICAES GRFICAS COM SW ING COMPONENTES ESPECIALIZADOS

JOPTIONPANE

Janelas de dialogo para informar ou solicitar confirmao de operaes ou efetuar a entrada direta de valores: Mensagens Entrada de Texto Janelas de Confirmao

83

Exemplos:

Nas IDE como NetBeans possvel inserir um objeto visual, mas no possvel controlar as aes dos respectivos botes. Se quiser utiliz-los no Netbeans, insira-os dentro de um mtodo actionPerformed de um JButton. Exemplo: - Criar um Programa contendo um boto que ao ser pressionado exiba informaes 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 cdigo:

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 atravs do import. Procure no cdigo o comando que cria a classe, que est no incio do programa: public class Mensagem extends javax.swing.JFrame { Antes deste comando insira o cdigo: 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 seleo de arquivos: 85

Abrir (Open) Salvar (Save)

Exemplo: Cdigo a ser inserido na ao de um boto Abrir Arquivo:

Classe File: suporte para tratamento de arquivos: FileReader/FileWrite FileInputStream / FileOutputStream

So 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 no String/char): read() e write(String s)

86

Exemplo: criar um programa que permita selecionar um arquivo de texto, .txt e mostrar o contedo 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 boto, digite:

87

 Insira, antes da declarao da classe public class , no comeo do programa:

import java.io.*; import javax.swing.*; possvel acrescentar outro boto para salvar novos texto que o usurio 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 aplicao criada como exemplo, representa a criao de editor de texto j composto de um Menu, mas que no possui os respectivos cdigos para efetuar as operaes de abrir um documento e salv-lo. Experimente implementar os respectivos cdigos nessa para efetivamente criar um editor de texto.

JEDITORPANE Painel de Contedo uma rea de texto especializada na exibio e edio de vrios tipos de contedo: texto simples(text/plain), HTML(text/html) e RTF Rich Text Format(text/rtf). Exemplo: Criar um Programa que permita exibir um arquivo com extenso.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 Pgina :

Insira a importao dos pacotes, antes da declarao da classe public class : import javax.swing.*; import java.net.*; import java.io.*; Compile e Execute

TRABALHANDO MLTIPLO S FORMULRIOS - MENUS

Para se construir uma Aplicao contendo vrios Formulrios preciso cri-los em separados e cham-los em um Formulrio Principal atravs de Botes ou de Menus. No Formulrio Principal a chamada dos outros formulrios consiste em se criar instncias dos respectivos formulrios que se deseja exibir, utilizando o mtodo show(), ou o mtodo setVisible(boolean). 89

Na criao de Formulrios utilizando o NetBeans ( e outras IDE), a ferramenta cria os comandos necessrios para o fechamento do Formulrios, desta forma se o Formulrio Principal cham-lo e este, aps ser aberto, for fechado provocar o fechamento da aplicao. Para evitar este problema devemos modificar estes comandos para podermos fechar o formulrio sem fechar a Aplicao. Exemplo: Criar uma Aplicao contendo um Menu que exibi os Formulrios de Cadastro de Clientes e de Veculos Clique no Menu File New Java GUI Forms Boto Next em Name digite SistLocao Clique no Boto 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 boto direito do mouse sobre o Menu criado selecione Add JMenuItem na janela propriedade clique em Text digite Clientes clique

90

novamente com o boto direito do mouse sobre o Menu criado selecione Add JMenuItem clique em Text e digite Veculos.

Observe que os SubMenus no aparecem no Form este sero exibido na execuo do programa, mas apara o objeto criado no Form.

Os Menus foram criados faltam os Formulrios Clientes e Veculos. Crie um Novo Form Clique no Menu File New clique no Boto Next em Name digite Clientes clique no boto Finish

91

Modifique o Layout para AbsoluteLayout e insira trs JLabels para exibir os rtulos Nome, Fone, CPF e trs JTextFields para podermos digitar/exibir os dados.

Devemos modificar o comando responsvel pelo fechamento do Form, para que no feche a Aplicao. Clique com o boto direito do mouse no Form e clique em Goto Source ou pressione Ctrl-3 , procure o comando, que deve estar antes do mtodo 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 (SistLocao), para isto clique na Aba SistLocao, localizada na janela principal do Form

D um duplo clique em JMenuItem1, se o mesmo no estiver aparecendo clique no menu criado, d um duplo clique no JMenuItem1, para inserir o evento responsvel pela chamada do Form Clientes.

Na janela de cdigo que se abre, procure o seguinte comando: private void jMenuItem1ActionPerformed 92

Antes deste comando digite: Clientes FormCliente = new Clientes(); //instanciao do Formulrio Clientes Se tiver criado a Template com outro nome substitua o nome Clientes por este nome. E dentro do mtodo, depois de // Add your handling code here: , digite: FormCliente.show(); //exibio do Formulrio Clientes Compile e Execute.

Repita os mesmos passos para criar o Form Veculos e para exibi-lo. Clique no Menu File New Next digite o Nome Veculos clique no boto Finish Mude o Layout e insira os componentes (JLabel e JTextField), v para o cdigo e modifique o comando System.exit(0) para setVisible(false) Volte para o Form SistLocao e d um duplo clique em JMenuItem2, antes do respectivo mtodo actionPerformed instancie o Form: Veculos FormVeiculo = new Veculos(); //instanciao do Form Dentro do mtodo digite o comando para exibio: FormVeiculo.show(); Compile e Execute.

93

BANCO DE DADOS NO NETBEANS

ACESSANDO BANCOS DE DADOS A comunicao de cdigo Java puro com Banco de dados uma tarefa muito difcil, devido a enorme quantidade de bancos de dados, existente no mercado, com linguagens proprietrias. 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 operaes dos SGBDR.

ARQUITETURA muito parecida com o padro ODBC (Open DataBase Connectivity). A Aplicao 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 Aplicao, implementando em Java ou de forma nativa o acesso ao BD.

Instalao 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 boto adicionar (DNS do usurio) 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 dilogo com um nome para a Fonte de Dados do BD e a localizao do servidor. 5. Clicar no boto Selecionar para definir o BD a ser usado.

94

Podemos construir uma aplicao 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 conexo com o BD: (BD Access: IJPlanetas) Connection conexo = DriverManager.getConnection( jdbc:odbc:IJPlanetas );

4) Por meio da conexo realizada, devemos obter uma instncia de um objeto Statement, PreparedStatement ou CallableStatement, para passar comandos SQL ao BD: Statement stmt= conexo.createStatement();

5)

Criar

objetos

para

executar

operaes

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 operaes 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 ); // obtm o valor do campo nome da tabela System.out.println(Nome); }

7) Quando no precisar mais dos objetos obtidos, libere-os: rs.close(); stmt.close();

8) Aps todas as operaes encerre a conexo com BD: conexo.close();

Exemplos de mtodos 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 sero utilizando em uma aplicao que realizar operaes 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

CONSTRUO DE APLICAES - ACESSANDO UM BANCO DE DADOS ACCESS Este exemplo realiza uma consulta na tabela denominada Relacao, com os campos Nome e Id. Vamos partir do princpio de que a ponte JDBC-OBDC j foi criada com o nome BDAccess.

96

JDBC NO NETBEANS

O NetBeans no 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 programao. Para trabalhar com Banco de Dados preciso faz-lo via cdigo, que dever ser inserido dentro do mtodo actionPerformed de um JButton. Cria-se o Formulrio contendo os componentes visuais para mostrar, e manipular, os dados da tabela do Banco de Dados. Dentre estes componentes esto os botes ou menus, os quais sero os responsveis por executar os cdigos para realizar uma determinada operao, consulta, insero, alterao ou excluso em um BD. Depois de criada a parte visual , devem ser implementados os cdigos nos botes/menus: OBS: - Os exemplos que se seguem utilizam uma Fonte de Dados ODBC com o Nome: PBD_Nomes que representa uma conexo com um Banco de Dados Access, contendo uma Tabela com o nome: TabFicha, contendo os campos (Matricula Tipo Nmero/Chave Primria; Nome Tipo Texto) Parte Visual do Programa:

97

Cdigos para Inserir:

Cdigos para Consultar que devem ser inseridos em um JButton/Menu:

98

Cdigos para Alterar:

Cdigos para Excluir

99

NOTA: Antes de inserir os cdigos preciso importar os pacotes para trabalhar com Banco de Dados e exibir caixa de mensagens: Localize o cdigo de criao da classe. Ex: Public Class ... Antes deste comando insira os seguintes cdigos: import java.sql.*; import javax.swing.*;

Exemplo Completo

Crie uma aplicao para cadastrar a Matricula e os Nomes dos Funcionrios de uma Empresa. 1. Clique no Menu File New Selecione Java GUI Forms JFrame Forms clique no boto Next. Na janela que se abre, no campo Name, digite SistCadFunc e clique no Boto 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 construda, falta o cdigo para salvar os dados. 100

4. Abra o Access e crie um BD (BDCadastro) com uma Tabela (TabFicha) com os campos: Matricula (Tipo Numrico/Chave Primria) e Nome (Tipo Texto_. 5. Devemos criar a Ponte JDBC/ODBC: abra o Painel de Controle Ferramentas Administrativas Fontes de Dados ODBC clique no Boto Add Selecione o Driver p/ BD Access clique no boto Concluir no campo Nome da Fonte de Dados digite PBD-Nomes clique no boto Selecionar Procure o BD criado (BDCadastro) e clique no Boto OK OK OK

101

6. Criado o BD e a Ponte ODBC, volte para a sua aplicao no NetBeans e d um duplo clique no JButton (Salvar) para codificar a conexo: 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 operaes de Consulta, Alterao e Excluso em BD: Insira trs Botes para executar as operaes restantes no Banco de Dados (Consulta, Alterao e Excluso), um JLabel, para exibir o Texto Nome para Consulta/Excluso, supondo que estas operaes sero feitas atravs do campo Nome, e insira tambm um JTextField para o usurio 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 atravs de um JMenuBar. Supondo que foram inseridos os novos componentes da seguinte forma:

Basta dar um duplo clique no boto desejado e inserir o respectivo cdigo para a respectiva operao: Consultar

103

Alterar:

104

Excluir:

9. Compile Execute. OBS: Como os comando de conexo com o Banco de Dados esto se repetido, os mesmos poderiam ser implementados dentro de uma funo e serem executados atravs de uma chamada desta funo quando se desejar estabelecer uma conexo com o banco de dados para realizar uma determinada operao em suas tabelas, diminuindo a quantidade de cdigo a ser digitado.

105

COMPONENTES GRFICOS
O Java oferece dois pacotes para criao de interfaces grficas: AWT e Swing. O AWT acompanha o Java desde as primeiras verses, e o Swing trata-se de um pacote mais completo introduzido posteriormente. Estes pacotes oferecem contineres (janelas, painis e frames) nos quais podem ser inseridos componentes grficos (botes, caixas de texto, etc.). A figura abaixo (do livro Java Foundation Classes in a Nutshell, de David Flanagan, Ed. OReilly) mostra as principais classes do pacote javax.swing.

106

Os contineres trabalham com o conceito de layout, que define como os componentes so dispostos dentro do continer. Os principais layouts definidos pelo Java so os seguintes:

Layout de Fluxo (Flow): os componentes so dispostos em seqncia no continer, da esquerda para a direita. Layout de Borda (Border): os componentes podem ser colocados em 5 regies - norte, sul, leste, oeste e centro. Layout de Grade (Grid): cria uma "grade" de X linhas por Y colunas, com X*Y clulas nas quais os componentes so colocados. Layout de Caixa (Box): empilha os componentes na horizontal ou na vertical. Null Layout: sem um layout especfico.

possvel colocar dentro de um continer outros contineres com layouts diferentes. No exemplo abaixo foram criados trs painis (componente JPanel): o primeiro segue o layout Box, o central usa o layout Border e o ltimo um Grid 2x2.

107

Alm dos layouts padro, outros tipos de layout podem ser utilizados. O layout Desenho Livre (usado como layout default pelo NetBeans - o ambiente de desenvolvimento que iremos utilizar) dispe os componentes na posio exata na qual eles so colocados no continer.

USANDO COMPONENTES G RFICOS NO NETBEANS

O NetBeans um poderoso ambiente para desenvolvimento de aplicativos, com suporte a desenvolvimento de aplicaes em vrias linguagens e plataformas, incluindo Java em suas trs edies: Micro Edition, Standard Edition e Enterprise Edition. Atravs do NetBeans possvel desenvolver aplicaes grficas em Java utilizando componentes Swing e AWT, assim como aplicaes que utilizem outros componentes desenvolvidos por terceiros. O NetBeans trabalha com o conceito de projetos de software. Um novo projeto criado no NetBeans atravs do menu Arquivo Novo Projeto. No assistente 'Novo Projeto' pode-se selecionar um entre os diversos tipos de projetos disponveis. Por exemplo, o tipo de projeto 'Aplicao de rea de trabalho Java' da Categoria 'Java' corresponde a uma aplicao grfica do Java Standard Edition. Em seguida possvel definir o nome do projeto e o diretrio no qual o projeto ser criado, alm de outras opes.

108

O projeto criado ser exibido na janela Projetos.

O projeto criado possui uma classe que representa uma interface grfica, na qual podem ser adicionados componentes contidos na paleta de componentes do NetBeans, conforme mostra a figura abaixo. Ao editar uma interface grfica, ser exibida a tela de edio Projeto - o retngulo cinza esquerda na figura abaixo, que representa a rea de trabalho da janela que est sendo editada - na qual possvel inserir os componentes disponveis 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 grfica na forma como esta ser exibida na tela, basta pressionar o boto

. 109

Tambm possvel inserir no projeto diversos tipos de classes Java atravs do menu Arquivo Novo Arquivo. Selecionando a categoria Formulrios GUI Swing, pode-se criar quadros (Formulrio JFrame), painis (Formulrio JPanel) e janelas de dilogo (Formulrio JDialog), por exemplo. Esses elementos correspondero a uma nova classe Java da aplicao, e serviro como contineres para outros componentes grficos.

A forma como o componente se ajusta tela depende do layout utilizado. O layout default usado pelo NetBeans o Desenho Livre, que mantm a posio original na qual o componente foi inserido. O layout utilizado pode ser alterado clicando o com o boto da direita do mouse sobre o continer na janela 'Inspetor'.

110

Na janela 'Propriedades' possvel definir as propriedades dos componentes. Por exemplo, aps adicionar um item de menu (JMenuItem) a um dos menus da barra de menus da interface grfica, ao selecion-lo, possvel 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 tambm no cdigo da aplicao, atravs dos mtodos 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 grfica, o cdigo correspondente a essas alteraes ser gerado no arquivo Java. Clique no boto 'Cdigo-Fonte' na tela de edio pra visualizar o cdigo da classe, e em seguida expanda (clicando no sinal '+') a linha marcada como 'Generated Code' para exibir o 111

cdigo gerado pelo NetBeans. O NetBeans protege este cdigo, marcado em azul, impedindo sua edio. Note que os componentes adicionados interface grfica so criados automaticamente como atributos da classe que representa a interface grfica da aplicao.

TAREFA 1: A INTERFACE GRFICA DA APLICAO

Comece a implementar a interface grfica do aplicativo de controle de acesso a academias utilizando o NetBeans. No se preocupe por enquanto em implementar a funcionalidade da aplicao. Crie um novo projeto do tipo Aplicativo de rea de trabalho Java. Na seqncia, edite os componentes da janela principal da aplicao. Caso necessrio, adicione novos frames e janelas de dilogo ao projeto. Teste a disposio dos componentes dentro da janela, para que seu aplicativo se comporte de maneira adequada quando for redimensionado ou maximizado. Durante este processo, pode ser necessrio modificar os layouts e a disposio dos componentes at atingir um resultado satisfatrio. Insira na interface da aplicao os componentes necessrios 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 restries de horrio, 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 horrios permitidos para o tipo de plano e se a mensalidade no estiver em atraso.

Use a janela de propriedades dos componentes para modificar as propriedades que julgar necessrias, como por exemplo o texto, o tipo de fonte, a cor, ou cone dos botes. Tente compilar e rodar a interface grfica da aplicao (Shift+F6). A lgica de funcionamento ser implementada em um segundo momento.

EVENTOS

O Java permite que eventos gerados pelo usurio 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 implementao dos tratadores de eventos, chamadas MouseAdapter e KeyAdapter, que so classes abstratas (com implementaes vazias para os mtodos 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 boto, por exemplo) deve se registrar para receber os eventos com o mtodo addMouseListener, e criar um objeto do tipo MouseAdapter. Isto pode ser feito criando uma classe annima, na qual deve ser definido o cdigo para tratar o evento correspondente. No exemplo abaixo foi definido o cdigo do mtodo 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 mtodos e chamar addMouseListener passando um objeto desta classe como parmetro. Outros tipos de eventos tambm possuem suas classes Listener, Adapter e Event, que so utilizadas de maneira semelhante.

TRATAMENTO DE EVENTO S NO NETBEANS A partir da janela de edio do NetBeans possvel criar tratadores de eventos gerados por componentes. Isso pode ser feito de duas formas: usando o modo de conexo ou definindo os tratadores de eventos. Para ativar o Modo de conexo, clique o boto na janela de edio da interface grfica. Em seguida,

voc deve selecionar o componente de origem e o componente de destino da ao. No exemplo abaixo, selecionamos na janela de projeto da interface grfica o item de menu File -> New da aplicao, e logo depois a rea de texto da aplicao. No Assistente de conexo, que ser aberto automaticamente, selecione o evento de origem no caso, o evento actionPerformed, que inclui a ativao do menu pelo mouse ou pelo teclado.

113

Logo depois, selecione a operao 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 mtodo tratador de eventos ser gerado:

Outra forma possvel de tratar eventos associar um tratador de evento a um componente. Ao clicarmos um componente o boto da direita do mouse, possvel criar um tratador para um evento gerado pelo componente.

115

Feito isso, pode-se editar o cdigo que ser executado quando o evento selecionado ocorrer. A edio de cdigo facilitada pelo recurso auto-completar do NetBeans, ativado teclando Ctrl+Espao. Assim possvel ter acesso aos atributos e mtodo da classe que est sendo editada. Lembre-se que os componentes adicionados interface grfica so atributos da classe, e seus mtodos e atributos tambm podem ser visualizados utilizando o recurso auto-completar.

116

IMPLEMENTANDO COMPON ENTES BSICOS COM SWING, UTILIZANDO NETBEANS

Vamos implementar um sistema simples de cadastro com o objetivo de explicar como funcionam os componentes bsicos 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 mtodos 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 grfica, ainda mais se tiver que faz-la na mo, linha por linha, para nos poupar trabalho e tempo o NetBeans possui uma fantstica ferramenta para desenvolvermos nossa interface grfica no estilo Drag and drop - Arrastar e soltar. Uma paleta com diversos componentes disponveis, onde voc tem apenas que arrast-la para dentro de seu Jframe e pronto! O NetBeans gera todo cdigo para voc automaticamente. No final deste tutorial voc ser capaz de criar seu prprio projeto fazendo uso de inmeras aplicaes possveis com o construtor de interface do NetBeans. Neste exemplo usado o NetBeans 5.5.1 verso em portugus.

ITEM 1: CRIANDO UM JF RAME.

Aps criar um projeto clique com o boto direito do mouse sobre ele, em novo, escolha a opo Formulrio JFrame como na imagem abaixo.

117

Note que ser gerada pra voc uma nova tela com uma caixa de edio, onde voc ir construir toda sua interface grfica, pode redimension-la vontade. Na barra de menu, a direita da tela, ter dois botes: Propriedades e Paleta. Em paleta estar todos os componentes que voc pode usar para criar sua interface grfica.

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 opes, 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 usurio insira os dados no programa.

importante salientar que todos os dados inseridos em um JTextField so tratados como String. Portanto se for inserir um dado numrico necessria a devida converso.

JTextArea: Campo semelhante ao JTextField, normalmente usado para entrada de textos maiores. Como crticas, sugestes, etc. JRadioButton: Boto que permite apenas seleo de uma opo quando relacionado a um ButtonGroup. ButtonGroup: Componente utilizado para criar grupos de JRadioButtons. JCheckBox: Caixas de mltiplas selees, permite o usurio marcar vrias opes ao mesmo tempo. JComboBox: Componente semelhante a um vetor, que permite ao usurio escolher apenas uma opo. JButton: Boto onde sero 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 ttulo Cadastro, para colocarmos borda com ttulo a um JPanel voc deve ir at o boto propriedades, a direita da tela, ou clicar com o boto direito do mouse sobre o JPanel e ir at a propriedade border, clique no boto com ... vrias opes de borda sero exibidas, selecione TitledBorder, e no campo Ttulo escreva o ttulo que desejar para o seu JPanel, no nosso exemplo Cadastro. Para o JPanel que contm 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 opo Estado, voc dever ir opo model em propriedades, insira o nome do item que voc quer que aparea e clique em adicionar. Para inserir uma imagem, coloque um JLabel e na opo icon em propriedades, marque Arquivo, boto Selecionar Arquivo e escolha a imagem que voc deseja adicionar a sua interface, de preferncia em .gif, em seguida apague o que estiver escrito na opo 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 opo nos JRadioButtons, da opo Sexo de nosso cadastro, voc deve adicionar ao projeto o componente ButtonGroup, este componente no 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, opo buttonGroup e escolha buttonGroup1 (nome padro para este componente), faa isso para ambos os JRadioButtons. Para apagar os nomes que vem dentro dos JTextField, JRadioButtons, JCheckBox e JButtons basta dar duplo clique sobre eles e apagar o que est escrito, ou ento na opo text em propriedades.

ITEM 4: MANIPULANDO O C DI G O

Antes de comear a manipular o cdigo, deve-se alterar o nome de varivel de todos os componentes que sero utilizados para processar os eventos (entenda eventos, como sendo basicamente a funcionalidade que voc dar a um boto), para que nosso cdigo fique mais legvel e organizado. Para alterar o nome de varivel de um componente, clique sobre ele, como o boto direito do mouse escolha Alterar o nome de varivel... e insira o nome que voc deseja. Em nosso projeto utilizaremos o seguinte padro: Para JTextField: campoNomeDaOpo Ex: campoNome Para JComboBox: comboNomeDaOpo Ex: comboEstado Para JRadioButton: rbNomeDaOpo Ex: rbMasculino Para JCheckBox: cbNomeDaOpo Ex: cbMusica Para JTextArea: campoNomeDaOpo Ex: campoBiografia Para JButton: btNomeDoBoto Ex: btSalvar JLabels e JPanels no necessitam de alterao pois no sero implementados diretamente no tratamento de eventos. Vamos implementar um evento no boto Salvar, onde os dados contidos em todos os componentes sero armazenados em um objeto, para isso voc deve criar uma classe auxiliar que apresente variveis para todas as opes do cadastro (Nome, endereo, sexo, etc.), e instanciar o objeto, voc dever criar mtodos set e get para todas as variveis (utilizaremos apenas 1 cadastro, mas voc pode fazer utilizando vetores ou arquivos), como disse anteriormente, o objetivo ensinar os mtodos necessrios a implementao dos componentes. Para inserir um evento de clique a um boto, clique sobre ele, opo Eventos > Action > actionPermormed, veja na imagem abaixo:

120

Repare que o NetBeans leva voc at a rea de edio de cdigo e gera pra voc o cabealho do mtodo que ir tratar o evento:

private void btSalvarActionPerformed(java.awt.event.ActionEvent evt) { // TODO adicione seu cdigo de manipulao aqui: }

Todo cdigo com fundo azul o NetBeans gera automaticamente pra voc e no pode ser mudado. Instancie fora do mtodo criado pelo NetBeans o seu objeto:

ClasseAuxiliar obj = new ClasseAuxiliar(); E comece a implementar o cdigo dentro do mtodo criado pelo NetBeans. Para receber os dados inseridos em um JTextField voc deve utilizar o mtodo getText() da seguinte forma

obj.setText( campoNome.getText() );

Faa o mesmo para os campos Endereo, E-Mail e Fone.

121

Para retornar os campos de um JComboBox voc deve utilizar o mtodo getSelectedItem(). Entretanto para armazenar em uma varivel 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 verificao de qual JRadioButton foi marcado pelo usurio, o mtodo 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 verificao para cada componente. O mtodo utilizado para isso o mesmo do JRadioButton, isSelected(), vamos adotar que as variveis 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 mtodo getText(), assim:

obj.setBiografia( campoBiografia.getText() );

Aps ser implementado todo os componentes no evento do boto salvar, coloque uma mensagem de confirmao para o usurio utilizando JOptionPane.showMessageDialog(null,"Cadastro realizado com sucesso");

No se esquea dos imports. Pronto o cadastro est completo, agora vamos para os mtodos de exibio. Aps os dados serem salvos voc deve apag-los de seus respectivos campos para usar os espao para 122

exibio (ou se voc quiser implementar mais de um cadastro). Para isso pode-se criar um boto Apagar ou simplesmente os dados sero apagados aps serem salvos, que como faremos aqui. Para apagar o JTextField e o JTextArea utilizao o mtodo 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 mtodo setSelectedIndex(int i) que recebe como parmetro um nmero 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 mtodo clearSelection(), da seguinte forma:

if ( rbMasculino.isSelected() || rbFeminino.isSelected() ) buttonGroup1.clearSelection(); O cdigo acima verifica se algum dos JRadioButtons esto selecionados, se verdadeiro, apaga a seleo.

Agora s falta apagar os JCheckBox que foram marcados, para isso basta verificar cada um para ver se esto marcados e ento, desmarcar. Utilizando o mtodo setSelected( boolean b ), pode-se mudar o estado de um JCheckBox, onde o parmetro do tipo boolean e true representa opo 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 sero apagados aps 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 so preenchidos os dados (os componentes), caso voc esteja implementando mais de um cadastro, utilizando vetor ou arquivos, seria interessante criar dois botes Prximo e Anterior para navegar entre os cadastros, mas isso fica para uma prxima oportunidade, como disse anteriormente o objetivo desde tutorial familiarizar voc com os principais componentes e aprender os mtodos necessrios para implement-los. Primeiramente devemos criar um evento para o boto Limpar da mesma forma que foi feito para o boto Salvar. Dentro do mtodo gerado pelo NetBeans vamos implementar nosso cdigo. Para exibir em um JTextField e JTextArea, utiliza-se o mtodo setText() Ex.: campoNome.setText( obj.getNome() );

Repita isso para todos os JTextField e para o JTextArea. Ateno para o nome de varivel do componente. Para alterar o estado de um JComboBox usamos o mtodo setSelectedItem(), ficando deste jeito:

comboEstado.setSelectedItem( obj.getEstado() ); Para selecionar um JRadioButton e JCheckBox, utilizaremos o mtodo setSelected(), devemos verificar qual opo sexual foi escolhida no cadastro e quais opes foram marcadas nos Interesses, e ento selecion-las, nosso cdigo ficar assim:

if ( obj.getSexo() == "Masculino" ) rbMasculino.setSelected(true); else rbFeminino.setSelected(true); O trecho acima verifica se a varivel sexo igual a Masculino (como definimos no evento do boto salvar) , ento marca o JRadioButton, seno, 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 exibio.

125

CONEXO 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 conexo e acesso aos principais banco de dados existentes so 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 conexo com os banco de dados. O pacote java.sql contm as classes e interfaces necessrias para trabalhar com acesso a banco de dados relacionais. Faz parte do pacote java.sql uma classe chamada DriverManager, pea central da arquitetura JDBC. Utilizada para abrir uma conexo com um banco de dados atravs de um driver JDBC. Quando uma conexo iniciada, a classe DriverManager escolhe um driver de uma lista de drivers disponveis para efetuar a conexo. Uma vez estabelecida a conexo com sucesso, as chamadas para consultas e busca de resultados so feitas diretamente atravs do driver JDBC. Um programa Java pode utilizar simultaneamente vrios drivers JDBC, isto , o programa pode acessar diferentes bancos de dados, bastando carregar o driver. O programador no 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 mquina local. Cada estao deve ter instalado o programa cliente; 2. ponte com ODBC acesso ao banco de dados atravs de um driver ODBC convencional. A ponte JDBC aponta para a ponte ODBC; 3. driver com protocolo proprietrio escrito em Java a comunicao entre o cliente e o banco de dados atravs do protocolo do SGBD. E o tipo mais flexvel e acessa um servidor usando um protocolo neutro, por exemplo HTTP. E o servidor que estabelece a conexo com os banco de dados; 4. driver com protocolo nativo o driver acessa diretamente o SGBD utilizando o protocolo nativo do mesmo. Por esta razo, os drivers, so fornecidos pelos fabricantes de banco de dados. So os chamados thin drivers.

CONEXO COM O BANCO DE DADOS

A conexo 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 conexo 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 trs formas diferentes e para todas necessrio conhecer a classe que implementa o driver: carga dinmica da classe com o mtodo Class.forName: Class.forName (sun. jdbc.odbc. jdbcOdbcDriver);

Instanciao de um objeto para forar a classe: new sun. jdbc.odbc. jdbcOdbcDriver();

Os exemplos acima esto baseados numa conexo 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. Aps a carga do driver necessrio 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 conexo especfica para cada banco de dados. Normalmente a documentao da URL de conexo fornecida junto com o driver. Para obter a conexo, esta deve ser passada como uma string. O formato de URL para conexo a um banco de dados Oracle, por exemplo, jdbc:oracle:<driver>: @<servidor>:<porta>:<instncia>.

ETAPA 4 ABRIR A CONEXO A conexo deve ser aberta atravs do mtodo esttico getConnection da classe DriverManager, onde o parmetro do mtodo a URL de conexo e o retorno um objeto que implementa o objeto Connection: Connection con = DriverManager.getConnection (url, usurio , senha); O DriverManager analisa a URL de conexo e tenta conectar com o primeiro driver carregado e, se no conseguir tenta o driver seguinte. Caso ele no consiga estabelecer conexo com nenhum dos drivers carregados, ento uma exceo gerada. Uma vez inicializada a conexo, atravs 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 trs tipos:

127

Statement - utilizado para enviar comandos SQL simples, isto , que no envolvem parmetros: 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 sentena SQL que se deseja utilizar, visto que o mtodo de enviar consultas (query) difere do envio de atualizaes (update, insert, delete,etc.) na base de dados. A principal diferena que o mtodo da consulta retoma uma instncia da classe reesultSet enquanto que a atualizao retoma um nmero inteiro. As consultas so executadas pelo mtodo execute Query do objeto Statement, e as atualizaes pelo mtodo 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 nmero inteiro, parmetros de sada de uma StoredProcedure ou, ainda, uma combinao de todos os anteriores: ResultSet - um conjunto de registros que retomam de uma consulta. Os registros podem ser acessados seqencialmente ou aleatoriamente. As colunas de cada registro podem ser acessadas atravs de um ndice ou pelo nome da coluna:

128

nmero inteiro - os comandos de atualizao no banco de dados (insert, update ou delete) atingem um nmero de linhas na tabela. O retomo do mtodo executeUpdate fornece esse nmero: int lin = comando.executeUpdate(delete * from EMP); parmetros de sada de Stored Procedures - atravs dos mtodos da classe CallableStatement possvel indicar quais os parmetros de sada, 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 informao 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 pginas bonitas na Web. Est se estabelecendo como uma linguagem de programao sria, altura das aplicaes empresariais mais sofisticadas. Este fenmeno somente se tornou possvel com a possibilidade destas aplicaes acessarem os bancos de dados atravs da API JDBC. Neste documento foi apresentada a API JDBC que utilizada para fazer uma conexo entre os programas Java e um banco de dados. Esta conexo feita de forma simples, e com poucos mtodos possvel executar todos os comandos SQL passando-os como parmetros para o banco de dados. A utilizao desta tecnologia no desenvolvimento de programas Java que tem a pretenso de acessar banco de dados o caminho natural da programao.

129

CONEXO DO JAVA COM O ORACLE

130

ANEXOS

CONFIGURAO DO JDK NO W INDOW S 7

A primeira coisa a fazer localizar e guardar os diretrios de dois arquivos que se encontram dentro da pasta do jdk que por sua vez est dentro da pasta Java. Ento 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 diretrio: src.rar Exemplo: C:\Program Files\Java\jdk1.6.0_17\src.zip

O seu diretrio pode ser diferente caso tenha instalado em outro local e/ou se sua verso do jdk for outra, fique atento a isso, copie e cole o diretrio em algum lugar pra ter fcil acesso porque iremos precisar. O outro arquivo que devemos ir atrs do diretrio tambm 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 diretrio desse arquivo em algum lugar para copiar e colar facilmente porque iremos precisar. Clique com boto auxiliar do mouse no cone "Meu computador" e v em "Propriedades". Clique em "Configuraes avanadas do sistema" e depois em "Variveis de ambiente". Em "Variveis do sistema" voc ir clicar em "Nova". Coloque no nome da varivel: ClassPath Em valor da varivel coloque os endereos 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;. ATENO: coloque do jeito que est acima, com os ";" (ponto e vrgula) e com o ponto final. O que pode mudar, como j foi dito anteriormente, so os endereos onde esto localizados os arquivos src.zip e tools.jar dependendo de onde voc instalou e da sua verso do jdk. Depois de fazer isso clique em Ok. Agora vamos configurar a varivel Path que est em Variveis do sistema tambm. Voc seleciona a varivel Path e clica em Editar, em Valor da varivel voc vai ACRESCENTAR (nada de apagar valores) o seu endereo do jdk, no meu caso ficaria assim: Exemplo: C:\Program Files\Java\jdk1.6.0_17\bin

131

ATENO: o que pode mudar o endereo do jdk, o ";" necessrio e o "bin" depois do endereo tambm! Depois de feito isso clique em Ok e depois em Ok de novo para sair das Variveis 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 no tenha nenhum deles, voc pode baixar e instalar a partir dos sites oficiais. O NetBeans possui algumas facilidades de conexo a banco de dados bem ao estilo Next > Next > Ok. Aps tudo instalado hora de comear a colocar a mo na massa. O Java para se conectar a qualquer banco de dados precisa de um driver de conexo, esse driver chamado de JDBC (Java Database Connectivity). Sem um JDBC no possvel fazer uma conexo a um banco de dados. Cada banco de dados possui seu prprio JDBC. Por exemplo a Oracle fornece um JDBC para ser usado em bancos Oracle, o PostGRESQL tambm fornece um JDBC para ser usado com o PostGRESQL e assim vai. No diferente com o MySQL. O pessoal do MySQL tambm disponibilizou um JDBC para ser usado em conexo Java MySQL. Como o MySQL tambm nos fornece um JDBC, vamos baix-lo do site oficial do MySQL. Endereo 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. Sero descompactados vrios arquivos como instrues e documentaes mas o arquivo que nos interessa um que termina com extenso .JAR. At a finalizao 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 localizao 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 trs colunas. Tudo bem simples. Se quiser seguir esse exemplo abaixo, vai o script SQL para a criao. 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 cdigo. 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 faa: Arquivo > Novo Projeto; Escolha categoria: Java. Projeto: Aplicativo Java; Clique em Prximo; Coloque um nome para o projeto e clique em finalizar

Abaixo temos a prxima tela aps clicar no boto Prximo. Aqui onde definiremos o nome para o projeto e mais algumas configuraes.

O projeto foi criado. Agora vamos adicionar o driver JDBC para que nossa aplicao consiga se conectar ao Banco de Dados. Para isso: Clique com o boto direito em cima do Projeto > Propriedades. Selecione a opo Bibliotecas e clique no boto 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 aplicao. Agora vamos fazer um pouco de cdigo. Ns iremos fazer toda a conexo com banco de dados direto da classe principal que o NetBeans nos forneceu. Logicamente essa metodologia no segue as melhores prticas da programao e todo o resto, mas serve para voc ter uma idia de pelo menos como conectar sua aplicao a uma base MySQL. O cdigo gerado pelo NetBeans est assim: package mysqlconnection;

public class Main { public static void main(String[] args) { //O cdigo vai aqui } }

Vamos criar a conexo e vamos fazer um select bsico no banco. Abaixo segue o cdigo com a conexo, com o envio do select e o tratamento de exceo. O cdigo 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 conexo String usuario = "root"; //Usurio do banco String senha = ""; //Senha de conexo try { Class.forName(driver); //Carrega o driver //Obtm a conexo 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("No foi possvel carregar o driver."); ex.printStackTrace(); } catch (SQLException ex) { System.out.println("Problema com o SQL"); ex.printStackTrace(); } } } 136

Repare que na obteno dos objetos a partir do ResultSet ns usamos como chave o nome da coluna no banco de dados. Se estiver tudo certo, j podemos executar nosso cdigo. Para isso faa aperte ou clique no Play. Se tudo deu certo e se voc utilizou o esquema de banco fornecido nesse post, a sada para console ser assim: run: Ricardo ricardo@meuemail.com 23 ==================================== Jos jose@seuemail.com 29 ==================================== CONSTRUDO COM SUCESSO (tempo total: 0 segundos)

137

CDIGO DO SISTEMA AGENDA DE TELEFONE

138

139

140

141

MODELO DE BANCO DE DADOS PARA A AGENDA DE TELEFONE

142