1. import java.awt.*;
   
2. import javax.swing.*;
   
3. import java.awt.event.*;
   
4. 
   
5. class JZChange extends JFrame implements ActionListener,MouseListener{
   
6. 
   
7. <FONT color=red>……省略组件的定义
   
8. </FONT>
   
9. /*
   
10. *进制转换具体实现方法
    
11. */
    
12. 
    
13. //1、二进制转八进制
    
14. public static String binToOct(String s){ //先将二进制转化为十进制存储，再进行位运算
    
15. int data = 0; //临时数据,初始化为0
    
16. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移一位再或运算
    
17. data = (s.charAt(i)-'0')|(data<<1);
    
18. }
    
19. s = "";
    
20. while(true){
    
21. int tmp = data & 7; //与7进行与运算
    
22. System.out.println(tmp);
    
23. s = tmp + s;
    
24. data >>= 3; //右移三位
    
25. if(data == 0)
    
26. break;
    
27. }
    
28. return s;
    
29. }
    
30. public static String binToDec(String s){ //2、二进制转十进制
    
31. int data = 0; //临时数据,初始化为0
    
32. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移一位再或运算
    
33. data = (s.charAt(i)-'0')|(data<<1);
    
34. }
    
35. s = Integer.toString(data); //将数字再转化为字符串
    
36. return s;
    
37. }
    
38. public static String binToHex(String s){ //3、二进制转十六进制
    
39. int data = 0; //临时数据,初始化为0
    
40. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移一位再或运算
    
41. data = (s.charAt(i)-'0')|(data<<1);
    
42. }
    
43. s = "";
    
44. while(true){
    
45. int tmp = data & 15; //与15进行与运算
    
46. if(tmp >= 10){
    
47. char tmpChar = (char)((char)tmp + '7');
    
48. s = tmpChar + s;
    
49. }else
    
50. s = tmp + s;
    
51. data >>= 4; //右移四位
    
52. if(data == 0)
    
53. break;
    
54. }
    
55. return s;
    
56. }
    
57. public static String octToBin(String s){ //4、八进制转二进制
    
58. int data = 0; //临时数据,初始化为0
    
59. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移三位再或运算
    
60. data = (s.charAt(i)-'0')|(data<<3);
    
61. }
    
62. s = "";
    
63. while(true){
    
64. int tmp = data & 1; //与1做与运算
    
65. s = tmp + s;
    
66. data >>= 1; //右移一位
    
67. if(data == 0) //判断原始数据是否为0
    
68. break;
    
69. }
    
70. return s;
    
71. }
    
72. public static String octToDec(String s){ //5、八进制转十进制
    
73. int data = 0; //临时数据,初始化为0
    
74. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移三位再或运算
    
75. data = (s.charAt(i)-'0')|(data<<3);
    
76. }
    
77. s = Integer.toString(data);
    
78. return s;
    
79. }
    
80. public static String octToHex(String s){ //6、八进制转十六进制
    
81. int data = 0; //临时数据,初始化为0
    
82. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移三位再或运算
    
83. data = (s.charAt(i)-'0')|(data<<3);
    
84. }
    
85. s = "";
    
86. while(true){
    
87. int tmp = data & 15; //与15做与运算
    
88. if(tmp >= 10){
    
89. char tmpChar = (char)((char)tmp + '7');
    
90. s = tmpChar + s;
    
91. }else
    
92. s = tmp + s;
    
93. data >>= 4; //右移四位
    
94. if(data == 0) //判断原始数据是否为0
    
95. break;
    
96. }
    
97. return s;
    
98. }
    
99. public static String decToBin(String s){ //7、十进制转二进制
    
100. int data = 0;
     
101. data = Integer.parseInt(s);
     
102. s = "";
     
103. while(true){
     
104. int tmp = data & 1; //与1做与运算
     
105. s = tmp + s;
     
106. data >>= 1; //右移一位
     
107. if(data == 0) //判断原始数据是否为0
     
108. break;
     
109. }
     
110. return s;
     
111. }
     
112. public static String decToOct(String s){ //8、十进制转八进制
     
113. int data = 0;
     
114. data = Integer.parseInt(s);
     
115. s = "";
     
116. while(true){
     
117. int tmp = data & 7; //与7做与运算
     
118. s = tmp + s;
     
119. data >>= 3; //右移三位
     
120. if(data == 0) //判断原始数据是否为0
     
121. break;
     
122. }
     
123. return s;
     
124. }
     
