Powered By Blogger

segunda-feira, 30 de setembro de 2013

Teste de Falhas Java and Hacker (Programação + falhas)

Aplicativo: Simulação simples de conta bancária


Aplicativo: Conta bancária/Caixa eletrônico simples em Java

Crie um protótipo de caixa eletrônico nalinguagem de programação Java. No início, ele pede seu nome e valor $$ inicial que tem na conta. O programa deve fornecer um número de até 4 dígitos - número da conta - para o usuário (use Random). Esses dados serão usados para criar um objeto da classe "Conta.java"

A seguir, mostra um menu com as opções (esse menu deverá ser um método):
- Extrato: exibe o nome, número da conta, saldo e quantos saques já foram realizados
- Sacar: recebe o valor a ser sacado, informa se pode ser sacado (não pode ficar negativo) e mostra o saldo
- Depositar: recebe o valor a ser depositado e mostra o novo saldo
- Sair

Esse menu aparece até o usuário escolher sair. As outras opções são métodos que devem fazer parte da "Conta.java" (setters e getters). Note que o usuário pode sacar no máximo 5 vezes por dia.


Nesse exercício não vamos usar explicitamente as palavras 'set' e 'get' nos nomes dos métodos. Mas isso não é necessário. O que vamos usar é sua ideia: a ideia por trás do 'set' é a de alterar valores de variáveis, pra isso vamos usar os métodos 'sacar' e 'depositar', que altera o valor do saldo ; a ideia por trás do 'get' é de simplesmente obter informações das variáveis, como é o caso do método 'extrato'.

Use a main só para iniciar o aplicativo

Inicialmente, no nosso arquivo "Caixa.java", que contém a 'main', criamos uma conta, pedindo um nome e um valor inicial.
Através do comando: 1 + numero.nextInt(9999) nós sorteamos um número de conta de até 4 dígitos (nextInt(9999) gera números de 0 até 9998, somando 1 gera de 1 até 9999).
Com esses dados, criamos uma conta, que na verdade é o objeto 'minhaConta' da classe "Conta.java".
Iniciamos nosso banco ou caixa eletrônico através do método 'iniciar()'.

Note que tentamos enxugar a 'main', pois é uma boa prática. No geral, ela é usada apenas como 'gatilho', pra começar o programa e não pra ser enchida de variáveis e linhas de código.
Vamos pra classe "Conta.java".


Sistema bancário simples em Java

Nossos atributos (variáveis) são: nome, saldo, conta e saques.
Aqui vamos usar a real função do construtor: inicializar as variáveis. Nesse caso é obrigatório, pois não tem como, em um sistema bancário, criar uma conta sem ter - no mínimo - esses dados.

Vamos ver agora os principais métodos desse sistema bancário:
extrato()
Método simples, que exibe todas as informações do usuário.

sacar(int valor)
Esse método altera a variável 'saldo'. No caso, ele reduz ela.
Porém, só faz sentido reduzir (tirar dinheiro), se 'valor' for menor que  o 'saldo', por isso é feito um tratamento através do teste condicional if.
Caso seja possível realizar o saque, devemos incrementar a variável 'saques', para termos controle do número de saques realizados. Caso não seja possível, exibimos uma mensagem informando o problema e nada ocorre.
Ou seja, é um belo exemplo de como usar o método set.

depositar(int valor)
Simplesmente adiciona um valor ao saldo atual.

iniciar()
Aqui é a tela inicial de nosso Caixa Eletrônico Progressivo Java.
Ele usa um laço do while que irá rodar o mini-sistema bancário enquanto o usuário não selecionar a opção de sair, que é o número 4 ( while(opcao != 4 ) ).
A cada iteração é exibido o menu através do método exibeMenu(), é pedido uma entrada (número) ao usuário e esse número é enviado para o método que vai direcionar o programa para a opção escolhida pelo usuário, o escolheOpcao().

exibeMenu()
Um método simples desse sistema bancário é o 'exibeMenu()', que não recebe nenhum argumento nem retorna nenhuma variável. Como o nome diz, ele simplesmente exibe a lista de opções de nosso sistema.

