代码分享：心算24小游戏

游戏规则：[请玩家仔细阅读]

(1)点击开始游戏进行游戏,玩家初始积分是40分,当玩家积分超过100分时,玩家赢,低于0分时,玩家输；

(2)游戏开始时,会自动随机生成一定可以通过四则运算得到24的四张扑克牌【J、Q、K、大小鬼记作10】；

(3)游戏过程中,玩家可以刷新扑克牌,但每刷新一次都会扣3分；

(4)玩家将四张扑克牌，用+、-、*、/及适当的括号组合起来,并把组合的表达式【用英文输入法】填到输入框里面【注意每张纸牌只可以使用一次】；

(5)单击确定按钮,游戏将会判断你输入的表达式是否符合数学规律,及是否为游戏显示的四张扑克牌的上的数字；

(6)如果输入合法,将系统将计算玩家所输入的表达式的值,如果正确则得5分,有鬼且正确加10分,错误扣2分；

(7)若玩家在1分30秒后才算出答案,则得4分,有鬼得8分,错误扣2分；

Java代码片段：

import java.awt.BorderLayout;  
import java.awt.Color;  
import java.awt.Container;  
import java.awt.Dimension;  
import java.awt.FlowLayout;  
import java.awt.Font;  
import java.awt.Label;  
import java.awt.TextField;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import java.awt.event.WindowAdapter;  
import java.awt.event.WindowEvent;  
import java.net.URL;  
import java.util.Random;  
import javax.swing.ImageIcon;  
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JLabel;  
import javax.swing.JPanel;  
import javax.swing.JTextArea;  
 
 
public class Calculate24 implements ActionListener{   
    JFrame frame=new JFrame();//创建窗口框架  
    Dimension screen=frame.getToolkit().getScreenSize();//获取显示器的分辨率  
    Container con=frame.getContentPane();//给窗体框架添加容器  
    TextField  txtField=new TextField(30);//输入表达式的区域  
    JPanel Buttompnl=new JPanel(); //按钮和其他组件的面板  
    private int count=43;//初始积分40  
    JLabel Title=new JLabel("欢迎使用头脑风暴之心算24点----刘学炜、范碧天、许培涛、陈燕茜同组合作设计");  
    JTextArea Count=new JTextArea();//用于显示游戏规则及提示  
    MyTimer timeshow=new MyTimer();//显示时间  
    JPanel pokerPanel=new JPanel();//显示扑克牌的面板  
    JButton btnStart=new JButton("开始游戏/洗牌");//开始游戏和刷牌的按钮  
    JButton btnOk=new JButton("确定");//确定按钮  
    Label label=new Label("请输入表达式:");//显示输入表达式  
    JLabel poker1=new  JLabel();//显示四张扑克牌     
    JLabel poker2=new  JLabel();      
    JLabel poker3=new  JLabel();      
    JLabel poker4=new  JLabel();      
    private Check c=new Check();//引入check类的对象  
    Random ran=new Random();//引入随机函数类对象  
    private float [] myStatus=new float[4];//四张扑克牌上对应的数字  
    private char [] mystatus=new char[4];//四张扑克牌上对应的花色  
    private float[] numbers=new float[4];//输入表达式的四个数字  
    private float[] different=new float[4];//调整积分的差别  
    private boolean addscore=false;//判断是否加双倍积分  
      
      
    Calculate24(){                   
           frame.setTitle("头脑风暴之心算24点");  
           Count.setEditable(false);  
           Count.setLineWrap(true);  
           Count.setWrapStyleWord(true);  
           Count.setSize(600, 85);  
           Count.setBackground(new Color(18,132,57));  
           Count.setText("游戏规则:[请玩家仔细阅读]" +  
                    "\n(1)点击开始游戏进行游戏,玩家初始积分是40分,当玩家积分超过100分时,玩家赢,低于0分时,玩家输；" +  
                    "\n(2)游戏开始时,会自动随机生成一定可以通过四则运算得到24的四张扑克牌【J、Q、K、大小鬼记作10】；" +  
                    "\n(3)游戏过程中,玩家可以刷新扑克牌,但每刷新一次都会扣3分；"+  
                    "\n(4)玩家将四张扑克牌，用+、-、*、/及适当的括号组合起来,并把组合的表达式【用英文输入法】填到输入框里面【注意每张纸牌只可以使用一次】；"+  
                    "\n(5)单击确定按钮,游戏将会判断你输入的表达式是否符合数学规律,及是否为游戏显示的四张扑克牌的上的数字；"+  
                    "\n(6)如果输入合法,将系统将计算玩家所输入的表达式的值,如果正确则得5分,有鬼且正确加10分,错误扣2分；" +  
                    "\n(7)若玩家在1分30秒后才算出答案,则得4分,有鬼得8分,错误扣2分；" 
                       );  
             
           //界面组件的相关设计  
            con.add(Title,BorderLayout.NORTH);  
            con.add(Buttompnl,BorderLayout.SOUTH);  
            con.add(pokerPanel,BorderLayout.CENTER);      
              
            Buttompnl.add(btnStart);  
            Buttompnl.add(label);  
            Buttompnl.add(txtField);  
              
            btnStart.setActionCommand("start");  
            btnStart.addActionListener(this);//添加开始按钮监听器  
            btnOk.setActionCommand("ok");  
            btnOk.addActionListener(this); //添加确定按钮监听器           
            pokerPanel.add(poker1);  
            pokerPanel.add(poker2);  
            pokerPanel.add(poker3);  
            pokerPanel.add(poker4);  
            pokerPanel.add(Count,BorderLayout.SOUTH);  
    }  
          
      
      
      
      
