抽象方法不需要加关键字，只有声明，没有具体实现
可以声明抽象字段，没有初始值
子类重写父类的抽象方法或者抽象字段，不需要加override

抽象属性和抽象方法

1.基本语法
（1）定义抽象类：

abstract class Person{}    //通过abstract关键字标记抽象类

（2）定义抽象属性：

val|var name:String    //一个属性没有初始化，就是抽象属性

（3）定义抽象方法：

def hello():String     //只声明而没有实现的方法，就是抽象方法

2.案例实操

abstract class Person {
  val name: String
  def hello(): Unit
}
class Teacher extends Person {
  val name: String = "teacher"
  def hello(): Unit = {
    println("hello teacher")
  }
}

继承&重写

如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
重写非抽象方法需要用override修饰，重写抽象方法则可以不加override
子类中调用父类的方法使用super关键字
子类对抽象属性进行实现，父类抽象属性可以用var修饰；子类对非抽象属性重写，父类非抽象属性只支持val类型，而不支持var；因为var修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写
Scala中属性和方法都是动态绑定，而Java中只有方法为动态绑定

案例实操(对比Java与Scala的重写)
scala

class Person {
  val name: String = "person"
  def hello(): Unit = {
    println("hello person")
  }
}
class Teacher extends Person {
  override val name: String = "teacher"
  override def hello(): Unit = {
    println("hello teacher")
  }
}
object Test {
  def main(args: Array[String]): Unit = {
    val teacher: Teacher = new Teacher()
    println(teacher.name)
    teacher.hello()
    val teacher1: Person = new Teacher
    println(teacher1.name)
    teacher1.hello()
  }
}

输出结果：
teacher
hello teacher
teacher
hello teacher

Java
补充：Java中多态就是父类引用指向子类对象，静态绑定→编译看左，动态绑定→运行看右

class Person {
    public String name = "person";
    public void hello() {
        System.out.println("hello person");
    }
}
class Teacher extends Person {
    public String name = "teacher";
    @Override
    public void hello() {
        System.out.println("hello teacher");
    }
}
class TestDynamic {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        Person teacher1 = new Teacher();
        System.out.println(teacher.name);
        teacher.hello();
        System.out.println(teacher1.name);
        teacher1.hello();
    }
}

输出结果：
teacher
hello teacher
person
hello teacher