Apostila Java 2 Com Banco de Dados

A p o s t i l a d e J a v a 2 C o m B a n c o d e D a d o s
Apostila de Java 2 Com Banco de Dados

1 – Introdução
1.1 – Java: O que é Java?
1.2 – Java: Como surgiu?
1.3 – Java: Funcionamento
2 – O que é preciso para programar em Java?

2.1 – Baixando o WinZip
2.2 – Baixando o JDK/SDK
2.3 – Baixando a documentação do JDK/SDK
2.4 – Baixando o JCreator
2.5 – Configurando o JCreator
2.6 – Testando o funcionamento do JDK/SDK e do JCreator
3 – Conceitos fundamentais de Programação em Java

3.1 – Como programa em Java
3.2 – Anatomia de uma Classe
3.3 – Comentários
3.4 – O uso do ponto-e-vírgula
3.5 – Tipos de dados
3.6 – Conversão de tipo
3.7 – Operadores
3.8 – Variáveis
3.9 – Funções matemáticas
4 – Introdução a interface gráficas em Java

4.1 – Entendo o Swing
4.11 – Uso do JFrame na construção de janelas no aplicativo
4.12 - Janela normal
4.2 - Janela Maximizada
4.3 - Janela minimizada
4.4 – Janela que não pode ser redimensionada
4.5 – Janela Centralizada
4.6 – Trocando a cor do fundo da janela
4.7 – Usando cores personalizadas para suas janelas
4.8 – Definindo um ícone para a janela do aplicativo
5 – Adicionando componentes JLabel ou rótulos na sua janela

5.1 - Criar os objetos JLabel
5.2 - Atribuir o conteúdo ao JLabel
5.3 - Definir Coluna, Linha, largura e altura do JLabel
5.4 - Alterando a cor do JLabel
5.5 - Cores personalizada para o JLabel
5.6 - Alterando tipo da fonte, estilo e tamanho
5.7 – Adicionando imagem ao componente JLabel
6 – Adicionando componentes JTextField ou caixa de texto

6.1 – Foco para uma caixa de texto
6.2 – Cor da fonte para a caixa de texto
6.3 – Trocando a fonte, estilo e tamanho da letra do JTextField
A l e k s a n d r a R . C a r d o z o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P á g i n a 1
6.4 – Alinhamento do texto de uma caixa de texto

6.5 – Alteração da cor de fundo da caixa de texto
7 – Adicionando componentes JButton ou botões a sua janela

7.1 – Botão somente com texto
7.2 – Botão com texto e imagem
7.3 – Botão somente com imagem
7.4 – Adicionando vários botões na janela
7.5 – Definir a cor de fundo para um componente JButton
7.6 – Definir teclas de atalho para objetos JButton
7.7 – Qual botão reagirá ao pressionamento da tecla enter
8 - Adicionando componentes JPasswordField

8.1 – Alterando a cor de fonte de um JPasswordField
8.2 – Definir uma cor personalizada para o componente JPasswordField
8.3 – Alterando a cor de fundo de um componente JPasswordField
8.4 – Cor de fundo personalizada para o componente JPasswordField
8.5 – Alterar tipo de fonte, estilo e tamanho da letra do componente
8.6 – Alterando o caracter que aparece no componente JPasswordField
9 – Controle JFormattedTextField para data, telefone, CEP, CPF

9.1 – Adicionando cores na letra do JFormattedTextField
9.2 – Adicionando cores no fundo do JFormattedTextField
9.3 – Alterando o tipo, estilo, tamanho da fonte do JFormattedTextField
10 – Fazendo um JButton executar uma ação

10.1 – Clicando no botão para fechar uma janela
10.2 – Clicando no mostrar para descobrir a senha digitada
10.3 – Clicando no botão somar e será mostrada a soma dos números
10.4 – Clicando no botão limpar e as caixas de texto serão limpas
10.5 – Ocultar e Exibir componentes
10.6 – Desabilitar e Habilitar Exibir componentes
11 – Apresentando a classe JList

11.1 – Selecionando múltiplos itens em uma caixa de listagem
11.2 – Trocando a cor da letra do JList
11.3 – Trocando a cor de fundo do JList
11.4 – Trocando tipo, estilo e tamanho da fonte do JList
12 – uso da classe JComboBox na criação de caixas de combinação

12.1 – Como criar uma caixa de combinação editável
13. Entendimento e uso da classe JCheckBox

13.1 – Iniciar um formulário com uma caixa de seleção marcada.
13.2 – Alterando a cor da letra de um JCheckBox
14 – Uso da Classe JRadioButton para criar botões de opção
15 – Fazendo um aplicativo com ComboBox CheckBox RadioButton
16 – Como adicionar dica aos seus botões

16.1 – Adicionar cores diferentes as dicas
17 – Tipos de diálogos fornecidos pela classe JOptionPane

17.1 – Como entender os diálogos de confirmação
17.2 – Traduzir os botões de diálogos
17.3 – Como obter dados por meio de diálogos do tipo prompt
17.4 – Como fornecer os valores a serem selecionados em um diálogo
17.5 – Entendimento e uso do método showMessageDialog.
18 – Maiúsculas e Minúsculas
19 – Adicionando Data nos seus aplicativos
20 – Adicionando Horas ao seu aplicativo
21 – Entendimento da classe JTextArea

21.1 – Definição das barras de rolagem para os controles JTextArea
21.2 – Controlando a quebra automática de linhas
21.3 – Cor da fonte, Cor de fundo
21.4 – Tipo, estilo e tamanho de fonte
22 – Adicionando menus a um aplicativo Java

22.1 – Como adicionar submenus a um item do menu
22.2 – Como usar caixa de seleção como itens do menu JCheckBoxMenuItem
22.3 – Usando botões de seleção como item do menu JRadioButtonMenuItem
22.4 – Menu executando ações
23 – Criando um menu de contexto – Classe JPopupMenu
24 – Uso da classe JToolBar para criar barra de ferramentas
25 – Como criar janelas secundárias com o uso da classe JDialog

25.1 – Como criar janelas secundárias modais
25.2 – Como criar janelas secundárias não-modais
25.3 – Como criar janelas secundárias com JFrame
26 – Uso da Classe JWindow para criar uma Splash Screen
27 – Banco de Dados Relacionais

27.1 – O que é um Banco de Dados?
27.2 – Banco de Dados Relacionais
27.3 – BD x SGBD
27. 4 – Índice
27.5 – Criando Banco de Dados
27.6 – Criando Tabelas no MS ACCESS
28 – O que SQL?
28.1 – Como usar SQL?
28.2 – Tipos de Dados
29 – ODBC/JDBC
29.1 – O que é um Driver?
29.2 – O que é ODBC?
29.3 – O que é JDBC?
29.4 – JDBC / ODBC
29.5 – DriverManager
29.6 – Como Criar Fontes de Dados ODBC
30 – SQL – Java & Banco de Dados - Considerações Iniciais

30.1 – Anatomia de uma Conexão e Testando a Conexão
30.2 - Criando a Tabela – CREATE TABLE
30.3 – Alterando Tabelas (Incluir ou Excluir Campos) ALTER TABLE
30.4 – Excluir Tabelas – DROP TABLE
30.5 – Inserindo Dados na Tabela (INSERT)
30.6 – Consultas (SELECT)
30.7 – Consultas Avançadas
30.8 – Atualizando Dados (UPDATE)
30.9 – Excluindo Dados (DELETE)
30.10 – Exibindo Dados em uma Lista
30.11 – Exibindo relatório com filtro e chamando outra janela
1 – Introdução
1.1 – Java: O que é?
O que faz ser tão especial a ponto de atrair a atenção da imprensa e

programadores de todo mundo?
É o fato de ter sido projetada levando em conta o que havia de melhor e pior
nos cinqüenta anos de existências das linguagens de programação. Java parte
do que deu ou não certo nas linguagens que a precederam ou lhe foram
contemporâneas. E suas características fazem-na uma linguagem muito útil
nestes tempos de interconectividade e migração tecnológica constantes.
Java é totalmente orientada a objetos é sua parente mais próxima é a

linguagem C, C++. Programadores em C sentir-se-ão muito à vontade ao
programarem em Java.
1.2 – Java: Como surgiu?
Java é ao mesmo tempo uma linguagem e um ambiente de programação.

Criada pela Sun Microsystems, foi inicialmente destinada a pequenos
dispositivos eletrônicos e quase fracassou. Comercialmente só se tornou um
quando se voltou para a internet. Isto porque, graças a sua característica
multiplataforma, possibilitou a inclusão de pequenas aplicações diretamente
nas páginas web, independente do sistema usado no computador do cliente.
A origem do nome Java por si só é material para um livro inteiro. Existem muita
especulação e lenda associada aos motivos que levaram os criadores da
linguagem Java – inicialmente chamada OAK, a batizaram-na como este nome
e a associaram ao café.
O mais importante é você saber que inicialmente a linguagem Java não incluía
a internet em suas pretensões. Hoje tem se mostrado a linguagem ideal para
desenvolvimento para internet e computação distribuída. Também está voltada
às origens, ao ser cogitada pelas grandes indústrias como linguagem de
programação para eletroeletrônicos e eletrodomésticos.
O principal responsável pelo desenvolvimento da linguagem Java foi o

engenheiro James Gosling que, a serviço Sun, comandou e orientou o grupo
de trabalho responsável pelo desenvolvimento do ambiente de programação
Java. O início do desenvolvimento da linguagem Java data de 1992, mas só
em 1995, Java foi apresentada ao mundo como linguagem e ambiente de
desenvolvimento multiplataforma.
Atualmente o ambiente Java se apresenta de diversas formas, cabendo ao

programador escolher a que mais o atrai.
1.3 – Java: Funcionamento
Java é uma linguagem de programação totalmente orientada a objetos. Seu

funcionamento, no que diz respeito ao desenvolvimento, é semelhante a outras
linguagens: DIGITAR, COMPILAR, EXECUTAR, DEPURAR. Mas como já
vimos, é uma das poucas, senão a única linguagem de programação que
permite ao programador criar um único código que roda sem alteração em
qualquer computador que possua uma Java Virtual Machine instalada. É
justamente a JVM ou Máquina Virtual Java o segredo por trás da
característica de multiplataforma, apresentada pelo ambiente de
desenvolvimento Java.
O diagrama seguinte ilustra o assunto. A independência de plataforma é a

capacidade de o mesmo programa ser executado em diferentes plataformas e
sistemas operacionais. Esta é uma das vantagens mais significativas da
linguagem Java.
Interpretador
Java
Código Fonte Compilador Binário Java (runtime Java ou
Arquivo.java Java Arquivo.class JVM – Java
Virtual
Machine/Máquina
Virtual Java)
O compilador Java gera JVM para WIN32
um arquivo binário com o
O código fonte é mesmo nome do arquivo
um arquivo gravado com a extensão.
digitado em Compilador Java. Esse arquivo é o
qualquer editor de Javac programa em Java e JVM para
texto puro e salvo pode ser executado em SOLARIS
com extensão qualquer máquina que
.Java possua a Java Virtual
Machine instalada. É
como se tivéssemos um
computador dentro do JVM para Linux
outro (emulador).
2 – O que é preciso para programar em Java?
Uma das grandes vantagens de programar em Java e também um motivo que

faz a linguagem contar com uma legião de fãs por todo o planeta está na
gratuidade de suas ferramentas de desenvolvimentos. Com extensão do
Access que fazer parte do pacote de aplicativos Office da Microsoft, tudo o
mais que você precisa pode ser obtido na internet.
O ambiente de desenvolvimento em si atende pelo nome de JDK – Java

Development Kit até a versão 1.6.0, ou SDK – Software Development Kit, da
versão 1.4.2 em diante. Mas é conveniente que além do JDK/SDK, você
também use um Ambiente de Desenvolvimento Integrado ou IDE – Integrated
Development Environment, pois o JDK/SDK trabalha em uma janela do

sistema e isto pode dificultar um pouco a vida de quem esta iniciando.
Todos os exercícios desta apostila foram testados em duas configurações:

Um AMD Duron 1000, com 128 de memória ram.
Um AMD Sempron 2600 com 1 GB de ram.
Creio que você não terá problemas para atingir os mesmos resultados.
2.1 – Baixando o WinZip
Baixe o Winzip a partir do site www.winzip.com. Usuários do Windows XP não

necessitam deste programa. Qualquer versão deve servir. Você pode inclusive,
usar descompactadores de outros fabricantes. Depois de baixar instale o
aplicativo Winzip.
2.2 – Baixando o JDK/SDK
Baixe o JDK/SDK a partir do site java.sun.com. Tenha certeza de esta

baixando a versão para Windows, pois na mesma página encontram-se
versões para outros sistemas, como o Linux e Solaris. Site: www.sun.com.
2.3 – Baixando a documentação do JDK/SDK
A instalação da documentação do JDK/SDK é opcional, mas muito útil não só a

quem está dando os primeiros passos na linguagem, como também para quem
já está na estrada há mais tempo e uma vez ou outra precisa recorrer à
documentação. O único inconveniente é estar em inglês, um obstáculo a quem
não domina este idioma. Mas pode ficar tranqüilo porque a instalação da
documentação é opcional. Baixe a documentação no www.sun.com.
2.4 – Baixando o JCreator
O JCreator é um programa da categoria IDE – Integrated Development

Environment ou melhor, Ambiente de Desenvolvimento Integrado. Ele se
integra ao JDK/SDK para tomar mais amigável o uso do ambiente. O JDK/DSK
continua sendo o verdadeiro responsável pelo trabalho pesado.
Optamos pelo JCreator por ele ser gratuito, pequeno, fácil de usar, estável e
cumpre o que promete: edita o código-fonte, compila, executa e ajuda a
depurar erros. Outras duas características muito úteis são endentações
automáticas e o uso de cores para diferentes partes do código-fonte.
Baixe o JCreator LE que é gratuito e atende as nossas necessidades.

Baixe no site www.jcreator.com.
Na mesma página em que você encontra a versão gratuita está a versão Pro
que é paga e só funciona por 30 dias. Tenha certeza de estar baixando a
versão LE que é gratuita e atende perfeitamente aos nossos objetivos.
2.5 – Configurando o JCreator
Depois de instalado é hora de configurar o JCreator, quando você iniciar o

JCreator pela primeira vez, ele será configurado. Ao dar o duplo clique no ícone
do JCreator será exibida a caixa de diálogo:
Clique em Next para avançar, aceitando o JCreator como editor associado aos
arquivos Java. Como já foi visto, os arquivos com a extensão Java nada mais
são do que arquivos texto contendo o código-fonte escrito em linguagem Java.
Caso o JCreator não localize automaticamente a pasta na qual você instalou o

JDK/SDK, clique na opção Browse para localizá-la. Depois de localizada
corretamente, clique em Next para avançar.
Se você instalou a documentação do JDK/SDK, clique no Browse para localiza-

la dentro da pasta de instalação do JDK/SDK. Depois de localizada
corretamente, clique em Finish para concluir o processo de configuração do
JCreator. Da próxima vez que for executado, estes procedimentos não serão
mais executados.
Tela inicial do JCreator
2.6 – Testando o funcionamento do JDK/SDK e do JCreator
Para testar, tanto o JDK/SDK quando o JCreator, vamos iniciar um arquivo

.Java em branco. Clicando em: File -> New -> File , depois clique em Next para
avançar, depois clicando no botão com as... para escolher a pasta onde você
vai guardar seus arquivos. Na opção name digite o nome do seu arquivo Java.
E ao final clique em Finish.
A linguagem Java diferencia letras maiúsculas de minúsculas. O “A” e o “a”, em

se tratando de programação em Java, são completamente diferentes. Portanto,
digite o código apresentando, com a máxima atenção, sem se preocupar com a
endentação que é automática no JCreator. Digite esse código:
import javax.swing.*;
public class teste extends JFrame{
public teste(){
super("Testando o JCreator");
setSize(300, 150);
setVisible(true);
}
public static void main(String args[]){
teste app = new teste();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
A l e k s a n d r a R . C a r d o z o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P á g i n a 1 0
Depois que você digitou o código, é preciso compilá-lo. Compilar um programa

é o ato de transformar esse código-fonte em executável ou, no caso do Java,
transformar o código-fonte em classe, pronta para ser interpretada pela
Máquina Virtual Java, da qual falamos anteriormente. Para compilar um código-
fonte no JCreator, basta clicar sobre o botão Complie File. Ao fazer isso, será
criada uma classe de com o nome de teste.class.
Botão Compile File:
Se tudo correu bem, será exibida na parte inferior do JCreator uma janela com
a mensagem Process Completed. O processamento não é imediato. Aguarde
até que alguma mensagem apareça ou o seu bom senso o alerte para algum
problema.
E se o JCreator encontrar algum erro durante a compilação ou execução de

classe, não se preocupe que você será avisado disto. O JCreator interpreta as
mensagens de erro do JDK/SDK e as exibe ao programador. Vamos a um
exemplo prático. Troque a letra “t” (minúscula) do nome do programa teste,
pela letra “T” (maiúsculas) e compile novamente.
Repare que além da mensagem de erro, o JCreator aponta a linha da provável

causa do erro.
Nota: toda vez que você fizer alguma alteração no código-fonte terá de
compilar o código-fonte de novo, para que as mudanças reflitam na classe.
Mas se tudo correu bem durante a compilação do teste.Java, agora você tem
uma classe pronta para se interpretada pela Máquina Virtual Java, Basta clicar
no botão execute File do JCreator.
Esta classe que compilamos e executamos foi uma forma fácil e rápida de
testar o ambiente e também de prepará-lo para os capítulos seguintes da
apostila. A única coisa que ela faz é exibir uma janela com a frase na barra
“Testando o Uso do JCreator”. Feche a janela e depois pressione qualquer
tecla para fechar do console e retornar ao JCreator.
Lembre-se que todos os exercícios e tarefas deste apostila são digitadas,
compiladas e executadas de dentro do JCreator. Se você teve alguma
dificuldade nos passos anteriores, repita-os até está seguro do processo:
Digitar -> Compilar-> Executar -> Depurar quando se fizer necessário, pois
são tarefas fundamentais para a compreensão e prática dos próximos
capítulos.
3 – Conceitos fundamentais de Programação em Java

3.1 – Como programa em Java
O processo utilizado na programação em Java é praticamente o mesmo das
outras linguagens: Digitar -> Compilar-> Executar -> Depurar quando
necessário. O diagrama seguinte ilustra o processo:
Início
Digitação do Código
.Java
Compilar
.class
Problemas na Depuração
compilação?
sim
não
Executar
.class
Fim
3.2 – Anatomia de uma Classe
Como vimos no capítulo anterior, a linguagem Java permite a criação de

programas independentes, chamamos de aplicações. Também permite a
criação de pequenas aplicações que rodam no navegador web, as applest
scripts de servidor, os servlets também criação de componentes. Uma classe
padrão:
1. class nomeclasse {
2. public static void main(String args[]){
3. //implementar código.
4. }
5.}
A numeração das linhas não faz parte do programa. Ela serve para ajudar na
identificação de cada linha, as quais vamos analisar a partir de agora.
public – é um modificador de classes e métodos. Significa que a classe ou

método é acessível externamente a esta classe. Isto permite que uma classe
possa utilizar alguma funcionalidade de outra classe.
static – é um outro modificador de métodos e indica que o método deve ser

compartilhado por todos os objetos criados a partir desta classe.
void – usado quando o método não retorna valor.
main – método principal. Obrigatório em aplicações, pois indica ao compilador

o início da execução da linha.
(String args []) – trata-se de um vetor de strings e recebe os argumentos

passados ao programa.
{ e } (abre e fecha chaves) – é entre as chaves que todas as instruções do

programa são colocadas.
Java e Case Sensitive

A linguagem Java é sensível ao contexto. Isto quer dizer que para o
compilador, palavras iguais grafadas em maiúsculas ou minúsculas são
diferentes.
3.3 – Comentários
Os comentários servem para facilitar o entendimento de um programa e

documentar o código. Java possui algumas formas de inserir comentários:
// (duas barras) – para inserir comentários de uma única linha.

/* Exemplo de comentários
/* e */ - (barra + asterisco e asterisco + barra) – para comentários de mais de

uma linha.
/* Exemplo de comentários */
3.4 – O uso do ponto-e-vírgula

No final de cada instrução usa-se o ponto-e-vírgula. No início você pode ficar
confuso quanto a usar ou não o ponto-e-vírgula, mas é questão de tempo para
habituar. Além disso, o compilador informa o erro por ausência ou uso indevido
do ponto-e-vírgula.
int a, b; a = 10; b = 20; total = a + b;
3.5 – Tipos de dados
Java possui oito tipos primitivos que servem para armazenar números inteiros,
ponto flutuante, valores booleanos e caracteres. Vamos conhece-las.
Inteiros:
Tipo Tamanho
byte 1 byte
short 2 bytes
Int 4 bytes
long 8 bytes
Ponto Flutuante:
Tipo Tamanho
float 8 byte
double 8 bytes
Caractere:
Tipo Tamanho
char 2 bytes
Booleano:
Tipo Tamanho
boolean 1 byte
Todos esses tipos de variáveis são escritos em letras minúsculas e são

usados, principalmente, na declaração de variáveis:
byte idade; short CEP; char controle;
Além dos oitos tipos básicos, uma variável pode ter uma classe como tipo,
como no exemplo seguinte: String nome = “Java”;
O uso da String é muito comum em Java.
Alguns caracteres especiais que você pode usar são os seguintes:
\n – new linha (quebra de linha)
\t – tab (tabulação)
\f – formfeed (avanço de formulário)
\” – aspas duplas
\’ – aspas simples
\\ - barra invertida
\r – return (retorno do carro)
\b – backspace (retorno apagando)
3.6 - Conversão de tipo
Às vezes necessitamos converter um tipo em outro. Um exemplo muito comum

é quando recebemos dados em forma de String. Para que possamos efetuar
operações matemáticas com esses dados, precisamos converte-los em
números.
Tabela de conversão de Tipos
Para converter String em Faça isto

int int novovalor = Integer.parseInt(valor)
Float float novovalor = Integer.parseInt(valor)
Double Int novovalor = Integer.parseInt(valor)
String valor1 = “10”;

int val1;
float val2;
double val3;
val1 = Integer.parseInt(valor1);
val2 = Float.parseFloat(valor2);
val3 = Double.parseDouble(valor3);
Ou também pode ser feita desta forma:

int val1 = Integer.parseInt(valor1);

float val2 = Float.parseFloat(valor2);
double val3 = Double.parseDouble(valor3);
Conversão entre tipos também pode ser implícitas ou explícitas. Veja os

exemplos:
Conversão implícita:
short numero1 = 10;

long numero2 = numero1; // convertemos short para long
Conversão explícita
long numero1 = 10;

byte numero2 = (byte) numero1; //convertemos long em byte
3.7 – Operadores
Operadores
Operador Nome Exemplo de uso
+ Adição A+B
- Subtração A-B
/ Divisão A/B
* Multiplicação A*B
% Módulo A%B
- Negativo (unário) A =-A
++ Incremento A++
++A
-- Decremento A—
--A
Operadores lógicos e relacionais

! NOT (não lógico) !A
&& AND (E lógico) A && B
|| OR (OU lógico) A || B
== Igual A A == B
!= Diferente A != B
< Menor que A<B
> Maior que A>B
<= Menor ou igual A <= B
>= Maior ou igual A >= B
Operadores Bitwise
~ Inversão ~A
& E (and) A&B
| OU (OR) A|B
^ XOU (XOR) A ^B
<< Deslocamento à esquerda A << B
>> Deslocamento à direita A >> B
= atribuição A=B
3.8 – Variáveis
Variáveis são elementos mais básicos que um programa manipula. Uma

variável é um espaço reservado na memória do computador para armazenar
um determinado tipo de dados. As variáveis são declaradas e, opcionalmente,
inicializadas com um valor qualquer. Caso você não atribua nenhum valor, o
Java atribuirá um valor default. Variáveis podem ter qualquer nome, desde que
não sejam nomes de palavras chaves que são usadas nos programas Java. E
as variáveis não podem ser digitadas com espaço e nem acentos.
Exemplos: nome123; nome_da_mae; NomeDoPai; Nome
3.9 – Funções matemáticas

O que é? Java possui diversas funções matemáticas que podem ser utilizadas
para simplificar cálculos e expressões.
Como usar? O uso das funções matemáticas é muito simples:
Função Significado
Math.abs(valor) Retorna ao valor absoluto
Math.sqrt(valor) Retorna a raiz quadrada
Math.cos(valor) Retorna o co-seno
Math.sin(valor) Retorna o seno
Math.tan(valor) Retorna a tangente
Math.acos(valor) Retorna ao arco co-seno
Math.asin(valor) Retorna ao arco seno
Math.atan(valor) Retorna ao arco tangente
Math.round(valor) Arredonda para seu inteiro mais próximo
Math.floor(valor) Arredonda o valor de um número para baixo
Math.ceil(valor) Arredonda o valor de um número para cima
Math.log(valor) Retorna o valor do logaritmo natural
Math.min(valor,valor1) Retorna o valor mínimo entre 2 números
Math.max(valor,valor1) Retorna o valor máximo entre 2 números
Math.PI Retorna o valor de PI
Math.E Valor da base do logaritmo natural
Math.pow(base,potencia) Potenciação
(Int) (Math.random()*100) Gera números aleatórios
4 – Introdução a interface gráficas em Java

Agora vamos falar sobre o pacote javax.swing, sua relação com o pacote
java.awt e introduziremos a classe JFrame, componente principal dos
aplicativos de interface gráfica em Java.
4.1 – Entendo o Swing
Contrário ao que muitos desenvolvedores e estudantes de Java pensam, o

Swing não é um subtítulo do AWT (Abstract Window Toolkit). Em vez disso, o
Swing é visto como uma cama disposta confortavelmente sobre o AWT. É
praticamente impossível falar de Swing sem mencionar alguns aspectos
relevantes e no momento oportuno veremos como eles se complementam.
O papel principal do AWT era fornecer um conjunto de componentes gráficos

destinados a facilitar a construção das interfaces gráficas para aplicativos e
applets em versões mais antigas do Java. De fato, o AWT continua sendo uma
das partes mais importantes do JFC (Java Foundation Classes) ao lado de
Swing, Accessibility Java 2D e Drag na Drop. Java 2 é agora parte do AWT e o
suporte Accessibility já está incluso no Swing.
Compone
List Button Containe Label CheckBox

r
Window
Frame
Esta hierarquia não está completamente. Mostramos apenas alguns dos

componentes para que o leitor veja como todos eles descendem de um
componente em comum, ou seja, a classe Component. Atenção deve ser à
classe Container, descendente direta da classe Component.
Um Component tem uma representação gráfica, de modo que ele possa ser
exibido na tela e forneça meios de interação com o usuário. A classe
Component define os métodos, propriedades e eventos que pode ser aplicados
a todos os componentes derivados dessa classe, incluído as classes Button,
Canvas, Label, Container, etc.
O Swing é um grande grupo de componentes visuais escritos em Java puro
(diferentes de alguns componentes AWT, que estão associados às
capacidades de renderização de interfaces gráficas da plataforma em que o
aplicativo está sendo executado).
Um componente do Swing é reconhecido pela letra “J” antecedendo o nome do
mesmo componente na hierarquia AWT. Assim, se no AWT temos o
componente Button, em Swing esse componente é chamado de JButton. Label
passa a ser chamado de JLabel, Frame de JFrame e assim por diante. Uma
recomendação é que você investigue na documentação on-line a diferença, por
exemplo, entre a funcionalidade de um button e um JButton
4.11 – Uso do JFrame na construção de janelas no aplicativo
Se você já leu outro material sobre interfaces gráficas em Java, deve estar se
perguntando por que preferimos não iniciar a apostila falando de caixas de
texto, rótulos, botões e outros componentes de interface. A razão é simples. A
janela do aplicativo é a parte mais importante da interface, além de ser o
fundamento sobre o qual os demais componentes serão construídos. Mas, o
fato de não reservamos muita atenção ao estudo das janelas dos aplicativos
provém do uso excessivo dos IDEs visuais (os famosos Ambientes de
Desenvolvimento Integrado).
A classe JFrame é uma versão melhorada de Frame que traz consigo suporte
aos componentes Swing. Essa classe fornece todas as propriedades, métodos
e eventos que precisamos para construir janela, tais como as que nossos
usuários estão acostumados a visualizar em seus sistemas. Ora, o usuário
sabe que a janela de um aplicativo pode ser minimizada, maximizada,
redimensionada, e etc. Então vamos demonstrar a classe JFrame serve aos
nossos propósitos.
A janela principal de um aplicativo de interface gráfica em Java é criada como
uma instância da classe JFrame (com exceção de Applets). A classe JFrame
herda diretamente de Frame, como mostra a figura seguinte:
Compone
List Button Containe Labe CheckBox

r l
Window
Frame JFrame
Considerações a serem levadas antes de começar a programa.
Quando o usuário encontrar esse símbolo em algum aplicativo, significa

que a linha debaixo tem que ser digitada na mesma linha.
Exemplo: public class NomePrograma
extends JFrame{
Quando você for digitar essa linha no JCreator, ela tem que ser digitada inteira
pois o método ou comando quando for compilado, encontrá erro.
4.12 - Janela normal

public class PrimeiraJanela extends JFrame{
public PrimeiraJanela(){
super("Nossa primeira janela");
setSize(300, 150);
setVisible(true); }
PrimeiraJanela app = new PrimeiraJanela();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
Vamos analisar cada linha do aplicativo.
Tenha a certeza de importar esse pacote em todos os aplicativos de interface gráfica

que estiver escrevendo: import javax.swing.*;
Em seguida temos a definição da classe principal:
public class PrimeiraJanela extends JFrame

{
// a implementação da classe vai aqui.
}
Observe como a classe PrimeiraJanela, que será a janela do aplicativo, herda da
classe JFrame. A partir desse ponto, nossa classe possui todas as propriedades,
métodos e eventos que precisamos para que o aplicativo possa ser minimizado,
maximizado e fechado por meios dos botões na barra de títulos. Dentro da classe
temos o construtor padrão, que será invocado quando uma instância dessa classe for
criada (o que acontecerá quando a janela for exibida na tela):
public class PrimeiraJanela extends JFrame
{
setSize(300, 150);
setVisible(true); }
Uma classe JFrame pode ser instanciada de duas maneiras: app = new()
que cria uma instância da classe que é inicialmente invisível, mas sem um título
na barra de títulos, ou: app = new(String Título)
que cria uma instância da classe inicialmente invisível e com um objeto String
representando o texto da barra de títulos. Assim, no construtor da classe
PrimeiraJanela, invocamos o segundo construtor da superclasse JFrame
fornecendo o texto que queremos como título da janela.
Após a definição do título da janela, temos uma chamada ao método setSize:
setSize(300, 150); - (300 – Altura e 150 – largura)
Finalmente exibimos a janela efetuando uma chamada ao método setVisible o

qual apresenta a seguinte sintaxe: setVisible(true);
Para finalizar o código para a janela, temos a definição do método main():
public static void main(String args[])

{
}
Na primeira linha criamos uma instância da classe PrimeiraJanela e a atribuímos à

referência app, então acessamos o método setDefaultCloseOperation e fornecemos
o valor EXIT_ON_CLOSE, que é uma das constantes da classe JFrame que define
como o aplicativo vai se comportar quando o usuário tentar fechar a janela, seja
clicando no botão fechar na barra de títulos ou pressionando ALT + F4. Veja no
quadro outros valores que você pode usar:
Valor da Constante Resultado

Faz com que a janela seja apenas ocultada quando o
usuário tentar fechar o aplicativo, ou seja, o programa
HIDE_ON_CLOSE continua sua execução. O uso desse valor só é
justificado quando queremos que a janela ou algum de
seus componentes esteja disponível para acesso e
manipulação, mas não queremos que isso seja visível
aos olhos do usuário.
Faz com que o usuário não seja capaz de fechar a
janela. Neste caso você deve efetuar algum
DO_NOTHING_ON_CLOSE processamento e fechar a janela, baseado em alguma
ação específica no seu código.
Libera, ou seja, retira da memória, tanto a janela do
aplicativo quanto seus componentes. A diferença entre
DISPOSE_ON_CLOSE este valor e HIDE_ON_CLOSE é que o primeiro oculta
a janela e só então libera da memória.
4.2 - Janela Maximizada: setExtendedState(MAXIMIZED_BOTH);

public class JanelaMaximizada extends JFrame{
public JanelaMaximizada(){
super("Como exibir a janela maximizada");
setSize(300, 150);
setVisible(true);
setExtendedState(MAXIMIZED_BOTH);
}
JanelaMaximizada app = new JanelaMaximizada();
}
}
4.3 - Janela minimizada: setExtendedState(ICONIFIED);

public class JanelaMinimizada extends JFrame{
public JanelaMinimizada(){
super("Como exibir a janela minimizada");
setSize(300, 150);
setVisible(true);
setExtendedState(ICONIFIED);
}
JanelaMinimizada app = new JanelaMinimizada();
}
}
4.4 – Janela que não pode ser redimensionada: setResizable(false);
Por padrão, as janelas dos aplicativos em Java podem ser redimensionadas
em tempo de execução, ou seja, durante a execução do programa. Algumas
vezes não queremos que o usuário seja capaz de alterar o tamanho da janela.
Com a lista abaixo podemos fazer com que a janela não seja redimensionada:
public class TamanhoFixo extends JFrame{
public TamanhoFixo(){
super("Uma janela não dimensionável");
setResizable(false);
setSize(300, 150);
setVisible(true);
}
TamanhoFixo app = new TamanhoFixo();
}
}
4.5 – Janela Centralizada: setLocationRelativeTo(null);
public class JanelaCentralizada extends JFrame{
public JanelaCentralizada (){
super("Janela Centralizada");
setSize(300, 150);
setVisible(true);
setLocationRelativeTo(null);
}
JanelaCentralizada app = new JanelaCentralizada ();
}
}
4.6 – Trocando a cor do fundo da janela