escolheOpcao(int opcao)
Vamos realmente escolher a opção que queremos no método 'escolheOpcao', que recebe um número.
Mas que número é esse?
Ora, é o referente ao menu. Você vê as opções, entra com o número e esse método serve pra escolher a opção desejada.
Escolher opção...isso te lembra algo? Sim, o comando switch.
Caso tenha escolhido a opção 1, eles nos envia para o método 'extrato()'.
Caso seja a 2, deveria ir para o método 'sacar()', porém não é sempre que podemos sacar. Só podemos se tivermos realizado menos de 3 saques.
Caso seja possível realizar o saque, tanto o caso 2 com o caso 3 devem receber um valor do usuário, que é o montante que vai ser sacado ou depositado.
O case 4 é para encerrar o sistema e qualquer outra opção cai na default que acusa como erro.


Código fonte Java do Aplicativo


Caixa.java

import java.util.Scanner;
import java.util.Random;

public class Caixa {
    
    
    public static void main(String[] args){
        // Declarando as variáveis, Scanner e Random
        String nome;
        double inicial;
        Scanner entrada = new Scanner(System.in);
        Random numero = new Random();
        int conta = 1 + numero.nextInt(9999);
    
        //Obtendo os dados iniciais do Cliente
        System.out.println("Cadastrando novo cliente.");
        System.out.print("Ente com seu nome: ");
        nome = entrada.nextLine();
        
        System.out.print("Entre com o valor inicial depositado na conta: ");
        inicial = entrada.nextDouble();
        
        //Criando a conta de um cliente
        Conta minhaConta = new Conta(nome, conta, inicial);
        minhaConta.iniciar();
    }
    
    
}


Conta.java

import java.util.Scanner;

public class Conta {
    private String nome;
    private int conta, saques;
    private double saldo;
    Scanner entrada = new Scanner(System.in);
    
    public Conta(String nome, int conta, double saldo_inicial){
        this.nome=nome;
        this.conta=conta;
        saldo=saldo_inicial;
        saques=0;
    }
    
    public void extrato(){
        System.out.println("\tEXTRATO");
        System.out.println("Nome: " + this.nome);
        System.out.println("Número da conta: " + this.conta);
        System.out.printf("Saldo atual: %.2f\n",this.saldo);
        System.out.println("Saques realizados hoje: " + this.saques + "\n");
        
    }
    
    public void sacar(double valor){
        if(saldo >= valor){
            saldo -= valor;
            saques++;
            System.out.println("Sacado: " + valor);
            System.out.println("Novo saldo: " + saldo + "\n");
        } else {
            System.out.println("Saldo insuficiente. Faça um depósito\n");
        }
    }
    
    public void depositar(double valor)
    {
        saldo += valor;
        System.out.println("Depositado: " + valor);
        System.out.println("Novo saldo: " + saldo + "\n");
    }
    
    public void iniciar(){
        int opcao;

        do{
            exibeMenu();
            opcao = entrada.nextInt();
            escolheOpcao(opcao);
        }while(opcao!=4);
    }
    
    public void exibeMenu(){
        
        System.out.println("\t Escolha a opção desejada");
        System.out.println("1 - Consultar Extrato");
        System.out.println("2 - Sacar");
        System.out.println("3 - Depositar");
        System.out.println("4 - Sair\n");
        System.out.print("Opção: ");
        
    }
    
    public void escolheOpcao(int opcao){
        double valor;
        
        switch( opcao ){
            case 1:    
                    extrato();
                    break;
            case 2: 
                    if(saques<3){
                        System.out.print("Quanto deseja sacar: ");
                        valor = entrada.nextDouble();
                        sacar(valor);
                    } else{
                        System.out.println("Limite de saques diários atingidos.\n");
                    }
                    break;
                    
            case 3:
                    System.out.print("Quanto deseja depositar: ");
                    valor = entrada.nextDouble();
                    depositar(valor);
                    break;
                    
            case 4: 
                    System.out.println("Sistema encerrado.");
                    break;
                    
            default:
                    System.out.println("Opção inválida");
        }
    }
}


