Publicado em: 26/05/2009 12:01:00

Galera,
eu estou fazendo uma calculadora, estou usando o NetBeans, usei um jFormattedTxtField para a tela e defini uma mascara so pra numeros nas propriedades, mas ainda assim qundo eu digito letras, elas aparecem como fazer pra não aparecerem?
Outro pro é, qundo eu aperto o botão para inserir os numeros pra fazr operações aew tudo bem ele insere e eu consigo fazer sem probelmas, mas qundo eu digito não faz.
Qundo eu digito 1 aperto a tecla de somar e dpois clico em outro numero ele faz a operação mas qundo eu digito por exeplo 12 na tela e aperto + aparece assim na tela 12.00.

espero que vcs possam me ajudar
[]s
_________________
Jean Gleison de S. Silva
e-mail: jeangleison2@gmail.com
msn: jeanvidaloucaparte1@hotmail.com

Publicado em: 26/05/2009 13:12:27

Posta o código aqui amigão.

Ninguém aqui curte fazer o Dever de Casa de ninguém.

Desculpe o mal jeito do pedido, mas é que já houve perguntas sobre o MESMO exercicio aqui e um outro "cidadão" pedindo ajuda URGENTE!!!!1!!1111.

Se for uma dúvida legitima, e já tem algo pronto, posta que ajudaremos com prazer.
_________________
KISS: Keep It Simple Stupid;
JEDI: Java Enchanted Developer Insider;
POG: O lado negro da Força;

Publicado em: 27/05/2009 23:31:41

cara num é que eu queira que ninguém faça meu dever de casa, se não adintaria de q? eu não ia aprebder nada e ainda por cima não ia tyer créditos para com o desenvolvimento! Só perguntei como fazer, só os passos entende? uma dica de como fazer! Só usei a calculadora como contexto!
Pense numa jFormattedTextField que cuja a mascara é só pra números, como faço pra aparecer somente numeros quando eu digitar!?
Vo usar o keyPressed será que dá certo?
Entendeu agora cara?! e desculpa qulqer coisa vlws aew grato!
_________________
Jean Gleison de S. Silva
e-mail: jeangleison2@gmail.com
msn: jeanvidaloucaparte1@hotmail.com

Publicado em: 28/05/2009 00:13:00

E ae, boa noite!!!

O JFormatted Text Field é bem fácil de usar!!

Não use o listener que disse!! É pior que reiventar a roda... O campo de texto formatado é bem fácil e "entendível", abaixo o exemplo:

import java.text.ParseException; import javax.swing.JFormattedTextField; import javax.swing.JFrame; import javax.swing.JTextField; import javax.swing.text.MaskFormatter; public class CampoFormatadoExemplo extends JFrame {     JTextField txt;     public CampoFormatadoExemplo() {    super("Exemplo de Campo Formatado");    setDefaultCloseOperation(EXIT_ON_CLOSE);    setSize(200, 100);    setLayout(null);            /*O JFormattedTextField é uma classe que herda de JTextField    No construtor ele recebe um maskformatter, cujo construtor recebe uma    string com a formatação, no caso, coloquei que só números podem entrar    Importante que ele gera um exceção se não conseguir fazer parse da máscara    para o campo de texto    */        try {        txt = new JFormattedTextField(new MaskFormatter("###########"));    } catch (ParseException e) {        System.out.println("Erro ao gerar máscara");    }    txt.setBounds(5, 20, 100, 20);    add(txt);     }     public static void main(String[] args) {    new CampoFormatadoExemplo().setVisible(true);     } }

Olha aqui para ver as opções de formatação:

http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/text/MaskFormatter.html

Eu, particularmente, curto muito essa forma de formatar, é bem rápida e precisa!

OBS: Nobre da sua parte não se sentir bem quando mostra um código que não foi você que fez! Nem todos são assim!

Espero ter ajudado, posta ae mais dúvidas, se houverem, para ajudar de forma coletiva!

OBS2: Editei, tinham uns errinhos de português :D


_________________
William Antônio Siqueira
Siga-me no Twitter - Tudo sobre JavaFX e um pouco mais
Veja meu Blog

Publicado em: 28/05/2009 12:29:03

Apoiado jesuino.

Louvável sua atitude companheiro, mas a sua pergunta foi ruim.
Se tivesse feito a pergunta sobre o JFormattedTextField no inicio, teria sua resposta fácil.

Se você leu as páginas que mandei, deve ter entendido como nos sentimos aqui no JAVAFREE sobre Dever de Casa.

Abraço e sucesso.
_________________
KISS: Keep It Simple Stupid;
JEDI: Java Enchanted Developer Insider;
POG: O lado negro da Força;

Publicado em: 28/05/2009 12:58:36

