面向对象——必敲项目（简化版qq炫舞）

一、项目需求：

（1）QuickHit游戏考验学员键盘输入内容的速度和准确性。
（2）根据输入速率和正确性将玩家分为不同级别，级别越高，一次显示的字符数越多，玩家正确输入一次的得分也越高。
（3）如果玩家在规定的时间内完成规定次数的输入，正确率达到规定要求，则玩家升级（为了简单起见，规定用户只要输入错误一次，则游戏结束）
（4）玩家最高级别为6级，初始级别一律为一级。

二、本项目覆盖的技能知识点

（1）面向对象程序设计的思想
（2）使用类图理解类的关系
（3）类的封装
（4）构造方法的使用
（5）this和static关键字的使用

重点：理解如何在一个类中定义另一个类的对象，和调用该对象的属性，方法；锻炼编程思维，锻炼抽象思维

三、难点分析

(1) 第一步，从需求分析，我们需要的几个类，一个玩家，一个游戏，还有一个等级，玩家，玩游戏需要游戏，游戏需要玩家去玩，所以他们两个是谁也离不开谁，互相需要

(2)第二步，有了类，需要去定义类的属性，

玩家（Plyer）类的属性： 

            玩家当前级别号（levelNo）

            玩家当前级别积分（currScore）

            当前级别开始时间（startTime）

            当前级别已用时间（elapsedTime）

级别（Level）类的属性：

            各级别编号（levelNo）

            各级别一次输出字符串的长度（strLength）

            各级别输出字符串的次数（strTime）

            各级别闯关的时间限制（timeLimit）

            各级别正确输入一次的得分（perScore）

相应类图如下所示：
   ------------------       -------------        ----------------
   |     Plyer   |          |  Game   |          |  Level     |
   ------------------       -------------        ----------------
   |-levelNo:int   |        |        |           |-levelNo:int  |
   |-currScore:int  |       -------------        |-strLength:int|
   |-startTime:long |       |        |           |-strTime:int  |
   |-elapsedTime:int|       -------------        |-timeLimit:int|
   ------------------                            |-perScore:int |
                    

(3)发现类的方法：

  经过分析，游戏类的主要方法有3个：输出字符串、确认玩家输入是否正确和输出相应结果息。   其中，第2个方法很简单，可以和第3个方法合并。 而玩家的方法只有一个，即玩游戏（根据游戏   的输出类输入相同字符串）。 级别类主要存放信息，没有具体操作。

进行整理并命名，得到如下结果。

玩家类的方法： 玩游戏play()。

游戏类的方法： String playgame()，输出字符串，返回字符串用于和玩家的输入进行比较；

                          void result(String s,String s1)，比较游戏输出s和玩家输入s1，根据比较结果输出相应信息。

(4)优化程序

     在游戏类的方法中，输出相应结果时肯定会涉及玩家类的信息，如当前级别编号、当前级别积分、当前级别已用时间等， 可以通过把Player对象作为游戏类的属性，轻松解决该问题。 级别类不包含各个级别的具体参数信息，可以增加LevelParam类，在该类中创建一个长度为6的Level数组，存放各个级别的具体参数信息， 并使用public final static修饰该数组，可以直接通过类名来访问，却无法修改其值。

四、项目实现思路

（1）游戏根据玩家的级别在控制台输出指定数量的字符。
（2）玩家根据控制台的输出来输入相同字符，按Enter键确认。
（3）游戏确认玩家输入是否正确。
（4）如果输入错误，则输出玩家输入错误提示信息，游戏非正常结束。
（5）如果输入正确但超时，则输出玩家速度太慢提示信息，游戏非正常结束。
（6）如果输入正确且没有超时，则输出玩家的积分、级别和用时信息。然后重复以上步骤，继续输出、输入和确认。
（7）玩家在规定时间内连续正确输入规定次数后，将显示玩家升级提示，游戏将重新计时计分，将一次输出更多字符。6级玩家闯关成功，输出恭喜信息，游戏正常结束。