Treinamento Hacker:
Encontre falhas, brechas e erros no aplicativo acima.
As respostas estão em cor branca, logo abaixo, bastando selecionar o texto para visualizar.
Porém, não olhe antes de tentar pensar bastante.




Não foi feito tratamento de erros, para adivinhar as bobagens que os usuários podem digitar.

Por exemplo, se digitar letra onde é pedido número, o sistema irá colapsar.

Note que os valores recebidos pelos métodos 'sacar' e 'depositar' devem ser positivos. Porém, não fizemos nada para checar isso, sendo portanto, possível burlar esse 'banco'.
Por exemplo, saque um valor negativo, de  -1 milhão de reais e terá 1 milhão de reais em sua conta ;)
Deve ser por isso que não existe o botão com o símbolo '-' no teclado dos bancos...

Criando um programa de cadastro em Java com banco de dados MySql

Bom vamos criar um programa simples de cadastro em Java utilizando um banco de dados MySql, antes de começarmos a programar nosso software precisamos fazer o download do conector MYSQL pois ele vai fazer toda a conexão com o banco de dados.

Abaixo está o link para você fazer o download pelo próprio site do MYSQL

vem um arquivo zipado com o jar que vamos usar dentro, se você quiser baixar o jar, coloquei ele para download, clique no link abaixo e baixe apenas o jar.

Depois de fazer o download você precisa extrair o arquivo

Caso tenha baixado o zip diretamente do site do MYSQL, depois de extrair o arquivo cole na pasta:
C:\Program Files\Java\jdk1.6.0_16\jre\lib\ext
Bem agora vamos criar nosso banco de dados, vamos criar uma tabela simples com:
Código, nome, data de nascimento, telefone, email.
Então o código SQL fica assim:
CREATE TABLE `elzobrito1`.`cadastro` (
`cod` INT( 255 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`nome` VARCHAR( 255 ) NOT NULL ,
`dt_nasc` VARCHAR( 255 ) NOT NULL ,
`telefone` VARCHAR( 255 ) NOT NULL ,
`email` VARCHAR( 255 ) NOT NULL
) ENGINE = MYISAM
Pronto agora podemos nos preocupar com as classes Java : )
Vamos criar uma classe Amigo, com os mesmos campos que colocamos no banco de dados.
cod
public class Amigo {
    private int cod;
    private String nome;
    private String dt_nasc;
    private String telefone;
    private String email;

    public int getCod() {
        return cod;
    }

    public void setCod(int cod) {
        this.cod = cod;
    }

    public String getDt_nasc() {
        return dt_nasc;
    }

    public void setDt_nasc(String dt_nasc) {
        this.dt_nasc = dt_nasc;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

}
Pronto a classe Amigo está criada, precisamos criar uma classe para conversar com nosso banco de dados. A classe que vamos criar agora faz busca e inserção no banco de dados.
import java.util.*;
import java.sql.*;
import java.util.ArrayList;

public class ConectaBanco {

    private String url;
    private String login;
    private String senha;

    public ConectaBanco(String url, String login, String senha) {
        setUrl(url);
        setLogin(login);
        setSenha(senha);
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login) {
        this.login = login;
    }

    public String getSenha() {
        return senha;
    }

    public void setSenha(String senha) {
        this.senha = senha;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void insere(String s, String msg) {
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            //System.out.println("\n Salvando URL: ...\n");
            try {
                Connection conn = DriverManager.getConnection(getUrl(),
getLogin(), getSenha());
                try {
                    String sql = s;
                    Statement stm = conn.createStatement();
                    try {
                        stm.executeUpdate(sql);
                        System.out.println(msg);
                    } catch (Exception ex) {
                        System.out.println("\nErro no resultset!\n" + ex);
                    }
                } catch (Exception ex) {
                    System.out.println("\nErro no statement!");
                }
            } catch (Exception ex) {
                System.out.println("\nErro no connection!");
            }
        } catch (Exception ex) {
            System.out.println("\nDriver nao pode ser carregado!");
        }

    }