Verdade, o problema é que quando ajudamos em dever de casa, ajudamos também com o mercado que temos, muitas pessoas não qualificadas, com certificado. Contribuimos com a facilidade da vida dos outros, irão achar que tudo é fácil!


_________________
William Antônio Siqueira
Siga-me no Twitter - Tudo sobre JavaFX e um pouco mais
Veja meu Blog

Publicado em: 28/05/2009 13:13:28

Oi,
uma outra maneira seria usar um JTextField e um PlainDocument com um DocumentFilter alterado. (EU pessoalmente não gosto do JFormattedTextField, pelo menos para entrada de dados.)

O DocumentFilter é um pouco mais trabalhoso mas possibilita um controle melhor do que é permitido ou não:
// exemplo permitindo apenas números        DocumentFilter filter = new DocumentFilter() {             @Override             public void insertString(FilterBypass fb, int offset, String text, AttributeSet attr)                     throws BadLocationException { //                if (text.matches("[0-9]*+")) //                    fb.insertString(offset, text, attr);                 fb.insertString(offset, text.replaceAll("[^0-9]", ""), attr);             }             @Override             public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attrs)                     throws BadLocationException { //                if (text.matches("[0-9]*+")) //                    fb.replace(offset, length, text, attrs);                 fb.replace(offset, length, text.replaceAll("[^0-9]", ""), attrs);             }         };                 PlainDocument doc = new PlainDocument();         doc.setDocumentFilter(filter);                 JTextField tf = new JTextField();         tf.setDocument(doc);
[]]
_________________
Carlos Heuberger
GC do Javafree.org
____________________________________________________________________________
This posting is provided AS IS with
no warranties and confers no rights.

Publicado em: 28/05/2009 21:47:28

Nossa!! Vivendo e aprendendo. Não conhecia esse componente, me parece ser bem melhor por aceitar uma ER como máscara, assim não há limitações.
Muitas vezes tive problemas com o Formatted(...) não deixar o usuário escrever até o fim!
O tópico não criado por mim, mas agradeço também!! Obrigado!
_________________
William Antônio Siqueira
Siga-me no Twitter - Tudo sobre JavaFX e um pouco mais
Veja meu Blog

Publicado em: 29/05/2009 00:26:15

Obg galera do javaFree e muito obg mesmo desculpa aew...vou ser mais objetivo nas minhas perguntas...é que sou novo na área e no grupo aqui...!
_________________
Jean Gleison de S. Silva
e-mail: jeangleison2@gmail.com
msn: jeanvidaloucaparte1@hotmail.com

Publicado em: 29/05/2009 11:26:42

jesuino:

Nossa!! Vivendo e aprendendo. Não conhecia esse componente, me parece ser bem melhor por aceitar uma ER como máscara, assim não há limitações.
Muitas vezes tive problemas com o Formatted(...) não deixar o usuário escrever até o fim!
O tópico não criado por mim, mas agradeço também!! Obrigado!

aprendí esse dias no stackoverflow...
a vantagem é maior... pois não está restrito ao uso de ER, voce pode programar qualquer coisa lá dentro, só não fica bom ser for algo demorado...
[]]
_________________
Carlos Heuberger
GC do Javafree.org
____________________________________________________________________________
This posting is provided AS IS with
no warranties and confers no rights.

Publicado em: 29/05/2009 12:01:15

simu:

O DocumentFilter é um pouco mais trabalhoso mas possibilita um controle melhor do que é permitido ou não:

Como eu realmente curti essa forma de formatar, Estou fazendo uma API que facilite o uso(comecei as 8 de hoje :hauhau: ), depois irei utilizar em meus projetos, quando tiver bem testada, podemos colocar nos minis exemplos!!

Vou tentar explicar rapidinho aqui.

A idéia principal é deixar o filro mais acessível e o documento flexível!
O próximo passo é usar a fábrica para criar novos tipos de campo de texto, ou gerar tipos concretos, assim poderíamos ter:

JTextField = new JTextOnlyNumber();

Sem mexer em mais nada no seu projeto existente. :metal:

Para o filtro, usei uma fábrica(padrão Factory) meio que alterada. Daí temos filtros de vários tipos. A idéia era ficar todas as configurações no filtro, usando ele como fábrica, mas ainda era um nível baixo de acesso, precisavamos criar uma camada acima, para que o documento conhecesse ele, não o programa principal.

