接口、抽象类

一、 方法重写
引例:
我们创建Teacher和UniTeacher这两个类，并让UniTeacher继承Teacher类
Teacher.java中

public class Teacher {
            public String name;
            public Teacher (){}
            public void Teach(){
    System.out.println(“老师在教学！”)
    }
}

UniTeacher.java中

public class UniTeacher extends Teacher {}

但当我们要修改UniTeacher类从Teacher类中继承过来的Teach方法时，我们就可以重写：

public class UniTeacher extends Teacher {
    public void Teach(){
    System.out.println(“大学老师在教学！”)
    }
}

定义：子类继承父类的前提，然后子类定义一个父类相同的（方法名、参数、返回类型）方法，区别于方法重载。

注意：构造函数是不能被继承，所以也不存在构造函数重写。
二、 自动转型
引例：
对于上面一个例子，我们创建一个Test.java文件

    public class Test {
        public static void main(String[] args) { 
            UniTeacher teacher = new UniTeacher();
        }
}

对此，我们还有另外一种创建teacher对象的写法：

    Teacher teacher = new UniTeacher();

同时，我们知道有

    Teacher teacher;
    teacher = new UniTeacher();

这样，我们能理解定义了一个父类的变量，将子类所属的方法和属性的地址告诉了父类变量。

定义：创建子类的对象，然后自动转型为父类的类型。

格式：父类类名 对象名 = new 子类类名();

注意：
转型后的对象类型为转型后的类型，执行的方法如果子类重写了父类的方法
则执行的是重写后的，如果没有重写，则执行的是父类自己的
如果没有自动转型过程，则执行的方法都是自己的方法
三、 多态
体现：多个同一种类型的对象，执行同一个方法，执行的过程不一样(有区别)

为什么会有多态现象？？？自动转型+方法重写
自动转型+方法重写前提 继承

四、 方法分类（构造方法、普通方法、抽象方法）
引例：
我们在创建一个类的时候，要赋予类的许多行为，就是我们讲的类的方法。
在Java中方法分为三种:构造方法，普通方法，抽象方法
在Teacher.java中：

        public class Teacher {
            public String name;
            //构造方法
            public Teacher(){}
            //普通方法
            public void Teach(){}
            //抽象方法
            public abstract void study();
}

随机我们在新建一个测试文件Test.java
在Test.java中

        public class Test {
            public static void main(String[] args){
            Teacher teacher = new Teacher();
            }
}

我们发现编译没有问题。

格式：
构造方法：public 类名(){}
普通方法：public 返回类型 方法名(参数) {}
抽象方法：public abstract 返回类型 方法名(参数);

五、 类的分类（普通类、抽象类、接口）
引例：
在上个例子中我们知道了在teacher这个类中，可以有构造方法，普通方法和抽象方法，那么存不存在有一种类不能有构造方法，普通方法或者抽象方法呢。
在Java中存在三种类：普通类、抽象类和接口。
在上个例子中，我们知道了我们创造的Teacher类为一个普通类，
我们下面来试试抽象类：

    public abstract class Teacher(){
        public String name;
        //构造方法
        public Teacher(){}
        //普通方法
        public void Teach(){}
        //抽象方法
        public abstract void Teach();
}

我们继续使用上面一个引例中的Test.java，发现它会编译报错。原因是抽象类不能创建对象。
下面再试试接口：

    public interface Teacher{
        public String name;
        //构造方法
        public Teacher(){}
        //普通方法
        public void Teach(){}
        //抽象方法
        public abstract void Teach();
}

我们继续使用上面一个引例中的Test.java，发现它也会编译报错，就连Teacher.java中也报错了，原因就是接口只能有抽象方法同时也不能创建对象，不但如此，在确定属性时，属性也要是常量，所以，修改如下：

public interface Teacher{
    public static final String name = “Teacher”;
//抽象方法
public abstract void Teach(); 
}

普通类：public class 类名{}
1.只能有普通方法和构造方法，一定不能有抽象方法
2.可以创建对象
3.属性可以是常量（static final），也可以是变量

抽象类：public abstract class 类名{}
1.三种类型的方法都可以存在
2.不能创建对象
3.属性可以是常量（static final），也可以是变量

接口：public interface 类名{}
1.只能有抽象方法，普通方法和构造方法不存在
2.不能创建对象
3.属性一定是常量（static final）

六、 接口继承
接口和抽象类的作用是用来当父类被继承的，抽象方法是用来指导子类重写(实现)的
关键字：implements
格式：public class 子类类名 implements 接口名{
//重写父类的所有的抽象方法
}
接口无非就是领导，只是指导开发。