类

一、类的定义

1.1 字段和方法

1. 类的定义可以包含字段field 和方法method，它们统称为类的成员member 。

   • 通过val 或者var 定义字段，通过def 定义方法。
   • 字段保留了对象的状态（或者说数据），方法用这些数据来执行计算。
   • 当实例化一个类时，runtime 会分配一些内存来保存对象的数据。
   • 字段又被称作实例变量，因为每个实例都有自己的变量。

   xxxxxxxxxx
   class C1{
       val field1 = 0;         // 字段
       var field2 = "hello";   // 字段
       def method1(){};        // 方法
   }
   

2. Scala 中，禁止同一个类中使用相同名字的字段和方法，而这在Java 中是允许的。

   xxxxxxxxxx
   class C1{  // 无法编译
       val f = 0 ;      // 字段
       def f = 1 ;      // 方法
   }
   

3. Scala 中，字段和方法属于同一个命名空间。事实上，Scala 只有两个命名空间用于定义，而Java 有四个。

   • Java 的四个命名空间：字段、方法、Class、package 。
   • Scala 的两个命名空间：值（字段、方法、package、单例对象）、类型（Class 和 Traits）。

4. 可以对字段设置缺省值_ 。

   xxxxxxxxxx
   class C1{
       val field1: Int = _
   }
   

   字段的 = _ 初始化代码会给这个字段赋一个零值。具体零值取决于字段的类型：数值类型的零值是 0 ，布尔值的零值是 false，引用类型的零值是 null 。这跟 Java 中没有初始化代码的变量效果一样。

   注意：并不能简单的去掉 = _ 。如果是 val field1: Int 会定义一个抽象变量，而不是一个未被初始化的变量。

1.2 对象实例化

1. 在Scala 中可以使用new 来实例化对象，这和Java 保持一致。当实例化对象时，可以使用值和类型来对其进行参数化parameterize 。

   • 参数化的意义是：在创建实例时，对其进行“配置”。

   • 值的参数化示例：在构造方法的圆括号中传入对象参数。

     xxxxxxxxxx
     val int1 = new java.math.BigInteger("1234")
     

   • 类型的参数化示例：在方括号中给出一个或者多个类型。

     xxxxxxxxxx
     val string1 = new Array[String](3)
     

   • 当同时使用类型参数化和值参数化时，首先是以方括号给出的类型参数，然后是圆括号给出的值参数。

2. 类型参数实际上是实例类型的一部分（而值参数不是），你也可以显式的给出实例的类型：

   xxxxxxxxxx
   val string1: Array[String] = new Array[String](3)
   

3. 如果希望对类型同时实例化多个对象，且参数相同，则可以简化：

   xxxxxxxxxx
   val a = new C
   val b = new C
   val c = new C
   // 简化为： val a, b, c = new C
   

1.3 可变性

1. 如果包含var 字段，则对象是可变的。

   xxxxxxxxxx
   class C1{
       val field1 = 0;         // 不可变字段
       var field2 = "hello";   // 可变字段
       // 其它定义
   }
   val obj1 = new C1;
   var obj2 = new C1;
   

   • obj1 是val 变量，因此不能对其重新赋值。但是可以修改obj1 的状态：

     xxxxxxxxxx
     // obj1 = new C1; // 错误：obj1 是 val
     obj1.field2 = "world"
     

   • obj2 是 var 变量，可以重新对其赋值：

     xxxxxxxxxx
     obj2 = new C1; // 再次创建对象
     

2. 可变对象与不可变对象的选择：

   • 不可变对象的优势：不会改变状态，因此可以自由地传递不可变对象，也可以在多线程中安全使用。同时不可变对象可被安全地用作哈希表里的键。
   • 不可变对象的劣势：有时需要拷贝很大的数据内容而实际上一个很小的局部更新就能满足要求。

   因此类库对于不可变的类也提供了可变的版本，如StringBuilder 就是 String 类的可变版本。

1.4 构造方法

1. 一个类如果没有定义体，则并不需要给出空的花括号。当然你也可以给出花括号，这不是必须的。

2. 类名后的圆括号中的参数称作类参数class parameter，Scala 编译器会收集类参数，并且创建一个主构造方法primary constructor，由主构造方法接收类参数。

   xxxxxxxxxx
   class C(n:Int,s:String) // 省略花括号
   val c = new C(1,"hello")
   

   • 这与Java 不同。

     • Java 中，类有构造方法，构造方法可以接收参数。而Scala 中，类可以直接接收参数，更为精简。
     • 在Scala 中，类定义体内可以直接使用类参数，不需要定义字段并编写构造方法将参数赋值给该字段。

   • Scala 编译器会将你在类定义体中给出的非字段定义、非方法定义的代码编译进类的主构造方法中。

     xxxxxxxxxx
     class C(n:Int,s:String)
     {
         println("n:"+n+";s:"+s)  // 将被添加到类的主构造方法中
     }
     

3. 虽然类定义体内可以直接使用类参数，但是在类外无法直接访问类参数。如果希望在类外访问，则需要将它做成字段。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       require(n>=0)
       val num:Int = n
       val name:String = s
       override def toString = num + ";" + name // 也可以使用 n 和 s
   }
   val c = new C(1,"zhang san")
   println(c.num+";"+c.name) //输出：1;zhang san
   // println(c.n+";"+c.s) 编译错误
   

   尽管 n 和s 是类参数，它们只会出现在类定义体中，Scala 编译器并不会为它们生成字段。

4. Scala 编译器会根据字段出现的先后顺序来依次初始化，因此如果字段之间有依赖关系，则需要仔细安排其位置。

   xxxxxxxxxx
   class C(m:Int,n:Int)
   {
       private val g = min(m,n)  // 首先被初始化
       val num1 = m/g            // 必须在 g 初始化之后才能初始化
       val num2 = n/g            // 必须在 g 初始化之后才能初始化
   }
   

5. 有时需要给某个类定义多个构造方法。在Scala 中，主构造方法之外的构造方法称作辅助构造方法auxiliary constructor 。

   • Scala 的辅助构造方法以 def this(...) 开始。

   • Scala 中，每个辅助构造方法都必须首先调用同一个类的另一个构造方法。即：每个辅助构造方法的第一条语句都必须是这样的形式：this(...) 。

     被调用的构造方法要么是主构造方法，要么是另一个定义在调用方之前的另一个辅助构造方法。这使得Scala 的每个构造方法最终都会调用到类的主构造方法，从而主构造方法成为类的单一入口。

   • Java 中，构造方法要么调用同一个类的另一个构造方法，要么调用超类的构造方法。而Scala 中，只有主构造方法才能调用超类的构造方法。这是一种更严格的限制。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       val num:Int = n
       val name:String = s
       def this(n:Int) = this(n,"zhang san") // 辅助构造方法
   }
   

6. 可以对主构造方法定义一个前置条件precondition，前置条件是对传入方法或者构造方法的参数值的约束，是方法调用者必须要满足的。

   • 实现前置条件的方式是采用require。它是定义在Predef 这个单例对象中，而Scala 源文件中默认自动引入Predef 的成员。
   • require 方法接收一个boolean 的参数。如果传入的参数为true，则它正常返回。如果传入的参数为false，则它抛出IllegalArgumentException ，这会阻止对象的构建。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       require(n>=0)  // 主构造方法必须满足的前置条件
       override def toString =  n + ";" + s
   }
   

1.5 this 关键字

1. 在类定义体中，关键字this 指向当前对象。如果方法需要返回当前对象，则必须显式给出this，否则this 大多数情况下可以省略。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       require(n>=0)
       val num:Int = n
       val name:String = s
       def lessThan(that:C) = this.num < that.num 
       // 也可以忽略 this，写作： num < that.num
       
       def max(that:C) = if(lessThan(that)) that else this // 必须显式指定 this
   }
   

1.6 无参方法

1. Scala 中，如果类的方法没有参数列表，则可以采用无参方法的模式（省略了空的参数列表）：

   xxxxxxxxxx
   class C(n:Int, s:String)
   {
       def width: Int = s.length // 无参方法
   }
   

   带空的圆括号定义的方法，如def width():Int = s.length 被称作空圆括号方法。

2. Scala 推荐对没有参数的、且不改变对象的状态的方法尽可能使用无参方法。这种做法支持“统一访问原则”：使用方代码不应该受到某个属性是字段还是方法实现的影响。

   如：要想把width 实现为字段而不是方法，则只需要简单将def 修改为val：

   xxxxxxxxxx
   class C(n:Int, s:String)
   {
       val width: Int = s.length // 修改为字段
   }
   

   从使用方来看，这个定义完全等价。区别在于：

   • 字段访问的速度比方法略快，因为字段值在对象初始化时就被预先计算好。而方法需要每次调用时都计算一次。
   • 字段需要为对象分配额外的内存空间，而方法不需要。

   因此属性实现为字段好还是方法好，这取决于类的用法。而用法可以随时间变化，核心点在于：类的使用方不应该被内部实现的变化所影响，使用方并不需要关心究竟是哪一种实现。