1、 游戏输出字符串
   实现步骤可以设计为以下几步。
   （1）生成字符串。
   （2）输出字符串。
   （3）返回字符串（必须返回，用于玩家和输入进行比较）。
   这其中的关键是第一步的实现，字符串的长度是多少？如何生成长度固定当内容随机的字符串？
2、 确认输出的字符并输出结果
   实现步骤可以设计为以下几步。
   （1）确认玩家的输入是否正确。
   （2）如果输入不正确，则直接输出错误信息并退出程序。
   （3）如果输入正确，则会有以下两种情况。
      1）如果超时，则直接输出玩家超时信息并退出程序。
      2）如果没有超时，则执行以下操作。
         a）计算玩家当前积分。
         b）计算玩家已用时间。
         c）输出玩家当前级别、当前积分和已用时间。
         d）判断用户是否已经闯过最后一关并处理。
3、 玩家玩游戏
   实现步骤可以设计为以下几步。
   （1）创建Game对象并传入player属性。
   （2）外层循环（循环次数是6，每循环一次，玩家提升一级）。
      1）晋级。
      2）积分清零，计时清零。
      3）内层循环（循环次数是该级别的strTime，每循环一次完成一次人家交互）。
         a）游戏输出字符串。
         b）玩家输入字符串。
         c）判断玩家输入的字符并输出相应结果。
4、 初始化各个级别的具体参数
   各个级别的具体参数信息，如各级别编号、各级别一次输出字符串的长度、各级别输出字符串的次数、各级别闯关的时间限制和各级别正确输入一次的得分，应该在游戏开始之前进行初始化。
   

代码如下：

1.玩家类

package QuickHit;

import java.nio.Buffer;
import java.util.Scanner;

/**
 * 玩家当前级别号（levelNo）
 * 玩家当前级别积分（currScore）
 *当前级别开始时间（startTime）
 *当前级别已用时间（elapsedTime）
 * @lihuilong
 */
public class Player {
    private int levelNo;//玩家级别号
    private int currScore;//玩家积分
    private int startTime;//玩家开始时间
    private int elapsedTime;//玩家所用时间

    public int getLevelNo() {
        return levelNo;
    }

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

    public int getCurrScore() {
        return currScore;
    }

    public void setCurrScore(int currScore) {
        this.currScore = currScore;
    }

    public int getStartTime() {
        return startTime;
    }

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

    public int getElapsedTime() {
        return elapsedTime;
    }

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

    public Player() {
        this.levelNo = levelNo;
        this.currScore = currScore;
        this.startTime = startTime;
        this.elapsedTime = elapsedTime;
    }
    public void play(){
        //声明一个游戏类，当掉用玩家时，调用这个游戏
        Game game = new Game(this);
        Scanner sc = new Scanner(System.in);
        //循环玩家等级
        for (int i = 0; i < levelparam.lp.length; i++) {
            levelNo+=1;//初始化玩家等级为1
            currScore=0;//将每一级开始，初始化分数为0
            System.out.println("---------------");
            System.out.println("当前等级为:"+(i+1)+"级");
            //循环每一级得次数
            for (int j = 0; j < levelparam.lp[levelNo-1].getStrTime(); j++) {
                //调用游戏方法，返回一个字符串
                String playgame = game.playgame();
                //计算游戏开始时间
                startTime=(int) System.currentTimeMillis();
                //键盘输入
                String next = sc.next();
                //将键盘输入得值和系统中得值做比较
                game.result(playgame,next);
            }


        }




        }
    }

2.游戏类

package QuickHit;
/**
 * 这里采用StringBuffer类，调用他的append方法，自动连接字符串，不需要重新造一个栈空间
 * @lihuilong
 */

import java.util.Random;

public class Game {
    private Player player;

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

