面向对象及项目QuickHit

一.面向对象总结

面向对象：
类与对象的关系:类是对象的抽象，对象是类的实现
类是由属性和方法构成，它的每一个对象都有对应的属性和方法
方法：
方法的重载：
目的：针对同一个行为的多种表现，对应相同方法名的多个方法
特点: 方法名相同，参数列表不同
类方法（static方法）
类名.方法名（）
封装：保护属性值不被随意修改
私有化属性并提供getter，setter对外接口
继承：代码重用，是多态的基础
extends关键字
默认的根类是Object，单根继承
方法的重写：
有继承关系
方法名相同，参数列表相同，返回值相同或小于父类，访问修饰符不能小于父类，异常不能严于父类
构造方法：
默认的构造方法都会先走父类无参构造方法
用super指定的构造方法，调用指定构造方法前，参照第一条
多态：
以父类做参数类型的
父类中方法如果被子类重写，那么在使用父类类型调用该方法时，则看具体的子类类型，决定调用的是哪个重写后的方法
以父类做返回值类型的
如果只调用父类方法，则没有问题
如果需要调用子类特有方法，则需要向下强制转型
抽象类和接口：
abstract关键字：定义抽象类和方法
interface关键字：定义接口
implements关键字：实现接口
相同点：都不能被实例化，都可以有抽象方法
不同点：接口的所有方法都默认是：public abstract类型
接口的所有属性都默认是：public static final类型
抽象类用来被继承，主要目的是代码重用
接口用来扩展功能，可以实现多个接口
异常：
异常的分类：Throwable–>Error , Exception
Exception–>checked异常，运行期异常（RuntimeException)
异常的处理：
try{有可能产出异常的代码}
catch(有可能的异常类型 e）{打印堆栈/打印异常信息…}
finally{最终块，往往用于关闭资源}
异常类的定义：
自定义异常类，继承已知的异常类
写出有参构造，并用super调用父类的有参构造

二.QuickHit项目实战

1.玩家类

public class Player {
    private String name;
    private int curLevel=1;//当前级别编号
    private int curScore;
    private long startTime=System.currentTimeMillis();
    private long usedTiem;
    public Player(String name) {
        this.name = name; }
    public  void play(){
        Game g=new Game();
        g.player=this;
        g.run();
        System.out.println("恭喜"+name+"，您已通关"); }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getCurLevel() {
        return curLevel;
    }
    public void setCurLevel(int curLevel) {
        this.curLevel = curLevel;
    }
    public int getCurScore() {
        return curScore;
    }
    public void setCurScore(int curScore) {
        this.curScore = curScore;
    }
    public long getStartTime() {
        return startTime;
    }
    public void setStartTime(long startTime) {
        this.startTime = startTime;
    }
    public long getUsedTiem() {
        return usedTiem;
    }
    public void setUsedTiem(long usedTiem) {
        this.usedTiem = usedTiem;
    }

2.游戏类

public class Game implements LevelParam {
    Player player = new Player("sam");
    //生成一串字符
    public String getStrings() {
        int curLvl = player.getCurLevel();
        Level lvl = LEVELS[curLvl - 1];
        String str = "";
        for (int i = 0; i < lvl.getCharCnt(); i++) {
            int ranNum = (int) (Math.random() * 10);
            str += ranNum;
        }
        return str;
    }
    //流程控制
    public void run(){
        Scanner sc=new Scanner(System.in);
        System.out.println("欢迎"+player.getName()+"来到quickHit峡谷！！!");
        while (player.getCurLevel()<=6){
        int lvlNum=player.getCurLevel();
        Level lvl=LEVELS[lvlNum-1];
        for (int i = 1; i <= lvl.getInputNum(); i++) {
            System.out.println("当前级别为：" + player.getCurLevel() + ",积分为：" + player.getCurScore()
                    + ",已用时间为：" + player.getUsedTiem()/1000+"秒");
            String out = getStrings();
            System.out.println(out);
            System.out.println("请输入对应的字符串：");
            String input = sc.next();
            long now = System.currentTimeMillis();
            player.setUsedTiem(now - player.getStartTime());
            if (!input.equals(out)) {//输入与输出不一致
                System.out.println("输入错误");
                System.exit(-1);
            } else if (player.getUsedTiem() / 1000 > lvl.getLimitTime()) {
                System.out.println("输入超时，游戏结束");
                System.exit(-1);
            }
            //输入正确且未超时的情况
            player.setCurScore(player.getCurScore() + lvl.getPerScore());//加分
        }

       player. setCurLevel(player.getCurLevel()+1);
        player.setUsedTiem(0);
        player.setStartTime(System.currentTimeMillis());
        }
    }

}

3.等级类

public class Level {
    private int lvlNum=1;//级别号
    private int charCnt;//当前级别每次输出的字符数
    private int perScore;//每次输入后的正确得分
    private long limitTime;//当前级别规定时间
    private int inputNum;//输入次数
    public int getLvlNum() {
        return lvlNum; }
    public void setLvlNum(int lvlNum) {
        this.lvlNum = lvlNum;}
        public int getCharCnt() {
        return charCnt; }
        public void setCharCnt(int charCnt) {
        this.charCnt = charCnt; }
        public int getPerScore() {
        return perScore; }

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

    public long getLimitTime() {
        return limitTime;
    }

    public void setLimitTime(long limitTime) {
        this.limitTime = limitTime;
    }

    public int getInputNum() {
        return inputNum;
    }

    public void setInputNum(int inputNum) {
        this.inputNum = inputNum;
    }

    public Level(int lvlNum, int charCnt, int perScore, long limitTime, int inputNum) {
        this.lvlNum = lvlNum;
        this.charCnt = charCnt;
        this.perScore = perScore;
        this.limitTime = limitTime;
        this.inputNum = inputNum;

    }

4.等级接口

public interface LevelParam {
    public final static Level LEVELS[]={
       new Level(1,2,3,20,5),
            new Level(2,3,5,40,8),
            new Level(3,4,7,60,10),
            new Level(4,5,8,55,8),
            new Level(5,6,9,50,6),
            new Level(6,7,10,40,4)
    };

}

5.测试类

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

本文地址：https://blog.csdn.net/Zhuuu_ZZ/article/details/107623273