码上快乐

相关内容   简体   繁体

第十三章 指导学习：人机猜拳

本文转载自  查看原文  2015-08-14 14:32  2009    使用Java理解程序逻辑

一、难点突破

1 知识梳理

二、综合练习

1 阶段1：练习——分析业务，创建用户类 

1.1 需求说明

  • 分析业务，抽象出类、类的特征和行为

  • 创建用户类

    

1.2 分析

1.3 代码

  • 创建用户：定义用户类Person，定义类的属性（name、score)和类的方法（showFirst()) 

  
  
  

   
   
   
     
    
  1. /**
    2.  
   

   
   
   
     
    
  1.  * 
    2.  
   

   
   
   
     
    
  1.  * @author wangshaohua
    2.  
   

   
   
   
     
    
  1.  * 
    2.  
   

   
   
   
     
    
  1.  */
    2.  
   

   
   
   
     
    
  1. public class Person {
    2.  
   

   
   
   
     
    
  1.  String name = "匿名"; // 名字
    2.  
   

   
   
   
     
    
  1.  int score = 0; // 积分
    2.  
   

   
   
   
     
    
    2.  
   

   
   
   
     
    
  1.  /**
    2.  
   

   
   
   
     
    
  1.  * 出拳
    2.  
   

   
   
   
     
    
  1.  * 
    2.  
   

   
   
   
     
    
  1.  * @return 出拳结果：1.剪刀 2.石头 3.布
    2.  
   

   
   
   
     
    
  1.  */
    2.  
   

   
   
   
     
    
  1.  public int showFist() {
    2.  
   

   
   
   
     
    
  1.  // 接收用户的选择
    2.  
   

   
   
   
     
    
  1.  Scanner input = new Scanner(System.in);
    2.  
   

   
   
   
     
    
  1.  System.out.print("\n请出拳:1.剪刀 2.石头 3.布 (输入相应数字) :");
    2.  
   

   
   
   
     
    
  1.  int show = input.nextInt();
    2.  
   

   
   
   
     
    
    2.  
   

   
   
   
     
    
  1.  // 输出出拳结果，并返回
    2.  
   

   
   
   
     
    
  1.  switch (show) {
    2.  
   

   
   
   
     
    
  1.  case 1:
    2.  
   

   
   
   
     
    
  1.  System.out.println("你出拳: 剪刀");
    2.  
   

   
   
   
     
    
  1.  break;
    2.  
   

   
   
   
     
    
  1.  case 2:
    2.  
   

   
   
   
     
    
  1.  System.out.println("你出拳: 石头");
    2.  
   

   
   
   
     
    
  1.  break;
    2.  
   

   
   
   
     
    
  1.  case 3:
    2.  
   

   
   
   
     
    
  1.  System.out.println("你出拳: 布");
    2.  
   

   
   
   
     
    
  1.  break;
    2.  
   

   
   
   
     
    
  1.  }
    2.  
   

   
   
   
     
    
  1.  return show;
    2.  
   

   
   
   
     
    
  1.  }
    2.  
   

   
   
   
     
    
  1. }
    2.  
   

  
  
  

  
  
  
    
   
   
   
    2. 
  
  
  

  
  
  
    
   
   
   
    2.

  • 测试用户出拳
  
  
  
    
   
   
   
  1. /**
    2. 
   
   
   
  2.  * 人机互动版猜拳游戏
    3. 
   
   
   
  3.  * 阶段1：测试用户出拳
    4. 
   
   
   
  4.  * 
    5. 
   
   
   
  5.  */
    6. 
   
   
   
  6. public class TestPerson {
    7. 
   
   
   
  7.  public static void main(String[] args) {
    8. 
   
   
   
  8.  Person person = new Person();
    9. 
   
   
   
  9.  System.out.println(person.showFist());
    10. 
   
   
   
  10.  }
    11. 
   
   
   
  11. }
    12.

2 阶段2：练习——创建计算机类

2.1 需求说明

          创建计算机类Computer。实现计算机出拳
         

2.2 分析

产生一个1～3的随机数，模拟计算机的出拳结果，例如，产生2，显示“电脑出拳：石头”

