Вы находитесь на странице: 1из 78
1
1

UNIVERSIDADE ESTADUAL DO PIAUÍ - UESPI CAMPUS UNIVERSITÁRIO “PROFESSOR POSSIDONIO QUEIROZ” CURSO LICENCIATURA PLENA EM COMPUTAÇÃO DISCIPLINA: LINGUAGEM DE PROGRAMAÇÃO IV PROFESSOR: JAMES MORAIS

A Linguagem

JAVA

E

Aplicações com NetBeans

PRODUZIDA PELA A TURMA DE COMPUTAÇÃO BLOCO V – ANO 2007 CAMPUS OEIRAS

OEIRAS (PI), DEZEMBRO DE 2007

SUMÁRIO

Histórico Da Linguagem-------------------------------------------------------04 Inicialização de variáveis------------------------------------------------------05

Concatenação--------------------------------------------------------------------06

Instruções de controle----------------------------------------------------------07 Palavras reservadas-------------------------------------------------------------06 Instrução teórica da linguagem------------------------------------------------08 Abstração de tipos de dados---------------------------------------------------08 Definição de métodos----------------------------------------------------------08 Passagem de valores------------------------------------------------------------08 A referencia this-----------------------------------------------------------------08 Ocultando dados-----------------------------------------------------------------08 Como Java é executado--------------------------------------------------------09 Usando variáveis----------------------------------------------------------------13 Compilação e execução de um programa em java--------------------------16 Aplicações com NetBeans-----------------------------------------------------17 Conhecendo a IDE--------------------------------------------------------------17 Aplicações Gráficas com Swing----------------------------------------------19 Principais Componentes--------------------------------------------------------20 Métodos comuns a todos os componentes-----------------------------------21 Gerenciadores de Layout-------------------------------------------------------22 Aplicações Gráficas com Swing ---------------------------------------------23 Construindo Aplicações com o NetBeans-----------------------------------23

3
3

Utilizando JLabel, JTextField e JButton com o NetBeans----------------23 Criando uma Calculadora------------------------------------------------------25 Utilizando JCombobox/Jlist e JRadioButton JCombobox/JList----------25 Utilizando JRadioButton com o NetBeans----------------------------------27

JOptionPane---------------------------------------------------------------------29

JEditorPane----------------------------------------------------------------------34

Trabalhando Múltiplos Formulários – Menus------------------------------35 Criando Múltiplos Formulários – Menus------------------------------------35 Criando Applets no NetBeans-------------------------------------------------43 Acessando Bancos de Dados--------------------------------------------------46 Construção de Aplicações - Acessando um Banco de Dados Access- - --46 Aplicativo comercial------------------------------------------------------------57 Maquina Registradora----------------------------------------------------------57 Calculadora Visual --------------------------------------------------------65 Controlador de Mensalidade e Conversor de Velocidade ------------79

4

Histórico da Linguagem

Java é uma linguagem de programação ideal para aplicativos para a Internet. Mostraremos a seguir as origens da linguagem, e porque ela é tão apropriada para ser usada na Internet, particularmente na WorldWide Web. Embora as papplets Java sejam escritas na linguagem Java, não é necessário saber programar em Java para usá-las. Se você está interessado em usar applets sem realmente programar em Java, pode pular esta parte, que introduz a linguagem. Você pode ler a definição da linguagem Java (em inglês), no site Java/HotJava da Web. http://www.javasoft.com/hooked/language-ref.html A História da Linguagem Java A história de uma linguagem de programação pode contar muita coisa sobre a linguagem em si. Durante a fase de projeto, é importante usar a linguagem em aplicativos reais. Do contrário, a linguagem não será tão útil quando for lançada, e não será tão divertido programar nela. A linguagem de programação Java foi usada no desenvolvimento de diversos aplicativos enquanto estava sendo projetada. Originalmente, pretendia-se que a Java fosse usada na programação de produtos eletrônicos de consumo (eletrodomésticos, eletroeletrônicos). Entretanto, ela se transformou em uma grande linguagem para programação para a WorldWide Web. As Origens da Java A linguagem de programação Java foi projetada e implementada por uma pequena equipe de pessoas coordenada por James Gosling na Sun Microsystems em Mountain View, Califórina. Além de seu trabalho com a Java, James Gosling é o autor do

de janelas neWs.

http://ww.javasoft.com/people/jag/index.html. A equipe Java original trabalhava no projeto de software para produtos eletrônicos de consumo. Rapidamente, eles descobriram que as

linguagens de programação existentes, como C e C++, não eram adequadas. Programas escritos em C e C++ têm de ser compilados para cada tipo específico de processador (chip de CPU). Quando um novo processador é lançado, a maior parte do software tem de ser recompilada, para aproveitar os novos recursos do processador. Depois de compilados, os programas em C e C++ não são facilmente adaptáveis ao uso de novas bibliotecas de software. Os programas têm de ser totalmente recompilados quando a biblioteca muda. Entretanto, softwares para produtos de eletrônica de consumo devem funcionar em novos processadores, porque os fabricantes têm como restrição o custo dos componentes. Se o preço de um processador fica muito alto, eles o substituirão imediatamente por um mais novo, de custo-benefício mais atraente. Mesmo pequenas variações de preço podem fazer diferença, quando se pensa em termos de vendas de milhões de unidades. Outro problema no uso de linguagens de programação tradicionais para o software de produtos eletrônicos de consumo está em que o consumidor quer uma vida útil longa para seu produto. Há torradeiras funcionando que têm 50 anos de idade. O plugue ainda se encaixa na tomada e as fatias de pão ainda se encaixam nas aberturas. Os Software normalmente tem uma vida útil bem mais curta, o que tornaria difícil construir uma torradeira com um computador embutido. Sempre que novos programas para torradeiras fossem escritos, eles teriam de apresentar compatibilidade retroativa, pois o software das torradeiras antigas teria de ser substituído. O software usado em produtos eletrônicos de consumo também precisa ser muito confiável, muito mais do que o software para computadores. Se um eletrodoméstico ou eletroeletrônico falha, o fabricante geralmente tem de substituir todo o aparelho.

emacs

do

Unix

e

do

sistema

5

Em 1990, James Gosling começou a projetar uma linguagem de programação nova, que seria mais apropriada para produtos eletrônicos de consumo, sem os problemas de linguagens tradicionais como C e C++. O resultado é Java, uma linguagem muito rápida, pequena e confiável, que rodará em todos os tipos de processadores.

Inicialização de variáveis

No Java não é permitido o uso de variáveis indefinidas. Variáveis definidas dentro do método são chamadas de variáveis automáticas, locais, temporárias ou estáticas e devem ser inicializadas antes do uso. Quando um objeto é criado, as variáveis membro são inicializadas com os seguintes valores em tempo de alocação:

Tipo de variável Valor inicial Tamanho

byte

0

8 bits

short

0

16 bits

Int

0

32 bits

long

0L

64 bits

float

0.0f

32 bits

Double

0.0d

64 bits

Char

‘\u0000’ (Null)

64 bits

Boolean

false

Operadores

No Java os operadores são muito similares ao estilo e funcionalidade de outras linguagens como por exemplo o C e o C++.

Pré-incremento:

x

x

O valor da variável x é 11

ou

= 10; = x + 1;

6

++x

O valor da variável x é 11.

Pós-Incremto:

x

= 10;

x

= x + 1;

O

valor da variável x é 11

ou

x = 10;

x++

O valor da variável x é 11.

Diferença entre o Pré-Incremento e o Pós-Incremento:

x = 10

++x => neste exato momento a variável a vale 11

x =10

x++ => neste exato momento a variável x vale 10

Separadores:

)

Operadores:

.

[

]

