这是一段文本框键盘监听代码，需求是：限定文本框中只能输入0~9数字，限制数字之外的非法字符的输入，以下代码虽然能限制字母的输入，但是 !@#$ 等字符依旧能进入文本框(也就是shift+1,2,3...)，原因是什么呢？求代码改进，谢谢

1. TextField tf = new TextField(20);
   
2. 
   
3. public void myEvent(){
   
4.         tf.addKeyListener(new KeyAdapter(){
   
5. 
   
6.                 public void keyPressed(KeyEvent e){
   
7.                         if(!(e.getKeyCode()>=KeyEvent.VK_0 && e.getKeyCode()<=KeyEvent.VK_9))
   
8.                                 e.consume();
   
9.                 }
   
10.         });
    
11. }

复制代码

总算来个有意思的帖子了

这个是你要的

1. public void keyPressed(KeyEvent e)
   
2.                         {
   
3.                                 e.consume();
   
4.                                 if ((e.getModifiers() == 0) && (e.getKeyCode() >= KeyEvent.VK_0 && e.getKeyCode() <= KeyEvent.VK_9))
   
5.                                 {
   
6.                                        
   
7.                                        
   
8.                                 }
   
9.                         }

复制代码

这个是另外一种办法

1. public class Document extends javax.swing.text.PlainDocument
   
2. {
   
3. 
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 JTextField jTextField = new JTextField();
   
7.                 Document document = new Document();
   
8.                 //[a-zA-Z0-9\u4e00-\u9fa5]
   
9.                 //简单的正则表达式，这你不用管，0-9是限制只有数字
   
10.                 //a-z是小写字母，\\u那个是中文
    
11.                 document.setCharLimit("[0-9]");
    
12.                 jTextField.setDocument(document);
    
13.                 //这样就限制能输入数字了
    
14.         }
    
15.         
    
16. 
    
17.         private static final long serialVersionUID = -4462693078138709956L;
    
18.          
    
19.         private String limit = ""; // 输入字符限制的正则表达式
    
20.          
    
21.         private int maxLength = -1; // 输入字符最大长度的限制，-1为不限制
    
22.         
    
23.         private double maxValue = 0; // 如果输入的是数字，则最大值限制
    
24.         
    
25.         private boolean isMaxValue = false; // 是否采用了最大值限制
    
26.         
    
27.         private java.awt.Toolkit toolkit = null; // 用来在错误的时候发出系统声音
    
28.         
    
29.         private boolean beep = false; // 是否发声，true为发出声音
    
30.         
    
31.         // 构造方法
    
32.         
    
33.         public Document()
    
34.         {
    
35.                 super();
    
36.                 this.init();
    
37.         }
    
38.         
    
39.         public Document(Content c)
    
40.         {
    
41.                 super(c);
    
42.                 this.init();
    
43.         }
    
44.         
    
45.         /**
    
46.          * 所有构造都需要的公共方法
    
47.          */
    
48.         private void init()
    
49.         {
    
50.                 toolkit = java.awt.Toolkit.getDefaultToolkit();
    
51.         }
    
52.         
    
53.         // 构造方法结束
    
54.          
    
55.         /**
    
56.          * 设置字符限制条件[a-zA-Z0-9\u4e00-\u9fa5]
    
57.          *
    
58.          * @param limit
    
59.          *            限制条件 参考正则表达式 java.util.regex.Pattern
    
60.          */
    
61.         public void setCharLimit(String limit)
    
62.         {
    
63.                 this.limit = limit;
    
64.         }
    
65.         
    
66.         /**
    
67.          * 返回字符限制的条件
    
68.          *
    
69.          * @return 条件
    
70.          */
    
71.         public String getCharLimit()
    
72.         {
    
73.                 return this.limit;
    
74.         }
    
75.         
    
76.         /**
    
77.          * 清除所有限制字符
    
78.          */
    
79.         public void clearLimit()
    
80.         {
    
81.                 this.limit = null;
    
82.         }
    
83.         
    
84.         /**
    
85.          * 字符输入限制是否包含该字符
    
86.          *
    
87.          * @param input
    
88.          *            字符
    
89.          * @return true为包含，false为不包含
    
90.          */
    
91.         public boolean isOfLimit(CharSequence input)
    
92.         {
    
93.                 if (limit == null)
    
94.                 {
    
95.                 return true;
    
96.                 }
    
97.                 else
    
98.                 {
    
99.                 return java.util.regex.Pattern.compile(limit).matcher(input).find();
    
100.                 }
     
101.         }
     
102.         
     
103.         /**
     
104.          * 字符输入的限制组是否为空
     
105.          *
     
106.          * @return true为空，false为有
     
107.          */
     
108.         public boolean isEmptyLimit()
     
109.         {
     
110.                 if (limit == null)
     
111.                 {
     
112.                 return true;
     
113.                 }
     
114.                 else
     
115.                 {
     
116.                 return false;
     
117.                 }
     
118.         }
     
119.         
     
120.         /**
     
121.          * 设置文本框所允许输入的最大字符长度
     
122.          *
     
123.          * @param maxLength
     
124.          *            最大字符长度
     
125.          */
     
126.         public void setMaxLength(int maxLength)
     
127.         {
     
128.                 this.maxLength = maxLength;
     
129.         }
     