2.3 代码

  • 计算机类

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 计算机类
    3. 
    
    
    
  3.  * 阶段2完成
    4. 
    
    
    
  4.  */
    5. 
    
    
    
  5. public class Computer {
    6. 
    
    
    
  6.  String name = "电脑"; // 名字
    7. 
    
    
    
  7.  int score = 0;; // 积分
    8. 
    
    
    
  8.  
    9. 
    
    
    
  9.  /**
    10. 
    
    
    
  10.  * 出拳
    11. 
    
    
    
  11.  * @return 出拳结果：1.剪刀 2.石头 3.布
    12. 
    
    
    
  12.  */
    13. 
    
    
    
  13.  public int showFist(){
    14. 
    
    
    
  14.  // 产生随机数
    15. 
    
    
    
  15.  int show = (int)(Math.random()*10)%3 + 1; //产生随机数，表示电脑出拳
    16. 
    
    
    
  16.  
    17. 
    
    
    
  17.  // 输出出拳结果并返回
    18. 
    
    
    
  18.  switch(show){
    19. 
    
    
    
  19.  case 1:
    20. 
    
    
    
  20.  System.out.println(name+"出拳: 剪刀");
    21. 
    
    
    
  21.  break;
    22. 
    
    
    
  22.  case 2:
    23. 
    
    
    
  23.  System.out.println(name+"出拳: 石头");
    24. 
    
    
    
  24.  break;
    25. 
    
    
    
  25.  case 3: 
    26. 
    
    
    
  26.  System.out.println(name+"出拳: 布");
    27. 
    
    
    
  27.  break;
    28. 
    
    
    
  28.  }
    29. 
    
    
    
  29.  return show;
    30. 
    
    
    
  30.  }
    31. 
    
    
    
  31. }
    32.
  • 测试计算机类

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 人机互动版猜拳游戏
    3. 
    
    
    
  3.  * 阶段2：测试电脑出拳 
    4. 
    
    
    
  4.  */
    5. 
    
    
    
  5. public class TestComputer {
    6. 
    
    
    
  6.  public static void main(String[] args) {
    7. 
    
    
    
  7.  Computer computer = new Computer();
    8. 
    
    
    
  8.  System.out.println(computer.showFist());
    9. 
    
    
    
  9.  }
    10. 
    
    
    
  10. }
    11.

3 阶段3 练习——创建游戏类，选择对战对手

3.1 需求说明

  • 创建游戏类Game
  • 编写游戏类的初始化方法initial()
  • 编写游戏类的开始游戏方法startGame()

    

3.2 分析

3.3 代码

  • 游戏类

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 游戏类
    3. 
    
    
    
  3.  */
    4. 
    
    
    
  4. public class Game1 {
    5. 
    
    
    
  5.  Person person; //甲方
    6. 
    
    
    
  6.  Computer computer; //乙方
    7. 
    
    
    
  7.  int count; //对战次数
    8. 
    
    
    
  8.  
    9. 
    
    
    
  9.  /**
    10. 
    
    
    
  10.  * 初始化
    11. 
    
    
    
  11.  */
    12. 
    
    
    
  12.  public void initial(){
    13. 
    
    
    
  13.  person = new Person();
    14. 
    
    
    
  14.  computer = new Computer();
    15. 
    
    
    
  15.  count = 0;
    16. 
    
    
    
  16.  }
    17. 
    
    
    
  17.  
    18. 
    
    
    
  18.  /**
    19. 
    
    
    
  19.  * 开始游戏
    20. 
    
    
    
  20.  */
    21. 
    
    
    
  21.  public void startGame() {
    22. 
    
    
    
  22.  initial();
    23. 
    
    
    
  23.  System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
    24. 
    
    
    
  24.  System.out.println("\n\t\t******************");
    25. 
    
    
    
  25.  System.out.println ("\t\t** 猜拳, 开始 **");
    26. 
    
    
    
  26.  System.out.println ("\t\t******************");
    27. 
    
    
    
  27.  
    28. 
    
    
    
  28.  System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
    29. 
    
    
    
  29.  /*选择对方角色*/
    30. 
    
    
    
  30.  System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
    31. 
    
    
    
  31.  Scanner input = new Scanner(System.in);
    32. 
    
    
    
  32.  int role = input.nextInt();
    33. 
    
    
    
  33.  if(role == 1){
    34. 
    
    
    
  34.  computer.name = "刘备";
    35. 
    
    
    
  35.  }else if(role == 2){
    36. 
    
    
    
  36.  computer.name = "孙权";
    37. 
    
    
    
  37.  }else if(role == 3){
    38. 
    
    
    
  38.  computer.name = "曹操";
    39. 
    
    
    
  39.  } 
    40. 
    
    
    
  40.  
    41. 
    
    
    
  41.  System.out.print("你选择了"+computer.name+"对战");
    42. 
    
    
    
  42.  }
    43. 
    
    
    
  43. }
    44.
  • 测试开始游戏：选择对战角色
    
    
    
    
     
     
     
  1. /**
    2. 
     
     
     
  2.  * 人机互动版猜拳游戏
    3. 
     
     
     
  3.  * 阶段3：测试开始游戏：选择对战角色
    4. 
     
     
     
  4.  */
    5. 
     
     
     
  5. public class TestGame1 {
    6. 
     
     
     
  6.  public static void main(String[] args) {
    7. 
     
     
     
  7.  Game1 game = new Game1();
    8. 
     
     
     
  8.  game.startGame();
    9. 
     
     
     
  9.  }
    10. 
     
     
     
  10. }
    11.