    //监听器设计  
    public void actionPerformed(ActionEvent e) {  
        //按下开始按钮  
        Count.setFont(new Font("Dialog",Font.PLAIN,20));    
      
        if(e.getActionCommand().equals("start")){  
            timeshow.usedTime=0;//时间归零  
            timeshow.timer.start(); //开始计时        
            Buttompnl.add(btnOk);  
            Buttompnl.add(timeshow.usedTimeLabel);  
            timeshow.timeText.setText("0分0秒");  
            Buttompnl.add(timeshow.timeText);  
            count-=3;//刷牌扣3分  
            Count.setText("\n\n您目前的积分是:"+count+  
                    "\n上一道题的系统答案是："+c.outputs);  
            try{for(int i=0;i<4;i++){  
                myStatus[i]=(float) ((int)(ran.nextFloat()*14+1));//随机产生四张牌  
                mystatus[i]=(char) ('A'+(int)(ran.nextFloat()*4));//随机产生花色  
                if(myStatus[i]>10f){//对J、Q、K、鬼作10处理  
                different[i]=myStatus[i]-10f;  
                myStatus[i]-=different[i];  
                }  
                else 
                 different[i]=0f;  
                if(i==3&&!c.check(myStatus))//检验所产生的纸牌是否能够算出24  
                i=2;      
            }  
              
                if(count<0){//查看刷牌后剩余的积分是否小于0  
                    timeshow.timer.stop();//停止计时  
                    timeshow.usedTime=0;//重新时间归零  
                    for(int i=0;i<4;i++){//返回初始界面  
                        myStatus[i]=0f;  
                        mystatus[i]='A';  
                    }  
                        NewPanel(myStatus,mystatus);  
                        Buttompnl.remove(btnOk);  
                        txtField.setText("");  
                        Count.setFont(new Font("Dialog",Font.PLAIN,12));  
                        Count.setText("游戏规则:[请玩家仔细阅读]" +  
                                "\n(1)点击开始游戏进行游戏,玩家初始积分是40分,当玩家积分超过100分时,玩家赢,低于0分时,玩家输；" +  
                                "\n(2)游戏开始时,会自动随机生成一定可以通过四则运算得到24的四张扑克牌【J、Q、K、大小鬼记作10】；" +  
                                "\n(3)游戏过程中,玩家可以刷新扑克牌,但每刷新一次都会扣3分；"+  
                                "\n(4)玩家将四张扑克牌，用+、-、*、/及适当的括号组合起来,并把组合的表达式【用英文输入法】填到输入框里面【注意每张纸牌只可以使用一次】；"+  
                                "\n(5)单击确定按钮,游戏将会判断你输入的表达式是否符合数学规律,及是否为游戏显示的四张扑克牌的上的数字；"+  
                                "\n(6)如果输入合法,将系统将计算玩家所输入的表达式的值,如果正确则得5分,有鬼且正确加10分,错误扣2分；" +  
                                "\n(7)若玩家在1分30秒后才算出答案,则得4分,有鬼得8分,错误扣2分；" 
                                   );  
                        count=43;//初始积分40  
                        new MasgDlg(this,"对不起，挑战失败！重新游戏请按【确定】,退出游戏请按【退出】");  
                       
                    }  
                else{  
                for(int i=0;i<4;i++)  
                    myStatus[i]+=different[i];  
            NewPanel(myStatus,mystatus);//显示生成的四张扑克牌  
            for(int i=0;i<4;i++){  
               myStatus[i]-=different[i];  
               if(different[i]==4)//双倍加分条件，遇鬼  
                 addscore=true;  
             }  
            }  
         }catch(Exception e1){  
               
         }  
        }  
        //按下确定按钮  
        else if (e.getActionCommand().equals("ok")){  
            try{float result=calculateString(txtField.getText().trim());              
                if(result==-1f){//输入不合法，或者没有输入正确的数字  
                    txtField.requestFocus();  
                    new MsgDlg("您输入的表达式不合法或你使用的数字不是扑克牌上的数字，请重新输入！",this);                 
                }else if(result!=24f){//输入合法，但计算结果不是24  
                    timeshow.usedTime-=8%60;//减去输入时间  
                    count-=2;   //错误扣2分           
                    if(count<0){    //判断积分是否小于0  
                        timeshow.timer.stop();  
                        timeshow.usedTime=0;  
                        timeshow.timeText.setText("0分0秒");  
                        for(int i=0;i<4;i++){//返回初始界面  
                            myStatus[i]=0f;  
                            mystatus[i]='A';  
                        }  
                            NewPanel(myStatus,mystatus);  
                            Buttompnl.remove(btnOk);  
                            txtField.setText("");  
                            Count.setFont(new Font("Dialog",Font.PLAIN,12));  
                            Count.setText("游戏规则:[请玩家仔细阅读]" +  
                                    "\n(1)点击开始游戏进行游戏,玩家初始积分是40分,当玩家积分超过100分时,玩家赢,低于0分时,玩家输；" +  
                                    "\n(2)游戏开始时,会自动随机生成一定可以通过四则运算得到24的四张扑克牌【J、Q、K、大小鬼记作10】；" +  
                                    "\n(3)游戏过程中,玩家可以刷新扑克牌,但每刷新一次都会扣3分；"+  
                                    "\n(4)玩家将四张扑克牌，用+、-、*、/及适当的括号组合起来,并把组合的表达式【用英文输入法】填到输入框里面【注意每张纸牌只可以使用一次】；"+  
                                    "\n(5)单击确定按钮,游戏将会判断你输入的表达式是否符合数学规律,及是否为游戏显示的四张扑克牌的上的数字；"+  
                                    "\n(6)如果输入合法,将系统将计算玩家所输入的表达式的值,如果正确则得5分,有鬼且正确加10分,错误扣2分；" +  
                                    "\n(7)若玩家在1分30秒才算出答案,则得4分,有鬼得8分,错误扣2分；" 
                                       );  
                            count=43;  
                            new MasgDlg(this,"对不起，挑战失败！重新游戏请按【确定】,退出游戏请按【退出】");  
                    }  
                    else//输出用户所输入的表达式的值  
                    {  
                        Count.setText("\n您目前的积分是:"+count+"\n对不起，您输入的表达式的值是"+result+",扣除2分,请重新输入！");  
                    }  
                      
                }else if(result==24f){//输入正确，得到24  
                    timeshow.usedTime-=8%60;//减去输入时间  
                    if(addscore){//遇鬼，双倍积分  
                        addscore=false;  
                        if(timeshow.usedTime>90){//遇鬼，超时加分方法  
                            count+=8;                         
                            Count.setText("\n您目前的积分是:"+count+"\n恭喜你，你的输入正确！但超出1分30秒,获得8分奖励,请做下一道题"+  
                                    "\n上一道题的系统答案是："+c.outputs);  
                        }  
                        else{//遇鬼，正常加分方法  
                             count+=10;       
                             Count.setText("\n您目前的积分是:"+count+"\n恭喜你，你的输入正确！获得10分奖励,请做下一道题" +  
                                    "\n上一道题的系统答案是："+c.outputs);  
                          }  
                          
                    }  
                    else{//普通加分  
                        if(timeshow.usedTime/60>=2){//超时，普通加分  
                            count+=4;                         
                            Count.setText("\n您目前的积分是:"+count+"\n恭喜你，你的输入正确！但超出1分30秒,获得4分奖励,请做下一道题"+  
                                    "\n上一道题的系统答案是："+c.outputs);  
                        }  
                        else{//普通加分  
                             count+=5;  
                             Count.setText("\n您目前的积分是:"+count+"\n恭喜你，你的输入正确！获得5分奖励,请做下一道题"+  
                                     "\n上一道题的系统答案是："+c.outputs);  
                            }  
                          
                      }  
                    timeshow.usedTime = 0;     
                    txtField.setText("");  
                    txtField.requestFocus();  
                    if(count>=100){  
                        timeshow.timer.stop();  
                        timeshow.usedTime=0;  
                        timeshow.timeText.setText("0分0秒");                                        
                        for(int i=0;i<4;i++){  
                            myStatus[i]=0f;  
                            mystatus[i]='A';  
                        }  
                            NewPanel(myStatus,mystatus);  
                            Buttompnl.remove(btnOk);  
                            txtField.setText("");  
                            Count.setFont(new Font("Dialog",Font.PLAIN,12));  
                            Count.setText("游戏规则:[请玩家仔细阅读]" +  
                                    "\n(1)点击开始游戏进行游戏,玩家初始积分是40分,当玩家积分超过100分时,玩家赢,低于0分时,玩家输；" +  
                                    "\n(2)游戏开始时,会自动随机生成一定可以通过四则运算得到24的四张扑克牌【J、Q、K、大小鬼记作10】；" +  
                                    "\n(3)游戏过程中,玩家可以刷新扑克牌,但每刷新一次都会扣3分；"+  
                                    "\n(4)玩家将四张扑克牌，用+、-、*、/及适当的括号组合起来,并把组合的表达式【用英文输入法】填到输入框里面【注意每张纸牌只可以使用一次】；"+  
                                    "\n(5)单击确定按钮,游戏将会判断你输入的表达式是否符合数学规律,及是否为游戏显示的四张扑克牌的上的数字；"+  
                                    "\n(6)如果输入合法,将系统将计算玩家所输入的表达式的值,如果正确则得5分,有鬼且正确加10分,错误扣2分；" +  
                                    "\n(7)若玩家在1分30秒后才算出答案,则得4分,有鬼得8分,错误扣2分；" 
                                       );  
                            count=43;  
                             new MasgDlg(this,"恭喜您，挑战成功！重新游戏请按【确定】,退出游戏请按【退出】");  
                    }  
                    else{  
                        for(int i=0;i<4;i++){  
                            myStatus[i]=(float) ((int)(ran.nextFloat()*14+1));  
                            mystatus[i]=(char) ('A'+(int)(ran.nextFloat()*4));  
                            if(myStatus[i]>10f){  
                            different[i]=myStatus[i]-10f;  
                            myStatus[i]-=different[i];  
                            }  
                            else 
                             different[i]=0f;  
                            if(i==3&&!c.check(myStatus))  
                                i=2;                          
                         }    
                        for(int i=0;i<4;i++)  
                            myStatus[i]+=different[i];  
                        NewPanel(myStatus,mystatus);  
                        for(int i=0;i<4;i++){  
                          myStatus[i]-=different[i];  
                          if(different[i]==4)  
                                 addscore=true;  
                        }  
                    }  
                }  
            }catch(Exception e1){  
              e1.printStackTrace();   
            }  
        }  
    }  
 
      
      
      
      