3. 不仅在方法定义时可以通过无参方法省略空的圆括号，还可以在方法调用时省略掉空的圆括号。

   xxxxxxxxxx
   val c = new C(1,"hello")
   val c_width = c.width // 省略掉空的圆括号
   

   • 从原理上讲，可以对 Scala 所有无参函数调用都去掉空括号，但是建议对于有副作用的调用时给出空括号。这些场景包括：方法执行I/O、修改了某个var 变量（可能是类内，可能是类外）。

     这时候空的参数列表给出一个视觉上的线索：这里发生了副作用。

     xxxxxxxxxx
     "hello".length    // 可以去掉 ()，因为没有副作用
     println()         // 建议不要去掉 ()，因为有副作用
     

   • 这种省略空括号的方法调用，使得使用方调用方法和访问字段的行为完全保持一致。

     xxxxxxxxxx
     class C(n:Int, s:String)
     {
         def width: Int = s.length // 无参方法
         val height: Int = n       // 字段
     }
     val c = new C(1,"hello")
     val c_width = c.width  // 调用方法
     val c_width = c.height // 访问字段
     

     由于这种访问一致性，使用方因此可以不关心属性背后的实现是通过方法、还是通过字段。

1.7 参数化字段

1. 有时候类的参数的唯一作用是为类的字段赋值，此时可以通过参数化字段来简写。

   xxxxxxxxxx
   class A(s:String){ 
       val name = s       // s 的作用是为 name 字段赋值
   }
   

   参数化字段 parametric field 是在类的参数之前添加一个val 或者var，这可以同时定义参数和一个同名的字段。

   xxxxxxxxxx
   class A(val name:String){ 
     // 现在 A 拥有一个名为 name 的字段，以及一个名为 name 的参数
   }
   

   这里 var 和 val 的区别在于：var 的字段是可重新赋值的，val 的字段是不可重新赋值的。

2. 你也可以为参数化字段添加修饰符，如private、protected、overried，就像你对其它类成员做的那样。

1.8 私有构造方法

1. Java 中，我们可以通过标记为 private 来隐藏构造方法。但是在Scala 中，主构造方法并没有显式的定义，它是通过类参数和类定义体隐式地定义的。

   可以在参数列表前加上 private 修饰符来隐藏主构造方法：

   xxxxxxxxxx
   class C private(
       private val name: String,
       private val age: Double
   )
   val c = new C("hello", 20.0)  // 编译失败
   

   一旦隐藏了主构造方法，则该构造方法只能从类本身及其伴生对象访问。类名依然是公有的，因此可以将其作为类型来用。但是不能调用其构造方法。

2. 如果隐藏了主构造方法，则有两种方式来创建类的实例：

   • 通过辅助构造方法来创建：

     xxxxxxxxxx
     class C private(
                      private val name: String,
                      private val age: Double)
     {
       def this(n: String) = this(n, 20.0)  // 辅助构造方法
     }
     val c = new C("hello")
     

   • 通过伴生对象的工厂方法来创建：

     xxxxxxxxxx
     class C private(
                      private val name: String,
                      private val age: Double)
     object C {
       def apply(name: String, age: Double) = new C(name,age)
     }
     val c = C("hello", 20.0)
     

     通过伴生对象的 apply 方法来创建类的一个实例。

3. 一种极端情况是：利用伴生对象来隐藏类本身。

   xxxxxxxxxx
   trait A {
       /*
       定义了一些接口
       */
   }
   object A {
     def apply(name: String, age: Double):A = new AImpl(name,age)  // 创建对象
     private class AImpl(private val name: String,private val age: Double)  extends A{
           /*
       定义了一些接口
       */
     }
   }
   

   现在类 CImpl 被完整的隐藏了，因为它是一个私有类。

二、单例对象

1. Scala 的类不允许有static静态成员，为了提供类似Java 静态成员的功能，Scala 提供了单例对象singleton object 。

   单例对象是Scala 中的一等公民，其地位与class 相等，并不是其附属。定义单例对象并不会定义类型。

2. 单例对象的定义看起来和类定义很像，只是class 关键字被 替换成了object 关键字。

   • 可以将单例对象视作存放 Java 中的静态字段和静态方法的地方。
   • 可以用单例对象名.成员名 的方式来访问单例对象的成员。

3. 类和单例对象的区别：

   • 单例对象不接收参数，而类可以。因为无法采用new 实例化单例对象，因此没有任何手段来向它传参。
   • 每个单例对象都是通过一个静态变量引用合成类synthetic class 的实例来实现的（这个合成类的名字是对象名+美元符$），因此单例对象从初始化的语义上跟Java 静态成员是一致的：单例对象在有代码首次访问时才被初始化。

4. Scala 在每个源码文件都隐式的引入了java.lang 和scala 包的成员，以及名为Predef 的单例对象的所有成员。

   Predef 单例对象位于scala 包中，它包含许多有用的方法。

   • 如：在Scala 源码中使用println 时，实际调用了Predef.println 方法，而该方法实际调用的是Console.println 来执行具体操作。
   • 如：在Scala 源码中使用assert 时，实际调用了Predef.assert 方法。

2.1 伴生对象

1. 当单例对象跟某个类共用同一个名字时，该单例对象被称作这个类的伴生对象companion object ，这个类被称作该单例对象的伴生类companion class。

   • 必须在同一个源码文件中定义类和类的伴生对象。
   • 类和它的伴生对象可以相互访问对方的私有成员。

   xxxxxxxxxx
   class C{            // 伴生类
       // 这里是类定义
   }
   object C{           // 伴生对象
       // 这里是单例对象的定义
   }
   

2.2 孤立对象

1. 没有伴生类的单例对象称作孤立对象standalone object。孤立对象有很多用途：作为工具方法的收集者、定义Scala 应用程序的入口等。

2. 要运行一个Scala 程序，必须提供一个单例对象的名称，该单例对象必须包含一个main 方法，该方法必须接收一个Array[String] 作为参数，该方法的类型必须为Unit。

   任何带有满足正确签名的main 方法的单例对象都能被用作应用程序的入口：

   xxxxxxxxxx
   object A{
       def main(args:Array[String]) = {
           for（arg <- args)
             println(arg)
       }
   }
   

3. scala 提供了一个特质scala.App 来便捷地定义main 方法：

   xxxxxxxxxx
   object A extends App{
       for（arg <- args)
          println(arg)
   }
   

   首先在单例对象的名字后面添加extends App，然后将main 方法里的代码直接写在单例对象的花括号里。可以通过args 的Array[String] 来访问命令行参数。

2.3 工厂对象

1. 工厂对象包含了创建其它对象的方法。通常建议采用工厂对象的方法来构建对象，而不是直接采用 new 来构建对象，这些方法称作工厂方法。

   这种做法的优点是：对象创建的逻辑可以被集中管理，而对象是如何用具体的类来表示的细节可以隐藏起来。

   • 一方面，你的类库更容易被使用方所理解。
   • 另一方面，因为暴露的细节少，这样就提供了更多机会让你在未来不破坏使用方代码的前提下改变类库的实现。

2. 工厂方法最直接的方案是创建类的伴生对象。

   xxxxxxxxxx
   abstract class C(name:String) { // 抽象父类
       // 类的定义体
   }
   class Child1(name:String,age:Int) extends C{ // 第一级子类
       // 类的定义体
   }
   class Child2(name:String,age:Int,job:String) extends Child1{ // 第二级子类
       // 类的定义体
   }
   ​
   object C {
       def make_C(n:String,m:Int) : C = new Child1(n,m)
       def make_C(n:String,m:Int,j:String) : C = new Child2(n,m,j)
   }
   

   C 对象包含三个重载的make_C 工厂方法，每个工厂方法创建不同的类的对象（它们要么是C 的对象，要么是C 子类的对象）。

3. 一旦有了工厂方法，就可以把目标类及其子类变成私有的，使得无法通过 new 来创建其对象。

   将类变成私有的方式之一是：将它们放在工厂对象中，并声明为私有的。

   xxxxxxxxxx
   abstract class C(name:String) { // 抽象父类
       // 类的定义体
   }
   ​
   object C {
     private class Child1(name:String,age:Int) extends C{ // 第一级子类
         // 类的定义体
     }
     private class Child2(name:String,age:Int,job:String) extends Child1{ // 第二级子类
         // 类的定义体
     }
       
       def make_C(n:String,m:Int) : C = new Child1(n,m)
       def make_C(n:String,m:Int,j:String) : C = new Child2(n,m,j)
   }
   

   现在子类 Child1 和 Child2 都无法在外部访问，但是可以通过单例对象C 的工厂方法访问。

三、访问级别

1. 在 Scala 中，默认的访问级别是 public 。通过private 修饰符可以将字段或者方法变成私有。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       private val num:Int = n      //私有字段
       private val name:String = s
   }
   

2. 包、类和对象的成员可以标上private 和 protected 这样的访问修饰符。这些修饰符对成员的访问限定在特定的代码区域。