4 阶段4：练习——实现一局对战

4.1 需求说明

    分别调用用户类和计算机类的出拳方法showFist()，接受返回值并比较，给出胜负结果
              

4.2 分析
4.3 代码

  
  
  
    
   
   
   
  • 实现一局对战
    • 
  
  
  

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 游戏类
    3. 
    
    
    
  3.  * 阶段4：实现一局对战
    4. 
    
    
    
  4.  */
    5. 
    
    
    
  5. public class Game2 {
    6. 
    
    
    
  6.  Person person; //甲方
    7. 
    
    
    
  7.  Computer computer; //乙方
    8. 
    
    
    
  8.  int count; //对战次数
    9. 
    
    
    
  9.  
    10. 
    
    
    
  10.  /**
    11. 
    
    
    
  11.  * 初始化
    12. 
    
    
    
  12.  */
    13. 
    
    
    
  13.  public void initial(){
    14. 
    
    
    
  14.  person = new Person();
    15. 
    
    
    
  15.  computer = new Computer();
    16. 
    
    
    
  16.  count = 0;
    17. 
    
    
    
  17.  }
    18. 
    
    
    
  18.  
    19. 
    
    
    
  19.  /**
    20. 
    
    
    
  20.  * 开始游戏
    21. 
    
    
    
  21.  */
    22. 
    
    
    
  22.  public void startGame() {
    23. 
    
    
    
  23.  initial(); // 初始化
    24. 
    
    
    
  24.  System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
    25. 
    
    
    
  25.  System.out.println("\n\t\t******************");
    26. 
    
    
    
  26.  System.out.println ("\t\t** 猜拳, 开始 **");
    27. 
    
    
    
  27.  System.out.println ("\t\t******************");
    28. 
    
    
    
  28.  
    29. 
    
    
    
  29.  System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
    30. 
    
    
    
  30.  /*选择对方角色*/
    31. 
    
    
    
  31.  System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
    32. 
    
    
    
  32.  Scanner input = new Scanner(System.in);
    33. 
    
    
    
  33.  int role = input.nextInt();
    34. 
    
    
    
  34.  if(role == 1){
    35. 
    
    
    
  35.  computer.name = "刘备";
    36. 
    
    
    
  36.  }else if(role == 2){
    37. 
    
    
    
  37.  computer.name = "孙权";
    38. 
    
    
    
  38.  }else if(role == 3){
    39. 
    
    
    
  39.  computer.name = "曹操";
    40. 
    
    
    
  40.  } 
    41. 
    
    
    
  41.  System.out.println("你选择了 "+computer.name+"对战");
    42. 
    
    
    
  42.  
    43. 
    
    
    
  43.  /*开始游戏*/
    44. 
    
    
    
  44.  System.out.print("\n要开始吗？（y/n） ");
    45. 
    
    
    
  45.  String con = input.next();
    46. 
    
    
    
  46.  int perFist; //用户出的拳
    47. 
    
    
    
  47.  int compFist; //计算机出的拳
    48. 
    
    
    
  48.  if(con.equals("y")){
    49. 
    
    
    
  49.  /*出拳*/
    50. 
    
    
    
  50.  perFist = person.showFist();
    51. 
    
    
    
  51.  compFist = computer.showFist();
    52. 
    
    
    
  52.  /*裁决*/
    53. 
    
    
    
  53.  if((perFist == 1 && compFist == 1) || (perFist == 2 && compFist == 2) || (perFist == 3 && compFist == 3)){
    54. 
    
    
    
  54.  System.out.println("结果:和局,真衰！\n"); //平局
    55. 
    
    
    
  55.  }else if((perFist == 1 && compFist == 3) || (perFist == 2 && compFist == 1) || (perFist == 3 && compFist == 2)){
    56. 
    
    
    
  56.  System.out.println("结果： 恭喜， 你赢了！"); //用户赢 
    57. 
    
    
    
  57.  }else{
    58. 
    
    
    
  58.  System.out.println("结果说:^_^,你输了，真笨!\n"); //计算机赢 
    59. 
    
    
    
  59.  } 
    60. 
    
    
    
  60.  } 
    61. 
    
    
    
  61.  }
    62. 
    
    
    
  62. }
    63.
  • 测试开始游戏：实现1局对战

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 人机互动版猜拳游戏
    3. 
    
    
    
  3.  * 阶段4：测试开始游戏：实现1局对战
    4. 
    
    
    
  4.  */
    5. 
    
    
    
  5. public class TestGame2 {
    6. 
    
    
    
  6.  public static void main(String[] args) {
    7. 
    
    
    
  7.  Game2 game = new Game2();
    8. 
    
    
    
  8.  game.startGame();
    9. 
    
    
    
  9.  }
    10. 
    
    
    
  10. }
    11.

