Scala學習（七）包和引入

1.包

在Scala中包的做用和Java或C++中相同，比起Java中的package，Scala中支持這樣的package定義：

package com{
    package hyc{
        package test{
            class Hello{
               ...
            }
        }
    }
}

這樣使得你能夠在一個原文件中編寫多個包的程序，而且他們不受文件夾名稱和位置的限制。

2.做用域規則

Scala 每一個嵌套的包有着本身的做用域，而且上層做用域能夠被下層做用域訪問。

package com{
    package hyc{     
         object Hello{
             def out() : Unit = {println("Hello")}
         }
        package test{
            class World{
               def out() : Unit = {Hello.out + " " + println("World")}
            }
        }
    }
}

咱們能夠看到對象Hello的同級包下的World類，能夠直接引用對象Hello的方法。

不過這樣會有一個瑕疵，界定以下代碼：

package com {
    package horstman{
        package impatient{
            class Manager{
                val sub = new collection.mutable.ArrayBuffer[Int]
            }
        }
    }
}

這裏咱們引用了一個特性，那就是scala包老是被引入的，所以collection包老是指向scala.collection。

假定有以下包，可能在另外一個文件中：

package com {
    package horstman{
        package collection{
            ...
        }
    }
}

這樣編譯將會出錯由於此時上面的collection包的引用指向了這裏的com.horstman.collection，裏面並無mutable包，所以報錯。

解決方法是使用絕對包名，在以_root_開始,或者直接不省略scala

package com {
    package horstman{
        package impatient{
            class Manager{
                val sub = new _root_.collection.mutable.ArrayBuffer[Int] //或者val sub = new scala.collection.mutable.ArrayBuffer[Int]
            }
        }
    }
}

3.串聯式包語句

package com.horstman.impatient{
    //com和horstman的成員在這裏不可見
    package people{
        class Person{
            ...
        }
    }
}

這樣的包語句限定了可見成員。

4.文件頂部標記法

package com.horstman.impatient

package people

class Person{
            ...
}

這樣等同於

package com.horstman.impatient{
    package people{
        class Person{
            ...
        }
    }
}

5.包對象

每一個包均可以有一個包對象，包對象的定義以下：

package com.horstman.impatient

//這是一個包對象

package object people{



}

包對象被編譯以後，在會在 包名全路徑.包對象名稱 的包名下 生成package.class 和package$.class 和單例對象同樣。

如何從包對象中取出變量呢？

package com.horstman.impatient
//這是一個包對象
package object people{
    val defaultName = "Name"
}

package people{
    class Person{
        var str = defaultName//從包對象拿到常量
    }
}

6.包可見性

在Java中，沒有被聲明爲public、private或protected的類成員在包含類的包中可見。Scala中能夠經過修飾符達到一樣的效果：

private[package|this]

例如：

package com.horstman.impatient.people

class Person{
    private[people] def name()  println("tom") //也能夠焰斬道上層包private[impatient] def name()  println("tom")

}

7.引入

在Scala中，你能夠用以下方式引入你須要的類或對象。

import a.b.c.A //只導入a.b.c包下的A

import a.b.c._ //導入a.b.c包下的所有

import a.b.c.{A,B} //導入a.b.c包下的A 和B

import a.b.c.{A => MyA} //只導入a.b.c包下的A 並將A重命名爲MyA

import java.util.{HashMap => _ , _} //將java.util.HashMap隱藏，使其不被引入。

Scala中能夠在任意位置聲明import 。

8.隱式引入

每一個Scala程序都是隱式的從以下代碼開始的：

import java.lang._

import scala._

import Predef._

和Java正序同樣java.lang包老是被引入。接下來scala包也被引入，不過方式有些特殊。不像其餘引入，scala引入能夠覆蓋以前的引入。

scala包時默認被引入的，所以在引入scala包時能夠省略scala關鍵字。例如：

import collection.mutable.ArrayBuffer 

等同於

import scala.collection.mutable.ArrayBuffer