2132_Java 2 com Banco Dados

(1)

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

(2)

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

(3)

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

(4)

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

(5)

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.

(6)

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. Código Fonte Arquivo.java Compilador Java Binário Java Arquivo.class Interpretador Java (runtime Java ou JVM – Java Virtual Machine/Máquina Virtual Java) O código fonte é um arquivo digitado em qualquer editor de texto puro e salvo

com extensão .Java

Compilador Javac

O compilador Java gera um arquivo binário com o

mesmo nome do arquivo gravado com a extensão. Java. Esse arquivo é o

programa em Java e pode ser executado em

qualquer máquina que possua a Java Virtual

Machine instalada. É como se tivéssemos um computador dentro do outro (emulador). JVM para WIN32 JVM para SOLARIS JVM para Linux

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

(7)

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.

(8)

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 instalocaliza-lação do JDK/SDK. Depois de localizada corretamente, clique em Finish para concluir o processo de configuração do

(9)

JCreator. Da próxima vez que for executado, estes procedimentos não serão mais executados.

(10)

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

(11)

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.

(12)

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:

Digitação do Código .Java Início Depuração sim não Problemas na compilação? Executar .class Compilar .class

(13)

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.

(14)

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

(15)

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”; String valor2 = “20”; String valor3 = “30”; 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: String valor1 = “10”;

String valor2 = “20”; String valor3 = “30”;

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;

(16)

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 Maior que A < B A > B <= >= Menor ou igual Maior ou igual A <= B 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.

(17)

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 Button

List Containe Label

r

CheckBox Window

(18)

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 Button List Labe l Containe r CheckBox Window

(19)

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 import javax.swing.*;

