Scala 之抽象、继承与特质（七）

一、Scala 的继承

• 1、只能单继承，关键字也是extends。
• 2、继承了父类则可直接引用父类的方法与属性，也可重写父类的方法与覆盖父类的属性。
• 3、继承父类的方法与覆盖父类的属性用的关键字都是override。
• 4、重写一个非抽象方法必须使用override修饰符。重写超类的抽象方法时，则不需要使用override关键字。

继承的示例代码如下所示：

package objectDemo2

class ExtendDemo {

}

class Person2(){
  val name : String = "HeHe"
  val age = 30

  def m1(age : Int) : Boolean = {
     if (age > 20) true
     else false
  }

  def m2(name : String) : String = name match {
    case "HeHe" => {
      println(s" Name is $name")
      name
  }
    case "BoBo" => {
    println(s" Name is $name")
    name
    }
    case _ => {
      println(s"Name of $name is nothing match ")
      "Nothing"
    }
  }
}

class Student(sex:String) extends Person2 {
  override val name : String = "BoBo"
  override val age: Int = 20
  // 继承父类的方法
  override def m1(age: Int): Boolean = super.m1(age)
  // 重写父类的方法
  override def m2(name : String) : String ={
    s"The student of name is $name and sex is $sex"
  }

  // 编写自身的方法
  def m3(age : Int): String ={
    if(age < 50)
      s"$name is young ..."
    else if(age > 60)
      s"${name}is old man ..."
    else
      "I don't match ....."
  }
}

object Student{
  def main(args: Array[String]): Unit = {
    val student = new Student("woman")
    println(student.m1(22))
    println( student.name + " is " + student.age )
    println(student.m2(student.name))
    println(student.m3(40))
  }
}

二、Scala 之抽象类

定义如下：

关于上面的定义，说明几点：
* （1）定义一个抽象类，需要使用关键字abstract。
* （2）定义一个抽象类的抽象方法，也不需要关键字abstract，只要把方法体空着，不写方法体就可以。
* （3）抽象类中定义的字段，只要没有给出初始化值，就表示是一个抽象字段，但是，抽象字段必须要声明类型，比如：val carBrand: String，就把carBrand声明为字符串类型，这个时候，不能省略类型，否则编译会报错。

示例代码如下：

package objectDemo2

abstract class AbstractDemo {
    val name : String
    var id : String

    // 定义一个没有实现的抽象方法
    def abs1 : String
    // 定义一个有实现的抽象方法
    def abs2(name : String) : String = s"Hello $name"
}

class AbsDemo extends AbstractDemo {
  override val name = "Tom"
  override var id = "12345"

  override def abs1 = "Hello abstract ...."
}

object AbsDemo{
  def main(args: Array[String]): Unit = {
    val demo = new AbsDemo()
    println("id: " + demo.id + ",name: " + demo.name )

    println(demo.abs1)

    println("调用父类的abs2方法：" + demo.abs2(demo.name))
  }
}

三、Scala 之特质

Scala 特质概述

• 1、Java中提供了接口，允许一个类实现任意数量的接口
• 2、在Scala中没有接口的概念，而是提供了“特质(trait)”，它不仅实现了接口的功能，还具备了很多其他的特性
• 3、Scala的特质，是代码重用的基本单元，可以同时拥有抽象方法和具体方法
• 4、Scala中，一个类只能继承自一个超类，却可以实现多个特质，从而重用特质中的方法和字段，实现了多重继承

定义

• 特质的定义和类的定义非常相似，有区别的是，特质定义使用关键字trait。

• 上面定义了一个特质，里面包含一个抽象字段id和抽象方法currentId。
• 注意，抽象方法不需要使用abstract关键字，特质中没有方法体的方法，默认就是抽象方法。
• 上面的实例中，特质只包含了抽象字段和抽象方法，相当于实现了类似Java接口的功能。实际上，特质也可以包含具体实现，也就是说，特质中的字段和方法不一定要是抽象的。

特质在类中的应用
* 特质定义好以后，就可以使用extends或with关键字把特质混入类中。

示例代码如下：

package objectDemo2

/**
  * scala 也是跟java一样单继承，但是可以with多个特质(物质类似java中的接口),
  * 特质编译成class后会变成跟java一样的接口
  * 引用多个特质则用多个with连接
  *特质可以单独被类继承，关键字也是用extends
  */
class ClassDemo {

}

/**
  * 特质
  */
trait Flyable {
  val distance: Int = 1000

  // 声明一个没有实现的方法
  def fight: String

  // 声明一个有实现的方法
  def fly: String = {
    "I can fly ...."
  }
}

trait Flyable2 {
  val runOfFly : Int = 30

  def runSpeek : String
}

/**
  * 抽象类
  */
abstract class Animal {
  // 声明一个没有赋值的属性
  val name: String

  // 声明一个没有实现的方法
  def run: String

  // 声明一个有实现的方法
  def climb: Unit = {
    println("I want to fly ...")
  }
}

class PersonD extends Animal with Flyable with Flyable2 {
  // 重写抽象类中的属性
  override val name = "BoBo"
  // 重写特质中的属性
  override val distance: Int = 8000
  // 重写抽象类中有实现的方法
  override def climb: Unit = super.climb
  // 特质中的属性必须得引入
  override val runOfFly: Int = 10
  // 物质中的方法必须得引入但不一定得实现
  override def runSpeek = ???

  // 重写抽象类中没有实现的方法
  override def run: String = {
     "I can run ..."
  }

  // 重写特质中有实现的方法
  override def fight: String = "Person fight ..."

  // 重写我特质中没有实现的方法
  override def fly: String = super.fly
}

object PersonD{
  def main(args: Array[String]): Unit = {
    val p = new PersonD
    println(p.climb)
    println(p.name + p.run)
    println(p.fight)
    println(p.fly + p.distance)
  }
}