    private float calculateString(String str) {  
    // 判断玩家输入的表达式的合法性                 
                      
                    int LBracketNum=0;//记录左括号个数  
                    int RBracketNum=0;//记录右括号个数  
                    int LBracketPla = 0;//记录左括号位置和     
                    int RBracketPla = 0;//记录右括号位置和   
                    int []LeftBracket=new int[10];//存放左括号的位置  
                    int []RightBracket=new int[10];//存放左括号的位置  
                    String tempStr,myString="";//临时字符，数字字符  
                    int numberNo=0,operatorNo=0;//数字个数，运算符个数  
                    String[]operators=new String[4];//保存运算符  
                    for(int i=0;i<4;i++){  
                        operators[i]="";//运算符数组初始化  
                    }  
                for(int i=0;i<str.length();i++){  
                    tempStr=str.substring(i,i+1);//对玩家输入的字符串逐个检验  
                    if(isNumber(tempStr)){//判断是否数字  
                        myString+=tempStr;  
                          
                    }else if(isOperator(tempStr)){//判断是否运算符  
                        if(numberNo>=4||operatorNo>=3)  
                            return -1f;  
                        try{  
                            numbers[numberNo]=(float) Integer.parseInt(myString);//对输入的字符串中的数字，转换成浮点型  
                        }catch(Exception e){                      
                        }  
                        myString="";  
                        numberNo++;//记录数字的个数  
                        operators[operatorNo]=tempStr;  
                        operatorNo++;//记录运算符的个数  
                        }else if(isBracket(tempStr)){//判断是否括号  
                        continue;       //Do Nothing,跳出本次循环  
                        }  
                      else   
                          return -1f;                 
                }  
                 if(myString.length()!=0&&numberNo==3){  
                       try{  
                           numbers[numberNo]=Float.parseFloat(myString);  
                       }catch(Exception e){   
                           return -1f;  
                       }  
                 }    
          
                numberNo=0;operatorNo=0;myString="";  
                for(int i=0;i<str.length();i++){  
                    tempStr=str.substring(i,i+1);  
                      
                    if(isNumber(tempStr)){  
                        myString+=tempStr;  
                          
                            if(numbers[numberNo]==Float.parseFloat(myString)){//判断数字是否一样，若一样则记录个数                 
                              numberNo++;  
                               
                        }  
                        continue;  
                    }  
                    else if(isOperator(tempStr)){  
                        operatorNo++;  
                        myString="";  
                        continue;  
                    }  
                  else if(isBracket(tempStr)){  
                       myString="";  
                        
                     if(tempStr.equals("(")){//记录左括号个数  
                    LBracketNum ++;  
                      
                    LeftBracket[LBracketNum-1]=numberNo+operatorNo+1;//记录每个左括号的位置      
                    LBracketPla +=numberNo+operatorNo;  //记录所有左括号的位置和     
                  
                    }  
                    else {//用同样的方法处理右括号  
                    RBracketNum ++;  
                      
                    RightBracket[RBracketNum-1]=numberNo+operatorNo+1;   
                    RBracketPla +=numberNo+operatorNo;  
                      
                    }  
                  }       
                }                 
                  
                  
                if(LBracketNum==RBracketNum&&LBracketNum==0)//判断是否没有左右括号  
                {  
                    ;//Do Nothing  
                }  
                else if(LBracketNum!=RBracketNum||LBracketPla>=RBracketPla){//括号使用错误（不匹配）  
                    return -1f;  
                  }  
                  
                for(int i1=0;i1<LeftBracket.length&&LeftBracket[i1]!=0;i1++){         
                       
                    if(LeftBracket[i1]%2==0||LeftBracket[i1]==7){//括号使用错误（左括号位置不正确）  
                        return -1f;  
                    }  
                }  
                for(int i1=0;i1<RightBracket.length&&LeftBracket[i1]!=0;i1++){  
                     if(RightBracket[i1]%2!=0||RightBracket[i1]==2){//括号使用错误（右括号位置不正确）  
                        return -1f;  
                    }  
                }     
    if(!isRightNum())//判断用户输入的数字是否为扑克牌上的数字  
        return -1f;                       
    
    //计算用户输入的表达式的值    
    else          
        {  
        float result=c.string_float(str);  
        return result;  
         }  
         
 }    
 
      
      
      
    private boolean isBracket(String str) {//判断是否为括号的方法  
        if(str.equals("(")||str.equals(")")){  
            return true;  
        }else 
        return false;  
    }  
      
      
      
      
    private boolean isNumber(String str) {//判断是否为数字的方法  
        if(str.equals("0")||str.equals("1")||str.equals("2")||str.equals("3")  
        ||str.equals("4")||str.equals("5")||str.equals("6")||str.equals("7")  
        ||str.equals("8")||str.equals("9")){  
            return true;  
        }  
        else      
        return false;  
    }  
      
      
      