    public String playgame(){
        //定义一个随机Random函数
        Random random = new Random();
        //取出玩家该等级得一次输入得长度数量
        int strlength = levelparam.lp[player.getLevelNo()-1].getStrlength();
        //定义一个存放字符得buffer
        StringBuffer buffer = new StringBuffer();
        //循环输出，得出字符得长度
        for (int j = 0; j < strlength; j++) {
            int i = random.nextInt(strlength);
            switch(i){
                case 0:
                    System.out.print("<");
                    buffer.append("<");
                    break;
                case 1:
                    System.out.print(">");
                    buffer.append(">");
                    break;
                case 2:
                    System.out.print("?");
                    buffer.append("?");
                    break;
                case 3:
                    System.out.print(",");
                    buffer.append(",");
                    break;
                case 4:
                    System.out.print("*");
                    buffer.append("*");
                    break;
                case 5:
                    System.out.print("/");
                    buffer.append("/");
                    break;
                case 6:
                    System.out.print("+");
                    buffer.append("+");
                    break;

            }

        }
           //返回字符串
        return buffer.toString();


    }
    //定义一个判断输入和输出得内容是否一致
    public void result(String s ,String s1){//传进去两个字符串做对比
        //定义一个结束得时间为当前时间
        long time= (int) System.currentTimeMillis();
        //得到总共用时赋值给玩家
        player.setElapsedTime((int) (time-player.getStartTime())/1000);
       if (s.equals(s1)){
           //比较如果玩家花费得时间大于系统规定得时间，则输出超时，并关闭程序
           if (player.getElapsedTime()>levelparam.lp[player.getLevelNo()-1].getTimeLimet()) {
               System.out.println("超时");
               System.exit(1);
           }else {
               //把每一级中，分数相加得出play玩家得每一级分数
               player.setCurrScore(player.getCurrScore()+levelparam.lp[player.getLevelNo()-1].getSorce());
               System.out.println("您得积分为"+ player.getCurrScore());
               System.out.println("用时："+player.getElapsedTime()+"秒");
           }


       }else{
           //如果玩家输出错误则退出程序
           System.out.println("输入错误");
           System.exit(1);

       }
       //如果玩家等级等于总等级则通关，并退出
    if (player.getLevelNo()==levelparam.lp.length){
        System.out.println("您已经全部通关");
        System.exit(0);
    }
    }
}

3.级别类

package QuickHit;

/**
 * 级别类
 * @lihuilong
 */
public class level {
    private  int No;//级别号
    private  int Strlength;//各级别一次输入的长度
    private  int StrTime;//各级别输出字符串的次数
    private  int TimeLimet;//各级别的时间限制
    private  int sorce;//各级别正确输入一次的得分

    public level(int no, int strlength, int strTime, int timeLimet, int sorce) {
        No = no;
        Strlength = strlength;
        StrTime = strTime;
        TimeLimet = timeLimet;
        this.sorce = sorce;
    }

    public int getNo() {
        return No;
    }

    public int getStrlength() {
        return Strlength;
    }

    public int getStrTime() {
        return StrTime;
    }

    public int getTimeLimet() {
        return TimeLimet;
    }

    public int getSorce() {
        return sorce;
    }
}

4.级别类生成的6位数组

package QuickHit;

/**级别的初始化,初始化一个静态的数组常量，数组长度为级别的最高次数，默认为6次
 * 默认静态 代码块
 * @lihuilong
 */
public class levelparam {
    public static final level [] lp = new level[6];
    static {
        lp[0] = new level(1,2,1,60,1);
        lp[1] = new level(2,3,2,50,2);
        lp[2] = new level(3,4,3,40,3);
        lp[3] = new level(4,5,4,30,4);
        lp[4] = new level(5,6,5,20,5);
        lp[5] = new level(6,7,6,10,6);


    }

}

5.最后测试类，

package QuickHit;

import java.util.Random;

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

运行结果如下图：

超时，自动退出

 

输入错误，退出

         最后第六关太难了，所以没通关，不能给大家带来效果展示，能力有限，轻喷 ，大佬们来看           看这个小游戏