Assim ficou o filtro(em construção :mrgreen: ):
package factory; import javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.text.DocumentFilter; public class DocumentFilterFactory extends DocumentFilter{        public static final int SO_NUMEROS = 0;    public static final int SO_LETRAS = 1;    private String er;        public static DocumentFilterFactory criar(int tipo){       switch (tipo) {       case SO_NUMEROS:          return new DocumentFilterFactory("[^0-9]");                case SO_LETRAS:          return new DocumentFilterFactory("[^A-Z|^a-z]");                default:          return new DocumentFilterFactory("");                }       }    public static DocumentFilterFactory criar(String er){       return new DocumentFilterFactory(er);       }        private DocumentFilterFactory(String pEr){       super();       this.er = pEr;    }        @Override    public void insertString(FilterBypass fb, int offset, String text,          AttributeSet attr) throws BadLocationException {       fb.insertString(offset, text.replaceAll(this.er, ""), attr);    }    @Override    public void replace(FilterBypass fb, int offset, int length, String text,          AttributeSet attrs) throws BadLocationException {       fb.replace(offset, length, text.replaceAll(this.er, ""), attrs);     } }

Em seguida, criei uma fábrica de documento. O que me foi horrível, pois quando fui criar um documento novo tive que mexer dentro do código da fábrica e isso poderia alterar quem usava o documento, tendo que conhecer os parâmetros para chamar a fábrica. Assim, decide usar o estratégia. Dessa forma, eu poderia simplesmente adicionar uma nova implementação da minha interface, mexendo em dois prontos e enfraquecendo a ligação entre o quem usa o documento e o documento concreto, pois esa poderia ser através de uma interface. Uma simples Composição! (Editado, lembrei agora que era uma composição: Prefira composição do que herança)
A interface tem só um método:
package strategy; import javax.swing.text.PlainDocument; public interface IDocument {    /*     * Retorna um NOVO documento     * Poderíamos usar o singleton combinado com as classes concretas     * para retornar sempre uma única instância, para economia de memória     * Assim,um ou campos de texto poderiam utilizar a mesma referência     * de formatação     */    public PlainDocument novoDocumentoPlano(); }

Assim, as concretas devem implementar esse método. Fiz três, para teste.

Uma para filtrar o que não é número:

package strategy.concretas; import javax.swing.text.PlainDocument; import factory.DocumentFilterFactory; import strategy.IDocument; public class DocNumeros implements IDocument {    public DocNumeros() {       super();    }    @Override    public PlainDocument novoDocumentoPlano() {       PlainDocument doc = new PlainDocument();       doc.setDocumentFilter(DocumentFilterFactory             .criar(DocumentFilterFactory.SO_NUMEROS));       return doc;    } }

Filtra só letras:

package strategy.concretas; import javax.swing.text.PlainDocument; import factory.DocumentFilterFactory; import strategy.IDocument; public class DocLetras implements IDocument{    @Override    public PlainDocument novoDocumentoPlano() {       PlainDocument doc = new PlainDocument();       doc.setDocumentFilter(DocumentFilterFactory             .criar(DocumentFilterFactory.SO_LETRAS));       return doc;    } }

Recebe a ER para filtrar:

package strategy.concretas; import javax.swing.text.PlainDocument; import factory.DocumentFilterFactory; import strategy.IDocument; public class DocNovo implements IDocument {    String er;    public DocNovo(String pEr){       this.er = pEr;    }        @Override    public PlainDocument novoDocumentoPlano() {       PlainDocument doc = new PlainDocument();       doc.setDocumentFilter(DocumentFilterFactory.criar(er));       return doc;    } }

Estava pronto, temos campos de texto formatados com só uma linha de código! Mas ainda queria testar se realmente tava legal, então eu criei uma nova formatação, com classe concreta:

