Você está na página 1de 17

O Swing é um framework que disponibiliza um conjunto de elementos gráficos

para ser utilizado na plataforma Java. O Swing é compatível com o Abstract


Window Toolkit (AWT), mas trabalha de forma totalmente diferente. A API
Swing, diferente do AWT, não delega a tarefa de renderização ao sistema
operacional, ele renderiza os elementos por conta própria. Como a AWT é
uma biblioteca de baixo-nível que depende de código nativo da plataforma ela
traz alguns problemas de compatibilidade entre as plataformas, fazendo com
que nem sempre o programa tenha a aparência desejada em todos os sistemas
operacionais. Além disso, o Swing é mais completo e os programas têm uma
aparência muito parecida, independente do sistema operacional que está sendo
utilizado, possui uma enorme gama de controles extras disponíveis, tais como
áreas de texto que nativamente podem mostrar conteúdo como RTF ou HTML,
botões com suporte a imagens, sliders, selecionadores de cores, alteração do
tipo de borda para os componentes, maior controle de como desenhar os
mínimos detalhes de apresentação e muito mais. No entanto, a performance é
um pouco pior devido a alta abstração, consumindo assim mais memória
RAM.

Confira os cursos de Java da DevMedia e aprofunde seu conhecimento sobre essa


linguagem.

Os principais componentes do Swing são resumidos abaixo:

 JFrame representa a janela do programa com barra de título, ícone,


botões de comando, etc. Entre os principais métodos temos
o pack() que compacta a janela para o tamanho dos
componentes, setSize(int, int) que define a largura e altura da
janela, setLocation(int, int) que define a posição da janela na tela
(x,y), setBounds(int, int, int, int) que define posição e
tamanho, setVisible(boolean) que exibe a janela
e setDefaultCloseOperation(int) que define o que ocorre quando o
usuário tenta fechar a janela (as opções
são: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, DISPOSE_ON
_CLOSE, EXIT_ON_CLOSE).
 JPanel representa um tipo básico de container para inserção de
componentes. Entre os principais métodos temos add(Component,
int) que adiciona o componente definindo sua posição
e setLayout(LayoutManagaer) que altera o tipo de layout.
 JLabel representa um rótulo de texto. Entre os principais métodos
temos o setText(String) que altera o texto e getText() que retorna o texto
atual.
 JTextFiel representa um campo de texto onde o usuário pode informar
um texto em uma linha. Entre os principais métodos
temos setText(String) que altera o texto e getText() que retorna o texto
atual.
 JPasswordField representa um campo de texto protegido, subclasse de
JTextField. O principal método é o setEchoChar(char) que define o
caractere que aparece ao digitar um texto.
 JTextArea representa uma caixa onde o usuário pode informar várias
linhas de texto. Entre os principais métodos temos o setText(String) que
altera o texto, getText() que retorna o texto atual, getSelectedText() que
retorna o texto selecionado pelo usuário e insert(String, int) que insere
um texto na posição especificada.
 JCheckBox representa uma caixa de seleção e permite selecionar ou
não uma opção. Entre os principais métodos temos
o setSelected(boolean) que altera o estado da caixa de seleção e o
método isSelected() que retorna true se a caixa estiver marcada
e false se não estiver marcada.
 JRadioButton representa um componente que permite seleciona uma
entre diversas opções. O JRadioButton é semelhante ao JCheckBox,
inclusive com os mesmos construtores e métodos.
 JComboBox representa uma caixa de combinação, da qual o usuário
pode selecionar uma opção. Entre os principais métodos temos
o addItem(Object) que adiciona um item à lista de
opções, setEditable(boolean) que permite ao usuário digitar uma
opção, getSelectedIndex() que retorna a posição do item atualmente
selecionado, getSelectedItem() que retorna o texto do item atualmente
selecionado, setSelectedIndex(int) que seleciona o item da posição
especificada e setSelectedIndex(Object) que seleciona o objeto
especificado na lista.
 JList representa uma lista de opções que permite a seleção de mais de
um item simultaneamente. Entre os principais métodos temos
o setListData(Object[]) que preenche ou altera os itens de uma
lista, getSelectedValues() que retorna um array de objetos contendo
itens selecionados na lista.
 JButton representa um botão destinado a executar uma ação. Entre os