3. Scala 对访问修饰符的处理大体上与Java 保持一致，但是也有一些重要区别。

3.1 private

1. Scala 对私有成员的处理跟Java 类似：标记为private 的成员只有在包含该定义的类或者对象的内部可见。

   xxxxxxxxxx
   class Outer{
       class Inner {
           private def f() = println("Inner f")
           class InnerMost {
               f()      // 内部访问：可以调用
           }
       }
       (new Inner).f() // 外部访问：编译错误，无法访问  f
   }
   

   • 在Scala 中，这个规则同样适用于内部类。Scala 在一致性上做的比Java 更好。

     如上例所示：

     • 第一次调用f 是包含在 Inner 类的内部，因此可以访问。
     • 第二次调用f 时发生在Inner 类的外部，因此无法访问。

   • 在Java 中，两种访问都可以进行。因为在Java 中，可以从外部类访问其内部类的私有成员。

3.2 protected

1. 和 Java 相比，Scala 对 protected 成员的访问也更加严格。在Scala 中，protected 成员只能从定义该成员的子类、或者该成员本身访问。而在Java 中，允许同一个包内的其它类访问这个类的受保护成员。

   xxxxxxxxxx
   package p {
       class Parent {
           protected def f() = println("Parent f")
       }
       class Child extends Parent {
           f()      // 子类可以访问父类的 protected 成员
       }
       class Other {
           (new Parent).f() // 同一个包内，在 Java 中允许访问； 在 Scala 中无法访问
       }
   }
   

3.3 public

1. Scala 并没有专门的修饰符来标记公有成员，任何未被标记为 private 或protected 的成员都是公有的。

   公有成员可以从任何位置访问到。

3.4 保护的范围

1. 我们可以通过限定词对Scala 中的访问修饰符机制进行增强。形如private[X] 或者 protected[X] 的含义是：对此成员的访问限制”上至“ X 都是私有的或者受保护的。其中 X 表示某个包含该定义的包、类或者单例对象。

2. 带限定词的访问修饰符允许我们对成员的可见性做非常细粒度的控制，尤其是允许我们表达Java 中访问限制的语义，如：包内私有、包内受保护、到最外层嵌套类范围内私有等。

   通过这种方法，我们还可以表达Java 中无法表示的访问规则。

   这种机制对于横跨多个包的大工程非常有用。可以定义对工程中某些子包可见、但是对外部不可见的实体。这在Java 中是无法做到的，因为Java 中一旦定义越过了包的边界，它就对整个世界可见了。

3. 示例：

   xxxxxxxxxx
   package root_p
   ​
   package first_p {
       private[root_p] class Outer {        // Outer 对包 root_p 内所有类和对象可见
           protected[first_p] def f1()={}   // f1 对包 first_p 内所有类和对象可见
           class Inner{
               private[Outer] val num1 = 0  // num1 对类 Outer 内所有类和对象可见
               private[Inner] val num2 = 0  // num2 对类 Inner 内所有类和对象可见
           }
           private[this] val num3 = 0       // num3 仅在当前对象内访问
       }
   }
   ​
   package second_p {
       import first_p._  // 导入 first_p 所有成员
       object Obj {
           private[second_p] val value = new Outer
       }
   }
   

   • private 限定词的用法：

     • private[root_p] Outer： 类Outer 对root_p 包内的所有类和对象都可见，但是对于root_p 包之外的代码都无法访问 Outer 。

       其公共访问范围为：root_p 包内访问。

     • private[first_p] def f1()={} ：方法 f1 对first_p 包内的所有类和对象都可见，但是对于 first_p 包之外的代码都无法访问。

       其公共访问范围为：first_p 包内访问。它等价于Java 的package 可见性。

     • private[Outer] val num1：变量num1 对Outer 类内的所有类和对象都可见，但是对于 Outer 类外的代码都无法访问。

       其公共访问范围为：Outer 类内访问。它等价于Java 的private 。

     • private[Inner] val num2：变量num2 对Inner 类内的所有类和对象都可见，但是对于 Inner 类外的代码都无法访问。

       其公共访问范围为：Inner 类内访问。它等价于Scala 的private 。

     • private[this] val num3：变量 num3 仅在包含该定义的同一个对象内访问，这样的定义被称作是对象私有的object-private 。

       这意味着所有对它的访问不仅必须来自于Outer 类的内部，还必须是来自于Outer 的同一个实例。因此将一个成员标记为private[this] 保证了它不会被同一个类的其它对象看到。

       xxxxxxxxxx
       class C(n:Int)
       {
         private val age:Int = n
         def is_less(other:C) = this.age <= other.age  // other.age 可以访问
       }
       ​
       println(new C(10).is_less(new C(20))) // 输出： true
       ​
       class C2(n:Int)
       {
         private[this] val age:Int = n
         def is_less(other:C) = this.age <= other.age  // other.age 无法访问
       }
       

   • protected 限定词的用法：所有的限定词都可以应用在protected 上，跟private 上的用法一样。

     即：如果我们在类C 中使用protected[X] 这个修饰符，则C 的所有子类，以及X 表示的包、类或对象中，都能访问这个被标记的定义。

     如：protected[first_p] def f1() ：方法f1 对包first_p 内的所有类和对象都可见，也对Outer 任何子类内部的所有类和对象可见。因此其含义就和Java 的protected 完全一样。

4. 在Java 中，静态成员和实例成员同属于一个类，因此访问修饰符对它们的应用方式是统一的。

   由于Scala 没有静态成员，而是用伴生对象来承载那些只存在一次的成员。因此Scala 的访问规则在private 和 protected 的处理上给伴生对象和类保留了特权。

   一个类会将它的所有访问权限和它的伴生对象共享，反之亦然。即：一个对象可以访问它的伴生类的所有私有成员，一个类也可以访问它的伴生对象的所有私有成员。

5. Scala 和 Java 在修饰符的方面的确很相似，但是有一个重要例外：protected static 。

   • Java 中，类C 的 protected static 成员可以被C 的所有子类访问。
   • 对于Scala 的伴生对象而言，protecte 成员没有任何意义，因为单例对象没有子类。

四、继承

1. 类的组合：一个类可以包含对另一个类的引用，利用这个被引用类来帮助它完成任务。组合代表了两个类的关系是：has-a 。

   类的继承：超类与子类的关系。继承代表了两个类的关系是：is-a

2. 组合和继承是两种用已有的类来定义新类的两种方式。如果追求代码复用，通常优先选择组合而不是继承。因为继承会遇到脆弱基类问题：在修改超类时会不小心破坏子类的代码。

4.1 继承

4.1.1 抽象类

1. 通过修饰符abstract 可以表明类是抽象的，这种类称作抽象类。不可以直接实例化一个抽象类。

   xxxxxxxxxx
   abstract class Element {
       def contents: Array[String]
   }
   

   其中contents 方法是一个没有实现的方法，这种方法称作抽象成员。一个包含抽象成员的类必须声明为抽象类。这与Java 不同，Java 中抽象成员也需要添加修饰符abstract。

4.1.2 继承

1. Scala 通过关键字extends 来声明类的继承。

   xxxxxxxxxx
   class ArrayElement(conts:Array[String]) extends Element{
       def contents: Array[String] = conts
   }
   

   extends 有两个作用：

   • 子类从父类中继承所有的非私有成员。
   • 子类成为父类的子类型subtype 。子类型的意思是：任何需要超类对象的地方，都可以用子类对象来替代。

   这里ArrayElement 是Element 的子类，Element 是ArrayElement 的超类。

2. 如果没有extends 语句，则Scala 的类默认继承自scala.AnyRef，这对应于Java 的java.lang.Object 类。

3. 类的继承：子类从父类中继承所有成员，除了以下两个例外：

   • 子类并不会继承父类的私有成员。

   • 如果子类已经实现了父类中相同名称和参数的成员，则该成员不会被继承。这种情况称作：子类的成员重写override 了父类的成员。

     更进一步的，如果子类的成员是具体的，而父类的成员是抽象的，则称子类的具体的成员实现implement 了那个抽象的成员。

4.1.3 父类构造函数

1. 如果需要调用超类的构造方法，则只需要将你打算传入的入参放在超类名称后的圆括号里即可。

   xxxxxxxxxx
   class Child(name: String) extends Parent(name){
      // 类的定义
   }
   

4.2 重载

1. Scala 支持方法重载：同一个方法名可以用于多个方法，这些方法的参数列表不同。在方法调用时，Scala 根据入参类型来选取合适的重载版本。与Java 类似，Scala 根据最匹配的入参类型来选择。

   如果找不到合适的重载版本，则编译器提示ambiguous reference 错误。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       private val num:Int = n
       private val name:String = s
       def f(num:Int) = this.num <= num       // 版本一
       def f(name:String) = this.name <= name // 版本二
   }
   