    private boolean isOperator(String str) {//判断是否为运算符的方法  
        if(str.equals("+")||str.equals("-")||str.equals("*")||str.equals("/")){  
            return true;  
        }  
    else 
        return false;  
    }  
      
       
      
      
      
    private boolean isRightNum(){//判断表达式的数字就是扑克牌上的数字  
    float tempStatus[]=new float[4];  
    for(int i=0;i<4;i++){  
        tempStatus[i]=myStatus[i];  
    }  
    for(int i=0;i<4;i++){  
        int j=0;  
        boolean existed=false;  
        while(j<4&&!existed){  
            if(tempStatus[j]==numbers[i]){  
                tempStatus[j]=-1f;  
                existed=true;  
            }  
            j++;  
        }  
        if(!existed)  
            return false;  
    }  
    return true;  
  }  
      
    
      
      
      
    private void NewPanel(float[] a,char[] Tempb){//扑克牌面板  
    pokerPanel.setLayout(new FlowLayout());  
     int []Tempa=new int[4];      
    for(int i=0;i<4;i++){                
        Tempa[i]=(int)a[i];  
    System.out.print(Tempa[i]+""+Tempb[i]+" ");  
    }  
    System.out.println();  
      
    //装载图片  
    URL url1=getClass().getResource(Tempa[0]+""+Tempb[0]+".jpg");     
    URL url2=getClass().getResource(Tempa[1]+""+Tempb[1]+".jpg");  
    URL url3=getClass().getResource(Tempa[2]+""+Tempb[2]+".jpg");  
    URL url4=getClass().getResource(Tempa[3]+""+Tempb[3]+".jpg");  
      
    poker1.setIcon(new ImageIcon(url1));  
    poker2.setIcon(new ImageIcon(url2));  
    poker3.setIcon(new ImageIcon(url3));  
    poker4.setIcon(new ImageIcon(url4));  
      
    poker1.setBackground(new Color(18,152,57));  
    poker2.setBackground(new Color(18,152,57));  
    poker3.setBackground(new Color(18,152,57));  
    poker4.setBackground(new Color(18,152,57));  
      
    frame.setSize(650, 480);  
    pokerPanel.setBackground(new Color(18,132,57));  
    Buttompnl.setBackground(new Color(18,132,57));  
      
    frame.setLocation((screen.width-frame.getSize().width)/2, (screen.height-frame.getSize().height)/2);  
    frame.setVisible(true);  
    frame.setResizable(false);  
    frame.addWindowListener(new WindowAdapter(){//设置窗口关闭监听器  
          public void windowClosing(WindowEvent e){  
           System.exit(0);  
            }  
      });  
  }   
      
 
      
      
    public static void main(String[] args){//程序入口，主函数调用  
        Calculate24 Start=new Calculate24();//实例化为对象  
        float []a=new float[4];  
        char []b=new char [4];  
        for(int i=0;i<4;i++)  
        b[i]='A';  
        Start.NewPanel(a,b);  
    }  
} 

