Apostila Programação I - Java básico

Prévia do material em texto

FVC – FACULDADE VALE DO CRICARÉ 
LINGUAGEM DE 
PROGRAMAÇÃO I 
Do fluxograma a programação em Java 
 
Douglas Tybel 
28/10/2010 
 
 
Data Versão da Revisão Descrição da Revisão Autor 
11/11/2012 1.0 Alunos que auxiliaram na revisão: 
Isis Pereira 
Douglas Tybel 
08/12/2012 1.1 Código fonte do exemplo com 
JCombobox adicionado. 
Douglas Tybel 
 
Este documento contém material desenvolvido pelo professor Douglas Tybel da Faculdade 
Vale do Cricaré em São Mateus/ES. Esta apostila tem como objetivo facilitar o ensino da 
disciplina com base em muitos livros e experiência do professor. 
 
2 
 
O QUE É JAVA ? .......................................................................................................................... 3 
VARIÁVEIS – ENTENDA COMO DECLARAR ............................................................................ 5 
ESCOPO – VISIBILIDADE DE SEU CÓDIGO ....................................................................................... 5 
MODIFICADOR STATIC .................................................................................................................. 6 
TIPOS DE DADOS – COMO DISTINGUIR ........................................................................................... 7 
DECLARAÇÃO DE VARIÁVEL ........................................................................................................... 9 
FLUXOGRAMA - TRANSFORME FLUXOGRAMA EM CODIGOS JAVA ................................ 10 
SEQUENCIAL – CÓDIGOS COMUNS DOS PROCESSAMENTOS .......................................................... 10 
CONTROLE DE DECISÃO – COMANDO IF ...................................................................................... 11 
CONTROLE DE REPETIÇÃO – COMANDO WHILE ............................................................................ 13 
CONTROLE DE REPETIÇÃO – COMANDO FOR .............................................................................. 14 
CONTROLE DE REPETIÇÃO – COMANDO SWITCH ....................................................................... 15 
EXEMPLOS DE FLUXOGRAMAS – INTERAGINDO COM SWINGS NETBEANS .................. 16 
FLUXOGRAMA PARA HABILITAR CAMPO – COMPONENTE JCHECKBOX ............................................ 16 
FLUXOGRAMA MASCARA CPF E CNPJ – COMPONENTE JFORMATTEDTEXTFIELD .......................... 17 
FLUXOGRAMA PREENCHER COMBO COM ANOS – COMPONENTE JCOMBOBOX ............................... 21 
PRINCIPAIS COMPONENTES SWINGS - MÉTODOS COMUNS ............................................ 24 
RÓTULO – O COMPONENTE JTEXTFIELD ..................................................................................... 25 
BUTTON – O COMPONENTE JBUTTON .......................................................................................... 25 
CAIXA DE COMBINAÇÃO – O COMPONENTE JCOMBOBOX .............................................................. 28 
CAMPO FORMATADO – O COMPONENTE JFORMATTEDTEXTFIELD ................................................. 29 
TABELA – O COMPONENTE JTABLE ............................................................................................. 30 
FORMULÁRIO – O COMPONENTE JFRAME .................................................................................... 32 
A CLASSE JOPTIONPANE – INTERAGINDO COM USUÁRIO ............................................... 33 
BIBLIOGRAFIA........................................................................................................................... 36 
 
 
3 
 
O QUE É JAVA ? 
 
A Sun Microsystems, uma empresa mundialmente conhecida no ramo de servidores de rede de 
computadores, tentou desenvolver uma plataforma de programação para hardwares. A ideia 
era criar um Controle Remoto Universal que poderia, à distância, controlar todos os aparelhos 
eletrodomésticos e computadores de uma residência, alem de permitir outras facilidades. 
Dentro da Sun ficou conhecida como “Projeto Green”, iniciado em dezembro de 1990 por 
Patrick Naughton, Mike Sheridan e James Gosling. (ANSELMO, 2005) 
Para o nome da linguagem conta-se que a equipe de desenvolvimento visitou uma cafeteria 
local, o nome “Java” (cidade de origem de um tipo de café importado) foi sugerido e “pegou”. 
As características da linguagem Java são: 
• Orientada a Objetos – Pode-se aplicar todos os conceitos de Orientação a Objetos 
conhecidos, incluindo abstração, herança, polimorfismo, encapsulamento, classes e 
reuso. 
• Robusta e Segura – Suporte a múltiplas camadas e execuções dos processos 
envolvidos (multithreading) e definição de classes que protegem o SO, além do 
ambiente que a além do ambiente que a linguagem está rodando. 
• Distribuída e Portátil – Práticas de processamento de objetos de forma distribuída, ou 
seja, um objeto pode estar em uma máquina e ser acessado por outra à distancia. A 
linguagem pode ser executada de celulares a mainframes. 
• Arquitetura Neutra – Baseada nos princípios do C++, deixou de lado coisas como 
múltipla herança para simplicidade do código escrito, possui nas classes somente uma 
porta de entrada. 
• Interpretada, mas de Alta Performance – Não gera os chamados executáveis, 
rodando sobre a Máquina Virtual Java(JVM) com interpreação dos Bytecodes. 
• Simples – Possui apenas seis comandos: dois de decisão, três de repetição e um para 
proteção do código. 
Mas tome cuidado, pois a linguagem Java é totalmente case sensitive, ou seja, diferencia os 
caracteres maiúsculos dos minúsculos. Desse modo, uma classe com o nome Math é 
totalmente diferente de uma classe com o nome math. 
Os arquivos Java tem extensão “.java” e dentro desta, segue o seguinte escopo: 
1. Definição do seu pacote; 
2. Definição de Importações de outros pacotes; 
3. Definição da classe; 
Um pacote é um conjunto de classes do mesmo tipo que podem ser agrupadas de modo a 
garantir diferentes formas de acesso, por exemplo: Pacote de Classes da Contabilidade, 
Pacote de Classes Utilitárias, Pacote de Classes do Financeiro. Nestes pacotes podemos ter 
dados restritos a quem pertence exclusivamente a ele. (ANSELMO, 2005) 
Na linguagem Java, utiliza-se a palavra-chave package para definir o pacote da seguinte 
maneira: 
Package contabilidade; 
Toda instrução em linguagem Java deve terminar obrigatoriamente com um ponto-e-vírgula(;). 
Veja na Figura1 – Como o Java funciona: 
 
4 
 
 
Figura 1 - Como o Java funciona 
Fonte: Própria(2012) 
 