Embora as propriedades mais importantes da janela do aplicativo já tenham
sido vista a possibilidade de alterar a cor de fundo da janela só pôde ser
apresentada agora. Isso se deve ao fato de a cor do fundo ser definida não
para a classe JFrame, mas para o painel de conteúdo, ou seja o objeto
Container que contém os controles da janela.
O aplicativo seguinte exibe uma janela com a cor azul definida como cor de
fundo. Observado que a cor de fundo para painel não afetará os demais
controles da janela. Veja o aplicativo abaixo:
import java.awt.*;
public class CorDeFundo extends JFrame{
public CorDeFundo(){
super("Definindo a cor de fundo para a janela");
Container tela = getContentPane();
tela.setBackground(Color.blue);
setSize(500, 100);
setVisible(true);
}
CorDeFundo app = new CorDeFundo();
}
}
Temos que importar o pacote import java.awt.*;, pois a classe Container está
nele. Veja como uma instância dessa classe é criada e atribuída à referência
tela: Container tela = getContentPane();
Após essa declaração o tela é um objeto Container que representa a janela do

aplicativo. Por meio dessa referência podemos adicionar e manipular os novos
componentes. Comando que troca a cor de fundo da janela:
Você pode usar: red, white, green, silver
4.7 – Usando cores personalizadas para suas janelas
Você sabia que você pode editar cores personalizadas para suas janelas de
aplicativos Java? Com o comando setBackground (), isso é possível.
Veja o exemplo:
import java.awt.*;
public class CorDeFundo2 extends JFrame{
public CorDeFundo2(){
tela.setBackground(new Color(255,128,128));
setSize(500, 100);
setVisible(true);
}
CorDeFundo2 app = new CorDeFundo2();
}
}
4.8 – Definindo um ícone para a janela do aplicativo

Nada contra o ícone padrão das janelas dos aplicativos Java. Mas, seria bem
interessante se pudéssemos definir um ícone que lembra nossa marca, ou
talvez um ícone que represente melhor a funcionalidade do aplicativo.
public class DefinirIcone extends JFrame{
public DefinirIcone(){
super("Como definir o ícone para a janela");
ImageIcon icone = new ImageIcon("teste.gif");
setIconImage(icone.getImage());
setSize(300, 150);
setVisible(true);
}
DefinirIcone app = new DefinirIcone();
}
}
Após executar o aplicativo, observe como o ícone padrão (a xícara de café) foi
alterada, substituída pela imagem que foi adicionada no aplicativo.
A definição de um ícone para a janela pode ser realizada com apenas duas
linhas de código: ImageIcon icone = new ImageIcon("teste.gif");
Na primeira linha criamos uma instância da classe ImageIcon e a atribuímos à

referência ícone. Objetos desta classe podem ser criados por meio de nove
construtores diferentes. Optamos por aquele que recebe o caminho e/ou nome
da imagem como argumento. Veja sua sintaxe:
ImagemIcon(String caminho_e_nome_da_imagem);
ImageIcon("teste.gif");
Só precisamos fornecer o nome da imagem ou o caminho e o nome da

imagem. É importante observar que esse caminho é sempre transformado em
uma URL antes de ser passado para o construtor da classe. Assim, você pode
fornecer uma imagem usando apenas o nome da imagem:
O Caminho e o nome da imagem:

ImageIcon icone = new ImageIcon("imagens/teste.gif");
Após iniciamos a classe ImageIcon, fazemos uso do método getImage dessa

classe para obter a imagem e a definimos como ícone da janela com uma
chamada a setIconImage da classe JFrame. setIconImage(icone.getImage());
5 – Adicionando componentes JLabel ou rótulos na sua janela
Freqüentemente chamado de rótulo, esse componente raramente tem seu

conteúdo alterado e, quando usado corretamente, possibilita manipulações
bem interessantes, como veremos a segui. Vamos começar escrevendo um
aplicativo que permite instanciar as classe JLabel de maneiras diferentes.
Esse aplicativo que adiciona JLabel, posiciona na janela, altera a cor e altera a
fonte desse componente:
import java.awt.*;
public class ExemploLabel extends JFrame{
JLabel rotulo1,rotulo2,rotulo3,rotulo4;
public ExemploLabel(){
super("Exemplo com Label");
setLayout(null);
rotulo1 = new JLabel ("Nome");
rotulo2 = new JLabel ("Idade");
rotulo3 = new JLabel ("Telefone");
rotulo4 = new JLabel ("Celular");
rotulo1.setBounds(50,20,80,20);
rotulo1.setForeground(Color.red);
rotulo2.setForeground(Color.blue);
rotulo3.setForeground(new Color(190,152,142));
rotulo1.setFont(new Font("Arial",Font.BOLD,14));
rotulo2.setFont(new Font("Comic Sans MS",Font.BOLD,16));
rotulo3.setFont(new Font("Courier New",Font.BOLD,18));
rotulo4.setFont(new Font("Times New Roman",Font.BOLD,20));
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
setSize(400, 250);
setVisible(true);
}
ExemploLabel app = new ExemploLabel();
}
}
Veja o programa depois de executado:
Para entender melhor como funciona o programa destacamos alguns trechos

do programa, sempre lembrando que temos que no começo do programa
importar esses pacotes que adicionam conteúdos a janela:
import java.awt.*;
5.1 - Apos fazermos as importações vamos criar os objetos do tipo JLabel:

5.2 - Em seguida atribuir o conteúdo ao JLabel:

5.3 - Próximo passo definir o largura e altura do JLabel e a coluna e a linha que
ele irá ocupar na janela.
50 – Coluna, 20 – linha, 80 – largura, 20 - comprimento
Comprimento 80
Linha 20
Linha 60
Linha 100 Altura 20

Linha 140
Coluna 50
5.4 - Próximo passo definir a cor da letra dos componentes JLabel, lembrando
que se esses objetos não forem adicionados ao aplicativo, a cor default é preto.
5.5 - Esses dois trechos abaixo especifica como criar cores personalizadas
para o componente JLabel.
5.6 - E ainda podemos definir a fonte, o estilo e o tamanho da letra do

componente JLabel.
Lembrando que o nome da fonte tem que ser definida como esta na opção de
fonte do sistema.
Exemplo: Comic Sans MS,

Courier New,
Arial, Lucida Sans,
Tahoma,
Times New Roman
Já o estilo pode ser definido como:

Font.BOLD fonte em negrito
Font.ITALIC fonte em itálico
Font.PLAIN fonte normal
Font.BOLD+Font.ITALIC negrito e itálico
E a numeração corresponde o tamanho da fonte.
Você pode definer 14, 16, 18, 20 entre outros tamanhos que fica a escolha do
usuário.
E finalmente o método tela que representa a janela deverá ser chamado, onde
vai exibir o rótulo o conteúdo do JLabel na janela.
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
5.7 – Adicionando imagem ao componente JLabel
É Possível exibir imagem em rótulos como instâncias da classe JLabel. Tais

rótulos podem conter apenas imagens ou imagens e texto. O aplicativo
seguinte mostra apenas uma imagem adicionada com um JLabel na janela.
Exemplo:
import java.awt.*;
public class LabelImagem extends JFrame{
JLabel imagem;
public LabelImagem(){
super("Uso da classe JLabel com Imagem");
ImageIcon icone = new ImageIcon("sapo.jpeg");
imagem = new JLabel(icone);
tela.add(imagem);
setSize(500, 460);
setVisible(true);
}
LabelImagem app = new LabelImagem();
}
}
6 – Adicionando componentes JTextField ou caixa de texto na sua janela
A classe JTextField possibilita a criação de caixas de texto de uma única linha.

Os usos mais freqüentes desse controle são para receber e validar dados
informados pelo usuário do aplicativo. Essa classe herda a maioria de seus
atributos, eventos e métodos da classe JTextComponent.
import java.awt.*;
public class ExemploJTextField extends JFrame{
JTextField texto1,texto2,texto3,texto4;
public ExemploJTextField (){
super("Exemplo com JTextField");
setLayout(null);
texto1 = new JTextField(50);
texto1.setBounds(110,20,200,20);
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
tela.add(texto1);
tela.add(texto2);
tela.add(texto3);
tela.add(texto4);
setSize(400, 250);
setVisible(true);
}
ExemploJTextField app = new ExemploJTextField();
}
}
Vejamos agora os trechos principais que fazem com que as caixas de texto
apareçam na janela.
Declarar os objetos: TextField texto1,texto2,texto3,texto4;

Estipular a quantidade de caracteres para as caixas de texto:
texto1 = new JTextField(50); texto2 = new JTextField(3);
texto3 = new JTextField(10); texto4 = new JTextField(10);
Especificar posicionamento das caixas:
E chamar o método tela para exibir as caixas na janela:
tela.add(texto1); tela.add(texto2); tela.add(texto3); tela.add(texto4);
Estamos vendo agora a janela com os componentes acionados.
6.1 – Foco para uma caixa de texto

Podemos também utilizar o comando requestFocus(); para apontar o foco
para uma determinada caixa de texto: texto1. requestFocus();
6.2 – Cor da fonte para a caixa de texto
Podemos também utilizar o comando setForeground(Color.cor); para alterar
a cor da fonte da caixa de texto: texto1. setForeground(Color.cor);
6.3 – Trocando a fonte, estilo e tamanho da fonte do JtextField:
Texto1.setFont(new Font("NomeFonte",Font.ESTILO,TAMANHO));
6.4 – Alinhamento do texto de uma caixa de texto
O comando setHorizontalAlignment() define o alinhamento dentro da caixa de
texto: texto1. setHorizontalAlignment(JTextField.LEFT);
setHorizontalAlignment (JTextField.RIGHT); posiciona o texto dentro da
caixa de compra da direita pra esquerda,
setHorizontalAlignment(JTextField.LEFT); posiciona o texto dentro da caixa
da esquerda pra direita.
setHorizontalAlignment(JTextField.CENTER); centraliza o texto dentro da
caixa de texto.
6.5 – Alteração da cor de fundo da caixa de texto
Como visto anteriormente podemos efetuar essa alteração chamando o
comando: texto1.setBackground(Color.blue);
7 – Adicionando componentes JButton ou botões a sua janela

A classe JButton herda de AbstractButton, uma classe que herda de
JComponet e define o comportamento básico para os botões e itens de menu.
Como ocorre com instâncias da classe JLabel, objetos da classe JButton
podem conter texto, texto e imagem ou apenas imagens.Seguindo os mesmo
métodos dos outros aplicativos de como adicionar componentes na janela esse
também segue o mesmo modelo.
7.1 - Botão somente com texto: Veja o exemplo de botão sem imagem:
import java.awt.*;
public class ExemploBotao extends JFrame{
JButton botão;
public ExemploBotao(){
super("Exemplo com JButton");
setLayout(null);
botao = new JButton ("Procurar");
botao.setBounds(50,20,100,20);
tela.add(botao);
setSize(400, 250);
setVisible(true);
}
ExemploBotao app = new ExemploBotao();
}
}
7.2 - Botão com texto e imagem: Exemplo de um botão com imagem:
import java.awt.*;
import java.awt.event.*;
JButton botao;
ImageIcon icone;
setLayout(null);
icone = new ImageIcon("abrir.gif");
botao = new JButton ("Abrir",icone);
tela.add(botao);
setSize(300, 150);
setVisible(true);
}
}
}
Analisando o programa, declaramos o ícone como ImageIcon, depois

adicionamos a figura a ícone, icone = new ImageIcon("abrir.gif"); no final
adicionamos o ícone junto ao texto do botão, botao = new JButton
("Abrir",icone); e com o objeto tela, tela.add(botao); adicionamos o botão a
janela.
7.3 - Botão somente com imagem: Exemplo de botão somente com figura:
JButton botao;
ImageIcon icone;
setLayout(null);
botao = new JButton (icone);
tela.add(botao);
setSize(400, 250);
setVisible(true);
}

}
}
Muito simples fazer esse tipo de botão com o aplicativo anterior de botão com
imagem basta você retirar o texto de dentro da linha que somente a imagem
será adicionada, veja a linha:
Linha do botão com texto e imagem: botão = new JButton (“Abrir”,icone);
Linha do botão somente com imagem: botão = new JButton (icone);
Aplicativo com os três botões
7.4 – Adicionando vários botões na janela

Veja o exemplo:
import java.awt.*;
JButton botao1,botao2,botao3,botao4;
setLayout(null);
botao1 = new JButton ("Procurar");
botao2 = new JButton ("Voltar >>");
botao3 = new JButton ("Próximo >>");
botao4 = new JButton ("Abrir");
botao1.setBounds(50,20,100,20);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}
}
}
7.5 – Definir a cor de fundo para um componente JButton
Para trocar a cor de fundo basta adicionar no aplicativo anterior as seguintes

linhas:
botao1.setBackground(Color.yellow);
botao2.setBackground(Color.red);
botao3.setBackground(Color.blue);
botao4.setBackground(Color.white);
7.6 – Definir teclas de atalho para objetos JButton
Para definir as teclas de atalhos temos que importar o pacote:

import java.awt.event.*; no inicio do programa
import java.awt.*;
E adicione as seguintes linhas dentro do aplicativo anterior:

botao1.setMnemonic(KeyEvent.VK_P);
botao2.setMnemonic(KeyEvent.VK_V);
botao3.setMnemonic(KeyEvent.VK_X);
botao4.setMnemonic(KeyEvent.VK_S);
7.7 – Qual botão reagirá ao pressionamento da tecla enter
Você pode passar o foco para um determinado botão assim que pressionar a
tecla enter, Com o comando getRootPane().setDefaultButton(). Basta digitar
o comando getRootPane().setDefaultButton(botao);
botão é o nome do botão que você definiu no programa, nesse exemplo definir
o último botão.
Quando você pressionar a tecla Enter o botão que receberá o foco piscará.
Veja o resultado:
7.8 - Alterando a cor do texto de um componente JButton
Basta adicionar as seguintes linhas dentro do aplicativo:
botao1.setForeground(Color.blue);
botao2.setForeground(Color.green);
botao3.setForeground(Color.red);
botao4.setForeground(Color.pink);
Resultado do programa:
8 - Adicionando componentes JPasswordField
A classe JPasswordField possibilita a criação de caixas de texto para a

digitação de senhas. Esta classe herda diretamente de JTextField e, portanto,
permite a aplicação de todas as técnicas já vista na classe JTextField.
No aplicativo abaixo vamos ver como funciona esse componente:

import java.awt.*;
public class ExemploJPasswordField extends JFrame{
JPasswordField caixa;
JLabel rotulo;
public ExemploJPasswordField(){
super("Exemplo com JPasswordField");
setLayout(null);
rotulo = new JLabel("Senha: ");
caixa = new JPasswordField(10);
rotulo.setBounds(50,20,100,20);
caixa.setBounds(50,60,100,20);
tela.add(rotulo);
tela.add(caixa);
setSize(400, 250);
setVisible(true);
}
ExemploJPasswordField app = new ExemploJPasswordField();
}
}
8.1 – Alterando a cor de fonte de um JPasswordField
caixa.setForeground(Color.blue); você poderá trocar a cor da letra da caixa

de texto. No caso essa letra vai ficar azul.
8.2 – Definir uma cor personalizada para o componente JPasswordField
Você também pode definir uma cor para letra conforme seu gosto usando essa
linha caixa.setForeground(new Color(115,99,128));
8.3 – Alterando a cor de fundo de um componente JPasswordField

Você pode digitar essa linha no aplicativo anterior:
caixa.setBackground(Color.yellow);
A caixa de texto dentro ficará com a cor amarela por dentro
8.4 – Cor de fundo personalizada para o componente JPasswordField

Ao digitar essa linha no aplicativo dentro da caixa de texto ficará com a cor
rosa. Onde você mesmo pode definir sua cor.
caixa.setBackground(new Color(255,128,128));
8.5 – Alterar tipo de fonte, estilo e tamanho da letra do componente

Com essa linha você pode alterar o estilo da fonte o tipo e o tamanho da fonte.
caixa.setFont(new Font("Ariel",Font.BOLD,20));
Exemplos para essa fonte você pode aproveitar o exemplo do JTextField
8.6 – Alterando o caracter que aparece no componente JPasswordField

Você pode personalizar qual caracter vai aparecer na sua caixa de texto basta
você digitar essa linha caixa.setEchoChar('*');
Dentro dos parênteses você pode adicionar qualquer caracter.
9 – Controle JFormattedTextField para data, telefone, CEP, CPF
O componente JFormattedTextField, similar a uma caixa de texto JTextField,

fornece a possibilidade da validação e exibição de dados formatados em tempo
real, ao seja, à medida que seu conteúdo é inserido. Esse componente é
conhecido nas linguagens Visual Basic, Delphi, C++ como MaskEdit, ou
simplesmente caixa de texto tipo máscara.
A vantagem de usar uma caixa de texto tipo máscara é que o usuário é forçado
a digitar os dados no formato especificado. O controle não aceita conteúdo que
não siga os padrões predefinidos.
Antes de usar o componente JFormattedTextField, é preciso entender o

funcionamento da classe MaskFormatter (do pacote javax.swing.text). Essa
classe é usada para especificar a máscara que será usada na caixa de texto.
Para definir os caracteres que serão aceitos, você deve usar a seguinte tabela:
Símbolo Valor Aceito

# Um número
? Uma letra
A Uma letra ou um número
* Qualquer conteúdo será aceito pelo controle
U Uma letra convertida em maiúsculo
L Uma letra convertida em minúsculos
Obtida a tabela vamos ver essa classe em ação. O aplicativo seguinte exibe
quatro caixas de texto na qual deve ser digitado o CEP, TELEFONE, CPF e
uma DATA qualquer.
import javax.swing.text.*;
import java.awt.*;
import java.text.*;
public class ExemploJFormattedTextField extends JFrame{
JLabel rotulocep,rotulotel,rotulocpf,rotulodata;
JFormattedTextField cep,tel, cpf, data;
MaskFormatter mascaracep,mascaratel, mascaracpf, mascaradata;
public ExemploJFormattedTextField(){
super("Exemplo com JFormattedTextField");
setLayout(null);
rotulocep = new JLabel("CEP: ");

rotulotel = new JLabel("Telefone: ");
rotulocpf = new JLabel("CPF: ");
rotulodata = new JLabel("Data: ");
rotulocep.setBounds(50,40,100,20);
rotulotel.setBounds(50,80,100,20);
rotulocpf.setBounds(50,120,100,20);
rotulodata.setBounds(50,160,100,20);
try{
mascaracep = new MaskFormatter("#####-###");
mascaratel = new MaskFormatter("(##)####-####");
mascaracpf = new MaskFormatter("#########-##");
mascaradata = new MaskFormatter("##/##/####");
mascaracep.setPlaceholderCharacter(‘_’);
mascaratel.setPlaceholderCharacter(‘_’);
mascaracpf.setPlaceholderCharacter(‘_’);
mascaradata.setPlaceholderCharacter(‘_’);
}
catch(ParseException excp){}
cep = new JFormattedTextField(mascaracep);

tel = new JFormattedTextField(mascaratel);
cpf = new JFormattedTextField(mascaracpf);
data = new JFormattedTextField(mascaradata);
cep.setBounds(150,40,100,20);
tel.setBounds(150,80,100,20);
cpf.setBounds(150,120,100,20);
data.setBounds(150,160,100,20);
tela.add(rotulocep);
tela.add(rotulotel);
tela.add(rotulocpf);
tela.add(rotulodata);
tela.add(cep);
tela.add(tel);
tela.add(cpf);
tela.add(data);
setSize(400, 250);
setVisible(true);
}
ExemploJFormattedTextField app = new ExemploJFormattedTextField();
}
}
Para construir o exemplo, usamos as variáveis globais:

FormattedTextField cep,tel, cpf, data;
O código que inicializa a máscara foi inserido em um bloco try{ } de modo a

evitar uma exceção:
try{
mascaracep.setPlaceholderCharacter(‘_’);
mascaratel.setPlaceholderCharacter(‘_’);
mascaracpf.setPlaceholderCharacter(‘_’);
mascaradata.setPlaceholderCharacter(‘_’);
}
Observe o uso do símbolo # para permitir somente valores numéricos e uma

chamada ao método setPlaceholderCharacter para definir o caractere que
será exibido como marcador para a máscara, geralmente o caractere de
sublinhado. Essa máscara é fornecida como argumento para o construtor da
classe JFormattedTextField:

9.1 – Adicionando cores na letra do JFormattedTextField
Essas linhas podem ser adicionadas no programa anterior acima do objeto tela.
cep.setForeground(Color.blue);
tel.setForeground(Color.red);
cpf.setForeground(Color.green);
data.setForeground(new Color(255,128,128));
9.2 – Adicionando cores no fundo do JFormattedTextField

Já esses códigos podem ser adicionados logo abaixo ao anterior.
cep.setBackground(Color.yellow);
tel.setBackground(Color.yellow);
cpf.setBackground(new Color(255,255,204));
data.setBackground(new Color(255,255,204));
9.3 – Alterando o tipo, estilo, tamanho da fonte do JFormattedTextField

Já esses códigos podem ser adicionados logo abaixo ao anterior.
cep.setFont(new Font("Times New Roman",Font.BOLD,14));

tel.setFont(new Font("Comic Sans MS",Font.PLAIN,14));
cpf.setFont(new Font("Arial",Font.BOLD,14));
data.setFont(new Font("Tahoma",Font.BOLD,14));
Aplicativo sendo executado depois de todos os códigos Java, estarem

adicionados no aplicativo, veja os efeitos com as cores:
10 – Fazendo um JButton executar uma ação
10.1 – Clicando no botão para fechar uma janela
Exemplo:
import java.awt.*;
public class ExemploBotaoSair extends JFrame{
JButton botaosair;
public ExemploBotaoSair(){
setLayout(null);
botaosair = new JButton ("Sair");
botaosair.setBounds(100,50,100,20);
botaosair.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
System.exit(0);
}
}
);
tela.add(botaosair);
setSize(300, 150);
setVisible(true);
}
ExemploBotaoSair app = new ExemploBotaoSair();
}
}
Como funciona o aplicativo sempre lembrando que temos que importar os

pacotes:
import javax.swing.*; - pacote que exibe conteúdos na janela

import java.awt.*; - pacote que exibe conteúdos na janela
import java.awt.event.*; - pacote que trabalha com os eventos
Como já visto em outros aplicativos:

Declarar o componente como JButton: JButton botaosair;
Atribuir o texto ao botão: botaosair = new JButton ("Sair");
Posicionar o botão na janela: botaosair.setBounds(100,50,100,20);
E chama o objeto tela para exibir o componente: tela.add(botaosair);
Explicando o funcionamento do botão:
System.exit(0);
}
}
);
addActionListener – Adicionar ação a lista que estará dentro do botão.
new ActionListener – Chamando nova ação a ser listada.
public void actionPerformed(ActionEvent e) –

performance da ação que o evento público chamara que será o exit.
System.exit(0); - Finaliza o aplicativo
Use sempre essa lista para fazer qualquer botão funcionar ou chama algum
evento:
nomebotao.addActionListener(
}
}
);
10.2 – Clicando no mostrar para descobrir a senha digitada

Um aplicativo simples mais muito interessante de ser observado, o usuário
digita a senha e clicando em mostrar será habilitado um JLabel mostrando qual
a senha que foi digitada. Veja o exemplo:
import java.awt.*;
public class SenhaDigitada extends JFrame{
JLabel rotulo, exibir;
JButton mostrar;
public SenhaDigitada(){
setLayout(null);

exibir = new JLabel("A senha digitada é: ");
mostrar = new JButton("Mostrar");
exibir.setVisible(false);
exibir.setBounds(50,120,200,20);
mostrar.setBounds(150,100,80,20);
mostrar.addActionListener(
String senha = new String(caixa.getPassword());
exibir.setVisible(true);
exibir.setText(senha);
}
}
);
tela.add(rotulo);
tela.add(caixa);
tela.add(exibir);
tela.add(mostrar);
setSize(400, 250);
setVisible(true);
}
SenhaDigitada app = new SenhaDigitada();
}
}
Um aplicativo muito fácil de ser compreendido, de diferente ao anterior que já
foi visto na parte JPasswordField só acrescentamos um novo JLabel que
quando iniciado vem oculto, e dentro do evento do botão criamos uma variável
chamada senha do tipo String, onde ela recebe uma String que vem da caixa
da senha e então é convertida em caracteres normal. E depois será habilitado
novamente o JLabel.
10.3 – Clicando no botão somar e será mostrada a soma dos números
Já nesse aplicativo alguns métodos novos foram aplicados, esse pede um

pouquinho de nossa atenção, alguns componentes foram colocados ao lado
para não ficar muito extenso e ser mais fácil de compreender.
Veja o exemplo:
import java.awt.*;
public class Soma extends JFrame{
JLabel rotulo1, rotulo2,exibir;
JTextField texto1,texto2;
JButton somar;
public Soma(){
super("Exemplo de soma");
setLayout(null);
rotulo1 = new JLabel("1º Número: ");
exibir = new JLabel("");
somar = new JButton("Somar");
rotulo1.setBounds(50,20,100,20); rotulo2.setBounds(50,60,100,20);
texto1.setBounds(120,20,200,20); texto2.setBounds(120,60,200,20);
exibir.setBounds(50,120,200,20); somar.setBounds(150,100,80,20);
somar.addActionListener(
int numero1,numero2,soma;
soma=0;
numero1 = Integer.parseInt(texto1.getText());
soma = numero1 + numero2;
exibir.setText("A soma é: "+soma);
}
}
);
tela.add(rotulo1); tela.add(rotulo2);
tela.add(texto1); tela.add(texto2);
tela.add(exibir); tela.add(somar);
setSize(400, 250);
setVisible(true);
}
Soma app = new Soma();
}
}
A habilitação do botão já foi explicado no aplicativo anterior, o que foi

acrescentado nesse aplicativo, foram os comandos que trabalham com
conversão de números.
Foram declaradas três variáveis do tipo inteira: int numero1, numero2, soma;
Foi atribuído zero a variável soma, para a variável ser iniciada vazia: soma=0;
Como texto1, texto2 são String, melhor dizer texto para armazená-las nas
variáveis numero1 e numero2, será necessário converte a String em números.
Nesse caso estamos convertendo o texto1 em inteiro para isso usamos o

Integer.parseInt(), e armazenamos na variável numero1 que é inteira.
Isso ocorrerá para a texto2 e a variável numero2.
Depois de convertido os valores agora é só fazer a soma e armazenar na

variável correspondente a soma, veja: soma = numero1 + numero2;
Chamamos o comando para habilitar o JLabel exibir e jogamos o valor de soma