5 阶段5：练习——实现循环对战，并累计得分 

5.1 需求说明

    实现循环对战，

并且累加赢家的得分

    

5.2 分析
5.3 代码

  • 实现循环对战
      
      
      
    
       
       
       
  1. /**
    2. 
       
       
       
  2.  * 游戏类
    3. 
       
       
       
  3.  * 阶段5：实现循环对战
    4. 
       
       
       
  4.  *
    5. 
       
       
       
  5.  */
    6. 
       
       
       
  6. public class Game3 {
    7. 
       
       
       
  7.  Person person; //甲方
    8. 
       
       
       
  8.  Computer computer; //乙方
    9. 
       
       
       
  9.  int count; //对战次数
    10. 
       
       
       
  10.  
    11. 
       
       
       
  11.  /**
    12. 
       
       
       
  12.  * 初始化
    13. 
       
       
       
  13.  */
    14. 
       
       
       
  14.  public void initial(){
    15. 
       
       
       
  15.  person = new Person();
    16. 
       
       
       
  16.  computer = new Computer();
    17. 
       
       
       
  17.  count = 0;
    18. 
       
       
       
  18.  }
    19. 
       
       
       
  19.  
    20. 
       
       
       
  20.  /**
    21. 
       
       
       
  21.  * 开始游戏
    22. 
       
       
       
  22.  */
    23. 
       
       
       
  23.  public void startGame() {
    24. 
       
       
       
  24.  initial(); // 初始化
    25. 
       
       
       
  25.  System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
    26. 
       
       
       
  26.  System.out.println("\n\t\t******************");
    27. 
       
       
       
  27.  System.out.println ("\t\t** 猜拳, 开始 **");
    28. 
       
       
       
  28.  System.out.println ("\t\t******************");
    29. 
       
       
       
  29.  
    30. 
       
       
       
  30.  System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
    31. 
       
       
       
  31.  /*选择对方角色*/
    32. 
       
       
       
  32.  System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
    33. 
       
       
       
  33.  Scanner input = new Scanner(System.in);
    34. 
       
       
       
  34.  int role = input.nextInt();
    35. 
       
       
       
  35.  if(role == 1){
    36. 
       
       
       
  36.  computer.name = "刘备";
    37. 
       
       
       
  37.  }else if(role == 2){
    38. 
       
       
       
  38.  computer.name = "孙权";
    39. 
       
       
       
  39.  }else if(role == 3){
    40. 
       
       
       
  40.  computer.name = "曹操";
    41. 
       
       
       
  41.  } 
    42. 
       
       
       
  42.  System.out.println("你选择了 "+computer.name+"对战");
    43. 
       
       
       
  43.  
    44. 
       
       
       
  44.  /*开始游戏*/
    45. 
       
       
       
  45.  System.out.print("\n要开始吗？（y/n） ");
    46. 
       
       
       
  46.  String con = input.next();
    47. 
       
       
       
  47.  int perFist; //用户出的拳
    48. 
       
       
       
  48.  int compFist; //计算机出的拳
    49. 
       
       
       
  49.  while(con.equals("y")){
    50. 
       
       
       
  50.  /*出拳*/
    51. 
       
       
       
  51.  perFist = person.showFist();
    52. 
       
       
       
  52.  compFist = computer.showFist();
    53. 
       
       
       
  53.  /*裁决*/
    54. 
       
       
       
  54.  if((perFist == 1 && compFist == 1) || (perFist == 2 && compFist == 2) || (perFist == 3 && compFist == 3)){
    55. 
       
       
       
  55.  System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n"); //平局
    56. 
       
       
       
  56.  }else if((perFist == 1 && compFist == 3) || (perFist == 2 && compFist == 1) || (perFist == 3 && compFist == 2)){
    57. 
       
       
       
  57.  System.out.println("结果： 恭喜， 你赢了！"); //用户赢
    58. 
       
       
       
  58.  person.score++;
    59. 
       
       
       
  59.  }else{
    60. 
       
       
       
  60.  System.out.println("结果说:^_^,你输了，真笨!\n"); //计算机赢
    61. 
       
       
       
  61.  computer.score++;
    62. 
       
       
       
  62.  }
    63. 
       
       
       
  63.  count++;
    64. 
       
       
       
  64.  System.out.print("\n是否开始下一轮（y/n）: ");
    65. 
       
       
       
  65.  con = input.next();
    66. 
       
       
       
  66.  }
    67. 
       
       
       
  67.  }
    68. 
       
       
       
  68. }
    69.
  • 测试循环对战
 

     
     
     
    
      
      
      
  1. public class TestGame3 {
    2. 
      
      
      
  2.  public static void main(String[] args) {
    3. 
      
      
      
  3.  Game3 game = new Game3();
    4. 
      
      
      
  4.  game.startGame();
    5. 
      
      
      
  5.  }
    6. 
      
      
      
  6. }
    7.

