Home > Artigos > Interfaces Gráficas >

Campo formatado para valores decimais

Publicado por sekkuar em 31/01/2013 - 12.685 visualizações

Muitas vezes é necessário ter um campo que só permita valores,
ou que deixe o valor inserido em algum formato, como monetário,
sem que se torne complicado demais recuperar o valor digitado
como decimal, enquanto exibe o valor formatado.

Essa classe pode ser usada para diferentes tipos de valores,
ela permite que você escolha qual é o formato, e guarda o valor,
em double para melhor acesso aos dados

E ainda mostra uma mensagem de erro/aviso caso um valor
no formato incorreto tenha sido digitado (por exemplo uma letra)

import java.awt.Color;
import javax.swing.*;
import java.text.*;
import java.awt.event.*;
import java.math.RoundingMode;
/**
 * Classe para criar campos formatados com valores em decimal
 * Tanto para valores simples, como para exibir máscaras monetárias 
 * ou porcentagem
 * 
 * @author Sekkuar
 *
 */
public class DecimalFormattedField extends JFormattedTextField {

/**Constantes para definir o formato*/
    public static final String NUMERO = "#,##0.00; -#,##0.00";
    public static final String REAL = "R$ #,##0.00;R$ -#,##0.00";
    public static final String PORCENTAGEM = "#,##0.00'%';-#,##0.00'%'";
    
    /**Formato sendo utilizado*/
    private DecimalFormat df;
    
    /**Valor inserido no campo*/
    private double dValue = 0.0;
    
    /**Ultimo valor válido*/
    private String oldValue = "0.00";
    
    /**String que será exibida em caso de valor inválido ou fora do formato*/
    public static final String ERRO = "Valor inválido";

/**
     * Cria um novo objeto DecimalFormattedField, com o formato especificado
     * 
     * @param formato Uma String que será o formato (pattern) do DecimalFormat a ser utilizado
     */
    public DecimalFormattedField(String formato) {
        super();

df = new DecimalFormat();
        df.setRoundingMode(RoundingMode.UP);
        df.applyPattern(formato);

this.setHorizontalAlignment(JTextField.RIGHT);

setValue(oldValue);
        applyActions();
    }

/**Aplica um novo DecimalFormat*/
    public void setDf(DecimalFormat df) {
        this.df = df;
        setValue("0.00");
        this.thisFocusGained(null);
        setText("0.00");
    }

/**Retorna o DecimalFormat sendo usado atualmente*/
    public DecimalFormat getDf() {
        return df;
    }

/**
     * Cria as ações de focus para setar e verificar os valores digitados
     */
    private void applyActions() {

this.addActionListener(new ActionListener() {

@Override
            public void actionPerformed(ActionEvent e) {
                transferFocus();
            }
        });

this.addFocusListener(new FocusListener() {

@Override
            public void focusLost(FocusEvent evt) {
                thisFocusLost(evt);
            }

@Override
            public void focusGained(FocusEvent evt) {
                thisFocusGained(evt);
            }
        });

}

/**Verifica se o valor digitado é válido, e insere os novos valores*/
    public void thisFocusLost(FocusEvent evt) {
        String valor = getText().replace(',', '.');
        if (!valor.equals("") && !valor.trim().isEmpty()) {
            oldValue = valor;
        }
        setValue(valor);
    }

/**Limpa o campo para que seja digitado novo valor*/
    public void thisFocusGained(FocusEvent fe) {
        super.setText("");
        normalText();
    }

/**Seta os valores no campo*/
    private void setValue(String value) {
        try {
            dValue = arredondar(Double.parseDouble(value));            
        } catch (Exception e) {
            /**Aqui o valor é inválido, então coloca novamente o valor antigo*/
            value = oldValue;
        }
        showValue(value);
    }

@Override
    public void setValue(Object value) {
        if(value instanceof Double){
            double d = (Double) value;
            this.setText(String.format("%f", d));
        }else{
            this.setText(value.toString());
        }
    }

/**
     * Mostra o valor formatado no padrão do DecimalFormat
     * @param s valor informado no campo
     */
    public void showValue(String s) {
        try {
            super.setText(df.format(new java.math.BigDecimal(s)));
        } catch (Exception e) {
            /**Valor inválido, exibe mensagem de erro*/
            error();
            dValue = Double.NaN;
        }
    }

/**
     * Retorna o valor inserido no campo.
     * @return dValue double value
     */
    public double getDoubleValue() {
        return dValue;
    }

@Override
    public Object getValue() {
        return getDoubleValue();
    }

/**
     * Mostra o texto ERRO em vermelho.
     */
    private void error() {
        this.setForeground(Color.red);
        super.setText(ERRO);
    }

/**
     * Volta o texto ao formato original
     */
    private void normalText() {
        this.setForeground(null);
    }

@Override
    public void setText(String valor) {
        super.setText(valor);
        this.thisFocusLost(null);
    }

/**Arredondamento para corrigir possíveis diferenças em decimal do valor exibido com o valor retornado*/
    public double arredondar(double d) {
        if (d > 0) {
            return (Math.ceil((d * 100.0))) / 100.0;
        } else {
            return (Math.floor((d * 100.0))) / 100.0;
        }
    }
}

Usar essa classe é muito fácil, ela pode ser colocada no lugar de qualquer componente JFormattedTextField ou JTextField, alguns formatos mais comuns estão já definidos como constantes na classe, para melhor utilização.

Aqui mostro um pequeno teste para ilustrar o uso da classe:

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

/**
 *
 * @author Sekkuar
 */
public class TesteDecimalField extends JFrame {

JFormattedTextField numero = new DecimalFormattedField(DecimalFormattedField.NUMERO);
    JFormattedTextField real = new DecimalFormattedField(DecimalFormattedField.REAL);
    JFormattedTextField porcentagem = new DecimalFormattedField(DecimalFormattedField.PORCENTAGEM);

public TesteDecimalField() {
        setLayout(new GridLayout(7, 1, 5, 5));
        
        add(new JLabel("Valor numérico:"));
        add(numero);

add(new JLabel("Valor monetário:"));
        add(real);

add(new JLabel("Valor porcento:"));
        add(porcentagem);
        JButton button = new JButton("Mostrar Valores");
        
        button.addActionListener(new ActionListener(){

@Override
            public void actionPerformed(ActionEvent e) {
                /**
                 * em versões do java anteriores à 7
                 * utilize (Double) para fazer o cast ao inves de (double)
                 */
                double valor1 = (double) numero.getValue();                                   
                double valor2 = (double) real.getValue();
                double valor3 = (double) porcentagem.getValue();
                
                String valor = valor1+"\n"+valor2+"\n"+valor3;
                
                JOptionPane.showMessageDialog(TesteDecimalField.this, valor, "Valores", JOptionPane.INFORMATION_MESSAGE);
            }
            
        });
        
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        add(button);
        pack();
    }
    
    public static void main(String...args){
        new TesteDecimalField().setVisible(true);
    }
}

Essa classe de teste gera o seguinte resultado

Ou seja, essa classe é muito versátil, pode ser usada tanto para os formatos já difinidos, como qualquer outro formato permitido por um DecimalFormat
(Para mais informações sobre formatos, acesse o tutorial do java)

**Grande parte dos crétidos para esta classe vão para este tópico que me forneceu a base para a implementação.

Download:	tela1.png
Size:	20 KB

Download:	tela2.png
Size:	11 KB

comentários: 7

Home > Artigos > Interfaces Gráficas >

Campo formatado para valores decimais

Tópicos Relacionados