O código fonte do projeto Java é salvo em arquivos com extensão “.java” com linguagem de 
alto nível, isso quer dizer que os homens conseguem entender. Seguindo a Figura 1, o próximo 
passo é transformar esse código em uma linguagem de baixo nível para extensão “.class”, 
neste caso significa que os códigos “.java” foram compilados para outros que as máquinas 
entendam. Os chamados Byte Code foram a grande ideia do Java, isso talvez seja o motivo de 
seu sucesso, uma vez que possibilita sua portabilidade entre plataformas. Entenda a ideia 
posta aqui, isso porque em qualquer que seja a plataforma, basta instalar Java Vitual 
Machine(JVM). 
O código está em Byte Code e apenas JVM podem lê-las, isso significa que essa maquina 
virtual Java pode ser instalada em qualquer plataforma e ainda sim entender os Byte Code 
executando aplicativos Java normalmente. 
Para facilitar o aprendizado do Java, é imprescindível que o estudante tenha conhecimento de 
fluxogramas, pois deste modo a transformação da lógica para o código Java fica ainda mais 
simples. 
 
 
5 
 
VARIÁVEIS – ENTENDA COMO DECLARAR 
 
Seguindo a linguagem de programação Orientada a Objetos, consideramos que os objetos tem 
como parte integrante a sua totalidade os seus atributos. Esses atributos nada mais são que 
variáveis. A declaração de uma variavel para atributo é bem simples, vejamos alguns dos tipos 
e como declará-las. 
Os atributos são criadosa partir de um tipo primitivo, este poderá ser em sua maioria: 
• boolean – Tipo lógico com valores true ou false; 
• char – Tipo caractere com valores entre 0 a 216 -1; 
• byte – Tipo inteiro com valores entre -27 a 27 -1; 
• short – Tipo inteiro com valores entre -231 a 215-1; 
• int – Tipo inteiro com valores entre -231 a 231 -1; 
• long – Tipo inteiro com valores entre -263 a 263 -1; 
• float – Tipo numérico flutuante (32 bits); 
• double – Tipo numérico flutuante (64 bits) 
 
Escopo – Visibilidade de seu código 
 
Os atributos e variáveis fazem parte de um escopo que é utilizado para definir o tipo de acesso 
que terá determinado atributo, classe ou objeto. Uma parte ficará totalmente escondida e 
restrita, e a outra servirá apenas ao pacote de classes que a classe que o definiu pertence, e 
uma última parte tem seu acesso tratado com as seguintes palavras-chave: 
• public: Qualquer classe, de qualquer pacote, tem acesso a este. 
• protected: Apenas as classes do mesmo pacote possuem acesso a este. 
• private: Apenas a própria classe poderá acessar este. 
Veja como definir variáveis ou atributos com escopo: 
public int c; //Atributo público de nome c do tipo inteiro. 
protected double b; //Atributo protegido de nome b do tipo double. 
private boolean a; //Atributo particular de nome a do tipo boolean 
A sintaxe completa da definição de um atributo ou declaração de uma variável em Java é: 
escopo tipoPrimitivo nomeVariavel = valorInicial; 
ou seja, poderíamos ter o seguinte conjunto de atributos ou variáveis: 
boolean a = false; 
char b = ‘A’; 
byte c = 1; 
short d = 2; 
int e = 3; 
long f = 4L; 
float g = 1.0F; 
double d = 1.0; 
 
 
6 
 
Uma variavel também pode ser declarada sem um valor inicial, como por exemplo: 
boolean a; 
char b; 
 
Só depois poderia ser atribuído valor, desta forma por exemplo: 
boolean a; 
boolean = true; 
ou 
char b; 
char b = ‘A’; 
 
Ambas as formas estão corretas, como usá-las dependerá da necessidade do programador. 
 
Modificador Static 
 
Existem as variáveis locais e globais, uma vez que o que diferencia as duas é que a local só 
existe dentro de seu fluxo(função) e a global existirá para todos as funções. 
Para acessar uma dessas variáveis quando se esta em outro formulário ou função, é 
necessário criar o objeto no qual a mesma esta inserido. Mas existe ainda o modificador 
“Static”. A variável com Static é chamada de: “variável estática” e pode ser acessada 
diretamente pelo nome da classe e não precisa de qualquer objeto. 
Sintaxe: <nome da classe>.<nome da variável> 
Veja um exemplo de declaração de uma variável estática: 
public static int codTopico; 
Vamos supor que esta declaração esteja em um frame chamado: jFReuniao que será 
responsável por gerenciar reuniões e, nela existe uma tabela com todos os tópicos desta 
reunião. Ao clicar em um dos tópicos, a variável codTopico é atribuído o código do tópico 
selecionado. 
Ao clicar em um botão que chama o formulário de tópicos, queremos filtrar pelo tópico recém 
clicado, para isso temos esta informação armazenada na variável publica e estática 
codTopico. No formulário de Históricos, no entanto para acessar essa variável, não é 
necessário criar nenhum objeto, apenas acessá-lo diretamente conforme código abaixo: 
jFReuniao.codTopico; 
Em que JFreuniao é o <nome da classe> e codTopico seria o <nome da variável>. 
 
 
7 
 
Tipos de dados – Como distinguir 
 