2. 类默认继承了java.lang.Object 类的toString 实现，该实现只是简单的打印出类名、一个@ 符、一个十六进制数字。

   通常会重写类的toString 方法来获取更有价值的信息，从而方便调试。重写方法通过关键字override 实现：

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       override def toString = n + ";" + s // 精简了花括号、return、空参数、返回类型
   }
   

   override 表示父类的该方法被重写覆盖了。

3. Scala 并没有操作符重载，因为它并没有传统意义上的操作符。类似+,-,*,/ 这样的字符可以被作为方法名。因此1+2 这种表达式实际上调用了Int 对象1 上的、一个叫做+ 的方法，2 是该方法的参数。

   你也可以显式写作：1.+(2) 。

4. Scala 中，字段和方法属于同一个命名空间，这使得字段重写无参方法成为可能。

   • 可以通过val 字段重写父类同名的 val 字段或者无参方法。
   • 也可以通过无参方法重写父类同名的 val 字段或者无参方法。

5. Scala 要求在所有重写了父类具体成员的成员之前加上 override 修饰符。

   • 如果重写的是父类的抽象成员，则可以加、也可以不加上 override 。

• 如果没有重写父类成员，但是添加了 override，则编译报错。

  • 如果应该添加而未添加 override，则编译器也报错。

6. 如果希望某个成员（方法或者字段）不能够被子类重载，则可以在成员之前添加 final 修饰符。

   如果子类 override 了父类的一个 final 成员，则编译报错。

   xxxxxxxxxx
   class C // 父类
   {
       final def echo = println("This is C")  // 不需要 echo 被子类重载
   }
   ​
   class Child extends C // 子类
   {
       override def echo = println("This is Child") // 编译报错
   }
   

7. 如果希望整个类没有子类，则可以简单的将类声明为 final的，做法是在类声明之前添加 final 修饰符。

   xxxxxxxxxx
   final class C // 不希望 C 拥有子类
   {
       def echo = println("This is C")  
   }
   

4.3 多态和动态绑定

1. 一个类型为C 的变量可以指向任何一个C 的子类型的对象，这种现象称作多态polymorphism 。

2. 对变量和表达式的方法调用是动态绑定的：实际被调用的方法实现是在运行时基于对象的类型来决定的，而不是变量或者表达式的类型决定的。

   xxxxxxxxxx
   class C // 父类
   {
       def echo = println("This is C")
   }
   ​
   class Child extends C // 子类
   {
       override def echo = println("This is Child")
   }
   ​
   def f1():C = new C             // 函数 f1 返回类型为 C
   def f2():C = new Child         // 函数 f2 返回类型为 C
   ​
   val c1 = f1()  // c1 类型 C
   val c2 = f2()  // c2 类型 C
   c1.echo        // 输出：This is C
   c1.echo        // 输出：This is Child
   

   例子中，虽然函数 f2 返回的静态类型是C，但是其动态类型是C 的子类 Child。其echo 方法调用的是子类中的echo 方法。

4.4 继承体系

1. Scala 中，所有类都继承自同一个名为Any 的超类。由于任何类都是Any 的子类，因此Any 中定义的方法是“全类型”的：它们可以在任何对象上被调用。

2. Scala 还在继承关系的底部定义了Null 类和Nothing 类，它们本质上是作为通用子类存在的。

   Nothing 类是每个其它类的子类。

   

4.4.1 Any 类

1. Any 类是所有继承关系的顶部，它定义了如下方法：

   • 相等和不等比较：

     xxxxxxxxxx
     final def ==(that:Any) : Boolean
     final def !=(that:Any) : Boolean
     def equals(that:Any) : Boolean
     

     • == 和 != 是 final 的，因此不能被子类重写。
     • == 方法本质上等同于 equals，而 != 一定是 equals 的反义。因此可以通过重写 equals 方法来定制 == 和 != 的含义。
     • Scala 的相等性== 被设计为：对类型的实际表现是透明的：对于值类型而言，它表示的是自然的数值相等性；对于引用类型而言，它表示的是从 Object 继承的 equals 方法的别名。

   • 哈希函数：

     xxxxxxxxxx
     def ## : Int
     def hasCode : Int
     

   • 格式化成字符串：

     xxxxxxxxxx
     def toString : String
     

2. 在 Scala 中，如果希望使用引用相等性而不是内容上的相等性，则使用eq 方法。AnyRef 类定义了eq,ne 方法来给出引用相等性和引用不等性。

3. Any 类有两个子类：AnyVal 和 AnyRef ：AnyVal 是所有值类型的父类；AnyRef 是所有引用类型的父类。

   在Java 平台上，AnyRef 事实上只是java.lang.Object 的一个别名，因此Java 编写的类和Scala 编写的类都集成自AnyRef 。虽然可以在面向Java 平台的Scala 程序中任意切换Object 和 AnyRef，但是推荐采用AnyRef 。

4.4.2 AnyVal 类

1. 可以通过继承AnyVal 来定义自己的值类型。

2. Scala 提供了九个内建的值类型：Byte,Short,Char,Int,Long,FLoat,Double,Boolean,Unit。

   • 其中前八个对应Java 的基本类型，它们的 runtime 是采用Java 基本类型来表示的。

     这些类的实例在Scala 中统统写作字面量，不能用 new 来创建这些类的实例。这是通过将这些值类型定义为 abstract 同时也是 final 这个技巧来完成的。

   • 最后一个Unit 粗略的对应到Java 的 void 类型，它有且只有一个实例值，写作() 。

3. 值类型以方法的形式支持通常的算术和布尔运算操作符，同时它们还支持Any 类的所有方法。

4. 值类空间是扁平的：所有的值类型都是scala.AnyVal 的子类，但是它们之间并没有子类关系。

   而不同值类型之间存在隐式类型转换。

5. 可以对Int 类型调用 min,max,until,to,abs 等方法。原理是：存在从Int 类到 RichInt 类的隐式转换。

   只要对Int 调用的方法没有在Int 类中定义，而RichInt类刚好定义了该方法，则隐式转换就自动应用。

   其它的值类型也有类似的辅助类和隐式转换。

4.4.3 底类型

1. Null 类是 null 引用的类型，它是每个引用类的子类。

   Null 类并不兼容值类型，如：你无法将null 赋值给一个整数变量。

2. Nothing 位于 scala 类继承关系的底部，它是任何其它类型的子类。

   实际上并不存在这个Nothing 类型的任何值，其用途之一是给出非正常终止信号。

   如：

   xxxxxxxxxx
   def error(message: String) : Nothing =
     throw new RuntimeException(message) // Nothing 表明该方法并不会正常返回
   ​
   def f(x:Int,y:Int): Int = 
     if (y!=0) x/y
     else error("can't divide by 0")
   

   由于error 分支的类型为 Nothing，兼容于Int，因此能够成功编译。

4.4.4 自定义值类型

1. 可以自定义值类型来对内建的值类型进行扩充。和内建的值类型一样，自定义的值类型通常也会编译成那种不使用包装类的Java 字节码。

   而在需要包装类的环境中（如泛型），值类型将被自动装箱和拆箱。

2. 要使得某个类成为值类，该类必须满足以下条件：

   • 该类继承自AnyVal。
   • 该类必须有且仅有一个参数，且在该唯一参数之前加上val（参数化字段）。这可以让该参数作为字段被外界访问。
   • 该类的内部除了def 之外不能有任何其它东西。
   • 该类不能有子类。
   • 该类不能重写equals 和 hashCode 。

   xxxxxxxxxx
   class RMB(val amount:Int) extends AnyVal
   {
       override def toString() = "$" + amount
   }
   

   RMB 在Scala 源码中的类型为RMB，但是编译后Java 字节码中直接使用Int 。

3. 一个良好的习惯是：对每个领域概念定义一个新的类，哪怕复用相同的类来实现不同用途也是可以的。甚至这样的类是细微类：既没有方法，也没有字段。

   这个方法可以有助于编译器在更多的地方帮助你。如：

   xxxxxxxxxx
   def ROI(cost:Double, revenue:Double): Double = (revenue-cost)/cost
   

   这个函数用于计算企业的ROI。如果由于疏忽，将成本传给了revenue 参数、将收入传给了cost 参数，则计算结果是错误的。此时编译器并不会错误，因为它们都是Double 类型。

   此时可以定义值类：

   xxxxxxxxxx
   class Cost(val value: Double) extends AnyVal
   class Revenue(val value: Double) extends AnyVal
   def ROI(cost:Cost, revenue:Revenue) : Double = (revenue.value-cost.value)/cost.value
   

五、Trait

1. Scala和Java 中，不支持多重继承，任何一个类都继承自单个父类。C++ 支持多重继承，一个类可以继承自多个父类。

   为了实现类似多重继承的效果，Java 采用接口interface 来实现，而Scala 采用特质trait 来实现。

   trait 是 Scala 代码复用的基础单元：trait 将方法、字段封装起来，然后通过将它们混入mix in 类的方式来实现复用。

   特质很像Java 接口，但是特质比接口更强大：它不仅可以定义方法，还可以定义字段来保持状态。