principais métodos temos o setText(String) que altera o texto do botão
e setIcon(Icon) que altera o ícone do botão.

Na Figura 1 podemos visualizar cada um dos componentes discutidos acima,


respectivamente.
Figura 1. Principais componentes do framework Swing.

Existem ainda diversos outros componentes Swing como o JSlider,


JProgressBar, JToolBar, JTabbedPane entre outros.

No restante do artigo abordaremos dois componentes muito utilizados no


framework Swing, veremos como podemos customizar o JTextField limitando
o número de caracteres permitidos e como implementar máscaras no
JFormattedTextField.

Limitando caracteres com JTextField

Controlar a entrada de texto num componente JTextField não é tão simples e


ainda causa muitas dúvidas para os desenvolvedores que trabalham com
Swing em java. A classe javax.swing.JTextField é uma subclasse da classe
abstrata JTextComponent e o modelo de dados padrão é um objeto da
classe PlainDocument, subclasse de AbstractDocument que implementa a
interface Document. Um dos métodos da classe PlainDocument é
o insertString() que é herdado da superclasse abstrata AbstractDocument. A
assinatura do método é:
public void insertString(int offset, String str, AttributeSet attr)
1throws BadLocationException
O argumento offset indica o deslocamento (a posição) inicial onde o objeto
String str deverá ser inserido. O AttributeSet seta os atributos
do JTextField, como os estilos.

Sempre que o conteúdo de um JTextField é modificado, o


método insertString() é invocado.

Segue na Listagem 1 um exemplo de como poderíamos utilizar o


método insertString para criar um novo modelos de dados que seja capaz de
restringir a quantidade de caracteres aceitos no modelo de dados de
qualquer JTextField.

Listagem 1. Criando um novo modelo de dados para restringir o número de


caracteres.

1 package com.exemplo;
2
3 import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
4 import javax.swing.text.PlainDocument;
5
6 public class TamanhoFixoJTextField extends PlainDocument {
7
8 private int tamMax;
9
10 public TamanhoFixoJTextField(int tamMax) {
11 super();
this.tamMax = tamMax;
12 }
13
14 public void insertString(int offset, String str, AttributeSet
15attr)
16 throws BadLocationException {
17
if (str == null)
18
return;
19
20 //Define a condição para aceitar qualquer número de
21caracteres
22 if (tamMax <= 0)
23 {
super.insertString(offset, str, attr);
24 return;
25 }
26
27 int tam = (getLength() + str.length());
28
29 //Se o tamanho final for menor, chama insertString()
30 aceitando a String
if (tam <= tamMax)
31 super.insertString(offset, str, attr);
32 }
33
34}
35
36

O argumento recebido pelo construtor define o número máximo de caracteres


aceitos. A chamada a super() no construtor permite que a classe ancestral faça
todas as inicializações necessárias. A variável de instância tamMax recebe o
valor do argumento do construtor. O método insertString() nos permite
sobrepor o método definido na superclasse para que possamos defini-lo como
quisermos. A exceção BadLocationException é disparada quando a posição de
inserção na String é inválida. No corpo do método insertString primeiramente
garantimos que não estamos recebendo uma String nula. Após isso
verificamos o valor máximo de caracteres a serem aceitos, se este valor for
menor ou igual a zero, tem-se que essa classe terá um comportamento igual a
sua ancestral PlainDocument, chamando o método insertString() da
superclasse e simplesmente a retornando. Dessa forma, se o máximo de
caracteres for menor ou igual zero, o número de caracteres aceitos será
indeterminado. A classe AbstractDocument ainda possui alguns métodos que
permitem o acesso aos dados que formam o conteúdo do JTextField, são
eles: getLength() ou ainda getText(). O método getLength() permite que
possamos acessar o número de caracteres atual do conteúdo. O conteúdo pode
ser acessado diretamente através de getText(). Portanto, no código acima
temos "int tam = (getLength() + str.length())" em que tam é a soma do
comprimento atual do conteúdo mais o comprimento da String str que está por
ser inserida. Se a soma for menor ou igual ao número máximo de caracteres,
aceitaremos str através da chamada ao método insertString da superclasse,
caso contrário não ocorrerá a chamada e o conteúdo a ser inserido será
ignorado.

