一个面向对象的打字游戏“QuickHit”程序（附源码）

目录

1. QuickHit项目描述

2. 功能模块

2.1 游戏输出字符串

2.2 确认输入并输出结果

2.3 玩家玩游戏

3. 技术

4. 源码

---

1. QuickHit项目描述

QuickHit游戏考验玩家从键盘输入内容的准确率和速度。

根据输入速率和正确率将关卡设置成6个级别，玩家从一级开始，根据输入内容的准确性和速度逐级升级，级别越高，一次显示（要求输入的内容）也就越多，每关要求的规定时间也有所变动，即逐级每关更难，相应的每关的积分也更多。如果玩家在规定时间内完成规定次数输出，且正确率达标（这里只要输错便退出）则晋级。

2. 功能模块

​​​​​​​2.1 游戏输出字符串

主要步骤是生成固定但内容随机的字符串，同时向控制台输出生成的字符串并返回此字符串（必须返回，用于和玩家输入比较）。

实现步骤可以设计为以下几步：
（1）生成字符串。
（2）输出字符串。
（3）返回字符串（必须返回，用于和玩家的输入进行比较）。

2.2 确认输入并输出结果

根据玩家输入是否如正确输出不同结果。当输入正确并且未超时，要输出玩家的当前级别、当前积分和已用时间。如何计算玩家的当前级别、当前积分和已用时间是关键。

实现步骤可以设计为以下几步：

（1）确认玩家的输入是否正确。

（2）如果输入不正确，则直接输出错误信息并退出程序。

（3）如果输入正确，则会有以下两种情况。

a：如果超时，则直接输出玩家超时信息并退出程序。

b：如果没有超时，则执行以下操作：

计算玩家当前积分。

计算玩家已用时间。

输出玩家当前级别、当前积分和已用时间。

判断用户是否已经闯过最后一关并处理。

2.3 玩家玩游戏

游戏的6个级别可以通过循环实现，而每个级别中的多次字符串输出通过内部子循环实现，该控制功能放在Player类的play（）方法中，每次玩家晋级后积分清零、计时清零。

实现步骤可以设计为以下几步：

（1）创建Game对象并传入player属性。

（2）外层循环（循环次数是6，每循环一次，玩家提升一级）。

a：晋级。

b：积分清零，计时清零。

c：内层循环（循环次数是该级别的strTime，每循环一次完成一次人机交互）。

游戏输出字符串。

玩家输入字符串。

判断玩家输入的字符串并输出相应结果。

3. 技术

用static静态代码块来设置配置各个级别的参数，用level类去创建一个关卡对象，存储每一关相应的关卡设置，创建一个play对象代表当前玩家状态，其中包括属性有当前级别号，当前积分，当前级别开始时间，当前级别已用时间，前面所有通过关卡获得的积分总和，游戏开始时会进入play（）方法的循环中，循环次数是static代码块中的数组长度，每关开始时清空计时和积分，更新关卡号和积分总和。

play对象和level对象配合play对象中的levelNo属性相关联。

每关中首先打印输出字符串，使用Random对象去让每次每个输出的字符随机产生，然后通过StringBuffer对象将这些字符连接起来，然后输出在控制台，并使用其toString方法返回字符串与输入的字符串进行对比。对比用if-else判断输入字符串与输出字符串是否匹配，不匹配则显示当前总得分然后退出，匹配还要判断当前关卡所用时间是否超时（获取当前系统时间以微秒为单位的方法是 System.currentTimeMillis()）超时则显示当前总得分然后退出，如果没超时则最后判断是否通关，通过则结束，否则进入下一个字符串的输出。

4. 源码

level类存放每一个级别对应的关卡所具有的属性

package QuickHi;

public class Level {
    private int level;//级别号
    private int strLength;//输出字符串长度【各级别不同】
    private int time;//输出字符串的频率或者次数
    private int timeLimit;//各级别所需时间变量
    private int perScore;//各级别输出字符串之后增加的分数变量

    public Level(){ }

    public Level(int level, int strLength, int time, int timeLimit, int perScore) {
        this.level = level;
        this.strLength = strLength;
        this.time = time;
        this.timeLimit = timeLimit;
        this.perScore = perScore;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public int getStrLength() {
        return strLength;
    }

    public void setStrLength(int strLength) {
        this.strLength = strLength;
    }

    public int getTime() {
        return time;
    }

    public void setTime(int time) {
        this.time = time;
    }

    public int getTimeLimit() {
        return timeLimit;
    }

    public void setTimeLimit(int timeLimit) {
        this.timeLimit = timeLimit;
    }

    public int getPerScore() {
        return perScore;
    }

    public void setPerScore(int perScore) {
        this.perScore = perScore;
    }
}

LevelParam类存放静态的每关对应的具体属性，都是常量 ，游戏的相关难易都只在这里设置

package QuickHi;

public class LevelParam {
    //定义常量  --》制定6个关卡中每个关卡的游戏规则
    public static final Level levels[] = new Level[6];
    //static{ }代表静态，作用：类加载的时候只加载一次，独一份
    static {
        levels[0] = new Level(1, 2, 5, 30, 2);
        levels[1] = new Level(2, 3, 5, 30, 3);
        levels[2] = new Level(3, 4, 5, 30, 4);
        levels[3] = new Level(4, 5, 5, 30, 5);
        levels[4] = new Level(5, 6, 5, 30, 6);
        levels[5] = new Level(6, 7, 5, 30, 7);
    }
}

Game 类存放着整个游戏的逻辑流程，主要包括打印出每关对应的字符在控制台，和每次输入与输出的对比以及对比后相应的处理判断

package QuickHi;

//游戏类

import java.util.Random;

public class Game {
    private Player player;

    public Game(){}