As informações tratadas em um algoritmo podem ser classificadas em dois tipos: 
• Constantes: Não sofrem alterações com o decorrer do fluxo, como por exemplo, PI = 
3,1416. 
• Variáveis: Há possibilidade de serem alteradas em algum instante no decorrer do fluxo. 
Exemplo: Uma nota, valor, data, saldo e etc. 
Diante das situações de programação, as linguagens já têm como base os tipos primitivos, 
segundo (BERG & FIGUEIRÓ, 2006, p. 33), são: 
• Numérico – toda informação numérica que pertença ao conjunto dos números relativos 
(negativos, nulos, positivos), por exemplo, a quantidade de alunos de uma sala. Bem 
como toda a informação numérica que pertença ao conjunto dos números reais 
(negativos, positivos, nulos), por exemplo, o preço de um produto. 
• Caracter – toda a informação composta por um ou mais caracteres alfanuméricos 
(0..9,A..Z,a..z) e/ou caracteres especiais (#,/,$,%,*,?,~,>,!,@...). 
Obs.: o espaço é considerado caracter especial. 
• Lógico – toda a informação que pode ser assumir apenas duas situações (biestável, 
ou seja, dois estados). Exemplo: verdadeiro ou falso, aberto ou fechado. 
Existem alem dos tipos primitivos, a possibilidade de declarar variáveis de classe, isso é muito 
comum nas linguagens atuais, uma vez que, possibilita toda uma estrutura da classe através 
da variável, por exemplo: Em Java o tipo String é uma classe que substitui o uso de do tipo 
primitivo caracter. Se uma variável é declarada do tipo primitivo caracter, o seu conteúdo 
contempla o escopo informado em caracteres alfanuméricos, especiais e só, já a classe String 
possibilita a manipulação da informação lá contida, isso através dos métodos próprios da 
classe String, veja o exemplo deste uso: 
Transformar o conteúdo da variável em minúscula: 
• String email = "DTYBEL@yahoo.com.br"; 
• email.toLowerCase(); 
A variável “email” após a execução da segunda linha será convertida totalmente para 
minúscula, deste modo, sua saída será: dtybel@yahoo.com.br 
Continuando a mesma linha de raciocínio, para identificar um tipo de dado classe basta 
observar que a primeira letra é maiúscula, isso porque, as classe têm as inicias maiúsculas, 
veja algumas classes que não são tipos primitivos em Java: String,Integer,Float etc. Estas 
classes são chamadas de “Wrapper Class” 
Segundo (ANSELMO, 2005, p. 33), o principal método de utilização dos numéricos é o 
parseTipo.Então, convertendo uma String para os diversos tipos, por exemplo, teríamos: 
 
byte a = Byte.parseByte(“1”); 
short b = Short.parseShort(“1”); 
int c = Integer.ParseInt(“1”); 
long d = Long.ParseLong(“1”); 
float e = Float.parseFloat(“1”); 
double f = Double.ParseDouble(“1”); 
 
 
8 
 
O autor mostra acima como converter o texto “1” em diversos tipos de valores através do 
método parseTipo das Wrapper Class. 
Para converter tipos primitivos, basta informar entre parênteses usando o método conhecido 
como “Casting”, seu novo tipo de retorno. 
Para integer: 
 
long g = 10L; 
int i = (int) g; 
Para Double: 
double d = 10.99; 
byte b = (byte)d; 
 
Uma das classes mais importantes para a linguagem Java é a classe String.Com ela é 
possível escrever objetos que recebem conjuntos de caracteres da seguinte maneira: 
String a = “Curso ADS 2012/2”; 
A String é uma classe, pois ela pode ser associada a diversos métodos para a manipulação do 
valor que é atribuído em si. Tais como: 
• concat(Str) – Concatena Str com o objeto; 
• equals(Str) – Compara se duas Str são idênticas; 
• length() – Retorna o tamanho do objeto; 
• replace(ch1,ch2) – Troca de caracteres; 
• toLowerCase() – Letras em minúscula; 
• toUpperCase() – Letras em maiúscula; 
• trim() – Retira os espaços em branco. 
Observe o exemplo 1: 
O objetivo é declarar uma variável, atribuir um texto e contar quantos caracteres existem, 
segue abaixo o código: 
 //Declarar variável a com Nome 
 String a = "Douglas Tybel"; 
 //Declarar variavel quant_caracteres para receber a quantidade 
 int quant_caracteres = a.length(); 
 //Imprimir na tela o resultado 
 System.out.println("A quantidade de caracteres é "+ quant_caracteres); 
 
Saída: 
A quantidade de caracteres é 13 
Neste momento seu retorno será: 13, uma vez que o espaço também será contado. 
 
 
 
9 
 
Observe o exemplo 2: 
O objetivo é declarar uma variável, atribuirum texto e substituir a letra “L” por “R”, segue abaixo 
o código: 
 //Assuma que o Cebolinha dos quadrinhos disse a frase abaixo: 
 String a = "Adolo solvete de molango."; 
 //Substitui na variável a o L por R e atribui o novo valor a variavel a 
 a = a.replace("l", "r"); 
 //Imprimir na tela o resultado 
 System.out.println(a); 
Saída: 
Adoro sorvete de morango. 
 
Declaração de variável 
 
Para que certa informação fique armazenada temporariamente e que possibilite acesso rápido, 
por sua vez, tendo a possibilidade de alteração e manipulação, usamos as variáveis. 
Segundo (BERG & FIGUEIRÓ, 2006, pp. 34-35), a declaração de uma variável consiste em: 
• nome que a diferencia das demais; 
• tipo de dado associado, que indica o tipo de informação que poderá ser armazenada 
na variável; 
• conteúdo, que é o dado guardado na variável; 
• endereço, que a localiza na memória; 
 
O autor faz observações relevantes sobre as variáveis: 
1) O nome de uma variável é único em um algoritmo. 
2) O conteúdo de uma variável poderá ser um dado todo tipo usado na sua criação. 
3) O conteúdo de uma variável é substituído por outro conteúdo que lhe venha a ser 
atribuído. 
4) O uso do nome de uma variável em uma expressão significa o uso do seu conteúdo 
(naquele momento) dentro da expressão. 
5) O uso de um conteúdo de variável em uma expressão não modifica seu valor. 
 
Para a declaração da variável, de modo geral, basta definir seu tipo e nome, onde se tem certa 
liberdade na nomenclatura, todavia, existem alguns limites básicos a serem observados para 
que sua variável não seja confundida com comandos internos. 
Cada linguagem de programação tem suas próprias regras para formação do nome de uma 
variável, de modo geral, a regra básica é: Nome de uma variável pode ser composto por letras 
sem espaço, dígitos e até mesmo o underline (_), sendo que o primeiro caractere deve ser uma 
letra. 
 
 
10 
 
FLUXOGRAMA - TRANSFORME FLUXOGRAMA EM CODIGOS 
JAVA 
 
Sequencial – Códigos comuns dos processamentos 
 
Os processamentos são representados em fluxograma por um retângulo. Este será executado 
em sequencia de cima para baixo do ponto de partida até o fim sem desvios. 
Em um processamento normalmente ocorre uma declaração de variável e uma atribuição. 
 
Figura 2 - Exemplo algoritmo sequencial 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
Para melhor entendimento, assuma o exemplo que uma variável “data” receberá o retorno de 
uma função para obter a data de hoje, assim seu processamento seria: 
 
 
 
Podemos identificar no exemplo acima uma declaração e atribuição. 
Em processamentos também podem ocorrer cálculos e atribuições apenas, pois uma variável 
criada no processamento de cima estará disponível para o processamento de baixo, com 
ressalva para subfluxos, uma vez que estes devem receber seus parâmetros como variáveis de 
entrada. 
 