Para testar o código presente na Listagem 1, vamos fazer um exemplo


utilizando um JTextField que segue esse modelo. Na Listagem 2 segue um
exemplo.

Listagem 2. Testando o JTextField utilizando o modelo de dados criado.

1 package com.exemplo;
2
3 import javax.swing.JFrame;
4 import javax.swing.JTextField;
5
6 public class TestandoJTextField extends JFrame {
7
private static final long serialVersionUID = 1L;
8
9 private JTextField txtExemplo;
10
11 public static void main(String[] args)
12 {
13 TestandoJTextField field = new TestandoJTextField();
14 field.testaJTextField();
15 }
16
private void testaJTextField() {
17 this.setTitle("Exemplo");
18 this.setSize(200, 180);
19
20 //Definimos o tamanho padrão do JTextField
21 txtExemplo = new JTextField(10);
22
23 //Passamos para o construtor o número máximo de caracteres
aceitos
24 txtExemplo.setDocument(new TamanhoFixoJTextField(5));
25
26 this.getContentPane().add(txtExemplo, "North");
27
28 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
29
30 setVisible(true);
31 }
32
}
33
34
35

No exemplo mostrado no código acima, tentamos adicionar uma string na


caixa de texto do programa, ou seja, o nome “Rafael”, porém como o nosso
componente aceita no máximo cinco caracteres não conseguimos digitar o
nome inteiro. Segue na Figura 2 a demonstração do programa funcionando e
permitindo um número máximo de caracteres.

Figura 2. Executando o programa e digitando uma string.

Um pequeno problema é quando desejamos colar na


nossa JTextField customizada uma string maior que a permitida. Se colarmos
uma string que o número máximo de caracteres seja permitido não será um
problema. Por exemplo, se tentarmos copiar a String “Marco” e colar
no JTextField ele aceitará normalmente, conforme ilustra a Figura 3.
Figura 3. Colando um texto com cinco caracteres.

No entanto, se copiarmos a string “Rafael” e tentarmos colar veremos que


essa string não será colada no JTextField, isso acontece porque esta string
ultrapassa o número máximo de caracteres permitidos e portanto a string não é
aceita. O ideal seria o campo de texto aceitar o número mínimo de caracteres e
desprezar o restante, dessa forma, a string mostrada seria “Rafae”. Para
modificar isso devemos fazer algumas modificações no código. Segue
na Listagem 3 o novo código com comentários das modificações.

Listagem 3. Modificando o código para contemplar as novas configurações.

1 package com.exemplo;
2
import javax.swing.text.AttributeSet;
3 import javax.swing.text.BadLocationException;
4 import javax.swing.text.PlainDocument;
5
6 public class TamanhoFixoJTextField extends PlainDocument {
7
8 private int tamMax;
9
10 public TamanhoFixoJTextField(int tamMax) {
super();
11 this.tamMax = tamMax;
12 }
13
14 public void insertString(int offset, String str, AttributeSet
15attr)
16 throws BadLocationException {
17
if (str == null)
18 return;
19
20 //Define a condição para aceitar qualquer número de
21caracteres
22 if (tamMax <= 0)
23 {
super.insertString(offset, str, attr);
24 return;
25 }
26
27 int tam = (getLength() + str.length());
28
29 //Se o tamanho final for menor, chama insertString()
aceitando a String
30 if (tam <= tamMax) {
31 super.insertString(offset, str, attr);
32 } else {
33 //Caso contrário, limita a string e envia para
insertString() que aceita a string
34 if (getLength() == tamMax) return;
35 String novaStr = str.substring(0, (tamMax -
36getLength()));
37 super.insertString(offset, novaStr, attr);
38 }
}
39
40}
41
42

O bloco else adicionado no final do código acima primeiramente verifica se o


comprimento atual do conteúdo é igual ao comprimento máximo, então
simplesmente retornamos, caso contrário criamos um novo objeto String
contendo apenas os caracteres de str que deveria caber no JTextField.

Agora se tentarmos copiar a String “Rafael” e colarmos no JTextField teremos


