JavaSE面向对象--QuickHit

面向对象的三大特性已经学习完了，自我感觉不是很好，许多地方的知识点运用的不够熟练，甚至有一些知识点很是模棱两可，不知道如何正确的运用，对于这次QuickHit项目，自我感觉最难的是时间戳和字符串，因为之前就对字符串不够熟悉，导致现在的这种情况，还有对于主方法中对象的不同使用，r容易混淆。

现在总结一下这个项目的感受和自我感觉的难点：
对于这个题的分析和和解题思路，因为PDF文档已经解释的很清晰明了，所以不再进行一个分析，这里最主要的是总结里面的代码。

1.定义的一个玩家类：这个类主要储存了玩家的级别，时间，和玩家玩儿游戏升级的方法

package com.QuickHit;
import java.util.*;
public class Player {
//当前级别
private int  levelNo;
//级别积分
private int score;
//开始时间
private long startTime;
//已用时间
private long elapseTime;
义方法
    //setter
    public void setLeveNo(int leveNo){
        this.levelNo = leveNo;
    }
    public void setScore(int score){
        this.score = score;
    }   
    public void setStartTime(long time){
        this.startTime = startTime;
    }
    public void setElapseTime(){
        this.elapseTime = elapseTime;
    }
    //getter
    public int getLeveNo(){
        return levelNo;
    }
    public int getScore(){
        return score;
    }
    public long getStartTime(){
        return startTime;
    }
    public long getElapseTime(){
        return elapseTime;
    }

    //玩家玩游戏的方法
    public void play(){
        //首先开始的一局游戏，
        Game game = new Game(this);
        //创建一个输入的对象
        Scanner input = new Scanner(System.in);
        //创建循环玩游戏的方法，外层循环一次代表升级一次，一共六级，当创建Stringbuffer 对象时，就已经在堆区创建了一个空间，这个时候空间的值是空的，当传入值是才会有相对应的内容。
        for (int i = 0; i < LevelInitial.levelsArr.length; i++) {
            //玩家升级一次
            levelNo += 1;  
            //获取游戏开始时间，就是获取到当前时间
            startTime = System.currentTimeMillis();
            //内循环，循环一次代表完成了一个等级的游戏
            for (int j = 0; j < LevelInitial.levelsArr[levelNo - 1].getStrTime(); j++) {
                //生成的字符串
                String out = game.printStr();
                //玩家输入相应字符串
                String in = input.next();
                //生成的字符串个输入的字符串比较结果
                game.result(out,in);
            }
        }
    }

}

这一段代码前半部分是很简单的，就是对一个类的封装和提供的一个接口访问，后面的玩家玩游戏的方法可能会难一点，因为涉及到字符串，我对字符串的运用一直都是不很明白，所以对于我来说这里比较的难以理解，所以我对代码的的解释就会详细一点。

Scanner input = new Scanner(System.in);
        //创建循环玩游戏的方法，外层循环一次代表升级一次，一共六级，当创建Stringbuffer 对象时，就已经在堆区创建了一个空间，这个时候空间的值是空的，当传入值是才会有相对应的内容。当用到增删改查的时候，可以用StringBuffer。

2.创建一个等级类：
这个类主要储存了等级数，和得分的初始化信息等

package com.QuickHit;

public class Level {
    //级别号
    private int levelNo;
    //字符串长度
    private int strlength;
    //输出字符串次数
    private int timeLimit;
    //闯关时间限制
    private int strTime;
    //输入正确的得分
    private int perscore;

public Level(int levelNo, int Strlength,int timeLimit,int strTime,int perscore){
        this.levelNo = levelNo;
        this.strlength = strlength;
        this.timeLimit = timeLimit;
        this.strTime = strTime;
        this.perscore = perscore;
        }
        //GETTER 因为游戏中数值已经确定了，不需要在另外设置了
        public int getLevelNo(){
            return levelNo;
        }
        public int getTimeLimit(){
            return timeLimit;
        }
        public int getStrTime(){    
            return strTime;
        }
        public int getStrlength(){
            return strlength;
        }
        public int getPerscore(){
            return perscore;
        }
}

这个类主要是为了获取分数，长度，时间，等级数做准备，这里是比较简单的