package strategy.concretas; import javax.swing.text.PlainDocument; import factory.DocumentFilterFactory; import strategy.IDocument; /* * Essa classe é um exemplo que você pode criar novos tipo * */ public class DocCriadoAqui implements IDocument{    @Override    public PlainDocument novoDocumentoPlano() {       PlainDocument doc = new PlainDocument();       //Vor criar uma que aceite só minúsculas       doc.setDocumentFilter(DocumentFilterFactory.criar("[^a-z]"));       return doc;    } }

Perfeito!! Funcionou! Mas eu nem me impressionei muito. Primeiro porque padrões são assim mesmo, fazem mágicas! Segundo porque ainda não estava daquele jeito, pois a classe final tinha que conhecer os tipos de documento, o que não é legal. Assim, poderíamos criar tipos de campos de texto.
Criei só uma para teste, porque esta prática tem muitas falhas, e a primeira dela é que "você está programando para uma implementação, não para uma interface", a outra é a segurança, pois o método setDocument pode ser alterado "por fora", então o nosso campo poderia perder a finalidade, se alguém mexer nesse método. É claro que existem muitas soluções(mais padrões e blá blá) para isso, mas já é outra história.

Olha o exemplo de concreta:

package camposDeTextoFormatados; import javax.swing.JTextField; import strategy.concretas.DocNumeros; public class JTextField4Numbers extends JTextField {    private static final long serialVersionUID = 1L;        public JTextField4Numbers(){       super();       setDocument((new DocNumeros()).novoDocumentoPlano());    } }

Agora é a parte mais legal, testar!!

Fiz um JFrame e testei alguns tipos:

import java.awt.GridLayout; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JTextField; import camposDeTextoFormatados.JTextField4Numbers; import strategy.IDocument; import strategy.concretas.DocCriadoAqui; import strategy.concretas.DocLetras; import strategy.concretas.DocNovo; import strategy.concretas.DocNumeros; public class MyFrame extends JFrame {    private static final long serialVersionUID = 1L;    /*     * Estamos usando o campo de texto diretamente, mas poderíamos     * gerar uma nova classe que teria tipos de textos já definidos      * */    private JTextField txt1, txt2, txt3, txt4, txt5;        /*     * Pode ser qualquer um documento para a filtragem!     *     * */    private IDocument doc;        public MyFrame() {       super("Exemplo: Fábrica e estratégia");       setDefaultCloseOperation(EXIT_ON_CLOSE);       setSize(400, 150);       setLayout(new GridLayout(5,5));       setResizable(false);       txt1 = new JTextField();              /*        * Aqui está nossa estratégia!!        * Quando instanciar o documento você terá o comportamento        * de acordo com o tipo!        */       doc = new DocNumeros();                 txt1.setDocument(doc.novoDocumentoPlano());       add(new JLabel("Só números"));       add(txt1);              /*        * Nos casos abaixo iremos instanciar um dos tipo pré feitos        * diretamente na chamada do método para adicionar o documento        * Isso mostrará a perfeição do uso dos padrões, a flexíbilidade,        * o polimorfismo e o encapsulamento, consequentemente, reuso!        * */       txt2 = new JTextField();       txt2.setDocument((new DocLetras()).novoDocumentoPlano());       add(new JLabel("Só letras"));       add(txt2);              txt3 = new JTextField();       //Vou fazer ele escrever só maiúsculas, para teste       txt3.setDocument((new DocNovo("[^A-Z]")).novoDocumentoPlano());       add(new JLabel("Só Maiúsculas"));       add(txt3);              txt4 = new JTextField();       //Esse é o que eu criei depois de toda a estrutura estar pronta       //demonstrando o poder dos padrões em uso       txt4.setDocument((new DocCriadoAqui()).novoDocumentoPlano());       add(new JLabel("Só Minúsculas"));       add(txt4);              txt5 = new JTextField4Numbers();       add(new JLabel("Campo já pronto(Só Números)"));       add(txt5);    }    public static void main(String[] args) {       new MyFrame().setVisible(true);    } }

Rodou legal, estou incluido o projeto para quem quiser se divertir! (EDITADO: Infelizmente o proxy da empresa não está me permitindo fazer upload =[)
Para quem quiser fazer o projeto passo passo, minha estrutura de pastas:


Finalizando: É claro que deve haver outras formas de fazer formatação sem ter que fazer um monte de coisa assim, mas serve para exemplificar e ensinar de forma didática. Além de colocar em prática os padrões. Existem muitos pontos a melhorar ai, mas é que fiz correndo :mrgreen: .
Enfim, espero que esse exemplo ajude alguém. Sei que eu irei utilizar a "API" daqui pra frente em meus projetos ^^.
_________________
William Antônio Siqueira
Siga-me no Twitter - Tudo sobre JavaFX e um pouco mais
Veja meu Blog

Mudar tamanho do label
http://javafree.uol.com.br/topic-868935-Mudar-tamanho-do-label.html

JFormattedTextField com formato decimal
http://javafree.uol.com.br/topic-855866-JFormattedTextField-com-formato-decimal.html

pq a data nao aparece formatada
http://javafree.uol.com.br/topic-864191-pq-a-data-nao-aparece-formatada.html

Datas
http://javafree.uol.com.br/topic-9942-Datas.html

Evento do JSlider não faz chamada de metodo...Por que??
http://javafree.uol.com.br/topic-859547-Evento-do-JSlider-nao-faz-chamada-de-metodoPor-que.html

Como criar os objetos?
http://javafree.uol.com.br/topic-1693-Como-criar-os-objetos.html

Extensão para o Firefox
http://javafree.uol.com.br/topic-856660-Extensao-para-o-Firefox.html

Como defini um pequeno campo de texto??? Dúvida cruel!!!
http://javafree.uol.com.br/topic-877821-Como-defini-um-pequeno-campo-de-texto-Duvida-cruel.html

Valor padrão no JOptionPane.showInputDialog
http://javafree.uol.com.br/topic-2515-Valor-padrao-no-JOptionPaneshowInputDialog.html