dentro do texto do Jlabel exibir para se apresentado no aplicativo.
Para variáveis do tipo Float, usaremos: Float.parseFloat();

Para variáveis do Double, usaremos Doublé.parseDouble();
10.4 – Clicando no botão limpar e as caixas de texto serão limpas

Depois de usadas nada como limpar suas caixas de texto, esta ai o exemplo
que irá ajudá-lo(a).
import java.awt.*;
public class Limpar extends JFrame{
JLabel rotulo1, rotulo2;
JButton limpar;
public Limpar(){
super("Exemplo Limpar");
setLayout(null);
limpar = new JButton("Limpar");
limpar.setBounds(150,100,80,20);
limpar.addActionListener(
texto1.setText(null);
texto1.requestFocus();
}
}
);
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(texto1);
tela.add(texto2);
tela.add(limpar);
setSize(400, 250);
setVisible(true);
}
Limpar app = new Limpar();
}
}
Nada de diferente no aplicativo somente as linhas que vão limpar as caixas de

texto e passar o foco para a primeira caixa vejam:
texto1.setText(null); ou texto1.setText(“”);
texto2.setText(null); ou texto2.setText(“”);
É atribuído null dentro das caixas, pois nulo significa vazio e requestFocus()
passa o foco para a caixa selecionada pelo usuário.
10.5 – Ocultar e Exibir componentes
Esse aplicativo é só para teste não tem muito que ser explicado, pois a única
coisa diferente é que quando você clica em ocultar os JLabels some e você
clica em exibir os JLabels aparecem novamente na janela.
Isso ocorre por que o comando setVisible(false), oculta e o comando
setVisible(true), exibe mostra na janela. Veja o exemplo:
import java.awt.*;
public class OcultarExibir extends JFrame{
JButton ocultar,exbir;
public OcultarExibir(){
super("Exemplo de ocultar e exibir componente");
setLayout(null);
rotulo1 = new JLabel("Rótulo 1"); rotulo2 = new JLabel("Rótulo 2");
ocultar = new JButton("Ocultar "); exbir = new JButton("Exibir ");
ocultar.setBounds(100,100,80,20); exbir.setBounds(250,100,80,20);
ocultar.addActionListener(
rotulo1.setVisible(false);
}
}
);
exbir.addActionListener(
rotulo1.setVisible(true);
}
}
);
tela.add(ocultar); tela.add(exbir);
setSize(400, 250);
setVisible(true);
}
OcultarExibir app = new OcultarExibir();
}
}
10.6 – Desabilitar e Habilitar Exibir componentes
Nada de diferente também somente o comando setEnabled(true) que habilita

e o setEnabled(false) eu desabilita. Veja o exemplo:
import java.awt.*;
public class DesabilitarHabilitar extends JFrame{
JButton desabilitar,habilitar;
public DesabilitarHabilitar(){
super("Exemplo de Desabilitar e Habilitar componentes");
setLayout(null);
rotulo1 = new JLabel("Rótulo 1"); rotulo2 = new JLabel("Rótulo 2");
desabilitar = new JButton("Desabilitar"); habilitar = new JButton("Habilitar");
desabilitar.setBounds(80,100,100,20); habilitar.setBounds(250,100,100,20);
desabilitar.addActionListener(
rotulo1.setEnabled(false);
}
}
);
habilitar.addActionListener(
rotulo1.setEnabled(true);
}
}
);
tela.add(desabilitar); tela.add(habilitar);
setSize(400, 250);
setVisible(true);
}
DesabilitarHabilitar app = new DesabilitarHabilitar();
}
}
11 – Apresentando a classe JList

A classe JList permite a criação do componente conhecido como caixa de
listagem ou ListBox (nome popular entre programadores delphi e VB). Uma
caixa de listagem é um controle visual que exibe uma série de itens dos quais o
usuário pode selecionar um ou mais itens.
A maneira mais usual de criar um caixa de listagem em Java é usar um vetor
de Strings para definirmos os itens que serão exibidos na lista. O aplicativo
seguinte apresenta uma janela que contém uma caixa de listagem e um botão.
O usuário pode selecionar uma entre oito cidades. Ao clicar no botão exibir, o
valor selecionado será exibido em um JLabel.
import java.awt.*;
public class ExemploJList extends JFrame{
JList lista;
String cidades[] = {"Rio de Janeiro","São Paulo","Minas Gerais","Espírito Santo",
"Bahia","Pernambuco","Rio Grande do Sul","Acre"};
JButton exibir;
JLabel rotulo;
public ExemploJList(){
super("Exemplo de List");
setLayout(null);
exibir = new JButton("Exibir");
rotulo = new JLabel("");
lista = new JList(cidades);
lista.setVisibleRowCount(5);
JScrollPane painelRolagem = new JScrollPane(lista);
lista.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
painelRolagem.setBounds(40,50,150,100);
exibir.addActionListener(
rotulo.setText("o estado é: "+lista.getSelectedValue().toString());
} } );
tela.add(painelRolagem);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
ExemploJList app = new ExemploJList();
}
}
Experimente selecionar um dos itens da lista e clicar no botão Exibir. Observe

que o texto do item selecionado é exibido em uma caixa de mensagem. Vamos
analisar o código e ver como isso foi possível.
O primeiro passo é declarar uma instância da classe JList chamada lista:

JList lista;
Em seguida declaramos e inicializamos um vetor de objetos String que contém
os itens que estarão disponíveis na list:
String cidades[] = {"Rio de Janeiro","São Paulo","Minas Gerais","Esprito
Santo", "Bahia","Pernambuco","Rio Grande do Sul","Acre"};
Os itens do vetor cidades são atribuídos à caixa de listagem por meio da
seguinte instrução:
É importante observar que o vinculo entre a caixa de listagem e o vetor cidades
não termina após essa instrução. Mais tarde, se alguma alteração for feita nos
elementos do vetor, você poderá atualizar a lista com uma chamada ao método
repaint da classe JComponent.
lista.rapaint();
Após a atribuição dos itens do vetor cidades à lista, temos que definir a
quantidade de elementos que serão visíveis sem a necessidade de acionar as
barras de rolagem isso é feito na linha:
Como queremos que o usuário seja capaz de selecionar apenas um item por
vez efetuaremos uma chamada ao método setSelectionMode e usaremos
uma das constantes da classe ListSelectionModel para definir a lista como
sendo de seleção única:
Uma lista não fornece barras de rolagem por padrão. Dessa forma, uma
instância da classe JScrollPane é usada para essa finalidade:
Quando clicamos no botão exibir, o método actionPerformed da classe publica.
Chamado:
rotulo.setText(“o estado é: “+lista.getSelectedValue().toString());
} } );
Nós efetuamos uma chamada ao método getSelectedValue().toString()); da

classe JList para obter o valor inteiro correspondente ao item selecionados.
Esse valor inicia em 0 e vai até a quantidade de itens menos 1. Obtido o valor,
só precisamos fornece-lo como índice para o valor o vetor cidades exibir o
resultado final na caixa de listagem.
11.1 – Selecionando múltiplos itens em uma caixa de listagem
No tópico anterior escrevemos um aplicativo que permita selecionar um item

em uma caixa de listagem e exibir seu valor e, um JLabel. No exemplo apenas
um dos itens podia ser selecionado. É possível, porém, selecionar mais de um
item em uma caixa de listagem. Tudo que temos a fazer é alterar o valor da
constante fornecida para o método setSelectionMode. Veja os valores
possíveis:
Valor da Constante Resultado
SINGLE_SELECTION Apenas um item pode ser selecionado de
cada vez.
SINGLE_INTERVAL_SELECTION Vários itens em um intervalo contíguo podem
ser selecionados.
MULTIPLE_INTERVAL_SELECTION Vários podem ser selecionados sem a
restrição de intervalo.
O exemplo seguinte é uma pequena modificação do exemplo anterior que

mostra como vários itens podem ser selecionados e como você pode atribuí-los
a um vetor de objetos de modo a manipulá-los mais tarde:
import java.awt.*;
public class ExemploJList2 extends JFrame{
JList lista;
JButton exibir;
public ExemploJList2(){
setLayout(null);
lista.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
Object selecionados[] = lista.getSelectedValues();
String resultados = "Valores selecionados:\n";
for(int i=0;i<selecionados.length;i++)
resultados += selecionados[i].toString()+"\n";
JOptionPane.showMessageDialog(null,resultados);
} } );
tela.add(exibir);
setSize(400, 250);
setVisible(true);
}
ExemploJList2 app = new ExemploJList2();
}
}
Execute o código e experimente selecionar mais de um item na caixa de

listagem. Lembre-se de que mais de um item pode ser selecionados mantendo
a tecla Crtl pressionada enquanto clicamos nos outros itens. Clique no botão
exibir, e você verá a caixa de mensagem exibindo os valores dos itens
selecionados.
Este exemplo apresenta poucas modificações. A primeira delas é a

modificação do valor fornecido para o método setSelectionMode:
Veja que agora a lista permite que vários itens sejam selecionados. A outra
modificação aconteceu no evento do botão exibir:
} } );
A classe JList possui um método chamado getSelectedValues que retorna um

vetor de objetos da classe Object. Este valor contém todos os itens
selecionados na caixa de listagem. Assim, a linha:
Object selecionados[ ] = lista.getSelectedValues();
Quando foi adicionado \n no final da frase Valores selecionados, que como

visto \n pula uma linha na próxima palavra que será exibida e não ao lado.
Criar um vetor chamado selecionados e atribui a ele os itens retornados pelo

método getSelectedValues. Mantenha em mente que temos um vetor objetos
da classe Object. Esquecer-se deste detalhe pode ser desastroso. O laço for
interage com cada um dos elementos do vetor selecionados, efetuando
chamadas ao método String de cada um e concatenando o resultado obtido
com o valor da variável resultados.
Cada vez que selecionados jogar um item dentro de resultado, cada item cada
item vai com a opção de pular uma linha por isso os itens são exibidos um em
baixo do outro.
A caixa de mensagem JOptionPane será estuda mais profundamente nos

próximos capítulos da apostila. A opção showMessageDialog, que dizer uma
mensagem de dialogo será exibida ao usuário.
11.2 – Trocando a cor da letra do JList

É possível trocar a cor da letra do componente JList abaixo do comando onde
você define em qual linha e coluna vai ficar o componente você pode digitar
essa linha: lista.setForeground(Color.blue);
11.3 – Trocando a cor de fundo do JList
lista.setBackground(Color.yellow);
11.4 – Trocando tipo, estilo e tamanho da fonte do Jlist

lista.setFont(new Font("Times New Roman",Font.BOLD,16));
Execute o aplicativo ExemploJList3.java que você poderá conferir onde aplicar

os comandos para as alterações citadas acima.
12 – uso da classe JComboBox na criação de caixas de combinação
Objetos da classe JComboBox são usados para a criação de controles

conhecidos como caixas de combinação, combo box ou lista drop-down. A
diferença entre a caixa de listagem e caixa de combinação é que esta última
exibe seus itens somente quando clicamos na seta (indicativo visual de que o
controle possui itens entre os quais podemos escolher) ou pressionando F4
quando o foco está no componente. Além, disso, caixas de combinação são
usadas quando o espaço é insuficiente para acomodar uma caixa de listagem.
A classe JcomboBox herda de JComponent, como mostra o relacionamento

seguinte:
Component
List Button Container Label CheckBox
Window
J Component
Frame
JComboBox
O aplicativo seguinte apresenta uma janela que contém uma caixa de

combinação e um botão. Quando selecionamos um item no JComboBox e
pressionamos o botão, Exibir o valor do item selecionado é exibido em uma
caixa de mensagem. Eis a listagem para o exemplo:
import java.awt.*;
public class ExemploJComboBox extends JFrame{
JComboBox lista;
String cidades[] = {"Rio de Janeiro","São Paulo","Minas Gerais","Espírito
Santo","Bahia","Pernambuco","Rio Grande do Sul","Acre"};
JButton exibir;
JLabel rotulo;
public ExemploJComboBox(){
super("Exemplo de JComboBox");
setLayout(null);
lista = new JComboBox(cidades);
lista.setMaximumRowCount(5);
lista.setBounds(50,50,150,30);
rotulo.setText("o estado é: "+lista.getSelectedItem().toString()); } } );
tela.add(lista);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
ExemploJComboBox app = new ExemploJComboBox();
}
}
Existem muitas similaridades na maneira de manipular as classes JList e

JComboBox. Durante a análise você perceberá que muitas das técnicas que
usamos anteriormente podem ser aplicadas quando estiver lidando com caixas
de combinação. O primeiro passo foi declarar um objeto da classe JComboBox:
JComboBox Lista;
Em seguida temos um vetor de nomes de cidades que será usado para

definimos os itens da caixa de combinação:

Temos um vetor de oito elementos que são atribuídos à caixa de combinação

com a seguinte instrução:
Um objeto da classe JComboBox já possui barras de rolagem. Tiramos proveito

desse fator efetuamos uma chamada ao metido setMaximumRowCount para
definir a quantidade e itens visíveis na lista sem a necessidade de acionar as
barras de rolagem:
O processo usado para exibir o item selecionado é o mesmo que usamos para
as caixas de listagem.
new ActionListener(){public void actionPerformed(ActionEvent e){
rotulo.setText("o estado é: “+lista.getSelectedItem().toString());
}});
tela.add(lista);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
12.1 – Como criar uma caixa de combinação editável
Se você experimentou com o exemplo anterior deve ter percebido que a caixa
de combinação é somente leitura, ou seja, estamos limitados aos itens
disponíveis para a escolha.
Existe, porém, uma forma de permitir que o usuário digite o valor desejado em
uma caixa de combinação. Basta efetuar uma chamada ao método setEditable
fornecendo o valor true como argumento:
lista.setEditable(true);
import java.awt.*;
public class ExemploJComboBox2 extends JFrame{
JComboBox lista;
JButton exibir;
JLabel rotulo;
public ExemploJComboBox2(){
setLayout(null);
exibir.addActionListener(new ActionListener(){
rotulo.setText("o estado é: "+lista.getSelectedItem().toString());
}});
tela.add(lista);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
ExemploJComboBox2 app = new ExemploJComboBox2();
} }
Agora o usuário será capaz de escolher um dos itens disponíveis ou digitar sua
escolha. É comum em campos editáveis o pressionamento da tecla enter após
a entrada da informação no campo. Desse forma, é importante efetuar uma
chamada ao método addActionListener da caixa de combinação e definir o
procedimento a ser efetuado. O trecho do código seguinte mostra como exibir o
valor que o usuário acaba de informar:
}
}
);
13. Entendimento e uso da classe JCheckBox
A classe JCheckBox é usada quando precisamos de controles como

caixas de seleção que podem ser marcados ou desmarcados pelo usuário e
oferecem feedback visual de modo percebemos seu estado atual. O uso de
caixas de seleção é freqüente em ambientes em que o usuário deve selecionar
uma ou mais das opções oferecidas.
O aplicativo seguinte apresenta uma janela com quatro caixas de
seleção e um botão. Marque uma das opções e pressione o botão. Uma
mensagem exibe o texto das caixas selecionadas. Veja a listagem:
import java.awt.*;
public class ExemploJCheckBox extends JFrame{
JCheckBox primeira,segunda,terceira,quarta,quinta;
JLabel vazio;
public ExemploJCheckBox(){
super("Exemplo de um JCheckBox");
tela.setLayout(null);
JLabel rotulo = new JLabel("Quais suas linguagens favoritas? ");
primeira = new JCheckBox("Java");
primeira.setMnemonic(KeyEvent.VK_J);
primeira.setBounds(40,60,60,20);
segunda = new JCheckBox("C++");
segunda.setMnemonic(KeyEvent.VK_C);
segunda.setBounds(100,60,60,20);
terceira = new JCheckBox("Delphi");
terceira.setMnemonic(KeyEvent.VK_D);
terceira.setBounds(160,60,60,20);
quarta = new JCheckBox("Visual Basic");
quarta.setMnemonic(KeyEvent.VK_V);
quarta.setBounds(230,60,100,20);
quinta = new JCheckBox("Python");
quinta.setMnemonic(KeyEvent.VK_P);
quinta.setBounds(335,60,70,20);
JButton botao = new JButton("Exibir");
vazio = new JLabel("");
vazio.setBounds(100,200,600,20);
botao.addActionListener(
String escolhas = "";
if (primeira.isSelected() ==true)
escolhas = escolhas + primeira.getText();
if (segunda.isSelected() ==true)
escolhas = escolhas +" "+segunda.getText();
if (terceira.isSelected() ==true)
escolhas = escolhas +" "+terceira.getText();
if (quarta.isSelected() ==true)
escolhas = escolhas +" "+quarta.getText();
if (quinta.isSelected() ==true)
escolhas = escolhas+" "+quinta.getText();
vazio.setText("Você escolheu: "+escolhas);}});
tela.add(rotulo);
tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
tela.add(botao);
tela.add(vazio);
setSize(500,300);
setVisible(true);
}
public static void main (String args[]){
ExemploJCheckBox app = new ExemploJCheckBox();
}
}
Durante a análise do código veremos como isso foi possível. Por ora, execute o
aplicativo, selecione as opções desejadas e clique no botão. Veja se o
resultado confere com sua escolha.
O primeira passo para a construção deste exemplo foi declarar as referências

global das instâncias da classe JCheckBox:
Mais adiante você entenderá por que essa variável precisa ser global. Em
seguida temos a criação de cinco caixas de seleção. Veja o código para a
primeira:
Observe que a forma de criar objetos da classe JCheckBox é semelhante a

criar objetos das classes JButton E JLabel.
Próximo passar atribuir às caixas de seleção suas teclas de atalho:

A tecla de atalho para o controle é definida com uma chamada ao método

setMnemonic.
Próximo passo posicionar as caixas de seleção no formulário, chamada ao

método setBounds, já visto anteriormente:
Para adicionar as cinco caixas de seleção à janela, fizemos o uso de tela.add,

já visto anteriormente: tela.add(primeira); tela.add(segunda); tela.add(terceira);
tela.add(quarta); tela.add(quinta);
O rótulo vazio e o botão de exibir já foram visto em exercícios anteriores.

Quando você clicar no botão o conteúdo que você selecionou vai aparecer no
rótulo vazio.
Vamos entender agora o botão exibir:
Na primeira linha desse método criamos uma variável chamada escolhas do

tipo String e definimos se conteúdo inicial como vazio. Em seguida temos um
laço IF, toda vez que você clicar no botão exibir ele fará a verificação e se a
caixa de seleção for marcada o método isSelected() testa o retorno se valor
for verdadeira, o aplicativo armazenará o conteúdo na variável escolhas.
Toda vez que você marca uma caixa de seleção o método setSelected()
recebe o valor true (verdadeiro), e quando você desmarca a caixa de seleção o
valor do método setSelected(), recebe o valor de false (falso).
13.1 – Iniciar um formulário com uma caixa de seleção marcada.
import java.awt.*;
public class ExemploJCheckBox2 extends JFrame{
public ExemploJCheckBox2(){
primeira.setSelected(true);
tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
setSize(500,300);
setVisible(true);
}
ExemploJCheckBox2 app = new ExemploJCheckBox2();
}
}
Utilize o método setSelected(true) para a caixa de seleção desejada:
13.2 – Alterando a cor da letra de um JCheckBox
Exemplo disponível no aplicativo ExemploJCheckBox1
primeira.setForeground(Color.blue);
segunda.setForeground(Color.red);
terceira.setForeground(Color.green);
quarta.setForeground(Color.yellow);
quinta.setForeground(Color.white);
14 – Uso da Classe JRadioButton para criar botões de opção
As caixas de seleção fornecem uma maneira conveniente de oferecer ao

usuário alguns itens dos quais ele pode escolher um, vários ou todos. Existem,
no entanto, situações em que apenas um dos itens pode ser selecionado. Para
esses casos temos os botões de opção. Botões de opção têm seu uso
justificado em casos em que apenas uma das opções pode ser selecionada.
Essa funcionalidade só é atingida quando usamos objeto da classe
ButtonGroup para agrupar os itens de modo, que sempre que um item dor
selecionado, os demais sejam automaticamente desmarcados.
O aplicativo seguinte apresenta uma janela com cinco botões de opção.
Quando você clicar em exibir uma mensagem exibirá o valor selecionado e
quando você clicar em outra opção a anterior será desmarcada.
import java.awt.*;
public class ExemploRadioButton extends JFrame{
JRadioButton primeira,segunda,terceira,quarta,quinta;
JLabel rotulo,rotulo2;
JButton exibir;
ButtonGroup grupo;
public ExemploRadioButton(){
super("Exemplo de um JRadioButton");
rotulo = new JLabel("Escolha uma cidade: ");
rotulo2 = new JLabel("");
exibir = new JButton ("Exibir");
primeira = new JRadioButton("Rio de Janeiro");
segunda = new JRadioButton("São Paulo");
terceira = new JRadioButton("Minas Gerais");
quarta = new JRadioButton("Amazonas");
quinta = new JRadioButton("Rio Grande do Sul");
JButton exibir;
ButtonGroup grupo;
grupo.add(primeira);
grupo.add(segunda);
grupo.add(terceira);
grupo.add(quarta);
grupo.add(quinta);
rotulo2.setText("A cidade escolhida foi: "+primeira.getText());
rotulo2.setText("A cidade escolhida foi: "+segunda.getText());
rotulo2.setText("A cidade escolhida foi: "+terceira.getText());
rotulo2.setText("A cidade escolhida foi: "+quarta.getText());
rotulo2.setText("A cidade escolhida foi: "+quinta.getText());}});
tela.add(rotulo);
tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
tela.add(exibir);
tela.add(rotulo2);
setSize(500,300);
setVisible(true);
}
ExemploRadioButton app = new ExemploRadioButton();
}
}
Explicando o aplicativo:
Para o exemplo criamos os botões de seleção e definimos suas teclas de

atalho.
Primeiro declaramos o grupo na área pública veja:

ButtonGroup grupo;
Botões de opção são agrupados usando uma instância da classe ButtonGroup:

ButtonGroup grupo;
Para adicionar um botão ao grupo, basta efetuar uma chamada ao metodo add
da classe ButtonGroup. Veja:
grupo.add(segunda);
grupo.add(quarta);
grupo.add(quinta);
É preciso, porém manter em mente que a classe ButtonGroup não é um
contêiner para objetos. Essa classe serve apenas ao propósito de agrupar os
botões para que somente um possa ser selecionado por uma vez.
Se caso o usuário quiser colocar um botão padrão, aquele que já esteja
marcado quando iniciar a janela use: primeiro.setSelected(true);
Método: setSelected(true) – marca o botão

setSelected(false) – desmarca o botão
Método: isSelected(true) – verifica se o botão esta marcado

