隱式引用(Implicit Import)

Scala會自己主動為每一個程序加上幾個隱式引用，就像Java程序會自己主動加上java.lang包一樣。

Scala中。下面三個包的內容會隱式引用到每一個程序上。所不同的是。Scala還會隱式加進對Predef的引用。這極慷慨便了程序猿的工作。

import java.lang._ // in JVM projects, or system namespace in .NET
import scala._     // everything in the scala package
import Predef._    // everything in the Predef object
 

上面三個包，包括了經常使用的類型和方法。java.lang包包括了經常使用的java語言類型，假設在.NET環境中，則會引用system命名空間。相似的，scala還會隱式引用scala包，也就是引入經常使用的scala類型。

請註意
上述三個語句的順序藏著一點玄機。

我們知道，通常，假設import進來兩個包都有某個類型的定義的話，比方說，同一段程序。即引用了’scala.collection.mutable.Set’又引用了’import scala.collection.immutable.Set’則編譯器會提示無法確定用哪一個Set。

這裏的隱式引用則不同，假設有同樣的類型。後面的包的類型會將前一個隱藏掉。

比方。java.lang和scala兩個包裏都有StringBuilder。這樣的情況下，會使用scala包裏定義的那個。java.lang裏的定義就被隱藏掉了，除非顯示的使用java.lang.StringBuilder。

Predef對象

Predef提供經常使用函數

包scala中的Predef對象包括了很多實用的方法。比如，Scala源文件裏寫下println語句，實際調用的是Predef的println。Predef.println轉而調用Console.println，完整真正的工作。

def print(x: Any) = Console.print(x)
def
 
 println() = Console.println()
def println(x: Any) = Console.println(x)
def printf(text: String, xs: Any*) = Console.print(text.format(xs: _*))

斷言函數assert以及相關函數也是在Predef中定義的：

/** Tests an expression, throwing an `AssertionError` if false.
*  Calls to this method will not be generated if `-Xelide-below`
*  is at least `ASSERTION`.
*
*  @see elidable
*  @param assertion   the expression to test
*/
@elidable(ASSERTION)
def assert(assertion: Boolean) {
if (!assertion)
  throw new java.lang.AssertionError("assertion failed")
}


/** Tests an expression, throwing an `AssertionError` if false.
*  Calls to this method will not be generated if `-Xelide-below`
*  is at least `ASSERTION`.
*
*  @see elidable
*  @param assertion   the expression to test
*  @param message     a String to include in the failure message
*/
@elidable(ASSERTION) @inline
final def assert(assertion: Boolean, message: => Any) {
if (!assertion)
  throw new java.lang.AssertionError("assertion failed: "+ message)
}

Predef定義類型別名

Predef是一個對象（Object）。這個對象中，定義一些類型別名。如：

scala.collection.immutable.List         // to force Nil, :: to be seen.

type Function[-A, +B] = Function1[A, B]

type Map[A, +B] = immutable.Map[A, B]
type Set[A]     = immutable.Set[A]
val Map         = immutable.Map
val Set         = immutable.Set

如今我們知道了。直接使用集合時，如List。Map。Set。用到的是immutable包中的對象。這是在Predef裏定義的。

隱式轉換

Predef對象定義了經常使用的隱式轉換，如：

implicit final class any2stringadd[A](private val self: A) extends AnyVal {
  def +(other: String): String = String.valueOf(self) + other
}

該隱式轉換。給AnyVal的全部子類型都加上了+(other: String): String方法，便於在打印或其它字符串操作時，增加其它的值類型。

再如：

@inline implicit def augmentString(x: String): StringOps = new StringOps(x)
@inline implicit def unaugmentString(x: StringOps): String = x.repr

該隱式轉換，使得我們能夠自由的對String使用StringOps的方法。
同理，數值類型的富包裝（Rich Wrapper）也是這樣實現的。

Scala程序猿能夠較少關心裝箱和拆箱操作，這也是因為Predef對象裏定義了Scala值類型與java基本類型直接的隱式轉換。

implicit def byte2Byte(x: Byte)           = java.lang.Byte.valueOf(x)
implicit def short2Short(x: Short)        = java.lang.Short.valueOf(x)
implicit def char2Character(x: Char)      = java.lang.Character.valueOf(x)
implicit def int2Integer(x: Int)          = java.lang.Integer.valueOf(x)
implicit def long2Long(x: Long)           = java.lang.Long.valueOf(x)
implicit def float2Float(x: Float)        = java.lang.Float.valueOf(x)
implicit def double2Double(x: Double)     = java.lang.Double.valueOf(x)
implicit def boolean2Boolean(x: Boolean)  = java.lang.Boolean.valueOf(x)

implicit def Byte2byte(x: java.lang.Byte): Byte             = x.byteValue
implicit def Short2short(x: java.lang.Short): Short         = x.shortValue
implicit def Character2char(x: java.lang.Character): Char   = x.charValue
implicit def Integer2int(x: java.lang.Integer): Int         = x.intValue
implicit def Long2long(x: java.lang.Long): Long             = x.longValue
implicit def Float2float(x: java.lang.Float): Float         = x.floatValue
implicit def Double2double(x: java.lang.Double): Double     = x.doubleValue
implicit def Boolean2boolean(x: java.lang.Boolean): Boolean = x.booleanValue

關於裝箱（Boxing）和拆箱（Unboxing）
熟悉Java或C#等語言的讀者會知道，裝箱是指將原始類型轉換成引用類型（對象）。用於須要對象的操作，而拆箱，則是把對象轉換成原始類型，用於須要原始類型的場景。
因為數值類型本身已經是類對象，因此Scala裏不須要裝箱（boxing）和拆箱（unboxing）操作。

當然，Scala代碼終於會執行在JVM上，所以實際上，始終會有裝箱成Scala類對象，和拆箱成Java原始值類型的操作，可是這些操作是透明的，程序猿不須要關心（實際上，這是由定義在Predef中的隱式轉換完畢的）。

參考資料

Predef官方標準庫文檔
隱式引用（Implicit Import）和Predef

轉載請註明作者Jason Ding及其出處
GitCafe博客主頁(http://jasonding1354.gitcafe.io/)
Github博客主頁(http://jasonding1354.github.io/)
CSDN博客(http://blog.csdn.net/jasonding1354)
簡書主頁(http://www.jianshu.com/users/2bd9b48f6ea8/latest_articles)
Google搜索jasonding1354進入我的博客主頁

【Scala】Scala的Predef對象