#p#

Java代码片段：

//import java.util.Random;  
 
/*  
 * 检查类，【本游戏的核心算法】  
 * ①用于检查随机生成的4个1~10的随机数能否通过运算得到24，  
 * 如果不能则再次产生4个随机数，  
 * 直到产生能够运算得到24的随机数为止  
 * ②检查用户输入的表达式是否合法或运算结果是否正确  
 */ 
public class Check {   
     protected String outputs=new String();  
    /*  
     * 返回随机数全排列的方法，  
     * 对产生的四个随机数进行全排列，  
     * 共有4*3*2*1=24种情况，  
     * 考虑到运行效率，  
     * 直接将各种情况罗列出来，  
     * 没有用递归全排列的方法，  
     * 该方法通过形参i控制选取24种排列的第几种，  
     * 返回四个数的一维浮点型数组  
     */ 
    private float[] number(float [] a,int i){  
         final float[] Array = new float[4];  
            switch(i){  
            case 0 : Array[0]=a[0];Array[1]=a[1];Array[2]=a[2];Array[3]=a[3];break;  
            case 1 : Array[0]=a[0];Array[1]=a[1];Array[2]=a[3];Array[3]=a[2];break;  
            case 2 : Array[0]=a[0];Array[1]=a[2];Array[2]=a[1];Array[3]=a[3];break;  
            case 3 : Array[0]=a[0];Array[1]=a[2];Array[2]=a[3];Array[3]=a[1];break;  
            case 4 : Array[0]=a[0];Array[1]=a[3];Array[2]=a[2];Array[3]=a[1];break;  
            case 5 : Array[0]=a[0];Array[1]=a[3];Array[2]=a[1];Array[3]=a[2];break;  
            case 6 : Array[0]=a[1];Array[1]=a[0];Array[2]=a[2];Array[3]=a[3];break;  
            case 7 : Array[0]=a[1];Array[1]=a[0];Array[2]=a[3];Array[3]=a[2];break;  
            case 8 : Array[0]=a[1];Array[1]=a[2];Array[2]=a[0];Array[3]=a[3];break;  
            case 9 : Array[0]=a[1];Array[1]=a[2];Array[2]=a[3];Array[3]=a[0];break;  
            case 10: Array[0]=a[1];Array[1]=a[3];Array[2]=a[2];Array[3]=a[0];break;  
            case 11: Array[0]=a[1];Array[1]=a[3];Array[2]=a[0];Array[3]=a[2];break;  
            case 12: Array[0]=a[2];Array[1]=a[1];Array[2]=a[0];Array[3]=a[3];break;  
            case 13: Array[0]=a[2];Array[1]=a[1];Array[2]=a[3];Array[3]=a[0];break;  
            case 14: Array[0]=a[2];Array[1]=a[0];Array[2]=a[1];Array[3]=a[3];break;  
            case 15: Array[0]=a[2];Array[1]=a[0];Array[2]=a[3];Array[3]=a[1];break;  
            case 16: Array[0]=a[2];Array[1]=a[3];Array[2]=a[0];Array[3]=a[1];break;  
            case 17: Array[0]=a[2];Array[1]=a[3];Array[2]=a[1];Array[3]=a[0];break;  
            case 18: Array[0]=a[3];Array[1]=a[1];Array[2]=a[2];Array[3]=a[0];break;  
            case 19: Array[0]=a[3];Array[1]=a[1];Array[2]=a[0];Array[3]=a[2];break;  
            case 20: Array[0]=a[3];Array[1]=a[2];Array[2]=a[1];Array[3]=a[0];break;  
            case 21: Array[0]=a[3];Array[1]=a[2];Array[2]=a[0];Array[3]=a[1];break;  
            case 22: Array[0]=a[3];Array[1]=a[0];Array[2]=a[2];Array[3]=a[1];break;  
            case 23: Array[0]=a[3];Array[1]=a[0];Array[2]=a[1];Array[3]=a[2];break;  
            }  
         return  Array ;  
     }  
      
 
      
      
    /*  
     * 返回运算符排列的方法，  
     * 四个数进行运算时需要三个运算符，  
     * 三个运算符的所有可能的排列是4^3=64种，  
     * 该方法直接返回64种运算符，  
     * 保存在二维字符型数组   
     */ 
    private char [][]Calculate(){  
         final char [][] Char=new char [64][3];//返回的运算符数组  
        final int [][] ar=new int [64][3];//控制返回三个运算符  
        int t=0;  
        stop:for(int i=0;i<4;i++){  
               for(int j=0;j<4;j++){  
                 for(int k=0;k<4;k++){    
                    ar[t][0]=i;  
                    ar[t][1]=j;  
                    ar[t][2]=k;           
                    for(int l=0;l<3;l++){//i,j,k的范围都是0~3，通过switch,将0~3分别映射为+，—，*，/  
                        switch(ar[t][l]){  
                        case 0:Char[t][l]='+';break;  
                        case 1:Char[t][l]='-';break;  
                        case 2:Char[t][l]='*';break;  
                        case 3:Char[t][l]='/';break;  
                        }  
                    }  
                    t++;  
                    if(t==64)  
                        break stop; //通过t的自增控制循环的结束       
                }  
            }  
        }     
        return Char;  
    }     
 
      
      
      
      
