框架加数据与抽象

　　我们对room做了改造，我们把出口，从原来以成员变量的硬编码，变成了有容器，使用Hash表

以框架+数据来提高可扩展性

　　命令解析是否可以脱离if-else

　　定义一个Handler来处理命令

　　用Hash表来保存命令和Handler之间的关系

新建Handler类

package demo02.clock.chengbao;

public class Handler {
    protected Game game;
    public Handler(Game game)
    {
        this.game=game;
    }
    public void doCmd(String word)
    {

    }
    public boolean isBye()
    {
        return false;
    }
}

 

新建HandlerBye类

package demo02.clock.chengbao;

public class HandlerBye extends Handler {

    HandlerBye(Game game) {
        super(game);
        // TODO Auto-generated constructor stub
    }

    @Override
    public boolean isBye() {
        // TODO Auto-generated method stub
        return true;
    }

    @Override
    public void doCmd(String word) {
        // TODO Auto-generated method stub
        super.doCmd(word);
    }


}

 

新建HandlerGo类

package demo02.clock.chengbao;

public class HandlerGo extends Handler {


    HandlerGo(Game game) {
        super(game);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void doCmd(String word) {
        // TODO Auto-generated method stub
        game.goRoom(word);
    }

}

 

新建HandlerHelp类

package demo02.clock.chengbao;

public class HandlerHelp extends Handler {


    HandlerHelp(Game game) {
        super(game);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void doCmd(String word) {
        System.out.println("迷路了吗？你可以做的命令有：go bye help");
        System.out.println("如：\tgo east");
    }

}

抽象

抽象方法，只声明而未实现的方法我们称为抽象方法，所有的抽象方法都需要用abstract关键字声明，包含抽象方法的类也需要使用abstract关键字声明，抽象类和普通类相比，区别在于抽象类带有抽象方法，抽象方法可以只声明，而不需要方法体。

abstract：抽象

抽象类定义规则：
1.抽象类和抽象方法必须用abstact关键字来修饰

2.抽象类不能直接实例化，也就是不能直接使用new关键字产生对象

People p = new People(); //错误，People是抽象类，无法实例化
3.抽象方法定义时，只需要声明，不需要实现

4.含抽象方法的类必须被声明为抽象类，抽象类的子类必须实现所有的抽象方法后，才能被实例化，否则这个子类还是个抽象类

提示：子类继承父类，也会继承下父类的访问权限为公有的方法，然后子类使用同样的方法名，而执行自己的方法体，我们称为方法的重写(override)，这里我们就注意到，子类在继承抽象类后，我们来完成方法体，用的是“实现”而不是“重写”。

抽象函数/抽象类

抽象函数——表达概念而且无法实现具体代码的函数

抽象类——表达概念而无法构造出实体的类

带有abstract修饰符的函数

有抽象函数的类一定是抽象类

抽象类不能制造对象

但是可以定义变量

　　任何继承了抽象类的非抽象类的对象可以付给这个变量

实现抽象函数

继承自抽象类的子类必须覆盖父类中的抽象函数

否则自己成为抽象类

两种抽象

与具体相对

　　表示一种概念而非实体

与细节相对

　　表示在一定程度上忽略细节而着眼大局

创建People类

package demo02.clock.chouxiang;

public abstract class People {
    private String  name;
    private  int age;
    //声明一个抽象方法talk()
    public abstract void talk();
}

创建Student类 Teacher类

package demo02.clock.chouxiang;

public class Student extends People {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public void talk() {
        System.out.println("学生->姓名"+this.name+"年龄"+this.age);
    }
}

package demo02.clock.chouxiang;

public class Teacher extends People {
    private String name;
    private  int age;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Teacher() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public void talk() {
        System.out.println("学生->姓名"+this.name+"年龄"+this.age);

    }
}

进行测试Test类

package demo02.clock.chouxiang;

public class Test  {
    public static void main(String[] args) {
        Student student = new Student("张郃",35);
        Teacher teacher = new Teacher("张飞", 48);
        student.talk();
        teacher.talk();
    }
}