125. public static String decToHex(String s){ //9、十进制转十六进制
     
126. int data = 0;
     
127. data = Integer.parseInt(s);
     
128. s = "";
     
129. while(true){
     
130. int tmp = data & 15; //与15进行与运算
     
131. if(tmp >= 10){
     
132. char tmpChar = (char)((char)tmp + '7');
     
133. s = tmpChar + s;
     
134. }else
     
135. s = tmp + s;
     
136. data >>= 4; //右移四位
     
137. if(data == 0)
     
138. break;
     
139. }
     
140. return s;
     
141. }
     
142. public static String hexToBin(String s){ //10、十六进制转二进制
     
143. int data = 0; //临时数据,初始化为0
     
144. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移四位再或运算
     
145. char tmpChar = s.charAt(i);
     
146. if(tmpChar >= 'A')
     
147. data = (s.charAt(i)-'7')|(data<<4);
     
148. else
     
149. data = (s.charAt(i)-'0')|(data<<4);
     
150. }
     
151. s = "";
     
152. while(true){
     
153. int tmp = data & 1; //与1做与运算
     
154. s = tmp + s;
     
155. data >>= 1; //右移一位
     
156. if(data == 0) //判断原始数据是否为0
     
157. break;
     
158. }
     
159. return s;
     
160. }
     
161. public static String hexToOct(String s){ //11、十六进制转八进制
     
162. int data = 0; //临时数据,初始化为0
     
163. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移四位再或运算
     
164. char tmpChar = s.charAt(i);
     
165. if(tmpChar >= 'A')
     
166. data = (s.charAt(i)-'7')|(data<<4);
     
167. else
     
168. data = (s.charAt(i)-'0')|(data<<4);
     
169. }
     
170. s = "";
     
171. while(true){
     
172. int tmp = data & 7; //与7做与运算
     
173. s = tmp + s;
     
174. data >>= 3; //右移三位
     
175. if(data == 0) //判断原始数据是否为0
     
176. break;
     
177. }
     
178. return s;
     
179. }
     
180. public static String hexToDec(String s){ //12、十六进制转十进制
     
181. int data = 0; //临时数据,初始化为0
     
182. for(int i=0;i<s.length();i++){ //循环位移再或，初始化为0，将数据左移四位再或运算
     
183. char tmpChar = s.charAt(i);
     
184. if(tmpChar >= 'A')
     
185. data = (s.charAt(i)-'7')|(data<<4);
     
186. else
     
187. data = (s.charAt(i)-'0')|(data<<4);
     
188. }
     
189. s = Integer.toString(data);
     
190. return s;
     
191. }
     
192. 
     
