A LinguagemJAVA

EAplicações com

NetBeans

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

OEIRAS (PI), DEZEMBRO DE 2007

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://w.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 emacs do Unix e do sistema de janelas neWs. http://w.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.

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 = 10; x = x + 1; O valor da
variável x é 1 ou x = 10;

++x O valor da variável x é 1. Pós-Incremto: x = 10; x = x + 1; O valor da variável x é 1 ou x = 10; x++ O valor da variável x é 1. Diferença entre o Pré-Incremento e o Pós-
Incremento: x = 10 ++x => neste exato momento a variável a vale 1 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);

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

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 ITM, microJavaTM e UltraJavaTM. 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 JavaOSTM. 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 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:

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

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

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 "..." é o código Java válido, a ser executado no 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.

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.

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:

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

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:

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.println(29);
System.out.print("O valor e "); }

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[]) {

n = 17+21;
System.out.println("O valor numérico é " + n);
int 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

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

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

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

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.

[seguinte]

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

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;

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

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

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.

d) GridLayout

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.
- 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:

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

Componente PropriedadeValor 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
Utilize o programa anterior e acrescente mais 4 (quatro) JButtons: Dê um duplo clique no botão Diminuir e insira o seguinte código:

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

clique no Botão
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

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

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

Crie uma nova Template JFrame Form Motor , clique no Menu File New
b) Criar uma aplicação para mostrar o tipo de motor (1.0/1.6/2.0) escolhido pelo usuário

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

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

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

Para saber qual a opção esta marcada devemos utilizar o Método boolean isSelected(), que devolve true ou false.

Dê um duplo clique no botão para inserir o código: 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();

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.

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:

Componetes (JLabel, JTextField, JButton).

No Netbeans basta inserir o texto desejado na propriedade ToolTipText dos 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);
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:

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.*;

É 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

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.

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.

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.

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.

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

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

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.

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=.. code="Applets/JCalculadora.class" width=350 height=250> </APPLET>

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$ 100,0 zero, de R$ 101 até 250 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 .

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

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)

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 rs.updateInt(2, 3535); //atualiza coluna 2

Cidade Estado Pop Sit

Brasíli
DF 2.0.0 Cheio
a
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
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

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

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

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