2. 通过trait 关键字来定义特质，其定义除了关键字不一样，其它都和类的定义相同。

   xxxxxxxxxx
   trait T {
       def f = println("This is a trait")
   }
   

   在特质定义中你可以做任何在类定义中做的事，语法也完全相同。除了以下两种情况：

   • 特质不能有任何“类”参数，即：那些传入类的主构造方法的参数。

     你可以这样定义一个类：class C:(x:Int,y:Int)，但是无法这样定义一个特质：trait C:(x:Int,y:Int) 。

   • 类中的 super 调用是静态绑定的，而在特质中 super 是动态绑定的。

     • 在类中编写 super.toString 这样的代码时，你可以明确知道实际调用的是哪个实现。

     • 在特质中编写 super.toString 这种代码时，你无法知道实际调用的是哪个实现，因为定义特质时super 并没有被定义。

       具体哪个实现被调用，在每次该特质混入到某个具体类时，都会重新判定。

       这种super 的奇怪行为是特征能够实现可叠加修改stackable modification 的关键。

3. 特质也有继承关系，如果未明确给出超类，则它默认继承自AnyRef 。

4. 一旦定义好特质，就可以通过extends 或者 with 关键字将其混入mix in到类中。

   一般是混入特质，而不是继承特质。因为混入和继承有很多重要区别。

5. 可以通过extends 来混入特质，这种情况下，类会隐式的继承了特质的超类。从特质继承的方法跟从超类继承的方法用起来一样。

   xxxxxxxxxx
   class Parent{
       def f1 = println("This is Parent class")
   }
   ​
   trait T extends Parent{
       def f2 = println("This is a trait")
   }
   ​
   class Child extends T{ // Child 隐式继承了 Parent，Child 还可以使用 T 的方法
       def f3 = println("This is Child class")
   }
   ​
   val c = new Child()
   c.f1         // 打印：This is Parent class
   c.f2         // 打印：This is a trait
   c.f3         // 打印：This is Child class
   

   同时特质也定义了一个类型，但是有几个约束：

   • 不能直接new 一个特质。
   • 只能使用特质中定义、以及特质从它的超类中继承而来的字段和方法。此时也能够支持多态和动态绑定。

   xxxxxxxxxx
   val c: T = new Child()  // c 的类型是 T
   c.f3                    // 编译失败，因为 T 没有 f3 成员
   c.f2                    // 打印：This is a trait
   c.f1                    // 打印：This is Parent class
   val t = new T()         // 编译失败，无法直接 new 一个特质
   

6. 如果类已经通过extends 继承自某个超类，如果还希望混入特质，则通过with 关键字。

   xxxxxxxxxx
   class Parent{
       def f1 = println("This is Parent class")
   }
   trait T {
       def f2 = println("This is a trait")
   }
   ​
   class Child extends Parent with T { // Child 显式继承了 Parent，并混入了 T
       def f3 = println("This is Child class")
   }
   ​
   val c = new Child()
   c.f1         // 打印：This is Parent class
   c.f2         // 打印：This is a trait
   c.f3         // 打印：This is Child class
   

7. 如果希望混入多个特质，则可以通过多个 with 子句添加。

   • 如果显式继承自父类，则父类采用extends，每个特质一个 with 子句。
   • 如果没有显式继承，则第一个特质采用extends，后面每个特质一个 with 子句。

   xxxxxxxxxx
   class Parent{
       def f1 = println("This is Parent class")
   }
   trait T1 {
       def f2 = println("This is a trait1")
   }
   trait T2 {
       def f3 = println("This is a trait2")
   }
   ​
   class Child extends Parent with T1 with T2 { // Child 显式继承了 Parent，并混入了 T1,T2
       def f4 = println("This is Child class")
   }
   

8. 类可以重写特质的成员，语法和重写超类中的成员一样。

9. 特质的一个主要用途是：自动给类添加基于已有方法的新方法。即：特质可以丰富一个瘦接口，使其成为一个富接口。

   瘦接口和富接口代表了面向对象设计中经常面临的取舍，在接口实现方和接口使用方之间的权衡。

   • 富接口有很多方法，对调用方很方便，但是实现方需要做更多的工作。
   • 瘦接口方法较少，因此实现起来更容易，但是需要调用方编写更多的代码。

   Java 通常采用瘦接口，而Scala 倾向于采用富接口。因为Scala 可以通过给特质添加具体方法的形式，而这种投入是一次性的。你只需要在特质中实现这些方法一次，然后混入类中。你不需要在每个混入该特质的类中重新实现一遍。

   因此和没有特质的语言相比，Scala 中实现富接口的代价更小。

10. 要用特质来实现富接口，只需要定义一个拥有为数不多的抽象方法（接口中的瘦的部分）和可能数量很多的具体方法（这些具体方法基于那些抽象方法编写）的特质。然后你可以将这个特质混入到某个类，在类中实现接口中瘦的部分，最终得到一个拥有完整富接口实现的类。

    xxxxxxxxxx
    abstract trait T{
        /***** 瘦接口部分：抽象 *****/
        def interface1(n:Int):Int
        def interface2(name:String):String
        
        /***** 富接口部分：具体 *****/
        def f1(m:Int) = {/* 调用 interface1 和 interface2 的具体实现 */}
        def f2(m:Int,n:String) = {/* 调用 interface1 和 interface2 的具体实现 */}
    }
    ​
    class C extends T{ // C 拥有了富接口
        /******  实现瘦接口  ******/
        override def interface1(n:Int) = {/* 具体实现 */}
        override def interface2(name:String) = {/* 具体实现 */}
    }
    

11. 当需要实现某个可复用的行为集合时，都需要决定是用特质还是抽象类。有一些参考意见：

    • 如果某个行为不会被复用，则用具体的类。

    • 如果某个行为可能被用于多个互不相关的类，则用特质。

    • 如果想要从Java 代码中继承某个行为，用抽象类。

      从Java 类继承和从Scala 类继承几乎一样，唯有一个例外：如果某个Scala 只有抽象方法，则它会被翻译成Java 的接口。

    • 如果计划将某个行为以编译好的形式分发，且预期会有外部的组织编写继承自它的类，则倾向于使用抽象类。因为当某个特质增加或者减少成员时，任何继承自该特质的类都需要被重新编译，哪怕这些类并没有任何改变。

      如果外部的使用方只是调用到这个行为，而没有继承，则特质也是可以的。

    • 如果没有任何线索，则推荐从特质开始。因为特质能让你保留更多选择。

12. 许多有经验的Scala 程序员都在实现的初期采用特质。每个特质可以描述整个概念的一小块。随着设计逐步固化和稳定，这些小块可以通过特质混入，被组合成更完整的概念。

5.1 Ordered Trait

1. 特质的一个应用场景是比较大小。通常为了支持大小比较操作，我们会定义一些方法：

   xxxxxxxxxx
   class C
   {
       def < (that:C)  =  {/* 小于比较 */ }
       def > (that:C)  =  that < this
       def <= (that:C) =  (this < that) || (this == that)
       def >= (that:C) =  (this > that) || (this == that)
   }
   

   实际上这个场景太普遍，因此Scala 提供了专用的特质来解决，这个特质叫Ordered 。

2. Ordered 特质定义了 <,>,<=,>= ，你需要实现compare 方法，而这些方法将基于compare 方法来实现。

   因此Ordered 特质允许你通过只实现一个 compare 方法来增强某个类，从而使其具有完整的比较操作。

   xxxxxxxxxx
   class C(n:Int) extends Ordered[C]{
       val num = n
       def compare(that:C) = this.num -  that.num
   }
   

   • Ordered 特质要求混入时提供一个类型参数，如这里的Ordered[C] ，其中C 是你要比较元素的类。

   • compare 方法用于比较调用者（这里是this），和传入对象（这里是that）。

     • 如果二者相等，则返回 0 。
     • 如果调用者较小，则返回负值。
     • 如果调用者较大，则返回正值。

3. 注意：Ordered 特质并不会帮你定义equals 方法，因为它做不到。因为当你用compare 来实现equals 时，需要检查传入对象的类型。而由于Java 的类型擦除机制，Ordered 特质自己无法完成这个检查。

   因此你需要自定义equals 方法，哪怕你已经继承了 Ordered 。

5.2 可叠加的修改

1. 特质除了用于将瘦接口转化成富接口之外，还可以用于为类提供可叠加的修改。