(

;

,

Operadores

Descrição

==

Igualdade

!=

Negação

+ - * /

Aritméticos

&&

e

||

ou

Concatenação

O operador + é utilizado para concatenar objetos do tipo String, produzindo uma nova

String:

String PrimeiroNome = “Antonio”;

String SegundoNome = “Carlos”; String Nome = PrimeiroNome + SegundoNome; Casting ( Conversão de tipos )

A linguagem Java não suporta conversões arbitrárias de tipos de variáveis. Você deve

explicitar a conversão entre tipos de variáveis.

Exemplo:

long bigval = 6; // Operação válida

int smallval = 99L; // Operação inválida porque são de tipos diferentes

float z = 12.414F; // Operação válida

float zp = 12.414; // Inválido, porque está tentando atribuir um valor double.

Convertendo

Long bigValue = 99L; Int squashed = (int)(bigValue);

7

Instruções de controle:

Declarações de Fluxos If, else if (expressão) // expressão cujo retorno é um valor do tipo boolean

{ Declarações ou blocos }

else // caso a condição anterior não seja satisfeita

{ Declarações ou blocos }

switch switch (expressão) // Esta expressão deve ser do tipo int ou char

{

case cond01:

declarações; break; // usado para sair do case.

case cond02:

declarações;

break;

case cond03:

declarações;

break;

}

for Loops

for (expr_inicial; condição_boolean; incremento)

{

Declarações ou blocos;

}

while Loops

while(condição_boolean)

{

Declarações ou blocos;

}

do Loops

do

{

Declarações ou blocos;

}

while(condição_boolean);

Palavras Reservadas

abstract do implements private throw boolean double import protected throws breaak else instanceof public true transient byte extends int return case false interface short try catch final long static void char finally native super volatile

8

class float new switch while continue for null synchronized default if package this Estruturação teórica da linguagem:

Classes e objetos:

1º Nível 2º Nível 3º Nível Veículos de Passeio Veículos de Transporte Fabricante Veículos n Níveis Abstração de Tipos de Dados Quando itens de dados são compostos para tipos de dados, semelhante a uma data, você

pode definir um número de bits de programas que especifica a operação do tipo de dados. Em Java você pode criar uma associação entre o tipo data e a operação tomorrow a seguir:

public class Date { private int day, month, year; public void tomorrow( ) { // código que incrementa o dia

}

}

Definição de Métodos

Em Java, métodos são definidoss usando uma aproximação que é muito similar à usada em outras linguagens, como por exemplo C e C++. A declaração é feita da seguinte forma:

< modifiers > <tipo de retorno> < nome > ( < lista de argumentos > ) < bloco >

< modifiers > -> segmento que possue os diferentes tipos de modificações incluíndo public, protected e private.

< tipo de retorno > -> indica o tipo de retorno do método.

< nome > -> nome que identifica o método.

< lista de argumentos > -> todos os valores que serão passados como argumentos.

public void addDays (int days) Passagem de Valores Em Java o único argumento passado é “by-value”; este é um argumento may not be changed do método chamado. Quando um objeto é criado, é passado um argumento para o método e o valor deste argumento é uma referência do objeto. O conteúdo do objeto passível de alteração é chamado do método, mas o objeto referenciado jamais é alterado. A Referência This É aplicado a métodos não estáticos. O Java associa automaticamente a todas as variáveis e métodos referenciados com a palavara this. Por isso, na maioria dos casos torna-se redundante o uso em todas as variáveis da palavra this. Existem casos em se faz necessário o uso da palavar this. Por exemplo, você pode necessitar chamar apenas uma parte do método passando uma instância do argumento do objeto. (Chamar um classe de forma localizada); Birthday bDay = new Birthday(this);

9

Ocultando Dados Usando a palavra private na declaração de day, month e year na classe Date, você impossibilitará o acesso a estes membros de um código fora desta classe. Você não terá permissão para atribuir valores, mas poderá comparar valores.

Como Java é executado

Um programa fonte escrito em linguagem Java é traduzido pelo compilador para os bytecodes, isto é, o código de máquina de um processador virtual, chamado Java Virtual Machine (JVM). A JVM é um programa capaz de interpretar os bytecodes produzidos pelo compilador, executando o programa cerca de 20 vezes mais lento do que C. Pode parecer ruim, mas é perfeitamente adequado para a maioria das aplicações. Com isto, um programa Java pode ser executado em qualquer plataforma, desde que esteja dotada de uma JVM. É o caso dos programas navegadores mais populares, como o Netscape Navigator e o Internet Explorer, que já vêm com uma JVM. A vantagem desta técnica é evidente: garantir uma maior portabilidade para os programas Java em código-fonte e compilados. Porém, as JVM tendem a ser programas extensos que consomem muitos recursos, restringindo assim o tamanho das aplicações escritas em Java.

Atualmente, já existem compiladores capazes de traduzir bytecodes para instruções de máquina nativas, como o Just In Time compiler (ou JIT), tornando os programas ainda mais rápidos. Este compilador requer uma versão específica para cada plataforma onde se pretende que o programa Java seja executado. Em contrapartida à maior velocidade de execução está também uma maior necessidade de memória, pois os bytecodes compilados, em geral, ficam três vezes maiores do que o original. Uma alternativa bem mais interessante, e talvez muito mais viável, é a implementação da JVM em hardware na forma de uma placa ou microchip. A primeira iniciativa neste sentido é da Sun Microelectronics, que está produzindo os chips picoJava I TM , microJava TM e UltraJava TM . Estes são capazes executar diretamente bytecodes, acelerando em milhares de vezes a velocidade de execução. Isto permitirá o desenvolvimento viável de aplicativos cada vez mais complexos, abrangentes e funcionais. Espera-se que estas soluções sejam brevemente empregadas na fabricação de telefones celulares, pagers, jogos, organizadores pessoais digitais, impressoras e eletrodomésticos de consumo, além aplicações mais sérias como estações de trabalho dotadas do sistema operacional JavaOS TM . Trata-se certamente do futuro das soluções para aplicações de rede.

Já se tornou clássica a idéia de que para aprender uma nova linguagem de programação não se deve ir direto à descrição sua formal. Ao invés disso, é melhor examinar cuidadosamente um pequeno programa escrito nessa linguagem, o mais simples possível, mas que permita "quebrar o gelo". Isso faz sentido pois, por exemplo, quando vamos aprender Inglês, ou outro idioma qualquer, não iniciamos com a leitura compenetrada de um livro de gramática, mas aprendemos algumas estruturas simples e procuramos exercitá-las, adiando o estudo

10

rigoroso para quando estivermos suficientemente maduros. Ao compreender as diversas partes componentes do exemplo, já teremos dado um grande passo para podermos escrever qualquer programa.

Seguindo essa linha, apresentamos nosso primeiro programa, o clássico "Alô pessoal!". O objetivo deste programa é simplesmente escrever na tela a frase "Alô pessoal!". Vejamos como é o código fonte:

public class AloPessoal { public static void main(String args[]) { System.out.println("Alo pessoal!");

}

}

Digitando o programa

Que tal colocarmos a mão na massa e digitarmos esse programinha? Para isso, é recomendável utilizar um editor de texto simples como o Notepad ou Bloco de Notas do Windows. Se estiver no Unix, use preferencialmente o TextEdit ou o vi. O nome do arquivo deve ser exatamente igual ao nome que aparece após a palavra class na primeira linha do programa e dever ter .java como sufixo. Assim sendo, o nome deverá ser "AloPessoal.java". Cuidado para digitar corretamente as maiúsculas e minúsculas, pois a linguagem Java é sensível ao tipo de caixa das letras.

Compilando o código fonte

Para criar o código binário, chamamos o compilador Java através da linha de comando, do seguinte modo:

javac AloPessoal.java

Com isso, será criado um arquivo binário (desde que tudo corra bem) com mesmo nome do arquivo original, mas com sufixo .class no lugar de .java. No nosso caso, teríamos um arquivo AloPessoal.class. Entre as (muitas) coisas que poderiam dar errado nesse momento, o código fonte pode conter erros. Esse não deverá ser o caso, se tiver digitado o programa exatamente como aparece acima. Se, porém, o compilador emitir mensagens de erro, será preciso identificar as linhas que estão incorretas, corrigí-las no editor, e chamar o compilador novamente. As linhas que contém algum tipo de incorreção são listadas pelo compilador juntamente com seu número, facilitando sua localização no editor.

Executando o código

11

Para podermos executar o programa é necessário chamar o interpretador Java, pois, como vimos, os bytecodes foram feitos para rodar em uma Java Virtual Machine. Podemos fazê- lo do seguinte modo:

java [nome da classe]

onde [nome da classe] é o nome do arquivo sem o sufixo .class. Em nosso caso, este será AloPessoal. Ao executar o programa, ele deverá exibir na tela a frase:

Alo pessoal!

Se isto não ocorrer, volte atrás e verifique se o programa foi digitado exatamente como aparece na listagem acima.

Este é um programa muito simples. Porém, a boa compreensão das estruturas presentes nele deverá permitir a programação fluente em Java em pouco tempo.

Entendendo a estrutura do programa

Todo programa Java, deve conter ao menos uma declaração da forma

public class [nome] { public static void main(String args[]) {

}

}

Onde [nome] é o nome da classe e a parte "

programa. O nome de uma classe é um identificador, como qualquer outro presente no programa, porisso não deve conter espaços ou outros caracteres gráficos, isto é, deve ser um nome composto de uma seqüência de caracteres que seja válida para um identificador. Outros exemplos de identificadores são nomes de variáveis, nomes de comandos, etc.

é o código Java válido, a ser executado no

"

Vamos adiar um pouco a complicação sobre o que vem a ser uma classe, pois isso depende de alguns conceitos da programação orientada a objetos. Por hora, vamos apenas aceitar que todo programa Java deve conter ao menos uma classe, e que é dentro de uma classe que vão os dados e os procedimentos. Notemos ainda que todo programa Java (mas não as applets) deve ter uma classe dotada de um procedimento chamado main. Os procedimentos em Java são chamados métodos. Os métodos encerram um conjunto de declarações de dados e de comandos que são executados mediante a chamada do método por seu nome. Vamos estudar os métodos em detalhe mais adiante. O método main é o ponto onde se dá o início da execução do programa, isto é, um método chamado automaticamente pela JVM.

12

Voltando ao nosso programinha AloPessoal, o código a ser executado é

System.out.println("Alo pessoal!");

System.out.println é o nome de uma função que serve para escrever informações textuais na tela. Os dados a serem escritos, devem estar delimitados entre os parênteses "(" e ")". "Alo pessoal!" é uma frase. Em computação, uma palavra ou uma frase que tenha função literal é denominada string. Em Java, a representação de uma string constante se dá colocando os caracteres entre aspas, por exemplo: "Imagem", "Rio de Janeiro", "Brasília", etc, são strings constantes.

Note que existe um ; (ponto e vírgula) no final da linha, logo após o ")". Em Java, é obrigatório colocar um ponto e vírgula após cada comando. Isso porque um comando pode ser quebrado em múltiplas linhas, sendo necessário sinalizar de algum modo onde é que o comando termina.

Java é sensível ao tipo de caixa, isto é, distingue caixa alta (maiúsculo) da caixa baixa (minúsculo). Os programadores acostumados a linguagem C e C++ vão certamente sentir-se em casa; porém os programadores acostumados à linguagem PASCAL devem ficar mais atentos.

Mais exemplos

Podemos escrever "Alo pessoal!" escrevendo primeiro, "Alo " e depois, "pessoal!". Para isso, o programa deve ser alterado da seguinte forma:

public class Alo { public static void main(String args[]) { System.out.print("Alo "); System.out.println("pessoal!");

}

}

Para escrever dados genéricos na tela, existe o comando System.out.print que escreve o dado e mantém o carro na mesma linha. Há também o System.out.println que escreve dados e muda o carro para a próxima linha.

Podemos concatenar dois ou mais strings usando o operador "+". Por exemplo, "Alo " + "pessoal!"

é o mesmo que "Alo pessoal!". Para escrever um número, basta escrever [string]+n onde [string] é um string qualquer e n é um número. Por exemplo:

13

public class Numero { public static void main(String args[]) { System.out.println("O valor é " + 29);

}

}

Como o lado esquerdo da expressão é um string, 29 é convertido para string "29" e é concatenado com "O valor é ". Compilando e executando esse exemplo como fizemos anteriormente, devemos obter na tela:

O valor é 29

Observemos que os comandos System.out.print e System.out.println escrevem uma informação de cada vez. Desta forma, precisamos usar "+" para unir "O valor e " com 29 para formar uma única string. No exemplo acima, nada impede que os dados sejam escritos em duas etapas: primeiro, "O valor e " e depois, 29. Neste caso, teríamos:

public class Numero { public static void main(String args[]) { System.out.print("O valor e ");

System.out.println(29);

}

}

Entretanto, a primeira abordagem parece mais razoável pois torna a programação mais clara e concisa, além de economizar comandos.

Usando variáveis

Uma variável é simplesmente um espaço vago, reservado e rotulado para armazenar dados. Toda variável tem um nome que a identifica univocamente e um valor, que corresponde à informação a ela atribuida. Por exemplo, int n; especifica que n é o nome de uma variável que pode armazenar um número inteiro como valor. Em geral, num contexto onde aparece o nome de uma variável ocorre a substituição por seu valor. O valor de uma variável pode mudar muitas vezes durante a execução de um programa, por meio de atribuições de valor.

Há diversos tipos de variáveis em Java, correspondendo aos vários tipos de dados aceitos. A discussão sobre esses tipos de dados será feita no próximo capítulo. Antes porém, vamos fazer um pequeno programa que declara uma variável interira, atribui a ela uma constante, e imprime seu valor na tela.

public class Numero { public static void main(String args[]) {

14

int n; n = 17+21; System.out.println("O valor numérico é " + n);

}

}

O

local onde uma variável está declarada é extremamente importante. Uma variável é

conhecida apenas dentro de algum escopo. Por exemplo, uma variável declarada no escopo

de uma classe (fora de um método) é conhecida por qualquer método que esteja declarado

dentro dessa mesma classe, enquanto uma variável declarada no escopo de um procedimento é conhecida apenas por esse procedimento. Há ainda outros tipos de escopo, como veremos mais adiante.

O sinal "=" é um operador, utilizado para atribuir um valor a uma variável. Por exemplo, n

= 1; faz com que o valor 1 seja armazenado na variável n. Há também os operadores usuais de adição, subtração, multiplicação e divisão de números. Estes são representados pelos símbolos "+ ", "-", "*" e "/", respectivamente.

Ao executar o programa acima (claro, depois de compilá-lo), ele escreve

O valor numerico é 38

Introduzindo comentários no código

Um comentário é uma porção de texto que não tem função para o compilador Java, mas é útil ao leitor humano. Assim sendo, um comentário é identificado mas ignorado completamente pelo compilador Java. A utilidade dos comentários é óbvia: deve conter explicações sobre um particular desenvolvimento do código, permitindo ao leitor compreender claramente o que se deseja realizar.

Os comentários são introduzidos no código Java de duas formas distintas:

Colocado em qualquer parte do programa e delimitado entre "/*" e "*/".

Escrevendo "//" antes do comentário, que se estenderá até o final da linha.

Por exemplo, o código:

// // Este é um exemplo de como somar dois numeros // public class Numero { public static void main(String args[]) { /* Método principal */ double x,y; // estes sao numeros reais de dupla precisao

15

// System.out.print("x = 2.0"); /* inicializando o "x" */

x = 2;

y = 3.0; /* iniciando o y, e fazendo y = y+x; */ y = y + x; // escrevendo a soma System.out.println("x+y = " + (x+y));

}

} /* fim de Numero */ é equivalente ao código:

public class Numero { public static void main(String args[]) { double x,y;

x = 2;

= 3.0;

y y = y + x;

System.out.println("x+y = " + (x+y));

}

}

Observação: double é um tipo de dado que indica um número real de dupla precisão.

No próximo capítulo, vamos estudar detalhadamente os tipos de dados aceitos pela linguagem Java.

No próximo capítulo, vamos estudar detalhadamente os tipos de dados aceitos pela linguagem Java. [ seguinte

16

Compilação e execução de um programa em Java

Ficheiro

Hello.java

// Java Hello World

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

}

}

17

Aplicações Com o Netbeans

O Netbeans é um ambiente integrado de desenvolvimento (IDE) que permite ao programador criar programas utilizando recursos gráficos. Para trabalhar com o NetBeans é necessário ter instalado, anteriormente em sua máquina uma das versões do JDK (Java), preferencialmente uma versão igual ou superior a J2SDK1.3.1.

NOTA: Antes de iniciar a construção dos exemplos é interessante conhecer um pouco da sintaxe básica da linguagem para facilitar o seu entendimento.

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 ou algo parecido, isto vai depender do tipo da instalação/ SO/ Número de vezes que o mesmo já tenha sido executado:

3.1. Criando uma Aplicação MDI:

- Composta de:

1. Um Formulário principal

2. Um Menu

- Passos:

1º - Clique no menu File New: será exibida uma tela;

2º - Dê um duplo clique em Java GUI Forms;

3º - Selecione Sample Form MDI Aplication com isto criaremos uma aplicação composta de um formulário com um menu e que aceita a abertura de outros formulários;

4º - Clique no botão NEXT;

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

18

6º - Será mostrada uma tela informando o nome da Aplicação e o nome do Package criado,

a superclasse que será estendida e as classes a serem implementadas. Não mude as opções padrão, clique no botão Next;

7º - Clique no botão Next;

8º - Clique no botão Next;

9º - Clique no botão Finish;

A IDE abrirá uma tela. O NetBeans trabalha com varias mini-telas com finalidades especificas, todas de forma integradas a janela principal, a barra de menu.

- Caso queira aumentar ou diminuir a área de visualização de uma destas basta passar o mouse e redimensiona-las de acordo com a necessidade do programa.

- Para visualizar uma destas janelas clique no Menu View e selecione a Janela desejada. Ex:

Source Editor ou Form Editor

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

3.2 Componentes da Janela em modo de Trabalho

3.3 Compilando: Clique no Menu Build Compile ou Pressione F9

3.4 Executando: Clique no Menu Build Execute ou Pressione F6

Na execução da aplicação o formulário / janela abre exibindo apenas o menu, isto porque não tem nenhum componente, verifique o menu sair, observe que o mesmo já foi implementado pelo NetBeans. Agora vamos inserir alguns componentes, procure deixar a sua aplicação parecida com a seguinte Tela no modo formulário. (Lembre-se que é possível alternar entre as telas de código e formulário clicando no menu View e selecione Form Editor/Source Editor).

3.5 Trabalhando com componentes:

- Na janela no canto superior direito, que mostra os componentes da aplicação, clique o Botão direito do mouse sobre BorderLayout e selecione Set Layout AbsolutLayout

NOTA: - Esta mesma operação pode ser efetuada clicando-se com o botão direito do mouse sobre a área do Formulário e selecionando SetLayout AbsolutLayout.

- É necessário modificar o Layout para que se possa colocar os componentes (botões,

Labels, etc.) na posição desejada, isto porque o Formulário (JFrame/Frame) quando é

19

criado tem como padrão o Layout BorderLayout que trabalha de forma diferente. Mais a frente será abordado de uma forma melhor sobre os Layout.

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

-

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

-

Insira outros componentes e mude suas propriedades realizando experiências, compilando

e

executando, para visualizar os resultados.

Criando uma Aplicação: - primeiro é necessário criar um projeto. Selecione General Java Application Next;

Em Project digite o nome Desejado.

Criando um Programa: File New File Java GUI Form JFrame Next;

Na nova janela que se abre digite o nome do Programa e clique no Botão Finish

Insira os componentes desejados

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

NOTA: Os exemplos que serão apresentados foram implementados utilizando o NetBeans 3.5.1, que se diferencia visualmente muito pouco em relação a versão 4.0 , posto que serão exemplos simples. Se for utilizar a versão 4.0 os passos a serem executados são os mesmos, salvo exceção quanto à criação do Projeto que já foi demonstrado.

Aplicações Gráficas com Swing

Assunto: Aplicações Gráficas com Swing

Objetivo: criar aplicações Gráficas utilizando Swing

Aplicações Gráficas com Swing

20

Nova família de componentes com funcionalidade ampliada e grande capacidade de configuração. O seu propósito é permitir a criação de interfaces versáteis e sofisticadas. Surgiu em 1997 com a JFC (Java Foundation Classes), com o Java 2, que engloba:

- Componentes Swing