Obter a data de 
hoje 
1. Date hoje; 
2. hoje = obterDataHoje(); 
 
11 
 
Controle de decisão – Comando IF 
 
Fluxograma: Comando em Java 
 
 
 
if ( condição ){ 
 
 Comando “TRUE” se verdadeiro; 
 
} else { 
 
 Comando “ELSE” se falso; 
 
} 
 
 
if ( condição ){ 
 
 Comando 1 “TRUE” se verdadeiro; 
 Comando 2 “TRUE” se verdadeiro; 
 
 
} else { 
 
 Comando 1 “ELSE” se falso; 
 Comando 2 “ELSE” se falso; 
 
} 
 
 
if ( condição ){ 
 
 Comando 1 “TRUE” se verdadeiro; 
 Comando 2 “TRUE” se verdadeiro; 
 
 
} 
 
 
12 
 
 
float n1 = 7; 
float n2 = 9; 
 
float media; 
media = (n1+n2)/2; 
 
if ( media > 7 ) { 
 
System.out.println(“Aprovado”); 
 
} else { 
 
System.out.println(“Reprovado”); 
 
 
} 
 
Este é um dos comandos mais fáceis, acredita-se que seja por isso mesmo que a maioria das 
pessoas perde sua lógica, pois o maior número de erros ocorre exatamente aqui. Alguns 
detalhes devem ser drasticamente observados: os parênteses envolvendo uma condicional são 
obrigatórios, as chaves para os comandos só são obrigatórias em caso de mais de uma 
instrução, porém é ideal colocá-las em qualquer caso. (ANSELMO, 2005, p. 38) 
 
 
13 
 
Controle de Repetição – Comando While 
 
Este comando é responsável pelo chamado “Laço de Repetição”, isto é, repetirá todas as 
instruções que estiverem em torno deste repetidas vezes, obedecendo a uma determinada 
condição. Possui a seguinte estrutura: (ANSELMO, 2005) 
Fluxograma: Comando em Java 
 
 
 
while ( condição ){ 
 
 Comando se verdadeiro a repetir; 
 
} 
 
 
 
 
int quantChutes = 0; 
int chutesPermitidos = 10; 
 
 
while ( quantChutes <= ChutesPermitidos ){ 
 
 quantChutes++; 
 System.out.println(“Total é “+ quantChutes); 
 
} 
 
 
O resultado do fluxo acima seria: 
Total é 1 
Total é 2 
... 
Total é 10. 
 
 
 
14 
 
Controle de Repetição – Comando FOR 
 
Esse comando é considerado do tipo repetição contada, uma vez que exatamente por termos o 
seu total domínio (tanto quando ele começa como quando ele termina). (ANSELMO, 2005) 
Controlaremos sua repetição através de uma variável que será o contador, uma vez que 
deveremos iniciá-la com valor para um ponto de partida e a condição será o determinante para 
o fim do loop. 
Fluxograma: Comando em Java 
 
 
 
for ( inicial; condição; incremento ){ 
 
Comando 1 se condição for verdadeira a 
repetir; 
 
Comando 2 se condição for verdadeira a 
repetir; 
 
 
} 
 
 int quantParcelas = 3; 
 
 
for (int parcela = 0; parcela <= 
quantParcelas; parcela++ ){ 
 
System.out.println(“Enviando...”); 
 
System.out.println(“Parcela ”+ parcela + “ 
foi enviada com sucesso.”); 
 
 
} 
 
 
15 
 
Controle de Repetição – Comando SWITCH 
 
Pode-se dizer que este comando seria o substituto para um laço determinado de comandos IF. 
Uma vez que tomamos caminhos diferentes a cada escolha pré-definida. Sua sintaxe abrange 
a seguinte estrutura: 
 
Fluxograma: Comando em Java 
 
 
 
switch ( atributo ) { 
 
case valor1: 
 Comando 1; 
 break; 
case valor2: 
 Comando 2; 
 break; 
 
case valor3: 
 Comando 3; 
 break; 
 
case valor4: 
 Comando 4; 
 break; 
default: 
 Comando caso nenhum. 
 
} 
 
 
int num = 2; 
 
switch ( num ) { 
 
case 1: 
 System.out.println(“É impar”); 
 break; 
 
case 2: 
 System.out.println(“É Par”); 
 break; 
 
default: 
 System.out.println(“Número diferente 
de 1 e 2”); 
 
} 
 
 
16 
 
EXEMPLOS DE FLUXOGRAMAS – INTERAGINDO COM SWINGS 
NETBEANS 
 
Fluxograma para habilitar campo – Componente jCheckBox 
 
Crie no Netbeans um frame com um componente jCheckBox e outro chamado 
JFormattedTextField. O check(jCheckBox1) caso marcado habilitará o campo para o 
lançamento do valor do desconto, caso contrário desabilitará. Veja nas figuras abaixo como 
deve ser feito. 
 
Figura 3 - Tela de desconto parte inicial 
Fonte: Própria (2012) 
Ferramenta: Netbeans 7.0.1 
 
Figura 4 - Tela de desconto parte final 
Fonte: Própria (2012) 
Ferramenta: Netbeans 7.0.1 
 
Abaixo na Figura 4 – Fluxograma para habilitar campo valor de desconto, mostra a tradução do 
fluxo para Java. 
 
Figura 5 - Fluxograma para habilitar campo valor de desconto 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
CÓDIGO FONTE: 
 
if (jCheckBox1.isSelected()){ 
 jFormattedTextField1.setEnabled(true); 
 } 
 else { 
 jFormattedTextField1.setEnabled(false); 
 } 
 
Fontes 1 - Habilitar campo desconto 
 
17 
 
Fluxograma mascara CPF e CNPJ – Componente 
JFormattedTextField 
 
Este exemplo segue da seguinte estrutura: Deacordo com a escolha do “Tipo da pessoa” será 
alterado a mascara de um componente swing que será passado como variável de entrada. 
Este fluxo servirá para todo o projeto, uma vez que não depende de componentes. 
 
Figura 6 - Tela mascara parte inicial 
Fonte: Própria (2012) 
Ferramenta: Netbeans 7.0.1 
 
Figura 7 - Tela mascara parte final 
Fonte: Própria (2012) 
Ferramenta: Netbeans 7.0.1 
 
