人机猜拳

一、难点突破

1 知识梳理

 

二、综合练习

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

1.1 需求说明

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

• 创建用户类

    

1.2 分析

1.3 代码

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

1. /**

1. *

1. * @author wangshaohua

1. *

1. */

1. public class Person {

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

1. int score = 0; // 积分

1. /**

1. * 出拳

1. *

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

1. */

1. public int showFist() {

1. // 接收用户的选择

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

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

1. int show = input.nextInt();

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

1. switch (show) {

1. case 1:

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

1. break;

1. case 2:

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

1. break;

1. case 3:

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

1. break;

1. }

1. return show;

1. }

1. }

• 测试用户出拳

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

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

    2.1 需求说明

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

    2.2 分析

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

    2.3 代码

     

    • 计算机类

     

     

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

    • 测试计算机类

     

     

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

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

     

    3.1 需求说明

     

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

       

          

      3.2 分析

      3.3 代码

      • 游戏类

       

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

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

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

                  

       

      4.2 分析
      4.3 代码

      • 实现一局对战

       

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

       

       

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

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

       

      5.1 需求说明

       

          实现循环对战，

      并且累加赢家的得分

       

       

          
      

       

      5.2 分析
      5.3 代码

       

      • 实现循环对战/**
        • * 游戏类
        • * 阶段5：实现循环对战
        • *
        • */
        • public class Game3 {
        • Person person; //甲方
        • Computer computer; //乙方
        • int count; //对战次数
        • /**
        • * 初始化
        • */
        • public void initial(){
        • person = new Person();
        • computer = new Computer();
        • count = 0;
        • }
        • /**
        • * 开始游戏
        • */
        • public void startGame() {
        • initial(); // 初始化
        • System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
        • System.out.println("\n\t\t******************");
        • System.out.println ("\t\t** 猜拳, 开始 **");
        • System.out.println ("\t\t******************");
        • System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
        • /*选择对方角色*/
        • System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
        • Scanner input = new Scanner(System.in);
        • int role = input.nextInt();
        • if(role == 1){
        • computer.name = "刘备";
        • }else if(role == 2){
        • computer.name = "孙权";
        • }else if(role == 3){
        • computer.name = "曹操";
        • }
        • System.out.println("你选择了 "+computer.name+"对战");
        • /*开始游戏*/
        • System.out.print("\n要开始吗？（y/n） ");
        • String con = input.next();
        • int perFist; //用户出的拳
        • int compFist; //计算机出的拳
        • while(con.equals("y")){
        • /*出拳*/
        • perFist = person.showFist();
        • compFist = computer.showFist();
        • /*裁决*/
        • if((perFist == 1 && compFist == 1) || (perFist == 2 && compFist == 2) || (perFist == 3 && compFist == 3)){
        • System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n"); //平局
        • }else if((perFist == 1 && compFist == 3) || (perFist == 2 && compFist == 1) || (perFist == 3 && compFist == 2)){
        • System.out.println("结果： 恭喜， 你赢了！"); //用户赢
        • person.score++;
        • }else{
        • System.out.println("结果说:^_^,你输了，真笨!\n"); //计算机赢
        • computer.score++;
        • }
        • count++;
        • System.out.print("\n是否开始下一轮（y/n）: ");
        • con = input.next();
        • }
        • }
        • }
        • 测试循环对战

         

         

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

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

         

        6.1 需求说明

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

                

        6.2 分析

         

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

         

        6.3 代码

         

        • 实现对战结果显示/**
          • * 游戏类
          • * 阶段6：实现对战结果显示
          • */
          • public class Game4 {
          • Person person; //甲方
          • Computer computer; //乙方
          • int count; //对战次数
          • /**
          • * 初始化
          • */
          • public void initial(){
          • person = new Person();
          • computer = new Computer();
          • count = 0;
          • }
          • /**
          • * 开始游戏
          • */
          • public void startGame() {
          • initial(); // 初始化
          • System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
          • System.out.println("\n\t\t******************");
          • System.out.println ("\t\t** 猜拳, 开始 **");
          • System.out.println ("\t\t******************");
          • System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
          • /*选择对方角色*/
          • System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
          • Scanner input = new Scanner(System.in);
          • int role = input.nextInt();
          • if(role == 1){
          • computer.name = "刘备";
          • }else if(role == 2){
          • computer.name = "孙权";
          • }else if(role == 3){
          • computer.name = "曹操";
          • }
          • System.out.println("你选择了 "+computer.name+"对战");
          • System.out.print("\n要开始吗？（y/n） ");
          • String con = input.next();
          • int perFist; //用户出的拳
          • int compFist; //计算机出的拳
          • while(con.equals("y")){
          • /*出拳*/
          • perFist = person.showFist();
          • compFist = computer.showFist();
          • /*裁决*/
          • if((perFist == 1 && compFist == 1) || (perFist == 2 && compFist == 2) || (perFist == 3 && compFist == 3)){
          • System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n"); //平局
          • }else if((perFist == 1 && compFist == 3) || (perFist == 2 && compFist == 1) || (perFist == 3 && compFist == 2)){
          • System.out.println("结果： 恭喜， 你赢了！"); //用户赢
          • person.score++;
          • }else{
          • System.out.println("结果说:^_^,你输了，真笨!\n"); //计算机赢
          • computer.score++;
          • }
          • count++;
          • System.out.print("\n是否开始下一轮（y/n）: ");
          • con = input.next();
          • }
          • /*显示结果*/
          • showResult();
          • }
          • /**
          • * 显示比赛结果
          • */
          • public void showResult(){
          • /*显示最后结果*/
          • System.out.println("---------------------------------------------------");
          • System.out.println(computer.name + " VS " + person.name);
          • System.out.println("对战次数："+ count);
          • int result = calcResult();
          • if(result == 1){
          • System.out.println("结果：打成平手，下次再和你一分高下！");
          • }else if(result == 2){
          • System.out.println("结果：恭喜恭喜！"); //用户获胜
          • }else{
          • System.out.println("结果：呵呵，笨笨，下次加油啊！"); //计算机获胜
          • }
          • System.out.println("---------------------------------------------------");
          • }
          • /**
          • * 计算比赛结果
          • * @return 1:战平；2:用户赢；3:电脑赢
          • */
          • public int calcResult(){
          • if(person.score == computer.score){
          • return 1; // 战平
          • }else if(person.score > computer.score){
          • return 2; // 用户赢
          • }else{
          • return 3; // 电脑赢
          • }
          • }
          • }
          • 测试
          1. public class TestGame4 {
          3. /**
          4. * 人机互动版猜拳游戏
          5. */
          6. public static void main(String[] args) {
          7. Game4 game = new Game4();
          8. game.initial();
          9. game.startGame();
          11. }
          12. }

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

           

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

              

          7.2 分析
          7.3 代码

           

          • 功能扩展

           

           

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

           

           

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

转载于:https://www.cnblogs.com/li654321/p/11466077.html