    public ArrayList busca(String s) {
        ArrayList amigo = new ArrayList();
        Amigo a = new Amigo();
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            //System.out.println("\n Salvando URL: ...\n");
            try {
                Connection conn = DriverManager.getConnection(getUrl(),
getLogin(), getSenha());
                try {
                    String sql = s;
                    Statement stm = conn.createStatement();
                    try {
                        ResultSet rs = stm.executeQuery(sql);
                        while (rs.next()) {
                            a.setCod(rs.getInt(1));
                            a.setNome(rs.getString(2));
                            a.setDt_nasc(rs.getString(3));
                            a.setTelefone(rs.getString(4));
                            a.setEmail(rs.getString(5));
                            amigo.add(a);
                        }
                        //System.out.println(rs.getInt(1));
                    } catch (Exception ex) {
                        System.out.println(ex);
                    }
                } catch (Exception ex) {
                    System.out.println("\nErro no statement!");
                }
            } catch (Exception ex) {
                System.out.println("\nErro no connection! " + ex);
            }
        } catch (Exception ex) {
            System.out.println("\nDriver nao pode ser carregado!");
        }
        return amigo;
    }
}
Agora vamos fazer o MAIN…
No MAIN vamos fazer um coisa bem simples apenas cadastrar e buscar um amigo no banco de dados.
import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO code application loSgic here
        Scanner ler  = new Scanner(System.in);
        ConectaBanco cb = new ConectaBanco("jdbc:mysql://URL",
 "LOGIN", "SENHA");

        int x=-1;
        while (x != 0) {
            System.out.println("Escolha uma opcao");
            System.out.println("1 - Cadastrar amigo");
            System.out.println("2 - Buscar Amigo");
            System.out.println("3 - Sair");
            x = Integer.parseInt(ler.nextLine());

            switch (x) {
                case 1: {
                    Amigo amigo = new Amigo();

                    System.out.println("Digite um nome:");
                    amigo.setNome(ler.nextLine());
                    System.out.println("Digite a data de nascimento:");
                    amigo.setDt_nasc(ler.nextLine());
                    System.out.println("Digite o Telefone:");
                    amigo.setTelefone(ler.nextLine());
                    System.out.println("Digite o E-mail:");
                    amigo.setEmail(ler.nextLine());

                    cb.insere("INSERT INTO
nome_do_banco_de_dados.nome_da_tabela VALUES
(NULL , '" + amigo.getNome() + "', '" + amigo.getDt_nasc() +
 "', '" + amigo.getTelefone() + "', '" + amigo.getEmail() + "');
", "Amigo gravado corretamente...");
                    break;
                }
                case 2: {
                    ArrayList a = new ArrayList();
                    System.out.println("Digite o nome do seu amigo
para procura:");
                    String nome = ler.nextLine();
                    a =  cb.busca("SELECT * FROM
nome_do_banco_de_dados.nome_da_tabelao WHERE nome
LIKE '%" + nome + "%';");
                    if (a.size()>0){
                        a.get(0).show(a);
                    }
                    else{
                        System.out.println("nao achamdos seu amigo");
                    }

                    break;
                }
                case 3: {
                    x=0;
                }
            }

        }
    }

}

Recebendo dados do usuário: a classe Scanner

Usaremos a classe Scanner para receber esses dados.

Importando (import) classes (class) e pacotes (packages)

Existem milhares de funcionalidades no Java. Essas classes foram agrupadas em pacotes, os packages.
E pacotes para a mesma funcionalidade são chamados de API (Application Programming Interface). Por exemplo, temos uma seção sobre a API Java 2D, para fazer desenhos em 2D.
Ou seja, são uma série de pacotes para desenhar.

Porém, todos esses pacotes não estão simplesmente prontos para serem utilizados, pois são muitos.
Inclusive, você pode criar (e vai) os seus pacotes, pode baixar, reutilizar, compartilhar, vender etc.
Se todos estes estivessem prontos para utilização, demoraria MUITO para rodar um programa em Java.

Qual a solução então?
Vamos dizer ao Java quais funcionalidades queremos usar. Pra isso, usamos a função 'import':
import pacote_que_voce_quer_importar;

Por exemplo: para usar print, printf e println, não precisa dizer nada ao Java.
São métodos tão comuns que podem ser usadas automaticamente em qualquer aplicação.
Esses métodos fazem parte de um pacote chamado 'java.lang'.


Recebendo dados do usuário: new Scanner(System.in)

Para receber dados do usuário, temos que usar a classe Scanner, que faz parte do pacote 'java.util'.
Vamos dizer ao Java que usaremos essa classe na nossa aplicação
Para isso, adicione essa linha no começo do programa:
import java.util.Scanner;

Bom, temos a classe. Vamos declarar o nosso objeto do tipo Scanner.
Vamos chamá-lo de 'entrada'. Sua declaração é feita da seguinte maneira:
Scanner entrada = new Scanner(System.in);

Pronto, o objeto 'entrada' será usado para ler entradas do sistema.

Lembre-se que há uma forte tipagem por trás dos panos. Ou seja, o Java está lidando com bytes, blocos de memória e outras coisas mais complicadas.
Então, para ele, há muita diferença entre inteiros, float, doubles e outros tipos. Portanto, precisamos ser bem claros quanto a isso.

Assim, a nossa entrada será bem tipada. Vamos iniciar por inteiros.
Para receber um número inteiro do usuário, com nosso objeto 'entrada', usaremos a seguinte sintaxe:
inteiro = entrada.nextInt();

Explicações dadas, vamos ver a coisa funcionando. Esse é um exemplo bem simples que pergunta a idade do usuário, espera ele digitar (e dar enter) e exibe essa mensagem na tela:

import java.util.Scanner;
        
public class Entrada {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        int idade;
        
        System.out.println("Digite sua idade: ");
        idade = entrada.nextInt();
        
        System.out.printf("Sua idade é " + idade + "\n");
        
    }
}

Mas isso de 'qual sua idade?...19...você tem 19 anos', é meio tele-tubbie.
Você é programador Java, vulgo Paladino das Artes Computacionais.
O seguinte programa usa uma função que obtém o ano atual (do computador do usuário) e calcula o ano que o usuário nasceu, que é algo mais útil que repetir o que você acabou de digitar.

Para isso, usaremos a classe 'Calendar', que tem métodos para trabalharmos com dias, horas, dias da semana, minutos, segundos, anos etc.
Para saber mais sobre, acesse a documentação:
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Calendar.html

Pra usar a 'Calendar', é necessário importar:
import java.util.Calendar;

Usaremos o método get(Calendar.YEAR), que retorna um inteiro com o ano, e vamos armazenar esse inteiro em uma variável 'ano'.

Então, nosso programa fica assim:

import java.util.Scanner;
import java.util.Calendar;

public class Entrada {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        int idade;
        int ano_atual;
        int ano_nascimento

        // pergunta a idade e armazena
        System.out.println("Digite sua idade: ");
        idade = entrada.nextInt();
       
        //Criando um objeto do tipo Calendar, o 'calendario' e armazenando o ano atual
        Calendar calendario = Calendar.getInstance();
        ano_atual=calendario.get(Calendar.YEAR);
        ano_nascimento= ano_atual - idade;
       
        System.out.printf("Você nasceu em " + ano_nascimento + "\n");
       
    }
}