Pare reproduzir esse exemplo, siga os passos: 
1. Crie um novo formulário JFrame; 
2. Adicione um componente não visual chamado: Grupo de botões (
) conhecido como buttonGroup. Devido sua característica não 
visual, para acessá-lo vá até a parte inferior esquerda no “Inspetor” no grupo Outros 
componentes. 
3. Adicione dois componentes Botão de opção ( ) conhecido em 
seu código como JCheckbox. Na sua propriedade associe o atributo “buttonGroup” 
ao buttonGroup1 que já está no formulário, o mesmo para o segundo botão de opção. 
4. Adicione um componente Rótulo ( ) conhecido em seu código como 
JLabel. Na sua propriedade “text” rotule-o com “CPF ou CNPJ”. 
5. Adicione um componente Campo formatado ( ) conhecido em 
seu código como JFormattedTextField. Na sua propriedade em formattedFactory 
defina uma mascara, na categoria moeda escolha o formato padrão. 
 
 
 
 
18 
 
 
Figura 8 - Fluxo mascara CPF e CNPJ 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
CÓDIGO FONTE: 
 
public void setMascara(String tipoPessoa,JFormattedTextField documento) throws 
ParseException{ 
 
//Limpar seu conteúdo 
documento.setValue(null); 
 
//É igual a PJ ? 
if (tipoPessoa.equals("PJ")){ 
 
//Mascara CNPJ 
documento.setFormatterFactory(new 
javax.swing.text.DefaultFormatterFactory(new 
javax.swing.text.MaskFormatter("##.###.###/####-##"))); 
 
}else{ 
 
//Mascara CPF 
documento.setFormatterFactory(new 
javax.swing.text.DefaultFormatterFactory(new 
javax.swing.text.MaskFormatter("###.###.###-##"))); 
 
} 
//Lançar foco para o campo CPF ou CNPJ 
documento.grabFocus(); 
 
} 
Fontes 2 - Fluxo mascara CPF ou CNPJ 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
 
19 
 
O código fonte do fluxograma já foi realizado, sendo assim, será necessário declará-lo nos 
códigos Java. No Netbeans, entre na aba “Código-fonte” role para baixo até encontrar a 
função: “public static void main(String args[])”, seu código virá acima do fluxograma 
principal main, ficando conforme abaixo: 
CÓDIGO FONTE: 
 
����SEU CÓDIGO DEVE SER ESCRITO AQUI.  
 
 /** 
 * @param args the command line arguments 
 */ 
 public static void main(String args[]) { 
 /* Create and display the form */ 
 java.awt.EventQueue.invokeLater(new Runnable() { 
 
 public void run() { 
 new NewJFrame().setVisible(true); 
 } 
 }); 
 } 
Fontes 3 – Onde declarar sua função 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
Lembre-se que mesmo declarando uma função, não acontecerá nada se não ligarmos a um 
evento de componentes swing, uma vez que devemos chamá-la na ação do usuário. Se 
pensarmos bem, o usuário vai clicar no Botão de opção “Física” caso ele deseje informar um 
CPF e no Botão de opção “Jurídica” se for CNPJ, sendo assim, devemos colocar nosso código 
quando o usuário clicar sobre um ou outro Botão de opção, vejamos o fluxo do que devemos 
fazer. 
 
Figura 9 – Fluxograma para o clique do botão de opção 
Fonte: Própria (2012) 
Ferramenta: Ferramenta: BizAgi 
 
 
 
20 
 
1. Obteremos qual dos botões de opção que o usuário clicou para sabermos se é PF ou 
PJ. 
2. Obteremos o componente que devemos lançar a mascara. 
3. Chamaremos nosso fluxograma que agora é função em Java passando o tipo de 
pessoa escolhida e o componente também. 
Vejamos abaixo o código fonte do fluxograma da Figura 9 – Fluxograma para o clique do botão 
de opção: 
CÓDIGO FONTE: 
 
//Obter a escolha do usuário para o tipoPessoa 
String tipoPessoa = buttonGroup1.getSelection().getActionCommand(); 
 
//Obter o componente que levará a mascara 
JFormattedTextField campo = jFormattedTextField1; 
 
try { 
 
//Definir mascara no componente escolhido de acordo com a escolha do tipoPessoa do 
usuário. 
 setMascara(tipoPessoa, campo); 
 
} catch (ParseException ex) { 
 Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex); 
 } 
Fontes 4 - Clique do botão de opção 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
 
Para adicionar corretamente o código, siga os passos: 
Clique com botão direito do mouse no primeiro Botão de Opção “Física”, vá até “Eventos” 
escolha “Action” e “ActionPerformed”. Abrirá a área dos fontes relativo ao fluxo do clique desse 
componente, então adicione o código Fonte 4 – Clique do botão de opção. 
Faça o mesmo para o Botão de Opção “Jurídica”, só que no seu código digite: 
CÓDIGO FONTE: 
 
//Simula um clique no Botão de opção Juridica 
 jRadioButton1ActionPerformed(evt); 
 
Fontes 5 - Simula clique no RadioButton 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
Simulando o clique, ou mesmo chamando o ActionPerformed do primeiro Botão de opção, não 
será necessário repetir todo o código outra vez, essa é uma das vantagens da programação 
orientada a objetos, o Reuso. 
 
 
21 
 
Fluxograma preencher combo com anos – Componente 
JComboBox 
 
Este exemplo segue da seguinte estrutura: Um campo para o ano inicial será preenchido assim 
como o ano final e, ao clicar sobre o botão Preencher, o combo “Ano” deve listar todos os anos 
desde o inicial até o final. 
 
Figura 10 - Tela preencher ano parte inicial 
Fonte: Própria (2012) 
Ferramenta: Netbeans 7.0.1 
 
 
 
Figura 11 - Tela preencher ano parte final 
Fonte: Própria (2012) 
Ferramenta: Netbeans 7.0.1 
Para reproduzir esse formulário, siga os passos: 
 
1. Crie um novo formulário JFrame; 
2. Adicione três componentes rótulo para “Ano inicial”,”Ano final” e “Ano”; 
3. Adicione um componente chamado Controle giratório ( ) conhecido como 
JSpinner. Insira tanto para o ano inicial e final; 
4. Adicione um JComboBox para listar os anos; 
5. Adicione um componente Button( ) conhecido como JButton. Servirá para chamar o fluxo 
para preencher o combo. 
6. Desenhe conforme Figura 11 – Tela preencher ano parte final. 
 
 
 
 
 
22 
 
Vejamos o fluxograma para preencher o combo: 
 
 
Figura 12 - Fluxo para preencher o combo com lista de anos 
Fonte: Própria (2012) 
Ferramenta: Ferramenta: BizAgi 
 