2. 一个典型的例子：对整数队列进行修改：

   • 可以将所有放入队列的整数翻倍。
   • 可以将所有放入队列的整数加一。
   • 可以将队列中的负数去掉。

   xxxxxxxxxx
   import scala.collection.mutable.ArrayBuffer
   ​
   abstract class MyQueue{
       def get(): Int
       def put(x:Int)
   }
   class BasicQueue extends MyQueue{
       private val buf = new ArrayBuffer[Int]
       def get() = buf.remove(0)
       def put(x:Int) = {buf += x}
   }
   ​
   val queue = new BasicQueue
   queue.put(10)
   println(queue.get())  // 打印结果：10          
   ​
   ​
   trait DoubleOp extends MyQueue{
       abstract override def put(x:Int) = {super.put(2*x)}
   }
   trait IncOp extends MyQueue{
       abstract override def put(x:Int) = {super.put(x+1)}
   }
   ​
   class DoubleBasicQueue extends BasicQueue with DoubleOp
   ​
   val queue2 = new DoubleBasicQueue
   queue2.put(10)
   println(queue2.get())  // 打印结果：20
   

   这里有两个要点：

   • DoubleOp 声明了一个超类MyQueue，因此该特质只能够被混入那些同样继承自MyQueue 的类。

   • 该特质在一个声明为抽象的方法里做了一个super 的调用。

     • 对于普通的类而言，这样的调用是非法的，因为它们在运行时必定会失败。因为父类的 put 方法是抽象的，并未实现。
     • 对于特质来说，这样的调用实际上可以成功。因为特质中的super 是动态绑定的，只要在给出了该方法具体定义的特质或类之后混入，DoubleOp 特质里的super 调用就可以正常工作。

     为了告诉编译器你是特意如此，必须将这样的方法标记为 abstract override 。这样的修饰符组合只允许用在特质的成员上，不允许用在类的成员上。其含义是：该特质必须混入某个拥有该方法具体定义的类中。

3. 如果类仅仅是继承然后混入特质，而并没有任何新的代码，这时候可以直接new而不必定义一个有名字的类。

   xxxxxxxxxx
   class DoubleBasicQueue extends BasicQueue with DoubleOp
   val queue2 = new DoubleBasicQueue
   

   可以简化为：

   xxxxxxxxxx
   val queue2 = new BasicQueue with DoubleOp
   

4. 这里的特质主要用作是代表某种修改modification，因为它们修改了底层类的状态，而不是定义并修改自己的状态。

   • 这些特质是可叠加的stackable。
   • 可以从这些特质中任意选择，将它们混入类。

5. 混入特质的顺序是重要的。大致上讲，越靠右出现的特质越先起作用。

   当你调用某个带有混入的类的方法时，最靠右端的特质中的方法最先被调用。如果该方法调用super，则它将调用左侧紧挨着它的那个特质的方法，以此类推。

5.3 特质和多重继承

1. 特质是一种从多个像类一样结构继承的方式，但是它和C++ 中的多重继承有重大区别。其中一个尤为重要的区别是：对super 的解读。

   • 在多重继承中，super 调用的方法在调用的地方就确定了。
   • 在特质中，super 调用的方法取决于类和混入类的特质的线性化linearization 。

2. 以一个简单例子来说明：

   xxxxxxxxxx
   import scala.collection.mutable.ArrayBuffer
   ​
   abstract class MyQueue{
       def get(): Int
       def put(x:Int)
   }
   class BasicQueue extends MyQueue{
       private val buf = new ArrayBuffer[Int]
       def get() = buf.remove(0)
       def put(x:Int) = {buf += x}
   }
   ​
   trait DoubleOp extends MyQueue{
       abstract override def put(x:Int) = {super.put(2*x)}
   }
   trait IncOp extends MyQueue{
       abstract override def put(x:Int) = {super.put(x+1)}
   }
   

   对于代码：

   xxxxxxxxxx
   val q = new BasicQueue with DoubleOp with IncOp
   q.put(1)
   

   • 如果是多重继承，则需要考虑q.put 究竟调用的是哪一个put 方法。

     如果规则是最后一个特质胜出，则DoubleOp 中的put 会被执行；如果规则是第一个特质胜出，则IncOp 中的put 会被执行。

     因此，这种方式无法实线可叠加的修改。

   • Scala 的规则是：线性化。

     当用new 实例化一个类的时候，Scala 会将类及其所有继承的类和特质都拿出来，将其线性的排列在一起。

     当你在某个类中调用 super 的时，被调用的方法是这个链条中向上最近的那个。如果除了最后一个方法外，所有的方法都调用了 super，则最终的结果就是叠加在一起的行为。

3. 在任何线性化中，类总是位于所有它的超类和混入的特质之前。因此当你写下调用super 的方法时，该方法绝对是在修改超类和混入特质的行为。

4. Scala 线性化的主要性质可以通过下面的例子说明：

   xxxxxxxxxx
   class Animal
   {
       def f = println("This is Animal")
   }
   ​
   trait Furry extends Animal
   {
       override abstract def f = {
           println("This is Furry")
           super.f
       }
   }
   trait HasLegs extends Animal
   {
       override abstract def f = {
           println("This is HasLegs")
           super.f
       }
   }
   trait FourLegged extends HasLegs
   {
       override abstract def f = {
           println("This is FourLegged")
           super.f
       }
   }
   class Cat extends Animal with Furry with FourLegged
   {
       override def f = {
           println("This is Cat")
           super.f
       }
   }
   

   其继承体系为：

   

   注意：

   • 即使Animal 的 f 是具体的，trait 中的f 也可以是抽象的。
   • 具体的类Cat 中，f 必须是具体的，也就是不能有abstract 。

   执行代码：

   xxxxxxxxxx
   var cat = new Cat
   cat.f
   /*
   输出为：
   This is Cat
   This is FourLegged
   This is HasLegs
   This is Furry
   This is Animal
   /*
   

   Cat (class Cat extends Animal with Furry with FourLegged) 的线性化从后到前计算过程如下：

   • 最后一部分是超类Animal 的线性化。这段线性化被直接复制过来而不加修改。

     由于Animal 并不显式扩展自某个超类，也没有混入任何特质，因此其线性化看起来是这样的：Animal -> AnyRef -> Any 。

   • 线性化倒数第二部分是首个混入特质 Furry 的线性化。因为所有已经出现在Animal 线性化中的类都不再重复出现，每个类在Cat 的线性化当中只出现一次。因此结果为：

     Furry ->Animal -> AnyRef -> Any 。

   • 接下来是 FourLegged 的线性化。同样的，任何之前出现的类都不再重复出现，因此结果为：

     FourLegged -> HasLegs -> Furry ->Animal -> AnyRef -> Any 。

   • 最后，Cat 线性化中的第一个类是它自己，最终Cat 的线性化结果为：

     Cat -> FourLegged -> HasLegs -> Furry ->Animal -> AnyRef -> Any 。

   当这些类和特质中的任何一个通过supper 调用某个方法时，被调用的是在线性化链条中出现在其右侧的首个实现。

   如果定义为：

   xxxxxxxxxx
   class Cat extends Animal with Furry with FourLegged
   {
       override def f = {
           println("This is Cat")
       }
   }
   

   因为Cat 中没有 super 调用，则并不会执行线性化链条搜索。

   xxxxxxxxxx
   var cat = new Cat
   cat.f
   /*
   输出为：
   This is Cat
   */
   

五、包和导入

1. 在大型程序中，通常以模块化的风格编写代码，将程序切分成若干个较小的模块，从而降低耦合。

5.1 包

1. Scala 代码存在于Java 平台全局的包层次结构当中。在Scala 中，可以通过两种方式将代码放进带名字的包中：

   • 在文件顶部放置一个package 子句，让整个文件的内容放进指定的包中。

     xxxxxxxxxx
     package com.xx.yy
     ​
     /* 现在整个文件的内容都在包中 */
     class C
     

   • 在 package 子句之后加上一段用花括号包裹起来的代码块，这个代码块包含了进入该包的定义。

     这个语法称作打包packaging，类似于C# 的命名空间。

     这是个更加通用的表示法，允许我们在一个文件中包含多个包的内容。如：将某个类的测试代码和原始代码放置在同一个文件里，不过分成不同的包。

     xxxxxxxxxx
     package com.xx.yy{ 
         /* 只有花括号中的内容在包中 */
         
         package model_a { // 原始 package
             class C       // 原始代码
         }
         package tests {   // 测试 package
             class C_Test  // 测试代码
         }
     }
     

2. 由于Scala 代码是 Java 生态的一部分，因此建议采用Java 的包名习惯：将域名倒过来。

3. 采用包层次结构划分代码之后，不仅有助于人们浏览代码，同时也告诉编译器：同一个包中的代码之间存在某种相关性。

4. 在访问同一个包内的代码时，Scala 允许我们采用简短的、不带限定前缀的名称。

   • 一个类不需要前缀就可以在自己的包内被访问。

     xxxxxxxxxx
     package com.xx.yy {
         package model_a {
             class C1             // 在 model_a 内， C1 不需要前缀就可以访问
             class C2{
                 val c = new C1   // 不需要 com.xx.yy.model_a.C1
             }
         }
     }
     

   • 包自身也可以从包含它的包里不带前缀的访问到。

     xxxxxxxxxx
     package com.xx.yy {
         package model_a {      // 在 com.xx.yy 内，model_a 不需要前缀就可以访问
              class C1  
         }
         class C3 {
             val c = new model_a.C1 // 不需要 com.xx.yy.model_a
         }
     }
     

   • 使用花括号打包语法时，所有在包外的作用域内可以被访问的名称，在包内也可以访问到。

     xxxxxxxxxx
     package com.xx.yy {
         class C3
         package model_b { // model_b 可以直接访问 C3
             class C4 {
                 // 由于外层 model_b 可以直接访问 C3，这里不需要 com.xx.yy.C3
                 val c = new C3 
             }
         }
     }
     

   • 这些访问规则只有当你显式的嵌套打包时才有效。如果你采用每个文件只有一个包的做法，则只有那些在当前包内定义的名称才直接可用。

     xxxxxxxxxx
     package com.xx.yy {
         class C1
     }
     ​
     package com.xx.yy.model_a { // 现在 com.xx.yy.model_a 位于文件顶层
         class C2 {
             val c = new C1  // C1 不再可见，编译错误
         }
     }
     