6 阶段6：练习——显示对战结果

6.1 需求说明

        游戏结束后，显示对战结果

        

6.2 分析

    编写showResult( )方法， 比较二者的得分情况， 给出对战结果

6.3 代码

  • 实现对战结果显示

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 游戏类
    3. 
    
    
    
  3.  * 阶段6：实现对战结果显示
    4. 
    
    
    
  4.  */
    5. 
    
    
    
  5. public class Game4 {
    6. 
    
    
    
  6.  Person person; //甲方
    7. 
    
    
    
  7.  Computer computer; //乙方
    8. 
    
    
    
  8.  int count; //对战次数
    9. 
    
    
    
  9.  
    10. 
    
    
    
  10.  /**
    11. 
    
    
    
  11.  * 初始化
    12. 
    
    
    
  12.  */
    13. 
    
    
    
  13.  public void initial(){
    14. 
    
    
    
  14.  person = new Person();
    15. 
    
    
    
  15.  computer = new Computer();
    16. 
    
    
    
  16.  count = 0;
    17. 
    
    
    
  17.  }
    18. 
    
    
    
  18.  
    19. 
    
    
    
  19.  /**
    20. 
    
    
    
  20.  * 开始游戏
    21. 
    
    
    
  21.  */
    22. 
    
    
    
  22.  public void startGame() {
    23. 
    
    
    
  23.  initial(); // 初始化
    24. 
    
    
    
  24.  System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
    25. 
    
    
    
  25.  System.out.println("\n\t\t******************");
    26. 
    
    
    
  26.  System.out.println ("\t\t** 猜拳, 开始 **");
    27. 
    
    
    
  27.  System.out.println ("\t\t******************");
    28. 
    
    
    
  28.  
    29. 
    
    
    
  29.  System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
    30. 
    
    
    
  30.  /*选择对方角色*/
    31. 
    
    
    
  31.  System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
    32. 
    
    
    
  32.  Scanner input = new Scanner(System.in);
    33. 
    
    
    
  33.  int role = input.nextInt();
    34. 
    
    
    
  34.  if(role == 1){
    35. 
    
    
    
  35.  computer.name = "刘备";
    36. 
    
    
    
  36.  }else if(role == 2){
    37. 
    
    
    
  37.  computer.name = "孙权";
    38. 
    
    
    
  38.  }else if(role == 3){
    39. 
    
    
    
  39.  computer.name = "曹操";
    40. 
    
    
    
  40.  } 
    41. 
    
    
    
  41.  System.out.println("你选择了 "+computer.name+"对战");
    42. 
    
    
    
  42.  
    43. 
    
    
    
  43.  System.out.print("\n要开始吗？（y/n） ");
    44. 
    
    
    
  44.  String con = input.next();
    45. 
    
    
    
  45.  int perFist; //用户出的拳
    46. 
    
    
    
  46.  int compFist; //计算机出的拳
    47. 
    
    
    
  47.  while(con.equals("y")){
    48. 
    
    
    
  48.  /*出拳*/
    49. 
    
    
    
  49.  perFist = person.showFist();
    50. 
    
    
    
  50.  compFist = computer.showFist();
    51. 
    
    
    
  51.  /*裁决*/
    52. 
    
    
    
  52.  if((perFist == 1 && compFist == 1) || (perFist == 2 && compFist == 2) || (perFist == 3 && compFist == 3)){
    53. 
    
    
    
  53.  System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n"); //平局
    54. 
    
    
    
  54.  }else if((perFist == 1 && compFist == 3) || (perFist == 2 && compFist == 1) || (perFist == 3 && compFist == 2)){
    55. 
    
    
    
  55.  System.out.println("结果： 恭喜， 你赢了！"); //用户赢
    56. 
    
    
    
  56.  person.score++;
    57. 
    
    
    
  57.  }else{
    58. 
    
    
    
  58.  System.out.println("结果说:^_^,你输了，真笨!\n"); //计算机赢
    59. 
    
    
    
  59.  computer.score++;
    60. 
    
    
    
  60.  }
    61. 
    
    
    
  61.  count++;
    62. 
    
    
    
  62.  System.out.print("\n是否开始下一轮（y/n）: ");
    63. 
    
    
    
  63.  con = input.next();
    64. 
    
    
    
  64.  }
    65. 
    
    
    
  65.  /*显示结果*/
    66. 
    
    
    
  66.  showResult();
    67. 
    
    
    
  67.  }
    68. 
    
    
    
  68.  
    69. 
    
    
    
  69.  /**
    70. 
    
    
    
  70.  * 显示比赛结果
    71. 
    
    
    
  71.  */
    72. 
    
    
    
  72.  public void showResult(){
    73. 
    
    
    
  73.  /*显示最后结果*/
    74. 
    
    
    
  74.  System.out.println("---------------------------------------------------");
    75. 
    
    
    
  75.  System.out.println(computer.name + " VS " + person.name);
    76. 
    
    
    
  76.  System.out.println("对战次数："+ count);
    77. 
    
    
    
  77.  
    78. 
    
    
    
  78.  int result = calcResult();
    79. 
    
    
    
  79.  if(result == 1){
    80. 
    
    
    
  80.  System.out.println("结果：打成平手，下次再和你一分高下！");
    81. 
    
    
    
  81.  }else if(result == 2){
    82. 
    
    
    
  82.  System.out.println("结果：恭喜恭喜！"); //用户获胜
    83. 
    
    
    
  83.  }else{ 
    84. 
    
    
    
  84.  System.out.println("结果：呵呵，笨笨，下次加油啊！"); //计算机获胜
    85. 
    
    
    
  85.  }
    86. 
    
    
    
  86.  System.out.println("---------------------------------------------------");
    87. 
    
    
    
  87.  }
    88. 
    
    
    
  88.  
    89. 
    
    
    
  89.  /**
    90. 
    
    
    
  90.  * 计算比赛结果
    91. 
    
    
    
  91.  * @return 1:战平；2:用户赢；3:电脑赢
    92. 
    
    
    
  92.  */
    93. 
    
    
    
  93.  public int calcResult(){
    94. 
    
    
    
  94.  if(person.score == computer.score){
    95. 
    
    
    
  95.  return 1; // 战平
    96. 
    
    
    
  96.  }else if(person.score > computer.score){
    97. 
    
    
    
  97.  return 2; // 用户赢
    98. 
    
    
    
  98.  }else{
    99. 
    
    
    
  99.  return 3; // 电脑赢
    100. 
    
    
    
  100.  }
    101. 
    
    
    
  101.  
    102. 
    
    
    
  102.  }
    103. 
    
    
    
  103. }
    104.
  • 测试
    
    
    
    
     
     
     
  1. public class TestGame4 {
    2. 
     
     
     
    3. 
     
     
     
  3.  /**
    4. 
     
     
     
  4.  * 人机互动版猜拳游戏 
    5. 
     
     
     
  5.  */
    6. 
     
     
     
  6.  public static void main(String[] args) {
    7. 
     
     
     
  7.  Game4 game = new Game4();
    8. 
     
     
     
  8.  game.initial();
    9. 
     
     
     
  9.  game.startGame();
    10. 
     
     
     
  10.  
    11. 
     
     
     
  11.  }
    12. 
     
     
     
  12. }
    13.

