Scala 的trait

标签：特质 val Scala trait extends println

  在Scala中，trait是一种特殊概念。trait可以作为接口，同时也可以定义抽象方法。类使用extends继承trait，在Scala中，无论继承类还是继承trait都用extends关键字。在Scala中， 类继承trait后必须实现其中的抽象方法，实现时不需要使用override关键字，同时Scala支持多重继承trait，使用with关键字即可。

1.1Scala的特质

  本节通过对Scala的特质概念、作用以及语法的相关阐述来说明Scala中的特质应用。通过与Java 中的接口相互对比可以加深对特质的了解。

1.Scala的特质定义

  由于Scala没有Java中接口的概念，所以Scala的特质就相当于Java中的接口，但是Scala的特质比接口的功能强大。Scala的特质定义如下:

trait identified{
}

  其中trait为定义特质的关键字，identified表示一个合法的标识，可以自定义。登中可以定义一些成员、属性或方法等。 

2.Scala的特质作用

  Scala的特质可以封装成员和方法。Java中的接口不提供具体的实现，Scala的特质同样也是封装一些成员属性和方法。例如定义一个Scala特质，相关代码如下:

trait Person{
   val name="scala"
   def a():Unit
}

  Scala的特质相当于抽象类和接口的合体。在JDK1.7中，Java的接口只能定义一些没实现的方法体和一些赋值的变量，而Scala的trait相当于接口和抽象类的合体。 

3.Scala的特质语法

  在Java中实现多接口可以通过implements关键字定义，例如定义一个类P实现多个接口(A和B 为接口)，即class P implements A, B。而在Scala中定义特质A和B时，实现特质的语法为:extends A with B,A和B的位置可以互换。例如 class Pextends A with B表示在一个类中实现多个特质。当类P中混入类S时，S的位置必须在extends之后，特质A或B不可以与类S互换位置，但是A和B的位置可以互换，例如class P extends S with A with B。

1.2 Scala的trait的用法

下面主要介绍Scala的trait的用法:

·只有抽象方法的trait。 

·只有抽象成员和方法的trait。

·具体成员的变量和方法。

·对象继承特质。

相关代码如下：

//定义trait
//1.不是类，不能实例化
//2.它的构造器不能带参数！即：不能添加（）
trait Shentihao{
//  abstract class Shentihao{
  //具体属性
  var KM_1 = 5
  //抽象属性
  var sports:String

  //具体方法
  def say(): Unit = {}
  //抽象方法
  def run
}

class Student1 extends Shentihao{
  var sports = "跳绳"

  def run():Unit={
    println("1000m 在4.5分钟内跑完")
  }
}

object Test20 {
  def main(args: Array[String]): Unit = {
    val s1 = new Student1()
  }
}

  对象继承特质是Scala中比较特殊的一点，可以为单独的某一对象继承trait。相关代码如下：

//多继承

//美貌
trait Beauty {
  val leg:Double

}

//智慧
trait Wisdom {
  val EQ:Int
}


//一个类，实现了两特质。用 with 隔开
//多个特质可以交换顺序
class Girl extends Beauty with Wisdom {
  val leg = 180
  val EQ = 180

  override def toString: String = s"leg=${leg},eq=${EQ}"
}
object Test20_1 {
  def main(args: Array[String]): Unit = {
    val girl = new Girl()
    println(girl)
  }
}

1.3 trait的mix 

  下面介绍一个类继承了一个特质后，特质中的成员的处理方式。成员分为抽象成员和具体成员。成员包括方法和属性，没有方法体实现的方法称为抽象方法，没有赋值的属性称为抽象属性；方法体中有具体实现的方法称为具体方法，赋予了一个具体值的属性称为具体属性。 

  抽象成员包括抽象方法和抽象属性。如果一个类继承了特质，那么抽象方法一定要实现方法体。抽象属性可以通过val或var关键字修饰，如果子类要访问由val或var修饰的抽象成员，要求变量修饰必须要对应，不加 override关键字。 

  具体成员包括具体方法和具体属性。如果是一个具体的方法，那么需要使用关键字override重写方法。使用override重写方法时，方法的名称、参数列表以及返回值必须相同。 具体属性同样使用val或var关键字修饰，val的重写需加上 override关键字，即override val 属性名称。var的重写不需override关键字和var修饰，只需属性名称即可。

1.4 trait的加载顺序

  在Java中构造器的调用顺序为先调用父类构造器再调用子类构造器。Scala 中的调用顺序与Java中的十分相似。trait的加载顺序为先执行超类(父类)中的构造器，再调用子类的构造器。如果混入的trait有父类，会按照继承关系先调用父类。如果有多个父类，则按照从左到右的顺序调用，最后才会调用本类构造器。当有超类调用构造器时按照从左到右、从父类到子类的顺序调用即可。 

//继承多个特质时，加载的顺序

//多个特质加载顺序
//1，先父后子
//2.从左到右
trait  A051{
  println("1")
}

trait B051{
  println("2")
}

class AB extends A051 with B051{
  println("AB")
}

object Test20_2 {
  def main(args: Array[String]): Unit = {
    new AB()
  }
}