Abaixo segue o código fonte do fluxograma preencher o combo: 
CÓDIGO FONTE: 
 
public void preencherCombo (JComboBox combo, int anoInicio, int anoFim){ 
 //Remove todos os itens existentes atualmente no combo 
 combo.removeAllItems(); 
 //Até que o I seja igual ao ano final, adicione I no combo 
 for ( int i = anoInicio; i <= anoFim; i++) { 
 //Adiciona um item ao combo "I" 
 combo.addItem(i); 
 } 
 
} 
Fontes 6 – Fluxo preencher código em códigos Java 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
Caso não saiba ainda como declarar sua função, siga Fontes 3 - Onde declarar sua função. 
Mesmo com a função já declarada, devemos criar o fluxo que ficará no evento ActionPerformed 
do botão “Preencher”, veja abaixo: 
 
23 
 
 
Figura 13 - Fluxo para o botão preencher 
Fonte: Própria (2012) 
Ferramenta: Ferramenta: BizAgi 
 
1. Obteremos o ano inicial digitado pelo usuário no componente Controle giratório. 
2. Obteremos o ano final digitado pelo usuário no componente Controle giratório. 
3. Chamaremos nosso fluxograma que agora é função em Java passando o combo que 
desejamos preencher, o ano incial e ofinal. 
Vejamos abaixo o código fonte do fluxograma da Figura 13 – Fluxo para o botão preencher: 
CÓDIGO FONTE: 
 
 //Obter ano inicial 
 int anoIni = Integer.parseInt( jSpinner1.getValue().toString() ); 
 //Obter ano final 
 int anoFim = Integer.parseInt( jSpinner2.getValue().toString() ); 
 
 //Chamar a função (fluxo) para preencher o combo com a lista de anos. 
 preencherCombo(jComboBox1, anoIni, anoFim); 
 
Fontes 7 – Fonte do fluxo para o botão preencher 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
 
Para adicionar corretamente o código, siga os passos: 
Clique com botão direito do mouse no Botão “Preencher”, vá até “Eventos” escolha “Action” e 
“ActionPerformed”. Abrirá a área dos fontes relativo ao fluxo do clique desse componente, 
então adicione o código Fonte do fluxo para o botão preencher. 
Veja os passos a serem seguidos: 
1. Desenhar o formulário, prestando atenção para colocar os componentes corretamente. 
2. Declarar a função que preenche o combo. Caso ainda não saiba como realizar essa 
tarefa, veja os Fontes 3. 
3. No evento clique do botão preencher, insira o Fonte do fluxo para o botão preencher. 
Resultado: 
 
24 
 
 
Fontes 8 – Resultado do fluxo preencher combo 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
PRINCIPAIS COMPONENTES SWINGS - MÉTODOS COMUNS 
 
Conheceremos a partir de agora, alguns dos componentes swings mais usados e seus 
métodos mais comuns. No Netbeans na parte superior direita, podemos localizar a Paleta de 
componentes, neste sentido, existem alguns grupos de componentes e, estudaremos o grupo 
“Controles Swing”, uma vez que contem os mais comuns componentes usado. 
Abaixo segue a figura com todos eles: 
 
Figura 14 - Controles Swing 
Fonte: Própria (2012) 
Ferramenta: NetBeans 7.0.1 
 
25 
 
 
Rótulo – O componente JTextField 
 
JTextField é um componente de peso leve que permite a edição de uma única linha de texto. 
getText 
public String getText() 
Retorna o texto contido no presente TextComponent. Se o documento base é nulo, dar-
se-á um NullPointerException. 
Retorna: 
o texto nele contido 
Erro lançado se nulo: 
NullPointerException - se o documento é nulo 
Exemplo: 
jTextField1.getText(); 
 
setText 
public void setText(String t) 
 
Define o texto do presente TextComponent para o texto especificado. Se o texto é nulo 
ou vazio, tem o efeito de simplesmente apagar o texto antigo. 
Parametros: 
t - o novo texto a ser definido 
Exemplo: 
jTextField1.setText(“Novo texto que desejar”); 
 
Button – O componente JButton 
 
Uma implementação de um "botão". Botões podem ser configurados e até certo ponto 
controlado, por ações. Usar uma ação com um botão tem muitos benefícios além da 
configuração diretamente de um botão. 
 
isEnabled 
public boolean isEnabled() 
 
26 
 
Determina se o componente está habilitado. Um componente habilitado pode 
responder a entrada do usuário e gerar eventos. Componentes são habilitados 
inicialmente por padrão. Um componente pode ser habilitado ou desabilitado, 
chamando seu método setEnabled. 
Retorna: 
true se o componente está habilitado, false caso contrário 
Exemplo: 
If ( jButton1.isEnabled() ) { 
System.out.println(“Está habilitado”); 
}else{ 
System.out.println(“Está desabilitado”); 
} 
 
 
 
27 
 
setEnabled 
public void setEnabled(boolean b) 
Habilita ou desabilita este componente, dependendo do valor do parâmetro b. Um 
componente habilitado pode responder a entrada do usuário e gerar eventos. 
Componentes são habilitados inicialmente por padrão. 
Nota: Desabilitar um componente leve não o impede de receber MouseEvents. 
Parameters: 
b - se for true, este componente é habilitado; caso contrário esse componente está 
desativado 
Exemplo: 
//Para habilitar 
jButton1.setEnabled( true ); 
//Para desabilitar 
jButton1.setEnabled( false ); 
 
setVisible 
public void setVisible(boolean b) 
Mostra ou oculta este componente dependendo do valor do parâmetro b. 
Parâmetro: 
b - Se verdadeiro, mostra este componente; caso contrário, esconde esse componente 
Exemplo: 
//Para deixá-lo visível 
jButton1.setVisible( true ); 
//Para deixá-lo invisível 
jButton1.setVisible ( false ); 
 
 
 
28 
 
Caixa de combinação – O componente JComboBox 
 
Um componente que combina um botão ou o campo editável e uma lista drop-down. O usuário 
pode selecionar um valor na lista suspensa, que aparece na solicitação do usuário. Se você 
fizer a caixa de combinação editável, em seguida, a caixa de combinação inclui um campo 
editável, no qual o usuário pode digitar um valor. 
 