como resultado a string limitada adicionada no campo, conforme mostra
a Figura 4 abaixo.

Figura 4. Colando uma string maior que o permitido no campo.

Outra situação muito comum ao trabalharmos com campos de entrada é


manipularmos alguns tipos de textos com valores pré-determinados como, por
exemplo, CPF, CNPJ, CEP, etc. Na próxima seção veremos como fazer isso
utilizando outro componente, o JFormattedTextField que é semelhante ao
JTextField, porém mais voltado para campos formatados.

Formatando campos com JFormattedTextField


As máscaras são muito utilizadas em sistemas comerciais, pois elas ajudam na
padronização da visualização de dados. Um exemplo de máscara é o telefone:
"(51)3636-0000" ou o CEP: "92-110.310". Tudo que for digitado ficará entre
os caracteres especiais da máscara seguindo a sequencia.

Antes de criarmos e utilizarmos um JFormattedTextField devemos criar um


objeto MaskFormatter e configurar uma máscara. Segue na Listagem 4 um
exemplo de uma máscara definida para CPF.

Listagem 4. Definindo uma mascara para um CPF.

1MaskFormatter mascaraCpf = new MaskFormatter("###.###.###-##");

Após isso, configuramos a máscara no JFormattedTextField, conforme o


código presente na Listagem 5.

Listagem 5. Configurando a mascara no objeto JFormattedTextField.

1JFormattedTextField cpf = new JFormattedTextField(mascaraCpf);

Quando criamos um MaskFormatter podemos utilizar ao invés de “#”, outros


caracteres, dependendo do tipo de restrição que desejamos implementar
no JFormattedTextField. Esses caracteres são definidos abaixo:

 "#" indica que qualquer número poderá ser inserido (0-9);


 "U" indica que qualquer letra (a-z) poderá ser inserida. A máscara
converterá letras minúsculas em maiúsculas;
 "L" indica qualquer letra (a-z) poderá ser inserida. A máscara
converterá letras maiúsculas em minúsculas;
 "?" indica qualquer letra (a-z) poderá ser inserida. A máscara manterá a
letra inserida;
 "A" indica qualquer letra ou numero (0-9 e a-z) poderá ser inserido;
 "H" indica qualquer caracter hexadecimal (0-9 a-f) poderá ser inserido;
 "*" indica qualquer coisa, incluindo caracteres especiais poderão ser
inseridos.

Segue abaixo algumas máscaras prontas que podemos utilizar em nossos


projetos:

 Telefone Internacional: "+##(##)####-####"


 Telefone Nacional: "(##)####-####"
 CEP: "##.###-###" ou "#####-###"
 CPF: "###.###.###-##"
 Placa de automóveis: "UUU-####"
 CNPJ: "##.###.###/####-##"
 Título de eleitor: "#########/##"
 Data de nascimento: "##/##/####"

Para exemplificar o uso do JFormattedTextField segue o exemplo presente


na Listagem 6, onde criamos quatro campos com máscaras, são eles: CEP,
Telefone, CPF, Data.

Listagem 6. Exemplo de código utilizando máscaras para CEP, telefone, CPF


e Data.