isSelected(false) – verifica se o botão esta desmarcado
15 – Fazendo um aplicativo com ComboBox CheckBox RadioButton
import java.awt.*;
public class ExemploComboCheckRadio extends JFrame{
JLabel rotulo1, rotulo2, rotulo3,texto;
JCheckBox negrito,italico,normal,negritoitalico;
JRadioButton tam1,tam2,tam3,tam4;
ButtonGroup grupo;
String cor[] = {"Sem Cor", "Vermelho", "Azul",
"Verde","Amarelo","Branco","Preto"};
JComboBox lista;
Integer estilo, tamfonte;
public ExemploComboCheckRadio(){
super("Exemplo Combo Check Radio BOX");
setLayout(null);
rotulo1 = new JLabel("Cor");
rotulo2 = new JLabel("Estilo");
rotulo3 = new JLabel("Tamanho");
texto = new JLabel("Programa feito em Java");
lista = new JComboBox(cor);
negrito = new JCheckBox("Negrito");
italico = new JCheckBox("Italico");
normal = new JCheckBox("Normal");
negritoitalico = new JCheckBox("Negrito Itálico");
tam1 = new JRadioButton("12");
grupo = new ButtonGroup();
grupo.add(tam1);
grupo.add(tam2);
grupo.add(tam3);
grupo.add(tam4);
texto.setBounds(100,200,300,20);
negrito.setBounds(200,50,100,20);
italico.setBounds(200,70,100,20);
normal.setBounds(200,90,100,20);
negritoitalico.setBounds(200,110,150,20);
tam1.setBounds(350,50,100,20);
tam4.setBounds(350,110,100,20);
tamfonte=12;
estilo=Font.PLAIN;
//coloca cor na fonte
lista.addActionListener( new ActionListener(){
if (lista.getSelectedItem().toString() == "Sem Cor")
texto.setForeground(Color.black);
if (lista.getSelectedItem().toString() == "Vermelho")
texto.setForeground(Color.red);
if (lista.getSelectedItem().toString() == "Azul")
texto.setForeground(Color.blue);
if (lista.getSelectedItem().toString() == "Verde")
texto.setForeground(Color.green);
if (lista.getSelectedItem().toString() == "Amarelo")
texto.setForeground(Color.yellow);
if (lista.getSelectedItem().toString() == "Branco")
texto.setForeground(Color.white);
if (lista.getSelectedItem().toString() == "Preto")
texto.setForeground(Color.black);}});
//coloca a fonte tamnho 12
tam1.addActionListener(new ActionListener(){
tamfonte=12;
texto.setFont(new Font("",estilo,tamfonte));}});
tamfonte=14;
tam3.addActionListener( new ActionListener(){
tamfonte=16;
tamfonte=18;
//coloca a fonte em negrito
negrito.addActionListener( new ActionListener(){
estilo=Font.BOLD;
normal.setSelected(false);
italico.setSelected(false);
negritoitalico.setSelected(false);
//coloca a fonte em italico
italico.addActionListener( new ActionListener(){
estilo=Font.ITALIC;
negrito.setSelected(false);
//coloca a fonte normal
normal.addActionListener( new ActionListener(){
estilo=Font.PLAIN;
//coloca a fonte em negrito e italico
negritoitalico.addActionListener( new ActionListener(){
estilo=Font.BOLD+Font.ITALIC;
tela.add(rotulo1); tela.add(rotulo2); tela.add(rotulo3);
tela.add(texto);
tela.add(negrito); tela.add(italico);
tela.add(normal); tela.add(negritoitalico);
tela.add(tam1); tela.add(tam2);
tela.add(tam3);tela.add(tam4);
tela.add(lista);
setSize(500,300);
setVisible(true); }
ExemploComboCheckRadio app = new ExemploComboCheckRadio();
}}
Aplicativo sendo executado.
Vamos estudar o aplicativo:
1º Passo: declarar as variáveis e os tipos

ButtonGroup grupo;
String cor[] = {"Sem Cor", "Vermelho", “Azul", "Verde"," Amarelo"," Branco"," Preto"};
JComboBox lista;
2º Passo: definir o conteúdo que serão exibidos na tela

Rótulos
rotulo1 = new JLabel("Cor"); rotulo2 = new JLabel("Estilo");
rotulo3 = new JLabel("Tamanho"); texto = new JLabel("Programa feito em Java");
ComboBox: lista = new JComboBox(cor);

Quantidade de linha no ComboBox: lista.setMaximumRowCount(7);
Estilo da fonte
negrito = new JCheckBox("Negrito");
italico = new JCheckBox("Itálico");
Tamanho da Fonte:
3º Passo: adicionar o RadioButton em um grupo para que somente um seja

selecionado
grupo.add(tam1);
grupo.add(tam2);
grupo.add(tam3);
grupo.add(tam4);
4º Passo: definir o posicionamento das opções

rotulo3.setBounds(300,20,70,20); texto.setBounds(100,200,300,20);
lista.setBounds(40,50,150,20); negrito.setBounds(200,50,100,20);
italico.setBounds(200,70,100,20); normal.setBounds(200,90,100,20);
tam1.setBounds(350,50,100,20);tam2.setBounds(350,70,100,20);
tam3.setBounds(350,90,100,20);tam4.setBounds(350,110,100,20);
Todos os passos acima já foram visto em outros aplicativos.
5º Passo: atribuir valor as variáveis que vai guardar o tamanho e o estilo da

fonte.
tamfonte=12; estilo=Font.PLAIN;
6º Passo: Funcionalidade do ComboBox – seleciona a cor da fonte

lista.addActionListener( new ActionListener(){
É feita a comparação com o comando IF, se o conteúdo da string do ComboBox for
igual a cor que você escolheu, então setForeground coloca a cor escolhida no rótulo
texto.
7º Passo: Trocar o tamanho da fonte

tamfonte=12;
tamfonte=14;
tamfonte=16;
tamfonte=18;
Quando você clicar no tamanho desejado, a variável tamfonte recebe o tamanho
escolhido, e modifica o tamanho do rótulo texto, o valor da variável tamfonte só será
modificado se você alterar e escolher outro tamanho, por isso a variável tamfonte é
declarada pública uma vez colocado valor nela, todos os métodos que tiver utilizando
essa variável faz referência ao valor dela.
8º Passo: Escolher o estilo da fonte

Coloca a fonte em negrito
negrito.addActionListener( new ActionListener(){
estilo=Font.BOLD;
Quando você selecionar o CheckBox do negrito, ele atribui o estilo negrito (BOLD) a
variável estilo, desmaca o CheckBox do normal, itálico e do negrito itálico, e exibir na
tela o rótulo texto com a fonte negrito.
Coloca a fonte em itálico

italico.addActionListener( new ActionListener(){
estilo=Font.ITALIC;
Quando você selecionar o CheckBox do itálico, ele atribui o estilo itálico (ITALIC) a
variável estilo, desmaca o CheckBox do normal, negrito e do negrito itálico, e exibir na
tela o rótulo texto com a fonte em itálico.
Coloca a fonte normal

normal.addActionListener( new ActionListener(){
estilo=Font.PLAIN;
Quando você selecionar o CheckBox do normal, ele atribui o estilo normal (PLAIN) a
variável estilo, desmaca o CheckBox do negrito, itálico e do negrito itálico, e exibir na
tela o rótulo texto com a fonte com estilo normal sem efeito.
Coloca a fonte em negrito e itálico

negritoitalico.addActionListener( new ActionListener(){
Quando você selecionar o CheckBox do negrito itálico, ele atribui o estilo negrito e
itálico (Font.BOLD+Font.ITALIC) a variável estilo, desmaca o CheckBox do negrito,
itálico e do normal, e exibir na tela o rótulo texto com a fonte com estilo negrito e
itálico.
A variável estilo é pública por isso quando você atribui valor nela, todos os métodos
que for utilizá-la exibirá no rótulo o estilo da variável estilo.
9º Passo: utiliza o método tela.add() para adicionar os métodos ao

aplicativo.
tela.add(rotulo1); tela.add(rotulo2); tela.add(rotulo3);
tela.add(texto);
tela.add(negrito); tela.add(italico);
tela.add(normal); tela.add(negritoitalico);
tela.add(tam1); tela.add(tam2);
tela.add(tam3);tela.add(tam4);
tela.add(lista);
16 – Como adicionar dica aos seus botões
O processo de adicionar dicas aos botões é sempre uma boa idéia

definir as dicas de ferramentas para que o usuário, ao posicionar o ponteiro do
mouse sobre o controle (Botão), possa ter mais informações sobre a
funcionalidade das ferramentas do aplicativo.
Veja na listagem abaixo:
import java.awt.*;
public class ExemploBotoesDicas extends JFrame{
JButton botao1,botao2;
public ExemploBotoesDicas(){
super("Exemplo de Botões com Dica");
botao1 = new JButton("Olá");
botao2 = new JButton("Sair");
botao1.setToolTipText("Botão usado para abrir algo");
botao2.setToolTipText("Botão que será usado para sair");
tela.add(botao1);
tela.add(botao2);
setSize(300,200);
setVisible(true);
}
ExemploBotoesDicas app = new ExemploBotoesDicas();
}
}
A dica de ferramenta para os botões foi definida nas linhas:

16.1 – Adicionar cores diferentes as dicas
Se você observou atentamente a dica de ferramenta do exemplo

anterior, deve ter percebido que o Java define o azul como cor de fundo e o
texto na cor preta. É possível acessar e manipular algumas das propriedades
das dicas de ferramenta de modo a adequá-las às cores propostas em seus
aplicativos. É uma técnica raramente usada, mas que surte efeitos bem
interessantes.
As dicas de ferramenta do Windows tem o amarelo como cor de fundo.

Veja como é possível atingir esse efeito em um aplicativo Java:
import java.awt.*;
public class ExemploBotoesDicas2 extends JFrame{
public ExemploBotoesDicas2(){
botao1 = new JButton("Olá");
UIManager.put("ToolTip.background",SystemColor.info);
tela.add(botao1);
tela.add(botao2);
setSize(300,200);
setVisible(true);
}
ExemploBotoesDicas2 app = new ExemploBotoesDicas2();
}
}
E para alterar a cor da letra da dica, basta você digitar:
UIManager.put("ToolTip.foreground",Color.blue);
17 – Tipos de diálogos fornecidos pela classe JOptionPane
Vamos usar constantemente a classe JOptionPane para exibir caixas de

mensagens mostrando resultados de operações. Nestes tópicos vamos estudar
os diferentes tipos de diálogos, assim como seus construtores mais
importantes.
Os diálogos de mensagens fornecidos pela classe JOptionPane são do tipo

modal, ou seja, quando o diálogo é exibido, tudo que estiver sendo executado
no aplicativo é suspenso até que a janela do diálogo seja fechada. Isso é
importante, uma vez que dependemos da resposta do usuário para continuar o
processamento normal do programa.
Os diálogos da classe JOptionPane podem ser exibidos com chamadas aos

seguintes métodos estáticos:
Método Uso
showConfirmDialog Usado para pedir confirmação, ou
seja, o usuário tem a opção de
responder “sim”, “não” ou “cancelar”.
showInputDialog Usado para obter entrada para o
programa.
showMessageDialog Usado para exibir mensagem sobre a
execução de alguma operação.
17.1 – Como entender os diálogos de confirmação
Diálogos de confirmação são usados para perguntar ao usuário se uma

determinada operação deve ser iniciada, continuada ou interrompida.
Aplicativos em Java geralmente usam esse tipo de diálogo para confirmar a
gravação de arquivos, fechamento de janelas, etc.
Exemplo:
JOptionPane.showConfirmDialog(null,”Fechar?”,”Fechar”,JOptionPane.YES_NO_OPTION);
Este método retorna um valor inteiro correspondente à opção escolhida pelo

usuário. Em diálogos de confirmação esse retorno pode ser um dos três
valores seguintes:
YES_OPTION – indica que o usuário escolheu a opção “Yes” ou “Sim”.
NO_OPTION – indica que o usuário escolheu a opção “No” ou “Não”.
CANCEL_OPTION – indica que o usuário escolheu a opção “Cancel” ou

“Cancelar”.
Os parâmetros para o método são:
JOptionPane.showConfirmDialog(parentComponent,”message”,”title”,optionType);
parentComponent – determina a janela na qual o diálogo será exibido.

Geralmente forncemos o valor null para esse parâmetro.
message – o texto a ser exibido no diálogo.
title – o texto para a barra de título do diálogo.
optionType – valor inteiro equivalente às opções disponíveis para o tipo de

diálogo, ou seja, YES_NO_OPTION, ou YES_NO_CANCEL_OPTION.
A listagem abaixo mostra como os diálogos de confirmação podem ser usados.

O Aplicativo pergunta se o usuário deseja realmente fechar a janela, caso você
clique no yes a janela será fecada, caso contrário o janela não será fechada.
import java.awt.*;
public class ExemploBotaoSair1 extends JFrame{
JButton botao;
public ExemploBotaoSair1(){
super("Exemplo de Botões com Diálogos de confirmação");
botao = new JButton("Sair");
botao.setToolTipText("Botão que finaliza a janela");
tela.add(botao);
public void actionPerformed(ActionEvent e) {
int opcao;
opção=JOptionPane.showConfirmDialog(null,
"Deseja mesmo fechar a janela?",
"Fechar",JOptionPane.YES_NO_OPTION);
if (opcao==JOptionPane.YES_OPTION)
System.exit(0);
}});
setSize(300,200);
setVisible(true);
}
ExemploBotaoSair1 app = new ExemploBotaoSair1();
}
}
Execute o aplicativo clique no botão sair e veja a mensagem do programa:
Se você clicar em Yes a janela será fechada e caso contrário ela continuará.
Passos para colocar o botão a janela e dicas de botões já foram vistos
anteriomente, e para chamar o caixa de confirmação basta você clicar no sair,
e o evento será executado, método para chamar o evento também já foi visto.
Veja o que tem de diferente:

int opcao;
opcao=JOptionPane.showConfirmDialog(null,"Deseja
mesmo fechar a janela?","Fechar",
JOptionPane.YES_NO_OPTION);
System.exit(0); }});
Foi declarada uma variável do tipo inteira com o nome de opção. Essa variável
vai receber a resposta do JOptionPane, e vai armazenar o valor que será
escolhido na caixa de confirmação. E o comando IF, que vai fazer a
comparação se o conteúdo da variável opção for igual
JOptionPane.YES_OPTION, ele retorna a verdadeiro e chama o método
System.exite(0) e finaliza a janela.
17.2 – Traduzir os botões de diálogos
Seria interessante exibir os textos dos botões em português? A classe

JOptionPane fornece um método chamado showOptionDialog que permite
personalizar o texto dos botões de diálogos. Não tem muita diferença entre o
showConfirmDialog e showOptionDialog.
Vejamos a listagem:
import java.awt.*;
public class ExemploTraduzir extends JFrame{
JButton botao;
public ExemploTraduzir(){
super("Exemplo de Botões Traduzidos");
tela.add(botao);
botao.addActionListener(new ActionListener(){
int opcao;
Object[] botoes = {"Sim","Não"};
opcao = JOptionPane.showOptionDialog(null,
"Deseja mesmo fechar a janela?",
"Fechar",JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,botoes,botoes[0]);
System.exit(0); }});
setSize(300,200);
setVisible(true);
setLocationRelativeTo(null);}
ExemploTraduzir app = new ExemploTraduzir();
O que foi modificado e o que há de diferente?

Os botões de diálogos traduzidos foram criados em português como itens de um vetor.
O vetor com essas duas opções, só apareceram dois botões, caso você queira o
cancelar basta adcionar a lista do vetor = {“Sim”,”Não”,”Cancelar”}. Object [ ] botoes =
{"Sim","Não"};
Em seguida a variável opcao que é do tipo inteira receberá o resultado da chamada ao
método showOptionDialog: Variável inteira: int opcao;
Vetor com os botões traduzidos: Object[] botoes = {"Sim","Não"};
Variável opção que esta recebendo o resultado do showOptionDialog:
opcao=JOptionPane.showOptionDialog(
null, – determina a janela na qual o diálogo será exibido. Geralmente forncemos o
valor null para esse parâmetro.
"Deseja mesmo fechar a janela?", – o texto a ser exibido no diálogo.
"Fechar", – o texto para a barra de título do diálogo.
JOptionPane.YES_NO_OPTION, - valor inteiro equivalente às opções disponíveis
para o tipo de diálogo, ou seja, YES_NO_OPTION, ou YES_NO_CANCEL_OPTION.
JOptionPane.QUESTION_MESSAGE, determina o tipo da mensagem a ser exibida,
exemplo pergunta, erro, informação, etc.
null, - ícone a ser exibido no diálogo, ícone personalizado.
botoes,botoes[0]); - Um vetor de objetos, geralmente do tipo string, representando as
possiveis escolhas, ou seja, os botões para o diálogo.
17.3 – Como obter dados por meio de diálogos do tipo prompt
Diálogos do tipo prompt são usados quando precisamos recebe entrada de

dados, geralmente fornecidos pelo usuário do aplicativo. A forma mais básica
de um diálogo do tipo prompt é obtida pelo método showInputDialog com a
seguinte sintaxe: showInputDialog(mensagem);
Quando o usuário digita o conteúdo solicitado e pressiona o botão OK, o
conteúdo da caixa é atribuído a variável nome. E o conteúdo dessa variável
será escrito dentro de um rótulo na janela. Se o botão cancel for acionado
acontecerá um erro no aplicativo. Como você pode perceber boa parte da caixa
de diálogo esta em inglês. Infelizmente não é possível traduzir esse diálogo
sem nos aventuramos em criar uma classe personalizada.
Veja a listagem:
import java.awt.*;
public class ExemploInputDialog extends JFrame{
JButton botao;
String nome;
JLabel rotulo;
public ExemploInputDialog(){
super("Exemplo de Input Dialog");
nome = JOptionPane.showInputDialog("Entre com seu nome: ");
rotulo.setText("O nome digitado foi: "+nome.toUpperCase());
tela.add(rotulo);
tela.add(botao);
int opcao;
opcao = JOptionPane.showOptionDialog(null,"Deseja
mesmo fechar a janela?","Fechar",
JOptionPane.YES_NO_OPTION,
null,botoes,botoes[0]);
System.exit(0);
}});
setSize(300,200);
setVisible(true);
}
ExemploInputDialog app = new ExemploInputDialog();
}
}
Caixa do InputDialog
Quando você clicar no Ok.

Veja o resultado, o nome vai aparecer todo em maiúsculo
17.4 – Como fornecer os valores a serem selecionados em um diálogo
O uso de diálogos prompt para obter entrada do usuário é muito conveniete,

mas há situações em que o usuário deve apenas selecionar um dos valores
fornecidos pelo aplicativo. Para essas situações você pode usar o seguinte
método da classe JOptionPane.
Veja a lista:
Import javax.swing.JOptionPane;
public class ExemploInputDialog1{
Object linguagens [] = {"Java","Delphi","C++","Visual Basic"};
Object opcao = JOptionPane.showInputDialog(null,"Qual sua
linguagem favorita?","Enquete",
null,linguagens,linguagens[0]);
JOptionPane.showMessageDialog(null,"Você escolheu: "+opcao);
System.exit(0);
}
}
17.5 – Entendimento e uso do método showMessageDialog.
Como o leitor já conhece todos os parâmetros, nos determinamos apenas no

parâmetro messaType. É aqui que definimos o tipo de mensagem que será
exibido. Os valores possíveis são: ERROR_MESSAGE,
INFORMATION_MESSAGE, WARNING_MESSAGE, QUESTION_MESSAGE,
PLAIN_MESSAGE. Cada um desses valores produz uma mensagem diferente,
como mostra o seguinte aplicativo:
import java.awt.*;
public class ExemploDeMessagens extends JFrame{
JButton erro, informacao, exclamacao, pergunta, nenhum;
public ExemploDeMessagens(){
super("Exemplo de mensagens");
erro = new JButton("Erro");
informacao = new JButton("Informação");
exclamacao = new JButton("Exclamação");
pergunta = new JButton("Pergunta");
nenhum = new JButton("Nenhum");
erro.setBounds(30,20,100,20);
informacao.setBounds(30,50,100,20);
exclamacao.setBounds(30,80,150,20);
pergunta.setBounds(30,110,100,20);
nenhum.setBounds(30,140,100,20);
tela.add(erro);
tela.add(informacao);
tela.add(exclamacao);
tela.add(pergunta);
tela.add(nenhum);
erro.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){

JOptionPane.showMessageDialog(null,"Você escolheu erro","Mensagem de
Erro",JOptionPane.ERROR_MESSAGE,null);}})
informacao.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

JOptionPane.showMessageDialog(null,"Você escolheu informação","Mensagem de
Informação",JOptionPane.INFORMATION_MESSAGE,null);}});
exclamacao.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

JOptionPane.showMessageDialog(null,"Você escolheu exclamação","Mensagem de
Exclamação",JOptionPane.WARNING_MESSAGE,null);}});
pergunta.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

JOptionPane.showMessageDialog(null,"Você escolheu pergunta","Mensagem de
Pergunta",JOptionPane.QUESTION_MESSAGE,null);}});
nenhum.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

JOptionPane.showMessageDialog(null,"Você escolheu
nenhum","Mensagem",JOptionPane.PLAIN_MESSAGE,null);}});
setSize(300,200);
setVisible(true);
}
ExemploDeMessagens app = new ExemploDeMessagens();
}
}
Tela inicial do aplicativo
Quando você clicar no botão a mensagem correspondente vai aparecer.
Veja um trecho de código que produz a segunda mensagem:
JOptionPane.showMessageDialog(null,"Você escolheu pergunta","Mensagem

de Pergunta",JOptionPane.QUESTION_MESSAGE,null);}});
18 – Maiúsculas e Minúsculas
Nada como você entrar com os dados em minúsculos e obter sua saída em
maiúsculos, ou vice versa. Para colocar a saída em maiúsculo utilize o método:
toUpperCase(). Observe o aplicativo abaixo:
import java.awt.*;
public class ExemploMaiusculas extends JFrame{
JButton copiar,limpar;
JLabel rotulo1,rotulo2;
public ExemploMaiusculas(){
super("Exemplo de saídas maiúsculas");
rotulo1 = new JLabel("Nome: ");
copiar = new JButton("Copiar");
copiar.setBounds(20,130,100,20);
copiar.addActionListener(new ActionListener(){
texto2.setText(texto1.getText().toUpperCase());}});
limpar.addActionListener(new ActionListener(){
texto1.setText("");
texto2.setText("");
texto1.requestFocus();}});
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(texto1);
tela.add(texto2);
tela.add(copiar);
tela.add(limpar);
setSize(300,200);
setVisible(true);
setLocationRelativeTo(null); }
ExemploMaiusculas app = new ExemploMaiusculas();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }}
import java.awt.*;
public class ExemploMinusculas extends JFrame{
public ExemploMinusculas(){
super("Exemplo de saídas minúsculas");
String texto;
texto = texto1.getText().toUpperCase();
texto1.setText(texto);
texto2.setText(texto1.getText().toLowerCase());}});
texto1.setText("");
texto2.setText("");
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(texto1);
tela.add(texto2);
tela.add(copiar);
tela.add(limpar);
setSize(300,200);
setVisible(true);
ExemploMinusculas app = new ExemploMinusculas();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);} }
Para colocar em minúsculos, basta você chamar o método toLowerCase(), se você

digitar a letra minúscula, quando você clicar em copiar, o texto da primeira caixa vai
ficar maiúsculas e a segunda fica minúsculas. E o botão limpar serve para limpar as
duas caixas e coloca o foco para a primeira caixa.
19 – Adicionando Data nos seus aplicativos
O aplicativo abaixo mostra dos tipos de data, somente com números e a outra
com o dia da semana e os meses escritos com o nome.
Vamos ver o aplicativo:
import java.awt.*;
import java.util.*;
public class Data extends JFrame{
int ds,dia,mes,ano;
Calendar data;
String diasemana[]={"Domingo","Segunda - Feira","Terça - Feira","Quarta - Feira",
"Quinta - Feira","Sexta - Feira","Sábado"};
String meses[]={"Janeiro","Fevereiro","Março","Abril","Maio","Junho",
"Julho","Agosto","Setembro","Outubro","Novembro","Dezembro"};
public Data(){
super("Exemplo de Data");
data = Calendar.getInstance();
ds = data.get(Calendar.DAY_OF_WEEK);
dia = data.get(Calendar.DAY_OF_MONTH);
mes = data.get(Calendar.MONTH);
ano = data.get(Calendar.YEAR);
rotulo.setText("Data: "+ds+" "+dia+"/"+(mes+1)+"/"+ano);
rotulo2.setText("Data: "+diasemana[ds-1]+", "+dia+" de "+meses[mes]+" de "+ano);
tela.add(rotulo);
tela.add(rotulo2);
setSize(300, 200);
setVisible(true);
setLocationRelativeTo(null); }
Data app = new Data();
20 – Adicionando Horas ao seu aplicativo
import java.awt.*;
import java.util.*;
import java.text.DecimalFormat;
import javax.swing.Timer;
public class Hora extends JFrame{
JLabel rotulo;
int hh,mm,ss,h;
Calendar hora;
DecimalFormat formato;
public Hora(){
super("Exemplo de Hora");
ActionListener tarefa = (new ActionListener(){
HORAS();
}
});
javax.swing.Timer time = new javax.swing.Timer(1000,tarefa);
time.start();
tela.add(rotulo);
setSize(300, 200);
setVisible(true);
}
Hora app = new Hora();
}
private void HORAS(){
hora = Calendar.getInstance();
hh = hora.get(Calendar.HOUR_OF_DAY);
mm = hora.get(Calendar.MINUTE);
ss = hora.get(Calendar.SECOND);
formato = new DecimalFormat("00");
rotulo.setText("Hora: "+formatar(hh%12)+":"+formatar(mm)+":"+formatar(ss));
}
private String formatar(int num){
return formato.format(num);
}
}
Vamos criar uma classe privada com o nome de HORAS vamos definir os
parâmetros para hora, minutos e segundos.
Depois criar um outra classe privada com o nome de formatar para que você
possa formatar a hora com dois dígitos, e coloca a hora no rótulo com uma
string.
Criar uma ação com o nome de tarefa, que vai chamar a classe privada
HORAS.
Por último chamar a biblioteca com o nome de Timer, e atribuir o tempo de um

segundo que é representado por mil. E chamar o método time.start(), para que
o relógio possa movimentar os segundos.
Aplicativo bem interessante execute veja como funciona.
A classe JTextField permite a criação de caixas de textos que aceitam a

entrada de apenas uma linha de texto. A classe JTextArea permite a entrada e
manipulação de múltiplas linhas de texto. Emobra a classe JTextArea forneça
uma série de métodos úteis para a manipulação de seu conteúdo, algumas
operações mais avançadas, tais como formatar e aplicar estilos diversos ao
texto de controle, são possíveis apenas com o uso da classes JTextPane e
JeditorPane. Esta apostila não aborda estas duas classes mas, você poderá
pesquisa-las na documentação Java.
A classe JTextArea fornece seis construtores. Dentre eles, o mais comumente

usado é aquele que cria uma área de texto em branco com um determinado
número de linhas e colunas. Veja a sintaxe para esse construtor:
JTextArea(int linhas, int colunas).
A listagem seguinte apresenta um aplicativo que contém um rótulo, uma área

de texto. Somente para o usuário visualizar como funciona o aplicativo:
import java.awt.*;
public class ExemploJTextArea extends JFrame{
JLabel rotulo;
JTextArea texto;
public ExemploJTextArea(){
super("Exemplo com JTextArea");
rotulo = new JLabel ("Endereço");
texto = new JTextArea(20,30);
tela.add(rotulo);
tela.add(texto);
setSize(400, 350);
setVisible(true);
}
ExemploJTextArea app = new ExemploJTextArea();
}
}
Este aplicativo apresenta poucas novidades. Começamos definindo uma

variável chamada texto que servirá para instanciarmos a área de texto:
JTextArea texto;
A área de texto é criada com a seguinte instrução:

Nosso controle vai exibir 20 linhas de texto e 30 colunas. É importante observar

que esses valores definem apenas o conteúdo que será visível no controle e
não a quantidade de texto que poderá ser inserida.
21.1 – Definição das barras de rolagem para os controles JTextArea
O aplicativo que digitamos no tópico anterior apresentou o uso da classe

JTextArea para construir áreas de texto que aceitem mais de uma linha de
conteúdo. O leitor deve ter percebido que, se a quantidade de texto exceder o
espaço reservado para o controle, parte de seu conteúdo não poderá ser
visualizado devido à ausência das barras de rolagens. A listagem seguinte é
uma pequena modificação do exemplo anterior que demostra como a classe
JScrollPane pode ser usada para adicionar barras de rolagem a objetos da
classe JTextArea:
import java.awt.*;
public class ExemploJTextArea3 extends JFrame{
JLabel rotulo;
JTextArea texto;
JScrollPane painelrolagem;
JPanel painel;
public ExemploJTextArea3(){
painelrolagem = new JScrollPane(texto);
painelrolagem.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
painelrolagem.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
painel = new JPanel();
painel.add(painelrolagem);
painel.setBounds(40,40,250,250);
tela.add(rotulo);
tela.add(painel);
setSize(300, 280);
setVisible(true);
}
ExemploJTextArea3 app = new ExemploJTextArea3();
}
}
Como este aplicativo é bem semelhante ao do tópico anterior, vamos nos

concentrar apenas nos trechos de códigos relevantes à adição das barras de
rolagem.
Definindo as variáveis: JLabel rotulo; JTextArea texto;

JScrollPane painelrolagem; JPanel painel;
A área de texto é criada com a seguinte linha: texto = new JTextArea(10,20);
Veja que criamos uma instância da classe JTextArea da forma usual. Em

seguida a linha: painelrolagem = new JScrollPane(texto);
Cria uma instância da classe JScrollPane fornecendo a referência texto como

argumento. É importante observar que, ao usar esse construtor, as dimesões
do painel de rolagem serão definidas de modo acomodar a área de texto criada
previamente.
Por padrão, as barras de rolagem definidas com o construtor anterior serão
exibidas somente quando o conteúdo da área de texto exceder sua capacidade
de exibição. Neste exemplo optamos por sempre mostrar as barras de rolagem.
Isso foi conseguido com as duas instruções seguintes:
painelrolagem.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROL
LBAR_ALWAYS);
painelrolagem.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_S
CROLLBAR_ALWAYS);
O aparecimento ou não das barras de rolagem vertical e horizontal é controlado

pelos métodos setVerticalScrollBarPolicy e setHorizontalScrollBarPolicy.
Esses dois métodos aceitam os valores de constantes na classe JScrollPane.
Para que seus aplicativos sigam os padrões predefinidos, use as constantes
que exibirão as barras de rolagem somente quando forem necessárias.
Neste aplicativo fizemos uso da classe JPanel para inclui as barras de

rolagem. Com isso temos mais controle sobre a disposição dos componentes
que estamos usando. Ela se destaca apenas um truque que usamos para
definir o espaçamento de todos os controles corretamente.
Para finalizar a análise, é adicionado no painel as barras de rolagem

(painelderolagem), pois as barras de rolagem quando estavam sendo
instanciadas pelo JScrollPane, recebeu o a área de texto (texto).
posiciona o painel na janela: painel.setBounds(40,40,250,250);
Adiciona o painel na janela: tela.add(painel);
A tabela seguinte relaciona essas constantes e descreve seus uso:
Constante Uso
HORIZONTAL_SCROLL_AS_NEEDED Exibe a barra de rolagem horizontal
somente quando for necessário.
HORIZONTAL_SCROLL_NEVER A barra de rolagem horizontal nunca é
exibida.
HORIZONTAL_SCROLL_ALWAYS Define que a barra de rolagem horizontal
deve ser exibida sempre.
VERTICAL_SCROLL_AS_NEEDED Exibe a barra de rolagem vertical
somente quando for necessário.
VERTICAL _SCROLL_NEVER A barra de rolagem vertical nunca é
exibida.
VERTICAL_SCROLL_ALWAYS Define que a barra de rolagem vertical
deve ser exibida sempre.
21.2 – Controlando a quebra automática de linhas
Por padrão, controles criados como instância da classe JTextArea não

oferecem a funcionalidade de quebra automática de linhas. Isso é incoveniente
em algumas situações em que o usuário digita longos trechos de texto no
componente. Imagine algo em torno de 50 a 100 palavras sendo exibidas em
apenas uma linha. Nada elegante. É possível forçar a quebra de linha
automática nos objetos JTextArea com uma chamada ao método
setLineWrap. Este método aceita os argumentos true ou false. Você tem que
usar juntamente com o setLineWrap o método setWrapStyleWord para que
haja a quebra de linha acontença entre palavras, se a próxima palavra não
couber na linha atual, deve ser deslocada para a próxima linha. Este método
aceita os argumentos true ou false.
Veja a sintaxe:
texto.setLineWrap(true);
texto.setWrapStyleWord(true);
Aplicativo disponível com o nome de ExemploJTextArea2.java
21.3 – Cor da fonte, Cor de fundo
Nada como alterar a cor da fonte do JTextArea, argumento igual ao JTextField
texto.setBackground(Color.yellow);
21.4 – Tipo, estilo e tamanho de fonte
Nada como alterar a cor de fundo do JTextArea, argumento igual ao JTextField:
texto.setFont(new Font("Comic Sans MS",Font.BOLD+Font.ITALIC,20));
Exemplo disponível com o nome de ExemploJTextArea4.java
22 – Adicionando menus a um aplicativo Java
Menus são uma parte integrante de qualquer aplicativo de interface

gráfica. Seu uso ajuda a agrupar o acesso as funcionalidades do programa em
lugares já conhecidos pelo usuário e evita a poluição desnecessárias de
componentes na tela do aplicativo.
Menus são criados como objetos das classes JMenurBar, JMenu,
JMenuitem, JCheckBoxMenuItem e JRadioButtonMenuItem. Todas essas
classes têm sua relevância e uma aplicação de cada um será apresentada em
seguida. Por ora, saiba que o menu pode ser adicionados apenas aos objetos
de classes que fornecem o método JMenuBar. A classe JMenuBar serve para
criar a barra de menus. Já o JMenu adiciona os itens do menu.Já os itens dos
menus são colocados com JMenuItem.
O Aplicativo seguinte apresenta uma barra de menus, que contém o
menu opções, com os itens limpar, fonte e sair:
import java.awt.*;
public class ExemploDeMenu extends JFrame{
JMenuBar barra;
JMenu opcoes;
JMenuItem limpar,fonte,sair;
public ExemploDeMenu(){
super("Exemplo de Menus");
barra = new JMenuBar();
setJMenuBar(barra);
opcoes = new JMenu("Opções");
barra.add(opcoes);
limpar = new JMenuItem("Limpar");
fonte = new JMenuItem("Fonte");
sair = new JMenuItem("Sair");
limpar.setMnemonic(KeyEvent.VK_L);
fonte.setMnemonic(KeyEvent.VK_F);
sair.setMnemonic(KeyEvent.VK_S);
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.addSeparator();
opcoes.add(sair);
setSize(500,300);
setVisible(true);
}
ExemploDeMenu app = new ExemploDeMenu();
}
}
Vamos analisar as partes mais importantes deste código:
Declarar na área pública a variável que vai receber a barra de menu:

JMenuBar barra;
Criar a barra de menus: barra = new JMenuBar();
Anexam a barra de menus à janela com uma chamada ao método

setJMenuBar da classe JFrame (janela): setJMenuBar(barra);
Uma janela pode ter apenas uma barra de menus, disposta horizontalmente na
parte superior da janela.
O menu Opções é criado com a seguinte instrução:

Depois é anexado a barra de menus: barra.add(opcoes);
Observe o o uso do método setMnemonic para definir as teclas de atalho para

o menu e todos os itens do menu.
Agora é a hora de criar os itens do menu opções:

Lembrando de declarar as variáveis que irão receber os itens do menu como

JMenuItem: JMenuItem limpar,fonte,sair;
Agora vamos anexar os itens no menu opções:

opcoes.add(limpar);
opcoes.add(fonte);
opcoes.addSeparator(); Adiciona um linha separadora no menu
opcoes.add(sair);
Exemplo do aplicativo acima sendo execurado
22.1 – Como adicionar submenus a um item do menu
Sbmenus podem ser adicionados a um determinado item de menu para tornar

o agrupamento lógico ainda mais eficiente. Essa técnica consiste em adicionar
um JMenu a outro JMenu. Veja um exemplo de como isso pode ser feito:
import java.awt.*;
public class ExemploDeMenu2 extends JFrame{
JMenuBar barra;
JMenu opcoes,fonte,cor;
JMenuItem limpar,sair,estilo,tamanho,azul,verde,vermelho,amarelo,preto;
public ExemploDeMenu2(){
super("Exemplo de Menus com submenus");
setJMenuBar(barra);
barra.add(opcoes);
fonte = new JMenu("Fonte");
cor = new JMenu("Cor");
azul = new JMenuItem("Azul");
verde = new JMenuItem("Verde");
vermelho = new JMenuItem("Vermelho");
amarelo = new JMenuItem("Amarelo");
preto = new JMenuItem("Preto");
estilo = new JMenuItem("Estilo");
tamanho = new JMenuItem("Tamanho");
cor.setMnemonic(KeyEvent.VK_C);
estilo.setMnemonic(KeyEvent.VK_E);
tamanho.setMnemonic(KeyEvent.VK_T);
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
setSize(500,300);
setVisible(true);
}
ExemploDeMenu2 app = new ExemploDeMenu2();
}}
Vamos analisar o aplicativo:
As variáveis que no aplicativo anterior foram declaradas como JMenuItem,