getSelectedIndex 
public int getSelectedIndex() 
Retorna o primeiro item na lista que corresponde o determinado item. O resultado não 
é sempre definido se o JComboBox permite que itens selecionados que não estão na 
lista. Retorna -1 se não houver nenhum item selecionado ou se o usuário especificou 
um item que não está na lista. 
Retorna: 
um inteiro que especifica o item atualmente selecionado, onde 0 especifica o primeiro 
item na lista; ou -1 se nenhum item for selecionado ou se o item selecionado no 
momento não está na lista 
Exemplo: 
//Verificar se algum item foi selecionado 
if ( JComboBox.getSelectedIndex() == -1){ 
System.out.println(“Nenhum item selecionado.”); 
} 
 
removeAllItems 
public void removeAllItems() 
Remove todos os itens da lista de itens. 
Exemplo: 
//Remover todos os item de um combobox 
jComboBox1.removeAllItems(); 
addItem 
public void addItem(Object anObject) 
Adiciona um item para a lista de itens. Este método só funciona se o JComboBox utiliza 
um modelo de dados mutáveis. 
Aviso: Podem surgir problemas de foco e teclado navegação se você adicionar objetos 
de cadeia de caracteres duplicados. Uma solução é adicionar novos objetos em vez de 
String objetos e certifique-se de que o método ToString () é definido. 
 
29 
 
Exemplo: 
 jComboBox1.addItem("Item 1"); 
 jComboBox1.addItem("Item 2"); 
 
Parâmetros: 
anObject - o objeto para adicionar à lista 
 
getSelectedItem 
public Object getSelectedItem() 
Retorna o item atual selecionado. 
Se a caixa de combinação é editável, então esse valor pode não ter sido adicionado da 
caixa de combinação com addItem, insertItemAt ou os construtores de dados. 
Retorna: 
O objeto atual selecionado 
Exemplo: 
//Obter o item selecionado no combo 
System.out.println( jComboBox1.getSelectedItem().toString() ); 
 
Campo formatado – O componente JFormattedTextField 
 
Campos de texto formatado fornecem uma maneira para os desenvolvedores especificar o 
conjunto de caracteres que pode ser digitado em um campo de texto válido. Especificamente, a 
classe JFormattedTextField adiciona um formatador e um valor de objeto para as 
características herdadas da classe JTextField. O formatador traduz o valor do campo texto 
exibe e o texto para o valor do campo. 
getValue 
public Object getValue() 
Retorna o último valor válido. Com base na política de edição da AbstractFormatter isto 
pode não retornar o valor atual. O valor atualmente editado pode ser obtido chamando 
commitEdit seguido de getValue. 
Retorna: 
Ultimo valor válido 
Exemplo: 
//Obter valor do campo 
System.out.println( jFormattedTextField1.getValue() ); 
 
 
30 
 
setFormatterFactory 
public void setFormatterFactory(JFormattedTextField.AbstractFormatterFactory tf) 
 
Define o AbstractFormatterFactory. AbstractFormatterFactory é capaz de retornar uma 
instância de AbstractFormatter que é usado para formatar um valor de exibir, como 
também um aplicando uma política de edição. 
Se você não explicitamente definiuum AbstractFormatterFactory por esse método (ou 
um construtor) um AbstractFormatterFactory e, consequentemente, será usado um 
AbstractFormatter baseiam na classe do valor. NumberFormatter será usado para 
números, DateFormatter será usado para datas, caso contrário será usado 
DefaultFormatter. 
Esta é uma propriedade de JavaBeans vinculado. 
Parâmetros: 
tf - AbstractFormatterFactory usado para instâncias de pesquisa de AbstractFormatter 
Exemplo: 
//Mascara CNPJ 
documento.setFormatterFactory(new 
javax.swing.text.DefaultFormatterFactory(new 
javax.swing.text.MaskFormatter("##.###.###/####-##"))); 
 
Tabela – O componente JTable 
 
A JTable é usado para exibir e editar tabelas bidimensionais regulares de células. 
A classe JTable é utilizada para vizualizar dados em grid no Swing é um dos componentes 
mais complexos desse pacote. Alias o JTable possui até um pacote especial, que contém 
diversas classes para sua utilização: javax.swing.table. A JTable é um componente MVC1: o 
seu trabalho é dividido em 3 partes, veja a mais importante: 
Model: É a parte que cuida dos dados, quem controla e distribui os dados na jtable. É 
implementado pela interface TableModel ( AbstractTableModel e DefaultTableModel ). Ela é 
responsável por fornecedor os dados para a tabela, a qual requisitará os dados através do 
método getValueAt, informando a linha e a coluna. Este método retorna um Object, ou seja, um 
objeto qualquer, que pode ser um Integer, uma String ou outra classe que você tenha 
implementado. 
Vamos neste momento definir uma variável para armazenar a estrutura atual da tabela: 
1. DefaultTableModel modelo = (DefaultTableModel) jTable1.getModel(); 
2. modelo.setNumRows(0); //Limpar as linhas 
Onde modelo receberá os dados atualmente contidos na tabela, como: colunas e linhas. 
 
1
 Model-view-controller (MVC) é um padrão de arquitetura de software que visa a separar a lógica de negócio da lógica de 
apresentação, permitindo o desenvolvimento, teste e manutenção isolado de ambos. 
 
31 
 
Para inserir uma linha será preciso executar o método addRow: 
modelo.addRow 
Segue abaixo como usá-lo corretamente: 
3. modelo.addRow(new Object[]{ 
“0001”, 
“Douglas”, 
“2799379892” 
}); 
 
4. jTable1.setModel(modelo); 
 
Esse comando adicionará uma nova linha com o conteúdo acima na tabela. 
Obter a primeira coluna da primeira linha selecionada: 
int codTopico = Integer.parseInt(masterTable.getValueAt(masterTable.getSelectedRow(), 
0).toString()); 
 
 
 
32 
 
Formulário – O componente JFrame 
 
setDefaultCloseOperation 
public void setDefaultCloseOperation(int operation) 
Define a operação que vai acontecer por padrão quando o usuário inicia um "close" 
sobre este quadro. Você deve especificar uma das seguintes opções: 
• DO_NOTHING_ON_CLOSE (definido em WindowConstants): não faça nada; 
• HIDE_ON_CLOSE (definido em WindowConstants): Ocultar automaticamente 
o quadro após invocar qualquer registo WindowListener objetos. 
• DISPOSE_ON_CLOSE (definido em WindowConstants): esconder e elimine o 
quadro após invocar qualquer registo WindowListener objetos 
automaticamente. 
• EXIT_ON_CLOSE (definido no JFrame): sair do aplicativo usando o método de 
saída do sistema. Use isto apenas em aplicações. 
O valor é definido como HIDE_ON_CLOSE por padrão. 
Parâmetros: 
operation - a operação que deve ser executada quando o usuário fecha o quadro 
Exemplo(Chamar um formulário JFrame): 
 //Declarar uma variável chamada frame do JFrame ComboAnos 
 jFComboAnos frame = new jFComboAnos(); 
 //Usando a variavel frame que é cópia do formulário, definir como fechará 
 frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
 //Reorganizar componentes do formulário 
 frame.pack(); 
 //Centralizar o frame sem nenhum componente relativo (centro) 
 frame.setLocationRelativeTo(null); 
 //Definir o frame como visível para que o usuário possa vê-lo. 
 frame.setVisible(true); 
 
 