1 package com.exemplo;
2
import java.awt.Container;
3 import java.text.ParseException;
4
5 import javax.swing.JFormattedTextField;
6 import javax.swing.JFrame;
7 import javax.swing.JLabel;
8 import javax.swing.text.MaskFormatter;
9
public class TestandoJFormattedTextField extends JFrame {
10
11 private static final long serialVersionUID = 1L;
12
13 public static void main(String[] args)
14 {
15 TestandoJFormattedTextField field = new
TestandoJFormattedTextField();
16 field.testaJFormattedTextField();
17 }
18
19 private void testaJFormattedTextField() {
20 Container janela = getContentPane();
21 setLayout(null);
22
//Define os rótulos dos botões
23 JLabel labelCep = new JLabel("CEP: ");
24 JLabel labelTel = new JLabel("Telefone: ");
25 JLabel labelCpf = new JLabel("CPF: ");
26 JLabel labelData = new JLabel("Data: ");
27 labelCep.setBounds(50,40,100,20);
labelTel.setBounds(50,80,100,20);
28 labelCpf.setBounds(50,120,100,20);
29 labelData.setBounds(50,160,100,20);
30
31 //Define as máscaras
32 MaskFormatter mascaraCep = null;
33 MaskFormatter mascaraTel = null;
MaskFormatter mascaraCpf = null;
34 MaskFormatter mascaraData = null;
35
36 try{
37 mascaraCep = new MaskFormatter("#####-###");
38 mascaraTel = new MaskFormatter("(##)####-####");
mascaraCpf = new MaskFormatter("#########-##");
39 mascaraData = new MaskFormatter("##/##/####");
40 mascaraCep.setPlaceholderCharacter('_');
41 mascaraTel.setPlaceholderCharacter('_');
42 mascaraCpf.setPlaceholderCharacter('_');
mascaraData.setPlaceholderCharacter('_');
43 }
44 catch(ParseException excp) {
45 System.err.println("Erro na formatação: " +
46 excp.getMessage());
System.exit(-1);
47 }
48
49 //Seta as máscaras nos objetos JFormattedTextField
50 JFormattedTextField jFormattedTextCep = new
51JFormattedTextField(mascaraCep);
52 JFormattedTextField jFormattedTextTel = new
JFormattedTextField(mascaraTel);
53 JFormattedTextField jFormattedTextCpf = new
54JFormattedTextField(mascaraCpf);
55 JFormattedTextField jFormattedTextData = new
56 JFormattedTextField(mascaraData);
57 jFormattedTextCep.setBounds(150,40,100,20);
jFormattedTextTel.setBounds(150,80,100,20);
58 jFormattedTextCpf.setBounds(150,120,100,20);
59 jFormattedTextData.setBounds(150,160,100,20);
60
61 //Adiciona os rótulos e os campos de textos com
62máscaras na tela
janela.add(labelCep);
63 janela.add(labelTel);
64 janela.add(labelCpf);
65 janela.add(labelData);
66 janela.add(jFormattedTextCep);
67 janela.add(jFormattedTextTel);
janela.add(jFormattedTextCpf);
68 janela.add(jFormattedTextData);
69 setSize(400, 250);
70 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
71 setVisible(true);
}
72
73
}
74
75
76
77
78
79
80

Segue na Figura 5 um exemplo de como ficou a tela codificada acima.


Figura 5. Exemplo da tela com os campos de textos e as máscaras
configuradas.

Se tentarmos entrar com letras onde apenas se aceita número veremos que os
caracteres não serão aceitos no campo.

Programa que calcule a média de salários de uma empresa, pedindo ao usuário


a grade de funcionários e os salários em JOptionPane e devolvendo a média em
DOS.

