Scala 中的抽象类和抽象字段及匿名内部类

抽象类

定义

如果类的某个成员在当前类中的定义是不包含完整的，它就是一个抽象类
不完整定义有两种情况：

1. 方法没有方法体（抽象方法）
2. 变量没有初始化（抽象字段）

语法

定义抽象类和Java一样，在类前面加上abstract关键字

// 定义抽象类
abstract class 抽象类名 {
  // 定义抽象字段
  val 抽象字段名:类型
  // 定义抽象方法
  def 方法名(参数:参数类型,参数:参数类型...):返回类型
}

代码示例

object Test01 {
  //创建形状抽象类
  abstract class Shape {
    //添加一个area抽象方法，用于计算面积
    def area:Double
  }

  //创建正方形类
  class Square extends Shape {
    //边长
    var edge:Double = _

    //满参构造
    def this (edge:Double){
      this()
      this.edge = edge
    }
    //计算面积
    override def area: Double = edge * edge
  }

  //创建长方形类
  class Rectangle extends Shape {
    //长
    var length:Double =_
    //宽
    var width:Double = _

    //满参构造
    def this (length:Double,width:Double){
      this()
      this.length = length
      this.width = width
    }
    //计算面积
    override def area: Double = length * width
  }

  //创建圆形类
  class Circle extends Shape {
    //半径
    var radius:Double = _

    //满参构造
    def this (radius:Double){
      this()
      this.radius = radius
    }
    //计算面积
    override def area: Double = Math.PI * radius * radius
  }

  def main(args: Array[String]): Unit = {
    //分别创建3个对象
    val square:Shape = new Square(2)
    val rectangle:Shape = new Rectangle(3, 2)
    val circle:Shape = new Circle(2)

    println(s"边长为2的正方形的面积 = ${square.area}")
    println(s"长为3,宽为2的长方形的面积 = ${rectangle.area}")
    println(s"半径为2的圆的面积 = ${circle.area}")
  }
}

抽象字段

在scala中，如果一个成员变量是没有初始化，我们就认为它是抽象的。

语法

abstract class 抽象类 {
    val/var 抽象字段:类型
}

代码示例

object Test02 {
  //定义一个 人  的抽象类
  abstract class Person {
    // 没有初始化的val字段就是抽象字段 我是谁
    val WHO_AM_I:String
  }

  //定义一个学生类继承 人 的抽象类
  class Student extends Person {
    //实现 WHO_AM_I 字段 赋值为 学生
    override val WHO_AM_I: String = "学生"
  }

  //定义一个 警察类
  class Policeman extends  Person {
    override val WHO_AM_I: String = "警察"
  }

  def main(args: Array[String]): Unit = {
    //创建对象
    val student = new Student
    val policeman = new Policeman
    //分别输出
    println(s"student.WHO_AM_I = ${student.WHO_AM_I}")
    println(s"policeman.WHO_AM_I = ${policeman.WHO_AM_I}")
  }
}

匿名内部类

匿名内部类是没有名称的子类，直接用来创建实例对象。

语法

val/var 变量名 = new 类/抽象类 {
    // 重写方法
}

代码示例

object Test03 {
  abstract class  Person {
    def sayHello(): Unit
  }

  def main(args: Array[String]): Unit = {
    //直接new 来创建一个匿名内部类对象
    val p1 = new Person {
      override def sayHello(): Unit = {
        println("我是一个匿名内部类")
      }
    }
    p1.sayHello()
  }
}