- Compatibilidade com múltiplas ´Look and Feel` - peles

- Biblioteca de acessibilidade monitores e teclados especiais

- Biblioteca Java 2D

- Compatibilidade com `Drag and Drop`

Principais Componentes

Os seus componentes são semelhantes ao da AWT (Abstract Window Toolkit), pois o modelo de eventos é o mesmo.

Diferenças: Componentes Swing são mais flexíveis e mais numerosos não utilizam código nativo, seus nomes iniciam com um J. A base para uma aplicação é o JFrame ou JWindow ( janela) ou a classe JApplet (miniapplicativos). JFrame não é um mero container, mas um painel especial que agrega três outros componentes em camadas destes o que nos interessa é o ContentPane (painel de conteúdo), onde vamos inserir os demais componentes:

Container conteudo= getContePane();

a) JLabel: rótulo de texto.

Métodos específicos:

String getText() retorna o texto do label

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

b) JButton: é um botão simples que pode ser criado com ou sem rótulo.

Métodos específicos:

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

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

21

c) JTexField e JTextArea

TextField: caixa de entrada de texto, possibilita a entrada e a edição de uma linha de texto.

TextArea: caixa de entrada de texto com múltiplas linhas. Exibe barra de rolagem horizontal e vertical.

Principais métodos:

String getText() retorna o texto contido no TextField

void setText(String txt) ajusta o texto da TextField para txt

d) JList e JCombobox

JList: caixa de lista que permite a exibição de uma lista de itens que não podem ser editados diretamente pelo usuário.

JCombobox: implementa uma lista de itens em que um único item selecionado é exibido.

Principais métodos:

int getSelectedIndex(); retorna índice do item selecionado

String getSelectedItem(); retorna o nome do item selecionado

void select(String str); ajusta o item selecionado para str

Métodos Comuns a Todos os Componentes

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

void move(int x, int y) Mover componente

void setForeground(Color x) Cor do componente

void setBackground(Color y)

Cor de Fundo do componente

void disable() Desabilitando componente

void enable() Habilitando componente

22

Gerenciadores de Layout

Gerenciamento de layout ( Layout Management ) é o processo de determinar o tamanho e a posição dos componentes na janela gráfica do programa, ou seja determinar onde os componentes irá ficar guiando a maneira como os elementos de interface serão dispostos dentro do container (Frame, Panel, Window).

Existem basicamente os seguintes tipos de layout:

a) FlowLayout

b) BorderLayout

c) CardLayout

d) GridLayout

e) GridBagLayout

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

a) FlowLayout

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

b) BorderLayout

É o Padrão: Divide a janela em cinco áreas nas quais os componentes podem ser exibidos:

norte, sul, leste, oeste e centro.

c) CardLayout

Permite apresentar dois ou mais componentes (geralmente painéis) compartilhando o mesmo espaço de apresentação. Funciona como uma pilha de cartas onde apenas uma fica visível.

- Cria-se um Painel fixo de Controle e um genérico (CardLayout) para conter outros painéis.

23

Deixa todos os componentes com igual tamanho, exibindo-os como uma tabela (linhas e colunas).

e) GridBagLayout

É o mais flexível dos gerenciadores de layout, permite colocar componentes em grades de

colunas, sendo possível um componente ocupar mais de uma coluna ao mesmo tempo. As linhas também não precisam necessariamente ter os mesmos tamanhos, ou seja, você pode configurar diferentes larguras e alturas de acordo com a necessidade. No entanto, é o mais difícil de ser implementado.

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

Assunto: Aplicações Gráficas com Swing Construindo aplicações com o NetBeans

Objetivo: criar aplicações Gráficas utilizando Swing

Utilizando JLabel, JTextField e JButton com o NetBeans.

1. Crie uma aplicação para somar os valores de duas Notas Fiscais a serem informados pelo usuário:

Nesta Aplicação utilizaremos dois JTextField (onde o usuário irá digitar os valores) um JLabel (mostrar o resultado da soma) e um botão a ser clicado para efetuar a soma.

Abra o NetBeans Clique no Menu File New Dê um Duplo clique em Java GUI Forms Selecione JFrame Form Clique no Botão Next. Na nova janela que se abre Digite JCalculadora" Clique no Botão Finish, seu projeto será iniciado

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

NOTA: - O AbsoluteLayout é um gerenciador de Layout criado especificamente para o

NetBeans, portanto se for utiliza-lo sem o NetBeans terá de acrescentar o respectivo pacote

e distribuí-lo juntamente com o seu programa. Caso contrário o mesmo não executará corretamente.

24

- O Null Layout não é um gerenciador de Layout, mas corresponde à situação em é desativado uso dos gerenciadores, neste caso a posição dos componentes é explicitamente definida através de métodos específicos que a ferramenta se encarrega de manipular, mas os mesmo não vale para o Formulário (Frame/JFrame), onde se faz necessário a utilização do método setBounds:

Ex: setBounds (10,10,300,400);

// abre o tela na posição largura 10, altura 10, com uma largura de 300 e altura 400.

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

Na janela do Centro do vídeo, embaixo da Aba Swing , existem vários ícones representando os respectivos componentes, passe o mouse sobre os mesmos e aparecerá o nome, clique no primeiro, JLabel", e clique no Form, Clique no segundo, JButton , e clique no Form, Clique no nono, JTextField , e clique no Form (dois JTextField), insira mais dois JLabel e outro JtextField.

Na janela Propriedade modifique as propriedades dos componentes de acordo com ao que se segue:

Componente

Propriedade

Valor

JFrame

Title

Calculadora

JLabel1

Text

Número 1

JLabel2

Text

Número 2

JLabel3

Text

Resultado

JTextField1

Text

JtextField2

Text

JButton1

Text

Somar

A parte visual já foi criada precisamos implementar o código no botão para efetuar a soma ( pegar os números e somá-los).

Dê um Duplo clique no botão e na janela de código que aparece digite:

double num1=Double.parseDouble(jTextField1.getText()); // converte texto para double

double num2=Double.parseDouble(jTextField2.getText());

25

double result = num1 + num2;

String R= String.valueOf(result); //Converte o Resultado para String

jLabel3.setText("Resultado: "+R); //exibe no JLabel o Resultado

Observe que os nomes dos componentes (jLabel3) começam com letras minúsculas.

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

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

Após initComponents(), insira o seguinte comando:

setBounds(10,10,300,400);

Se precisar voltar para o modo Form Editor clique no Menu View Form Editor ou Crt+8.

Para ir para o código clique no menu View Source Editor ou Crt+3.

Compile Menu Build Compile (F9), execute Menu Build Execute (F5).

Criando uma Calculadora

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

Componente

Propriedade

Valor

Propriedade

Valor

JButton2

Text

Diminuir

Mnemonic

D

JButton3

Text

Multiplicar

Mnemonic

M

JButton4

Text

Dividir

Mnemonic

V

JButton5

Text

Limpar

TooltipText

Limpar as caixas de Texto

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

26

double num1=Double.parseDouble(jTextField1.getText()); // converte texto para double

double num2=Double.parseDouble(jTextField2.getText());

double result = num1- num2;

String R= String.valueOf(result); //Converte o Resultado para String

jLabel3.setText("Resultado: "+R); //exibe no JLabel o Resultado

Repita o processo nos outros botões modificando apenas a operação matemática.

Dê um duplo clique no botão Limpar e digite:

jTextField1.setText(" "); // limpa a caixa de texto

jTextField2.setText(" ");

jTextField1.requestFocus(); //muda o foco para a caixa 1

Compile (F9) e execute (F6).

Para criar um arquivo que é executado diretamente pelo Windows basta criar

um arquivo .Bat :

Abra o Bloco de Notas e digite: java Jcalculadora;

Salve com um nome qualquer e com a extensão Calculadora.Bat , na mesma pasta do programa:

OBS: Lembre-se que o Layout AbsoluteLayout é EXCLUSIVO do NetBeans, sendo que para utiliza-lo efetivamente na sua aplicação, você deverá incluir no seu projeto o respectivo pacote, senão na execução ocorrerá erros, ou modifique o Layout para Null Layout e defina o tamanho de seu Frame/JFrame para que o mesmo possa ser visualizado no tamanho desejado (setBounds()), caso contrário o mesmo aparecerá mostrando somente a barra de titulo.

OBS2: Para fins de agilizar a construção dos exemplos será utilizado o Layout AbsoluteLayout , mas se for construir comercialmente um programa, o mesmo deverá ter o Layout Null Layout .

Utilizando JCombobox/Jlist e JRadioButton JCombobox/JList

27

a) Criar uma aplicação para informar qual a forma de pagamento selecionada

pelo usuário: Cheque, Cartão ou Dinheiro:

Clique no Menu File

New

Java GUI Forms

clique em JFrame Form

clique em Next

Na Janela que se abre digite FormaPaga clique no botão Finish

Modifique o Layout para AbsoluteLayout

Clique no Form e modifique a propriedade Title do Form para Forma de Pagamento

Clique no sétimo ícone JCombobox" e clique no Form, na Janela Propriedades

clique em Model

clique no Botão

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

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

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

A parte visual foi criada, falta o código. Para saber qual a opção selecionada utilize o Método:

Object getSelectedItem().

Dê um duplo clique no botão Escolher e digite :

String S= (String) jComboBox1.getSelectedItem();//converte em String

jLabel1.setText("A opção escolhida foi: " + S); //exibe opção no Jlabel

Compile (F9) e Execute (F6).

28

Se desejar também é possível saber o índice: getSelectedIndex()

A utilização do JList é idêntica a vista a cima, basta substituir o método

getSelectedItem(), por getSelectedValue().

Utilizando JRadioButton com o NetBeans

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

Crie uma nova Template JFrame Form Motor , clique no Menu File New

No Form que se abre Clique no sexto ícone ButtonGroup e clique no Form para criar um grupo de radio e permitir a seleção de apenas uma opção

Clique no quinto ícone JRadioButton" e clique no Form, na janela Propriedades selecione Text e digite Motor 1.0 . Selecione a propriedade buttonGroup e clique em buttonGroup1 , repita todo o processo por duas vezes para criar a opção Motor 1.6 e Motor 2.0

Insira um JLabel, Text: Opção Escolhida , no Form e um JButton, Escolher .

Para

saber

qual

a

opção

esta

marcada

isSelected(), que devolve true ou false.

devemos

utilizar

o

Método

boolean

Dê um duplo clique no botão para inserir o código:

if (jRadioButton1.isSelected()) //verifica se a opção esta marcada -true

jLabel1.setText("Motor escolhido: 1.0"); //exibe opção no JLabel

if (jRadioButton2.isSelected()) //verifica se a opção esta marcada -true

jLabel1.setText("Motor escolhido: 1.6");

if (jRadioButton3.isSelected()) //verifica se a opção esta marcada -true

jLabel1.setText("Motor escolhido: 2.0");

Para saber qual é o Texto exibido pelo JRadioButton basta utilizar o Método:

String getText().

Ex: String s=jRadioButton1.getText();

29

Aplicações Gráficas com Swing Componentes Especializados

Assunto: Aplicações Gráficas com Swing Componentes Especializados

Objetivo: Criar aplicações utilizando componentes especializados Swing.

JOptionPane

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

Mensagens

Entrada de Texto

Janelas de Confirmação

Exemplos:

//Mensagem

JOptionPane.showMessageDialog( this, mensagem );

// Confirmação

int x = JOptionPane.showConfirmDialog( this, Mensagem1 );

// Entrada de Texto

String s= JOptionPane.showInputDialog( Mensagem 2 );

int x = JOptionPane.showConfirmDialog(this, "Confirmar? , "Aplicação",

JOptionPane.OK_CANCEL_OPTION,

JOptionPane.QUESTION_MESSAGE);

Nas IDE como NetBeans é possível inserir um objeto visual, mas não é possível controlar as ações dos respectivos botões.

Se quiser utiliza-los no Netbeans, insira-os dentro de um método actionPerformed de um JButton.

30

Exemplo: - Criar um Programa contendo um botão que ao ser pressionado exiba informações sobre o programa:

- Crie uma nova Template JFrame Form Mensagem , Menu File New

- Mude o Layout para AbsoluteLayuot

- Insira um JButton Mensagem , dê um duplo clique para inserir o código:

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

// o \n foi utilizado para mostrar como inserir uma quebra de linha.

- Este componente pertence ao pacote Swing que deve ser importado através do import

- Procure no código o comando que cria a classe, que está no início do programa:

public class Mensagem extends javax.swing.JFrame {

- Antes deste comando insira o código:

import javax.swing.*; //importa os componentes do pacote swing

- 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

Componetes (JLabel, JTextField, JButton

JFileChooser

).

Janelas de dialogo para seleção de arquivos:

Abrir (Open)

Salvar (Save)

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

JFileChooser arq= new JFileChooser();

int Result=arq.showOpenDialog(this);

31

if(Result==JFileChooser.APPROVE_OPTION){

File arquivo= arq.getSelectedFile(); //Classe paraArquivos

System.out.println(arquivo); //Imprime nome do Arquivo

}

}

}

Classe File: suporte para tratamento de arquivos:

FileReader/FileWrite FileInputStream / FileOutputStream

- são usados para ler ou gravar arquivos no sistema:

FileReader in = new FileReader("Entrada.txt");

FileWriter out = new FileWriter ("Saida.txt");

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

read() e write(String s)

while ((int c=arqin.read()) !=-1){ // lê Entrada.txt

out.write(c); // grava em Saida.txt

System.out.write(c); // direciona para o vídeo

}

out.write(p); // gravar a String no final do arquivo

in.close(); // fecha os arquivos

out.close();

}

}

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

32

Crie uma nova Template, Java Gui Form JFrame Form

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

try{ // Blco de Tratamento de erros/exceções nos arquivos

File arquivo; //Objeto para arquivos

JFileChooser arq= new JFileChooser(); // objetos de seleção de arquivo

int Result=arq.showOpenDialog(this); // mostra a janela de seleção de arquivo

if(Result==JFileChooser.APPROVE_OPTION){ //verifica se foi seleciona um arquivo

arquivo = arq.getSelectedFile(); //verifica o arquivo selecionado

int c; //variável para receber os Bytes do arquivo

String Texto=""; //variável para receber os dados do arquivo

FileReader inArq = new FileReader(arquivo.getPath()); //abre o arquivo para leitura

while((c = inArq.read())!=-1){ //lê Byte por Byte até o final do arquivo (-1)

Texto=Texto+(char)c; // transforma o Byte lido em um char

} //final do while

jTextArea1.setText(Texto); // exibe no JTextArea o conteúdo lido do arquivo

inArq.close();

} // final do if

} catch (IOException ioe) { // verifica qual foi o erro/exceção

JOptionPane.showMessageDialog(this,"erro ao abrir o arquivo"); // mensagem de erro

}

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

import java.io.*;

import javax.swing.*;

33

É possível acrescentar um outro botão para salvar novos textos que o usuário pode inserir

no JTextArea:

Acrescente um novo JButton Salvar , dê um duplo clique e digite:

try{

File arquivo;

JFileChooser arq= new JFileChooser();

int Result=arq.showSaveDialog(this);

if(Result==JFileChooser.APPROVE_OPTION){

arquivo = arq.getSelectedFile(); //Classe para Arquivos

FileWriter inArq = new FileWriter(arquivo.getPath());

inArq.write(jTextArea1.getText()); // lê o arquivo

inArq.close();

}

}catch(IOException ioe) {

JOptionPane.showMessageDialog(this,"erro ao abriri o arquivo");

} // Add your handling code here:

}

Estes comandos podem ser inseridos em um Menu.

A primeira aplicação criada como exemplo, representa a criação de editor de texto já

composto de um Menu, mas que não possui os respectivos códigos para efetuar as operações de abrir um documento e salvá-lo. Experimente implementar os respectivos códigos nessa para efetivamente criar um editor de texto.

JEditorPane

Painel de Conteúdo é uma área de texto especializada na exibição e edição de vários tipos

de conteúdo: texto simples(text/plain), HTML(text/html) e RTF Rich Text Format(text/rtf).

Exemplo: Criar um Programa que permita exibir um arquivo com extensão .html ou .htm

34

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)

Insira um objeto JButton, Selecionar Página, digite o código :

JFileChooser arq = new JFileChooser();

int result=arq.showOpenDialog(this);

if(result==JFileChooser.APPROVE_OPTION){

try{

File arquivo= arq.getSelectedFile();

URL pagina= new URL("file:"+arquivo.getPath());

jEditorPane1.setPage(pagina);

} catch(MalformedURLException mue) {

JOptionPane.showMessageDialog(this,"Erro na página");

}catch( IOException ioe){

JOptionPane.showMessageDialog(this,"Erro no arquivo");

}

}

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

import javax.swing.*;

import java.net.*;

import java.io.*;

Compile e Execute.

Trabalhando Múltiplos Formulários - Menus.

35

Assunto: Aplicações Gráficas com Swing Múltiplos Formulários.

Objetivo: Criar aplicações com Vários Formulários

Criando Múltiplos Formulários - Menus

Para se construir uma Aplicação contendo vários Formulários é preciso criá-los em separados e chamá-los em um Formulário Principal através de Botões ou de Menus.

No Formulário Principal a chamada dos outros formulários consiste em se criar instâncias dos respectivos formulários que se deseja exibir, utilizando o método show(), ou

o método setVisible(boolean).

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

Exemplo

Criar uma Aplicação contendo um Menu que exibi os Formulários de Cadastro de Clientes

e de Veículos

Clique no Menu File New Java GUI Forms Botão Next em Name

digite SistLocação Clique no Botão Finish

É preciso criar o Menu.

Na Aba Swing, clique no ícone JMenuBar e clique no Form na Janela Propriedades clique em Text e digite Cadastro (texto que será exibido pelo Menu)

Clique com o botão direito do mouse sobre o Menu criado e selecione

Add JMenuItem

na janela propriedade clique em Text e digite Clientes

clique novamente com o botão direito do mouse sobre o Menu criado e selecione

Add JMenuItem clique em Text e digite Veículos.

36

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

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

Crie um Novo Form Clique no Menu File

New clique no Botão Next em

Name digite Clientes clique no botão Finish

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

Devemos modificar o comando responsável pelo fechamento do Form, para que não feche a Aplicação.

Clique com o botão direito do mouse no Form e clique em Goto Source ou pressione Ctr-3 , procure o comando, que deve estar antes do método main:

private void exitForm(java.awt.event.WindowEvent evt) {

Apague o comando:

System.exit(0);

E digite no seu lugar:

setVisible(false);

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

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

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

private void jMenuItem1ActionPerformed

Antes deste comando digite:

Clientes FormCliente = new Clientes(); //instanciação do Formulário Clientes

Se tiver criado a Template com outro nome substitua o nome Clientes por este nome.

37

E dentro do método, depois de // Add your handling code here: digite:

FormCliente.show(); //exibição do Formulário Clientes

Compile e Execute.

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

Clique no Menu File New Next

digite o Nome Veículos

clique no botão Finish

Mude o Layout e insira os componentes (JLabel e JTextField), vá para o código e modifique o comando System.exit(0) para setVisible(false)

Volte para o Form SistLocação e dê um duplo clique em JMenuItem2, antes do respectivo método actionPerformed instancie o Form:

Veículos FormVeiculo = new Veículos(); //instanciação do Form

Dentro do método digite o comando para exibição:

FormVeiculo.show();

Compile e Execute. Seu Pequeno Sistema foi Criado

Applets Funcionamento e Estrutura

Assunto: Applets: Funcionamento e Estrutura

Objetivo: escrever mini-aplicativos java que rodam na internet e intranet.

Applets

São pequenos programas Java que podem ser inseridos dentro de páginas HTML.

Interagir com o usuário que a consulte

Pode executar tarefas complexas, como realizar cálculos e apresentar gráficos, sons e imagens em movimento.

38

Applets: Funcionamento

Para inserir uma applet numa página HTML, usamos a diretiva <applet>, que deve apresentar pelo menos três parametros: code, width e height.

Assim, a especificação mais simples tem a forma:

<applet code=[java applet] width=[largura] height=[altura]> </applet>

[java applet]: nome da classe principal do programa Java

AloPessoal.class

[largura] e [altura]:indicam a largura e a altura em pixels da área dentro da página reservada para a apresentação da applet. Uma applet deve conter ao menos uma classe pública, e essa classe pública deve estender a classe Applet.

A classe Applet faz parte do package applet:

import java.awt.*; //importação dos componentes

import java.applet.*; //importação da classe Applet

public class AloPessoal extends Applet {

public void paint(Graphics g){ //método para desenho

g.drawString("Alô Pessoal!", 100, 20); // desenha um texto

}

}

Este programa deve ser compilado, e após a depuração dos erros é informado o arquivo gerado: .class, no arquivo html através do parâmetro code (code = ArquivoJava.class) é informado qual o arquivo Java a ser utilizado na página HTML.

Arquivo Html (com um nome qualquer, Ex: Alo.html):

<applet code= AloPessoal.class width=120 height=120> </applet>

Parâmetros adicionais:

- codebase: URL do diretório que contém as classes compiladas (bytecodes) do applet

- name: Um nome que identifica uma particular instância de um applet dentro de uma página HTML (útil para comunicação entre applets).

39

- align: especifica um alinhamento para a área da applet dentro da página. Análogo ao alinhamento de imagens.

- alt: Texto a ser exibido na área da applet durante o carregamento, ou na impossibilidade de carregar a applet.

Applets: Estrutura

A classe Applet define quatro métodos básicos para controlar a execução e interação com o

browser:

a) init(): executado quando a applet e carregada ou recarregada adição de componentes,

recebimento de parâmetros de execução e preparo da applet

b) start(): executado após o método init ou ao ser recarregada deve ser utilizado quando é

necessário assegurar alguma condição especial.

c) stop(): executada quando o usuário muda de página permanecendo na memória, ou fecha

o browser.

d) destroy(): executada quando a applet for removida da memória.

paint(), é definido pela classe Component da AWT: atualiza a exibição da applet

A maneira mais simples de se construir uma applet é por meio do método paint o conteúdo

apresentado só depende desse método.

A combinação destes métodos representa o ciclo de vida de uma applet.

Criando Applets no NetBeans

A criação de Applet utilizando o Netbeans é uma tarefa simples, devendo ser criado apenas o programa Java, o Applet, porque a ferramenta cria automaticamente o corresponde arquivo HTML, com o mesmo nome do seu programa, contendo os códigos para executar a página web.

1) Criar um Applet que permita ao usuário digitar dois números reais e mostrar o resultado da soma destes:

A criação de Applet no Netbeans é feita através de Templates, é possível trabalhar com a

Classe Applet do pacote AWT ou com a classe JApplet do pacote Swing.

40

O Exemplo que se segue, será implementado utilizando o JApplet.

Clique no menu File

New

Java GUI Form JApplet Form

clique no Botão Next

digite o nome Calculadora e clique no botão Finish.

Antes de inserir os componentes modifique o Layout para NullI Layout , para poder organizar os componentes da maneira desejada. Clique com o botão direito do mouse, na janela no canto superior direito, em JApplet e selecione Null Layout

Insira três JLabel ( Número 1: e Número 2: ), dois JTextField, quatro JButton( Somar , Diminuir , Multiplicar , Dividir ).

Para inserir um atalho para o botão, digite a letra desejada na propriedade Mnemonic

A parte visual foi criada, falta os eventos dos botões.

Dê um duplo clique botão Somar e digite:

float op1,op2, result; // variáveis auxiliares "pega" o número digitado e o converte para

float

op1=Float.parseFloat(jTextField1.getText());

op2=Float.parseFloat(jTextField2.getText());

result=op1+op2; //converte o resultado em String e exibe

jLabel3.setText(String.valueOf("Resultado: " + result));

jTextField1.setText(" "); //Limpar o JTextField

jTextField2.setText(" ");

jTextField1.requestFocus(); //muda o foco para o JTextField 1

Compile e Execute.

Observe que ao executar o programa o mesmo é mostrado no Applet Viewer, um aplicativo do JDK construído para auxiliar na implementação dos applets, e gera automaticamente o arquivo HTML com o mesmo nome do programa applet.

41

Para visualisar o arquivo HTML, clique no menu View FileSystem, e dê um duplo clique no arquivo com o mesmo nome do programa, mas do tipo HTML

Se desejar modifique a área destinada a mostrar o applet no browser, modifique no arquivo HTML os valores dos códigos WIDTH (Largura do Apllet) e HEIGHT( Altura). Ex:

<APPLET codebase= </APPLET>

code="Applets/JCalculadora.class" width=350 height=250>

Para executar o arquivo, ou seja, abrir no browser basta executar (F6):

Para implementar as operações matemáticas (eventos) dos outros botões, dê um duplo clique no botão e digite o mesmo código do botão soma e modificando apenas o sinal de soma para a operação desejada. Exemplo para o botão Subtrair

float op1, op2, result; // variáveis auxiliares "pega" o número digitado e o converte para float

op1 = Float.parseFloat( jTextField1.getText() );

op2 = Float.parseFloat( jTextField2.getText() );

result = op1- op2;//converte o resultado em String e exibe

jLabel3.setText( String.valueOf( "Resultado: " + result) );

jTextField1.setText(" "); //Limpar o JTextField

jTextField2.setText(" ");

jTextField1.requestFocus(); //muda o foco para o JTextField 1

Também é possível exibir os resultados das operações utilizando um JOptionPane.

2) Crie um Applet que informa o valor do empréstimo, que é calculado conforme o valor do saldo médio digitado pelo usuário (até R$ 1000,00 zero, de R$ 1001 até 2500 30% do Saldo Médio, acima de R$ 2500 50% do Saldo Médio):

Crie um Novo Programa: File New Java GUI Form JApplet digite o nome Empréstimo Finish

Clique com o Botão direito do mouse no Form, selecione setLayout e clique em Null Layout .

42

Insira dois JLabel no Form, modificando as propriedade Text para Saldo Médio e Valor do Empréstimo , insira um JTextField e um JButton, modifique a propriedade Text para Calcular .

Dê um duplo clique no botão e digite os comandos:

float saldo; //variável auxiliar

try{ //tratamento de erros do valores

saldo = Float.parseFloat(jTextField1.getText()); // pega o valor digitado e converte

//verificação dos valor digitado e do empréstimo que pode ser concedido

if (saldo<1000)

jLabel2.setText("Valor do Empréstimo: Zero");

if ((saldo>=1000) & (saldo<=2500))

jLabel2.setText("Valor do Empréstimo: " + saldo * 0.3);

if (saldo>2500)

jLabel2.setText("Valor do Empréstimo: " + saldo * 0.5);

}catch (Exception e){ //exibe mensagem caso não seja digitado um valor válido

jLabel2.setText("Não é um Valor Válido");

}

Compile e Execute.

Banco de Dados No NetBeans

Assunto: Acessando Bancos de Dados.

Objetivo: criar programas que acessam Banco de Dados.

Acessando Bancos de Dados

43

A comunicação de código Java puro com Banco de dados é uma tarefa muito difícil, devido

a enorme quantidade de bancos de dados, existente no mercado, com linguagens

proprietárias.

A plataforma Java permite o acesso a banco de dados por meio de uma API (Application

Programming Interface) chamada JDBC (Java Database Connectivity). É uma interface entre a linguagem Java e outra linguagem que todos os bancos de dados suportam.

O Objetivo da JDBC é possibilitar o uso de dados existentes em SGBDR remotos. Utiliza o

SQL (Structured Query Language), linguagem destinada às operações dos SGBDR.

Arquitetura

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

A Aplicação para acessar um BD deve utilizar a API JDBC, contida no pacote java.sql.

Por meio da classe DriverManager, seleciona-se o driver de acesso ao BD que será utilizado.O driver passa a oferece uma interface padronizada para a Aplicação, implementando em Java ou de forma nativa o acesso ao BD.

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

1. Acessar o painel de controle e ativar o aplicativo Fonte de Dados ODBC;

2. Clicar no botão adicionar (DNS do usuário) para criar uma nova ponte de um banco de

dados;

3. Selecionar Driver adequado (Driver do Microsoft Access, por exemplo)

4. Preencher a caixa de diálogo com um nome para a Fonte de Dados do BD e a localização

do servidor.

5. Clicar no botão Selecionar para definir o BD a ser usado.

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

1º) Importar o pacote java.sql:

import java.sql.*;

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

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

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

44

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

5º) Por meio da conexão realizada, devemos obter uma instância de um objeto Statement, PreparedStatement ou CallableStatement, para passar comandos SQL ao BD:

Statement stmt= conexão.createStatement();

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

ExecuteUpdate(String), executeBatch()):

int reg =stmt.executeUpdate( delete from planeta where nome= Maria );

ResultSet rs = stmt.executeQuery( select nome from planeta );

7. Algumas operações retornam resultados do BD (um objeto Resultset conjunto de registros), os quais devemos exibir ou processar:

while( rs.next() ) { //move o curso de registros

String Nome=rs.getString( nome ); // obtém o valor do campo nome da tabela

System.out.println(Nome);

}

8.

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

rs.close();

stmt.close();

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

conexão.close();

Exemplos de métodos de ResultSet:

rs.absolute(3); //move cursor para linha

rs.updateString( Nome , Maria ); //atualiza nome

rs.updateRow(); //atualiza linha na tabela

rs.moveToInserRow(); //insere nova linha

45

Principais Comandos SQL

Segue exemplos dos principais comandos que serão utilizando em uma

aplicação que realizar operações em um Banco de Dados:

Tabela Brasil

Cidade

Estado

Pop

Sit

Brasília

DF

2.000.000

Cheio

SELECT: - realiza consultas

Select cidade, estado FROM Brasil WHERE pop > 1000;

INSERT: - Insere um registro

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

UPDATE: - Modifica um registro

UPDATE Brasil SET Sit = Cheio WHERE Pop > 1000;

DELETE: - Excluir um registro

DELETE FROM Brasil WHERE cidade = BSB

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

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

import java.sql.*; //pacote para trabalhar com BD

public class LeBDAccess{

public static void main(String args[]){

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//seleciona Driver conecta com BD

46

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

//objeto comandos SQL

Statement stmt= con.createStatement();

//Comando SQL

ResultSet rs=stmt.executeQuery("select * from Relacao");

//verifica se existem registros

while(rs.next()){

// obtém o valor armazenado no campo Nome da tabela Relacao

String nome=rs.getString("nome");

// obtém o valor arqmazenado no campo da Id

int id=rs.getInt("id");

// imprime o conteúdo da variável

System.out.println("Nome:"+nome+ " Ident:"+id);

}

rs.close(); //fecha "ponte"

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

System.out.println( erro de conexão + e.getMessage()); // mensagem de erro

} catch(ClassNotFoundException e){

System.out.println("Driver não encontrado");

}

}

}

47

JDBC no NetBeans

O NetBeans não possui ferramentas que permitam criar visualmente componentes, em um programa, para manipular os dados de uma tabela, a exemplo dos existentes em outras ferramentas, em outras Linguagens de programação.

Para trabalhar com Banco de Dados é preciso fazê-lo via código, que deverá ser inserido dentro do método actionPerformed de um JButton. Cria-se o Formulário contendo os componentes visuais para mostrar, e manipular, os dados da tabela do Banco de Dados. Dentre estes componentes estão os botões ou menus, os quais serão os responsáveis por executar os códigos para realizar uma determinada operação, consulta, inserção, alteração ou exclusão em um BD.

Depois de criada a parte visual, devem ser implementados os códigos nos botões/menus:

OBS: - Os exemplos que se seguem utilizam uma Fonte de Dados ODBC com o Nome:

PBD_Nomes que representa uma conexão com um Banco de Dados Access, contendo uma Tabela com o nome: TabFicha , contendo os campos (Matricula Tipo Número/Chave Primária; Nome Tipo Texto)

- Parte Visual do Programa:

a) Códigos para Inserir:

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con = DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt = con.createStatement(); //objeto comdo sql

String CadNome = jTextField1.getText(); //obtém nome digitado

int CadMat=Integer.parseInt( jTextField2.getText() );

stmt.executeUpdate( insert into TabFicha (Matricula, Nome) values (' " +

CadMat + " ',' " +

CadNome + " ' ) " );

48

JOptionPane.showMessageDialog( this, " Dados Salvos! ");

con.close(); // fecha conexão com BD

} catch( SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this, "Erro Cmdo SQL " + e.getMessage() );

} catch( ClassNotFoundException e){

JOptionPane.showMessageDialog( this, " Driver não encontrado " );

}

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

boolean consulta=true; //variável auxiliar utilizada para informar se houve sucesso na consulta

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt= con.createStatement();//objeto comdo sql

String ConsNome= jTextField1.getText();

ResultSet RS= stmt.executeQuery(

"Select * from TabFicha where nome=' " + ConsNome + " ' ");

while (RS.next()){

int Mat= RS.getInt("Matricula");

jTextField2.setText(String.valueOf( Matricula ));

jTextField3.setText(RS.getString("Nome"));

consulta=false;

JOptionPane.showMessageDialog(this,"Dados Encontrados!");

49

}

if (consulta) JOptionPane.showMessageDialog(this,"Dados Não

Encontrados!");

RS.close ();

stmt.close();

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this,"Erro Cmdo SQL"+e.getMessage());

} catch(ClassNotFoundException e){

JOptionPane.showMessageDialog(this,"Driver não encontrado");

}

c) Códigos para Alterar:

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt= con.createStatement();//objeto comdo sql

String ConsNome= jTextField1.getText();

int CadMat=Integer.parseInt(jTextField2.getText());

String CadNome=jTextField3.getText();

int registro = stmt.executeUpdate("

update TabFicha set Nome=' " +CadNome+ " ', Matricula='

"+CadMat+ " 'where Nome=' " + ConsNome + " ' ");

if (registro!=0) JOptionPane.showMessageDialog(this,"Dados Alterados!");

50

else JOptionPane.showMessageDialog(this,"Dados Não Alterados!");

stmt.close();

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this,"Erro Cmdo SQL

"+e.getMessage());

} catch(ClassNotFoundException e){

JOptionPane.showMessageDialog(this,"Driver não encontrado");

}

d) Códigos para Excluir:

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt= con.createStatement();//objeto comdo sql

String ExcNome= jTextField1.getText();

int registro=stmt.executeUpdate("delete from TabFicha where Nome=' " +

ExcNome + " ' ");

if (registro!=0) JOptionPane.showMessageDialog(this,"Dados Excluidos!");

else JOptionPane.showMessageDialog(this,"Dados não

Excluidos!");

stmt.close();

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

51

JOptionPane.showMessageDialog(this,"Erro Cmdo SQL"+e.getMessage());

} catch(ClassNotFoundException e){

JOptionPane.showMessageDialog(this,"Driver não encontrado");

}

NOTA:Antes de inserir os códigos é preciso importar os pacotes para trabalhar com Banco de Dados e exibir caixa de mensagens:

Localize o código de criação da classe. Ex:

Public Class

Antes deste comando insira os seguintes códigos:

import java.sql.*;

import javax.swing.*;

Exemplo Completo

Crie uma aplicação para cadastrar a Matricula e os Nomes dos

Funcionários de uma Empresa.

1. Clique no Menu File New Selecione Java GUI Forms Jframe Forms clique no botão

Next. Na janela que se abre, no campo Name, digite SistCadFunc e clique no Botão Finish.

2. Modifique o Layout do JFrame para AbsoluteLayout e insira os seguintes componentes:

dois JLabel (Nome e Matricula), dois JTextField e um JButton (Salvar)

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

4. Abra o Access e crie um BD (BDCadastro) com uma Tabela (TabFicha) com os campos:

Matricula (Tipo Numérico/Chave Primária) e Nome Tipo Texto.

5. Devemos criar a Ponte JDBC/ODBC: abra o Painel de Controle

Ferramentas Administrativas

Fontes de Dados ODBC

clique no Botão Add

Selecione o Driver p/ BD Access

52

clique no botão Concluir

no campo Nome da Fonte de Dados digite PBD-Nomes

clique no botão Selecionar

Procure o BD criado (BDCadastro) e clique no Botão OK

6. Criado o BD e a Ponte ODBC, volte para a sua aplicação no NetBeans e dê um duplo

clique no JButton (Salvar) para codificar a conexão:

Depois de private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { , digite:

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con = DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt = con.createStatement(); //objeto comdo sql

String CadNome = jTextField1.getText(); //obtém nome digitado

int CadMat=Integer.parseInt( jTextField2.getText() );

stmt.executeUpdate("insert into TabFicha (Matricula,Nome) values ('" +

CadMat + "','" + CadNome + "')" );

JOptionPane.showMessageDialog( this, " Dados Salvos! ");

con.close(); // fecha conexão com BD

} catch( SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this, "Erro Cmdo SQL " + e.getMessage() );

} catch( ClassNotFoundException e){

JOptionPane.showMessageDialog( this, " Driver não encontrado " );

}

53

8. Realizando operações de Consulta, Alteração e Exclusão em BD:

Insira três Botões para executar as operações restantes no Banco de Dados (Consulta, Alteração e Exclusão), um JLabel, para exibir o Texto Nome para Consulta/Exclusão , supondo que estas operações serão feitas através do campo Nome , e insira tabém um JTextField para p usuário poder digitar o Nome , ou crie um novo Form contendo os JLabel, JTextField , e JButton, sendo que o mesmo deverá ser chamado por outro Form através de um JMenurBar.

Basta dar um duplo clique no botão desejado e inserir o respectivo código

para a respectiva operação:

Consultar

boolean consulta=true;

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt= con.createStatement();//objeto comdo sql

String ConsNome= jTextField1.getText();

ResultSet RS= stmt.executeQuery("Select * from TabFicha where nome='" +

ConsNome + "' ");

while (RS.next()){

int Mat= RS.getInt("Matricula");

jTextField2.setText(String.valueOf(Mat));

jTextField3.setText(RS.getString("Nome"));

consulta=false;

JOptionPane.showMessageDialog(this,"Dados Encontrados!");

}

54

if (consulta) JOptionPane.showMessageDialog(this,"Dados Não

Encontrados!");

RS.close ();

stmt.close();

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this,"Erro Cmdo SQL "+e.getMessage());

} catch(ClassNotFoundException e){

JOptionPane.showMessageDialog(this,"Driver não encontrado");

}

Alterar:

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt= con.createStatement();//objeto comdo sql

String ConsNome= jTextField1.getText();

int CadMat=Integer.parseInt(jTextField2.getText());

String CadNome=jTextField3.getText();

int registro = stmt.executeUpdate("update TabFicha set Nome='" +CadNome+

"', Matricula='"+CadMat+ "'where Nome='" + ConsNome + "' ");

if (registro!=0) JOptionPane.showMessageDialog(this,"Dados Alterados!");

else JOptionPane.showMessageDialog(this,"Dados Não Alterados!");

stmt.close();

55

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this,"Erro Cmdo SQL"+e.getMessage());

} catch(ClassNotFoundException e){

JOptionPane.showMessageDialog(this,"Driver não encontrado");

}

Excluir:

try{ //tratamento de erros

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//busca Driver

//conecta no BD

Connection con=DriverManager.getConnection("jdbc:odbc:PBDNomes","","");

Statement stmt= con.createStatement();//objeto comdo sql

String ExcNome= jTextField1.getText();

int registro=stmt.executeUpdate("delete from TabFicha where Nome='" +

ExcNome + "'");

if (registro!=0)

JOptionPane.showMessageDialog(this,"Dados Excluidos!");

else

JOptionPane.showMessageDialog(this,"Dados não Excluidos!");

stmt.close();

con.close(); //fecha conexão com BD

} catch(SQLException e){ //trata os erros

JOptionPane.showMessageDialog(this,"Erro Cmdo SQL"+e.getMessage());

} catch(ClassNotFoundException e){

56

JOptionPane.showMessageDialog(this,"Driver não encontrado");

}

Compile Execute.

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

APLICATIVO COMERCIAL

(Linguagem de programação Java utilizando o Netbeans 5.5.1)

O seguinte exemplo foi desenvolvido a partir de discussões em sala de aula e

diversas pesquisas, contudo, seu conteúdo expresso em códigos que devem ser bem

analisados para um melhor desenvolvimento do curso.

MÁQUINA REGISTRADORA

Primeiramente crie dois formulários, no nosso exemplo, utilizamos tela1 e tela2.

Para possibilitar o acesso de um formulário a outro insira as seguintes linhas de comandos

tela2 frmdois=new tela2() após a seção Public Class.

Para chamar o formulário insira os comandos no botão do primeiro formulário

frmdois.show();

57

Crie os botões e caixas de diálogos, não se preocupe com as figuras, as colocaremos posteriormente. Para efetuar as adições coloque no botão adição os seguintes comandos

private void btntrocoActionPerformed(java.awt.event.ActionEvent evt) {

recebido=Double.parseDouble(jTextField6.getText());

troco=total-recebido;

r=String.valueOf(recebido);

tr=String.valueOf(troco);

jTextField7.setText(tr);

jTextField1.requestFocus();

saldo=total+saldo;

s=String.valueOf(saldo);

jTextField8.setText(s);

total=0;

subtotal=0;

quantidade=0;

valor=0;

jTextArea1.setText(" R$ "+jTextArea1.getText()+t+" Recebido R$ "+r+"Troco R$ "+tr+"\n");

58

No botão resultado insira os códigos:

recebido=Double.parseDouble(jTextField6.getText());

troco=total-recebido;

r=String.valueOf(recebido);

tr=String.valueOf(troco);

jTextField7.setText(tr);

jTextField1.requestFocus();

saldo=total+saldo;

s=String.valueOf(saldo);

jTextField8.setText(s);

total=0;

subtotal=0;

quantidade=0;

valor=0;

jTextArea1.setText(" R$ "+jTextArea1.getText()+t+" Recebido R$ "+r+"Troco R$ "+tr+"\n");

}

Para calcular o troco insira:

59

recebido=Double.parseDouble(jTextField6.getText());

troco=total-recebido;

r=String.valueOf(recebido);

tr=String.valueOf(troco);

jTextField7.setText(tr);

jTextField1.requestFocus();

saldo=total+saldo;

s=String.valueOf(saldo);

jTextField8.setText(s);

total=0;

subtotal=0;

quantidade=0;

valor=0;

jTextArea1.setText(" R$ "+jTextArea1.getText()+t+" Recebido R$ "+r+"Troco R$ "+tr+"\n");

}

No botão finalizar insira:

jTextField6.requestFocus();

60

60 Para declararmos as variáveis que possibilitaram a resolução dos cálculos, iremos declara-las de forma generalizada

Para declararmos as variáveis que possibilitaram a resolução dos cálculos, iremos declara-las de forma generalizada para todo o formulário e não Private(privada), para isto declaramos as seguintes variaveis logo acima da ultima seção public static :

double subtotal,total,valor,recebido,troco,saldo=0; // Variáveis do tipo real

int codigo,quantidade; // Variáveis do tipo interira

String produto,q,v,c,t,tr,r,s; // Variáveis do tipo caracteres ( strings)

61

O JButton Resultado com o símbolo de “+” (mais) servirá para adicionar os valores das compras e armazenar o valor do código e demais informações, para isto coloque as seguintes linhas de comandos :

private void btnresultadoActionPerformed(java.awt.event.ActionEvent evt) {

codigo=Integer.parseInt(jTextField1.getText()); //Converte String em int

quantidade=Integer.parseInt(jTextField3.getText());

produto=jTextField2.getText(); // produto recebe o valor do 2º JText

//Converte String para real

valor=Double.parseDouble(jTextField4.getText());

subtotal=quantidade*valor; //efetua a multip. das variáveis envolvidas

total=subtotal+total; // Armazena os subtotais

c=String.valueOf(codigo); //Converte números em textos

v=String.valueOf(valor);

q=String.valueOf(quantidade);

t=String.valueOf(total);

jTextField5.setText(t); //Imprime o valor do total

jTextField1.setText(""); // Deixa em brando os JTexts

jTextField2.setText("");

jTextField3.setText("");

jTextField4.setText("");

jTextField6.setText("");

62

jTextField7.setText("");

jTextField1.requestFocus(); // Tranfere o cursor para o 1º JText

} // Fim do código

O JButton finalizar servirá para encerrar o processo de novas compras de produtos e levar o processo para seus estágio de “valor recebido” (JTextField6).

// Transfere o cursor para jTextField6.

jTextField6.requestFocus();

O JButton com o símbolo de uma cédula servirá para calcular o valor do troco, além de calcular o saldo total do comerciante e preparar o cursor para uma nova rotina de vendas, para isto coloque as seguintes linhas de comando:

private void btntrocoActionPerformed(java.awt.event.ActionEvent evt) {

// Converte texto para números

recebido=Double.parseDouble(jTextField6.getText());

troco=total-recebido; // Calcula o troco

r=String.valueOf(recebido); // Converte número para texto

tr=String.valueOf(troco);

jTextField7.setText(tr); // Emite o valor do troco

jTextField1.requestFocus();

63

saldo=total+saldo; // Incrementa o saldo

s=String.valueOf(saldo); // Converte número para texto jTextField8.setText(s); // Emite

o vlor do saldo

total=0; // Zera o valor da variavel

subtotal=0;

quantidade=0;

valor=0;

// Comando de impresão no componente JTextArea1

jTextArea1.setText("

"+tr+"\n");

}

R$

"+jTextArea1.getText()+t+"

Recebido

R$

"+r+"Troco

R$

Qualquer dúvida envie um E-mail : arthurnewblackcrew.bol.com.br

CALCULADORA VISUAL

No nosso exemplo utilizamos 21 JButtons, mas não se assuste 10 deles serão utilizados somente para possibilitar um teclado virtual, além do botões utilizaremos 7 JTextFields para exibir valores, coloque estes objetos no formulário e altere as seguintes propriedades Text dos JButton como na seguinte figura e deixe em branco a propriedade do JTextFields, renomeie como achar melhor. Insira as seguintes linhas de comando:

64

Tente deixar a parte visual i l t
Tente
deixar
a
parte
visual
i
l
t

private voidbtnexpoenteActionPerformed(java.awt.event.ActionEvent evt)

{

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

num1=num1*num1;

primeiro=String.valueOf(num1);

R=String.valueOf(num1);

jText.setText(R);

if (contador==0)

jText1.setText(primeiro+"Exp"+"2 = "+R);

65

if (contador==1)

jText2.setText(primeiro+"Exp"+"2 = "+R);

if (contador==2)

jText3.setText(primeiro+"Exp"+"2 = "+R);

if (contador==3)

jText4.setText(primeiro+"Exp"+"2 = "+R);

if (contador==4)

jText5.setText(primeiro+"Exp"+"2 = "+R);

if (contador==5)

{

jText6.setText(primeiro+"Exp"+"2 = "+R);

contador=-1;

}

contador=contador+1;

jText.requestFocus();

}

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

{

jText.setText("");

66

jText1.setText("");

jText2.setText("");

jText3.setText("");

jText4.setText("");

jText5.setText("");

jText6.setText("");

num1=0;

resul=0;

contador=0;

jText.requestFocus();

}

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

{

jTextvirtual.setText(jText.getText()); /* Componente invisível*/

jText.setText("");

jText.requestFocus();

jLabsinal.setText("M"); /*Componente invisivel que serve para identificar a operação*/

}

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

67

{

jText.setText(""); // Limpa o visor da calculadora

jText.requestFocus(); // Passa o foco para o visor da calculadora

num1=0;

resul=0;

}

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

{

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

soma=String.valueOf(resul);

if (jLabsinal.getText()=="+") // Se a operação for de adição

{

p=(resul*num1)/100; // Valor porcentual

resul=resul+p;

// Valor adicionado com a porcentagem

}

if (jLabsinal.getText()=="-")

{

p=(resul*num1)/100;

resul=resul-p;

68

}

if

(jLabsinal.getText()=="x")

{

p=(resul*num1)/100;

resul=resul*p;

 

}

if

(jLabsinal.getText()=="÷") // Se a operação for de divisão

{

 

if (num1==0) // Se o denoiminador for inválido

{

// Mensagem de erro

jOptmensagem.showMessageDialog(this,"DENOMINADOR NÃO PODE SER IGUAL

A

ZERO");

jText.requestFocus(); // Passa o foco para o visor da calculadora

}

else // Se o denominador for válido

{

p=(resul*num1)/100; // Calcula o valor porcentual

resul=resul/p;

//Divide o 1° valor pelo seu porcentual correspondente

}

}

69

R=String.valueOf(resul);

primeiro=String.valueOf(num1);

if (contador==0)

jText1.setText(soma+jLabsinal.getText()+primeiro+"% = "+R);

if (contador==1)

jText2.setText(soma+jLabsinal.getText()+primeiro+"% = "+R);

if (contador==2)

jText3.setText(soma+jLabsinal.getText()+primeiro+"% = "+R);

if (contador==3)

jText4.setText(soma+jLabsinal.getText()+primeiro+"% = "+R);

if (contador==4)

jText5.setText(soma+jLabsinal.getText()+primeiro+"% = "+R);

if (contador==5)

{

jText6.setText(soma+jLabsinal.getText()+primeiro+"% = "+R);

contador=-1;

}

contador++;

jText.setText("");

jText.requestFocus();

70

}

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

{

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

jLabsinal.setText("-"); /*Componente invisivel*/

soma=String.valueOf(resul);

resul=resul-num1;

R=String.valueOf(resul);

primeiro=String.valueOf(num1);

if (contador==0)

jText1.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==1)

jText2.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==2)

jText3.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==3)

jText4.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==4)

jText5.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

71

if (contador==5)

{

jText6.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

contador=-1;

}

contador++;

jText.setText("");

jText.requestFocus();

}

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

{

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

jLabsinal.setText("x");

if (resul==0)

{

resul=1;

}

soma=String.valueOf(resul);

resul=num1*resul;

72

R=String.valueOf(resul);

primeiro=String.valueOf(num1);

if (contador==0)

jText1.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==1)

jText2.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==2)

jText3.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==3)

jText4.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==4)

jText5.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==5)

{

jText6.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

contador=-1;

}

contador++;

jText.setText("");

jText.requestFocus();

73

}

private void btndivisãoActionPerformed(java.awt.event.ActionEvent evt)

{

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

jLabsinal.setText("÷");

soma=String.valueOf(resul);

if (num1==0) // Se o denominador for inválido

{

jOptmensagem.showMessageDialog(this,"DENOMINADOR NÃO PODE SER IGUAL A ZERO!");

jText.setText(soma);

jText.requestFocus();

}

resul=resul/num1;

R=String.valueOf(resul);

primeiro=String.valueOf(num1);

if (contador==0)

jText1.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==1)

jText2.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

74

if (contador==2)

jText3.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==3)

jText4.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==4)

jText5.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==5)

{

jText6.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

contador=-1;

}

contador++;

jText.setText("");

}

private void btnresultadoActionPerformed(java.awt.event.ActionEvent evt) {

soma=String.valueOf(resul);

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

if (jLabsinal.getText()=="+") // Se a operação for de adição

resul=num1+resul;

75

if (jLabsinal.getText()=="-") // Se a operação for de divisão

resul=(resul-num1);

if (jLabsinal.getText()=="x") // Se a operação for de multiplicação

resul=num1*resul;

if (jLabsinal.getText()=="÷") // Se a operação for de divisão

resul=resul/num1;

if (jLabsinal.getText()=="M") // Se a operação for cálculo de médias

resul=(num1+num2)/2;

// Efetua o calculo da média entre os dois valores mencionados

R=String.valueOf(resul);

primeiro=String.valueOf(num1);

if (contador==0)

jText1.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==1)

jText2.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==2)

jText3.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==3)

jText4.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==4)

jText5.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

76

if (contador==5)

{

jText6.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

contador=-1;

}

contador++;

jText.setText("");

jText.requestFocus();

}

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

{

num1=Double.parseDouble(jText.getText()); // Armazena o 1° valor

soma=String.valueOf(resul);

resul=num1+resul;

R=String.valueOf(resul);

primeiro=String.valueOf(num1);

jLabsinal.setText("+"); /*Componente invisivel*/

if (contador==0)

jText1.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

77

if (contador==1)

jText2.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==2)

jText3.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==3)

jText4.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==4)

jText5.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

if (contador==5)

{

jText6.setText(soma+jLabsinal.getText()+primeiro+" = "+R);

contador=-1;

}

jText.setText("");

jText.requestFocus();

contador++;

}

Qualquer dúvida envie um E-mail : arthurnewblackcrew.bol.com.br

CONTROLADOR DE MENSALIDADES E CONVERSOR

DE VELOCIDADE

78

O seguinte exemplo foi desenvolvido com três Frames, o primeiro utiliza três JButtons e servirá para acessar outros formulários

exemplo foi desenvolvido com três Frames , o primeiro utiliza três JButtons e servirá para acessar