193. public void actionPerformed(ActionEvent e) {
     
194. //点击二进制按钮
     
195. if(e.getSource() == jRB_2){
     
196. jRB_2.setSelected(true);
     
197. jRB_8.setSelected(false);
     
198. jRB_10.setSelected(false);
     
199. jRB_16.setSelected(false);
     
200. for(int i = 0;i < 2;i++){
     
201. jButtons[i].setEnabled(true);
     
202. }
     
203. for(int i = 2;i < 16;i++){
     
204. jButtons[i].setEnabled(false);
     
205. }
     
206. jTextField.setText("");
     
207. switch(curFlag){
     
208. case 8:
     
209. if(displayStr != "")
     
210. displayStr = this.octToBin(displayStr);
     
211. break;
     
212. case 10:
     
213. if(displayStr != "")
     
214. displayStr = this.decToBin(displayStr);
     
215. break;
     
216. case 16:
     
217. if(displayStr != "")
     
218. displayStr = this.hexToBin(displayStr);
     
219. break;
     
220. default:
     
221. break;
     
222. }
     
223. curFlag = 2;
     
224. jTextField.setText(displayStr);
     
225. }
     
226. //点击八进制按钮
     
227. if(e.getSource() == jRB_8){
     
228. jRB_2.setSelected(false);
     
229. jRB_8.setSelected(true);
     
230. jRB_10.setSelected(false);
     
231. jRB_16.setSelected(false);
     
232. for(int i = 0;i < 8;i++){
     
233. jButtons[i].setEnabled(true);
     
234. }
     
235. for(int i = 8;i < 16;i++){
     
236. jButtons[i].setEnabled(false);
     
237. }
     
238. jTextField.setText("");
     
239. switch(curFlag){
     
240. case 2:
     
241. if(displayStr != "")
     
242. displayStr = this.binToOct(displayStr);
     
243. break;
     
244. case 10:
     
245. if(displayStr != "")
     
246. displayStr = this.decToOct(displayStr);
     
247. break;
     
248. case 16:
     
249. if(displayStr != "")
     
250. displayStr = this.hexToOct(displayStr);
     
251. break;
     
252. default:
     
253. break;
     
254. }
     
255. curFlag = 8;
     
256. jTextField.setText(displayStr);
     
257. }
     
258. //点击十进制按钮
     
259. if(e.getSource() == jRB_10){
     
260. jRB_2.setSelected(false);
     
261. jRB_8.setSelected(false);
     
262. jRB_10.setSelected(true);
     
263. jRB_16.setSelected(false);
     
264. for(int i = 0;i < 10;i++){
     
265. jButtons[i].setEnabled(true);
     
266. }
     
267. for(int i = 10;i < 16;i++){
     
268. jButtons[i].setEnabled(false);
     
269. }
     
270. jTextField.setText("");
     
271. switch(curFlag){
     
272. case 2:
     
273. if(displayStr != ""){
     
274. displayStr = this.binToDec(displayStr);
     
275. }
     
276. break;
     
277. case 8:
     
278. if(displayStr != ""){
     
279. displayStr = this.octToDec(displayStr);
     
280. }
     
281. break;
     
282. case 16:
     
283. if(displayStr != ""){
     
284. displayStr = this.hexToDec(displayStr);
     
285. }
     
286. break;
     
287. default:
     
288. break;
     
289. }
     
290. curFlag = 10;
     
291. jTextField.setText(displayStr);
     
292. }
     
293. //点击十六进制按钮
     
294. if(e.getSource() == jRB_16){
     
295. jRB_2.setSelected(false);
     
296. jRB_8.setSelected(false);
     
297. jRB_10.setSelected(false);
     
298. jRB_16.setSelected(true);
     
299. for(int i = 0;i < 16;i++){
     
300. jButtons[i].setEnabled(true);
     
301. }
     
302. jTextField.setText("");
     
303. switch(curFlag){
     
304. case 2:
     
305. if(displayStr != ""){
     
306. displayStr = this.binToHex(displayStr);
     
307. }
     
308. break;
     
309. case 8:
     
310. if(displayStr != ""){
     
311. displayStr = this.octToHex(displayStr);
     
312. }
     
313. break;
     
314. case 10:
     
315. if(displayStr != ""){
     
316. displayStr = this.decToHex(displayStr);
     
317. }
     
318. break;
     
319. default:
     
320. break;
     
321. }
     
322. curFlag = 16;
     
323. jTextField.setText(displayStr);
     
324. }
     
325. }
     
326. 
     
327. public void mouseClicked(MouseEvent e){
     
328. for(int i=0;i<16;i++){
     
329. if(e.getSource() == jButtons[i]){
     
330. if(jButtons[i].isEnabled() == true){ //判断按钮是否已经启用
     
331. if(i>=0&&i<10){
     
332. displayStr = displayStr + i;
     
333. System.out.println("点击了按钮"+i);
     
334. }else{
     
335. char tmp = (char)(i+55);
     
336. displayStr = displayStr + tmp;
     
337. System.out.println("点击了按钮"+tmp);
     
338. }
     
339. }
     
340. jTextField.setText(displayStr);
     
341. }
     
342. }
     
343. if(e.getSource() == jb_clear){
     
344. System.out.println("点击了按钮清空");
     
345. displayStr = "";
     
346. jTextField.setText("");
     
347. }
     
348. if(e.getSource() == jb_delete){
     
349. System.out.println("点击了按钮删减");
     
350. int length = displayStr.length();
     
351. if(length > 1){
     
352. displayStr = displayStr.substring(0,displayStr.length()-1);
     
353. }else
     
354. displayStr = "";
     
355. jTextField.setText(displayStr);
     
356. }
     
357. }
     
358. 
     
359. <FONT color=red>…………省略空函数
     
360. </FONT>
     
361. public static void main(String[] args){
     
362. JZChange jzChange = new JZChange();
     
363. }
     
364. }
     
365. 
     
366. 程序存在BUG，当数据存储达到32bit，就会出现问题，比如十六进制转二进制，输入AB234545，再点击二进制，程序就卡住了，百思不得其解，难道跟符号位有关？

复制代码

组件的定义：

1. private JRadioButton jRB_2,jRB_8,jRB_10,jRB_16;         //进制转换单选按钮
   