    /*  
     * 返回计算结果的方法，  
     * 对两个随机数进行运算  
     */ 
    private float Run(float a,float b,char c){  
        float sum=0f;  
        switch(c){  
        case '+': sum=a+b;break; //将'+'字符转换成加法运算  
        case '-': sum=a-b;break; //将'-'字符转换成减法运算  
        case '*': sum=a*b;break; //将'*'字符转换成乘法运算  
        case '/': sum=a/b;break; //将'/'字符转换成除法运算  
        }  
        return sum;       
    }  
 
      
      
      
      
      
    /*  
     * check方法  
     * 如果可以运算得到24，  
     * 返回true，  
     * 否则返回false  
     * 为了节省运行时间，  
     * 运算时，  
     * 只要某一次运算结果是24就直接返回true  
     * 只有产生的随机数不能运算得到24时才会运行所有情况  
     */ 
     protected  boolean check(float[] myStatus){  
          
        float num[]=new float [4];  
        char [][] allcha=new char [64][3];  
         allcha=Calculate();  
        for(int i=0;i<24;i++){  
            for(int j=0;j<64;j++){  
                    float x;  
                   num=number(myStatus,i);  
                     
                   /*   
                    * 注释解析：  
                    * ABCD表示四个参与运算的随机数     
                    * ①②③表示运算顺序      
                    */ 
                   x=Run(Run(Run(num[0],num[1],allcha[j][0]),num[2],allcha[j][1]),num[3],allcha[j][2]);  
                   if(x==24.0f){  
                       //System.out.println("(("+num[0]+allcha[j][0]+num[1]+")"+allcha[j][1]+num[2]+")"+allcha[j][2]+num[3]);  
                       outputs="(("+(int)num[0]+allcha[j][0]+(int)num[1]+")"+allcha[j][1]+(int)num[2]+")"+allcha[j][2]+(int)num[3];  
                       System.out.println(outputs);  
                       return true;  
                       }  
                      // 以上运算类型为：((A①B)②C)③D  
                   x=Run(Run(num[0],num[1],allcha[j][0]),Run(num[2],num[3],allcha[j][2]),allcha[j][1]);  
                   if(x==24.0f){   
                       //System.out.println("("+num[0]+allcha[j][0]+num[1]+")"+allcha[j][1]+"("+num[2]+allcha[j][2]+num[3]+")");  
                       outputs="("+(int)num[0]+allcha[j][0]+(int)num[1]+")"+allcha[j][1]+"("+(int)num[2]+allcha[j][2]+(int)num[3]+")";  
                       System.out.println(outputs);  
                       return true;  
                       }  
                      //以上运算类型为：(A①B)②(C①D)  
                   x=Run(Run(num[0],Run(num[1],num[2],allcha[j][1]),allcha[j][0]),num[3],allcha[j][2]);  
                   if(x==24.0f){  
                       //System.out.println("("+num[0]+allcha[j][0]+"("+num[1]+allcha[j][1]+num[2]+"))"+allcha[j][2]+num[3]);  
                       outputs="("+(int)num[0]+allcha[j][0]+"("+(int)num[1]+allcha[j][1]+(int)num[2]+"))"+allcha[j][2]+(int)num[3];  
                       System.out.println(outputs);  
                       return true;  
                       }  
                      //以上运算类型为：(A②(B①C))③D  
                   x=Run(num[0],Run(Run(num[1],num[2],allcha[j][1]),num[3],allcha[j][2]),allcha[j][0]);  
                   if(x==24.0f){  
                       //System.out.println(num[0]+""+allcha[j][0]+"(("+num[1]+allcha[j][1]+num[2]+")"+allcha[j][2]+num[3]+")");  
                       outputs=(int)num[0]+""+allcha[j][0]+"(("+(int)num[1]+allcha[j][1]+(int)num[2]+")"+allcha[j][2]+(int)num[3]+")";  
                       System.out.println(outputs);  
                       return true;  
                   }  
                     //以上运算类型为：A③((B①C)②D)  
                   x=Run(num[0],Run(num[1],Run(num[2],num[3],allcha[j][2]),allcha[j][1]),allcha[j][0]);  
                   if(x==24.0f){   
                       //System.out.println(num[0]+""+allcha[j][0]+"("+num[1]+allcha[j][1]+"("+num[2]+allcha[j][2]+num[3]+"))");  
                       outputs=(int)num[0]+""+allcha[j][0]+"("+(int)num[1]+allcha[j][1]+"("+(int)num[2]+allcha[j][2]+(int)num[3]+"))";  
                       System.out.println(outputs);  
                       return true;  
                       }  
                     //以上运算类型为：A③(B②(C①D))  
           }  
        }  
        return false;                     
    }    
      
      
      
     
      