para que possam ser anexado a submenus elas terão que mudar de classe e
passar a ser da classe JMenu. Veja:
Observe como o item Fonte do menu
Opções tem uma seta para a direita,
indicando que tem nesse item três
submenus, Cor, Estilo e Tamanho. O
item Cor também possui uma seta
para direita, indicando que nesse item
possui, cinco subitens.
Agora vamos criar o item fonte e cor como JMenu, e os itens azul, verde,
vermelho, amarelo e preto serão criados como JMenuItem, vai indicar que o
JMenuItem é um item do JMenu do item Cor.
Agora vamos anexar os itens cor, estilo e tamanho no item fonte:

fonte.add(cor); fonte.add(estilo); fonte.add(tamanho);
E finalmente anexar as cores dentro do item cor:

cor.add(azul); cor.add(verde); cor.add(vermelho);
cor.add(amarelo); cor.add(preto);
22.2 – Como usar caixa de seleção como itens do menu JCheckBoxMenuItem
Neste tópico vamos mostrar a técnica que usa as caixas de seleção nos itens
do menu. A vantagem de usar caixas de seleção como itens de menu é que
você pode marcar e desmarcar itens sem a exigência de que no mínimo um
dos itens esteja selecionado.
Caixas de seleção como itens do menu são criadas como instâncias da classe
JCheckBoxMenuItem. As propriedades, métodos e eventos dessa classe são
semelhantes aos da classe JCheckBox, de modo que você não terá nenhuma
dificuldade em usá-la em seus aplicativos.
A listagem seguinte mostra como podemos criar as caixas de seleção, onde
todas podem ser selecionadas:
import java.awt.*;
JMenuBar barra;
JMenu opcoes,fonte,estilo,cor;
JMenuItem limpar,sair,tamanho,azul,verde,vermelho,amarelo,preto;
JCheckBoxMenuItem normal, negrito, italico, negritoitalico;
super("Exemplo de Menus com JChekBoxMenuItem");
setJMenuBar(barra);
barra.add(opcoes);
estilo = new JMenu("Estilo");
normal = new JCheckBoxMenuItem("Normal");
negrito = new JCheckBoxMenuItem("Negrito");
italico = new JCheckBoxMenuItem("Itálico");
negritoitalico = new JCheckBoxMenuItem("Negrito e Itálico");
opcoes.setMnemonic(KeyEvent.VK_O);
normal.setMnemonic(KeyEvent.VK_M);
negrito.setMnemonic(KeyEvent.VK_N);
italico.setMnemonic(KeyEvent.VK_I);
negritoitalico.setMnemonic(KeyEvent.VK_C);
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
estilo.add(normal);
estilo.add(negrito);
estilo.add(italico);
estilo.add(negritoitalico);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
setSize(500,300);
setVisible(true);
}
}
}
Declarar as variáveis que vão receber as caixas de seleção:
Anexar os estilos as caixas de seleção:

Definir as teclas de atalho:

Anexar os estilos ao item estilo do menu fontes:

estilo.add(normal);
22.3 – Usando botões de seleção como item do menu JRadioButtonMenuItem
Botões de seleção pode ser adicionados a um menu como instância da classe

JRadioButtonMenuItem. Usamos tais controles quando queremos que
apenas um item entre dois ou mais itens possam ser selecionados. Um bom
exemplo é quando queremos fornecer um menu que permite escolhe o
tamanho da fonte que será aplicada a um determinado componente.
O aplicativo seguinte contém o Menu Opções, com o item Fonte e o submenu
Tamanho, onde você pode escolher o tamanho desejado para sua fonte.
Lembrando que somente um tamanho pode ser escolhido, e a mesma coisa foi
definida para as caixas de seleção (JRadioButtonMenuItem), somente um
estilo poderá ser definido:
import java.awt.*;
JMenuBar barra;
JMenu opcoes,fonte,cor,estilo,tamanho;
JMenuItem limpar,sair,azul,verde,vermelho,amarelo,preto;
JCheckBoxMenuItem nomeE[];
ButtonGroup grupoT,grupoE;
JRadioButtonMenuItem tamanhoF[];
String tam[] = {"12","14","16","18"};
String est[] = {"Normal", "Negrito", "Itálico", "Negrito e Itálico"};
super("Exemplo de Menus com JRadioButtonMenuItem");
setJMenuBar(barra);
barra.add(opcoes);
grupoE = new ButtonGroup();
nomeE = new JCheckBoxMenuItem[4];
for(int i = 0; i < 4; i++){
nomeE[i] = new JCheckBoxMenuItem(est[i]);
estilo.add(nomeE[i]);
grupoE.add(nomeE[i]);
}
tamanho = new JMenu("Tamanho");
grupoT = new ButtonGroup();
tamanhoF = new JRadioButtonMenuItem[4];
for(int i = 0; i < 4; i++){
tamanhoF[i] = new JRadioButtonMenuItem(tam[i]);
tamanho.add(tamanhoF[i]);
grupoT.add(tamanhoF[i]);
}
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
setSize(500,300);
setVisible(true);
}
}
}
Neste aplicativo existem algumas coisas diferentes, os itens do menu estilo

desse aplicativo foi alterado, e tem algumas modificações do anterior veja:
1º Passo:
Para este exemplo vamos usar dois vetores, veja as declarações:
Um vetor é para a caixa de seleção (JCheckBoxMenuItem), que recebe o

nome de nomeE, e a letra E é para representar estilo.
Esse vetor serve para definirmos os itens do submenu Cor.
O outro vetor é para o botão de seleção (JRadioButtonMenuItem ), que

recebe o nome de nomeF, e letra F é para representar fonte.
Esse vetor serve para definirmos os itens do submenu Estilo.
2º Passo:
Agora declaramos duas instânciasda classe ButtonGroup:
Atribuimos os nomes grupoT, pertece ao tamanho da fonte, e o grupoE, que

pertence ao estilo da fonte.
Esse ButtonGroup agrupa as opções dos onde você só poderá escolher um

item de cada submenu.
3º Passo:
Criamos dois vetores do tipo String que servirão para definimos os valores dos
itens do menu.
String tam[] = {"12","14","16","18"};

O primeiro para tamanho da fonte e o segundo para o estilo.
4º Passo:
Criar os submenus:
O submenu tamanho é criado com a seguinte instrução:

O submenu estilo é criado com a seguinte instrução:

5ª Passo:
Em seguinda inicializamos as referências dos grupos:

6ª Passo:
Atribuir a quantidade de itens a caixa de seleção:

Atribuir a quantidade de itens ao botão de seleção:

7º Passo:
Para instanciar os itens do menu Cor, usamos o seguinte laço for:
for(int i = 0; i < 4; i++){

}
Esse laço é executado uma vez para cada um dos valores contidos no vetor
est que no nosso caso são quatro estilo (normal, negrito, itálico, negrito e
itálico). A cada interação atribuímos ao item de menu atual um dos valores do
vetor est, adicionamos o item ao menu Estilo e também ao grupo de botões
grupoE. Lembrando que o primeiro índice do vetor é 0, o segundo é 1, o
terceiro é 2 e o quarto é 3, por isso usamos no for i < 4, quando for satisfeita a
condição o for é encerrado e o menu recebe os estilos.
for(int i = 0; i < 4; i++){

}
Esse laço é executado uma vez para cada um dos valores contidos no vetor
tam que no nosso caso são quatro estilo (12, 14, 16, 18). A cada interação
atribuímos ao item de menu atual um dos valores do vetor tam, adicionamos o
item ao menu Tamanho e também ao grupo de botões grupoT. Lembrando
que o primeiro índice do vetor é 0, o segundo é 1, o terceiro é 2 e o quarto é 3,
por isso usamos no for i < 4, quando for satisfeita a condição o for é encerrado
e o menu recebe os tamanhos.
OBS: Quando usamos vetores para criar itens de menus não podemos
adicionar teclas de atalho.
22.4 – Menu executando ações
Quando um determinado item é selecionado, o código do aplicativo deve

detectar a seleção e efetuar as ações determinadas. Esse procedimento é fácil.
Uma vez que a classe JMenuItem herda abstração de botões e fornece o
método addActionListener.
No aplicativos adicionamos ao exemplo um componente JTextArea, para usar
as opções dos menus Limpar, Cor, Estilo e Tamanho. Use o menu Limpar para
apagar todo o conteúdo do JTextArea. Use a caixa de seleção para definir os
estilos da fonte do JTextArea. Os estilos possíveis são: normal, negrito, itálico,
negrito e itálico. E utilize o botão de seleção para obter o tamanho da fonte do
JTextArea. Os tamanhos possíveis são: 12, 14, 16 e 18.
import java.awt.*;
JMenuBar barra;
String tam[] = {"12","14","16","18"};
JTextArea texto;
JPanel painel;
JScrollPane rolagem;
int estilofonte, tamfonte;
super("Exemplo de Menus executando ações");
estilofonte=Font.PLAIN;
tamfonte=12;
setJMenuBar(barra);
barra.add(opcoes);
TratadorE tratestilo = new TratadorE();
for(int i = 0; i < 4; i++){
nomeE[i].addItemListener(tratestilo); }
TratadorT trattamanho = new TratadorT();

for(int i = 0; i < 4; i++){
tamanhoF[i].addItemListener(trattamanho); }
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
rolagem = new JScrollPane(texto);
rolagem.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_
SCROLLBAR_ALWAYS);
rolagem.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_
SCROLLBAR_ALWAYS);
painel.add(rolagem);
tela.add(painel);
texto.setText("");
texto.requestFocus();}});
azul.addActionListener(new ActionListener(){
repaint();}});
verde.addActionListener(new ActionListener(){
repaint();}});
vermelho.addActionListener(new ActionListener(){
repaint();}});
amarelo.addActionListener(new ActionListener(){
repaint();}});
preto.addActionListener(new ActionListener(){
A l e k s a n d r a R . C a r d o z o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P á g i n a 1 0 0
repaint();}});
sair.addActionListener(new ActionListener(){
int resposta;
resposta=JOptionPane.showConfirmDialog(null,"Deseja realmente
sair?","Mensagem do Programa",JOptionPane.YES_NO_OPTION);
if (resposta==6)
System.exit(0);}});
setSize(500,300);
setVisible(true); }
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }
private class TratadorE implements ItemListener{
public void itemStateChanged(ItemEvent e){
if(nomeE[0].isSelected())
estilofonte= Font.PLAIN;
estilofonte= Font.BOLD;
estilofonte= Font.ITALIC;
estilofonte= Font.BOLD+Font.ITALIC;
texto.setFont(new Font("", estilofonte, tamfonte));
repaint(); } }
private class TratadorT implements ItemListener{
if(tamanhoF[0].isSelected())
tamfonte= 12;
tamfonte= 14;
tamfonte= 16;
tamfonte= 18;
repaint(); } }
}
Menu Limpar:
texto.setText("");
Quando este item for executado, o componente JTextArea será limpo e

receberá o foco.
Menu Sair:
int resposta;
if (resposta==6)
System.exit(0);}});
Quando este item de menu for selecionado, uma mensagem perguntando se o

usuário deseja fechar o aplicativo será exibida, caso o usuário escolha sim o
aplicativo será fechado. É claro que aqui usamos uma classe anônima. Onde
declaramos uma variável inteira chamada resposta, e atribuímos ela ao
JOptionPane que vai exibir uma mensagem na tela, quando o usuário escolher
a opção, a variável resposta recebe esse valor, e depois é executado o laço IF,
se o conteúdo da variável resposta for igual a 6 então o IF, chama o método
System.exit(0), e finaliza o aplicativo.
Menu Fonte -> Estilo:
Agora vamos usar uma classe privada que implementa a interface

ActionListener e tratar todos os itens de menu Estilo e Tamanho de uma só
vez.

repaint(); } }
Menu Fonte -> Tamanho

tamfonte= 12;
tamfonte= 14;
tamfonte= 16;
tamfonte= 18;
repaint(); } }
Menu Fonte -> Cor -> Amarelo
Quando o item correspondente a cor for selecionado e executado o

componente JTextArea, receberá a cor escolhida
repaint();}});
repaint();}});
Declarar a variável que vai receber o conteúdo da classe privada:
Variavel trattamanho recebe a referência da classe privada TratadorT.

Variavel tratestilo recebe a referência da classe privada TratadorE.

Chama a variável que esta fazendo referência a classe privada que vai
executar a ação do menu:
tamanhoF[i].addItemListener(trattamanho);
nomeE[i].addItemListener(tratestilo); }
OBS: O método repaint(), sempre é chamando nas classes, ele serve para
atualizar o estilo, fonte ou a cor escolhida.
23 – Criando um menu de contexto – Classe JPopupMenu
Menus de contexto ou menu popup têm a mesma funcionalidade dos menus

convecionais. A única diferença é que menus de contexto são exibidos quando
clicamos com o botão direito no componente para o qual o menu foi definido.
Para ver um exemplo de menu com contexto, abra seu editor de texto favorito e
clique com o botão direito sobre a área de edição de texto. As chances de um
menu de contexto ser exibido são enormes. Em Java menus de contexto são
criados como objetos da classe JPopupMenu. Os itens do menu são criados a
partir da classe JMenuItem, de modo que você pode usar todas as técnicas
que vimos nos tópicos anteriores.
O aplicativo seguinte cria um menu de contexto para uma área de texto e
oferece as opções de recortar, copiar e colar. Veja a listagem para o exemplo:
mport javax.swing.*;
import java.awt.*;
public class ExemploDePopupMenu extends JFrame{
JPopupMenu opcoes;
JMenuItem recortar,copiar,colar;
JTextArea texto;
public ExemploDePopupMenu(){
super("Exemplo de PopupMenu");
texto.addMouseListener(new MouseAdapter(){
public void mouseReleased(MouseEvent e){
if(e.isPopupTrigger())
opcoes.show(e.getComponent(),e.getX(),e.getY()); }});
Tratador tratmenu = new Tratador();
opcoes = new JPopupMenu();
recortar = new JMenuItem("Recortar");
copiar = new JMenuItem("Copiar");
colar = new JMenuItem("Colar");
recortar.setMnemonic(KeyEvent.VK_R);
copiar.setMnemonic(KeyEvent.VK_C);
colar.setMnemonic(KeyEvent.VK_L);
recortar.addActionListener(tratmenu);
copiar.addActionListener(tratmenu);
colar.addActionListener(tratmenu);
opcoes.add(recortar);
opcoes.add(copiar);
opcoes.add(colar);
tela.add(texto);
setSize(320,340);
setVisible(true);
}
ExemploDePopupMenu app = new ExemploDePopupMenu();
}
private class Tratador implements ActionListener{
if(e.getSource()==recortar)
texto.cut();
if(e.getSource()==copiar)
texto.copy();
if(e.getSource()==colar)
texto.paste();
repaint(); }}
}
Quando você executar esse aplicativo, clique com o botão direito na área de
texto e o menu de contexto será exibido. Escolha um dos itens do menu e veja
o resultado obtido.
O menu de contexto usado para este exemplo é criado na linha:

Para exibi-lo, criamos uma classe anônima MouseAdapter e a fornecemos

como argumento para o método addMouseListener da área de texto:
public void mouseReleased(MouseEvent e) {
Quando clicamos com o botão direito na área de texto e o método

mouseReleased é disparado, efetuamos uma chamada ao método
isPopupTrigger da classe MouseEvent. Esse método retorna verdadeio se o
evento foi disparado com o botão direito do mouse. Satisfeita a condição, o
menu de contexto é exibido. Observe os parâmetros para o método show da
classe JPopupMenu:
show(Componet invoker, int x, int y);

O parâmetro invoker é o componente para o qual o menu de contexto esta

definido. Os parâmetros x e y são as coordenadas do mouse no momento em
que o menu de contexto é chamado.
24 – Uso da classe JToolBar para criar barra de ferramentas
Uma barra de ferramentas é um contêiner para agrupar botões e outros

controles usados com maior freqüência no aplicativo. Grande parte dos
aplicativos atuais apresenta barras de ferramentas, de modo que você deve
analisar e verificar a necessidade de implementar essa funcionalidade em seus
programas. Barras de ferramentas em aplicativos Java são criadas como
objetos da classe JToolBar. Essa classe oferece algumas funcionalidades bem
interessantes, entre elas a capacidade de ser arrastada pela janela do
aplicativo (e até fora deste). O aplicativo seguinte mostra como incluir uma
barra de ferramentas semelhantes às encontradas em muitos programas
atuais. No momento os botões não fornecem nenhuma funcionalidade, mas
você será capaz de arrastar a barra para qualquer um dos cantos da janela e,
para sua surpresa, arrastá-la para fora do aplicativo. Veja a listagem para o
exemplo:
import java.awt.*;
public class ExemploBarraDeFerramentas extends JFrame{
JToolBar barra;
JButton direita,esquerda,centralizar,recortar,copiar,colar;
ImageIcon imagens[];
public ExemploBarraDeFerramentas(){
super("Exemplo de Barra de Ferramentas");
String icones[]={"imagens/direita.gif","imagens/esquerda.gif",
"imagens/centro.gif","imagens/recortar.gif",
"imagens/copiar.gif","imagens/colar.gif"};
imagens = new ImageIcon[6];
for(int i = 0;i < 6;i++){
imagens[i] = new ImageIcon(icones[i]);}
direita = new JButton(imagens[0]);
esquerda = new JButton(imagens[1]);
centralizar = new JButton(imagens[2]);
recortar = new JButton(imagens[3]);
copiar = new JButton(imagens[4]);
colar = new JButton(imagens[5]);
direita.setToolTipText("Direita (Ctrl+d)");
esquerda.setToolTipText("Esquerda (Ctrl+e)");
centralizar.setToolTipText("Centralizar (Ctrl+z)");
recortar.setToolTipText("Recortar (Ctrl+x)");
copiar.setToolTipText("Copiar (Ctrl+c)");
colar.setToolTipText("Colar (Ctrl+v)");
barra = new JToolBar("Barra de Ferramentas");
barra.setRollover(true);
barra.add(direita);
barra.add(esquerda);
barra.add(centralizar);
barra.addSeparator();
barra.add(recortar);
barra.add(copiar);
barra.add(colar);
barra.setBounds(1,1,260,50);
tela.add(barra);
setSize(320,340);
setVisible(true); }
ExemploBarraDeFerramentas app = new ExemploBarraDeFerramentas();
}
}
Para que este exemplo ficasse bem realista, adicionamos uma barra de menus.
Experimente arrastar a barra de ferramentas.
Declarar o vetor que vai receber as imagens:

Para definir as imagens dos botões da barra de ferramentas, usamos o

seguinte vetor de objetos com seis posições da classe ImageIcon:
O nome e o caminho das imagens são definidos como itens do vetor ícones:
O próximo passo é instanciar os objetos da classe ImageIcon com as imagens

do vetor ícones. Isso é feito no laço seguinte:
for(int i = 0;i < 6;i++){
imagens[i] = new ImageIcon(icones[i]); }
São criados seis botões com imagens veja seguintes instruções:

Próximo passo adicionar dicas aos botões da barra de ferramentas:

A barra de ferramentas é criada na linha:

Trocar a cor de fundo da dica dos botões da barra de ferramentas:

Trocar a cor da letra da dica dos botões da barra de ferramentas:

Os botões são adicionados à barra de ferramentas pelo método add:

barra.add(direita);
barra.add(copiar);
barra.add(colar);
Aplicar o efeito Rollover aos botões da barra de ferramentas:

O efeito Rollover modifica algum aspecto do controle quando movemos o
ponteiro sobre ele. Geralmente esse efeito aplica cores e imagens diferentes.
Em barras de ferramentas a técnica mais comum é aplicar uma borda
diferenciada quando o ponteiro adentra ou sai da área do componente.
Java permite aplicar esse efeito a barras de ferramentas por meio de uma
chamada ao método setRollover da classe JToolBar. Veja como isso pode
ser feito:
Posicionar a barra de ferramentas na janela:

Adicionar a barra de ferramentas na janela:

tela.add(barra);
25 – Como criar janelas secundárias com o uso da classe JDialog
Janelas secundárias são modais ou não-modais que dependem da janela

principal do aplicativo. Por meio dessas janelas podemos efetuar novas
operações acessando até mesmo os componentes da janela principal. Janelas
secundárias são criadas como instâncias da classe JDialog, e fornece
praticamente todas as funcionalidades da classe JFrame. Isso quer dizer que
podemos obter o painel de conteúdo de um objeto dessa classe e incluir
componentes, interagir com o usuário, enviando dados para a janela principal.
25.1 – Como criar janelas secundárias modais
O aplicativo seguinte é o nosso ponto de partida para o estudo da classe

JDialog. Trata-se de uma janela principal com apenas um botão. Quando você
clicar no botão abrir, uma nova janela com apenas um botão é aberta. Veja:
import java.awt.*;
public class NovaJanela2 extends JFrame{
JButton abrir;
Inicial segundajanela;
public NovaJanela2(){
super("Abrir uma nova janela");
abrir = new JButton("Abrir");
abrir.setBounds(100,50,80,20);
abrir.addActionListener(new ActionListener(){
segundajanela = new Inicial(null,"Segunda Janela",true);
segundajanela.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
segundajanela.setVisible(true); }});
tela.add(abrir);
setSize(300, 150);
setVisible(true);
NovaJanela2 app = new NovaJanela2();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}
private class Inicial extends JDialog{
JButton sair;
public Inicial(Frame owner, String title,boolean modal){
super(owner,title,modal);
Container tela1 = getContentPane();
tela1.setLayout(null);
sair = new JButton("Sair");
sair.setBounds(50,50,100,20);
TBsair tsair = new TBsair();
sair.addActionListener(tsair);
tela1.add(sair);
setSize(200,200);
setLocationRelativeTo(null);} }
private class TBsair implements ActionListener{
public void actionPerformed(ActionEvent evento){
int status = JOptionPane.showConfirmDialog(null,"Deseja realmente fechar o
programa?","Mensagem de saída",JOptionPane.YES_NO_OPTION);
if (status == JOptionPane.YES_OPTION)
{segundajanela.setVisible(false);
segundajanela.dispose();}}
}
}
Primeira janela Segunda Janela
Janela Modal – Você não pode clicar na janela de traz:
Após a execução do aplicativo, clique no botão Abrir. Você visualizará a

segunda janela com o botão de Sair. O entendimento do código é muito
importante para o uso correto de janelas secundárias em um aplicativo Java. É
Importante acompanhar atentamente a análise que faremos.
A classe privada Inicial:

JButton sair;
tela1.add(sair);
setSize(200,200);
}
}
Declaramos a variável que vai fazer referência ao botão sair: JButton sair;
Declaramos a referência segundajanela que receberá a Incial:

Classe privada Incial: Esta classe herda JDialog. Observe os parâmetros para
seu construtor: public Inicial(Frame owner, String Title, boolean modal);
O parâmetro owner é usado para especificar a janela principal a partir da qual

a janela secundária será chamada. O parâmetro title serve para fornece o título
para janela, modal especifica se a janela será modal ou não-modal. Uma
janela modal tem o foco e deve ser fechada antes que o usuário volte à janela
principal do aplicativo.
Na linha linha do construtor temos uma chamada ao construtor da superclasse

JDialog: super(owner,title,modal);
O que fazemos aqui é transferir os valores recebidos para a superclasse.
Chamamos os métodos para adicionar componentes na janela:

Em seguinda, adicionamos o texto a ser exibido no botão Sair, logo após

posicionamos o botão na janela, criamos a variável que vai fazer referência a
classe privada TBsair, depois adicionamos essa classe ao botão sair pelo
evento addActionListener, e chamamos o método add, e adicionamos o botão
na janela secundária.
tela1.add(sair);
Em seguida definimos o tamanho da janela secundária:

setSize(200,200);
Por final centralizamos a janela:

Voltando à janela principal agora, para chamar a janela secundária, usamos o

seguinte trecho de código:
segundajanela.setVisible(true);
}
}
);
Quando clicamos no botão e o método actionPerformed da classe anônima

ActionListener é chamado, instanciamos um objeto da janela secundária e o
atribuímos à referência segundajanela. Em seguida definimos o modo como a
janela vai se comportar quando tentamos fecha-la:
Ac constate DISPOSE_ON_CLOSE esconde a janela e em seguida a libera da

memória. Este é o comportamente mais adequado para janelas modais.
A úttima linha: segundajanela.setVisible(true);
Exibe a janela colocando-a na frente da janela principal. Caso queira, revise o

tópico para posicionar a janela secundária no centro da tela quando ela for
exibida.
Classe privada TBsair (Tratar Botão Sair)

int status = JOptionPane.showConfirmDialog(null,"Deseja realmente
fechar o programa?","Mensagem de
saída",JOptionPane.YES_NO_OPTION);
segundajanela.dispose();
}
}
}
Sem muita modificações dos exemplos anteriores, o que tem de diferente é que
quando você clicar em Sim para finalizar a janela secundária, o aplicativo
coloca a janela invisível com o método setVisible(false); e depois retira da
memória com o método dispose().
25.2 – Como criar janelas secundárias não-modais
Janela não-modais são aquelas onde você, pode fazer uso da janela principal.
Exemplo do aplicativo de janela não-modal, veja o exercício
NovaJanela4.java.
Modificações a serem observadas:
segundajanela = new Inicial(null,"Segunda Janela",false);
Para janela não-modais, o último parâmetro deve ser false.
Para janela modal, o último parâmetro deve ser true
25.3 – Como criar janelas secundárias com JFrame
Como a classe JDialog, também podemos criar uma janela com a classe
JFrame, quando você iniciar esse aplicativo, será executada a tela principal
com um botão chamado Abrir, quando você abrir a janela secundária com o
botão Sair, a janela principal fica invisível com o método setVisible(false); e
depois é retirada da memória com o método dispose(), já na janela secundária
quando você clicar em sair uma mensagem será exibida, perguntando se você
quer fechar o aplicativo, caso você responda sim a janela é fechada.
import java.awt.*;
public class NovaJanela extends JFrame{
JButton abrir;
public NovaJanela(){
segundajanela = new Inicial();
setVisible(false);
dispose();}});
tela.add(abrir);
setSize(300, 150);
setVisible(true);
NovaJanela app = new NovaJanela();
private class Inicial extends JFrame{
JButton sair;
private Inicial(){
super("Menu Principal...");
tela.add(sair);
setSize(200,200);
} }
26 – Uso da Classe JWindow para criar uma Splash Screen
Uma Splash Screen ou tela de splash é uma tela, geralmente retangular e

contendo uma imagem e texto, que permanece no centro da tela do
computador enquanto o aplicativo é iniciado. Seu uso é bem vindo em
aplicativos que necessitam de tempo para reunir todos os recursos necessários
para à sua execução. Quando todos os recursos estão alocados, a tela de
Splash é fechada e a janela principal do aplicativo é exibida.
A escolha de um objeto da classe JWindow para implementar uma tela de
Splash é justificada pelo fato de que janelas criadas a partir dessa classe não
possuem a barra de títulos, os botões de sistema (fechar, minimizar, etc) e a
borda características das demais janelas.
import java.awt.*;
public class ExemploSplashScreen extends JFrame{
TelaInicial inicio;
JButton botaosair;
public ExemploSplashScreen(){
super("Exemplo de Splash Screen");
inicio = new TelaInicial();
inicio.setVisible(true);
System.exit(0); } } );
setSize(300, 150);
}
ExemploSplashScreen app = new ExemploSplashScreen();
public void principal(){
setVisible(true);}
private class TelaInicial extends JWindow{
public TelaInicial(){
tela.setLayout(new FlowLayout(FlowLayout.LEFT,1,1));
ImageIcon imagem = new ImageIcon("imagens/fundo.gif");
JLabel rotulo = new JLabel(imagem);
tela.add(rotulo);
ActionListener fechar = new ActionListener(){
setVisible(false);
dispose();
principal();}};
javax.swing.Timer timer = new javax.swing.Timer(5000,fechar);
timer.start();
pack();
} }
}
A tela de splash mostrada na figura é exibida por cinco segundos. Decorrido esse
período, ela será fechada e a janela principal do aplicativo será exibida. Vamos
analisar todo o código começando com a classe TelaInicial:
Esta classe estende JWindow, portanto não terá bordas, barra de títulos ou botões de
sistema: private class TelaInicial extends JWindow
Veja as cinco primeiras linhas de seu construtor:

tela.add(rotulo);
As primeiras duas linhas obtém uma referência ao painel de conteúdo da janela e
defininem o gerenciador de layout. As duas linhas seguintes carregam a imagem a ser
exibida e fornece o argumento para o construtor da classe JLabel. A imagem será
exibida como parte de um rótulo. A última linha adiciona o rótulo à janela.
Em seguida temos a instância da classe ActionListener.
setVisible(false);
dispose();
principal();}};
Quando o método actionPerformed dessa classe é chamado, nós ocultamos a tela de
splash, a liberamos da memória e efetuamos uma chamada ao método principal da
classe principal.
Para disparar o método actionListener, fazemos uso de um timer:
timer.start();
Este timer está ajustado para cinco segundos, mas você pode alterar este valor de
acordo com sua finalidade.
As duas últimas linhas da classe TelaInicial, redimensionam a janela de acordo com o
tamanho da imagem usada e posicionam a janela no centro da tela.
pack();
A tela do splash (TelaInicial) é chamada a partir da classe principal por meio das
seguintes instruções: inicio = new TelaInicial();
E, para finalizar, eis o método principal:
setVisible(true);}
O único proposito deste método é tornar a janela principal visível, uma vez que não
podemos acessa-la a partir da classe TelaInicial.
27 – Banco de Dados Relacionais
27.1 – O que é um Banco de Dados?
Um banco de dados típico é formado por uma ou mais Tabelas. As tabelas, por
sua vez, são formadas por COLUNAS e LINHAS. As COLUNAS, também
chamadas de CAMPOS, servem para dar nome ao espaço reservados a
determinada informação. Já as LINHAS de uma tabela, também chamadas de
REGISTROS ou TUPLAS. São espaços reservados para a informação a ser
armazenada.
No exemplo apresentado em seguida temos três CAMPOS, de nome ID,
NOME e TELEFONE. Os campos dão nome a cada coluna do Banco de Dado
se indicam qual informação será armazenada em cada coluna. Três LINHAS,
contendo informações de três pessoas. Note que, enquanto os campos são
únicos e não se repetem, as linhas são em quantidade quase infinita e podem
se repetir total ou parcialmente.
Nota: Neste caso em particular, as informações do campo ID são geradas pelo próprio
SGBD por meio da autonumeração; portanto, não são inseridas pelo usuários e
também não se repetem.
ID NOME TELEFONE
1 Tulio Maravilha 1234-5678
2 Otavio Mesquita 1234-6789
3 Luiz Pedro 1234-9658
► (AutoNumeração) |
O conjunto apresentado forma uma tabela de nome CADASTRO que, por sua vez,
forma o banco de dados AGENDA.
Um Banco de Dados típico é criado a partir das seguintes etapas:
1) Cria-se um banco de dados, dando um nome a ele. Esse nome vai ajudá-lo a
identificar o tipo de informação que ele contêm. Exemplo de nomes para Banco de
Dados: colecoes, vendas, cadastro, etc. Evitamos o uso de palavras acentuadas e
separadas por espaço, tendo em vista a maior compatibilidade possível. Se necessário
usar mais de uma palavra para nomear o banco de dados, separe-as pelo caractere
UNDERSCORE (sublinhado), como em seguida: Departamento_Pessoal.
2) e 3) Cria-se uma ou mais tabelas, definindo para cada uma delas o nome de cada
coluna e o tipo de dados que ela armazenará. Usando como exemplo, o banco de
dados Departamento_Pessoal, podemos criar as tabelas funcionarios, imposto,
ponto eletronico. Aqui também vale a regra de evitar acentuação na nomeação das
tabelas e seus campos, bem como separar palavras pelo caractere UNDERSCORE
(sublinhado).
4) Alimenta-se o banco de dados com os registros, seja por digitação ou outro