O ano de nascimento é calculado e armazenado através da operação de subtração:
ano_nascimento = ano_atual - idade;

Você aprenderá outras operações matemáticas em breve.
Aqui vale uma ressalva.

Eu fiz assim por ser um tutorial básico e por questão de organização, mas a variável 'ano_nascimento' não seria necessária.
Poderíamos ter usado '(ano_atual - idade)' direto no printf assim:

System.out.printf("Você nasceu em " + (ano_atual - idade) + "\n");

Mas tem que ser entre parênteses.
Assim você não precisa mais da variável 'ano_nascimento'.

Aliás, também não precisaríamos da variável 'ano_atual', poderíamos ter feito diretamente assim:
System.out.printf("Você nasceu em " + ( calendario.get(Calendar.YEAR) - idade) + "\n");

Quer saber? Esqueça da variável 'idade', faça só:

import java.util.Scanner;
import java.util.Calendar;

public class Entrada {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        
        System.out.println("Digite sua idade: ");
        Calendar calendario = Calendar.getInstance();
        
        System.out.printf("Você nasceu em " + (calendario.get(Calendar.YEAR) - entrada.nextInt()) + "\n");
        
    }
}

Notou como fomos tirando as variáveis e foi ficando cada vez menor?
Cada vez que tiramos, o programa fica menor e ocupa menos espaço.