     /*  
     * 把字符串的数学表达式计算出结果  
     */      
   protected float string_float(String s0){  
        char s[]=new char[s0.length()];  
        float sum=0;//计算结果  
        float num[]={-1,-1,-1,-1};  //记录数学表达式中的数      
        int calculate_location[]={-1,-1,-1};  
        char calculate[]={'a','a','a'};//记录数学表达式中的运算符  
        int calculate_priority[]={3,2,1};//设置优先级          
        int abc;  
        for(int i=0;i<s.length;i++)  
            s[i]=s0.charAt(i);  
        for(int i=0,j=0,l=0;i<s.length;i++){//分析字符串  
            if(s[i]>='0'&&s[i]<='9')  
            {//得到数学表达式中的数  
                num[j]=s[i]-48;               
                if(i+1<s.length)  
                    if(s[i+1]>='0'&&s[i+1]<='9')  
                    {  
                        num[j]=num[j]*10+s[i+1]-48;  
                        i++;  
                    }  
                j++;  
                continue;  
            }             
            if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/')//得到表达式中的运算符                
                if(calculate_location[l]==-1)  
                {  
                    calculate_location[l]=i;  
                    calculate[l]=s[i];  
                    l++;  
                }         
        }  
        for(int i=0,i0=0,j=0;i<s.length;i++)  
        {//分析表达式的运算优先级  
            if(s[i]==')')             
            {// 先算括号里的表达式  
                for(i0=i;s[i0]!='(';i0--)                 
                    if(s[i0]=='+'||s[i0]=='-'||s[i0]=='*'||s[i0]=='/')                    
                        for(j=0;j<3;j++)  
                            if(calculate_location[j]==i0)  
                                calculate_priority[j]+=8;  
                s[i0]='s';  
            }         
            if(s[i]=='*'||s[i]=='/')//再算乘除    
                for(j=0;j<3;j++)  
                    if(calculate_location[j]==i)  
                        calculate_priority[j]+=4;             
        }         
          
        /*  
         * 此处的if是把刚才分析的运算优先级用一个int的变量abc记录下来，如123则表示第三个运算符  
         * 运算级最高，其实是第二个，最后是第一个  
         */ 
        if(calculate_priority[0]>calculate_priority[1])  
        {  
            if(calculate_priority[0]>calculate_priority[2])  
                calculate_priority[0]=-1;  
            else 
                calculate_priority[2]=-1;  
        }  
        else 
        {  
            if(calculate_priority[1]>calculate_priority[2])  
                calculate_priority[1]=-1;  
            else 
                calculate_priority[2]=-1;  
        }  
        if(calculate_priority[0]<0)  
        {  
            if(calculate_priority[1]>calculate_priority[2])  
            {  
                calculate_priority[1]=-2;  
                calculate_priority[2]=-3;  
            }  
            else 
            {  
                calculate_priority[1]=-3;  
                calculate_priority[2]=-2;  
            }  
        }  
        else 
        {  
            if(calculate_priority[1]<0)  
            {  
                if(calculate_priority[0]>calculate_priority[2])  
                {  
                    calculate_priority[0]=-2;  
                    calculate_priority[2]=-3;  
                }  
                else 
                {  
                    calculate_priority[0]=-3;  
                    calculate_priority[2]=-2;  
                }  
            }  
            else 
            {  
                if(calculate_priority[0]>calculate_priority[1])  
                {  
                    calculate_priority[0]=-2;  
                    calculate_priority[1]=-3;  
                }  
                else 
                {  
                    calculate_priority[0]=-3;  
                    calculate_priority[1]=-2;  
                }  
            }  
        }         
        abc=calculate_priority[0]*100+calculate_priority[1]*10+calculate_priority[2];  
        abc=-abc;         
          
        //根据刚才分析的运算级，计算出结果，保存在sum里面  
        switch(abc){  
        case 123:sum=Run(Run(Run(num[0],num[1],calculate[0]),num[2],calculate[1]),num[3],calculate[2]);break;  
        case 132:sum=Run(Run(num[0],num[1],calculate[0]),Run(num[2],num[3],calculate[2]),calculate[1]);break;  
        case 213:sum=Run(Run(num[0],Run(num[1],num[2],calculate[1]),calculate[0]),num[3],calculate[2]);break;  
        case 231:sum=Run(Run(num[0],num[1],calculate[0]),Run(num[2],num[3],calculate[2]),calculate[1]);break;  
        case 312:sum=Run(num[0],Run(Run(num[1],num[2],calculate[1]),num[3],calculate[2]),calculate[0]);break;  
        case 321:sum=Run(num[0],Run(num[1],Run(num[2],num[3],calculate[2]),calculate[1]),calculate[0]);break;  
        }  
          
        return sum;//返回结果  
    }  
      
      
      
 
    
    
  //测试区  
    /* public static void main(String[]args){  
        Check c=new Check();  
        Float [] test=new Float [4];  
        Random ran=new Random();  
        for(int i=0;i<4;i++)  
            test[i]=(float) ((int)(ran.nextFloat()*10+1));  
        //c.check(test);  
        System.out.println(test[0]+"  "+test[1]+"  "+test[2]+"  "+test[3]+"  "+c.check(test));  
        test[0]=5.0f;  
        test[1]=10.0f;  
        test[2]=2.0f;  
        test[3]=10.0f;  
        //c.check(test);  
        System.out.println(test[0]+"  "+test[1]+"  "+test[2]+"  "+test[3]+"  "+c.check(test));  
          
    }*/ 
} 

