Java面向对象总复习-QuickHit

 1 package com.bdqn;
 2 /**
 3  * 1.玩家级别类
 4  * @author pc
 5  *
 6  */
 7 public class Level {
 8     /**
 9      * 级别号
10      */
11     private int levelNo;
12     /**
13      * 各级别一次输出字符串的长度
14      */
15     private int strLength;
16     /**
17      * 各级别输出字符串的次数
18      */
19     private int strTime;
20     /**
21      * 各级别闯关的时间限制
22      */
23     private int timeLimit;
24     /**
25      * 各级别成功输入一次的得分
26      */
27     private int perScore;
28     
29     public Level() {
30     }
31     /**
32      * 有参数构造赋值
33      * @param levelNo 级别号
34      * @param strLength 各级别一次输出字符串的长度
35      * @param strTime 各级别输出字符串的次数
36      * @param timeLimit 各级别闯关的时间限制
37      * @param perScore 各级别成功输入一次的得分
38      */
39     public Level(int levelNo, int strLength, int strTime, int timeLimit,
40             int perScore) {
41         this.levelNo = levelNo;
42         this.strLength = strLength;
43         this.strTime = strTime;
44         this.timeLimit = timeLimit;
45         this.perScore = perScore;
46     }
47     public int getLevelNo() {
48         return levelNo;
49     }
50     public void setLevelNo(int levelNo) {
51         this.levelNo = levelNo;
52     }
53     public int getStrLength() {
54         return strLength;
55     }
56     public void setStrLength(int strLength) {
57         this.strLength = strLength;
58     }
59     public int getStrTime() {
60         return strTime;
61     }
62     public void setStrTime(int strTime) {
63         this.strTime = strTime;
64     }
65     public int getTimeLimit() {
66         return timeLimit;
67     }
68     public void setTimeLimit(int timeLimit) {
69         this.timeLimit = timeLimit;
70     }
71     public int getPerScore() {
72         return perScore;
73     }
74     public void setPerScore(int perScore) {
75         this.perScore = perScore;
76     }
77     
78 
79 }

 1 package com.bdqn;
 2 /**
 3  * 2.游戏级别参数设置
 4  */
 5 public class LevelParam {
 6      //规定游戏级别为6级
 7     public final static Level[] levels=new Level[6];
 8     
 9     //设置各个级别的游戏参数值
10     static{
11         levels[0]=new Level(1, 2, 10, 30, 1);
12         levels[1]=new Level(2, 3, 9, 26, 2);
13         levels[2]=new Level(3, 4, 8, 22, 5);
14         levels[3]=new Level(4, 5, 7, 18, 8);
15         levels[4]=new Level(5, 6, 6, 14, 10);
16         levels[5]=new Level(6, 7, 5, 10, 15);
17     }
18 
19 }

 1 package com.bdqn;
 2 
 3 import java.util.Scanner;
 4 
 5 /**
 6  * 3.玩家类
 7  * @author pc
 8  *
 9  */
