锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
聽* 鏂囦歡鐨勫悇縐嶆搷浣?br />聽* 鏉ㄥ僵 http://blog.sina.com.cn/m/yangcai
聽* 鏂囦歡鎿嶄綔 1.0
聽*/
聽
//package common;
聽
import java.io.*;
聽
public class FileOperate
{
聽static boolean exitnow=false;
聽static String aa,bb;
聽 public FileOperate() {
聽 }
聽
聽 /**
聽聽 * 鏂板緩鐩綍
聽聽 */
聽 public void newFolder(String folderPath) {
聽聽聽 try
聽聽聽 {
聽聽聽聽聽 String filePath = folderPath;
聽聽聽聽聽 filePath = filePath.toString();
聽聽聽聽聽 File myFilePath = new File(filePath);
聽聽聽聽聽 if(!myFilePath.exists())
聽聽聽聽聽 {
聽聽聽聽聽聽聽 myFilePath.mkdir();
聽聽聽聽聽 }
聽聽聽聽聽 System.out.println("鏂板緩鐩綍鎿嶄綔 鎴愬姛鎵ц");
聽聽聽 }
聽聽聽 catch(Exception e)
聽聽聽 {
聽聽聽聽聽 System.out.println("鏂板緩鐩綍鎿嶄綔鍑洪敊");
聽聽聽聽聽 e.printStackTrace();
聽聽聽 }
聽 }
聽
聽 /**
聽聽 * 鏂板緩鏂囦歡
聽聽 */
聽 public void newFile(String filePathAndName, String fileContent)
聽 {
聽
聽聽聽 try
聽聽聽 {
聽聽聽聽聽 String filePath = filePathAndName;
聽聽聽聽聽 filePath = filePath.toString();
聽聽聽聽聽 File myFilePath = new File(filePath);
聽聽聽聽聽 if (!myFilePath.exists())
聽聽聽聽聽 {
聽聽聽聽聽聽聽 myFilePath.createNewFile();
聽聽聽聽聽 }
聽聽聽聽聽 FileWriter resultFile = new FileWriter(myFilePath);
聽聽聽聽聽 PrintWriter myFile = new PrintWriter(resultFile);
聽聽聽聽聽 String strContent = fileContent;
聽聽聽聽聽 myFile.println(strContent);
聽聽聽聽聽 resultFile.close();
聽聽聽聽聽 System.out.println("鏂板緩鏂囦歡鎿嶄綔 鎴愬姛鎵ц");
聽聽聽 }
聽聽聽 catch (Exception e) {
聽聽聽聽聽 System.out.println("鏂板緩鐩綍鎿嶄綔鍑洪敊");
聽聽聽聽聽 e.printStackTrace();
聽
聽聽聽 }
聽
聽 }
聽
聽 /**
聽聽 * 鍒犻櫎鏂囦歡
聽聽 */
聽 public void delFile(String filePathAndName) {
聽聽聽 try {
聽聽聽聽聽 String filePath = filePathAndName;
聽聽聽聽聽 filePath = filePath.toString();
聽聽聽聽聽 File myDelFile = new File(filePath);
聽聽聽聽聽 myDelFile.delete();
聽聽聽聽聽 System.out.println("鍒犻櫎鏂囦歡鎿嶄綔 鎴愬姛鎵ц");
聽聽聽 }
聽聽聽 catch (Exception e) {
聽聽聽聽聽 System.out.println("鍒犻櫎鏂囦歡鎿嶄綔鍑洪敊");
聽聽聽聽聽 e.printStackTrace();
聽
聽聽聽 }
聽
聽 }
聽
聽 /**
聽聽 * 鍒犻櫎鏂囦歡澶?
聽聽 */
聽 public void delFolder(String folderPath)
聽 {
聽聽聽 try
聽聽聽 {
聽聽聽聽聽 delAllFile(folderPath); //鍒犻櫎瀹岄噷闈㈡墍鏈夊唴瀹?
聽聽聽聽聽 String filePath = folderPath;
聽聽聽聽聽 filePath = filePath.toString();
聽聽聽聽聽 File myFilePath = new File(filePath);
聽聽聽聽聽 myFilePath.delete(); //鍒犻櫎絀烘枃浠跺す
聽聽聽聽聽 System.out.println("鍒犻櫎鏂囦歡澶規搷浣?鎴愬姛鎵ц");
聽聽聽 }
聽聽聽 catch (Exception e)
聽聽聽 {
聽聽聽聽聽 System.out.println("鍒犻櫎鏂囦歡澶規搷浣滃嚭閿?);
聽聽聽聽聽 e.printStackTrace();
聽
聽聽聽 }
聽
聽 }
聽
聽 /**
聽聽 * 鍒犻櫎鏂囦歡澶歸噷闈㈢殑鎵鏈夋枃浠?
聽聽 * @param path String 鏂囦歡澶硅礬寰?濡?c:/fqf
聽聽 */
聽 public void delAllFile(String path)
聽 {
聽聽聽 File file = new File(path);
聽聽聽 if(!file.exists())
聽聽聽 {
聽聽聽聽聽 return;
聽聽聽 }
聽聽聽 if(!file.isDirectory())
聽聽聽 {
聽聽聽聽聽 return;
聽聽聽 }
聽聽聽 String[] tempList = file.list();
聽聽聽 File temp = null;
聽聽聽 for (int i = 0; i < tempList.length; i++)
聽聽聽 {
聽聽聽聽聽 if(path.endsWith(File.separator))
聽聽聽聽聽 {
聽聽聽聽聽聽聽 temp = new File(path + tempList[i]);
聽聽聽聽聽 }
聽聽聽聽聽 else
聽聽聽聽聽 {
聽聽聽聽聽聽聽 temp = new File(path + File.separator + tempList[i]);
聽聽聽聽聽 }
聽聽聽聽聽 if (temp.isFile())
聽聽聽聽聽 {
聽聽聽聽聽聽聽 temp.delete();
聽聽聽聽聽 }
聽聽聽聽聽 if (temp.isDirectory())
聽聽聽聽聽 {
聽聽聽聽聽聽聽 delAllFile(path+"/"+ tempList[i]);//鍏堝垹闄ゆ枃浠跺す閲岄潰鐨勬枃浠?
聽聽聽聽聽聽聽 delFolder(path+"/"+ tempList[i]);//鍐嶅垹闄ょ┖鏂囦歡澶?
聽聽聽聽聽 }
聽聽聽 }
聽聽聽聽聽聽聽聽聽 System.out.println("鍒犻櫎鏂囦歡鎿嶄綔 鎴愬姛鎵ц");聽
聽 }
聽
聽 /**
聽聽 * 澶嶅埗鍗曚釜鏂囦歡
聽聽 * @param oldPath String 鍘熸枃浠惰礬寰?濡傦細c:/fqf.txt
聽聽 * @param newPath String 澶嶅埗鍚庤礬寰?濡傦細f:/fqf.txt
聽聽 */
聽 public void copyFile(String oldPath, String newPath) {
聽聽聽 try {
聽聽聽聽聽 int bytesum = 0;
聽聽聽聽聽 int byteread = 0;
聽聽聽聽聽 File oldfile = new File(oldPath);
聽聽聽聽聽 if (oldfile.exists())
聽聽聽聽聽 { //鏂囦歡瀛樺湪鏃?
聽聽聽聽聽聽聽 InputStream inStream = new FileInputStream(oldPath); //璇誨叆鍘熸枃浠?
聽聽聽聽聽聽聽 FileOutputStream fs = new FileOutputStream(newPath);
聽聽聽聽聽聽聽 byte[] buffer = new byte[1444];
聽聽聽聽聽聽聽 int length;
聽聽聽聽聽聽聽 while ( (byteread = inStream.read(buffer)) != -1) {
聽聽聽聽聽聽聽聽聽 bytesum += byteread; //瀛楄妭鏁?鏂囦歡澶у皬
聽聽聽聽聽聽聽聽聽 System.out.println(bytesum);
聽聽聽聽聽聽聽聽聽 fs.write(buffer, 0, byteread);
聽聽聽聽聽聽聽 }
聽聽聽聽聽聽聽 inStream.close();
聽聽聽聽聽 }
聽聽聽聽聽聽聽聽聽聽聽 System.out.println("鍒犻櫎鏂囦歡澶規搷浣?鎴愬姛鎵ц");聽
聽聽聽 }
聽聽聽 catch (Exception e) {
聽聽聽聽聽 System.out.println("澶嶅埗鍗曚釜鏂囦歡鎿嶄綔鍑洪敊");
聽聽聽聽聽 e.printStackTrace();
聽
聽聽聽 }
聽
聽 }
聽
聽 /**
聽聽 * 澶嶅埗鏁翠釜鏂囦歡澶瑰唴瀹?
聽聽 * @param oldPath String 鍘熸枃浠惰礬寰?濡傦細c:/fqf
聽聽 * @param newPath String 澶嶅埗鍚庤礬寰?濡傦細f:/fqf/ff
聽聽 */
聽 public void copyFolder(String oldPath, String newPath) {
聽
聽聽聽 try
聽聽聽 {
聽聽聽聽聽 (new File(newPath)).mkdirs(); //濡傛灉鏂囦歡澶逛笉瀛樺湪 鍒欏緩绔嬫柊鏂囦歡澶?
聽聽聽聽聽 File a=new File(oldPath);
聽聽聽聽聽 String[] file=a.list();
聽聽聽聽聽 File temp=null;
聽聽聽聽聽 for (int i = 0; i < file.length; i++)
聽聽聽聽聽 {
聽聽聽聽聽聽聽 if(oldPath.endsWith(File.separator))
聽聽聽聽聽聽聽 {
聽聽聽聽聽聽聽聽聽 temp=new File(oldPath+file[i]);
聽聽聽聽聽聽聽 }
聽聽聽聽聽聽聽 else{
聽聽聽聽聽聽聽聽聽 temp=new File(oldPath+File.separator+file[i]);
聽聽聽聽聽聽聽 }
聽
聽聽聽聽聽聽聽 if(temp.isFile())
聽聽聽聽聽聽聽 {
聽聽聽聽聽聽聽聽聽 FileInputStream input = new FileInputStream(temp);
聽聽聽聽聽聽聽聽聽 FileOutputStream output = new FileOutputStream(newPath + "/" +
聽聽聽聽聽聽聽聽聽聽聽聽聽 (temp.getName()).toString());
聽聽聽聽聽聽聽聽聽 byte[] b = new byte[1024 * 5];
聽聽聽聽聽聽聽聽聽 int len;
聽聽聽聽聽聽聽聽聽 while ( (len = input.read(b)) != -1)
聽聽聽聽聽聽聽聽聽 {
聽聽聽聽聽聽聽聽聽聽聽 output.write(b, 0, len);
聽聽聽聽聽聽聽聽聽 }
聽聽聽聽聽聽聽聽聽 output.flush();
聽聽聽聽聽聽聽聽聽 output.close();
聽聽聽聽聽聽聽聽聽 input.close();
聽聽聽聽聽聽聽 }
聽聽聽聽聽聽聽 if(temp.isDirectory())
聽聽聽聽聽聽聽 {//濡傛灉鏄瓙鏂囦歡澶?
聽聽聽聽聽聽聽聽聽 copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
聽聽聽聽聽聽聽 }
聽聽聽聽聽 }
聽聽聽聽聽聽聽聽聽聽聽 System.out.println("澶嶅埗鏂囦歡澶規搷浣?鎴愬姛鎵ц");聽
聽聽聽 }
聽聽聽 catch (Exception e) {
聽聽聽聽聽 System.out.println("澶嶅埗鏁翠釜鏂囦歡澶瑰唴瀹規搷浣滃嚭閿?);
聽聽聽聽聽 e.printStackTrace();
聽
聽聽聽 }
聽
聽 }
聽
聽 /**
聽聽 * 縐誨姩鏂囦歡鍒版寚瀹氱洰褰?
聽聽 * @param oldPath String 濡傦細c:/fqf.txt
聽聽 * @param newPath String 濡傦細d:/fqf.txt
聽聽 */
聽 public void moveFile(String oldPath, String newPath) {
聽聽聽 copyFile(oldPath, newPath);
聽聽聽 delFile(oldPath);
聽
聽 }
聽
聽 /**
聽聽 * 縐誨姩鏂囦歡鍒版寚瀹氱洰褰?
聽聽 * @param oldPath String 濡傦細c:/fqf.txt
聽聽 * @param newPath String 濡傦細d:/fqf.txt
聽聽 */
聽 public void moveFolder(String oldPath, String newPath) {
聽聽聽 copyFolder(oldPath, newPath);
聽聽聽 delFolder(oldPath);
聽
聽 }
聽
聽 public static void main(String args[])
聽 {
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠1]聽 鍔熻兘涓錛氭柊寤虹洰褰?);
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠2]聽 鍔熻兘浜岋細鏂板緩鏂囦歡");
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠3]聽 鍔熻兘涓夛細鍒犻櫎鏂囦歡");
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠4]聽 鍔熻兘鍥涳細鍒犻櫎鏂囦歡澶?);
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠5]聽 鍔熻兘浜旓細鍒犻櫎鏂囦歡澶歸噷闈㈢殑鎵鏈夋枃浠?);
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠6]聽 鍔熻兘鍏細澶嶅埗鏂囦歡");
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠7]聽 鍔熻兘涓冿細澶嶅埗鏂囦歡澶圭殑鎵鏈夊唴瀹?);
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠8]聽 鍔熻兘鍏細縐誨姩鏂囦歡鍒版寚瀹氱洰褰?);
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠9]聽 鍔熻兘涔濓細縐誨姩鏂囦歡澶瑰埌鎸囧畾鐩綍");
聽 聽System.out.println("浣跨敤姝ゅ姛鑳借鎸塠10] 閫鍑虹▼搴?);
聽 聽
聽while(!exitnow)
聽{
聽 聽聽FileOperate fo=new FileOperate();
聽 聽聽try
聽 聽聽{
聽 聽聽BufferedReader Bin=new BufferedReader(new InputStreamReader(System.in));
聽 聽聽String a=Bin.readLine();
聽 聽聽int b=Integer.parseInt(a);
聽 聽聽
聽 聽聽switch(b)
聽 聽聽{
聽 聽聽聽case 1:System.out.println("浣犻夋嫨浜嗗姛鑳戒竴聽 璇瘋緭鍏ョ洰褰曞悕");聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 fo.newFolder(aa);
聽 聽聽聽聽聽 break;
聽 聽聽聽case 2:System.out.println("浣犻夋嫨浜嗗姛鑳戒簩聽 璇瘋緭鍏ユ枃浠跺悕");聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 System.out.println("璇瘋緭鍏ュ湪"+aa+"涓殑鍐呭");
聽 聽聽聽聽聽 bb=Bin.readLine();
聽 聽聽聽聽聽 fo.newFile(aa,bb);
聽 聽聽聽聽聽 break;
聽 聽聽聽case 3:System.out.println("浣犻夋嫨浜嗗姛鑳戒笁聽 璇瘋緭鍏ユ枃浠跺悕");聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 fo.delFile(aa);
聽 聽聽聽聽聽 break;
聽 聽聽聽case 4:System.out.println("浣犻夋嫨浜嗗姛鑳藉洓聽 璇瘋緭鍏ユ枃浠跺悕");聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 fo.delFolder(aa);
聽 聽聽聽聽聽 break;
聽 聽聽聽case 5:System.out.println("浣犻夋嫨浜嗗姛鑳戒簲聽 璇瘋緭鍏ユ枃浠跺悕");聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 fo.delAllFile(aa);
聽 聽聽聽聽聽 break;聽聽
聽 聽聽聽case 6:System.out.println("浣犻夋嫨浜嗗姛鑳藉叚聽 璇瘋緭鍏ユ枃浠跺悕");聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 System.out.println("璇瘋緭鍏ョ洰鏍囨枃浠跺悕");聽
聽 聽聽聽聽聽 bb=Bin.readLine();
聽 聽聽聽聽聽 fo.copyFile(aa,bb);
聽 聽聽聽聽聽 break;
聽 聽聽聽case 7:System.out.println("浣犻夋嫨浜嗗姛鑳戒竷聽 璇瘋緭鍏ユ簮鏂囦歡鍚?);聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 System.out.println("璇瘋緭鍏ョ洰鏍囨枃浠跺悕");聽
聽 聽聽聽聽聽 bb=Bin.readLine();
聽 聽聽聽聽聽 fo.copyFolder(aa,bb);
聽 聽聽聽聽聽 break;聽 聽聽聽聽聽
聽 聽聽聽case 8:System.out.println("浣犻夋嫨浜嗗姛鑳藉叓聽 璇瘋緭鍏ユ簮鏂囦歡鍚?);聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 System.out.println("璇瘋緭鍏ョ洰鏍囨枃浠跺悕");聽
聽 聽聽聽聽聽 bb=Bin.readLine();
聽 聽聽聽聽聽 fo.moveFile(aa,bb);
聽 聽聽聽聽聽 break;
聽 聽聽聽 聽case 9:System.out.println("浣犻夋嫨浜嗗姛鑳戒節聽 璇瘋緭鍏ユ簮鏂囦歡鍚?);聽聽
聽 聽聽聽聽聽 aa=Bin.readLine();
聽 聽聽聽聽聽 System.out.println("璇瘋緭鍏ョ洰鏍囨枃浠跺悕");聽
聽 聽聽聽聽聽 bb=Bin.readLine();
聽 聽聽聽聽聽 fo.moveFolder(aa,bb);
聽 聽聽聽聽聽 break;聽 聽聽聽聽聽
聽 聽聽聽case 10:exitnow=true;
聽 聽聽聽聽聽聽 System.out.println("紼嬪簭緇撴潫錛岃閫鍑?);
聽 聽聽聽聽聽 break;
聽 聽聽聽default:System.out.println("杈撳叆閿欒.璇瘋緭鍏?-10涔嬮棿鐨勬暟");聽聽 聽聽聽聽 聽聽聽聽聽 聽
聽 聽聽 }
聽 聽聽
聽 聽聽
聽 聽聽System.out.println("璇烽噸鏂伴夋嫨鍔熻兘");
聽 聽聽
聽 聽聽
聽 聽聽}
聽 聽聽catch(Exception e)
聽 聽聽{
聽 聽聽System.out.println("杈撳叆閿欒瀛楃鎴栫▼搴忓嚭閿?);
聽 聽聽}
聽 聽聽
聽}聽 聽
聽}
}
http://www.tkk7.com/Files/yangcai/FileOperate_java.rar
]]>
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.text.*;
import java.util.*;
public class show extends JFrame implements Runnable
{
聽static JFrame jf;
聽JLabel jl;
聽public show()
聽{
聽聽jf=new JFrame("鏃墮棿鏄劇ず");
聽聽jl=new JLabel();
聽聽jf.getContentPane().add(jl);
聽聽jf.setSize(200,100);聽聽
聽}
聽
聽public void run()
聽{
聽聽while(true)
聽聽{
聽聽聽SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
聽聽聽jl.setText(sdf.format(new Date()));
聽聽聽try
聽聽聽{
聽聽聽聽Thread.sleep(1000);聽
聽聽聽}
聽聽聽catch(Exception e)
聽聽聽{
聽聽聽聽jl.setText("鍑洪敊閿欒錛岃閲嶅惎紼嬪簭");
聽聽聽}
聽聽}聽聽
聽}聽
聽public static void main(String arg[])
聽{
聽聽show t=new show();
聽聽Thread thread1=new Thread(t);
聽聽thread1.start();聽聽
聽聽jf.setVisible(true);聽聽
聽}聽
}
]]>
聽*聽聽 MyAccess.java
聽*聽 鏉ㄥ僵 http://blog.sina.com.cn/m/yangcai
聽*聽 鏈鍚庝慨鏀逛簬2007.1.15
聽*
聽*/
import java.util.*;
import java.sql.*;
import java.io.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
public class MyAccess extends JFrame implements ActionListener,ListSelectionListener
{
聽private static Connection conn;
聽private static Statement comm;
聽private static ResultSet rs;
聽private聽 static int total=0,k=10,row=0,i=0;
聽JLabel jl,jl2;
聽JTable jt;
聽JTextField jid,jname,jscore,se;
聽static JButton go,add,drop,del,jbse,flush;
聽JFrame jf;
聽JScrollPane s;
聽Vector vect=new Vector();
聽String[] data = {"瀛﹀彿=","瀛﹀彿>","瀛﹀彿<", "濮撳悕=", "鍒嗘暟=","鍒嗘暟>=","鍒嗘暟<"};
聽聽JComboBox dataList = new JComboBox(data);
聽String[] columnNames = {"瀛﹀彿","濮撳悕","鍒嗘暟"};
聽AbstractTableModel tm = new AbstractTableModel()
聽 {
聽聽聽聽聽聽聽聽聽 public int getColumnCount(){ return 3;}
聽聽聽聽聽聽聽聽聽 public int getRowCount(){ return k;}
聽聽聽聽聽聽聽聽聽 public Object getValueAt(int row, int col){ return ((Vector)vect.get(row)).get(col); }
聽聽聽聽聽聽聽聽聽 public String getColumnName(int column){聽聽聽 return columnNames[column];聽聽 }
聽聽聽聽聽 };
聽
聽public MyAccess()
聽{
聽聽jf=new JFrame("鑰冩劅瀛﹂櫌04綰AVA鎴愮嘩綆$悊緋葷粺");
聽聽jf.setSize(490,570);
聽聽jf.locate(200,200);
聽聽jf.setResizable(false);
聽聽jf.getContentPane().setLayout(new FlowLayout());聽
聽聽jl=new JLabel("鑰冩劅瀛﹂櫌04綰AVA鎴愮嘩");
聽聽jid=new JTextField(6);
聽聽jname=new JTextField(5);
聽聽jscore=new JTextField(3);
聽聽se=new JTextField(9);
聽聽go=new JButton("鍒嗘暟(浣?>楂?");
聽聽go.addActionListener(this);
聽聽add=new JButton("娣誨姞");
聽聽add.addActionListener(this);
聽聽drop=new JButton("淇敼");
聽聽drop.addActionListener(this);
聽聽del=new JButton("鍒犻櫎");
聽聽del.addActionListener(this);
聽聽jbse=new JButton("鎼滅儲");
聽聽jbse.addActionListener(this);
聽聽flush=new JButton("鍒鋒柊");
聽聽flush.addActionListener(this);
聽聽jl2=new JLabel("");
聽聽jl2.setForeground(Color.red);
聽聽jf.getContentPane().add(jl);
聽聽jt=new JTable(tm);
聽聽jt.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
聽聽this.jt.getSelectionModel().addListSelectionListener(this);
聽聽
聽聽
聽聽s = new JScrollPane(jt);聽聽
聽聽jf.getContentPane().add(s);
聽聽jf.getContentPane().add(new JLabel("瀛﹀彿:"));
聽聽jf.getContentPane().add(jid);
聽聽jf.getContentPane().add(new JLabel("濮撳悕:"));
聽聽jf.getContentPane().add(jname);
聽聽jf.getContentPane().add(new JLabel("鍒嗘暟:"));
聽聽jf.getContentPane().add(jscore);
聽聽jf.getContentPane().add(add);
聽聽jf.getContentPane().add(drop);
聽聽jf.getContentPane().add(del);
聽聽jf.getContentPane().add(new JLabel("鎼滅儲瀛︾敓:"));
聽聽jf.getContentPane().add(dataList);
聽聽jf.getContentPane().add(se);
聽聽jf.getContentPane().add(jbse);
聽聽jf.getContentPane().add(flush);
聽聽jf.getContentPane().add(go);
聽聽jf.getContentPane().add(jl2);
聽聽
聽}
public void exce(String exce)
{
聽try
聽{聽this.jt.getSelectionModel().removeListSelectionListener(this);
聽聽rs = execQuery(exce);
聽聽vect.removeAllElements();
聽聽tm.fireTableDataChanged();
聽聽total=0;
聽聽while(rs.next())
聽聽{聽
聽聽聽Vector rec_vector=new Vector();
聽聽聽rec_vector.addElement(rs.getString(1));
聽聽聽rec_vector.addElement(rs.getString(2));
聽聽聽rec_vector.addElement(rs.getString(3));
聽聽聽vect.addElement(rec_vector);
聽聽聽聽聽 total++;聽聽聽聽聽
聽聽}
聽聽k=total;
聽聽this.closeDB();
聽聽System.out.println("vect鏄潰鏈?+total+"璁板綍鎵ц鎿嶄綔");
聽聽System.out.println("鎴愬姛鎵ц:"+exce);
聽聽this.jt.getSelectionModel().addListSelectionListener(this);聽聽
聽聽聽聽
聽}
聽catch(Exception ee)
聽{
聽聽jl2.setText("鏃犳硶鎵ц,璇峰~鍏ユ紜殑鏁版嵁");
聽聽System.out.println("鎵ц澶辮觸,鍙兘鏌ヨ涓虹┖");
聽聽k=0;
聽聽
聽}
}
public void excesql(String sql)
{
聽try
聽{
聽conBuild();
聽Statement stm=conn.createStatement();
聽stm.executeUpdate(sql);
聽jf.repaint();
聽jl2.setText("鎿嶄綔宸叉墽琛?);
聽System.out.println("鎴愬姛鎵ц:"+sql);
聽this.closeDB();
聽}
聽catch(Exception ee)
聽{
聽聽jl2.setText("鏃犳硶鎵ц,璇峰~鍏ユ紜殑鏁版嵁");
聽聽System.out.println(sql+"鏃犳硶鎵ц");
聽}
}聽
public static void regDriver()//register JDBC 妗ユ帴 driver
{
聽聽聽聽聽 try{Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").newInstance();//鍏抽敭鍙?
聽聽聽聽聽 System.out.println("椹卞姩娉ㄥ唽鎴愬姛");
聽聽聽聽聽 }
聽聽聽聽聽聽 catch(Exception e)
聽聽聽聽 {
聽 聽聽 System.out.println("鏃犳硶鍒涘緩椹卞姩紼嬪簭瀹炰綋!");
聽 聽 }
}
聽聽 //寤虹珛鏁版嵁搴撹繛鎺?br />public static void conBuild()//寤虹珛JDBC榪炴帴
聽 {
聽聽 try{
聽聽聽聽 MyAccess.regDriver();
聽聽聽聽 conn=DriverManager.getConnection("jdbc:odbc:myDSN","","");//鍏抽敭鍙?
聽聽聽聽 conn.setAutoCommit(true);
聽聽聽聽 System.out.println("鎴愬姛榪炴帴鏁版嵁搴?);
聽聽聽聽 }
聽聽聽聽 catch(Exception e)
聽聽聽聽 {
聽聽聽聽聽 System.out.println(e.getMessage()) ;
聽聽聽聽聽 System.out.println("鏃犳硶榪炴帴鏁版嵁搴揅onnection!錛岃繍琛屼箣鍓嶈鍏堣緗暟鎹簮 MyDSN");
聽聽聽聽 }
}
聽 public static ResultSet execQuery(String stmt1)//鎵ц鏌ヨ璇彞
聽聽聽 {
聽聽聽聽 try{
聽 聽聽 conBuild();
聽聽聽聽聽 comm=conn.createStatement();
聽聽聽聽聽 rs=comm.executeQuery(stmt1);
聽聽聽聽聽 return rs;
聽聽聽聽 }
聽聽聽聽 catch(Exception e)
聽聽聽聽聽 {
聽聽聽聽聽聽 System.out.println("鏃犳硶鍒涘緩Statement!");return null;
聽聽聽聽聽 }
}聽聽聽
public static void closeDB()
{
聽聽聽聽聽聽聽 try{
聽聽聽聽聽聽聽聽聽 comm.close();
聽聽聽聽聽聽聽聽聽 conn.close();
聽聽聽聽聽聽聽聽聽 System.out.println("鍏抽棴璁板綍闆嗭紝鏂紑鏁版嵁搴?);
聽聽聽聽聽聽聽聽聽 }
聽聽聽聽聽聽聽聽聽 catch(Exception e)
聽聽聽聽聽聽聽聽 {
聽聽聽聽聽聽聽聽聽 System.out.println(e.getMessage());
聽聽聽聽聽聽聽聽 }
聽}
public void actionPerformed(ActionEvent ee)// 瀹炵幇ActionListener涓殑鍞竴鏂規硶
{
聽if(ee.getSource()==go)
聽{
聽聽try
聽聽{
聽聽聽
聽聽聽if(i==0)
聽聽聽{
聽聽聽聽exce("SELECT * FROM 鎴愮嘩 order by 鍒嗘暟");
聽聽聽聽i=1;聽
聽聽聽聽go.setText("鍒嗘暟(楂?>浣?");
聽聽聽}
聽聽聽else
聽聽聽{
聽聽聽聽exce("SELECT * FROM 鎴愮嘩 order by 鍒嗘暟 desc");
聽聽聽聽i=0;
聽聽聽聽go.setText("鍒嗘暟(浣?>楂?");聽
聽聽聽}
聽聽聽
聽聽聽jl2.setText("宸叉寜鍒嗘暟鎺掑簭");
聽聽聽聽聽聽
聽聽}
聽聽catch(Exception go)
聽聽{
聽聽聽System.out.println("鍑虹幇閿欒");
聽聽聽jl2.setText("鎻愮ず:鍑虹幇閿欒");
聽聽}
聽聽
聽聽
聽}
聽if(ee.getSource()==add)
聽{
聽聽this.excesql("insert into 鎴愮嘩 values('"+jid.getText()+"','"+jname.getText()+"','"+jscore.getText()+"')");
聽聽exce("SELECT * FROM 鎴愮嘩 order by 瀛﹀彿");
聽聽jid.setText("");
聽聽jname.setText("");
聽聽jscore.setText("");
聽聽jf.repaint();
聽聽聽聽
聽聽System.out.println("鎵ц娣誨姞鎿嶄綔");
聽聽
聽聽聽
聽}
聽if(ee.getSource()==drop)
聽{
聽聽this.excesql("update 鎴愮嘩 set 濮撳悕='"+jname.getText()+"' ,鍒嗘暟="+jscore.getText()+" where 瀛﹀彿='"+jid.getText()+"'" );
聽聽exce("SELECT * FROM 鎴愮嘩 order by 瀛﹀彿");聽
聽
聽}
聽if(ee.getSource()==del)
聽{
聽聽this.excesql("delete from 鎴愮嘩 where 瀛﹀彿='"+jid.getText()+"'");
聽聽exce("SELECT * FROM 鎴愮嘩 order by 瀛﹀彿");
聽聽jl2.setText("鎻愮ず:鎴愬姛鍒犻櫎ID涓?+jid.getText()+"鐨勬暟鎹?);
聽聽System.out.println("鎵ц鍒犻櫎鎿嶄綔");聽
聽聽聽
聽}
聽if(ee.getSource()==jbse)
聽{
聽聽if(dataList.getSelectedIndex()>=4)
聽聽{
聽 聽聽聽String sql="SELECT *聽 FROM 鎴愮嘩 WHERE "+dataList.getSelectedItem()+se.getText();
聽聽聽exce(sql);
聽聽}
聽聽else
聽聽{
聽聽聽String sql="SELECT *聽 FROM 鎴愮嘩 WHERE "+dataList.getSelectedItem()+"'"+se.getText()+"'";
聽聽聽exce(sql);
聽聽}
聽聽jl2.setText("鎼滅儲緇撴灉:鍏?+k+"鏉℃暟鎹?);
聽聽System.out.println(k+"鎵ц鎼滅儲鎿嶄綔");
聽聽
聽聽jf.repaint();
聽}
聽
聽if(ee.getSource()==flush)
聽{
聽聽exce("SELECT * FROM 鎴愮嘩 order by 瀛﹀彿");
聽聽jid.setText("");
聽聽jname.setText("");
聽聽jscore.setText("");
聽聽se.setText("");
聽聽jf.repaint();
聽聽jl2.setText("鎻愮ず:鍒鋒柊鎴愬姛");
聽聽
聽}
聽
}
public void valueChanged(ListSelectionEvent el)聽 //姣忓綋閫夋嫨鍊煎彂鐢熸洿鏀規椂璋冪敤銆?
{
聽聽row=0;
聽聽row=jt.getSelectedRow();
聽聽if(row<0) row=0;聽聽
聽聽Object row_id=jt.getValueAt(row,0);
聽聽Object row_name=jt.getValueAt(row,1);
聽聽Object row_score=jt.getValueAt(row,2);
聽聽
聽聽jid.setText(row_id.toString());
聽聽jname.setText(row_name.toString());
聽聽jscore.setText(row_score.toString());
聽聽System.out.println("閫夋嫨宸叉敼鍙?+k+"聽 "+total);
聽聽
聽聽
}
public static void main(String s[])
聽聽聽聽聽 {
聽聽聽聽 MyAccess ma=new MyAccess();
聽聽ma.exce("SELECT * FROM 鎴愮嘩 order by 瀛﹀彿");
聽聽聽聽 ma.jf.setVisible(true);
聽聽聽聽
聽聽聽聽聽 }
}
import java.io.*;
import java.net.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
public class yc extends JFrame
{
聽public static JLabel jl1,jl2;
聽public static TextArea ta1,ta2;
聽public static JButton jb1,jb2;
聽public static Container cp1;
聽 static Socket svr;
聽public static PrintWriter out;
聽
聽
聽public static void main(String arg[])
聽{
聽聽JFrame jf=new JFrame("涓庡皬鏂拌亰澶?-VIP聽聽聽聽聽聽聽聽聽聽聽聽 瀹㈡埛绔?);
聽聽jf.setSize(500,450);
聽聽jf.setResizable(false);
聽聽jf.locate(100,100);
//聽聽cp1=getContentPane();
聽聽jl1=new JLabel("榪炴帴涓?...");
聽聽ta1=new TextArea();
聽聽ta2=new TextArea();
聽聽jb1=new JButton("鍙戦?);
聽聽jb1.addActionListener(new Listener());
聽聽jb2=new JButton("娓呯┖");
聽聽jb2.addActionListener(new Listener());
聽聽jf.getContentPane().setLayout(new FlowLayout());
聽聽jf.getContentPane().add(jl1);
聽聽聽jf.getContentPane().add(ta1);
聽聽聽jf.getContentPane().add(ta2);
聽聽聽jf.getContentPane().add(jb1);
聽聽聽jf.getContentPane().add(jb2);
聽聽聽
聽聽jf.setVisible(true);
聽聽try
聽聽{
聽聽聽target2 outmsg2=new target2();
聽聽聽Thread outthread2=new Thread(outmsg2);
聽聽聽outthread2.start();
聽聽聽QQ();
聽聽聽
聽聽聽
聽聽}
聽聽catch(Exception e)
聽聽{
聽聽聽
聽聽}
聽聽
聽聽
聽}
聽
static void QQ()throws Exception
{
聽 System.out.println("姝e湪榪炴帴鏈嶅姟鍣?璇風◢鍊?..");
聽 //涓庢寚瀹氬湴鍧鐨勬湇鍔″櫒鐩歌繛鎺?br />聽 svr=new Socket("127.0.0.1",3300);//瑕佽繛鎺ヨ繙紼嬩富鏈鴻濉獻P
聽//svr=new Socket(InetAddress.getLocalHost(),3300)
聽 jl1.setText("涓?+svr.getInetAddress()+"榪炴帴鎴愬姛!璇瘋緭鍑鴻浼犻佺殑淇℃伅...");
聽}
聽
聽
}
聽
聽class Listener implements ActionListener{
聽聽public void actionPerformed(ActionEvent e)
聽聽{
聽聽聽
聽聽聽 if(e.getSource()==yc.jb2)
聽聽聽聽 {
聽聽聽聽 聽聽 yc.ta1.setText("");
聽聽聽聽 }
聽聽聽聽
聽聽聽 else
聽聽聽 {
聽聽聽 聽try
聽聽聽 {
聽聽聽 聽
聽聽聽 聽yc.out=new PrintWriter(yc.svr.getOutputStream());
聽聽聽 聽yc.out.println(yc.ta2.getText());
聽聽聽 聽yc.out.flush();
聽聽聽 聽yc.ta1.append("[鑷繁]璇?\n"+yc.ta2.getText()+"\n");
聽聽聽 聽yc.ta2.setText("");
聽
聽聽聽
聽聽聽 }
聽聽聽聽 catch(Exception ee)
聽聽聽聽 {
聽聽聽聽 聽
聽聽聽聽 }
聽聽聽 聽
聽聽聽 }
聽聽聽
聽聽聽聽
聽聽聽聽
聽聽}
聽}
聽
聽
聽
聽
class target2 implements Runnable
{
聽public void run()
聽{
聽聽聽
聽聽聽 while(true)
聽聽聽 {
聽聽聽 聽
聽聽聽try
聽聽聽{
聽聽聽聽
聽聽聽 BufferedReader in=new BufferedReader(new InputStreamReader(yc.svr.getInputStream()));
聽 聽聽聽 String str=in.readLine();
聽聽 聽聽聽 str="[鏈嶅姟绔?+yc.svr.getInetAddress()+"]璇?\n"+str;
聽聽聽 聽聽 yc.ta1.append(str+"\n");
聽聽聽}
聽聽聽
聽聽聽catch(Exception ee)
聽聽聽{
聽聽聽聽;
聽聽聽}聽
聽聽聽 聽
聽聽 聽聽
聽聽 聽聽
聽聽 聽聽}
聽}
}
聽
聽
聽
鈥斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺?/p>
聽
聽
//QQ鏈嶅姟绔?/p>
import java.io.*;
import java.net.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
public class ycserver extends JFrame
{
聽public static JLabel jl1;
聽public static TextArea ta1,ta2;
聽public static JButton jb1,jb2;
聽public static Container cp1;
聽public static ServerSocket svr;聽
聽public static Socket clt;
聽public static Thread thread;
聽public static int i=0;
聽
聽聽
聽public static void main(String arg[])
聽{
聽聽JFrame jf=new JFrame("涓庢潹褰╄亰澶?-VIP聽聽聽聽聽聽聽聽聽聽聽 鏈嶅姟绔?);
聽聽jf.setSize(500,450);
聽聽jf.locate(200,200);
聽聽jf.setResizable(false);
聽聽ta1=new TextArea();
聽聽ta2=new TextArea();
聽聽jb1=new JButton("鍙戦?);
聽聽jb2=new JButton("娓呯┖");
聽聽jl1=new JLabel("絳夊緟榪炴帴");
聽聽jb1.addActionListener(new jb1Listener());
聽聽jb2.addActionListener(new jb1Listener());
聽聽jf.getContentPane().setLayout(new FlowLayout());
聽聽jf.getContentPane().add(jl1);
聽聽聽jf.getContentPane().add(ta1);
聽聽聽jf.getContentPane().add(ta2);
聽聽聽jf.getContentPane().add(jb1);
聽聽聽jf.getContentPane().add(jb2);
聽聽聽
聽聽jf.setVisible(true);
聽聽try
聽聽{
聽聽聽target outmsg=new target();
聽聽聽Thread outthread=new Thread(outmsg);
聽聽聽outthread.start();
聽聽聽
聽聽聽wait wait1=new wait();
聽聽聽Thread waitthread=new Thread(wait1);
聽聽聽waitthread.start();
聽聽聽
聽聽聽QQ();
聽聽聽
聽聽}
聽聽catch(Exception e)
聽聽{
聽聽聽
聽聽}
聽聽
聽聽
聽}
聽
聽
static void QQ()throws Exception
{/*
聽//寤虹珛鏈嶅姟鍣ㄥ鑺傚瓧
聽 svr=new ServerSocket(3300);
聽 System.out.println("絳夊緟榪炴帴....");
聽//絳夊緟瀹㈡埛鏈烘帴鍏?br />聽聽 clt=svr.accept();
聽聽聽 i++;
聽聽聽 ta1.setText(i+"");
聽//鑾峰緱瀹㈡埛IP鍦板潃
聽 System.out.println("榪炴帴璇鋒眰鏉ヨ嚜:"+clt.getInetAddress());
聽 jl1.setText("榪炴帴璇鋒眰鏉ヨ嚜:"+clt.getInetAddress());
聽 //寤虹珛I/O嫻?br />聽 */
聽聽 }
聽聽
聽}
聽
聽
聽class jb1Listener implements ActionListener
聽{
聽聽public void actionPerformed(ActionEvent e)
聽聽{
聽聽聽if(e.getSource()==ycserver.jb2)
聽聽聽{
聽聽聽聽ycserver.ta1.setText("");
聽聽聽}
聽聽聽
聽聽聽else
聽聽聽{
聽聽聽聽 try
聽聽聽 {
聽聽聽 聽聽聽聽聽聽
聽聽 聽PrintWriter out=new PrintWriter(ycserver.clt.getOutputStream());
聽聽 聽out.println(ycserver.ta2.getText());
聽聽 聽out.flush();
聽聽聽 聽ycserver.ta1.append("[鑷繁]璇?\n"+ycserver.ta2.getText()+"\n");
聽聽聽 聽ycserver.ta2.setText("");
聽
聽聽聽
聽聽聽 }
聽聽聽聽 catch(Exception ee)
聽聽聽聽 {
聽聽聽聽 聽
聽聽聽聽 }
聽聽聽}
聽聽
聽聽}
聽}
聽
class target implements Runnable
{
聽public void run()
聽{
聽聽聽
聽聽聽 while(true)
聽聽聽 {
聽聽聽 聽
聽聽聽try
聽聽聽{聽聽聽聽
聽聽聽 BufferedReader in=new BufferedReader(new InputStreamReader(ycserver.clt.getInputStream()));
聽 聽聽聽 String str=in.readLine();
聽聽 聽聽聽 str="[瀹㈡埛绔湪"+ycserver.clt.getInetAddress()+"]璇?\n"+str;
聽聽聽 聽聽 ycserver.ta1.append(str+"\n");
聽聽聽}
聽聽聽
聽聽聽catch(Exception ee)
聽聽聽{
聽聽聽聽;
聽聽聽}聽
聽聽聽 聽
聽聽 聽聽
聽聽 聽聽
聽聽 聽聽}
聽}
}
聽
class wait implements Runnable
{
聽public void run()
聽{
聽聽聽
聽聽聽 while(true)
聽聽聽 {
聽聽聽 聽
聽聽聽try
聽聽聽{聽聽聽聽
聽聽聽 //寤虹珛鏈嶅姟鍣ㄥ鑺傚瓧
聽 ycserver.svr=new ServerSocket(3300);
聽 System.out.println("絳夊緟榪炴帴....");
聽//絳夊緟瀹㈡埛鏈烘帴鍏?br />聽聽 ycserver.clt=ycserver.svr.accept();
聽聽聽 ycserver.i+=2;
聽聽聽 ycserver.ta1.setText(ycserver.i+"");
聽//鑾峰緱瀹㈡埛IP鍦板潃
聽 System.out.println("榪炴帴璇鋒眰鏉ヨ嚜:"+ycserver.clt.getInetAddress());
聽 ycserver.jl1.setText("榪炴帴璇鋒眰鏉ヨ嚜:"+ycserver.clt.getInetAddress());
聽 //寤虹珛I/O嫻?br />聽聽聽}
聽聽聽
聽聽聽catch(Exception ee)
聽聽聽{
聽聽聽聽;
聽聽聽}聽
聽聽聽 聽
聽聽 聽聽
聽聽 聽聽
聽聽 聽聽}
聽}
}
聽
聽
聽
public class calculator extends JFrame implements ActionListener
{//榪欓噷鎴戞妸JFrame鍐欐垚Frame錛岃繖涓敊璇壘浜嗗ソ涔?br />聽JFrame frame;
聽
聽private JButton jia=new JButton("+");
聽private JButton jian=new JButton("-");
聽private JButton cheng=new JButton("*");
聽private JButton chu=new JButton("/");
聽private JButton qiuyi=new JButton("%");
聽private JButton deng=new JButton("=");
聽private JButton fu=new JButton("+/-");
聽private JButton dian=new JButton(".");
聽private JButton kai=new JButton("sqrt");
聽private JButton diao=new JButton("1/x");
聽private JButton aa=new JButton("A");
聽private JButton bb=new JButton("B");
聽private JButton cc=new JButton("C");
聽private JButton dd=new JButton("D");
聽private JButton ee=new JButton("E");
聽private JButton ff=new JButton("F");
聽
聽private TextField k1=new TextField();聽
聽private objConversion convert = new objConversion();
聽
聽JMenuItem copy,paste,s,t,help,about,me;
聽JRadioButton sixteen,ten,eight,two;
聽JButton backspace,ce,c,num0,num1,num2,num3,num4,num5,num6,num7,num8,num9;
聽Container cp;
聽
聽JTextField text;
聽String copycontent="";
聽boolean clickable=true,clear=true;
聽int all=0;
聽double qian;
聽String fuhao;
聽int jin=10,first=1;
聽
聽
聽public calculator()
聽{
聽聽setTitle("璁$畻鍣紞鏉ㄥ僵鍒朵綔");
聽聽setSize(400,300);
聽聽setLocation(250,200);
聽聽text=new JTextField(25);
聽//聽text.setEnabled(false);
聽聽text.setText("0.");
聽聽text.setHorizontalAlignment(JTextField.RIGHT);//浠庡彸鍒板乏
聽
聽聽JPanel cp1=new JPanel();
聽聽JPanel cp2=new JPanel();
聽聽JPanel cp3=new JPanel();
聽聽
聽聽cp=getContentPane();
聽聽cp.add(cp1,"North");
聽聽cp.add(cp2,"Center");
聽聽cp.add(cp3,"South");
聽聽
聽聽cp1.setLayout(new GridLayout(1,6));
聽聽cp2.setLayout(new GridLayout(2,4));
聽聽cp3.setLayout(new GridLayout(6,6));
聽聽
聽聽sixteen=new JRadioButton("鍗佸叚榪涘埗");
聽聽sixteen.setVisible(false);
聽聽ten=new JRadioButton("鍗佽繘鍒?,true);
聽聽ten.setVisible(false);
聽聽eight=new JRadioButton("鍏繘鍒?);
聽聽eight.setVisible(false);聽
聽聽two=new JRadioButton("浜岃繘鍒?);
聽聽two.setVisible(false);
聽聽sixteen.addActionListener(this);
聽聽ten.addActionListener(this);
聽聽eight.addActionListener(this);
聽聽two.addActionListener(this);聽
聽聽ButtonGroup btg=new ButtonGroup();
聽聽
聽聽btg.add(sixteen);聽
聽聽btg.add(ten);聽
聽聽btg.add(eight);聽
聽聽btg.add(two);
聽
聽聽JTextField t3=new JTextField(25);
聽聽cp1.add(text);
聽//聽text.setEnabled(false);
聽聽text.setEditable(false);
聽聽text.setBackground(new Color(255, 255, 255));
聽聽
聽聽cp2.add(sixteen);
聽聽cp2.add(ten);
聽聽cp2.add(eight);
聽聽cp2.add(two);
聽聽
聽聽backspace=new JButton("Backspace");
聽聽backspace.setForeground(new Color(255,0,0));
聽聽backspace.addActionListener(this);
聽聽ce=new JButton("CE");
聽聽ce.setForeground(new Color(255,0,0));
聽聽ce.addActionListener(this);
聽聽c=new JButton("C");
聽聽c.setForeground(new Color(255,0,0));
聽聽c.addActionListener(this);
聽聽k1.setVisible(false);
聽聽cp2.add(k1);
聽聽cp2.add(backspace);
聽聽cp2.add(ce);
聽聽cp2.add(c);
聽聽
聽聽num0=new JButton("0");
聽聽num1=new JButton("1");
聽聽num2=new JButton("2");
聽聽num3=new JButton("3");
聽聽num4=new JButton("4");
聽聽num5=new JButton("5");
聽聽num6=new JButton("6");
聽聽num7=new JButton("7");
聽聽num8=new JButton("8");
聽聽num9=new JButton("9");
聽
聽聽cp3.add(num7);
聽聽num7.addActionListener(this);
聽聽cp3.add(num8);
聽聽num8.addActionListener(this);
聽聽cp3.add(num9);
聽聽num9.addActionListener(this);
聽聽cp3.add(chu);
聽聽chu.setForeground(new Color(255,0,0));
聽聽chu.addActionListener(this);
聽聽cp3.add(kai);
聽聽kai.addActionListener(this);
聽聽cp3.add(num4);
聽聽num4.addActionListener(this);
聽聽cp3.add(num5);
聽聽num5.addActionListener(this);
聽聽cp3.add(num6);
聽聽num6.addActionListener(this);
聽聽cp3.add(cheng);
聽聽cheng.setForeground(new Color(255,0,0));
聽聽cheng.addActionListener(this);
聽聽cp3.add(qiuyi);
聽聽qiuyi.addActionListener(this);
聽聽cp3.add(num1);
聽聽num1.addActionListener(this);
聽聽cp3.add(num2);
聽聽num2.addActionListener(this);
聽聽cp3.add(num3);
聽聽num3.addActionListener(this);
聽聽cp3.add(jian);
聽聽jian.setForeground(new Color(255,0,0));
聽聽jian.addActionListener(this);
聽聽cp3.add(diao);
聽聽diao.addActionListener(this);
聽聽cp3.add(num0);
聽聽num0.addActionListener(this);
聽聽cp3.add(fu);
聽聽fu.addActionListener(this);
聽聽cp3.add(dian);
聽聽dian.addActionListener(this);
聽聽cp3.add(jia);
聽聽jia.setForeground(new Color(255,0,0));
聽聽jia.addActionListener(this);
聽聽cp3.add(deng);
聽聽deng.setForeground(new Color(255,0,0));
聽聽deng.addActionListener(this);
聽聽cp3.add(aa);
聽聽aa.addActionListener(this);
聽聽cp3.add(bb);
聽聽bb.addActionListener(this);
聽聽cp3.add(cc);
聽聽cc.addActionListener(this);
聽聽cp3.add(dd);
聽聽dd.addActionListener(this);
聽聽cp3.add(ee);
聽聽ee.addActionListener(this);
聽聽cp3.add(ff);
聽聽ff.addActionListener(this);
聽聽aa.setVisible(false);
聽聽bb.setVisible(false);
聽聽cc.setVisible(false);
聽聽dd.setVisible(false);
聽聽ee.setVisible(false);
聽聽ff.setVisible(false);
聽聽聽聽聽
聽聽JMenuBar mainMenu = new JMenuBar();
聽聽setJMenuBar(mainMenu);
聽聽JMenu editMenu = new JMenu("緙栬緫");
聽聽JMenu viewMenu = new JMenu("鏌ョ湅");
聽聽JMenu helpMenu = new JMenu("甯姪");
聽聽mainMenu.add(editMenu);
聽聽mainMenu.add(viewMenu);
聽聽mainMenu.add(helpMenu);
聽聽
聽聽copy = new JMenuItem(" 澶嶅埗");
聽聽paste = new JMenuItem(" 綺樿創");
聽聽KeyStroke copyks=KeyStroke.getKeyStroke(KeyEvent.VK_C,Event.CTRL_MASK);
聽 聽聽copy.setAccelerator(copyks);//璁劇疆閫鍑鴻彍鍗曢夐」鍔犱笂蹇嵎閿?br />聽 聽聽KeyStroke pasteks=KeyStroke.getKeyStroke(KeyEvent.VK_V,Event.CTRL_MASK);
聽 聽聽paste.setAccelerator(pasteks);//璁劇疆閫鍑鴻彍鍗曢夐」鍔犱笂蹇嵎閿?br />聽聽editMenu.add(copy);
聽聽editMenu.add(paste);
聽聽copy.addActionListener(this);
聽聽paste.addActionListener(this);
聽聽
聽聽t = new JMenuItem("鈼忔爣鍑嗗瀷");
聽聽s = new JMenuItem("聽聽 縐戝鍨?);
聽聽viewMenu.add(t);
聽聽viewMenu.add(s);
聽聽t.addActionListener(this);
聽聽s.addActionListener(this);
聽聽聽聽
聽聽help = new JMenuItem(" 甯姪涓婚");
聽聽about = new JMenuItem(" 鍏充簬璁$畻鍣?);
聽聽me = new JMenuItem(" 浣滆呬富欏?);
聽聽helpMenu.add(help);
聽聽helpMenu.add(about);聽
聽聽helpMenu.add(me);
聽聽help.addActionListener(this);
聽聽about.addActionListener(this);
聽聽me.addActionListener(this);
聽聽
聽聽
聽聽
聽聽
聽聽
聽聽
聽聽
聽addWindowListener(new WindowDestroyer());//緇撴潫紿楀彛
聽}
聽
聽
聽
聽public void actionPerformed(ActionEvent e)
聽
聽{//鍝嶅簲鍔ㄤ綔浠g爜
聽聽
聽聽if(first==1)
聽聽text.setText("");
聽聽first=0;//絎竴嬈℃妸鏂囨湰妗?.娓呯┖
聽
聽 聽Object temp = e.getSource();
聽 聽if(temp==copy)
聽 聽{
聽聽聽copycontent = text.getText();
聽聽}
聽聽if(temp==paste)
聽 聽{
聽聽聽text.setText(text.getText()+copycontent);
聽聽
聽聽}
聽聽if(temp==t)
聽聽{//鏍囧噯
聽聽聽
聽聽聽sixteen.setVisible(false);
聽聽聽ten.setVisible(false);
聽聽聽eight.setVisible(false);
聽聽聽two.setVisible(false);
聽聽聽t.setText("鈼忔爣鍑嗗瀷");
聽聽聽s.setText("聽聽聽 縐戝鍨?);
聽聽聽aa.setVisible(false);
聽聽聽bb.setVisible(false);
聽聽聽cc.setVisible(false);
聽聽聽dd.setVisible(false);
聽聽聽ee.setVisible(false);
聽聽聽ff.setVisible(false);
聽聽}
聽聽if(temp==s)
聽聽{//縐戝
聽聽聽
聽聽聽sixteen.setVisible(true);
聽聽聽ten.setVisible(true);
聽聽聽eight.setVisible(true);
聽聽聽two.setVisible(true);
聽聽聽t.setText("聽聽 鏍囧噯鍨?);
聽聽聽s.setText("鈼忕瀛﹀瀷");
聽聽聽aa.setVisible(true);
聽聽聽bb.setVisible(true);
聽聽聽cc.setVisible(true);
聽聽聽dd.setVisible(true);
聽聽聽ee.setVisible(true);
聽聽聽ff.setVisible(true);
聽聽聽aa.setEnabled(false);
聽聽聽bb.setEnabled(false);
聽聽聽cc.setEnabled(false);
聽聽聽dd.setEnabled(false);
聽聽聽ee.setEnabled(false);
聽聽聽ff.setEnabled(false);
聽聽聽
聽聽聽
聽聽}
聽聽if(temp==help)
聽聽{ //鎵撳紑緋葷粺甯姪鏂囦歡 瑕佹煡璧勬枡
聽聽聽try
聽聽聽{
聽聽聽聽 String filePath = "C:/WINDOWS/Help/calc.chm";
聽聽聽聽聽 Runtime.getRuntime().exec("cmd.exe /c "+filePath);
聽聽聽
聽聽聽}
聽聽聽catch(Exception eeee)
聽聽聽{
聽聽聽聽System.out.println("鎵撳紑緋葷粺鐨勮綆楀櫒鍑洪敊");聽聽聽聽
聽聽聽}
聽聽}
聽聽if(temp==about)
聽聽{
聽聽聽JOptionPane.showMessageDialog(frame,"聽聽聽聽聽 Java璁$畻鍣╘n聽聽聽聽聽 鏉ㄥ僵 鍒朵綔\n\n 聽聽}
聽聽if(temp==me)
聽聽{
聽聽聽try
聽聽聽{
聽聽聽聽Process p = Runtime.getRuntime().exec("explorer 聽聽聽}
聽聽聽catch(Exception eeee)
聽聽聽{
聽聽聽聽System.out.println("鎵撳紑鎸囧畾緗戦〉鍑洪敊");聽聽聽聽
聽聽聽}聽
聽聽}
聽聽
聽聽
聽聽try
聽聽{
聽聽if(temp==sixteen)
聽聽{
聽聽聽String hex=text.getText();
聽聽聽int inthex=Integer.parseInt(hex,jin);//鍏堟妸鏁板彉涓?0榪涘埗聽聽
聽聽聽text.setText(convert.decHex(inthex)) ;
聽聽聽jin=16;
聽聽聽aa.setEnabled(true);
聽聽聽bb.setEnabled(true);
聽聽聽cc.setEnabled(true);
聽聽聽dd.setEnabled(true);
聽聽聽ee.setEnabled(true);
聽聽聽ff.setEnabled(true);
聽聽聽num2.setEnabled(true);
聽聽聽num3.setEnabled(true);
聽聽聽num4.setEnabled(true);
聽聽聽num5.setEnabled(true);
聽聽聽num6.setEnabled(true);
聽聽聽num7.setEnabled(true);
聽聽聽num8.setEnabled(true);
聽聽聽num9.setEnabled(true);
聽
聽聽}
聽聽if(temp==eight)
聽聽{
聽聽聽String oct =text.getText();
聽聽聽int intoct=Integer.parseInt(oct,jin);聽聽
聽聽聽text.setText(convert.decOct(intoct)) ;
聽聽聽jin=8;
聽聽聽
聽聽聽aa.setEnabled(false);
聽聽聽bb.setEnabled(false);
聽聽聽cc.setEnabled(false);
聽聽聽dd.setEnabled(false);
聽聽聽ee.setEnabled(false);
聽聽聽ff.setEnabled(false);
聽聽聽num2.setEnabled(true);
聽聽聽num3.setEnabled(true);
聽聽聽num4.setEnabled(true);
聽聽聽num5.setEnabled(true);
聽聽聽num6.setEnabled(true);
聽聽聽num7.setEnabled(true);
聽聽聽num8.setEnabled(false);
聽聽聽num9.setEnabled(false);
聽聽}
聽聽if(temp==two)
聽聽{
聽聽聽String bin=text.getText();
聽聽聽int intbin=Integer.parseInt(bin,jin);
聽聽聽text.setText(convert.decBin(intbin));
聽聽聽jin=2;
聽聽聽
聽聽聽aa.setEnabled(false);
聽聽聽bb.setEnabled(false);
聽聽聽cc.setEnabled(false);
聽聽聽dd.setEnabled(false);
聽聽聽ee.setEnabled(false);
聽聽聽ff.setEnabled(false);
聽聽聽num2.setEnabled(false);
聽聽聽num3.setEnabled(false);
聽聽聽num4.setEnabled(false);
聽聽聽num5.setEnabled(false);
聽聽聽num6.setEnabled(false);
聽聽聽num7.setEnabled(false);
聽聽聽num8.setEnabled(false);
聽聽聽num9.setEnabled(false);
聽聽}
聽聽if(temp==ten)
聽聽{
聽聽聽String dec=text.getText();
聽聽聽int intdec=Integer.parseInt(dec,jin);
聽聽//聽text.setText(convert.decDec(intdec));聽 //鏈彞浼氭妸123鍙樻垚321
聽聽聽text.setText(intdec+"");
聽聽聽jin=10;
聽聽聽aa.setEnabled(false);
聽聽聽bb.setEnabled(false);
聽聽聽cc.setEnabled(false);
聽聽聽dd.setEnabled(false);
聽聽聽ee.setEnabled(false);
聽聽聽ff.setEnabled(false);
聽聽聽num2.setEnabled(true);
聽聽聽num3.setEnabled(true);
聽聽聽num4.setEnabled(true);
聽聽聽num5.setEnabled(true);
聽聽聽num6.setEnabled(true);
聽聽聽num7.setEnabled(true);
聽聽聽num8.setEnabled(true);
聽聽聽num9.setEnabled(true);
聽聽}
聽聽}
聽聽catch(Exception ee)
聽聽{
聽聽聽System.out.println("杞崲鍑洪敊,鍙兘浣犳病鏈夎緭鍏ヤ換浣曞瓧絎?);
聽聽聽text.setText("杞崲鍑洪敊");
聽聽聽clear=false;
聽聽}
聽聽
聽聽if(temp==backspace)
聽聽{//閫鏍?br />聽聽String s = text.getText();
聽聽text.setText("");
聽聽for (int i = 0; i < s.length() - 1; i++)
聽聽{
聽聽char a = s.charAt(i);
聽聽text.setText(text.getText() + a);
聽聽}
聽聽}
聽聽
聽聽if (temp==ce)
聽聽{
聽聽聽text.setText("0.");
聽聽聽clear=true;
聽聽聽first=1;
聽聽}
聽聽if (temp==c)
聽聽{
聽聽聽text.setText("0.");聽聽聽;
聽聽聽clear=true;
聽聽聽first=1;
聽聽}
聽聽
聽聽if(temp==num0)
聽聽聽{ 聽
聽聽聽聽if(clear==false)//鍒ゆ柇鏄惁鐐瑰嚮浜嗙鍙蜂綅
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"0");
聽聽聽}
聽聽
聽聽if(temp==num1)
聽聽聽{ 聽聽聽
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"1");
聽聽聽聽clear=true;//絎簩嬈′笉鍦ㄦ竻絀猴紙鍓嶄簩鍙ワ級
聽聽聽}
聽聽
聽聽if(temp==num2)
聽聽聽{ 聽聽聽
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"2");
聽聽聽聽clear=true;
聽聽聽}
聽聽
聽聽if(temp==num3)
聽聽聽{ 聽聽聽
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"3");
聽聽聽聽clear=true;
聽聽聽}
聽聽
聽聽if(temp==num4)
聽聽聽{ 聽聽聽
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"4");
聽聽聽聽clear=true;
聽聽聽}
聽聽
聽聽if(temp==num5)
聽聽聽{
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"5");
聽聽聽聽clear=true;
聽聽聽}
聽聽
聽聽if(temp==num6)
聽聽聽{
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"6");
聽聽聽聽clear=true;
聽聽聽}
聽聽if(temp==num7)
聽聽聽{
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"7");
聽聽聽聽clear=true;
聽聽聽}
聽聽
聽聽if(temp==num8)
聽聽聽{
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"8");
聽聽聽聽clear=true;
聽聽聽}
聽聽
聽聽if(temp==num9)
聽聽聽{
聽聽聽聽if(clear==false)
聽聽聽聽text.setText("");
聽聽聽聽text.setText(text.getText()+"9");
聽聽聽聽clear=true;
聽聽聽}
聽聽聽if(temp==aa)
聽聽聽{
聽聽聽聽text.setText(text.getText()+"A");
聽聽聽}
聽聽if(temp==bb)
聽聽聽{
聽聽聽聽text.setText(text.getText()+"B");
聽聽聽}
聽聽
聽聽if(temp==cc)
聽聽聽{
聽聽聽聽text.setText(text.getText()+"C");
聽聽聽}
聽聽
聽聽if(temp==dd)
聽聽聽{
聽聽聽聽text.setText(text.getText()+"D");
聽聽聽}
聽聽
聽聽if(temp==ee)
聽聽聽{
聽聽聽聽text.setText(text.getText()+"E");
聽聽聽}聽
聽聽if(temp==ff)
聽聽聽{
聽聽聽聽text.setText(text.getText()+"F");
聽聽聽}
聽聽聽if(temp==dian)
聽聽聽{
聽聽聽聽clickable=true;
聽聽聽聽for (int i = 0; i < text.getText().length(); i++)
聽聽聽if ('.' == text.getText().charAt(i))
聽聽聽{
聽聽聽clickable=false;
聽聽聽break;
聽聽聽} //絎竴灞傚垽鏂槸鍚﹂噷闈㈠惈鏈夊皬鏁扮偣;
聽聽聽聽
聽聽聽聽if(clickable==true)//絎簩鍧涘垽鏂?br />聽聽聽聽text.setText(text.getText()+".");
聽聽聽聽
聽聽聽}
聽聽聽
聽聽try
聽聽{聽
聽聽聽if(temp==jia)
聽聽聽{//鍔犳硶
聽聽聽聽qian=Double.parseDouble(text.getText());
聽聽聽聽fuhao="+";
聽聽聽聽clear=false;
聽聽聽}
聽聽聽if(temp==jian)
聽聽聽{
聽聽聽聽qian=Double.parseDouble(text.getText());
聽聽聽聽fuhao="-";
聽聽聽聽clear=false;
聽聽聽聽;
聽聽聽聽
聽聽聽}
聽聽聽if(temp==cheng)
聽聽聽{
聽聽聽聽qian=Double.parseDouble(text.getText());
聽聽聽聽fuhao="*";
聽聽聽聽clear=false;
聽聽聽聽 聽聽聽
聽聽聽}
聽聽聽if(temp==chu)
聽聽聽{
聽聽聽聽qian=Double.parseDouble(text.getText());
聽聽聽聽fuhao="/";
聽聽聽聽clear=false;
聽聽聽聽 聽聽聽
聽聽聽}
聽聽聽if(temp==deng)
聽聽聽{
聽聽聽聽double ss=Double.parseDouble(text.getText());
聽聽聽聽text.setText("");
聽聽聽聽if(fuhao=="+")
聽聽聽聽text.setText(qian+ss+"");
聽聽聽聽if(fuhao=="-")
聽聽聽聽text.setText(qian-ss+"");
聽聽聽聽if(fuhao=="*")
聽聽聽聽text.setText(qian*ss+"");
聽聽聽聽if(fuhao=="/")
聽聽聽聽text.setText(qian/ss+"");
聽聽聽聽clear=false;//瑕佹竻絀哄墠涓嬈$殑鏁版嵁
聽聽聽聽;
聽聽聽聽
聽聽聽}
聽聽聽
聽聽聽if(temp==kai)
聽聽聽{ 聽聽聽
聽聽String s = text.getText();
聽聽if (s.charAt(0) == '-')
聽聽{
聽聽聽text.setText("璐熸暟涓嶈兘寮鏍瑰彿");
聽聽}
聽聽else
聽聽text.setText(Double.toString(java.lang.Math.sqrt(Double.parseDouble(text.getText()))));
聽聽clear=false;
聽聽}
聽聽
聽聽if(temp==diao)
聽聽{
聽聽聽
聽聽聽if (text.getText().charAt(0) == '0'&&text.getText().length() == 1)
聽聽聽 {
聽聽聽聽text.setText("闄ゆ暟涓嶈兘涓洪浂");
聽聽聽 }
聽聽else
聽聽{
聽聽boolean isDec = true;
聽聽聽int i, j, k;
聽聽聽String s = Double.toString(1 / Double.parseDouble(text.getText()));
聽聽聽for (i = 0; i < s.length(); i++)
聽聽聽if (s.charAt(i) == '.')
聽聽聽break;
聽聽聽for (j = i + 1; j < s.length(); j++)
聽聽聽if (s.charAt(j) != '0')
聽聽聽{
聽聽聽isDec = false;
聽聽聽break;
聽聽聽}
聽聽聽if (isDec == true)
聽聽聽{
聽聽聽String stemp = "";
聽聽聽for (k = 0; k < i; k++)
聽聽聽聽stemp += s.charAt(k);
聽聽聽聽text.setText(stemp);
聽聽聽}
聽聽聽else
聽聽聽text.setText(s);
聽聽聽}
聽
聽聽聽聽clear=false;
聽聽}
聽聽if(temp==qiuyi)
聽聽{
聽聽聽text.setText("0");
聽聽聽clear=false;
聽聽}
聽聽if (temp == fu)
聽聽{ //瀵煎笀錛屾鏂規硶鍙傝冧功涓緥瀛?br />聽聽聽boolean isNumber = true;
聽聽聽String s = text.getText();
聽聽聽for (int i = 0; i < s.length(); i++)
聽聽聽if (! (s.charAt(i) >= '0' && s.charAt(i) <= '9' || s.charAt(i) == '.' ||
聽聽聽s.charAt(i) == '-'))
聽聽聽聽聽聽聽 {
聽聽聽聽聽isNumber = false;
聽聽聽聽聽break;
聽聽聽聽聽}
聽聽聽if (isNumber == true)
聽聽聽 {
聽聽聽//濡傛灉褰撳墠瀛楃涓查瀛楁瘝鏈?-'鍙?浠h〃鐜板湪鏄釜璐熸暟,鍐嶆寜涓嬫椂,鍒欏皢棣栫鍙峰幓鎺?
聽聽聽聽聽if (s.charAt(0) == '-')
聽聽聽聽聽{
聽聽聽聽聽text.setText("");
聽聽聽聽聽for (int i = 1; i < s.length(); i++)
聽聽聽聽聽聽聽聽 {
聽聽聽聽聽聽聽char a = s.charAt(i);
聽聽聽聽聽聽聽text.setText(text.getText() + a);
聽聽聽聽聽聽聽聽 聽聽}
聽聽聽聽聽}
聽聽聽聽聽聽//濡傛灉褰撳墠瀛楃涓茬涓涓瓧絎︿笉鏄鍙鳳紝鍒欐坊鍔犱竴涓鍙峰湪棣栧瓧姣嶅
聽聽聽else
聽聽聽text.setText('-' + s);
聽聽聽}
聽聽}
聽聽
聽}
聽catch(Exception eee)
聽{
聽聽System.out.println("榪愮畻鏃?棣栧厛杈撳叆鏁板瓧鎴栧瓧絎?);
聽聽text.setText("榪愮畻鍑洪敊");
聽聽clear=false;
聽}
聽聽
聽聽
聽聽
聽}
聽
聽class WindowDestroyer extends WindowAdapter
聽{//閫鍑虹獥鍙e姩浣?br />聽聽public void windowClosing(WindowEvent e)
聽聽{
聽聽System.exit(0);
聽聽}
聽}
聽
class objConversion
{//瀵煎笀,鏈繘鍒剁被鍙傝冧簡CSMD綾昏漿鎹緥瀛?br />聽
聽public void objConversion ()
聽{
聽}
聽
聽public String decDec (int decNum)
聽{//10
聽聽
聽聽String strDecNum = Integer.toString(decNum);
聽聽
聽聽for (int i = strDecNum.length(); i < 3; i++)
聽聽{
聽聽聽strDecNum = "0" + strDecNum;
聽聽}
聽聽
聽//聽return strDecNum;
聽聽return invert (strDecNum, 5);
聽聽
聽}
聽
聽public String decHex (int decNum)
聽{//10 to 16
聽聽
聽聽String strHexNum = "";
聽聽int currentNum = 0;
聽聽
聽聽while (decNum != 0)
聽聽{
聽聽聽
聽聽聽if (decNum > 15)
聽聽聽{
聽聽聽聽
聽聽聽聽currentNum = decNum % 16;
聽聽聽聽decNum /= 16;
聽聽聽聽
聽聽聽}
聽聽聽else
聽聽聽{
聽聽聽聽
聽聽聽聽currentNum = decNum;
聽聽聽聽decNum = 0;
聽聽聽聽
聽聽聽}
聽聽聽
聽聽聽switch (currentNum)
聽聽聽{
聽聽聽聽
聽聽聽聽case 15:聽strHexNum += "F";
聽聽聽聽聽聽聽break;
聽聽聽聽case 14:聽strHexNum += "E";
聽聽聽聽聽聽聽break;
聽聽聽聽case 13:聽strHexNum += "D";
聽聽聽聽聽聽聽break;
聽聽聽聽case 12:聽strHexNum += "C";
聽聽聽聽聽聽聽break;
聽聽聽聽case 11:聽strHexNum += "B";
聽聽聽聽聽聽聽break;
聽聽聽聽case 10:聽strHexNum += "A";
聽聽聽聽聽聽聽break;
聽聽聽聽default:聽strHexNum += Integer.toString(currentNum);
聽聽聽聽聽聽聽break;
聽聽聽聽聽聽聽
聽聽聽}
聽聽聽
聽聽}
聽聽聽
聽聽return invert (strHexNum, 2);
聽聽聽
聽}
聽聽
聽public String decOct (int decNum)
聽{//10 to 8
聽聽
聽聽String strOctNum = "";
聽聽
聽聽while (decNum != 0)
聽聽{
聽聽聽
聽聽聽if (decNum > 7)
聽聽聽{
聽聽聽聽
聽聽聽聽strOctNum += Integer.toString(decNum % 8);
聽聽聽聽decNum /= 8;
聽聽聽聽
聽聽聽}
聽聽聽else
聽聽聽{
聽聽聽聽
聽聽聽聽strOctNum += Integer.toString(decNum);
聽聽聽聽decNum = 0;
聽聽聽聽
聽聽聽}
聽聽聽
聽聽}
聽聽
聽聽return invert (strOctNum, 3);
聽聽
聽}
聽
聽public String decBin (int decNum)
聽{//10 to 2
聽聽
聽聽String strBinNum = "";
聽聽
聽聽while (decNum != 0)
聽聽{
聽聽聽
聽聽聽if (decNum > 1)
聽聽聽{
聽聽聽聽
聽聽聽聽strBinNum += Integer.toString(decNum % 2);
聽聽聽聽decNum /= 2;
聽聽聽聽
聽聽聽}
聽聽聽else
聽聽聽{
聽聽聽聽
聽聽聽聽strBinNum += Integer.toString(decNum);
聽聽聽聽decNum = 0;
聽聽聽聽
聽聽聽}
聽聽聽
聽聽}
聽聽
聽聽return invert (strBinNum, 8);
聽聽
聽}
聽
聽private String invert (String strNum, int minLength) //杞崲闀垮害
聽{聽聽
聽聽
聽聽String answer = "";
聽聽int length = strNum.length();
聽聽
聽聽if (length < minLength)
聽聽{
聽聽聽
聽聽聽for (int padding = (minLength - length); padding > 0; padding--)
聽聽聽{
聽聽聽聽answer += "0";
聽聽聽}
聽聽聽
聽聽}
聽聽
聽聽for (int i = length; i > 0; i--)
聽聽{
聽聽聽answer += strNum.charAt (i - 1);
聽聽}
聽聽
聽聽return answer;
聽聽
聽}
聽
}
聽
聽
聽public static void main(String arg[])//浜х敓紿楀彛
聽{
聽聽calculator win = new calculator();聽
聽聽win.setVisible(true);
聽}
}