下面定义多个父类和子类演示构造器的执行顺序。相关代码如下：

trait A051{ println("A051") }

trait AA051 extends A051 {println("AA051")}

trait AB051 extends A051 {println("AA051")}

trait B051 {println("B051")}

trait BA051 extends B051{println("BA051")}

trait BB051 extends B051 {println("BB051")}

class AB extends AA051 with BA051 with AB051 with BB051{
  println("AB")
}

object Test21{
  def main(args: Array[String]): Unit = {
    new AB()
  }
}

//A051 AA051 B051 BA051 AA051 BB051 AB

1.5 解决空指针异常问题

  通过前面的介绍，了解了Scala构造器的调用顺序并解释了父类构造器打印为0的问题。 下面介绍调用构造器引起的第二个问题，即空指针异常问题。 

1.trait的抽象成员父类使用问题

  在新定义一个对象时，该对象会先调用父类的构造器。而在父类构造器中由于变量没有赋值，实际相当于null，再通过变量(实际为null)调用方法时就会报空指针异常的问题。 

2.解决方法

  解空指针异常的方式有两种，分别是提前定义和懒加载。提前定义就是在调用对象之前给变量赋值，即提前定义法。懒加载就是在调用的过程中通过lazy关键字解决问题。 

下面定义一个Logger演示构造器执行顺序，造成空指针问题。相关代码如下：

方法1：使用lazy关键字

import java.io.PrintWriter
//经典错误:空指针异常

trait FileLogger{
  //抽象属性，没有=
  val filename:String
  println("父类",filename)

  //lazy表示，不立刻求值，而是等到这个变量被使用的时候，去求值
  lazy val fileout = new PrintWriter(filename)

  //用来把 msg 写入到对应文件中
  def log(msg: String): Unit ={
    fileout.println(msg)
    fileout.flush()
  }
}

class Test211 extends FileLogger{

  val filename = "2024-10-28.txt"
  println("子类",filename)
}

object Test21_1 {
  def main(args: Array[String]): Unit = {
    val t1 = new Test211()
    t1.log("test!")
  }
}

方法2：提前定义 

import java.io.PrintWriter
//经典错误:空指针异常

trait FileLogger{
  //抽象属性，没有=
  val filename:String
  println("父类",filename)

  //lazy表示，不立刻求值，而是等到这个变量被使用的时候，去求值
  //lazy val fileout = new PrintWriter(filename)  去掉lazy
  val fileout = new PrintWriter(filename)

  //用来把 msg 写入到对应文件中
  def log(msg: String): Unit ={
    fileout.println(msg)
    fileout.flush()
  }
}

class Test211 extends FileLogger{

  val filename = "2024-10-28.txt"
  println("子类",filename)
}

object Test21_1 {
  def main(args: Array[String]): Unit = {
//    val t1 = new Test211()
    val t1 = new {val filename="2024-10-29.txt"} with FileLogger
    t1.log("test!")
  }
}

1.6 trait与类的相关特性

  通过之前的介绍我们对trait和类都有了一个初步的了解，下面通过trait和类的相同点以及不同点来说明trait的相关特性。 

1.trait与类的相同点

  类和trait都以定义成员变量和方法，成员变量和方法可以是抽象的也可以是具体的。如果类是抽象类，则可以定义抽象成员和抽象方法，如果类是普通类，则可以定义一些普通的变量和方法。trait相当于抽象类和接口，所以trait 既可以定义抽象成员也可以定义普通成员。在继承方面它们都可以使用extends关键字。 

2.trait与类的不同点

  定义类或抽象类时可以有构造参数，而trait构造器不能带参数。关于多继承问题，Java中的类不支持多继承，接口支持多实现:而在Scala中trait可以支持多继承，也可以在多继承的同时混入多个特质。

1.7trait多继承
  下面从trait多继承的实现方法和混入多trait的语法格式对多继承做一个简单介绍，通过多继承产生的问题进一步加深对trait名继承的了解。下面简单介绍多继承广生的问题以解决方案。 

1.trait多继承的定义
  可以通过混入多个trait实现多继承。例如，定义特质t1、t2,在类A中混入多个特质，即class A extends tl with t2表示在类A中混入 t1和t2两个特质。 

2.混入多trait的语法
混入多trait的语法如下:

extends A with B with C

  其中多个特质可以互换位置，即可以 extends C with A with B。多个特质互换位置不影响实现多继承。

3.多重继承

  多重继承容易产生菱形问题。菱形问题可以描述为B和C继承自A，D继承自B和C，如果A有一个方法被B和C重载，而D不对其重载，那么D应该实现谁的方法，B还是C？解决菱形问题的方法是采用最右优先深度遍历进行搜索。

4.多重继承的惰性求值

  惰性求值相当于懒加载问题，即当使用时再去求它的值。当使用子类调用父类的方法出现惰性求值的问题时，只有调用父类中真正的方法时才会对子类中的方法求值。

标签：特质,val,Scala,trait,extends,println
From： https://blog.csdn.net/2301_81748087/article/details/143188374