    public Game(Player player){
        this.player = player;
    }

    /*
    * 1、游戏输出字符串
    * */

    public String printStr(){
        //获取用户当前级别号对应的字符串长度【角标从0开始，所有减1】
        int strLength = LevelParam.levels[player.getLevelNo()-1].getStrLength();
        //创建一个可以编辑的字符串对象StringBuffer【String对象是不可编辑的字符串对象】
        StringBuffer buffer = new StringBuffer();
        //创建一个随机对象
        Random random = new Random();
        //循环输出要输出的字符串
        for (int i = 0 ; i < strLength ; i++){
            //产生随机数
            int rand = random.nextInt(strLength);

            //拼接字符串
            switch (rand){
                case 0: buffer.append("<"); break;
                case 1: buffer.append(">"); break;
                case 2: buffer.append("*"); break;
                case 3: buffer.append("&"); break;
                case 4: buffer.append("^"); break;
                case 5: buffer.append("!"); break;
                case 6: buffer.append("%"); break;
            }
        }
        //输出字符串
        System.out.println(buffer);
        //将StringBuffer类型的变量转变为String类型的对象--》toString()
        String ss = buffer.toString();
        return ss;
    }

    /*
    * 2.游戏比对方式【输出的和输入的进行】
    * */
    public void printResult(String out,String in){
        boolean flag;
        //比对输出的字符串和输入的字符串
        if (out.equals(in)){
            flag = true;
        }else {
            flag = false;
        }
        //1、如果输入正确的话
        if (flag){
            //获取当前时间
            long currentTime = System.currentTimeMillis();
//            (currentTime - player.getStartTime())/1000    当前时间 - 起始时间 = 共使用时间
//            LevelParam.levels[player.getLevelNo()-1].getTimeLimit()   当前（某个用户通过）该关卡所需时间

            if ((currentTime - player.getStartTime())/1000 > LevelParam.levels[player.getLevelNo()-1].getTimeLimit()){
                //1、如果超时，则显示超时，并退出jvm虚拟机
                System.out.println("超时，您输入的太慢了！退出");
                System.exit(1);
            }else {
                //2、如果没有超时
                //2、1计算分数
                player.setOurScore(player.getOurScore()+LevelParam.levels[player.getLevelNo()-1].getPerScore());

                //2、2计算时间
                player.setElapsedTime((int)(currentTime - player.getStartTime())/1000);

                //2、3输出积分，级别，时间
                System.out.println("输入正确，您的级别是"+player.getLevelNo()+"  您的积分："+player.getOurScore()+",已用时间："+player.getElapsedTime()+"秒");

                //2、4判断用户是否已经闯过最后一关
                if (player.getLevelNo() == 6){
                    int score = LevelParam.levels[player.getLevelNo()-1].getPerScore()*LevelParam.levels[player.getLevelNo()-1].getTime();

                    //如果玩家达到最高分
                    if(player.getOurScore() == score){
                        System.out.println("你当前获得的总积分为："+(player.getOurScore()+player.getSumScore()));
                        System.out.println("你已经闯关成功，恭喜");
                        System.exit(0);
                    }
                }
            }
        }else {
            System.out.println("你当前获得的总积分为："+(player.getOurScore()+player.getSumScore()));
            System.out.println("输出错误，退出");
            System.exit(0);
        }
    }

    public Player getPlayer() {
        return player;
    }

    public void setPlayer(Player player) {
        this.player = player;
    }
}

Player类存放玩家相关信息

package QuickHi;

import java.util.Scanner;

public class Player {
    private int levelNo;//级别号
    private int ourScore;//当前积分
    private long startTime;//各级别开始时间
    private long elapsedTime;//各级别已用时间
    private int sumScore;//游戏结束时总共获得的积分

    /*
    * 玩家玩游戏
    * */
    public void play(){
        Game game = new Game(this);
        Scanner scanner = new Scanner(System.in);
        for (int i = 0 ; i < LevelParam.levels.length ; i++){
            //1.晋级
            this.levelNo += 1;
            //2.计时清零
            this.startTime = System.currentTimeMillis();
            //3.积分清零
            this.ourScore = 0;
            //4.以上关卡获得的总积分
            this.sumScore = 0;
            for (int j = 0 ; j < levelNo-1 ; j++){
                this.sumScore += LevelParam.levels[j].getPerScore()*LevelParam.levels[j].getTime();
            }


            for (int j = 0 ; j < LevelParam.levels[levelNo-1].getTime() ; j++){
                //输出字符串
                String outStr = game.printStr();
                //输入字符串
                String inStr = scanner.next();

                game.printResult(outStr, inStr);
            }
        }
    }

    public Player() {
    }

    public Player(int levelNo, int ourScore, long startTime, long elapsedTime) {
        this.levelNo = levelNo;
        this.ourScore = ourScore;
        this.startTime = startTime;
        this.elapsedTime = elapsedTime;
    }

    public int getLevelNo() {
        return levelNo;
    }

    public void setLevelNo(int levelNo) {
        this.levelNo = levelNo;
    }

    public int getOurScore() {
        return ourScore;
    }

    public void setOurScore(int ourScore) {
        this.ourScore = ourScore;
    }

    public long getStartTime() {
        return startTime;
    }

    public void setStartTime(long startTime) {
        this.startTime = startTime;
    }

    public long getElapsedTime() {
        return elapsedTime;
    }

    public void setElapsedTime(long elapsedTime) {
        this.elapsedTime = elapsedTime;
    }

    public int getSumScore() {
        return sumScore;
    }

    public void setSumScore(int sumScore) {
        this.sumScore = sumScore;
    }
}

测试类，运行此类来运行整个程序

package QuickHi;

public class Test {
    public static void main(String[] args) {
        Player player = new Player();
        player.play();
    }
}