5. 如果花括号嵌套让你的代码缩进太多不方便阅读，则你可以用多个 package 子句但是不采用花括号。这称作链式包子句。

   xxxxxxxxxx
   package com.xx.yy // 省略了花括号
   class C1
   ​
   package com.xx.yy // 省略了花括号
   package model_a   // 省略了花括号
   class C2{
       val c = new C1  // C1 可见
   }
   

6. 有时候可能 package 名字相互遮挡。

   xxxxxxxxxx
   // 位于文件 launch.scala 中
   package launch {
       class Booster3
   }
   ​
   // 位于文件 mypackage.scala 中
   package mypackage {
       package navigation {
           package launch {
               class Booster1
           }
           class MissionControl {
               val booster1 = new launch.Booster1
               val booster2 = new mypackage.launch.Booster2
               val booster3 = new _root_.launch.Booster3
           }
       }
       package launch {
           class Booster2
       }
   }
   

   • MissionControl 和 Booster1 的包launch 位于同一个包，因此可以直接访问 launch.Booster1 。
   • navigation 和 Booster2 的包launch 位于同一个包，因此可以通过mypackage.launch.Booster2 来访问。
   • Scala 提供了一个名为_root_ 的包，这个包不会跟任何用户编写的包冲突。每个你编写的顶层包都被当作时_root_ 包的成员。因此_root_.launch.Booster3 可以访问Booster3 。

5.2 导入

1. 在Scala 中，可以通过import 子句导入包和包的成员。被导入的项可以通过File 这样的简单名字访问，而不需要在前面加上包名或者对象名，如：java.io.File 。

   xxxxxxxxxx
   package model_a
   ​
   abstract class Fruit(
     val name: String,
     val color: String)
   ​
   object Fruits {
       object Apple extends Fruit("apple","red")
       object Orange extends Fruit("orange","orange")
       val menu = List(Apple,Orange)
   }
   

   使用时可以通过四种方式导入：

   • 导入包本身：

     xxxxxxxxxx
     import java.util.regrex  // 导入 regrex 包
     // 现在可以直接使用 regrex 这个名字了
     ​
     class C {
         val pattern = regrex.Pattern.compile("[0-9]*abc") 
     }
     

   • 导入单个类型：

     xxxxxxxxxx
     import model_a.Fruit
     // 现在可以直接使用 Fruit 这个名字了
     

   • 导入包内的所有成员：

     xxxxxxxxxx
     import model_a._
     // 现在可以直接使用 Fruit, Fruits 等名字了，因为它们都是 model_a 的成员
     

     这种方式与java 稍有不同。java 中是星号* ，而scala 中是下划线_ 。因为scala 中* 是个合法的标识符。

   • 导入对象的所有成员：

     xxxxxxxxxx
     import model_a.Fruits._
     // 现在可以直接使用 Apple,Orange,menu 等名字了，因为它们都是 Fruits 的成员
     

2. Scala 的导入比java 的导入更加通用：

   • 导入可以出现在任何地方，不仅仅是在某个编译单元的最开始。

   • 可以导入任意对象或者包，而不仅仅是导入包。

     xxxxxxxxxx
     def printFruit(fruit: Fruit) = {
         import fruit._                   // 导入可以出现在任何地方，可以导入对象
         println(name + "s are " + color)
     }
     

     这里导入了对象fruit，而不是包。它导入了对象fruit 的所有成员，因此接下来的name,color 等价于fruit.name 和fruit.color 。

   • 可以让你重命名并隐藏某些被导入的成员。做法是：在import 中引入括在花括号中的导入选择器子句，这个子句跟在那个我们要导入成员的对象的后面。

     • 导入限定的成员：

       xxxxxxxxxx
       import Fruits.{Apple,Orange}
       // 这里只会从 Fruits 对象导入 Apple 和 Orange 这两个成员
       

     • 重命名被导入的成员：通过格式 原名 => 新名 ：

       xxxxxxxxxx
       import Fruits.{Apple => XXX,Orange}
       // 这里只会从 Fruits 对象导入 Apple 和 Orange 这两个成员，但是 Apple 重命名为 XXX
       

     • 如果花括号里只有下划线，则等价于导入所有成员：

       xxxxxxxxxx
       import Fruits.{_}
       // 等价于 import Fruits._
       

     • 可以配合 _ 和 =>，此时表示：引入所有成员，但是将某些被导入成员重命名。

       xxxxxxxxxx
       import Fruits.{Apple => XXX, _}
       // 导入 Fruits 对象的所有成员，但是将 Apple 重命名为 XXX
       

     • 可以通过格式 原名 => _ 来排除某个成员的导入。

       xxxxxxxxxx
       import Fruits.{Apple => _, _}
       //除了 Apple 之外， 导入 Fruits 的所有成员
       

3. Scala 导入选择器拥有巨大灵活性，可以包含：

   • 一个简单的名字x，这将把 x 包含在导入的名字集合里。

   • 一个重命名子句 x => y ，这将让名字为x 的成员以名字 y 可见。

   • 一个隐藏子句 x => _，这将会从导入的名字集合里排除 x 。

   • 一个捕获所有的 _ 。这将会导入除了之前规则中提到的成员之外的所有成员。

     如果希望捕获所有，则它必须出现在导入选择器列表的末尾。

   前面给出的简单导入子句可以看作是带有选择器子句的导入子句的缩写。

   如：import p._ 等价于 import p.{_}； 而 import p.n 等价于 import p.{n} 。

4. Scala 对每个程序都隐式添加了一些导入。本质上，这就好像是为每个.scala 源码文件的顶部都添加了三行导入子句：

   xxxxxxxxxx
   import java.lang._  // java.lang 包的全部内容
   import scala._      // scala 包的全部内容
   import Predef._     // Predef 对象的全部内容
   

   • java.lang 包包含了标准的Java 类。由于 java.lang 是隐式导入的，因此可以直接写 Thread，而不是 java.lang.Thread 。

   • scala 包包含了Scala 的标准类库。由于scala 是隐式导入的，因此可以直接写 List，而不是 scala.List 。

   • Predef 对象包含了许多类型、方法和隐式转换的定义，这些定义在scala 程序中经常被用到。

     由于Predef 是隐式导入的，因此可以直接写 assert ，而不是 Predef.assert 。

   • Scala 对这三个子句进行了一些特殊处理，后导入的会遮挡前面的。

     如：scala 包和 java 1.5 版本以后的 java.lang 包都定义了 StringBuilder类。由于 scala 的导入遮挡了 java.lang 的导入，因此 StringBuilder 这个名字会引用到 scala.StringBuilder，而不是 java.lang.StringBuilder 。

5.3 包对象

1. 可以添加到包里的代码有类、特质、孤立对象之外，还可以添加其它代码：任何能够放在class level 的定义，都能够放在package level 。

2. 如果你有某个希望在整个包都能用的helper 方法，可以将其放在包的顶层。具体做法是：将其定义放在包对象package object中 。

   每个包都允许有一个包对象，任何被放在包对象里的定义都被当作这个包本身的成员。

3. 包对象的语法和花括号”打包“很像，区别是包对象包含了一个object 关键字。包对象的花括号括起来的部分可以包含任何你希望添加的定义。

   • 任何包的任何其他代码都可以像引入类一样引入这些方法。
   • 包对象经常用于包级别的类型别名和隐式转换。
   • 顶层scala 包也有一个包对象，其中的定义对所有Scala 代码都可用。

   xxxxxxxxxx
   // 位于文件 p1/package.scala 中
   package object p1 {
       def printFruit(fruit: Fruit) = {
           import fruit._
           println(name + "s are " + color)
       }
   }
   ​
   // 位于文件 p2/package.scala 中
   package p2
   import p1.printFruit
   /* 其它代码 */
   

4. 包对象会被编译成名为package.class 的类文件，该文件位于它增强的包的对应目录下。

   源文件最好能保持相同的习惯，即：包对象的源码放在包名目录下的一个叫package.scala 的文件中。

五、隐式类型转换

1. Scala 支持隐式类型转换：这是一个定义为implicit 的方法。

   xxxxxxxxxx
   class C(n:Int,s:String)
   {
       val num:Int = n
       val name:String = s
   }
   implicit def CtoInt(c:C) = c.num  // 隐式类型转换
   val c = new C(123,"Hello")
   println(1+c)  // 输出：124
   

   为了让隐式类型转换能够工作，它需要定义在作用域内。