130.         
     
131.         /**
     
132.          * 取消文本框最大字符长度的限制
     
133.          */
     
134.         public void cancelMaxLength()
     
135.         {
     
136.                 this.maxLength = -1;
     
137.         }
     
138.         
     
139.         /**
     
140.          * 如果输入的为纯数字，则可用此方法来设置数字的最大值
     
141.          *
     
142.          * @param maxValue
     
143.          *            最大值
     
144.          */
     
145.         public void setMaxValue(double maxValue)
     
146.         {
     
147.                 this.isMaxValue = true;
     
148.                 this.maxValue = maxValue;
     
149.         }
     
150.         
     
151.         /**
     
152.          * 文本框是否限制了数字内容的最大数值
     
153.          *
     
154.          * @return true为限制了
     
155.          */
     
156.         public boolean isMaxValue()
     
157.         {
     
158.                 return this.isMaxValue;
     
159.         }
     
160.         
     
161.         /**
     
162.          * 返回限制数字内容最大值
     
163.          *
     
164.          * @return double类最大值，如果没有限制会返回0
     
165.          */
     
166.         public double getMaxValue()
     
167.         {
     
168.                 return this.maxValue;
     
169.         }
     
170.         
     
171.         /**
     
172.          * 取消数字内容的最大值设置
     
173.          */
     
174.         public void cancelMaxValue()
     
175.         {
     
176.                 this.isMaxValue = false;
     
177.                 this.maxValue = 0;
     
178.         }
     
179.         
     
180.         /**
     
181.          * 使所有限制设置恢复默认
     
182.          */
     
183.         public void reset()
     
184.         {
     
185.                 clearLimit();
     
186.                 cancelMaxLength();
     
187.                 cancelMaxValue();
     
188.         }
     
189.         
     
190.         /**
     
191.          * 错误时发声开关
     
192.          *
     
193.          * @param beep
     
194.          *            true为发声音
     
195.          */
     
196.         public void errorBeep(boolean beep)
     
197.         {
     
198.                 this.beep = beep;
     
199.         }
     
200.         
     
201.         /**
     
202.          * 输入错误时是否发声
     
203.          *
     
204.          * @return boolean true为发声
     
205.          */
     
206.         public boolean isErrorBeep()
     
207.         {
     
208.                 return beep;
     
209.         }
     
210.         
     
211.         public void insertString(int offs, String str, javax.swing.text.AttributeSet a) throws javax.swing.text.BadLocationException, NumberFormatException
     
212.         {
     
213.                 // 若字符串为空，直接返回。
     
214.                 if (str == null)
     
215.                 {
     
216.                         return;
     
217.                 }
     
218.                 boolean b = true;
     
219.                 char[] ch = str.toCharArray();
     
220.                 for (int i = 0; i < ch.length; i++)
     
221.                 {
     
222.                         String temp = String.valueOf(ch[i]);
     
223.                         // 如果要输入的字符不在允许范围内
     
224.                         if (!isOfLimit(temp))
     
225.                         {
     
226.                                 b = false;
     
227.                         }
     
228.                         
     
229.                         // 如果有字符长度限制，并且现在的字符长度已经大于或等于限制
     
230.                         if (maxLength > -1 && this.getLength() >= maxLength)
     
231.                         {
     
232.                                 b = false;
     
233.                         }
     
234.                 }
     
235.                 // 如果内容设置了最大数字
     
236.                 if (isMaxValue)
     
237.                 {
     
238.                         String s = this.getText(0, this.getLength()); // 文档中已有的字符
     
239.                         s = s.substring(0, offs) + str + s.substring(offs, s.length());
     
240.                         if (Double.parseDouble(s) > maxValue)
     
241.                         {
     
242.                                 if (beep)
     
243.                                 {
     
244.                                         toolkit.beep(); // 发出声音
     
245.                                 }
     
246.                                 return;
     
247.                         }
     
248.                 }
     
249.                   
     
250.                 // 如果输入不合法
     
251.                 if(!b)
     
252.                 {
     
253.                         if (beep)
     
254.                         {
     
255.                                 toolkit.beep(); // 发出声音
     
256.                         }
     
257.                         return;
     
258.                 }
     
259.                
     
260.                 super.insertString(offs, new String(ch), a);
     
261.         }
     
262. 
     
263. }

复制代码

用输入法输入数字字母也是检测不到滴哦。。

因为要输入数字与输入你所说的特殊字符时按的键是同一个键，只不过输入特殊字符时要按下shift键，你可以在if语句上加一句System.out.println(e.getkeyCode());这样你就会看到你所按的键的值，但你输入1时所按的键值是49，输入！时所按的键值为16   49，符合if条件，所以能输进去，另外，在输入时必须是英文输入法才行，若是中文输入法，则能输入汉字而且不会显示键值。

个人认为应该在接受键值时他是判断shift是否被按下在输出值，也就是说你按下a+1是显示1.但你按下shift+1显示！一样，他不会去判断按了a没，却判断shift键按下没，所以加上一句 if(!(!e.isShiftDown()&&e.getKeyCode()>=KeyEvent.VK_0 && e.getKeyCode()<=KeyEvent.VK_9))中的!e.isShiftDown()，当按下shift键时不去显示值。这样就只能显示数字了！