33 
 
A CLASSE JOPTIONPANE – INTERAGINDO COM USUÁRIO 
 
JOptionPane torna fácil aparecer em uma caixa de diálogo padrão que solicita aos usuários 
um valor ou informa algo. 
Enquanto a classe JOptionPane pode parecer complexa devido ao grande número de 
métodos, quase todos os usos desta classe são chamadas de uma linha para um dos métodos 
estáticos showXxxDialog mostrados abaixo: 
Nome do método Descrição 
showConfirmDialog Faz uma pergunta de confirmação, como Sim/não/cancelar. 
showInputDialog Tela solicita algum dado digitado pelo usuário. 
showMessageDialog Informar ao usuário sobre algo que aconteceu. 
showOptionDialog A grande unificação dos três acima. 
 
Cada um desses métodos também vem em um valor showInternalXXX, que usa uma estrutura 
interna para manter a caixa de diálogo caixa.Conveniência de vários métodos também foram 
definidos - sobrecarregado versões dos métodos básicos que usam listas de parâmetros 
diferentes. 
Todos os diálogos são modais. Cada método “showXxxDialog” bloqueia o segmento atual até 
que a interação do usuário estiver concluída. 
Parâmetros: 
Os parâmetros para esses métodos seguem padrões consistentes: 
parentComponent 
Define o componente que deve ser o pai dessa caixa de diálogo. Ele é usado de duas 
maneiras: o quadro que o contém é usado como o pai do quadro para a caixa de 
diálogo, e suas coordenadas de tela são usadas na colocação da caixa de diálogo. Em 
geral, a caixa de diálogo é colocada logo abaixo do componente. Este parâmetro pode 
ser nulo, caso em que um padrão Frame é usado como o pai, e a caixa de diálogo será 
centralizada na tela. 
message 
Uma mensagem descritiva para ser colocado na caixa de diálogo. 
 
messageType 
Define o estilo da mensagem. O gerente de aparência pode esquematizar o diálogo 
diferentemente dependendo deste valor e muitas vezes irá fornecer um ícone padrão. 
Os valores possíveis são: 
 
34 
 
• ERROR_MESSAGE 
• INFORMATION_MESSAGE 
• WARNING_MESSAGE 
• QUESTION_MESSAGE 
• PLAIN_MESSAGE 
 
optionType 
Define o conjunto de botões de opção que aparecem na parte inferior da caixa 
de diálogo: 
• DEFAULT_OPTION 
• YES_NO_OPTION 
• YES_NO_CANCEL_OPTION 
• OK_CANCEL_OPTION 
Você não está limitado a este conjunto de botões de opção. Você pode 
fornecer qualquer botões que você quer usando o parâmetro options. 
options 
Uma descrição mais detalhada do conjunto de botões de opção que 
aparecerão na parte inferior da caixa de diálogo. 
icon 
Um ícone decorativo para ser colocado na caixa de diálogo. Um valor padrão 
para este é determinado pelo parâmetro messageType. 
title 
O título para a caixa de diálogo. 
initialValue 
A seleção de padrão (valor de entrada). 
Quando um dos métodos showXxxDialog retorna um número inteiro, os valores possíveis são: 
• YES_OPTION 
• NO_OPTION 
• CANCEL_OPTION 
• OK_OPTION 
• CLOSED_OPTION 
 
Exemplos: 
Mostrar uma caixa de diálogo de erro que exibe a mensagem, 'alerta': 
 
JOptionPane.showMessageDialog(null, "alerta", "alerta", 
JOptionPane.ERROR_MESSAGE); 
 
 
 
 
 
35 
 
Mostrar uma caixa de diálogo de informação interna com a mensagem, 'informações': 
 
JOptionPane.showInternalMessageDialog(frame, "information", 
"information", JOptionPane.INFORMATION_MESSAGE); 
 
Mostrar um painel de informações com as opções sim/não e 'escolher um' da 
mensagem: 
 
JOptionPane.showConfirmDialog(null, 
"choose one", "choose one", JOptionPane.YES_NO_OPTION); 
 
Mostrar uma caixa de diálogo de informação interna com as opções sim/não/cancelar e 
'por favor,escolha uma' da mensagem e informações de título: 
 
JOptionPane.showInternalConfirmDialog(frame, 
"please choose one", "information", 
JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE); 
 
Mostrar uma caixa de diálogo de aviso com o título de OK, cancelar, opções 'Aviso' e 
'Clique em OK para continuar' da mensagem: 
 
 //Confirmar 
 Object[] options = {"Sim", "Não"}; 
 int sd = 
 JOptionPane.showOptionDialog( 
 null, 
 "Deseja realmente ALTERAR dados do PEDIDO ?", 
 "Confirmação!", 
 JOptionPane.DEFAULT_OPTION, 
 JOptionPane.WARNING_MESSAGE, 
 null, 
 options, 
 options[0]); 
 
 if (sd != 0) { 
 return; 
 } 
 
Mostrar uma caixa de diálogo perguntando ao usuário para digitar uma seqüência de 
caracteres: 
 
String inputValue = JOptionPane.showInputDialog("Por favor, insira um valor "); 
 
Mostrar uma caixa de diálogo perguntando ao usuário para selecionar uma seqüência de 
caracteres: 
 
Object[] possibleValues = { "Primeiro", "Segundo", "Terceiro" }; 
Object selectedValue = JOptionPane.showInputDialog(null, 
"Escolha um", "Input", 
JOptionPane.INFORMATION_MESSAGE, null, 
possibleValues, possibleValues[0]); 
 
 
36 
 
BIBLIOGRAFIA 
ANSELMO, F. (2005). Aplicando Lógica Orientada a Objeto em Java (2ª ed ed.). Florianópolis: 
VisualBooks. 
BERG, A., & FIGUEIRÓ, J. P. (2006). Lógica de programação (3ª Edição ed.). Canoas: ULBRA.