接口和抽象类的使用

接口定义的是规则：

使用接口：就是实现接口、实现接口的关键字 implements，重写方法

使用接口的时候需要注意：
1.接口是没有静态代码块或者构造方法的
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterfaceA MyInterfaceB{
//覆盖重写所有抽象方法
}

父类（抽象类）：

/**
 *
 * 抽象类 - 父类
 * 可以设置构造函数
 *
 */
package Test13_Demo.Demo04;/*
    @create 2020--12--01--10:13
*/
public abstract class Employee {
    //属性
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    /**
     * 抽象类中的构造方法不能被程序直接调用，因为该类是一个抽象类，不能实例化对象
     * 但是在创建子类（普通类）的时候，子类构造函数会默认调用父类的无参构造函数，为了子类对象的父类存储空间赋值
     */
    //无参构造
    public Employee() {
        super();
    }
    //有参构造
    public Employee(String name) {
        super();
        this.name = name;
    }
    //定义成员方法 - 抽象方法
    public abstract void work();
    //抽象类中可以保存普通方法
    public void test() {
        System.out.println("我是一个普通方法");
    }
}

接口：

/**
 *
 * 引入接口：
 *
 * 接口：是抽象类上一级的封装存在
 *
 * 功能：具备开车考试的功能的接口
 * 具体的方法：理论，场地，路考
 *
 * 接口可以理解为是一个思想，具体的实现不用管，由实现这个接口的类来实现
 *
 * 接口语法：
 * 使用interface替代原来的class，其他的步骤与类定义相同
 * 1.接口中的方法均为公共访问的抽象方法 - jdk7.0之前，之后有所改动
 * 2.接口中无法定义普通的成员属性
 *
 * 接口其实是一个特殊的类，在经过jvm编译之后，还是会生成一个.class文件
 */
package Test13_Demo.Demo04;/*
    @create 2020--12--01--10:37
*/
public interface Driverable {
    //定义成员属性 - 在这里声明的是一个常量
    //隐藏了public static关键词
    //public static String name = "哪吒";
    //定义抽象方法
    public abstract void TheoryTest();
    public abstract void FieldDriver();
    public abstract void RoadDriver();
}

子类 - 司机：

/**
 *
 * 司机类 - 子类
 *
 * 是员工 - 继承employee - extends
 * 需要会开车 - 实现会开车的接口 - implements
 */
package Test13_Demo.Demo04;/*
    @create 2020--12--01--11:08
*/
public class Driver extends Employee implements Driverable {
    //接口中的方法
    @Override
    public void TheoryTest() {
        System.out.println("理论考试100分");
    }
    @Override
    public void FieldDriver() {
        System.out.println("会倒车入库，会侧方位停车");
        System.out.println("s弯，上坡起步，直角转弯");
    }
    @Override
    public void RoadDriver() {
        System.out.println("百米加减档");
    }
    //员工类中的方法
    @Override
    public void work() {
        System.out.println("上下班接送领导，白天接送客人");
    }
}

子类 - 经理：

/**
 *
 * 经理类
 * 要会开车
 *
 */
package Test13_Demo.Demo04;/*
    @create 2020--12--01--11:14
*/
import javafx.scene.input.Mnemonic;
public class Manager extends Employee implements Driverable {
    //接口中的方法
    @Override
    public void TheoryTest() {
        System.out.println("理论考试100分");
    }
    @Override
    public void FieldDriver() {
        System.out.println("会倒车入库，会侧方位停车");
        System.out.println("s弯，上坡起步，直角转弯");
    }
    @Override
    public void RoadDriver() {
        System.out.println("百米加减档");
    }
    //员工类中的方法
    @Override
    public void work() {
        System.out.println("管理餐厅的人员以及设备");
    }
    public Manager() {
    }
    //调用父类的有参构造
    public Manager(String name) {
        super(name);
    }
}

子类 - 服务员：

/**
 *
 * 定义一个普通类去实现父类（抽象类）中的所有的抽象方法！
 */
package Test13_Demo.Demo04;/*
    @create 2020--12--01--10:22
*/
import Test13_Demo.Demo02.Employee;
public class Waiter extends Employee{
    @Override
    public void work() {
        System.out.println("接客，上菜，结账");
    }
    public Waiter() {
    }
    /**
     *
     * 子类的构造方法可以调用父类的构造方法
     * 这里，一个参数的子类构造，调用了父类的一个参数的构造，，为父类中的成员赋值
     * 但是最终还是子类对象自己使用了这个成员变量
     * @param name
     */
    //子类的有参构造
    public Waiter(String name) {
        super(name); //调用的父类（抽象类）中的有参构造方法
    }
}

测试类：

/**
 *
 * 接口定义的是规则：
 * 使用接口：就是实现接口、实现接口的关键字implements，重写方法
 *
 */
package Test13_Demo.Demo04;/*
    @create 2020--12--01--11:17
*/
public class InterfaceDemo {
    public static void main(String[] args) {
        //创建经理
        Manager manager = new Manager("Jack");
        //接口中的方法
        manager.TheoryTest();
        manager.FieldDriver();
        manager.RoadDriver();
        //抽象类中的方法
        manager.work();
        //创建司机
        Driver driver = new Driver();
        //接口中的方法
        driver.TheoryTest();
        driver.FieldDriver();
        //抽象类中的方法
        driver.work();
        //服务员没有实现接口，所以不能调用接口中的方法
        Waiter waiter = new Waiter();
        waiter.work();
    }
}