2.     private JTextField jTextField;                          //显示文本框
   
3.     private JPanel jPanel1,jPanel2;
   
4.     private JButton[] jButtons;
   
5.     private JButton jb_delete,jb_clear;
   
6.     private static int curFlag = 0;                             //标识当前进制,取值为2、8、10、16,初始化为0
   
7.     private static String displayStr = "";
   
8.    
   
9.    
   
10.     public JZChange(){
    
11.         //设置标题
    
12.         super("进制转换器");
    
13.         //初始化面板
    
14.         jRB_2 = new JRadioButton("二进制");                 //二进制单选按钮
    
15.         jRB_2.setFont(new Font("宋体",Font.PLAIN,12));
    
16.         jRB_8 = new JRadioButton("八进制");                 //八进制单选按钮
    
17.         jRB_8.setFont(new Font("宋体",Font.PLAIN,12));
    
18.         jRB_10 = new JRadioButton("十进制");                //十进制单选按钮
    
19.         jRB_10.setFont(new Font("宋体",Font.PLAIN,12));
    
20.         jRB_16 = new JRadioButton("十六进制");              //十六进制单选按钮
    
21.         jRB_16.setFont(new Font("宋体",Font.PLAIN,12));
    
22.         jb_delete = new JButton("删减");
    
23.         jb_delete.setFont(new Font("宋体",Font.PLAIN,12));
    
24.         jb_clear = new JButton("清空");
    
25.         jb_clear.setFont(new Font("宋体",Font.PLAIN,12));
    
26.         
    
27.         jPanel1 = new JPanel(new GridLayout(3,2));
    
28.         jPanel1.add(jRB_2);
    
29.         jRB_2.addActionListener(this);
    
30.         jPanel1.add(jRB_8);
    
31.         jRB_8.addActionListener(this);
    
32.         jPanel1.add(jRB_10);
    
33.         jRB_10.addActionListener(this);
    
34.         jPanel1.add(jRB_16);
    
35.         jRB_16.addActionListener(this);
    
36.         jPanel1.add(jb_clear);
    
37.         jb_clear.addMouseListener(this);
    
38.         jPanel1.add(jb_delete);
    
39.         jb_delete.addMouseListener(this);
    
40.         jTextField = new JTextField();
    
41.         jTextField.setEditable(false);
    
42.         //jTextField.setFont(new Font("新宋体",Font.BOLD,17));
    
43.         
    
44.         jPanel2 = new JPanel(new GridLayout(4,4));
    
45.         jButtons = new JButton[16];
    
46.         //初始化0-9的数字按钮
    
47.         for(int i = 0;i < 10;i++){
    
48.             String digitStr = "";
    
49.             digitStr = digitStr+i;
    
50.             //System.out.println(digitStr);
    
51.             jButtons[i] = new JButton(digitStr);
    
52.         }
    
53.         //初始化A-Z的字母按钮
    
54.         for(int i = 10;i < 16;i++){
    
55.             String letterStr = "";
    
56.             char letter = (char)(i+55);
    
57.             letterStr = letterStr+letter;
    
58.             //System.out.println(letterStr);
    
59.             jButtons[i] = new JButton(letterStr);
    
60.         }
    
61.         //添加按钮
    
62.         for(int i = 0;i < 16;i++){
    
63.             jPanel2.add(jButtons[i]);
    
64.             jButtons[i].addMouseListener(this);
    
65.         }
    
66.         this.add(jTextField,BorderLayout.NORTH);
    
67.         this.add(jPanel1,BorderLayout.CENTER);
    
68.         this.add(jPanel2,BorderLayout.SOUTH);
    
69.         //初始化按钮状态
    
70.         for(int i = 0;i < 16;i++){
    
71.                 jButtons[i].setEnabled(false);
    
72.         }
    
73.         this.setSize(250,250);
    
74.         this.setResizable(false);
    
75.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
76.         this.setLocationRelativeTo(null);
    
77.         this.setVisible(true);
    
78.     }

复制代码

空函数：

1. public void mousePressed(MouseEvent e){
   
2.         }
   
3.         public void mouseReleased(MouseEvent e){
   
4.         }
   
5.         public void mouseEntered(MouseEvent e){
   
6.         }
   
7.         public void mouseExited(MouseEvent e){
   
8.         }

复制代码

程序存在BUG，当数据存储达到32bit，就会出现问题，比如十六进制转二进制，输入AB234545，再点击二进制，程序就卡住了，百思不得其解，难道跟符号位有关？