猜拳小游戏

  1 import java.util.Random;                                                                              
  2 import java.util.Scanner;                                                                             
  3                                                                                                       
  4 /*                                                                                                    
  5 请编写一个猜拳的游戏                                                                                            
  6 有个人 Tom,设计他的成员变量. 成员方法, 可以电脑猜拳. 电脑每次都会随机生成 0, 1, 2                                                    
  7 0 表示 石头 1 表示剪刀 2 表示 布                                                                                 
  8 并要可以显示 Tom的输赢次数(清单), 假定 玩三次.                                                                          
  9  */ 
 10  // 测试类,主类
 11 public class Games {                                                                               
 12                                                                                                       
 13     // 测试                                                                                             
 14     public static void main(String[] args) {                                                          
 15         // 创建一个玩家对象                                                                                   
 16         Tom t = new Tom();                                                                            
 17         // 用来记录最后输赢的次数                                                                                
 18         int isWinCount = 0;                                                                           
 19                                                                                                       
 20         // 创建一个二维数组,用来接收局数,Tom出拳情况以及电脑出拳情况                                                            
 21         int[][] arr1 = new int[3][3];                                                                 
 22         int j = 0;                                                                                    
 23                                                                                                       
 24         // 创建一个一维数组,用来接收输赢情况                                                                          
 25         String[] arr2 = new String[3];                                                                
 26                                                                                                       
 27         Scanner scanner = new Scanner(System.in);                                                     
 28         for (int i = 0; i < 3; i++) {   //比赛3次                                                              
 29             // 获取玩家出的拳                                                                                
 30             System.out.println("请输入你要出的拳(0-拳头,1-剪刀,2-布):");                                           
 31             int num = scanner.nextInt();                                                              
 32             t.setTomGuessNum(num);                                                                    
 33             int tomGuess = t.getTomGuessNum();                                                        
 34             arr1[i][j + 1] = tomGuess;                                                                
 35                                                                                                       
 36             // 获取电脑出的拳                                                                                
 37             int comGuess = t.computerNum();                                                           
 38             arr1[i][j + 2] = comGuess;                                                                
 39                                                                                                       
 40             // 将玩家猜的拳与电脑做比较                                                                           
 41             String isWin = t.vsComputer();                                                            
 42             arr2[i] = isWin;                                                                          
 43             arr1[i][j] = t.count;                                                                     
 44                                                                                                       
 45             // 对每一局的情况进行输出                                                                            
 46            System.out.println("=========================================");                           
 47             System.out.println("局数\t玩家的出拳\t电脑的出拳\t输赢情况");                                             
 48             System.out.println(t.count + "\t" + tomGuess + "\t\t" + comGuess + "\t\t" + t.vsComputer());
 49             System.out.println("=========================================");                          
 50             System.out.println("\n\n");                                                               
 51             isWinCount = t.winCount(isWin);                                                           
 52         }                                                                                             
 53                                                                                                       
 54         // 对游戏的最终结果进行输出                                                                               
 55         System.out.println("局数\t玩家的出拳\t电脑的出拳\t\t输赢情况");                                               
 56         for (int a = 0; a < arr1.length; a++) {                                                       
 57             for (int b = 0; b < arr1[a].length; b++) {                                                
 58                 System.out.print(arr1[a][b] + "\t\t\t");                                              
 59             }                                                                                         
 60                                                                                                       
 61             System.out.print(arr2[a]);                                                                
 62             System.out.println();                                                                     
 63         }                                                                                             
 64         System.out.println("你赢了" + isWinCount + "次");                                                 
 65     }                                                                                                 
 66                                                                                                       
 67 }                                                                                                     
 68 
 69 // Tom类
 70 class Tom {     // 核心代码  
 71     // 玩家出拳的类型 
 72     int tomGuessNum; //0,1,2
 73     // 电脑出拳的类型
 74     int comGuessNum; //0,1,2
 75     // 玩家赢的次数
 76     int winCountNum;  
 77     // 比赛的次数
 78     int count = 1;   //一共比赛3次                                                                                 
 79      
 80     
 81     public void showInfo() {
 82         //....
 83     }
 84     
 85     /**                                                                                               
 86      * 电脑随机生成猜拳的数字的方法                                                                                 
 87      * @return                                                                                        
 88      */                                                                                               
 89     public int computerNum() {                                                                        
 90         Random r = new Random();                                                                      
 91         comGuessNum = r.nextInt(3);      // 方法 返回 0-2的随机数                                                             
 92         // System.out.println(comGuessNum);                                                           
 93         return comGuessNum;                                                                           
 94     }                                                                                                 
 95                                                                                                       
 96     /**                                                                                               
 97      * 设置玩家猜拳的数字的方法                                                                                   
 98      * @param tomGuessNum                                                                             
 99      */                                                                                               
100     public void setTomGuessNum(int tomGuessNum) {                                                     
101         if (tomGuessNum > 2 || tomGuessNum < 0) { 
102             //抛出一个异常, 李同学会写,没有处理
103             throw new IllegalArgumentException("数字输入错误");                                             
104         }                                                                                             
105         this.tomGuessNum = tomGuessNum;                                                               
106     }                                                                                                 
107                                                                                                       
108     public int getTomGuessNum() {                                                                     
109         return tomGuessNum;                                                                           
110     }                                                                                                 
111                                                                                                       
112     /**                                                                                               
113      * 比较猜拳的结果                                                                                        
114      * @return 玩家赢返回true,否则返回false                                                                    
115      */                                                                                               
116     public String vsComputer() { 
117          //比较巧
118         if (tomGuessNum == 0 && comGuessNum == 1) {                                                   
119             return "你赢了";                                                                             
120         } else if (tomGuessNum == 1 && comGuessNum == 2) {                                            
121             return "你赢了";                                                                             
122         } else if (tomGuessNum == 2 && comGuessNum == 0) {                                            
123             return "你赢了";                                                                             
124         } else if (tomGuessNum == comGuessNum){                                                       
125             return "平手";                                                                              
126         } else {                                                                                      
127             return "你输了";                                                                             
128         }                                                                                             
129     }                                                                                                 
130                                                                                                       
131     /**                                                                                               
132      * 记录玩家赢的次数                                                                                       
133      * @return                                                                                        
134      */                                                                                               
135     public int winCount(String s) {                                                                   
136         count++;    //控制玩的次数                                                                                   
137         if (s.equals("你赢了")) {     //统计赢的次数                                                                   
138             winCountNum++;                                                                            
139         }                                                                                             
140         return winCountNum;                                                                           
141     }                                                                                                 
142                                                                                                       
143 }                                                                                                     

 

posted @ 2024-08-26 09:48  勤奋的小番茄  阅读(11)  评论(0编辑  收藏  举报