Porém perde em legibilidade. Note que agora está mais difícil de entender o que fizemos.
Com 'idade', 'ano_atual' e 'ano_nascimento' fica bem mais organizado.

Não existe um método ou jeito melhor de se fazer as coisas. Programar é algo pessoal.
Você terá que encontrar um meio termo entre eficiência (programa rápido e ocupado pouco espaço), mas que seja de fácil entendimento por outros usuários (e por você no futuro). Pois se escrever de forma muito compacta e complicada, pode ser que nem você entenda o que fez futuro.

Recebendo outros tipos de dados, float: nextFloat();

No exemplo anterior, usamos o tipo inteiro.
Se você for perspicaz notará o 'Int' de 'nextInt()'.

Sim, pra float, será 'nextFloat':

import java.util.Scanner;

public class Entrada {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        float preco;
     
        System.out.println("Quanto custa algo em uma loja de R$ 1,99? ");
        preco = entrada.nextFloat();
     
        System.out.println("Hã? " + preco + "?");
     
    }
}

Programa bobo ,não?
Não. É uma pegadinha. Digite 1,99 pra você ver.
O certo é 1.99 ;)


Exercício:
Crie um aplicativo que pergunte o ano de nascimento e diga a idade atual do indivíduo.
Use a classe Calendar e o método get(Calendar.YEAR) desta classe.



PS:  não chame o usuário de indivíduo

PS2: Poderá existir alguns problemas no cálculo de sua idade
1. Por conta do mês que você faz aniversário.
Isso será resolvido deixando o problema mais completo, perguntando o mês e dia do aniversário e usando testes condicionais, que aprenderemos mais adiante.

2. Se o usuário não digitar um número, ou digitar negativo ou outro absurdo.
Nesse momento você sentirá vontade de chamar ele de indivíduo, energúmeno e outras coisas.
Mas se acostume.

Existe uma coisa chamada tratamento de erros e exceções, muito usada justamente pra tentar imaginar os possíveis erros e exceções que podem ocorrer.
No caso, exceções, é o nome bonito que se dá aos absurdos que os usuários podem digitar.

Por exemplo, você já deve ter visto em cadastros:
Insira sua data de nascimento na forma dd/mm/aaaa:

Aí o usuário vai e digita 5/janeiro/89 e não sabe qual foi o erro.
Experimente agora digitar algo que não seja um número em seus programas.

Para saber mais sobre a relação de de usuários x programadores visite:
http://www.vidadesuporte.com.br
http://www.vidadeprogramador.com.br

Vídeo-aula sobre a classe Scanner:

Para assistir a vídeo-aula ministrada pela Universidade XTI sobre o assunto abordado nesse artigo, clique aqui.

Manipulando Caixas de Dialogo com JOptionPane

JOptionPane

Uma Introdução à Programação Visual

Após apresentarmos os conceitos estruturais principais de linguagem, a idéia de orientação a objeto e as classes que mais utilizaremos como String e Numbers, passaremos agora a focar numa programação mais voltada a práticas possíveis, demonstrando classes com funções mais avançadas e importantes, além de abandornamos um pouco o visual de console e partirmos para a programação visual de Java.
Para introduzir esta nova fase, iniciaremos descrevendo um pouco sobre JOptionPane do pacote visual Swing.
A classe JOptionPane nos proporciona uma série de métodos estáticos que ao serem invocados criam caixas de diálogos simples e objetivas.
Para usar JOptionPane temos sempre que importar o pacote javax.swing.JOptionPane primeiro.

Caixas de Diálogo Input Text