processo: mecânico, óptico, magnético, etc. São esses registros que formarão as
linhas da tabela. Os dados inseridos podem e devem usar acentuação e palavras com
espaço em branco entre si.
1 - Nome do 2 - Nome da 3 - Nome e tipo de 4 – Entrada de

Banco de Dados Tabela dados das COLUNAS Dados(digitação, etc)
27.2 – Banco de Dados Relacionais
Os Bancos de Dados atuais permitem que se criem relacionamentos entre as

tabelas, os quais eliminam campos redundantes, e como conseqüência
imediata, temos a redução do número de campos de cada tabela, redução no
tempo de entrada de dados e mais velocidade no processamento.
Banco de Dados VENDAS

Tabela Clientes Tabela Pedidos
Número do Cliente Número do Pedido

Nome do Cliente Número do Cliente
Endereço Descrição do Pedido
Telefone Total
Note que cada cliente pode fazer mais de um pedido, mais cada pedido só
pode estar relacionado a um cliente. O campo que está sendo usado para
relacionar uma tabela à outra é o Número do Cliente. Se este vínculo não
fosse criado, não haveria como saber qual cliente é determinado pedido, a não
ser que incluíssemos em cada pedido todos os dados do cliente. Com o uso
dos relacionamentos, este procedimento é desnecessário.
Os tipos de relacionamentos mais comuns são:
UM para MUITOS – Exemplo: um único cliente pode fazer vários pedidos, um

único vendedor pode emitir vários pedidos, um único professor pode lecionar
várias disciplinas.
UM para UM – Exemplo: um cliente e atendido por um único vendedor.
MUITOS para MUITOS – Exemplo: vários alunos podem ser matriculados em

vários cursos e os vários cursos podem ter matriculados vários alunos.
27.3 – BD x SGBD
Os softwares usados para criar e gerenciar (armazenar e manupilar) os dados

de uma empresa são conhecidos por SGBD – SISTEMA GERENCIADOR DE
BANCO DE DADOS. O SGBD adotado por nós é o ACCESS, que faz parte do
pacote comercial OFFICE da empresa MICROSOFT. Embora os exemplos
desta apostila utilizarem a versão 2000, versões anteriores e recentes também
poderão ser usadas sem problemas, observam as pequenas diferenças nas
telas que ilustram os tópicos. A apostila não faz o estudo específico sobre o MS
ACCESS, vamos apenas nos limitar a abordar apenas a parte que nos
interessa, que é a criação do Banco de Dados. Seu gerenciamento será feito
em Java e SQL.
27. 4 – Índices
Um índice não é uma característica do Modelo Relacional, mas sim uma

estratégia de otimização de consulta para implementações desse modelo. Isso
acontece porque o Modelo Relacional é um modelo teórico, porém quando
transformado em uma implementação as suas operações (tanto da álgebra
quanto do cálculo) exigem um tempo de busca. Se os dados estiverem
ordenados de uma forma ideal, esse tempo de busca pode ser bastante
reduzido.
Os índices funcionam então como catálogos organizados de forma a beneficiar
certo tipo de consulta. É possível imaginar que uma tabela seria associada a
quantidade máxima de índices, porém isso traria muitos gasto de inserção e
alteração. Por isso, em uma implantação de um banco de dados, são
escolhidos os indíces mais adequados. Normalmente a chave primária é um
índice.
O limitador é imposto exclusivamente pela ferramenta de software utilizada.
Sendo assim, para a recuperação dos dados é necessário a existência de
mecanismos que facilitem a consulta, proporcionando uma perfomance
aceitável para a mesma. Para isso, os sistemas de bancos de dados
relacionais criam índices das tabelas, sendo que esses índices são atualizados
constantemente.
Caso o índice se corrompa por algum motivo, é possível que pesquisas
possam retornar resultados não desejados ou que inserções de chaves
duplicadas aconteçam. Nesse caso o banco de dados será corrompido
também. Os sistemas de bancos (bases) de dados possuem mecanismos de
evitar que esses eventos ocorram como também possibilitam a recuperação
dos índices e consistência da tabela caso eles ocorram.
Tipos de Índices
De acordo com as necessidades de busca, os tipos de índices ideais variam.

Alguns bancos implementam um tipo, outros vários.
Um indice em árvore (e existem vários tipos de árvore) ordena os dados e

permite buscas razoavelmente rápidas para elementos específicos e busca
bastante rápidas para intervalos. O índice em árvore é geralmente baseado na
idéia da Árvore Binária, porém adaptada para atender as características de
usar Memória de . O tipo mais comum é a Árvore B.
Um índice em hash organiza os dados codificando-os e mapeando-os em

posições de array. São uma forma extremamente rápida de encontrar
elementos específicos, mas praticamente inúteis para responder um intervalo
de valores.
Um índice binário é indicado quando o campo indexado tem um pequeno

número de valores que indicam a categoria da tupla, por exemplo o campo
sexo (M,F), que é constantemente usada em consultas. Nesse caso, é criada
uma lista dos elementos de cada tipo.
Outros tipos de índices são: R-Tree, GiST, etc.
27.5 – Criando Banco de Dados
Antes de criar o Banco de Dados, crie uma pasta no raiz C:\, chamada Agenda.
Execute o MS Access, marque a opção BANCO DE DADOS VAZIO DO

ACCESS e clique em OK (Figura1)
Figura1
No campo Salvar Em, localize a pasta C:\Agenda. Em Nome do Arquivo, digite

Agenda e clique no botão Criar (Figura2).
Figura2
Com este procedimento o banco de dados Agenda.mdb, precisa de ao menos
uma tabela para pode armazenar informações. A tabela pode ser criada com
ACCESS, Java e SQL. Não feche o MS ACCESS.
27.6 – Criando Tabelas no MS ACCESS
Apesar de poder criar e gerenciar tabelas exclusivamente com Java e SQL, é

importante você conhecer o processo de criação de tabelas no MS ACCESS.
Confira se na coluna Objetos a opção Tabela está selecionada.
Selecione a opção Criar Tabela No Modo de Estrutura.
Depois de todos os passos anterior ser executado, Clique no botão Novo.
Selecione a opção Modo de Estrutura.
Na tela seguinte crie os campos para a tabela.
Depois de digitar estas informações, crie a Chave Primária, clique no campo

Nome,
depois clique no ícone da Chave Primária,
depois de clicar na chave primária o campo nome receberá a
chave,
Após terminar os passos anterior, salve no Menu Arquivo, Salvar ou clique no

ícone do Disquete, e coloque o nome da tabela de Cadastro e clique em OK.
Agora a tabela Cadastro está criada e pronta para receber dados, seja pelo ACCESS,
Java ou SQL.
28 – O que SQL?
SQL – Structured Query Language / Linguagem de Consulta Estruturada é

exatamente isto: uma linguagem. E como toda linguagem, se presta à
comunicação SQL é uma linguagem de consulta, usada para estabelecer
comunicação com banco de dados, dos mais simples aos mais sofisticados.
Por ser mundialmente aceita como linguagem de consulta a banco de dados,
os que se propõem a aprender SQL, estejam na China, no Brasil ou em
qualquer país do mundo, receberão o mesmo conjunto de informações.
SQL pode ser usada junto com linguagens procedurais, linguagens visuais e
até mesmo com linguagens de script. E de certa forma, as linguagens de script
serviram para dar um novo impulso ao interesse por SQL. Mas não é só isto.
Um servidor de SQL faz com que a linguagem vá muito além do que a forma
embutida pode oferecer.
28.1 – Como usar SQL?

As formas usuais de executar instruções SQL são:
EMBUTIDA – SQL pode ser chamada de dentro de uma linguagem

(procedural, visual ou de script).
WIZARDS – Rotinas embutidas nos SGBDs que permitem a construção de

complexas instruções SQL, aparentes ou não, até mesmo por quem não
conhece a linguagem.
RAD – Geradores de Aplicações são mecanismos de geração automática de

rotinas ou até mesmo a geração de aplicações completas independentes do
mecanismo gerador.
IDE – Os Ambientes Integrados de Desenvolvimento facilitam o uso do SQL
por permitirem que com o uso de interfaces gráficas e wizards, as instruções
sejam montadas com mais facilidade e rapidez.
28.2 – Tipos de Dados
A tabela seguinte serve para identificar o tipo de dados do MS ACCESS e sua

relação com o tipo de dados SQL:
MS ACCESS SQL
Texto CHAR
CHAR(n)
VARCHAR
VARCHAR(n)
Sendo “n” um número que identifica o comprimento do campo, ou seja, qual o limite
máximo de caracteres que pode ser armazenado.
Se não for especificado, será igual a 255.
Memorando TEXT
Formato MS ACCESS Formato SQL
BYTE
Byte SMALLINT
Inteiro INTEGER
Inteiro Longo REAL
Número Simples FLOAT
Duplo UNIQUEIDENTIFIER
Código de Replicação DECIMAL ou NUMERIC
Decimal DECIMAL(n) ou NUMERIC(n)
DECIMAL(n,d) ou NUMERIC(n,d)
Sendo “n” é o número máximo de caracteres permitido no campo,
“d” é o número de casas decimais.
Data/Hora DATE, TIME, DATETIME
Moeda MONEY ou CURRENCY
AutoNumeração COUNTER
Sim/Não BIT
Tipos Numéricos
Diferença entre cada um dos tipos numéricos diz respeito à precisão e

limitações de valores de cada um. A tabela seguinte serve para esclarecer o
assunto:
ACCESS SQL Tamanho de Armazenamento

Byte BYTE 1 byte
Inteiro (Integer) SMALLINT 2 bytes
Inteiro Longo (Long) INTEGER 4 bytes
Simples (Single) REAL 4 bytes (vírgula flutuante de precisão simples)
Duplo (Double) FLOAT 8 bytes (vírgula flutuante de precisão duplo)
Decimal DECIMAL 14 bytes
29 – ODBC/JDBC
29.1 – O que é um Driver?

Driver é um tipo de software que tem por finalidade permitir a comunicação
entre sistemas. Os drivers geralmente são fornecidos pelos fabricantes, mas é
comum encontrar drivers genéricos distribuídos com o sistema operacional e
também drivers de terceiros, gratuitos ou não.
O que se espera de um driver é a máxima compatibilidade e velocidade sem
degradar a performance do sistema. Um driver tem que fazer o seu papel de
forma transparente e sem que seja criado um gargalo.
29.2 – O que é ODBC?

ODBC – Open DataBase Connectivity / Padrão Aberto de Conectividade a
Banco de Dados é uma interface com grande disponibilidade de drivers para
acesso a banco de dados. ODBC é instalado junto com o MS ACCESS, mas
também pode ser instalado a partir do MDAC – Mircrosoft Universal Data
Access / Componente Microsoft de Acesso Universal a Banco de Dados.
Para acessar o Administrador de Fonte de Dados ODBC, basta acessar o
Painel de Controle.
Importante: É altamente recomendável que você instale ou atualize o MDAC.
Muitos erros de conexão encontrados, foram corrigidos após a instalação ou
atualização deste componente. Você baixar no www.microsoft.com.br, ou pelo
instalador do ORACLE LITE.
29.3 – O que é JDBC?

JDBC – Java DataBase Connectivity / Padrão Java de Conectividade a
Banco de Dados é a interface que possibilita às aplicações Java acessarem
bancos de dados relacionais e demais arquivos de dados. É atualmente a
forma mais prática e rápida para conectar uma aplicação Java a um arquivo de
dados.
29.4 – JDBC / ODBC

Embora um programa em Java possa utilizar diretamente a interface ODBC
para acessar arquivos de dados, este procedimento é trabalhoso e elimina a
portabilidade da aplicação. Mas onde conseguir a ponte JDBC-ODBC? Já
vimos que os drivers ODBC são instalados com o MS ACCESS. E o JDBC?
Você não precisa se preocupar com a instalação do JDBC e da ponte JDBC-
ODBC. No Java2 essas interfaces fazem parte do pacote e são instalados junto
com o JDK/SDK 1.2.X em diante. Até o Java 1(JDK 1.1.X), havia necessidade
de baixar e instalar em separado o JDBC e a ponte JDBC-ODBC.
29.5 – DriverManager
O DriverManager é uma classe pacote Java.sql e serve para:
Fazer a conexão com o banco de dados;
Gerenciar o conjunto de drivers JDBC correspondente;
Controlar o Login;
Controlar as mensagens entre o banco de dados e o driver.
Um programador que utiliza um driver não precisa saber como ele foi
codificado, mas deve saber como carregá-lo para que ele se registre no
DriverManager.
29.6 – Como Criar Fontes de Dados ODBC

As telas seguintes mostram passo-a-passo como criar uma fonte de dados
ODBC, agora vejamos este processo em detalhes:
1 . Vá em Iniciar -> Configurações -> Painel de Controle e dê um duplo-clique

no ícone Fonte de Dados ODBC (32 Bits).
2. Selecione a aba NFD de Sistema / Fonte de Dados de Sistema, dê um

clique no botão Adicionar, conforme mostra a figura1.
Figura1
3. Selecione o Driver para Microsoft Access (*.mdb) e dê um clique no botão

Concluir, conforme mostra a figura2.
Figura2
4. Dê um clique no botão Selecionar, conforme mostra a figura3
Figura3
5. Localize na pasta C:\Agenda e o arquivo Agenda.mdb e dê um clique no

botão Ok, conforme mostra a figura4.
Figura4
6. Digite a palavra Agenda no campo Nome da Fonte de Dados e em seguida

dê um clique no botão OK, conforme mostra a figura5.
Figura5
7. A Fonte de Dados está criada e você já pode visualizá-la em Fontes de

Dados de Sistema, conforme mostra a figura6. Dê um clique no botão OK
para fechar a janela do Administrador de Fonte Dados ODBC
Figura6
30 – SQL – Java & Banco de Dados - Considerações Iniciais
Este é o tópico principal de nossa apostila. É aqui que aprenderemos, na

prática, a fazer conexões com banco de dados usando Java e SQL. Verifique
se você possui os requisitos necessários para prosseguir:
Um banco de dados com o nome Agenda.mdb, criado conforme o tópico 27.5.
Uma fonte de dados ODBC com o nome Agenda, criado conforme o tópico
29.6.
30.1 – Anatomia de uma Conexão e Testando a Conexão
Vejamos a anatomia de uma classe que implementa uma conexão com banco
de dados:
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4. import java.sql.*;
Linha 1, 2, 3 e 4 importa os pacotes de classes que implementa a criação de

janelas, botões, eventos dos botões e o acesso ao banco de dados com o
Java. Os pacotes principais da linguagem são importados default. Pacotes de
uso específico devem ter esta importação explícita nas linhas de codificação da
classe.
5. public class TestaConexao extends JFrame{

6.JButton botao;
7.public TestaConexao(){
8. super("Testando a Conexão...");
9. Container tela = getContentPane();
10. setLayout(null);
11. botao = new JButton("Verificar Conexão");
12. botao.setBounds(50,50,150,20);
13. botao.addActionListener(new ActionListener(){
14. public void actionPerformed(ActionEvent e){
Linha 15 a 24 – Na linguagem Java existe um método para notificação de

erros. Caso o bloco de comandos situado entre as chaves da linha 15 a 24
retorne erro, ele será capturado pelo catch
Linha 16, 17 e 18 – Criam variáveis com a string de conexão, o nome do

usuário e a senha, se houver. Lembre-se que a fonte de dados é criada em
operação à parte. Se tiver dúvidas sobre criação de fontes de dados, leia
novamente o tópico 29.6.
Linha 19 – Esta linha carrega o driver que será usado pela aplicação Java para
realizar a comunicação com o banco de dados.
Linha 20 – Cria uma conexão de nome con.
Linha 21 – Estabelece a conexão usando os valores das variáveis que foram

declaradas inicializadas nas linhas 16, 17 e 18. Nome de usuário e senha são
opcionais. Por estar dentro de uma instrução try, caso ocorra algum problema
na conexão, programa desvia a execução do código para o bloco catch, que
exibierá a mensagem da linha 22. Não é nem a única nem a forma mais
profissional de tratar exceções, mas é a mais simples e funcional para quem
está dando os primeiros passos em Java.
Linha 22 – Exibe uma mensagem dizendo que a conexão foi estabelecida com
sucesso.
Linha 23 – Fecha a conexão aberta nas linhas 19 e 20.
15. try {
16. String url = "jdbc:odbc:Agenda";
17. String usuario = "";
18. String senha = "";
19. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
20. Connection con;
21. con = DriverManager.getConnection(url,usuario,senha);
22. JOptionPane.showMessageDialog(null,"Conexão
estabelecida","Mensagem do
Programa",JOptionPane.INFORMATION_MESSAGE);
23. con.close();
24. }
Linha 25 – Captura os erros ocorridos durante a execução do aplicativo. Caso

algo saia errado, será executado o bloco de comandos que está entre as
chaves 26 e 28.
Linha 27 – Exibe uma mensagem de erro quando a conexão com o banco de

dados não for estabelecida.
25. catch(Exception event)

26. {
27. JOptionPane.showMessageDialog(null,"Conexão não
estabelecida","Mensagem do
Programa",JOptionPane.ERROR_MESSAGE);
28. }
29. }});
30. tela.add(botao);
31. setSize(300, 150);
32. setVisible(true);
33. setLocationRelativeTo(null);
34. }
35.public static void main(String args[]){
36.TestaConexao app = new TestaConexao();
37.app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
38.}
39.}
Aplicativo sendo executado, clique no

botão verificar para ver se a conexão
foi estabelecida.
Conexão OK Conexão com erro
30.2 - Criando a Tabela – CREATE TABLE
Podemos criar uma tabela de nome Tabela1 com os campos Campo1

(AutoNumeração), Campo2 (Texto), Campo3 (Memorando), Campo4
(Data/Hora) e Campo5 (Sim/Não). Veja a sintaxe:
CREATE TABLE Tabela1 (Campo1 COUNTER, Campo2 VARCHAR(50),

Campo3 TEXT, Campo4 DATETIME, Campo5 BIT)
Lembrando que os comandos do SQL, devem ser digitados em maiúsculos.
Usando como referência a tabela de TIPOS DE DADOS, você pode criar

tabelas com praticamente qualquer um dos tipos disponíveis no MS ACCESS.
E não é só isto, além do nome do campo e do tipo de dados, você pode incluir
as seguintes chaves:
NULL – Não rquerido. O campo não precisa conter dados. Se nada for
especificado, NULL será usado como padrão default.
NOT NULL – Requerido. É um campo cuja entrada de dados é obrigatória.
Vamos criar a Tabela2 usando as seguintes informações:
CREATE TABLE Tabela2 (ID COUNTER, Nome VARCHAR(50) NOT NULL,

Tel1 VARCHAR(20) NOT NULL,Tel2 VARCHAR(20) NULL)
Neste exemplo, a digitação do Nome e do Tel1 é obrigatório. Só o segundo

telefone, Tel2, é opcional.
Vamos criar a Tabela3 usando o PRIMARY KEY, (campo chave), que também
pode ser criado na instrução SQL.
CREATE TABLE Tabela3 (ID COUNTER PRIMARY KEY, Nome

VARCHAR(50) NOT NULL, Tel1 VARCHAR(20) NOT NULL,Tel2
VARCHAR(20) NULL)
Quase sempre vamos ter um ou mais campos em nossa tabela, que não
podem se repetir. Exemplos de campos que não podem se repetir: nome,
número de código, matrícula, login e etc. Com a palavra chave UNIQUE,
definimos os campos os campos que não admitem dados repetidos:
CREATE TABLE Tabela4 (ID COUNTER PRIMARY KEY, Nome

VARCHAR(50) NOT NULL UNIQUE, Tel1 VARCHAR(20) NOT NULL,Tel2
VARCHAR(20) NULL)
Obs: Execute o aplicativo ManipulacaoDeTabelas.java e execute a linha

acima, quando você clicar no botão Executar Instrução uma mensagem
confirmando êxito será exibida.
30.3 – Alterando Tabelas (Incluir ou Excluir Campos) ALTER TABLE
Para inserir um novo campo em nossa Tabela2, usamos o seguinte comando:

ALTER TABLE Tabela2 ADD Endereco VARCHAR(50) NOT NULL
Para excluir um campo em nossa Tabela2, usamos o seguinte comando:

ALTER TABLE Tabela2 DROP Endereco
30.4 – Excluir Tabelas – DROP TABLE
Não é muito comum a remoção de uma tabela. Veja o comando:

DROP TABLE Tabela1
Programa ManipulacaoDeTabelas em execução
Digite a instrução SQL na caixa de texto e clique no botão para executar as

instruções SQL.
OBS: Estamos criando as tabelas dentro do banco de dados Agenda.mdb,

pois na classe privada Manipular, chamamos os procedimentos referente a
banco de dados. Para conferir se as tabelas foram criadas abra o banco de
dados Agenda.mdb pelo MS ACCESS, e verifique se a coluna Objetos a
opção Tabelas esta selecionada e veja se todas que você criou esta nesta
opção.
private void manipular(){

try {
String url = "jdbc:odbc:Agenda";
String usuario = "";
String senha = "";
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con;
con = DriverManager.getConnection(url,usuario,senha);
Statement st = con.createStatement();
st.executeUpdate(texto.getText());
JOptionPane.showMessageDialog(null,"Dados Criado Com Sucesso","
Mensagem do Programa",JOptionPane.INFORMATION_MESSAGE);
con.close();
}
catch(Exception event)
{
JOptionPane.showMessageDialog(null,"Conexão não estabelecida \n
Comandos Inválidos","Mensagem do Programa",JOptionPane.ERROR_MESSAGE);
}
}
30.5 – Inserindo Dados na Tabela (INSERT)
Agora que vimos como CRIAR, ALTERAR e REMOVER tabelas, vamos ver
como incluir dados em uma tabela já existente. Veja a sintaxe:
INSERT INTO NomedaTabela (Campo1, Campo2, Campo3) VALUES

(‘valor1’,’valor2’,’valor3’)
Laço If no aplicativo Incluir2.java:
Quando o usuário utiliza campos Sim/Não, o banco de dados trata esses

valores como 1 para sim, 0 para não, para facilitar o usuário, o laço If resgata o
conteúdo que o usuário digitar na caixa de texto Deficiência, pode ser digitado
s ou S, n ou N. Se o usuário digitar s ou S, o laço If armazena na variável result
o valor 1, caso o usuário digite n ou N, o laço If armazena na variável result o
valor 0. O conteúdo da variável result será utilizada na instrução SQL.
if ((t6.getText().equals("s")) || (t6.getText().equals("S")))
result = "1";
else if ((t6.getText().equals("n")) || (t6.getText().equals("N")))
result = "0";
Vamos utilizar o exemplo Inclui2.java, para analisar a sintaxe da instrução

SQL:
st.executeUpdate("INSERT INTO Tabela1 (Nome, Idade, Dn, Sal, Def) VALUES

('"+t2.getText()+"',"+t3.getText()+",#"+t4.getText()+"#,"+t5.getText()+","+result+")");
Os valores se apresentam entre aspas simples se forem do tipo String de

caracteres. Se forem do tipo Número ou Bit (Sim/Não), não precisa de aspas.
Datas e Horas entre o símbolo do sustenido (#), também conhecido como
tralha ou jogo da velha. Valor do Tipo CURRENCY ou MONEY, 36.50 ou
’36,50’, se você usar ponto separador, o MS ACCESS converte em vírgula,
agora se você for usar vírgula, insira o valor entre aspas simples.
Note que temos na tabela Tabela1 um campo Código do Tipo AutoNumeração,

cujo os valores são gerados automaticamente pelo MS ACCESS.
Lembretes:
1. Não inseri dados em campos do tipo COUNTER (AutoNumeração).
2. Atenção com os campos que possuem a chave NOT NULL, pois a inserção
de dados é obrigatória.
3. Também será retornado erro caso você defina um campo como PRIMARY
KEY ou UNIQUE e tente entrar com dados repetidos nestes campos.
Excute também o aplicativo Incluir.java.
30.6 – Consultas (SELECT)
Agora que possuímos tabelas com dados, podemos usar a instrução SELECT
e cláusula WHERE (onde) para consultas a essas tabelas. Cláusula WHERE
perimte que façamos consultas (SELECT), alterações (UPDATE) e exclusões
(DELETE) com o uso de condições para que a ação seja executada.
Aplicativo Consultar.java, veja a instrução SQL, vai listar listar todos os

registro da tabela Tabela1
SELECT * FROM Tabela1
Aplicativo Consultar2.java, veja a instrução SQL, vai listar todos os registros

da tabela Cadastro.
SELECT * FROM Cadastro
Operadores que podem ser usados com WHERE
= igual a
<> diferente de
< menor que
<= menor que ou igual a
> maior que
>= maior que ou igual
30.7 – Consultas Avançadas
O uso do NOT- Se usarmos NOT após a cláusula WHERE, vamos inverter a

função do operador. Veja o exemplo só retorna a verdadeiro se o campo Cód
tiver valores menor que 5: Veja aplicativo Consultar3.java.
SELECT * FROM Tabela1 WHERE NOT Cod>5
O uso do LIKE – Junto com WHERE, LIKE, torna a manipulação de um banco

de dados desafiador. Veja o aplicativo Consultar4.java, retorna todos os
registro que tem sobre nome Silva.
SELECT * FROM Tabela1 WHERE Nome LIKE '%Silva%'
Outros exemplos:
Retorna todos os registros que possuam a string João no início do campo:
WHERE Nome LIKE ‘%João’
Retorna todos os registros que possuam a string João no final do campo:
WHERE Nome LIKE ‘João%’
Uso de Operadores Lógicos – Podemos usar operadores lógicos AND (E),

OR (OU) para melhorar ainda mais nossas operações de banco de dados.
Exemplo Consultar5.java, listar todos os registros que o salário é menor ou

igual a 500 e a data de nascimento menor que 01/01/1978, vai listar todos que
são de 1978.
SELECT * FROM Tabela1 WHERE Sal <=500 AND Dn < #01-01-1979#
Exemplo Consultar6.java, listar todos registros que o sobre nome tenha Silva
e todos que o salário seja menor que 500.
SELECT * FROM Tabela1 WHERE Nome LIKE '%Silva%' OR sal < 500
A Função IsNull – Retorna os campos que não possuem dados. Lista todos os
campos que estão em branco. Exemplo uma lista de alunos, que nem todos os
alunos possuem telefone. Essa instrução lista esse campos em branco:
WHERE InNull(Telefone)
No aplicativo Consultar7.java, será consultada as duas tabelas e será exibido

todos os registros das duas. Cada um correspondente ao seu nome.
SELECT * FROM Tabela1,Cadastro WHERE

Tabela1.Nome=Cadastro.Nome
Consultas especificas
Como podemos verificar no aplicativo Consultar8.java, nós podemos fazer uso

de uma consulta individual. Onde você digita o Código e clicando no botão
Consultar Registro, os campos sobre aquele registro é visualizado.Veja:
import java.awt.*;
import java.sql.*;
public class Consultar8 extends JFrame{
JButton botao;
JLabel l1,l2,l3,l4,l5,l6;
JTextField t1,t2,t3,t4,t5,t6;
String result;
int num;
public Consultar8(){
super("Inclusão de Registro");
l1 = new JLabel("Código: "); t1 = new JTextField(5);
l2 = new JLabel("Nome: "); t2 = new JTextField(50);
l3 = new JLabel("Idade: "); t3 = new JTextField(2);
l4 = new JLabel("Data Nasc.: "); t4 = new JTextField(10);
l5 = new JLabel("Salário: "); t5 = new JTextField(15);
l6 = new JLabel("Deficiência: "); t6 = new JTextField(5);
l1.setBounds(20,30,80,20); t1.setBounds(100,30,150,20);
l3.setBounds(20,110,80,20);t3.setBounds(100,110,30,20);
botao = new JButton("Consultar Registro"); botao.setBounds(110,270,150,20);
tela.add(l1);tela.add(t1);
tela.add(botao);
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1 WHERE
Cod="+t1.getText());
rs.next();
t2.setText(rs.getString("Nome"));
t3.setText(rs.getString("Idade"));
t4.setText(rs.getString("Dn"));
t5.setText(rs.getString("Sal"));
num=Integer.parseInt(rs.getString("Def"));
if (num==1)
result = "Sim";
else if (num==0)
result = "Não";
t6.setText(result);
st.close();
con.close();
}
catch(Exception event) {
JOptionPane.showMessageDialog(null,"Conexão não
estabelecida \nPessoa não encontrada","Mensagem do
}
}});
setSize(450, 350);
setVisible(true);
}
Consultar8 app = new Consultar8();
}
}
Vamos analisar o código do botão Consultar Registro:
Cria os objetos que permitem a realização de consultas SQL. Statement

permite a execução das instruções SQL, enquanto ResultSet armazena o
resultado na janela:
Invoca o método createStatement de Connection para obter um objeto que

implementa a interface Statement. Agora podemos utilizar st para consultar o
banco de dados:
Realiza a consulta que será feita pelo campo Código, chamando o método
executeQuery de Statement:

Posiciona no primeiro Registro:
rs.next();
Exibe dentro das caixas de texto, as informações sobre o código pesquisado:
Resgata o valor do campo Def, converte esse valor para inteiro e armazena na
variável inteira num, declarada no início do aplicativo:
Utiliza o laço IF para condição, que verifica se o valor da variável num, for igual
a 1, a sentença é verdadeira, logo o conteúdo a ser exibido na caixa de texto
será Sim, caso contrário se o valor for igual a 0, logo a sentença será falsa e o
conteúdo a ser exibido na caixa de texto, será Não.
if (num==1)
result = "Sim";
else if (num==0)
result = "Não";
t6.setText(result);
Caso o usuário entre com o código inválido, o aplicativo exibirá uma mensagem
de texto, informando ao usuário a inválidade.
Aplicativo Consultar8.java em execução.
Mensagem de erro quando o código inválido é informado.
Consultas com ORDER BY
Podemos optar por exibir os dados ordenados por um dos campos da tabela:
SELECT * FROM Tabela2 ORDER BY Nome
ASC ou DESC
Se não for especificado a classificação da nossa ordenação, ela será ASC

(ascendente) por default. Para a ordenação decrescente, usamos DESC. Mais
de uma classificação pode ser utilizada bastar utilizar vírgulas.
SELECT * FROM Cadastro ORDER BY Nome, Telefone_1 ASC
30.8 – Atualizando Dados (UPDATE)
A instrução UPDATE, serve para realizar atualizações nos registro da tabela.

Sintaxe:
UPDATE NomeDaTabela SET Campo=’NovoValor’ WHERE

Campo=’ValorAntigo’
Atualização de registro pelo código, na Tabela2, foi selecionado o código 1

para realizar as alterações veja:
UPDATE Tabela2 SET Nome='Pedro Carlos da Silva’, Idade=29,Dn=#23-05-

1978#,Sal=380.00,Def=0 WHERE Cod=1
No campo Sal, se você for adicionar o valor com vírgula coloque o valor entre
aspas simples ex: ‘380,00’
No campo Def, onde os valores retornados para a tabela é sim ou não, 1

corresponde a Sim, 0 corresponde a não.
No campo Dn, onde os valores a serem incluídos são datas deve ser usar #23-
05-2004#.
String utilizam aspas simples, e números não utilizam aspas simples.

Só que nesse aplicativo foi feito um laço IF, para dizer que quando for digitando
s ou S, a variável result recebe o valor 1, e exibe na caixa de texto o conteúdo
sim. Caso for digitado n ou N, a variável result recebe o valor 0, e exibe na
caixa de texto o conteúdo não.
{result = "1";
t6.setText("Sim");}
{result = "0";
t6.setText("Não");}
E na isntrução SQL foi colocado a variável result, que contém o valor 1 ou 0.
st.executeUpdate("UPDATE Tabela2 SET

Nome='"+t2.getText()+"',Idade="+t3.getText()+",Dn=#"+t4.getText()+"#,Sal
="+t5.getText()+",Def="+result+" WHERE Cod="+t1.getText());
Exemplo Alterar2.java, alterar da Tabela2 todos os salários para o valor que o

usuário espercificar
UPDATE Tabela2 SET Def="+t1.getText()
30.9 – Excluindo Dados (DELETE)
Para excluir dados de uma linha inteira de uma tabela, usamos a seguinte
instrução DELETE:
DELETE FROM NomeDaTabela WHERE Campo=’Valor’
Por exemplo para excluir todos os registro da tabela Tabela2, aplicativo
Excluir.java: DELETE * FROM Tabela2
Excluindo Registro pelo Código, aplicativo Excluir2.java:
DELETE FROM Tabela2 WHERE Cod= t1.getText()
Excluindo com operadores lógicos:
DELETE FROM Tabela2 WHERE Cod>3 AND sal<500
30.10 – Exibindo Dados em uma Lista
Até agora estamos visualizando nossas listagem no console. Agora vamos ver
uma listagem feita na própria janela. Veja o aplicativo Relatorio.java:
import java.awt.*;
import java.sql.*;
import java.util.*;
public class Relatorio extends JFrame{

private Connection con;
private JTable tabela;
public Relatorio(){
super("Agenda - Nomes" );
String senha = "";
try{
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
con = DriverManager.getConnection(url, usuario, senha);
}
catch (Exception e){
estabelecida","Mensagem do Programa",
JOptionPane.ERROR_MESSAGE);
}
buscaTabela();
setSize(600,200);
setVisible(true);
}
Relatorio app = new Relatorio();
}
private void buscaTabela(){
Statement st;
ResultSet res;
try{
Vector cabecalho = new Vector();
Vector linhas = new Vector();
st = con.createStatement();
res = st.executeQuery("SELECT * FROM Cadastro ORDER BY Nome");
res.next();
ResultSetMetaData rsmd = res.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); ++i)
cabecalho.addElement(rsmd.getColumnName(i));
do{
linhas.addElement(proximaLinha(res,rsmd));
}
while (res.next());
tabela = new JTable(linhas,cabecalho);
JScrollPane scroller = new JScrollPane( tabela );
getContentPane().add(scroller, BorderLayout.CENTER);
validate();
st.close();
}
catch (SQLException sqlex){
}
}
private Vector proximaLinha(ResultSet rs, ResultSetMetaData rsmd){
Vector LinhaAtual = new Vector();
try{
switch(rsmd.getColumnType(i)){
case Types.VARCHAR: LinhaAtual.addElement(rs.getString(i));
break;
case Types.TIMESTAMP: LinhaAtual.addElement(rs.getDate(i));
break;
case Types.NUMERIC: LinhaAtual.addElement(new Long(rs.getLong(i)));
break;
}
}
catch(SQLException e){
}
return LinhaAtual;
}
}
Aplicativo Relatorio.java em execução
A primeira vista o código do aplicativo Relatorio.java pode parecer um pouco