1. import javax.swing.JOptionPane;
2. public class Media {
3. public static void main(String[] args) {
4.
5. int quantidadeFuncionarios = 0;
6. float salarioFuncionario = 0;
7. float totalSalarios = 0;
8. float mediaSalarial = 0;
9. //variável contadora para laço
10. int contadora = 0;
11.
12. quantidadeFuncionarios = Integer.parseInt(JOptionPane.showInputDialog(null,"
Digite a quantidade de funcionários","Número de funcionários",JOptionPane.QUESTION
_MESSAGE));
13.
14. while (contadora < quantidadeFuncionarios){
15. contadora++;
16. salarioFuncionario = Float.parseFloat(JOptionPane.showInputDialog(null,"D
igite o salário do funcionário","Salário",JOptionPane.QUESTION_MESSAGE));
17. totalSalarios = totalSalarios + salarioFuncionario;
18. }
19.
20. mediaSalarial = totalSalarios / quantidadeFuncionarios;
21. System.out.println("Média Salarial = " + mediaSalarial);
22.
23. System.exit(0);
24. }
25.
26. }

2) Criar um programa que receba por janela JoptionPane o valor de um produto


e um código de aumento, segundo a tabela:

Código % aumento
1 10
3 25
4 30
8 50

Utilizando a estrutura switch-case, mostrar em janela de saída o novo valor do


produto depois de acrescida a porcentagem correspondente.

1. import javax.swing.JOptionPane;
2. public class Porcentagem {
3. public static void main(String[] args) {
4.
5. int codigoTaxaAumento;
6. float valorProduto;
7.
8.
9. valorProduto = Float.parseFloat(JOptionPane.showInputDialog(null,"R$","Valor
do produto",JOptionPane.QUESTION_MESSAGE));
10. codigoTaxaAumento = Integer.parseInt(JOptionPane.showInputDialog(null,"Códig
o","Código de taxa do aumento",JOptionPane.QUESTION_MESSAGE));
11.
12. switch (codigoTaxaAumento) {
13. case 1: valorProduto = valorProduto + (valorProduto * 10 / 100);
14. JOptionPane.showMessageDialog(null,"R$ " + valorProduto,"Valor do prod
uto com taxa de aumento",JOptionPane.PLAIN_MESSAGE);
15. break;
16.
17. case 3: valorProduto = valorProduto + (valorProduto * 25 / 100);
18. JOptionPane.showMessageDialog(null,"R$ " + valorProduto,"Valor do produto co
m taxa de aumento",JOptionPane.PLAIN_MESSAGE);
19. break;
20.
21. case 4: valorProduto = valorProduto + (valorProduto * 30 / 100);
22. JOptionPane.showMessageDialog(null,"R$ " + valorProduto,"Valor do produto co
m taxa de aumento",JOptionPane.PLAIN_MESSAGE);
23. break;
24.
25. case 8: valorProduto = valorProduto + (valorProduto * 50 / 100);
26. JOptionPane.showMessageDialog(null,"R$ " + valorProduto,"Valor do produto co
m taxa de aumento",JOptionPane.PLAIN_MESSAGE);
27. break;
28.
29. default: JOptionPane.showMessageDialog(null,"Código" + codigoTaxaAumento,"Có
digo de taxa de aumento desconhcido",JOptionPane.PLAIN_MESSAGE);
30. break;
31. }
32. System.exit(0);

3) Criar um programa para cálculo do salário líquido em que três valores devem
ser informados pelo usuário em janelas de entrada: a quantidade de horas
trabalhadas, o salário hora e o número de dependentes. O programa deve
mostrar em janela de saída as informações contidas no lado esquerdo da tabela
seguinte:

Informação Cálculos
Salário bruto Horas trabalhadas * salário hora + (50 * número de
dependentes)

Desconto INSS Se salário bruto <= 1000 INSS=salário bruto * 8.5/100


Se salário bruto > 1000 INSS=salário bruto * 9/100

Desconto IR Se salário bruto <= 500 IR=0


Se salário bruto > 500 e <= 1000 IR=salário bruto*5/100
Se salário bruto > 1000 IR=salário bruto*7/100

Salário líquido Salário bruto - INSS - IR

1. import javax.swing.JOptionPane;
2.
3. public class Rh {
4.
5. public static void main( String args[] )
6. {
7.
8. String ND, SH, HT;
9. int nd;
10. float sh, ht, dIR, sb;
11. double dINSS, sl;
12.
13. ND=
14. JOptionPane.showInputDialog
15. (null,"Digite número de dependentes","Número de Dependentes",
16. JOptionPane.QUESTION_MESSAGE);
17.
18. nd = Integer.parseInt(ND);
19.
20. SH=
21. JOptionPane.showInputDialog
22. (null,"Digite salário hora","Salário Hora",
23. JOptionPane.QUESTION_MESSAGE);
24.
25. sh = Float.parseFloat(SH);
26.
27. HT=
28. JOptionPane.showInputDialog
29. (null,"Digite número de horas trabalhadas","Número de Horas Trabalhadas",
30. JOptionPane.QUESTION_MESSAGE);
31.
32. ht = Float.parseFloat(HT);
33.
34. sb = ht*sh+(50*nd);
35.
36. {JOptionPane.showMessageDialog (
37. null, "Salário Bruto" +sb , "Salário Bruto",
38. JOptionPane.INFORMATION_MESSAGE );}
39.
40. if (sb<=1000)
41.
42. dINSS = sb*8.5/100;
43.
44. else
45.
46. dINSS = sb*9/100;
47.
48. {JOptionPane.showMessageDialog (
49. null, "Desconto do INSS" +dINSS , "Desconto do INSS",
50. JOptionPane.INFORMATION_MESSAGE );}
51.
52. if (sb<=500)
53.
54. dIR = 0;
55.
56. if (sb>500 && sb<=1000)
57.
58. dIR = sb*5/100;
59.
60. else
61.
62. dIR = sb*7/100;
63.
64. {JOptionPane.showMessageDialog (
65. null, "Desconto do IR" +dIR , "Desconto do IR",
66. JOptionPane.INFORMATION_MESSAGE );}
67.
68. sl = sb-dINSS-dIR;
69.
70. {JOptionPane.showMessageDialog (
71. null, "Salário Líquido" +sl , "Salário Líquido",
72. JOptionPane.INFORMATION_MESSAGE );
73. System.exit( 0 );}
74.
75. }
76. }

4) Desenvolver programa que peca ao usuario para cadastrar uma senha; na


sequencia, deve pedir ao usuario que digite duas variaveis reais, e ira calcular a
divisão da primeira pela segunda. O programa ira pedir ao usuario que digite
sua senha:Se estiver correta ela mostra o resultado da divisao. Senao da
mensagem de erro e encerra o aplicativo.

1. import javax.swing.*;
2. public class Senha4 {
3. public static void main(String[] args) {
4. String cadastroSenha;
5. String confirmaSenha;
6. double a;
7. double b;
8.
9. cadastroSenha = JOptionPane.showInputDialog(null,"Senha","",JOptionPane.QUES
TION_MESSAGE);
10.
11. a = Double.parseDouble(JOptionPane.showInputDialog(null,"Primeiro número",""
,JOptionPane.QUESTION_MESSAGE));
12. b = Double.parseDouble(JOptionPane.showInputDialog(null,"Segundo número",""
,JOptionPane.QUESTION_MESSAGE));
13.
14. confirmaSenha = JOptionPane.showInputDialog(null,"Digite sua senha","",JOpti
onPane.QUESTION_MESSAGE);
15.
16. if (confirmaSenha.equals(cadastroSenha)){
17. System.out.println(a/b);
18. }else{
19. System.out.println("Senha incorreta");
20. }
21.
22. System.exit(0);
23. }
24.
25. }

5) Implementar programa que realize uma das 4 operaçoes (+), (-), (/) e (*)
entre duas variáveis, através da escolha do usuário.

1. import javax.swing.JOptionPane;
2.
3. public class Operacoes{
4.
5. public static void main( String args[] )
6. {
7. //APRESENTAÇÃO DAS VARIAVEIS
8.
9. String a, b, escolha;
10. int es;
11. float c, d, e;
12.
13.
14. //DEFINIÇÃO DAS VARIAVEIS
15.
16. escolha = JOptionPane.showInputDialog ("Digite 0 para soma, \n Digite 1 para su
btraçao, \n Digite 2 para divisao, \n Digite 3 para multiplicacao");
17. es = Integer.parseInt(escolha);
18. a = JOptionPane.showInputDialog ("Digite o primeiro numero");
19. c = Float.parseFloat(a);
20. b = JOptionPane.showInputDialog ("Digite o segundo numero");
21. d = Float.parseFloat(b);
22.
23.
24.
25. //SWITCH CASE
26.
27. switch (es)
28. {
29. case 0:
30. e = c + d;
31. JOptionPane.showMessageDialog(null, "Resultado da soma: " + e, "Feito", JOptio
nPane.PLAIN_MESSAGE );break;
32.
33. case 1:
34. e = c - d;
35. JOptionPane.showMessageDialog(null, "Resultado da subtracao: " + e, "Feito",
JOptionPane.PLAIN_MESSAGE );break;
36.
37. case 2:
38. e = c / d;
39. JOptionPane.showMessageDialog(null, "Resultado da divisao: " + e, "Feito", JOp
tionPane.PLAIN_MESSAGE );break;
40.
41. case 3:
42. e = c * d;
43. JOptionPane.showMessageDialog(null, "Resultado da multiplicacao: " + e, "Feito
", JOptionPane.PLAIN_MESSAGE );break;
44.
45. }
46. System.exit(0);
47. }
48. }

Você também pode gostar