Scala中的继承和特质

谁践踏了优雅 2023-06-12 09:52 12阅读 0赞

### 1.继承 ###

### 1.1 扩展类 ###

在`Scala中`，让子类继承父类，与Java一样，也是使用`extends`关键字

class Employee extends Person{ 
    	var salary = 0.0
    }

继承代表子类可以继承父类的`field`和`method`；然后子类可以在自己内部放入父类所没有，子类特有的`field`和`method`；使用继承可以有效复用代码。

子类可以覆盖父类的`field`和`method`；但是如果父类用`final`修饰，则该类无法被继承。还可以将`field`和`method`用final修饰，field和method是无法被覆盖的。

### 1.2 重写方法 ###

在Scala中重写一个方法必须使用override修饰符。override关键字可以帮助我们尽早地发现代码里的错误，比如：`override`修饰的父类方法的方法名我们拼写错了；比如要覆盖的父类方法的参数我们写错了；等等

public class Person{ 
    override def toString = getClass.getName+"[name ="+name+"] "
    }

此外，在子类覆盖父类方法之后，如果我们在子类中就是要调用父类的被覆盖的方法呢？那就可以使用super关键字，显式地指定要调用父类的方法.（和java一样）

public class Employee extends Person{ 
    ...
    override def toString  = super.toString + "[salary = "+ salary+"]"
    }

`super.toString` 会调用父类即Person的toString方法

### 1.3 抽象类 ###

如果在父类中，有某些方法无法立即实现，而需要依赖不同的子来来覆盖，重写实现自己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这种方法就是**抽象方法**。

而一个类中如果有一个抽象方法，那么类就必须用`abstract`来声明为抽象类，此时抽象类是不可以实例化的

在子类中覆盖抽象类的抽象方法时，不需要使用`override`关键字

abstract class AbstractDemo(name:String) { 
      def sayHello:Unit
    }
    
    class StudentDemo(name:String) extends AbstractDemo(name){ 
      def sayHello: Unit = println("Hello " + name)
    }
    
    object StudentDemo{ 
      def main(args: Array[String]): Unit = { 
        val li = new StudentDemo("Li")
        li.sayHello
      }
    }

输出结果

Hello Li

### 1.4 扩展类 ###

在`Scala`中扩展类的方式和Java一样都是使用`extends`关键字

### 1.5 重写方法 ###

在Scala中重写一个非抽象的方法必须使用`override`修饰符

## 2 特质 ##

### 2.1 trait & with ###

Scala 中没有 interface 这个关键字，想要实现类似的功能，可以使用特质 (trait)。trait 等价于 Java 8 中的接口，因为 trait 中既能定义抽象方法，也能定义具体方法，这和 Java 8 中的接口是类似的。

// 1.特质使用 trait 关键字修饰
    trait Logger {
    
      // 2.定义抽象方法
      def log(msg: String)
    
      // 3.定义具体方法
      def logInfo(msg: String): Unit = {
        println("INFO:" + msg)
      }
    }

想要使用特质，需要使用 `extends` 关键字，而不是 `implements` 关键字，如果想要添加多个特质，可以使用 `with` 关键字。

// 1.使用 extends 关键字,而不是 implements,如果想要添加多个特质，可以使用 with 关键字
    class ConsoleLogger extends Logger with Serializable with Cloneable {
    
      // 2. 实现特质中的抽象方法
      def log(msg: String): Unit = {
        println("CONSOLE:" + msg)
      }
    }

### 2.2 特质中的字段 ###

和方法一样，特质中的字段可以是抽象的，也可以是具体的：

*  如果是抽象字段，则混入特质的类需要重写覆盖该字段；
 *  如果是具体字段，则混入特质的类获得该字段，但是并非是通过继承关系得到，而是在编译时候，简单将该字段加入到子类。

trait Logger {
      // 抽象字段
      var LogLevel:String
      // 具体字段
      var LogType = "FILE"
    }

覆盖抽象字段：

class InfoLogger extends Logger {
      // 覆盖抽象字段
      override var LogLevel: String = "INFO"
    }

### 3.3 带有特质的对象 ###

Scala 支持在类定义的时混入 `父类 trait`，而在类实例化为具体对象的时候指明其实际使用的 `子类 trait`。示例如下：

trait Logger：

// 父类
    trait Logger {
      // 定义空方法 日志打印
      def log(msg: String) {}
    }

trait ErrorLogger：

// 错误日志打印，继承自 Logger
    trait ErrorLogger extends Logger {
      // 覆盖空方法
      override def log(msg: String): Unit = {
        println("Error:" + msg)
      }
    }

trait InfoLogger：

// 通知日志打印，继承自 Logger
    trait InfoLogger extends Logger {
    
      // 覆盖空方法
      override def log(msg: String): Unit = {
        println("INFO:" + msg)
      }
    }

具体的使用类：

// 混入 trait Logger
    class Person extends Logger {
      // 调用定义的抽象方法
      def printDetail(detail: String): Unit = {
        log(detail)
      }
    }

这里通过 main 方法来测试：

object ScalaApp extends App {
    
      // 使用 with 指明需要具体使用的 trait  
      val person01 = new Person with InfoLogger
      val person02 = new Person with ErrorLogger
      val person03 = new  Person with InfoLogger with ErrorLogger
      person01.log("scala")  //输出 INFO:scala
      person02.log("scala")  //输出 Error:scala
      person03.log("scala")  //输出 Error:scala
    
    }

这里前面两个输出比较明显，因为只指明了一个具体的 `trait`，这里需要说明的是第三个输出，**因为 trait 的调用是由右到左开始生效的**，所以这里打印出 `Error:scala`。

### 3.4 特质构造顺序 ###

`trait` 有默认的无参构造器，但是不支持有参构造器。一个类混入多个特质后初始化顺序应该如下：

// 示例
    class Employee extends Person with InfoLogger with ErrorLogger {...}

1.  超类首先被构造，即 Person 的构造器首先被执行；
2.  特质的构造器在超类构造器之前，在类构造器之后；特质由左到右被构造；每个特质中，父特质首先被构造；
    
     *  Logger 构造器执行（Logger 是 InfoLogger 的父类）；
     *  InfoLogger 构造器执行；
     *  ErrorLogger 构造器执行;
3.  所有超类和特质构造完毕，子类才会被构造。