complicado, mas tenho certeza de que após a análise, você perceberá que é
só uma questão de tempo até estar totalmente familiarizado com os novos
objetos usados no exemplo:
1. Declara tabela como instância do objeto JTable: private JTable tabela;
2. Classe pública Relatório é a responsável pela criação da conexão com o

banco de dados, incluindo o tratamento de erros:

public Relatorio(){
String senha = "";
try{
}
estabelecida","Mensagem do Programa",
JOptionPane.ERROR_MESSAGE);
}
buscaTabela();
setSize(600,200);
setVisible(true);
}
3. O método buscaTabela é o responsável por criar a tabela que será inserida

na janela:
buscaTabela();
4. Cria os objetos que permitem a realização de consultas SQL, Statement

permite a execução das instruções SQL, enquanto o ResultSet armazena o
resultado da consulta:
Statement st;
ResultSet res;
5. Cria os vetores cabecalho e linha para, armazenar respectivamente as

colunas e linhas que irão compor nossa tabela:

6. Invoca o método createStatemente de Connection para obter um objeto

que implementa a interface Statement. Agora podemos utilizar st para
consultar o bando de dados:
7. Realiza a consulta em ordem alfabética chamando o método executeQuery

de Statement:
8. Posiciona no primeiro registro:
res.next();
9. Armazenaa informações sobre o banco de dados e a consulta, que poderão

ser usadas pela conexão ou pelo desenvolvedor:
10. Inicia um loop. O objeto das linhas seguintes é montar a tabela com seus
cabeçalhos:
Utiliza o método rsmd.getColumnCount(), que informa quantos registros

compõem a tabela, e monta o cabeçalho, adicionando os títulos (Nome, Idade,
Sexo e etc) a cada coluna do cabeçalho:

Adiciona as linhas e o cabeçalho a tabela, cria barras de rolagem se

necessário, adiciona as barras de rolagem a janela, com o painel centralizado e
usa o método validate(), para validar os dados.
do{
}
while (res.next());
validate();
11. Criamos mais um vetor e um loop, com a finalidade de percorrer a tabela,

usando as informações obtidas do loop anterior:

try {
12. Por fim, estrutura switch…case verifica o tipo de dados e utilize a forma
mais apropriada para obtê-los (getString() para textos, getDate() para
data/hora, getLong() para números):
break;
break;
break;
30.11 – Exibindo relatório com filtro e chamando outra janela
No aplicativo Relatorio1.java, temos uma janela que exibe um rótulo, uma

caixa de texto e um botão, quando o usuário digita um nome, e clica no botão
Exibir Relatório, o aplicativo retorna uma outra janela exibindo os nomes.
Caso o usuário não digite nenhum nome, e clique no botão Exibir Relatório, o
aplicativo exibe todos os nomes da tabela. Veja o aplicativo:
Primeira janela do aplicativo Relatorio1.java
Verificar quais Tipos de Dados podem ser utilizados para exibir a saída de
dados da tabela.
Tipos de Dados Verificar Saída

String (Caractere) Types.VARCHAR rs.getString
Integer (Inteiro) Types.INTEGER new Long(rs.getLong)
DATETIME(Data e Hora) TIMESTAMP rs.getDate
Números Flutuantes Types.NUMERIC rs.getDouble
BIT (Lógico) Types.BIT rs.getByte
Double (8 bytes) Types.DOUBLE Long(rs.getLong)
Real (4 bytes) Types.REAL Long(rs.getLong)
FLOAT(Double) Types.FLOAT Long(rs.getLong)
Exemplo Relatorio2.java, exibe na janela os registros referentes a cada

pessoa das duas tabelas. Resgata os dados da Tabela1 e da tabela Cadastro,
utiliza a cláusula WHERE, para verificar se o nome da pessoa nas duas tabelas
são iguais, e exibe os dados destas pessoas na janela.
Veja a instruação SQL:
1º Passo: Seleciona os campos de cada tabela:
SELECT Tabela1.Cod,Tabela1.Nome,Tabela1.Idade,Tabela1.Dn,Tabela1.Sal,
Tabela1.Def,Cadastro.Telefone_1,Cadastro.Telefone_2,Cadastro.Celular
2º Passo: Atriubui quais tabelas serão utilizadas:
FROM Cadastro, Tabela1
3º Passo: Utiliza a cláusula WHERE para comparar os nomes nas tabelas:
WHERE Cadastro.Nome=Tabela1.Nome
Tela do aplicativo Relatorio2.java em execução
Aplicativos resolvidos em Ordem Alfabética:
mport javax.swing.*;
import java.awt.*;
import java.sql.*;
public class Alterar extends JFrame{
JButton botao, botao2;
String result;
int num;
Alterar(){
super("Alteração de Registro");
botao2 = new JButton("Alterar Registro"); botao2.setBounds(200,270,150,20);
tela.add(botao);tela.add(botao2);
try {
String senha = "";
Connection con;
rs.next();
if (num==1)
result = "Sim";
else if (num==0)
result = "Não";
t6.setText(result);
st.close();
con.close();
}
{
JOptionPane.showMessageDialog(null,"Conexão não estabelecida \nPessoa
não encontrada","Mensagem do Programa",JOptionPane.ERROR_MESSAGE);
}
}});
botao2.addActionListener(new ActionListener(){
try {
{result = "1";
t6.setText("Sim");}
{result = "0";
t6.setText("Não");}

String senha = "";
Connection con;
st.executeUpdate("UPDATE Tabela2 SET
Nome='"+t2.getText()+"',Idade="+t3.getText()+",Dn=#"+t4.getText()+"#,Sal="+t5.getText()+",Def
="+result+" WHERE Cod="+t1.getText());
JOptionPane.showMessageDialog(null,"Registro Alterado com Sucesso","Mensagem
do Programa",JOptionPane.INFORMATION_MESSAGE);
t1.requestFocus();
st.close();
con.close();
}
{
}
}});
setSize(450, 350);
setVisible(true);
}
Alterar app = new Alterar();
}
}
import java.awt.*;
import java.sql.*;
public class Alterar2 extends JFrame{
JButton botao;
JLabel l1;
JTextField t1;
Alterar2(){
super("Alteração de Registro");
l1 = new JLabel("Entre com o valor do novo salário: ");
t1 = new JTextField(10);
botao = new JButton("Alterar Valores"); botao.setBounds(150,100,150,20);
tela.add(botao);
tela.add(botao);
try {
String senha = "";
Connection con;
st.executeUpdate("UPDATE Tabela2 SET Def="+t1.getText());
JOptionPane.showMessageDialog(null,"Registros Alterado com Sucesso","Mensagem
t1.requestFocus();
st.close();
con.close();
}
{
}
}});
setSize(450,200);
setVisible(true);
}
Alterar2 app = new Alterar2();
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
public class Consultar extends JFrame{
String result;
public Consultar(){
super("Consulta de Registros");
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1");
while (rs.next()){
System.out.println("Codigo: "+rs.getString("Cod")+" ");
System.out.println("Nome: "+rs.getString("Nome")+" ");
System.out.println("Idade: "+rs.getString("Idade")+" ");
System.out.println("Data Nasc.: "+rs.getString("Dn")+" ");
System.out.println("Salario: "+rs.getString("Sal")+" ");
System.out.println("Deficiencia: "+rs.getString("Def")+" ");
System.out.println(" ");
}
st.close();
con.close();
}
{
Comandos Digitados Inválidos","Mensagem do Programa",JOptionPane.ERROR_MESSAGE);
}
setSize(450, 350);
}
Consultar app = new Consultar();
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
String result;
JTable tabela;
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Cadastro");
while (rs.next()){
System.out.println("Tel 1: "+rs.getString("Telefone_1")+" ");
System.out.println("Tel 2: "+rs.getString("Telefone_2")+" ");
System.out.println("Celular.: "+rs.getString("Celular")+" ");
}
st.close();
con.close();
}
{
}
setSize(450, 350);
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
String result;
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1 WHERE NOT
Cod>5");
while (rs.next()){
}
st.close();
con.close();
}
{
}
setSize(450, 350);
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
String result;
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1 WHERE Nome
LIKE '%Silva%'");
while (rs.next()){
}
st.close();
con.close();
}
{
}
setSize(450, 350);
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
String result;
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1 WHERE Sal <=500
AND Dn < #01-01-1979#");
while (rs.next()){
}
st.close();
con.close();
}
{
}
setSize(450, 350);
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
String result;
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1 WHERE Nome

LIKE '%Silva%' OR sal < 500");
while (rs.next()){
}
st.close();
con.close();
}
{
}
setSize(450, 350);
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
String result;
try {
String senha = "";
Connection con;
ResultSet rs = st.executeQuery("SELECT * FROM Tabela1,Cadastro WHERE
Tabela1.Nome=Cadastro.Nome");
while (rs.next()){
System.out.println("Telefone 1: "+rs.getString("Telefone_1")+" ");
System.out.println("Telefone 1: "+rs.getString("Telefone_2")+" ");
System.out.println("Celular: "+rs.getString("Celular")+" ");
}
st.close();
con.close();
}
{
}
setSize(450, 350);
}
}
}
import java.awt.*;
import java.sql.*;
JButton botao;
String result;
int num;
super("Consulta de Registro");
tela.add(botao);
try {
String senha = "";
Connection con;
rs.next();
if (num==1)
result = "Sim";
else if (num==0)
result = "Não";
t6.setText(result);
st.close();
con.close();
}
{
}
}});
setSize(450, 350);
setVisible(true);
}
}
}
import java.awt.*;
public class CorDeFundo extends JFrame{
public CorDeFundo(){
setSize(500, 500);
setVisible(true);
}
CorDeFundo app = new CorDeFundo();
}
}
import java.awt.*;
public class CorDeFundo2 extends JFrame{
public CorDeFundo2(){
setSize(500, 500);
setVisible(true);
}
CorDeFundo2 app = new CorDeFundo2();
}
}
import java.awt.*;
import java.util.*;
public class Data extends JFrame{
int ds,dia,mes,ano;
Calendar data;
String diasemana[]={"Domingo","Segunda - Feira","Terça - Feira","Quarta - Feira",
"Quinta - Feira","Sexta - Feira","Sábado"};
String meses[]={"Janeiro","Fevereiro","Março","Abril","Maio","Junho",
"Julho","Agosto","Setembro","Outubro","Novembro","Dezembro"};
public Data(){
super("Exemplo de Data");
data = Calendar.getInstance();
ds = data.get(Calendar.DAY_OF_WEEK);
dia = data.get(Calendar.DAY_OF_MONTH);
mes = data.get(Calendar.MONTH);
ano = data.get(Calendar.YEAR);
rotulo.setText("Data: "+ds+" "+dia+"/"+(mes+1)+"/"+ano);
rotulo2.setText("Data: "+diasemana[ds-1]+", "+dia+" de "+meses[mes]+" de "+ano);
tela.add(rotulo);
tela.add(rotulo2);
setSize(300, 200);
setVisible(true);
}
Data app = new Data();
}
}
public class DefinirIcone extends JFrame{
public DefinirIcone(){
super("Como definir o ícone para a janela");
setSize(300, 150);
setVisible(true);
}
DefinirIcone app = new DefinirIcone();

}
}
import java.awt.*;
public class DesabilitarHabilitar extends JFrame{
JButton desabilitar,habilitar;
public DesabilitarHabilitar(){
super("Exemplo de Desabilitar e Habilitar componentes");
setLayout(null);
rotulo1 = new JLabel("Rótulo 1");
desabilitar = new JButton("Desabilitar");
habilitar = new JButton("Habilitar");
desabilitar.setBounds(80,100,100,20);
habilitar.setBounds(250,100,100,20);
desabilitar.addActionListener(
}
}
);
habilitar.addActionListener(
}
}
);
tela.add(desabilitar); tela.add(habilitar);
setSize(400, 250);
setVisible(true);
}
DesabilitarHabilitar app = new DesabilitarHabilitar();
}
}
import java.awt.*;
import java.sql.*;
public class Excluir extends JFrame{
JButton botao;
public Excluir(){
super("Exclusão de Registro");
botao = new JButton("Excluir Registro"); botao.setBounds(30,50,150,20);
tela.add(botao);
try {
String senha = "";
Connection con;
st.executeUpdate("DELETE * FROM Tabela2");
JOptionPane.showMessageDialog(null,"Registros Excluidos Com
Sucesso","Mensagem do Programa",JOptionPane.INFORMATION_MESSAGE);
st.close();
con.close();
}
{
}
}});
setSize(200, 150);
setVisible(true);
}
Excluir app = new Excluir();
}
}
import java.awt.*;
import java.sql.*;
public class Excluir2 extends JFrame{
JButton botao, botao2;
String result;
int num;
public Excluir2(){
super("Exclusão de Registro");
botao2 = new JButton("Excluir Registro"); botao2.setBounds(200,270,150,20);
tela.add(botao);tela.add(botao2);
try {
String senha = "";
Connection con;
rs.next();
if (num==1)
result = "Sim";
else if (num==0)
result = "Não";
t6.setText(result);
st.close();
con.close();
}
{
}
}});
try {
String senha = "";
Connection con;
st.executeUpdate("DELETE FROM Tabela2 WHERE Cod="+t1.getText());
JOptionPane.showMessageDialog(null,"Registro Excluido com Sucesso","Mensagem
t1.setText(""); t2.setText(""); t3.setText(""); t4.setText(""); t5.setText("");t6.setText("");
t1.requestFocus();
st.close();
con.close();
}
{
}
}});
setSize(450, 350);
setVisible(true);
}
Excluir2 app = new Excluir2();
}
}
import java.awt.*;
public class ExemploBarraDeFerramentas extends JFrame{
JToolBar barra;
JButton direita,esquerda,centralizar,recortar,copiar,colar;
public ExemploBarraDeFerramentas(){
super("Exemplo de Barra de Ferramentas");
for(int i = 0;i < 6;i++){
imagens[i] = new ImageIcon(icones[i]);
}
barra.add(direita);
barra.add(copiar);
barra.add(colar);
tela.add(barra);
setSize(320,340);
setVisible(true);
}
ExemploBarraDeFerramentas app = new ExemploBarraDeFerramentas();
}
}
import java.awt.*;
setLayout(null);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}

}
}
import java.awt.*;
public class ExemploBotaoAoPressionarEnter extends JFrame{
public ExemploBotaoAoPressionarEnter(){
setLayout(null);
getRootPane().setDefaultButton(botao4);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}
ExemploBotaoAoPressionarEnter app = new ExemploBotaoAoPressionarEnter();
}
}
import java.awt.*;
public class ExemploBotaocomBotaoAtalho extends JFrame{
public ExemploBotaocomBotaoAtalho(){
setLayout(null);
botao1.setMnemonic(KeyEvent.VK_P);
botao2.setMnemonic(KeyEvent.VK_V);
botao3.setMnemonic(KeyEvent.VK_X);
botao4.setMnemonic(KeyEvent.VK_S);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}

ExemploBotaocomBotaoAtalho app = new ExemploBotaocomBotaoAtalho();
}
}
import java.awt.*;
public class ExemploBotaoCordaLetra extends JFrame{
public ExemploBotaoCordaLetra(){
setLayout(null);
botao1.setForeground(Color.blue);
botao2.setForeground(Color.green);
botao3.setForeground(Color.red);
botao4.setForeground(Color.pink);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}
ExemploBotaoCordaLetra app = new ExemploBotaoCordaLetra();
}
}
import java.awt.*;
public class ExemploBotaoCordeFundo extends JFrame{
public ExemploBotaoCordeFundo(){
setLayout(null);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}
ExemploBotaoCordeFundo app = new ExemploBotaoCordeFundo();
}
}
import java.awt.*;
public class ExemploBotaoCordeFundo extends JFrame{
public ExemploBotaoCordeFundo(){

setLayout(null);
tela.add(botao1);
tela.add(botao2);
tela.add(botao3);
tela.add(botao4);
setSize(400, 250);
setVisible(true);
}
ExemploBotaoCordeFundo app = new ExemploBotaoCordeFundo();
}
}
import java.awt.*;
public class ExemploBotaoSair1 extends JFrame{
JButton botao;
public ExemploBotaoSair1(){
botao.setToolTipText("Exemplo de Botões com Diálogos de confirmação");
tela.add(botao);
int opcao;
opcao = JOptionPane.showConfirmDialog(null,"Deseja mesmo
fechar a janela?","Fechar",JOptionPane.YES_NO_OPTION);
System.exit(0);
}});
setSize(300,200);
setVisible(true);
}
ExemploBotaoSair1 app = new ExemploBotaoSair1();
}
}
import java.awt.*;
public class ExemploBotaoSair extends JFrame{
JButton botaosair;
public ExemploBotaoSair(){
setLayout(null);
System.exit(0);
} } );
setSize(300, 150);
setVisible(true);
}
ExemploBotaoSair app = new ExemploBotaoSair();
}
}
import java.awt.*;
public class ExemploBotoes extends JFrame{
JButton botaotexto,botaoimagemtexto,botaoimagem;
ImageIcon icone;
public ExemploBotoes(){
setLayout(null);
botaotexto = new JButton ("Novo");
botaoimagemtexto = new JButton ("Abrir",icone);
botaoimagem = new JButton (icone);
botaotexto.setBounds(50,20,100,20);
botaoimagemtexto.setBounds(50,60,100,20);
botaoimagem.setBounds(50,100,100,20);
tela.add(botaotexto);
tela.add(botaoimagemtexto);
tela.add(botaoimagem);
setSize(400, 250);
setVisible(true);
}
ExemploBotoes app = new ExemploBotoes();
}
}
import java.awt.*;
public class ExemploBotoesDicas extends JFrame{
public ExemploBotoesDicas(){
botao1 = new JButton("Abrir");
tela.add(botao1);
tela.add(botao2);
setSize(300,200);
setVisible(true);
}
ExemploBotoesDicas app = new ExemploBotoesDicas();
}
}
import java.awt.*;
public class ExemploBotoesDicas2 extends JFrame{
public ExemploBotoesDicas2(){
botao1 = new JButton("Abrir");
tela.add(botao1);
tela.add(botao2);
setSize(300,200);
setVisible(true);
}
ExemploBotoesDicas2 app = new ExemploBotoesDicas2();
}
}
import java.awt.*;
public class ExemploComboCheckRadio extends JFrame{
ButtonGroup grupo;
String cor[] = {"Sem Cor","Vermelho","Azul","Verde","Amarelo","Branco","Preto"};
JComboBox lista;
public ExemploComboCheckRadio(){
super("Exemplo Combo Check Radio BOX");
setLayout(null);
rotulo1 = new JLabel("Cor");
rotulo2 = new JLabel("Estilo");
rotulo3 = new JLabel("Tamanho");
texto = new JLabel("Programa feito em Java");
lista = new JComboBox(cor);
negrito = new JCheckBox("Negrito") ;
italico = new JCheckBox("Italico");
grupo.add(tam1);
grupo.add(tam2);
grupo.add(tam3);
grupo.add(tam4);
negrito.setBounds(200,50,100,20);
italico.setBounds(200,70,100,20);
normal.setBounds(200,90,100,20);
tam4.setBounds(350,110,100,20);
tamfonte=12;
estilo=Font.PLAIN;
lista.addActionListener(new ActionListener(){
tamfonte=12;
tamfonte=14;
tamfonte=16;
tamfonte=18;
//coloca a fonte em negrito
negrito.addActionListener(new ActionListener(){
estilo=Font.BOLD;
//coloca a fonte em italico
italico.addActionListener(new ActionListener(){
estilo=Font.ITALIC;
//coloca a fonte normal
normal.addActionListener(new ActionListener(){
estilo=Font.PLAIN;
//coloca a fonte em negrito e italico
negritoitalico.addActionListener(new ActionListener(){
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(texto);
tela.add(negrito);
tela.add(italico);
tela.add(normal);
tela.add(negritoitalico);
tela.add(tam1);
tela.add(tam2);
tela.add(tam3);
tela.add(tam4);
tela.add(lista);
setSize(500,300);
setVisible(true);
}
ExemploComboCheckRadio app = new ExemploComboCheckRadio();
}
}
import java.awt.*;
public class ExemploDeMenu extends JFrame{
JMenuBar barra;
JMenu opcoes;
JMenuItem limpar,fonte,sair;
public ExemploDeMenu(){
super("Exemplo de Menus");
setJMenuBar(barra);
barra.add(opcoes);
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
setSize(500,300);
setVisible(true);
}
ExemploDeMenu app = new ExemploDeMenu();
}
}
import java.awt.*;
JMenuBar barra;
JMenuItem limpar,sair,estilo,tamanho,azul,verde,vermelho,amarelo,preto;
super("Exemplo de Menus com submenus");
setJMenuBar(barra);
barra.add(opcoes);
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
setSize(500,300);
setVisible(true);
}
}
}
import java.awt.*;
JMenuBar barra;
JMenu opcoes,fonte,estilo,cor;
JMenuItem limpar,sair,tamanho,azul,verde,vermelho,amarelo,preto;
super("Exemplo de Menus com JChekBoxMenuItem");
setJMenuBar(barra);
barra.add(opcoes);

opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
estilo.add(normal);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
setSize(500,300);
setVisible(true);
}
}
}
import java.awt.*;
JMenuBar barra;
String tam[] = {"12","14","16","18"};
super("Exemplo de Menus com JRadioButtonMenuItem");
setJMenuBar(barra);
barra.add(opcoes);
for(int i = 0; i < 4; i++){
}
for(int i = 0; i < 4; i++){
}
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
setSize(500,300);
setVisible(true);
}
}
import java.awt.*;
JMenuBar barra;
String tam[] = {"12","14","16","18"};
JTextArea texto;
JPanel painel;
JScrollPane rolagem;
int estilofonte, tamfonte;
super("Exemplo de Menus executando ações");
estilofonte=Font.PLAIN;
tamfonte=12;
setJMenuBar(barra);
barra.add(opcoes);

