概念

java中有抽象类, scala也有抽象类型

scala的抽象类可以有哪些成员:

1. 普通类可以有的, 抽象类都可以
2. 抽象类可以有抽象方法和抽象字段(属性)
3. 抽象类不能直接创建对象, 只能创建他的子类的对

1.定义抽象类：abstract class Person{} //通过abstract关键字标记抽象类
2.定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性
3.定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法

案例

abstract修饰的类就是抽象类

package abs
object Abs1 {
  def main(args: Array[String]): Unit = {
    val b: A = new B
    b.foo()
  }
}
abstract class A(var a: Int) {
  // 属性只声明, 不初始化, 这就是抽象字段
  var b: Int
  // 方法只有声明, 没有实现, 就是抽象方法
  def foo(): Int
}
class B extends A(20) {
  override var b: Int = _
  override def foo(): Int = {
    println("foo...")
    10
  }
}

继承和重写

（1）如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
（2）重写非抽象方法需要用override修饰，重写抽象方法则可以不加override。
（3）子类中调用父类的方法使用super关键字
（4）子类对抽象属性进行实现，父类抽象属性可以用var修饰；
子类对非抽象属性重写，父类非抽象属性只支持val类型，而不支持var。
因为var修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写
（5）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()
    }
}

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");
    }

}
public 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();
    }
}

结果对比

Scala Java

匿名内部类

在Scala匿名内部类用的比较少,用匿名函数用的多.

object Abs1 {
def main(args: Array[String]): Unit = {
// 创建一个匿名内部类的对象,在scala中很少使用匿名内部类
val a: A = new A(20) {
override var b: Int = 30
override def foo(): Int = {
println(“abc”)
100
}
}
a.foo()
}
}
abstract class A(var a: Int) {
// 属性只声明, 不初始化, 这就是抽象字段
var b: Int
// 方法只有声明, 没有实现, 就是抽象方法
def foo(): Int
}