package com.QuickHit;
import java.util.*;
public class Game {
    private Player player;
    public Game(Player player){
        this.player = player;
    }
    //方法
    public String printStr(){
        //得到玩家等级
        int levelNo = player.getLevelNo() - 1;
        //得到玩家等级的字符串的长度
        int strlen = LevelInitial.levelsArr[levelNo].getStrlength();
        //创建随机数对象
        Random random = new Random();
        //创建一个stringBuffer，储存产生的随机字符
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < strlen; i++) {
            //每循环一次产生一个随机数
            int rand = random.nextInt(strlen);
            //将这个随机数字对应的字符 拼接
            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);
        //返回用户输入好的字符串
        return buffer.toString();
    }
    public void result(String out,String in){
        //判断输出和输入结果是否一致
        if (out.equals(in)) {
            //获取当前时间
            long currentTime = System.currentTimeMillis();
            //获取开始游戏的时间戳。判断是否超时
            if (currentTime - player.getStartTime()/1000<=LevelInitial.levelsArr[player.getLeveNo()-1].getTimeLimit()) {
                //如果没有超时，继续运行
                int newScore = player.getScore() + LevelInitial.levelsArr[player.getLeveNo() - 1].getPerscore();
                player.setScore(newScore);
                long time = (currentTime - player.getStartTime())/1000;
                player.setElapseTime(time);

System.out.println("输入正确，您的等级是：" + player.getLevelNo() + ", 您的积分是：" + player.getScore() + "， 您的用时为：" + player.getElapseTime() + "秒");
                //判断是否已经全部通关
                if (player.getLeveNo() == 6) {
                    //定义初始化的和为0
                    int sum = 0;
                    //计算总分
                    for (int j = 0; j < LevelInitial.levelsArr.length; j++) {
                        int currentScore = LevelInitial.levelsArr[j].getPerscore() * LevelInitial.levelsArr[j].getStrTime();
                        sum += currentScore;
                    }
                    if (player.getScore() == sum) {
                        System.out.println("恭喜您全部通关！！真棒！！");
                        System.exit(0);
                    }
                }
            }else {
                //输入正确但是超时
                System.out.println("输入正确，但是时间超时，游戏结束！！游戏退出！！");
                System.exit(1);
            }
            }else {
            //输入错误
            System.out.println("输入错误，游戏结束！！游戏退出！！");
            System.exit(1);
        }
    }
}

这里定义的是一个玩家类，在定义的时候，我遇到了字符串的使用这方面的问题，字符串适应不够熟练，甚至有些地方根本不知道怎么去使用，这也是导致我在做这题的时候没有做出来的原因之一，他们的之间的逻辑在脑海中也不够清晰，所以感觉这是一个难点，比如说哦判断超时啊，算积分啊，感觉都不如人意。

package hit;
public class LevelInitial {
    //把所有的等级放入到数组中
    //类变量，--》属于类，在类被加载的时候，创建这个数组
    public static Level[] levelsArr = new Level[6];
    //静态初始化块
    //在加载类的时候执行静态初始化块，并且只会被执行一次
    static {
        levelsArr[0] = new Level(1, 2, 30, 5, 1);
        levelsArr[1] = new Level(2, 3, 25, 4, 2);
        levelsArr[2] = new Level(3, 4, 22, 3, 5);
        levelsArr[3] = new Level(4, 5, 20, 3, 8);
        levelsArr[4] = new Level(5, 6, 18, 3, 10);
        levelsArr[5] = new Level(6, 7, 15, 3, 15);
    }
}

这里定义的是玩游戏的规则，等级分数，升级分数，经过讲解后，明白了初始化块和静态初始化块。

package hit;
public class Test {
    public static void main(String[] args){
        //创建玩家，玩游戏
        Player p = new Player();
        p.play();
    }
}

这里，这个程序的所有代码都已经完成了。
总结：在做这个代码的时候，开始我是没有思路的，在pdf的帮助下才完成，感觉自己在做稍微代码量多一点的题，涉及知识点很多的时候，不知道怎么把自己所学的知识点综合运用起来，好好的利用，在看了pdf的思路之后，突然想起原来是用这种方法，应该是自己代码量不够，所以做分析的时候总是吃力。自己在细节方面还有运用方面还差的很多，以后会注意。