for(int i = 0; i < 4; i++){
nomeE[i].addItemListener(tratestilo);
}
for(int i = 0; i < 4; i++){
tamanhoF[i].addItemListener(trattamanho);
}
opcoes.add(limpar);
opcoes.add(fonte);
opcoes.add(sair);
cor.add(azul);
cor.add(verde);
cor.add(vermelho);
cor.add(amarelo);
cor.add(preto);
fonte.add(cor);
fonte.add(estilo);
fonte.add(tamanho);
rolagem = new JScrollPane(texto);
rolagem.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
rolagem.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWA
YS);
painel.add(rolagem);
tela.add(painel);
texto.setText("");
azul.addActionListener(new ActionListener(){
repaint();}});
verde.addActionListener(new ActionListener(){
repaint();}});
repaint();}});
repaint();}});
preto.addActionListener(new ActionListener(){
repaint();}});
int resposta;
if (resposta==6)
System.exit(0);}});
setSize(500,300);
setVisible(true);
}
}
repaint(); } }
tamfonte= 12;
tamfonte= 14;
tamfonte= 16;
tamfonte= 18;
repaint(); } }
}
import java.awt.*;
public class ExemploDeMessagens extends JFrame{
JButton erro, informacao, exclamacao, pergunta, nenhum;
public ExemploDeMessagens(){
super("Exemplo de mensagens");
erro = new JButton("Erro");
informacao = new JButton("Informação");
exclamacao = new JButton("Exclamação");
pergunta = new JButton("Pergunta");
nenhum = new JButton("Nenhum");
erro.setBounds(30,20,100,20);
informacao.setBounds(30,50,100,20);
exclamacao.setBounds(30,80,150,20);
pergunta.setBounds(30,110,100,20);
nenhum.setBounds(30,140,100,20);
tela.add(erro);
tela.add(informacao);
tela.add(exclamacao);
tela.add(pergunta);
tela.add(nenhum);
erro.addActionListener(new ActionListener(){
JOptionPane.showMessageDialog(null,"Você escolheu erro","Mensagem de

Erro",JOptionPane.ERROR_MESSAGE,null);}});
informacao.addActionListener(new ActionListener(){
informação","Mensagem de Informação",JOptionPane.INFORMATION_MESSAGE,null);}});
pergunta.addActionListener(new ActionListener(){
pergunta","Mensagem de Pergunta",JOptionPane.QUESTION_MESSAGE,null);}});
nenhum.addActionListener(new ActionListener(){
nenhum","Mensagem",JOptionPane.PLAIN_MESSAGE,null);}});
exclamacao.addActionListener(new ActionListener(){
exclamação","Mensagem de Exclamação",JOptionPane.WARNING_MESSAGE,null);}});
setSize(300,200);
setVisible(true);
}
ExemploDeMessagens app = new ExemploDeMessagens();
}
}
import java.awt.*;
public class ExemploDePopupMenu extends JFrame{
JPopupMenu opcoes;
JMenuItem recortar,copiar,colar;
JTextArea texto;
public ExemploDePopupMenu(){
super("Exemplo de PopupMenu");
public void mouseReleased(MouseEvent e) {
opcoes.show(e.getComponent(),e.getX(),e.getY());
}});
Tratador tratmenu = new Tratador();
recortar = new JMenuItem("Recortar");
copiar = new JMenuItem("Copiar");
colar = new JMenuItem("Colar");
recortar.setMnemonic(KeyEvent.VK_R);
copiar.setMnemonic(KeyEvent.VK_C);
colar.setMnemonic(KeyEvent.VK_L);
recortar.addActionListener(tratmenu);
copiar.addActionListener(tratmenu);
colar.addActionListener(tratmenu);
opcoes.add(recortar);
opcoes.add(copiar);
opcoes.add(colar);
tela.add(texto);
setSize(320,340);
setVisible(true);
}
ExemploDePopupMenu app = new ExemploDePopupMenu();
}
private class Tratador implements ActionListener{
if(e.getSource()==recortar)
texto.cut();
if(e.getSource()==copiar)
texto.copy();
if(e.getSource()==colar)
texto.paste();
repaint();
}}}
import java.awt.*;
public class ExemploInputDialog extends JFrame{
JButton botao;
String nome;
JLabel rotulo;
public ExemploInputDialog(){
super("Exemplo de Input Dialog");
nome = JOptionPane.showInputDialog("Entre com seu nome: ");
rotulo.setText("O nome digitado foi: "+nome.toUpperCase());
tela.add(rotulo);
tela.add(botao);
int opcao;
opcao = JOptionPane.showOptionDialog(null,"Deseja mesmo
fechar a
janela?","Fechar",JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE,null,b
otoes,botoes[0]);
System.exit(0);
}});
setSize(300,200);
setVisible(true);
}
ExemploInputDialog app = new ExemploInputDialog();

}
}
import javax.swing.JOptionPane;
public class ExemploInputDialog1{
Object linguagens [] = {"Java","Delphi","C++","Visual Basic"};
Object opcao = JOptionPane.showInputDialog(null,"Qual sua linguagem
favorita?","Enquete",JOptionPane.QUESTION_MESSAGE,null,linguagens,linguagens[0]);
JOptionPane.showMessageDialog(null,"Você escolheu: "+opcao);
System.exit(0);
}
}
import java.awt.*;
public class ExemploJCheckBox extends JFrame{
JLabel vazio;
public ExemploJCheckBox(){

tela.add(rotulo);
tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
tela.add(botao);
tela.add(vazio);
setSize(500,300);
setVisible(true);
}
ExemploJCheckBox app = new ExemploJCheckBox();
}
}
import java.awt.*;
JLabel vazio;
primeira.setForeground(Color.blue);
segunda.setForeground(Color.red);
terceira.setForeground(Color.green);
quarta.setForeground(Color.yellow);
quinta.setForeground(Color.white);
tela.add(rotulo);
tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
tela.add(botao);
tela.add(vazio);
setSize(500,300);
setVisible(true);
}
}
}
import java.awt.*;

tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
setSize(500,300);
setVisible(true);
}
}
}
import java.awt.*;
public class ExemploJComboBox extends JFrame{
JComboBox lista;
JButton exibir;
JLabel rotulo;
public ExemploJComboBox(){
setLayout(null);
}
}
);
tela.add(lista);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
ExemploJComboBox app = new ExemploJComboBox();
}
}
import java.awt.*;
public class ExemploJComboBox2 extends JFrame{
JComboBox lista;
JButton exibir;
JLabel rotulo;
public ExemploJComboBox2(){
setLayout(null);
}
}
);
tela.add(lista);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
ExemploJComboBox2 app = new ExemploJComboBox2();
}
}
import javax.swing.text.*;
import java.awt.*;
import java.text.*;
public class ExemploJFormattedTextField extends JFrame{
JLabel rotulocep,rotulotel,rotulocpf,rotulodata;
JFormattedTextField cep,tel, cpf, data;
public ExemploJFormattedTextField(){
super("Exemplo com JFormattedTextField");
setLayout(null);
rotulocep = new JLabel("CEP: ");
rotulotel = new JLabel("Telefone: ");
rotulocpf = new JLabel("CPF: ");
rotulodata = new JLabel("Data: ");
rotulocep.setBounds(50,40,100,20);
rotulotel.setBounds(50,80,100,20);
rotulocpf.setBounds(50,120,100,20);
rotulodata.setBounds(50,160,100,20);
try{
mascaracep.setPlaceholderCharacter('_');
mascaratel.setPlaceholderCharacter('_');
mascaracpf.setPlaceholderCharacter('_');
mascaradata.setPlaceholderCharacter('_');
}
cep.setBounds(150,40,150,20);
tel.setBounds(150,80,150,20);
cpf.setBounds(150,120,150,20);
data.setBounds(150,160,150,20);
cep.setForeground(Color.blue);
tel.setForeground(Color.red);
cpf.setForeground(Color.green);
data.setForeground(new Color(255,128,128));
cep.setBackground(Color.yellow);
tel.setBackground(Color.yellow);
cpf.setBackground(new Color(255,255,204));
data.setBackground(new Color(255,255,204));
cep.setFont(new Font("Times New Roman",Font.BOLD,14));
tel.setFont(new Font("Comic Sans MS",Font.PLAIN,14));
cpf.setFont(new Font("Arial",Font.BOLD,14));
data.setFont(new Font("Tahoma",Font.BOLD,14));
tela.add(rotulocep);
tela.add(rotulotel);
tela.add(rotulocpf);
tela.add(rotulodata);
tela.add(cep);
tela.add(tel);
tela.add(cpf);
tela.add(data);
setSize(400, 250);
setVisible(true);
}
ExemploJFormattedTextField app = new ExemploJFormattedTextField();
}
}
import java.awt.*;
public class ExemploJList extends JFrame{
JList lista;
JButton exibir;
JLabel rotulo;
public ExemploJList(){
setLayout(null);
}
}
);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
ExemploJList app = new ExemploJList();
}
}
import java.awt.*;
JList lista;
JButton exibir;
setLayout(null);
}
}
);
tela.add(exibir);
setSize(400, 250);
setVisible(true);
}
}
}
import java.awt.*;
JList lista;
JButton exibir;
JLabel rotulo;
setLayout(null);
lista.setForeground(Color.blue);
lista.setBackground(Color.yellow);
lista.setFont(new Font("Times New Roman",Font.BOLD,16));
}
}
);
tela.add(exibir);
tela.add(rotulo);
setSize(400, 250);
setVisible(true);
}
}
}
import java.awt.*;
public class ExemploJPasswordField extends JFrame{
JLabel rotulo;
public ExemploJPasswordField(){
setLayout(null);
tela.add(rotulo);
tela.add(caixa);
setSize(400, 250);
setVisible(true);
}
ExemploJPasswordField app = new ExemploJPasswordField();
}
}
import java.awt.*;
public class ExemploJTextArea extends JFrame{
JLabel rotulo;
JTextArea texto;
public ExemploJTextArea(){
tela.add(rotulo);
tela.add(texto);
setSize(400, 350);
setVisible(true);
}
ExemploJTextArea app = new ExemploJTextArea();
}
}
import java.awt.*;
JLabel rotulo;
JTextArea texto;
setLayout(null);
texto.setLineWrap(true);
texto.setWrapStyleWord(true);
tela.add(rotulo);
tela.add(texto);
setSize(400, 350);
setVisible(true);
}
}
}
import java.awt.*;
JLabel rotulo;
JTextArea texto;
JScrollPane painelrolagem;
JPanel painel;
painelrolagem = new JScrollPane(texto);
painelrolagem.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
painelrolagem.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAY
S);
tela.add(rotulo);
tela.add(painel);
setSize(300, 280);
setVisible(true);
}
}
}
import java.awt.*;
JLabel rotulo;
JTextArea texto;
texto.setBackground(Color.yellow);
texto.setFont(new Font("Comic Sans MS",Font.BOLD+Font.ITALIC,20));
tela.add(rotulo);
tela.add(texto);
setSize(400, 350);
setVisible(true);
}
}
}
import java.awt.*;
public class ExemploJTextField extends JFrame{
public ExemploJTextField (){
setLayout(null);
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
tela.add(texto1);
tela.add(texto2);
tela.add(texto3);
tela.add(texto4);
setSize(400, 250);
setVisible(true);
}
ExemploJTextField app = new ExemploJTextField();
}
}
import java.awt.*;
public class ExemploJTextFieldCorLetra extends JFrame{
public ExemploJTextFieldCorLetra (){
setLayout(null);

texto1.setForeground(Color.blue);
texto2.setForeground(Color.red);
texto3.setForeground(new Color(182,105,126));
texto4.setForeground(new Color(205,255,126));
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
tela.add(texto1);
tela.add(texto2);
tela.add(texto3);
tela.add(texto4);
setSize(400, 250);
setVisible(true);
}
ExemploJTextFieldCorLetra app = new ExemploJTextFieldCorLetra();
}
}
import java.awt.*;
public class ExemploJTextFieldFundo extends JFrame{
public ExemploJTextFieldFundo (){
setLayout(null);
texto1.setBackground(Color.yellow);
texto2.setBackground(Color.green);
texto3.setBackground(new Color(182,105,126));
texto4.setBackground(new Color(205,255,126));
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
tela.add(texto1);
tela.add(texto2);
tela.add(texto3);
tela.add(texto4);
setSize(400, 250);
setVisible(true);
}
ExemploJTextFieldFundo app = new ExemploJTextFieldFundo();
}
}
import javax.swing.event.*;
import java.awt.*;
public class ExemploLabel extends JFrame{
public ExemploLabel(){
setLayout(null);
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(rotulo3);
tela.add(rotulo4);
setSize(400, 250);
setVisible(true);
}
ExemploLabel app = new ExemploLabel();
}
}
import java.awt.*;
public class ExemploMinusculas extends JFrame{
public ExemploMinusculas(){
super("Exemplo de saídas minúsculas");
String texto;
texto = texto1.getText().toUpperCase();
texto1.setText(texto);
texto2.setText(texto1.getText().toLowerCase());}});
texto1.setText("");
texto2.setText("");
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(texto1);
tela.add(texto2);
tela.add(copiar);
tela.add(limpar);
setSize(300,200);
setVisible(true);
}
ExemploMinusculas app = new ExemploMinusculas();
}
}
import java.awt.*;
public class ExemploMaiusculas extends JFrame{
public ExemploMaiusculas(){
super("Exemplo de saídas maiúsculas");
texto2.setText(texto1.getText().toUpperCase());}});
texto1.setText("");
texto2.setText("");
tela.add(rotulo1);
tela.add(rotulo2);
tela.add(texto1);
tela.add(texto2);
tela.add(copiar);
tela.add(limpar);
setSize(300,200);
setVisible(true);
}
ExemploMaiusculas app = new ExemploMaiusculas();
}
}
import java.awt.*;
JButton exibir;
ButtonGroup grupo;
public ExemploRadioButton(){
super("Exemplo de um JRadioButton");
rotulo = new JLabel("Escolha uma cidade: ");
exibir = new JButton ("Exibir");
primeira = new JRadioButton("Rio de Janeiro");
segunda = new JRadioButton("São Paulo");
terceira = new JRadioButton("Minas Gerais");

quarta = new JRadioButton("Amazonas");
quinta = new JRadioButton("Rio Grande do Sul");
grupo.add(segunda);
grupo.add(quarta);
grupo.add(quinta);
rotulo2.setText("A cidade escolhida foi: "+primeira.getText());
rotulo2.setText("A cidade escolhida foi: "+segunda.getText());
rotulo2.setText("A cidade escolhida foi: "+terceira.getText());
rotulo2.setText("A cidade escolhida foi: "+quarta.getText());
rotulo2.setText("A cidade escolhida foi: "+quinta.getText());
}});
tela.add(rotulo);
tela.add(primeira);
tela.add(segunda);
tela.add(terceira);
tela.add(quarta);
tela.add(quinta);
tela.add(exibir);
tela.add(rotulo2);
setSize(500,300);
setVisible(true);
}
ExemploRadioButton app = new ExemploRadioButton();
}
}
import java.awt.*;
public class ExemploSplashScreen extends JFrame{
TelaInicial inicio;
JButton botaosair;
public ExemploSplashScreen(){
super("Exemplo de Splash Screen");
inicio = new TelaInicial();
System.exit(0);
} } );
setSize(300, 150);
}
ExemploSplashScreen app = new ExemploSplashScreen();
}
setVisible(true);
}
private class TelaInicial extends JWindow{
public TelaInicial(){
tela.add(rotulo);
setVisible(false);
dispose();
principal();}};
timer.start();
pack();
}
}
}
import java.awt.*;
public class ExemploTraduzir extends JFrame{
JButton botao;
public ExemploTraduzir(){
super("Exemplo Traduzir Botões");
tela.add(botao);
int opcao;
opcao = JOptionPane.showOptionDialog(null,"Deseja mesmo

fechar a
janela?","Fechar",JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE,null,b
otoes,botoes[0]);
System.exit(0);
}});
setSize(300,200);
setVisible(true);
}
ExemploTraduzir app = new ExemploTraduzir();
}
}
import java.awt.*;
import java.util.*;
import javax.swing.Timer;
public class Hora extends JFrame{
JLabel rotulo;
int hh,mm,ss,h;
Calendar hora;
DecimalFormat formato;
public Hora(){
super("Exemplo de Hora");
ActionListener tarefa = (new ActionListener(){
HORAS();
}
});
javax.swing.Timer time = new javax.swing.Timer(1000,tarefa);
time.start();
tela.add(rotulo);
setSize(300, 200);
setVisible(true);
}
Hora app = new Hora();
}
private void HORAS(){
hora = Calendar.getInstance();
hh = hora.get(Calendar.HOUR_OF_DAY);
mm = hora.get(Calendar.MINUTE);
ss = hora.get(Calendar.SECOND);
rotulo.setText("Hora: "+formatar(hh%12)+":"+formatar(mm)+":"+formatar(ss));
}
private String formatar(int num){

return formato.format(num);
}
}
import java.awt.*;
import java.sql.*;
public class Incluir extends JFrame{
JButton botao;
JLabel lnome, ltel1,ltel2,lcel;
JTextField tnome,ttel1,ttel2,tcel;
public Incluir(){
lnome = new JLabel("Nome: ");
ltel1 = new JLabel("Telefone 1: ");
ltel2 = new JLabel("Telefone 2: ");
lcel = new JLabel("Celular: ");
tnome = new JTextField(50);
ttel1 = new JTextField(15);
ttel2 = new JTextField(15);
tcel = new JTextField(15);
botao = new JButton("Incluir Registro");
lnome.setBounds(20,30,80,20);
ltel1.setBounds(20,70,80,20);
ltel2.setBounds(20,110,80,20);
lcel.setBounds(20,150,80,20);
tnome.setBounds(100,30,280,20);
ttel1.setBounds(100,70,100,20);
ttel2.setBounds(100,110,100,20);
tcel.setBounds(100,150,100,20);
tela.add(lnome);
tela.add(ltel1);
tela.add(ltel2);
tela.add(lcel);
tela.add(tnome);
tela.add(ttel1);
tela.add(ttel2);
tela.add(tcel);
tela.add(botao);
try {
String senha = "";
Connection con;
st.executeUpdate("INSERT INTO Cadastro (Nome, Telefone_1, Telefone_2,
Celular) VALUES
('"+tnome.getText()+"','"+ttel1.getText()+"','"+ttel2.getText()+"','"+tcel.getText()+"')");
tnome.setText("");
ttel1.setText("");
ttel2.setText("");
tcel.setText("");
tnome.requestFocus();
JOptionPane.showMessageDialog(null,"Registro Inserido Com
st.close();
con.close();
}
{
estabelecida","Mensagem do Programa",JOptionPane.ERROR_MESSAGE);
}
}});
setSize(400, 250);
setVisible(true);
}
Incluir app = new Incluir();
}
}
import java.awt.*;
import java.sql.*;
public class Incluir2 extends JFrame{
JButton botao;
String result;
public Incluir2(){
t1.setText("AutoNumeração S/V"); t1.setEnabled(false);
l2.setBounds(20,70,80,20); t2.setBounds(100,70,300,20); t2.requestFocus();
botao = new JButton("Incluir Registro"); botao.setBounds(110,270,150,20);
tela.add(botao);
try {
result = "1";
result = "0";
String senha = "";
Connection con;
st.executeUpdate("INSERT INTO Tabela1 (Nome, Idade, Dn, Sal, Def)
VALUES ('"+t2.getText()+"',"+t3.getText()+",#"+t4.getText()+"#,"+t5.getText()+","+result+")");
t1.setText(""); t2.setText(""); t3.setText(""); t4.setText(""); t5.setText("");t6.setText("");
t2.requestFocus();
JOptionPane.showMessageDialog(null,"Registro Inserido Com
st.close();
con.close();
}
{
}
}});
setSize(450, 350);
setVisible(true);
}
Incluir2 app = new Incluir2();
}
}
public class JanelaCentralizada extends JFrame{
public JanelaCentralizada(){
super("Janela Centralizada");
setSize(300, 150);
setVisible(true);
}
JanelaCentralizada app = new JanelaCentralizada();
}
}
public class JanelaMaximizada extends JFrame{
public JanelaMaximizada(){
super("Como exibir a janela maximizada");
setSize(300, 150);
setVisible(true);
setExtendedState(MAXIMIZED_BOTH);
}
JanelaMaximizada app = new JanelaMaximizada();
}
}
public class JanelaMinimizada extends JFrame{
public JanelaMinimizada(){
super("Como exibir a janela minimizada");
setSize(300, 150);
setVisible(true);
setExtendedState(ICONIFIED);
}
JanelaMinimizada app = new JanelaMinimizada();
}
}
import java.awt.*;
public class Limpar extends JFrame{
JButton limpar;
public Limpar(){
super("Exemplo Limpar");
setLayout(null);
rotulo1 = new JLabel("1º Número: "); rotulo2 = new JLabel("2º Número: ");
texto1 = new JTextField(5);texto2 = new JTextField(5);
limpar.addActionListener(
}
}
);
tela.add(limpar);
setSize(400, 250);
setVisible(true);
}
Limpar app = new Limpar();
}
}
import java.awt.*;
import java.sql.*;
public class ManipulacaoDeTabelas extends JFrame{

JButton botao,botao1;
JTextField texto;
JLabel rotulo;
public ManipulacaoDeTabelas(){
super("Manipulação de Tabelas");
rotulo = new JLabel("Entre com sua instrução: ");
texto = new JTextField(255);
botao = new JButton ("Executar Instrução SQL");
botao1 = new JButton ("Limpar");
tela.add(botao);
tela.add(botao1);
tela.add(rotulo);
tela.add(texto);
manipular();
}});
texto.setText("");
texto.requestFocus();
}});
setSize(400,200);
setVisible(true);
}
ManipulacaoDeTabelas app = new ManipulacaoDeTabelas();
}
private void manipular(){
try {
String senha = "";
Connection con;
st.executeUpdate(texto.getText());
JOptionPane.showMessageDialog(null,"Dados Criado Com
con.close();
}
{
Comandos Inválidos","Mensagem do Programa",JOptionPane.ERROR_MESSAGE);
}
}
}
import java.awt.*;
public class NovaJanela extends JFrame{
JButton abrir;
public NovaJanela(){
segundajanela = new Inicial();
setVisible(false);
dispose();}});
tela.add(abrir);
setSize(300, 150);
setVisible(true);
NovaJanela app = new NovaJanela();
JButton sair;
private Inicial(){
super("Menu Principal...");
tela.add(sair);
setSize(200,200);

}
}
import java.awt.*;
JButton abrir;
}});
tela.add(abrir);
setSize(300, 150);
setVisible(true);
JButton sair;
tela1.add(sair);
setSize(200,200);
}
}
import java.awt.*;
JButton abrir;
segundajanela = new Inicial(null,"Segunda Janela",false);
}});
tela.add(abrir);
setSize(300, 150);
setVisible(true);

JButton sair;
tela1.add(sair);
setSize(200,200);
}
}
import java.awt.*;
public class OcultarExibir extends JFrame{
JButton ocultar,exbir;
public OcultarExibir(){
super("Exemplo de ocultar e exibir componente");
setLayout(null);
ocultar = new JButton("Ocultar ");
exbir = new JButton("Exibir ");
ocultar.setBounds(100,100,80,20);
exbir.setBounds(250,100,80,20);
ocultar.addActionListener(
}
}
);
exbir.addActionListener(
}
}
);
tela.add(ocultar); tela.add(exbir);
setSize(400, 250);
setVisible(true);
}
OcultarExibir app = new OcultarExibir();
}
}
public class PrimeiraJanela extends JFrame{
setSize(300, 150);
setVisible(true);
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
public Relatorio(){
String senha = "";
try{
}
JOptionPane.showMessageDialog(null,"Conexão não estabelecida","Mensagem do
}
buscaTabela();
setSize(600,200);
setVisible(true);
}
Relatorio app = new Relatorio();
}
Statement st;
ResultSet res;
try{
res.next();
do{
}
while (res.next());
validate();
st.close();
}
}
}
try{
break;
break;
break;
}
}
}
return LinhaAtual;
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
public class Relatorio1 extends JFrame{
JLabel l;
JTextField t;
JButton b;
Inicial janela;
public Relatorio1(){
setLayout(null);
l = new JLabel("Nome: "); l.setBounds(20,20,100,20);
t = new JTextField(50); t.setBounds(20,50,250,20);
b = new JButton("Exibir Relatório"); b.setBounds(100,90,150,20);
tela.add(l);tela.add(t);tela.add(b);
b.addActionListener(new ActionListener(){
janela = new Inicial();
janela.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
janela.setVisible(true);
}});
setSize(400,200);
setVisible(true);
}
Relatorio1 app = new Relatorio1();
}
private Inicial(){
setSize(400,300);
String senha = "";
try
{
}
catch (Exception e)
{
}
buscaTabela();
}
Statement st;
ResultSet res;
try {
res = st.executeQuery("SELECT * FROM Nomes WHERE Nome
LIKE'%"+t.getText()+"%'");
res.next();
do
{
}
while (res.next());
validate();
st.close();
}
catch (SQLException sqlex) {
}
}
private Vector proximaLinha(ResultSet rs, ResultSetMetaData rsmd )
{
try
{
switch(rsmd.getColumnType(i))
{
break;
break;
case Types.INTEGER: LinhaAtual.addElement(new Long(rs.getLong(i)));
break;
}
}
catch(SQLException e) {
}
return LinhaAtual;
}
}
}
import java.awt.*;
import java.sql.*;
import java.util.*;
public class Relatorio2 extends JFrame{
public Relatorio2(){
String senha = "";
try{
}
}
buscaTabela();
setSize(600,200);
setVisible(true);
}
Relatorio2 app = new Relatorio2();
}
Statement st;
ResultSet res;
try{
res = st.executeQuery("SELECT
Tabela1.Cod,Tabela1.Nome,Tabela1.Idade,Tabela1.Dn,Tabela1.Sal,Tabela1.Def,Cadastro.Tel
efone_1,Cadastro.Telefone_2,Cadastro.Celular FROM Cadastro, Tabela1 WHERE
Cadastro.Nome=Tabela1.Nome");
res.next();
do{
}
while (res.next());
JScrollPane scroller = new JScrollPane( tabela ) ;
validate();
st.close();
}
}
}
try{
break;
case Types.INTEGER: LinhaAtual.addElement(new Long(rs.getLong(i)));
break;
break;
case Types.NUMERIC: LinhaAtual.addElement(rs.getDouble(i));
break;
case Types.BIT: LinhaAtual.addElement(rs.getByte(i));
break;
}
}
}
return LinhaAtual;
}
}
import java.awt.*;
public class SenhaDigitada extends JFrame{
JLabel rotulo, exibir;
JButton mostrar;
public SenhaDigitada(){
setLayout(null);
exibir = new JLabel("A senha digitada é: ");
mostrar = new JButton("Mostrar");
mostrar.setBounds(150,100,80,20);
mostrar.addActionListener(
String senha = new String(caixa.getPassword());
exibir.setText(senha);
}
}
);
tela.add(rotulo);
tela.add(caixa);
tela.add(exibir);
tela.add(mostrar);
setSize(400, 250);
setVisible(true);
}
SenhaDigitada app = new SenhaDigitada();
}
}
import java.awt.*;
public class Soma extends JFrame{
JLabel rotulo1, rotulo2,exibir;
JButton somar;
public Soma(){
super("Exemplo de soma");
setLayout(null);
rotulo1 = new JLabel("1º Número: "); rotulo2 = new JLabel("2º Número: ");
texto1 = new JTextField(5);texto2 = new JTextField(5);
exibir = new JLabel(""); somar = new JButton("Somar");
exibir.setBounds(50,120,200,20); somar.setBounds(150,100,80,20);
somar.addActionListener(
int numero1,numero2,soma;
soma=0;
soma = numero1 + numero2;
}
}
);
tela.add(exibir); tela.add(somar);
setSize(400, 250);
setVisible(true);
}
Soma app = new Soma();

}
}
public class TamanhoFixo extends JFrame{
public TamanhoFixo(){
super("Uma janela não dimensionável");
setResizable(false);
setSize(300, 150);
setVisible(true);
}
TamanhoFixo app = new TamanhoFixo();
}
}
import java.awt.*;
import java.sql.*;
public class TestaConexao extends JFrame{
JButton botao;
public TestaConexao(){
super("Testando a Conexão...");
botao = new JButton("Verificar Conexão");
try {
String senha = "";
Connection con;
JOptionPane.showMessageDialog(null,"Conexão estabelecida","Mensagem do
Programa",JOptionPane.INFORMATION_MESSAGE);
con.close();
}
{
estabelecida","Mensagem do Programa",JOptionPane.ERROR_MESSAGE);
}
}});
tela.add(botao);
setSize(300, 150);
setVisible(true);
}
TestaConexao app = new TestaConexao();
}
}

Apostila Java 2 Com Banco de Dados

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Apostila Java 2 Com Banco de Dados

Hochgeladen von

Copyright:

Verfügbare Formate

A p o s t i l a d e J a v a 2 C o m B a n c o d e D a d o s

Apostila de Java 2 Com Banco de Dados

2 – O que é preciso para programar em Java?

3 – Conceitos fundamentais de Programação em Java

4 – Introdução a interface gráficas em Java

5 – Adicionando componentes JLabel ou rótulos na sua janela

6 – Adicionando componentes JTextField ou caixa de texto

6.4 – Alinhamento do texto de uma caixa de texto

7 – Adicionando componentes JButton ou botões a sua janela

8 - Adicionando componentes JPasswordField

9 – Controle JFormattedTextField para data, telefone, CEP, CPF

10 – Fazendo um JButton executar uma ação

11 – Apresentando a classe JList

12 – uso da classe JComboBox na criação de caixas de combinação

13. Entendimento e uso da classe JCheckBox

14 – Uso da Classe JRadioButton para criar botões de opção

15 – Fazendo um aplicativo com ComboBox CheckBox RadioButton

16 – Como adicionar dica aos seus botões

17 – Tipos de diálogos fornecidos pela classe JOptionPane

19 – Adicionando Data nos seus aplicativos

20 – Adicionando Horas ao seu aplicativo

21 – Entendimento da classe JTextArea

21 – Entendimento da classe JTextArea

22 – Adicionando menus a um aplicativo Java

23 – Criando um menu de contexto – Classe JPopupMenu

24 – Uso da classe JToolBar para criar barra de ferramentas

25 – Como criar janelas secundárias com o uso da classe JDialog

26 – Uso da Classe JWindow para criar uma Splash Screen

27 – Banco de Dados Relacionais

30 – SQL – Java & Banco de Dados - Considerações Iniciais

1.1 – Java: O que é?

O que faz ser tão especial a ponto de atrair a atenção da imprensa e

Java é totalmente orientada a objetos é sua parente mais próxima é a

1.2 – Java: Como surgiu?

Java é ao mesmo tempo uma linguagem e um ambiente de programação.

O principal responsável pelo desenvolvimento da linguagem Java foi o

Atualmente o ambiente Java se apresenta de diversas formas, cabendo ao

1.3 – Java: Funcionamento

Java é uma linguagem de programação totalmente orientada a objetos. Seu

O diagrama seguinte ilustra o assunto. A independência de plataforma é a

2 – O que é preciso para programar em Java?

Uma das grandes vantagens de programar em Java e também um motivo que

O ambiente de desenvolvimento em si atende pelo nome de JDK – Java

Development Environment, pois o JDK/SDK trabalha em uma janela do

Todos os exercícios desta apostila foram testados em duas configurações:

2.1 – Baixando o WinZip

Baixe o Winzip a partir do site www.winzip.com. Usuários do Windows XP não

2.2 – Baixando o JDK/SDK

Baixe o JDK/SDK a partir do site java.sun.com. Tenha certeza de esta

2.3 – Baixando a documentação do JDK/SDK

A instalação da documentação do JDK/SDK é opcional, mas muito útil não só a

2.4 – Baixando o JCreator

O JCreator é um programa da categoria IDE – Integrated Development

Baixe o JCreator LE que é gratuito e atende as nossas necessidades.

2.5 – Configurando o JCreator

Depois de instalado é hora de configurar o JCreator, quando você iniciar o

Caso o JCreator não localize automaticamente a pasta na qual você instalou o

Se você instalou a documentação do JDK/SDK, clique no Browse para localiza-

Tela inicial do JCreator

2.6 – Testando o funcionamento do JDK/SDK e do JCreator

Para testar, tanto o JDK/SDK quando o JCreator, vamos iniciar um arquivo

A linguagem Java diferencia letras maiúsculas de minúsculas. O “A” e o “a”, em

Depois que você digitou o código, é preciso compilá-lo. Compilar um programa