Java代码片段：

import java.awt.BorderLayout;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
 
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JLabel;  
import javax.swing.JPanel;  
 
 
@SuppressWarnings("serial")  
public class MasgDlg extends JFrame implements ActionListener {  
    Calculate24 bp=new Calculate24();  
     protected MasgDlg( Calculate24 btp,String strMsg){  
        this.setTitle("提示窗口");  
        bp=btp;  
       JPanel textp=new JPanel();  
       JPanel btnp=new JPanel();  
       JLabel label=new JLabel();  
       this.setLayout(new BorderLayout());  
       this.add(textp,BorderLayout.NORTH);  
       this.add(btnp,BorderLayout.SOUTH);  
      textp.add(label,BorderLayout.CENTER);  
      label.setText(strMsg);  
      this.setSize(580,100);  
      this.setLocation(400,300);  
      JButton btnOk=new JButton("确定");  
      JButton btnquit=new JButton("退出");  
      btnOk.setActionCommand("restart");  
      btnOk.addActionListener(this);  
      btnquit.setActionCommand("quit");  
      btnquit.addActionListener(this);  
      btnp.add(btnOk);  
      btnp.add(btnquit);  
      this.setVisible(true);//显示对话框  
      this.setAlwaysOnTop(true);  
      bp.btnStart.setEnabled(false);  
  }  
      
      
      
      
    public void actionPerformed(ActionEvent e) {  
        if(e.getActionCommand().equals("restart")){  
          this.dispose();  
          bp.btnStart.setEnabled(true);  
        }  
        else if(e.getActionCommand().equals("quit")){  
            System.exit(0);  
            //隐藏对话框  
        }  
    }  
      
      
      
      
    //测试区  
    /*public static void main(String []args){  
        new MsgDlg("欢迎再次使用");  
    }*/ 
} 

Java代码片段：

import java.awt.BorderLayout;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
 
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JLabel;  
import javax.swing.JPanel;  
 
@SuppressWarnings("serial")  
public class MsgDlg extends JFrame implements ActionListener {  
    Calculate24 tempCal24;  
     protected MsgDlg(String strMsg,Calculate24 Cal24){  
        //super();  
        this.setTitle("提示窗口");  
       JPanel textp=new JPanel();  
       JPanel btnp=new JPanel();  
       JLabel label=new JLabel();  
       this.setLayout(new BorderLayout());  
       this.add(textp,BorderLayout.NORTH);  
       this.add(btnp,BorderLayout.SOUTH);  
      textp.add(label,BorderLayout.CENTER);  
      label.setText(strMsg);  
      this.setSize(580,100);  
      this.setLocation(400,300);  
      JButton btnOk=new JButton("确定");  
      tempCal24=Cal24;  
      btnOk.addActionListener(this);  
      btnp.add(btnOk);  
      this.toFront();  
      tempCal24.btnOk.setEnabled(false);//使确定按钮不可用  
      this.setVisible(true);//显示对话框  
  }  
 
      
    public void actionPerformed(ActionEvent e) {  
        this.dispose();//隐藏对话框  
        tempCal24.btnOk.setEnabled(true);//激活确定按钮  
    }  
      
      
      
      
    //测试区  
    /*public static void main(String []args){  
        new MsgDlg("欢迎再次使用");  
    }*/ 
}  

Java代码片段：

import javax.swing.*;  
import java.awt.event.*;  
 
 
/*  
 * 时间显示类  
 */ 
 
@SuppressWarnings("serial")  
public class MyTimer extends JPanel  
{  
       protected int usedTime = 0;//定义初始时间为0  
        public Timer timer;  
        public JLabel usedTimeLabel = new JLabel("用时：");  
        public JTextField timeText = new JTextField(5);  
        protected  MyTimer()  
        {  
                timeText.setEditable(false);  
                timeText.setText("0分0秒");  
                setVisible(true);  
                timer = new Timer(1000,new TimerListener());  
        }  
        class TimerListener implements ActionListener//时间显示监听  
        {             
                public void actionPerformed(ActionEvent e)  
                {  
                        usedTime++;  
                        timeText.setText(usedTime/60+"分"+usedTime%60+"秒"); //显示所用时间,分秒                         
                }  
        }  
 
} 

效果图片：

下载地址：http://down.51cto.com/data/318971#

原文链接：http://www.oschina.net/code/snippet_188162_7861

【编辑推荐】

1. 一个Java程序员对2011年的回顾
2. 用Java GUI编写的画板程序
3. Java的动态绑定机制
4. JavaFX 2012：彻底开源
5. Java中带复选框的树的实现和应用