As caixas de diálogo de entrada de texto ou Input Text Dialog servem para fazer uma requisição de algum dado ao usuário de forma bem simples e direta.
O que é digitado pelo usuário é retornado pelo método em forma de string.
Existem mais de 10 métodos sobrecarregados para invocar uma caixa de diálogo Input Text, mas, a princípio, usaremos a mais simples. O método showInputText recebe um argumento que é a string contendo a informação desejada, o que na maioria das vezes é uma pergunta ou pedido.
O exemplo abaixo demonstra um programa pedindo para que digite seu nome.
1.import javax.swing.JOptionPane;
2. 
3.public class CaixasDeDialogo {
4.public static void main(String[] args) {
5.JOptionPane.showInputDialog("Qual é o seu nome?");
6.}
7.}
Será apresentada uma janela a seguir.
Exemplo de Input Text Dialog da classe JOptionPane

Caixas de Diálogo Confirm

Outra caixa de diálogo simples e objetiva do JOptionPane é a caixa de diálogo de confirmação ou Confirm Dialog.
A Confirm Dialog (caixa de confirmação) consiste de uma caixa contendo uma mensagem, um ícone e três botões: sim, não e cancelar.
Apesar deste ser o aspecto padrão, esta caixa, como qualquer outra de JOptionPane, pode ser facilmente configurada (assunto que será tratado com mais detalhes nas próximas páginas).
No método padrão chamado showConfirmDialog usamos dois argumentos:
  1. O primeiro é a dependência ou frame pai, ou seja, de qual janela esta confirmação está sendo gerada. Como nossos exemplos iniciais não possuem nenhuma dependência, então, sempre usaremos null neste argumento.
  2. O segundo argumento é a mensagem que desejamos mostrar ao usuário.
O método showConfirmDialog sempre retorna uma constante que é a resposta clicada pelo usuário, que são:
ValorNome da ConstanteEquivale
0YES_OPTIONao clicar no botão Yes (sim)
1NO_OPTIONao clicar no botão No (não)
2CANCEL_OPTIONao clicar no botão Cancel (cancelar)
Melhorando o exemplo anterior ficaria assim.
01.import javax.swing.JOptionPane;
02. 
03.public class CaixasDeDialogo {
04.public static void main(String[] args) {
05.String nome = null;
06.nome = JOptionPane.showInputDialog("Qual é o seu nome?");
07.JOptionPane.showConfirmDialog(null"O seu nome é " + nome + "?");
08.}
09.}
A caixa de confirmação pareceria da seguinte forma:
Exemplo de Confirm Dialog da classe JOptionPane

Caixa de Diálogo de Mensagem

A caixa de diálogo de mensagem é uma caixa que serve apenas para emitir uma mensagem. Esta caixa também é muito configurável e versátil, pois serve para muitas situações distintas como uma mensagem de erro, um alerta, ou simplesmente uma informação.
O método showMessageDialog é responsável em trazer a caixa de mensagem, o qual pode ter muitos argumentos, porém, vamos nos ater ao mais simples.
Assim como o método showConfirmDialog, usaremos null como valor de nosso primeiro argumento, pois, por enquanto, não há dependência de outras janelas em nosso programa. O segundo argumento é a mensagem que desejamos emitir.
Para finalizar nosso exemplo, incluiremos as caixas de mensagem de acordo com as respostas.
01.import javax.swing.JOptionPane;
02. 
03.public class CaixasDeDialogo {
04.public static void main(String[] args) {
05.String nome = null;
06.int resposta;
07.nome = JOptionPane.showInputDialog("Qual é o seu nome?");
08.resposta = JOptionPane.showConfirmDialog(null"O seu nome é " + nome + "?");
09.if (resposta == JOptionPane.YES_OPTION) {
10.// verifica se o usuário clicou no botão YES
11.JOptionPane.showMessageDialog(null"Seu nome é " + nome);
12.else {
13.JOptionPane.showMessageDialog(null"Seu nome não é " + nome);
14.}
15.}
16.}
Faça o Download deste Código
Abaixo está um exemplo de como irá ficar a caixa de mensagem caso clique no botão YES.
Exemplo de Message Dialog da classe JOptionPane