2. 由于隐式类型转换是由编译器隐式的作用在代码上，而不是在代码中显式的给出。因此对于使用方程序员，究竟哪些地方隐式转换起了作用并不是那么直观。因此这会阻碍代码的可读性。

3. 隐式定义指的是我们允许编译器插入程序以解决类型错误的定义。例如：如果 x + y 无法通过编译，则编译器可能将它修改为 convert(x) + y ，其中 convert 是某种可用的隐式转换。

   如果 convert 是一种简单的转换函数，则不应该在代码里显式写出从而有助于澄清程序的主要逻辑。

4. 隐式转换规则：

   • 标记规则：只有标记为 implicit 的定义才可用。

     关键字 implicit 用于标记哪些声明可以被编译器用作隐式定义。可以用 implicit 来标记任何变量、函数或者对象的定义。编译器只会从那些显式标记为 implicit 的定义中选择。

   • 作用域规则：被插入的隐式转换必须是当前作用域的单个标识符，或者跟隐式转换的源类型或者目标类型有关联。

     Scala 编译器只会考虑那些在当前作用域内的隐式转换，因此必须以某种方式将隐式转换定义引入到当前作用域。

     除了一个例外，隐式转换在当前作用域中必须是单个标识符。如对于 x + y，编译器不会插入someVar.convert(x) 这种形式的转换，你必须显式导入 import someVar.convert 来使用单个标识符 convert 。事实上对于类库而言，通常提供一个包含了一些有用的隐式转换的 Preamble 对象，这样使用这个类库的代码就可以通过 import Preamble._ 来访问该类库的隐式类型转换。

     但是这个规则有一个例外：编译器还会在隐式转换的源类型或者目标类型的伴生对象中查找隐式定义。我们不需要在程序中import 伴生对象。

   • 每次一个规则：每次只能有一个隐式定义被插入。

     如：编译器绝对不会将 x + y 重写为 convert1(convert2(x)) + y 。

     可以通过让隐式定义包含隐式参数的方式绕过这个限制。

   • 显式优先原则：只要代码按照编写的样子能够通过类型检查，就不要尝试隐式定义。

     编译器不会对已经可以工作的代码做修改。

     这个规则必然可以得出结论：我们总是可以将隐式标识符替代成显式的，代码会更长但是歧义更少。这是一种折衷：

     • 如果代码看上去重复啰嗦，则隐式转换可以减少这种繁琐的代码
     • 如果代码看上去生硬晦涩，则可以显式的插入转换

     究竟是否采用隐式转换，这是代码风格问题。

5. 隐式转换可以使用任何名称。隐式转换的名称只有两种情况下重要：

   • 当你希望显式给出转换时
   • 当决定程序的哪些位置都有哪些隐式转换可用时。

   考虑一个带有两个隐式转换的对象：

   xxxxxxxxxx
   object MyConversions {
     implicit def stringWrapper(s :String) : IndexedSeq[Char] = ...
     implicit def intToString(x :Int): String = ...
   }
   

   如果你只是希望使用 stringWrapper 转换，并不希望使用 intToString 转换，则可以通过仅仅引入其中一个来实现：

   xxxxxxxxxx
   import MyConversions.stringWrapper
   

   在这里，隐式转换的名字很重要，因为只有这样才可以有选择的引入一个而不引入另外一个。

6. Scala 会在三个地方使用隐式定义：

   • 转换到一个预期的类型：在预期不同类型的上下文中使用某个类型。如你有一个String，但是你要将它传递给一个要求 IndexedSeq[Char] 的方法。

   • 对某个（成员）选择接收端（即字段、方法调用）的转换：适配接收端的类型。

     如 "abc".exists 将转换为 stringWrapper("abc").exists ，因为 exists 方法在 String 上不可用，但是在 IndexedSeq 上是可用的。

   • 隐式参数：用于给被调用函数提供更多关于调用者诉求的信息。

     隐式参数对于泛型函数尤其有用，被调用的函数可能完全不知道某个或某些入参的类型。

5.1 转换到一个预期的类型

1. 每当编译器看到一个 X 而它需要一个 Y 的时候，他就会查找一个能将 X 转换为 Y 的隐式转换。

2. 将 Double 隐式转换成Int 可能并不是一个好主意，因为这会悄悄的丢掉精度。我们更推荐从一个受限的类型转换成更通用的类型。

   如：scala.Predef ，它是每个 Scala 程序都会隐式导入的对象，它定义了一些从 “更小” 的数值类型到 “更大” 的数值类型的隐式转换。如 scala.Predef 定义了：

   xxxxxxxxxx
   implicit def int2double(x: Int): Double = x.toDouble
   

   Scala 中并没有什么强制类型转换，所有的类型转换都是通过这种隐式转换或者显式转换来实现的。

5.2 转换接收端

1. 隐式转换还能应用于方法调用的接收端，也就是调用方法的那个对象。这种隐式转换有两个用途：

   • 允许我们更平滑的将新类集成到已有的类继承关系图谱当中。
   • 支持在语言中编写（原生的）领域特定语言 DSL 。

2. 即如你写了 obj.doIt，而 obj 并没有一个 doIt 的成员，编译器会在放弃之前尝试插入转换。

   这里转换需要应用于接收端，也就是 obj。编译器会装作 obj 的预期“类型”为“拥有“名字为 doIt 的成员。这个”类型“ 并不是一个普通的 scala 类型，不过从概念上讲它是存在的。

3. 接收端转换的一个主要用途是：让新类型和已有类型的集成更为平滑。

   如定义了新类型：

   xxxxxxxxxx
   class MyCls(n: Int, d: Int){
     ...
     def + (that: MyCls): MyCls = ...
     def + (that: Int): Mycls = ...
   }
   

   则我们可以通过以下调用：

   xxxxxxxxxx
   val obj = new MyCls(1,2)
   obj + 1
   

   但是无法通过以下调用：

   xxxxxxxxxx
   1 + obj
   

   因为作为接收端的 1 并没有一个合适的方法 + (MyCls) 。为了允许这样的操作，我们可以定义一个 Int 到 MyCls 的隐式转换：

   xxxxxxxxxx
   implicit def intToMyCls(x: Int) = new MyCls(x, 1)
   1 + obj
   

   背后的原理：Scala 编译器首先尝试对表达式 1 + obj 进行类型检查。虽然 Int 有多个 + 方法，但是没有一个是接收参数为 MyCls 类型的，因此类型检查失败。接着编译器检查一个从 Int 到另一个拥有可以应用 MyCls 参数的 + 方法的类型的隐式转换，编译器将会找到intToMyCls 隐式转换并执行：

   xxxxxxxxxx
   intToMyCls(1) + obj
   

4. 隐式转换的另一个主要用途是模拟添加新的语法。

   考虑创建一个 Map ：

   xxxxxxxxxx
   Map("a" -> 1, "b" -> 2)
   

   这里的 -> 并不是 scala 的语法特性，而是 ArrowAssoc 类的方法。ArrowAssoc 是一个定义在 scala.Predef 对象这个 scala 标准前导preamble 代码里的类。当写下 "a" -> 1 时，编译器将插入一个从 "a" 到 ArrowAssoc 的转换。

   下面是相关定义：

   xxxxxxxxxx
   package scala
   object Predef{
     class ArrowAssoc[A](x: A){
       def -> [B](y: B): Tuple2[A,B] = Tuple2(x,y)
     }
     implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A] = new ArrowAssoc(x)
     ...
   }
   

   这种“富包装类”模式在给编程语言提供 syntax-like 的扩展的类库中非常常见。

   • 只要你看到有人调用了接受类中不存在的方法，那么很可能使用了隐式转换。
   • 如果你看到名为 RichSomething 的类（如：RichInt,RichBoolean），那么这个类很可能对 Something 类型增加了 syntax-like 的方法。

   富包装类的应用场景广泛，它可以让你做出以类库形式定义的内部 DSL 。

5. Scala 2.10 引入隐式类来简化富包装类的编写。隐式类是一个以 implicit 关键字开始的类。对这样的类，编译器会生成一个从类的构造方法参数到类本身的隐式转换。

   如：

   xxxxxxxxxx
   case class Rect(width: Int, height: Int)
   implicit class RectMaker(width: Int){
     def x(height: Int) = Rect(width, height)
   }
   val myRect = 3 x 4
   

   其调用过程为：

   • 由于 Int 类型没有一个名为 x 的方法，因此编译器会查找一个从 Int 到某个有该方法的类型的隐式转换。
   • 编译器将找到类 RectMaker并执行转换，然后调用 RectMaker 的 x 方法。

   并不是所有的类都可以作为隐式类。

   • 隐式类不能是样例类。

   • 隐式类的构造方法必须有且仅有一个参数。

   • 隐式类必须存在于另一个对象、类或者特质里。

     在实际应用中，只要是用隐式类作为富包装类来给某个已有的类添加方法，该限制不是问题。