public class PrimeiraJanela extends JFrame{ public PrimeiraJanela(){

super("Nossa primeira janela"); setSize(300, 150);

setVisible(true); }

public static void main(String args[]){

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 {

public PrimeiraJanela(){

super("Nossa primeira janela"); setSize(300, 150);

(20)

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

{

PrimeiraJanela app = new PrimeiraJanela();

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

HIDE_ON_CLOSE

Faz com que a janela seja apenas ocultada quando o usuário tentar fechar o aplicativo, ou seja, o programa 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.

DO_NOTHING_ON_CLOSE

Faz com que o usuário não seja capaz de fechar a janela. Neste caso você deve efetuar algum processamento e fechar a janela, baseado em alguma ação específica no seu código.

DISPOSE_ON_CLOSE

Libera, ou seja, retira da memória, tanto a janela do aplicativo quanto seus componentes. A diferença entre este valor e HIDE_ON_CLOSE é que o primeiro oculta a janela e só então libera da memória.

(21)

4.2 - Janela Maximizada: setExtendedState(MAXIMIZED_BOTH); import javax.swing.*;

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); import javax.swing.*;

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: import javax.swing.*;

public class TamanhoFixo extends JFrame{ public TamanhoFixo(){

super("Uma janela não dimensionável"); setResizable(false);

setSize(300, 150); setVisible(true); }

public static void main(String args[]){ TamanhoFixo app = new TamanhoFixo();

(22)

4.5 – Janela Centralizada: setLocationRelativeTo(null); import javax.swing.*;

public class JanelaCentralizada extends JFrame{ public JanelaCentralizada (){ super("Janela Centralizada"); setSize(300, 150); setVisible(true); setLocationRelativeTo(null); }

JanelaCentralizada app = new JanelaCentralizada (); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }

}

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 javax.swing.*; 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); }

public static void main(String args[]){ CorDeFundo app = new CorDeFundo();

(23)

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:

tela.setBackground(Color.blue);

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 javax.swing.*; import java.awt.*;

public class CorDeFundo2 extends JFrame{ public CorDeFundo2(){

super("Definindo a cor de fundo para a janela"); Container tela = getContentPane();

tela.setBackground(new Color(255,128,128)); setSize(500, 100);

setVisible(true); }

CorDeFundo2 app = new CorDeFundo2();

app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } tela.setBackground(new Color(255,128,128)); tela.setBackground(new Color(255,228,228)); tela.setBackground(new Color(255,255,204));

(24)

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

public static void main(String args[]){ 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");

setIconImage(icone.getImage());

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:

ImageIcon icone = new ImageIcon("teste.gif"); 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

(25)

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:

public class ExemploLabel extends JFrame{ JLabel rotulo1,rotulo2,rotulo3,rotulo4; public ExemploLabel(){

super("Exemplo com Label"); Container tela = getContentPane(); setLayout(null);

rotulo1 = new JLabel ("Nome"); rotulo2 = new JLabel ("Idade"); rotulo3 = new JLabel ("Telefone"); rotulo4 = new JLabel ("Celular"); rotulo1.setBounds(50,20,80,20); rotulo2.setBounds(50,60,80,20); rotulo3.setBounds(50,100,80,20); rotulo4.setBounds(50,140,80,20); rotulo1.setForeground(Color.red); rotulo2.setForeground(Color.blue); rotulo3.setForeground(new Color(190,152,142)); rotulo4.setForeground(new Color(201,200,100)); 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); setLocationRelativeTo(null); }

ExemploLabel app = new ExemploLabel();

}

(26)

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:

5.1 - Apos fazermos as importações vamos criar os objetos do tipo JLabel: JLabel rotulo1,rotulo2,rotulo3,rotulo4;

5.2 - Em seguida atribuir o conteúdo ao JLabel: rotulo1 = new JLabel ("Nome"); rotulo2 = new JLabel ("Idade"); rotulo3 = new JLabel ("Telefone"); rotulo4 = new JLabel ("Celular");

5.3 - Próximo passo definir o largura e altura do JLabel e a coluna e a linha que ele irá ocupar na janela.

rotulo1.setBounds(50,20,80,20); rotulo2.setBounds(50,60,80,20); rotulo3.setBounds(50,100,80,20); rotulo4.setBounds(50,140,80,20);

50 – Coluna, 20 – linha, 80 – largura, 20 - comprimento

Linha 20 Linha 60 Linha 100 Linha 140 Comprimento 80 Altura 20

(27)

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.

rotulo1.setForeground(Color.red); rotulo2.setForeground(Color.blue);

5.5 - Esses dois trechos abaixo especifica como criar cores personalizadas para o componente JLabel.

rotulo3.setForeground(new Color(190,152,142)); rotulo4.setForeground(new Color(201,200,100));

5.6 - E ainda podemos definir a fonte, o estilo e o tamanho da letra do componente JLabel.

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

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.

rotulo1.setFont(new Font("Arial",Font.BOLD,14));

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

(28)

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:

public class LabelImagem extends JFrame{ JLabel imagem;

public LabelImagem(){

super("Uso da classe JLabel com Imagem"); Container tela = getContentPane();

ImageIcon icone = new ImageIcon("sapo.jpeg"); imagem = new JLabel(icone);

tela.add(imagem); setSize(500, 460); setVisible(true); }

public static void main(String args[]){ LabelImagem app = new LabelImagem();

(29)

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.

public class ExemploJTextField extends JFrame{ JLabel rotulo1,rotulo2,rotulo3,rotulo4;

JTextField texto1,texto2,texto3,texto4; public ExemploJTextField (){

super("Exemplo com JTextField"); Container tela = getContentPane(); setLayout(null);

rotulo1 = new JLabel ("Nome"); rotulo2 = new JLabel ("Idade"); rotulo3 = new JLabel ("Telefone"); rotulo4 = new JLabel ("Celular"); texto1 = new JTextField(50); texto2 = new JTextField(3); texto3 = new JTextField(10); texto4 = new JTextField(10); rotulo1.setBounds(50,20,80,20); rotulo2.setBounds(50,60,80,20); rotulo3.setBounds(50,100,80,20); rotulo4.setBounds(50,140,80,20); texto1.setBounds(110,20,200,20); texto2.setBounds(110,60,20,20); texto3.setBounds(110,100,80,20); texto4.setBounds(110,140,80,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); setLocationRelativeTo(null); }

ExemploJTextField app = new ExemploJTextField();

}

Vejamos agora os trechos principais que fazem com que as caixas de texto apareçam na janela.

(30)

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:

texto1.setBounds(110,20,200,20); texto2.setBounds(110,60,20,20); texto3.setBounds(110,100,80,20); texto4.setBounds(110,140,80,20);

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

(31)

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

import java.awt.*;

public class ExemploBotao extends JFrame{ JButton botão;

public ExemploBotao(){

super("Exemplo com JButton"); Container tela = getContentPane(); setLayout(null);

botao = new JButton ("Procurar"); botao.setBounds(50,20,100,20); tela.add(botao);

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

public class ExemploBotao extends JFrame{ JButton botao;

ImageIcon icone; public ExemploBotao(){

icone = new ImageIcon("abrir.gif"); botao = new JButton ("Abrir",icone); botao.setBounds(50,20,100,20); tela.add(botao);

(32)

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: import java.awt.event.*;

public class ExemploBotao extends JFrame{ JButton botao;

ImageIcon icone; public ExemploBotao(){

icone = new ImageIcon("abrir.gif"); botao = new JButton (icone);

botao.setBounds(50,20,100,20); tela.add(botao); setSize(400, 250); setVisible(true); setLocationRelativeTo(null); }

}

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

(33)

7.4 – Adicionando vários botões na janela Veja o exemplo:

import javax.swing.*; import java.awt.*; import java.awt.event.*;

public class ExemploBotao extends JFrame{ JButton botao1,botao2,botao3,botao4; public ExemploBotao(){

botao1 = new JButton ("Procurar"); botao2 = new JButton ("Voltar >>"); botao3 = new JButton ("Próximo >>"); botao4 = new JButton ("Abrir");

botao1.setBounds(50,20,100,20); botao2.setBounds(50,60,100,20); botao3.setBounds(50,100,100,20); botao4.setBounds(50,140,100,20); tela.add(botao1); tela.add(botao2); tela.add(botao3); tela.add(botao4); setSize(400, 250); setVisible(true); }

(34)

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

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

(35)

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:

(36)

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

import java.awt.*; import java.awt.event.*;

public class ExemploJPasswordField extends JFrame{ JPasswordField caixa;

JLabel rotulo;

public ExemploJPasswordField(){ super("Exemplo com JPasswordField"); Container tela = getContentPane(); 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(); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }

}

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

(37)

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

(38)

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.*; import javax.swing.text.*; import java.awt.*;

import java.awt.event.*; 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"); Container tela = getContentPane();

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

(39)

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(); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

} }

Para construir o exemplo, usamos as variáveis globais: FormattedTextField cep,tel, cpf, data;

MaskFormatter mascaracep,mascaratel, mascaracpf, mascaradata; O código que inicializa a máscara foi inserido em um bloco try{ } de modo a evitar uma exceção:

try{

mascaracep = new MaskFormatter("#####-###"); mascaratel = new MaskFormatter("(##)####-####"); mascaracpf = new MaskFormatter("#########-##"); mascaradata = new MaskFormatter("##/##/####");

mascaracep.setPlaceholderCharacter(‘_’); mascaratel.setPlaceholderCharacter(‘_’); mascaracpf.setPlaceholderCharacter(‘_’); mascaradata.setPlaceholderCharacter(‘_’); } catch(ParseException excp){}

(40)

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:

cep = new JFormattedTextField(mascaracep); tel = new JFormattedTextField(mascaratel); cpf = new JFormattedTextField(mascaracpf); data = new JFormattedTextField(mascaradata); 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:

(41)

10 – Fazendo um JButton executar uma ação 10.1 – Clicando no botão para fechar uma janela Exemplo:

public class ExemploBotaoSair extends JFrame{ JButton botaosair;

public ExemploBotaoSair(){ super("Exemplo com JButton"); Container tela = getContentPane(); 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

(42)

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:

botaosair.addActionListener( new ActionListener(){

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( new ActionListener(){

} } );

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:

public class SenhaDigitada extends JFrame{ JPasswordField caixa;

JLabel rotulo, exibir; JButton mostrar; public SenhaDigitada(){

super("Exemplo com JPasswordField"); Container tela = getContentPane(); setLayout(null);

(43)

rotulo = new JLabel("Senha: "); caixa = new JPasswordField(10);

exibir = new JLabel("A senha digitada é: "); mostrar = new JButton("Mostrar");

exibir.setVisible(false); rotulo.setBounds(50,20,100,20); caixa.setBounds(50,60,200,20); exibir.setBounds(50,120,200,20); mostrar.setBounds(150,100,80,20); mostrar.addActionListener( new ActionListener(){

public void actionPerformed(ActionEvent e){ 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.

(44)

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 javax.swing.*; import java.awt.*; import java.awt.event.*;

public class Soma extends JFrame{ JLabel rotulo1, rotulo2,exibir; JTextField texto1,texto2; JButton somar;

public Soma(){

super("Exemplo de soma");

Container tela = getContentPane(); 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"); 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( new ActionListener(){

public void actionPerformed(ActionEvent e){ int numero1,numero2,soma;

soma=0;

numero1 = Integer.parseInt(texto1.getText()); numero2 = Integer.parseInt(texto2.getText()); soma = numero1 + numero2;

exibir.setVisible(true);

exibir.setText("A soma é: "+soma);

} } ); exibir.setVisible(false); tela.add(rotulo1); tela.add(rotulo2); tela.add(texto1); tela.add(texto2); tela.add(exibir); tela.add(somar); setSize(400, 250);