7 阶段7：练习——完善游戏类的startGame()

7.1 需求说明

    输入并保存用户姓名，游戏结束后显示双方的各自得分

    

7.2 分析
7.3 代码

  • 功能扩展

   
   
   
    
    
    
    
  1. public class Game {
    2. 
    
    
    
  2.  Person person; //甲方
    3. 
    
    
    
  3.  Computer computer; //乙方
    4. 
    
    
    
  4.  int count; //对战次数
    5. 
    
    
    
  5.  
    6. 
    
    
    
  6.  /**
    7. 
    
    
    
  7.  * 初始化
    8. 
    
    
    
  8.  */
    9. 
    
    
    
  9.  public void initial(){
    10. 
    
    
    
  10.  person = new Person();
    11. 
    
    
    
  11.  computer = new Computer();
    12. 
    
    
    
  12.  count = 0;
    13. 
    
    
    
  13.  }
    14. 
    
    
    
  14.  
    15. 
    
    
    
  15.  /**
    16. 
    
    
    
  16.  * 开始游戏
    17. 
    
    
    
  17.  */
    18. 
    
    
    
  18.  public void startGame() {
    19. 
    
    
    
  19.  
    20. 
    
    
    
  20.  System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------");
    21. 
    
    
    
  21.  System.out.println("\n\t\t******************");
    22. 
    
    
    
  22.  System.out.println ("\t\t** 猜拳, 开始 **");
    23. 
    
    
    
  23.  System.out.println ("\t\t******************");
    24. 
    
    
    
  24.  
    25. 
    
    
    
  25.  System.out.println("\n出拳规则：1.剪刀 2.石头 3.布");
    26. 
    
    
    
  26.  
    27. 
    
    
    
  27.  Scanner input = new Scanner(System.in);
    28. 
    
    
    
  28.  String exit = "n"; // 退出系统
    29. 
    
    
    
  29.  
    30. 
    
    
    
  30.  do{
    31. 
    
    
    
  31.  initial(); // 初始化
    32. 
    
    
    
  32.  /*选择对方角色*/
    33. 
    
    
    
  33.  System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
    34. 
    
    
    
  34.  
    35. 
    
    
    
  35.  int role = input.nextInt();
    36. 
    
    
    
  36.  if(role == 1){
    37. 
    
    
    
  37.  computer.name = "刘备";
    38. 
    
    
    
  38.  }else if(role == 2){
    39. 
    
    
    
  39.  computer.name = "孙权";
    40. 
    
    
    
  40.  }else if(role == 3){
    41. 
    
    
    
  41.  computer.name = "曹操";
    42. 
    
    
    
  42.  } 
    43. 
    
    
    
  43.  
    44. 
    
    
    
  44.  // 扩展功能1：输入用户姓名
    45. 
    
    
    
  45.  /*输入用户姓名*/
    46. 
    
    
    
  46.  System.out.print("请输入你的姓名：");
    47. 
    
    
    
  47.  person.name = input.next();
    48. 
    
    
    
  48.  
    49. 
    
    
    
  49.  System.out.println(person.name+" VS "+computer.name+" 对战\n");
    50. 
    
    
    
  50.  // 扩展功能1结束
    51. 
    
    
    
  51.  
    52. 
    
    
    
  52.  System.out.print("要开始吗？（y/n） ");
    53. 
    
    
    
  53.  String start = input.next(); // 开始每一局游戏
    54. 
    
    
    
  54.  
    55. 
    
    
    
  55.  
    56. 
    
    
    
  56.  int perFist; //用户出的拳
    57. 
    
    
    
  57.  int compFist; //计算机出的拳
    58. 
    
    
    
  58.  
    59. 
    
    
    
  59.  while(start.equals("y")){
    60. 
    
    
    
  60.  /*出拳*/
    61. 
    
    
    
  61.  perFist = person.showFist();
    62. 
    
    
    
  62.  compFist = computer.showFist();
    63. 
    
    
    
  63.  /*裁决*/
    64. 
    
    
    
  64.  if((perFist == 1 && compFist == 1) || (perFist == 2 && compFist == 2) || (perFist == 3 && compFist == 3)){
    65. 
    
    
    
  65.  System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n"); //平局
    66. 
    
    
    
  66.  }else if((perFist == 1 && compFist == 3) || (perFist == 2 && compFist == 1) || (perFist == 3 && compFist == 2)){
    67. 
    
    
    
  67.  System.out.println("结果： 恭喜， 你赢了！"); //用户赢
    68. 
    
    
    
  68.  person.score++;
    69. 
    
    
    
  69.  }else{
    70. 
    
    
    
  70.  System.out.println("结果说:^_^,你输了，真笨!\n"); //计算机赢
    71. 
    
    
    
  71.  computer.score++;
    72. 
    
    
    
  72.  }
    73. 
    
    
    
  73.  count++;
    74. 
    
    
    
  74.  System.out.print("\n是否开始下一轮（y/n）: ");
    75. 
    
    
    
  75.  start = input.next(); 
    76. 
    
    
    
  76.  }
    77. 
    
    
    
  77.  /*显示结果*/
    78. 
    
    
    
  78.  showResult(); 
    79. 
    
    
    
  79.  
    80. 
    
    
    
  80.  // 扩展功能3：循环游戏，直到退出系统
    81. 
    
    
    
  81.  System.out.print("\n要开始下一局吗？(y/n)：");
    82. 
    
    
    
  82.  exit = input.next(); 
    83. 
    
    
    
  83.  System.out.println();
    84. 
    
    
    
  84.  // 扩展功能3结束
    85. 
    
    
    
  85.  }while(!exit.equals("n")); 
    86. 
    
    
    
  86.  
    87. 
    
    
    
  87.  System.out.println("系统退出！");
    88. 
    
    
    
  88.  }
    89. 
    
    
    
  89.  
    90. 
    
    
    
  90.  /**
    91. 
    
    
    
  91.  * 显示比赛结果
    92. 
    
    
    
  92.  */
    93. 
    
    
    
  93.  public void showResult(){
    94. 
    
    
    
  94.  /*显示对战次数*/
    95. 
    
    
    
  95.  System.out.println("---------------------------------------------------");
    96. 
    
    
    
  96.  System.out.println(computer.name + " VS " + person.name);
    97. 
    
    
    
  97.  System.out.println("对战次数："+ count);
    98. 
    
    
    
  98.  
    99. 
    
    
    
  99.  // 扩展功能2：显示最终的得分
    100. 
    
    
    
  100.  System.out.println("\n姓名\t得分"); 
    101. 
    
    
    
  101.  System.out.println(person.name+"\t"+person.score);
    102. 
    
    
    
  102.  System.out.println(computer.name+"\t"+computer.score+"\n");
    103. 
    
    
    
  103.  // 扩展功能2结束
    104. 
    
    
    
  104.  
    105. 
    
    
    
  105.  /*显示对战结果*/
    106. 
    
    
    
  106.  int result = calcResult();
    107. 
    
    
    
  107.  if(result == 1){
    108. 
    
    
    
  108.  System.out.println("结果：打成平手，下次再和你一分高下！");
    109. 
    
    
    
  109.  }else if(result == 2){
    110. 
    
    
    
  110.  System.out.println("结果：恭喜恭喜！"); //用户获胜
    111. 
    
    
    
  111.  }else{ 
    112. 
    
    
    
  112.  System.out.println("结果：呵呵，笨笨，下次加油啊！"); //计算机获胜
    113. 
    
    
    
  113.  }
    114. 
    
    
    
  114.  System.out.println("---------------------------------------------------");
    115. 
    
    
    
  115.  }
    116. 
    
    
    
  116.  
    117. 
    
    
    
  117.  /**
    118. 
    
    
    
  118.  * 计算比赛结果
    119. 
    
    
    
  119.  * @return 1:战平；2:用户赢；3:电脑赢
    120. 
    
    
    
  120.  */
    121. 
    
    
    
  121.  public int calcResult(){
    122. 
    
    
    
  122.  if(person.score == computer.score){
    123. 
    
    
    
  123.  return 1; // 战平
    124. 
    
    
    
  124.  }else if(person.score > computer.score){
    125. 
    
    
    
  125.  return 2; // 用户赢
    126. 
    
    
    
  126.  }else{
    127. 
    
    
    
  127.  return 3; // 电脑赢
    128. 
    
    
    
  128.  }
    129. 
    
    
    
  129.  
    130. 
    
    
    
  130.  }
    131. 
    
    
    
  131. }
    132.