10 public class Player {
11     /**
12      * 玩家的级别号
13      */
14     private int levelNo; 
15     /**
16      * 当前积分
17      */
18     private int curScore;
19     /**
20      * 各级别的开始时间
21      */
22     private long startTime=0;
23     /**
24      * 各级别已用时间
25      */
26     private int elapsedTime;
27     public int getLevelNo() {
28         return levelNo;
29     }
30     public void setLevelNo(int levelNo) {
31         this.levelNo = levelNo;
32     }
33     public int getCurScore() {
34         return curScore;
35     }
36     public void setCurScore(int curScore) {
37         this.curScore = curScore;
38     }
39     public long getStartTime() {
40         return startTime;
41     }
42     public void setStartTime(long startTime) {
43         this.startTime = startTime;
44     }
45     public int getElapsedTime() {
46         return elapsedTime;
47     }
48     public void setElapsedTime(int elapsedTime) {
49         this.elapsedTime = elapsedTime;
50     }
51     /**
52      * 玩家玩游戏
53      */
54     public void play(){
55         /**
56          * 玩家玩游戏
57          * this: 本类对象的
58          */
59         Game game=new Game(this);
60         /**
61          * 外层循环一次，内层循环一周
62          * 外层：关数=级别
63          * 内层：每关的里的局数
64          * 循环一次晋级一次，一次通关成功
65          */
66         for (int i = 0; i < LevelParam.levels.length; i++) {
67             //1.玩家记录游戏级别，晋级
68             this.levelNo+=1;
69             
70             //2.晋级后计时清零，积分清零
71             //开始时间=当前系统时间
72             this.startTime=System.currentTimeMillis();
73             this.curScore=0;
74             
75             //3.内层循环，循环一次完成一次字符串的输出、输入，比较
76             for (int j = 0; j < LevelParam.levels[levelNo-1].getStrTime(); j++) {
77                 //3.1 游戏输出字符串
78                 String outStr=game.printStr();
79                 
80                 //3.2 接受用户控制台输入
81                 Scanner input=new Scanner(System.in);
82                 String inStr=input.next();
83                 
84                 //3.3 游戏判断玩家输入是否正确，并输出相应结果
85                 game.printResult(outStr,inStr);
86             }
87             
88         }
89     }
90 }

  1 package com.bdqn;
  2 
  3 import java.util.Random;
  4 
  5 
  6 
  7 public class Game {
  8     /**
  9      *1. 引入玩家类
 10      */
 11     private Player player;
 12      
 13     /**
 14      * 2.游戏被玩家玩
 15      * @param player
 16      */
 17     public Game(Player player) {
 18         this.player=player;
 19     }
 20     /**
 21      * 3.游戏随机输出字符串
 22      * @return 输出的字符串，用于和玩家输入的比较
 23      */
 24     public String printStr() {
 25         //1.获取一次输出的字符串的长度
 26         int strLength=LevelParam.levels[player.getLevelNo()-1].getStrLength();
 27         //2.定义动态拼接字符串的对象
 28         StringBuffer sbf=new StringBuffer();
 29         //3.创建生成随机数的对象
 30         Random random=new Random();
 31         //4.循环拼接生成要输出的字符串
 32         for (int i = 0; i < strLength; i++) {
 33             //4.1 产生随机数
 34             int rand=random.nextInt(strLength);
 35             //4.2 根据随机数拼接字符串
 36             switch (rand) {
 37             case 0:
 38                   sbf.append(">");
 39                 break;
 40             case 1:
 41                  sbf.append("<");
 42                 break;
 43             case 2:
 44                  sbf.append("*");
 45                 break;
 46             case 3:
 47                 sbf.append("&");
 48                 break;
 49             case 4:
 50                 sbf.append("%");
 51                 break;
 52             case 5:
 53                 sbf.append("#");
 54                 break;
 55             }
 56         }
 57         //5.输出字符串
 58         System.out.println(sbf.toString());
 59         
 60         //6.返回字符串用于和玩家输入做对比
 61         return sbf.toString();
 62     }
 63     /**
 64      * 4.游戏判断玩家输入是否正确，并输出相应结果
 65      * @param outStr 游戏打印的输出字符串
 66      * @param inStr  玩家输入的字符串
 67      */
 68     public void printResult(String outStr, String inStr) {
 69         //1.输入正确
 70         if(outStr.equals(inStr)){ 
 71              //1.1 获取当前系统时间(毫秒为单位)
 72             long currentTime=System.currentTimeMillis();
 73             //1.2游戏时间=当前时间-开始时间（秒）
 74             long palytime=(currentTime-player.getStartTime())/1000;
 75             //1.3游戏规定的时间限制
 76             long limitTime=LevelParam.levels[player.getLevelNo()-1].getTimeLimit();
 77             //1.4判断游戏是否超时 
 78             if(palytime>limitTime){
 79                 //1.4.1 超时
 80                   System.out.println("你输入太慢，已经超时，退出！！");
 81                   System.exit(1);
 82               }else{ 
 83                   //1.4.2 没有超时
 84                   //1.4.2.1 计算当前积分=原来积分+当前等级游戏积分
 85                   //原来积分
 86                   int currentScore=player.getCurScore();
 87                   //当前等级成功输入一次的游戏积分
 88                   int playPerScore=LevelParam.levels[player.getLevelNo()-1].getPerScore();
 89                   //玩完当局之后设置当前的积分
 90                   player.setCurScore(currentScore+playPerScore);
 91                   //1.4.2.2 计算已用时间
 92                   player.setElapsedTime((int)palytime);
 93                   //1.4.2.3 输出当前积分，当前级别，已用时间
 94                   System.out.println("输入正确，您的级别"
 95                           +player.getLevelNo()
 96                           +",您的积分"+player.getCurScore()
 97                           +",已用时间"+player.getElapsedTime());
 98                   //1.4.2.4 判断用户是否已经闯过最后一关
 99                   if(player.getLevelNo()==LevelParam.levels.length){
100                       //计算闯关分数
101                       //当前局成功一次的积分
102                       int perScore=LevelParam.levels[player.getLevelNo()-1].getPerScore();
103                       //获取当前关的局数
104                       int perNum=LevelParam.levels[player.getLevelNo()-1].getStrTime();
105                       //计算每关的总积分
106                       int score=perScore*perNum;
107                       //判断是否最后通关
108                       if(player.getCurScore()==score){
109                           System.out.println("恭喜你已经通关成功，成为绝世高手！");
110                           System.exit(0);
111                       }
112                       
113                   }
114               }
115         }else{ 
116          //2.输入不正确
117             System.out.println("输入错误，退出！");
118             System.exit(0);
119         }
120     }
121     
122     public Player getPlayer() {
123         return player;
124     }
125     public void setPlayer(Player player) {
126         this.player = player;
127     }
128 
129 }

 1 package com.bdqn;
 2 
 3 public class Test {
 4 
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9       Player player=new Player();
10       player.play();
11 
12     }
13 
14 }