QuickHit项目——Java实现
文章目录
- 项目分析
- 代码实现
- 项目总结
项目分析
QuickHit 游戏考验你键盘输入的速度和准确性。
根据输入速度和正确率将玩家分为不同级别，级别越高，一次显示的字符数就越多，玩家
正确输入一次的得分也越高。如果玩家在规定时间内完成规定次数的输入，正确率达到
规定要求，则玩家升级（为了简单起见，规定用户错误输入一次，游戏结束）。玩家最
高级别为六级，初始级别一律为一级
QuickHit游戏的设计主要是面向对象的程序设计，用到了抽象，封装，继承和多态。
在做这道题的时候，首先你得理清楚它的思路，比如说它涉及到了对象，对象的属性，实现的方法等等。
代码实现
玩家类
package cn.kgc.kb03.quickhit;
/**
* @作者：BeiisBei
* @时间：2019/9/3
* @目的：
*/
import java.util.Scanner;
//玩家类
public class Player {
private int levelNo; //玩家当前级别
private int currScore; //玩家当前积分
private long 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 long getStartTime() {
return startTime;
}
public void setStartTime(long startTime) {
this.startTime = startTime;
}
public int getElapsedTime() {
return elapsedTime;
}
public void setElapsedTime(int elapsedTime) {
this.elapsedTime = elapsedTime;
}
/**
* 玩家类的方法play()
* 玩家玩游戏
*/
public void play() {
Scanner input=new Scanner(System.in);
Game game=new Game(this); //this--->指当前对象的引用，传入的值是当前Player类(现在没创建对象)以后创建对象的引用。
//外层循环一次，等级加1
for(int i = 0; i<LevelParam.levels.length; i++) {
//等级加1
this.levelNo+=1;
//积分清0
this.currScore=0;
//计时清0
this.startTime=System.currentTimeMillis();
//获得每个级别对应的字符串输入字数
int strLength=LevelParam.levels[levelNo-1].getStrTime();
//内层循环一次，判断玩家输入的字符串
for(int k=0;k<strLength;k++) {
//游戏输出字符串
String out=game.printStr();
//玩家输入
String in=input.next();
//判断玩家输入的字符串，并输出相应结果
game.printResult(out, in);
}
}
}
}
游戏类
package cn.kgc.kb03.quickhit;
/**
* @作者：
* @时间：2019/9/3
* @目的：
*/
import java.util.*;
//游戏类
public class Game {
public Player play; //玩家
/***
* 构造方法
*/
public Game(Player play) {
this.play = play;
}
/***
* 生成字符串，输出字符串，返回字符串用于和玩家的输入进行比较
* @return
*/
public String printStr() {
StringBuffer sbu=new StringBuffer(); //StringBuffer类，字符串缓冲区，添加字符串
Random rand=new Random(); //产生随机数类
//根据相应的等级，来获得相应的输入次数
int strLength=LevelParam.levels[play.getLevelNo()-1].getStrLength();
for(int i=0;i<strLength;i++) {
int randNum=rand.nextInt(strLength); //产生随机数
switch(randNum) {
case 0:
sbu.append(">"); //append方法的作用是在一个StringBuffer对象后面追加字符串
break;
case 1:
sbu.append("<");
break;
case 2:
sbu.append("!");
break;
case 3:
sbu.append("#");
break;
case 4:
sbu.append("@");
break;
case 5:
sbu.append("%");
break;
case 6:
sbu.append("&");
break;
case 7:
sbu.append("*");
break;
case 8:
sbu.append("~");
break;
case 9:
sbu.append("?");
break;
}
}
System.out.println(sbu); //输出字符串
return sbu.toString(); //返回字符串
}
/**
* 比较游戏输出out,和玩家输入in,根据比较结果输出相应信息
*
*/
public void printResult(String out, String in) {
//输入正确
if(out.equals(in)) {
//system.currentTimeMillis()的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
long currentTime=System.currentTimeMillis();
//如果超时
if((currentTime-play.getStartTime())/1000>LevelParam.levels[play.getLevelNo()-1].getTimeLimit()) {
System.out.println("你输入的太慢了，已经超时，退出!");
System.exit(1);
}
//如果没有超时
//计算玩家当前的积分
play.setCurrScore(play.getCurrScore()+LevelParam.levels[play.getLevelNo()-1].getPerScore());
//计算已用时间
play.setElapsedTime((int)(currentTime-play.getStartTime())/1000);
//输出玩家当前级别，当前积分，已用时间
System.out.println("输入正确，你的级别是:"+play.getLevelNo()+"，你的积分是:"+play.getCurrScore()+",已用时间:"+play.getElapsedTime()+"秒！");
//判断用户是否已经闯过最后一关：等级为6，玩家获得的积分==通过所需要的分数（次数*每次的分数）
if(play.getLevelNo()==6) {
//获得通关所需要的分数
int score=LevelParam.levels[play.getLevelNo()-1].getPerScore()*LevelParam.levels[play.getLevelNo()-1].getStrTime();
if(score==play.getCurrScore()) {
System.out.println("恭喜你，通关了~");
System.exit(0);
}
}
}else {
//输入错误
System.out.println("输入错误，退出！");
System.exit(1);
}
}
}
级别类
package cn.kgc.kb03.quickhit;
/**
* @作者：
* @时间：2019/9/3
* @目的：
*/
//级别类
public class Level {
private int levleNo; //各级别编号
private int strLength; //各级别一次输出字符串长度
private int strTime; //各级别输出字符串的次数
private int timeLimit; //各级别闯关时间限制
private int perScore; //各级别输入正确一次的得分
public int getLevleNo() {
return levleNo;
}
public void setLevleNo(int levleNo) {
this.levleNo = levleNo;
}
public int getStrLength() {
return strLength;
}
public void setStrLength(int strLength) {
this.strLength = strLength;
}
public int getStrTime() {
return strTime;
}
public void setStrTime(int strTime) {
this.strTime = strTime;
}
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;
}
public Level(int levleNo, int strLength, int strTime, int timeLimit, int perScore) {
super();
this.levleNo = levleNo;
this.strLength = strLength;
this.strTime = strTime;
this.timeLimit = timeLimit;
this.perScore = perScore;
}
}
玩家级别参数类
package cn.kgc.kb03.quickhit;
/**
* @作者：
* @时间：2019/9/3
* @目的：
*/
//玩家级别参数类
public class LevelParam {
//对应玩游戏的6个级别
public final static Level levels[]=new Level[6]; //static属性属于该类所有，既由该类创建的所有对象共用同一个static属性。
//static代码块的用法：当类被载入时，静态代码块被执行，且只被执行一次，静态块常用来执行类属性的初始化。
static {
levels[0]=new Level(1,2,6,56,1);
levels[1]=new Level(2,3,5,56,2);
levels[2]=new Level(3,4,4,46,5);
levels[3]=new Level(4,5,3,36,8);
levels[4]=new Level(5,6,2,26,10);
levels[5]=new Level(6,7,1,16,15);
}
}
测试类
package cn.kgc.kb03.quickhit;
/**
* @作者：
* @时间：2019/9/3
* @目的：
*/
//测试类
public class Test {
public static void main(String[] args) {
Player p = new Player();
p.play();
}
}
项目总结
1.类继承的注意点：类的构造方法是不可以被继承的；虽然不能继承构造方法，但是我们可以 在子类的构造方法中 通过关键字 super 来调用到 父类的构造方法
2.构造方法一旦程序员自己给定了，那么jvm不再提供默认的 无参构造方法；
3.abstract关键字的注意点:
（1）不可以和final关键字一起使用，因为abstract关键字 是要求子类一定要重写父类的方法，但是final是不允许重写的；
（2）不可以和private关键字一起使用，因为private是私有的，不能被继承的内容，代表根本不存在方法重写，因此不能一起使用；
（3）不可以和static一起使用，因为static是静态修饰符，代表不需要实例化对象，直接用类名就可以调用方法， 那么如果是抽象方法，没有方法实现调用方法会出错，所以编译 器禁止 abstract和static一起使用
4.多态的三要素：
（1）一定要有继承
（2）一定要重写
（3）父类的指针，指向子类的对象。