测试 

   
   
   
    
    
    
    
  1. /**
    2. 
    
    
    
  2.  * 人机互动版猜拳游戏 
    3. 
    
    
    
  3.  * 程序入口
    4. 
    
    
    
  4.  */
    5. 
    
    
    
  5. public class StartGuess {
    6. 
    
    
    
  6.  public static void main(String[] args) {
    7. 
    
    
    
  7.  Game game = new Game();
    8. 
    
    
    
  8.  game.startGame();
    9. 
    
    
    
  9.  }
    10. 
    
    
    
  10. }
    11.

三、总结

  • 类和对象的关系是抽象和具体的关系
  • 使用类的步骤如下
    • （1）定义类：使用关键字class。
    • （2）创建类的对象：使用关键字new。
    • （3）使用类的属性和方法：使用“.”操作符。
  • 定义类的方法包括三个部分
    • （1）方法的名称 
    • （2）方法返回值的类型 
    • （3）方法的主体
  • 类的方法调用，使用如下两种形式。
    • （1）同一个类中的方法，直接使用方法名
    • （2）不同类的方法，先创建对象，再使用“对象名.方法名”
  • 在Java中，有成员变量和局部变量，它们的作用域各不相同

关注我们


捐赠我们
    良师益友工作室一直在致力于帮助编程爱好更加快速方便地学习编程，如果您对我们的成果表示认同并且觉得对你有所帮助，欢迎您对我们捐赠^_^。

    







免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。



猜您在找 人机交互，来和我猜拳吧！ 【WPF学习】第十三章 理解路由事件 Java 实现简单的人机猜拳游戏 人机猜拳（这是最近的一个总结） 【WPF学习】第三十三章 高级命令 【WPF学习】第五十三章 动画类型回顾 增强学习笔记 第十三章 策略梯度方法 第十三章 springboot + lombok JAVA基础代码分享--模拟人机猜拳系统 python学习-6 猜拳小游戏
 
粤ICP备18138465号  © 2018-2025 CODEPRJ.COM