本文主要內容：
1、包
2、引用
3、訪問修飾符

1、包

Scala採用了Java完整的包機制，不同點是Scala可以進行包的巢狀，而Java只能從包的層級的根開始。

package launch{
  class Booster3
}

package bobsrockets{
  package navigation{
    package launch{
      class Bosster1
    }
    class MissionControl{
      val booster1 = new launch.Booster1
      val booster2 = new
 
 bobsrockets.launch.Booster2
      //_root_代表頂層包
      val booster3 = new _root_.launch.Booster3
    }
  }
  package launch{
    class Booster2
  }
}

2、引用

我們來看個例子：

package aaa
abstract class Fruit{
 val name:String, val color:String
}
Object Fruits{
  Object Apple extends Fruit("apple","red")
  Object Orange extends
 
 Fruit("orange","Orange")
  Object Pear extends Fruit("pear","yellowwish")
  val menu = List(Apple,Orange,Pear)
}

import 子句讓包或物件的成員可以直接通過名稱訪問而不用通過字首包或物件的名稱，比如：

//易於訪問Fruit
import aaa.Fruit
//易於訪問aaa的所有成員
import aaa._
//易於訪問Fruit的所有成員
import aaa.Fruits._

Scala的包引用可以出現在任何地方。

//方法showFruit引用了Fruit的所有成員，之後println就可以直接用其成員
 

def showFruit(fruit:Fruit){
  import fruit._
  println(name+"s are"+color)
}

Scala的引用還可以重新命名或者隱藏成員。

//只引用Fruits裡所有成員
import Fruits._
//只引用Fruits裡的Apple和Orange
import Fruits.{Apple,Orange}
//只引用Fruits裡的Apple和Orange,且將Apple重新命名為a
import Fruits.{Apple=>a,Orange}
//引用java.sql包，且重新命名為S，這樣呼叫可以直接寫出S.Date
import java.{sql=>S}
//引用Fruits所有成員，Apple重新命名為a
import Fruits.{Apple=>a,_}
//引用Fruits裡的所有水果，除了Apple
import Fruits.{Apple=>_,_}

總結如下：

• 簡單名x。把x包含進引用名集。
• 重新命名子句x=>y。讓名為x的成員以名稱y出現。
• 隱藏子句x=>_。把x排除在引用名集外。
• 全包括"_"。引用除了前面字句提到的之外的全體成員。

3、訪問修飾符

私有成員(private)

私有成員的處理方式與Java的相同。不同之處是，Scala裡，同樣的規則還應用在了內部類上。

class Outer{
  class Inner{
    private def f(){println("f")}
    class InnerMost{
      f()
    }
  }
}

在Scala裡，(new Inner).f()訪問非法，因為f在Inner被宣告為private而訪問不在類inner之內。相反，在類InnerMost裡訪問f沒有問題，因為這個訪問包含在Inner類之內。Java支援兩種訪問方式，因為它允許外部類訪問其內部類的私有成員。

保護成員(protected)

在Scala裡，對保護成員的訪問也同樣比Java嚴格一些。Scala裡，保護成員只允許子類中可以被訪問。而在Java中，還允許在同一個包的其他類中進行這種訪問。

公開成員

任何沒有標記為private或protected的成員都是公開的。公開成員沒有顯示的修飾符，被其修飾的成員可以在任何地方被訪問。

保護的作用域：
Scala裡的訪問修飾符可以通過限定詞強調。格式為private[X]或protected[X]的修飾符表示”直到”X的私有或保護，這裡X指代某個所屬的包、類或單例物件。

package bobsrockets{
  package navigation{
    private[bobsrockets] class Navigator{
      protected[navigation] def useStarChart(){}
      class LegOfJourney{
        private[Navigator] val distance = 100
      }
      private[this] var speed = 200
    }
  }
  package launch{
    import navigation._
    object Vehicle{
      private[launch] val guide = new Navigator
    }
  }
}

所有的限定詞也可以用protected，在此處與private的意思相同。比如C類裡的protected[X]修飾符允許C的所有子類及修飾符所屬的包、類或物件X訪問。

可見性與伴生物件

對於私有或保護訪問來說，Scala中，類的所有訪問許可權對伴生物件開放。我們可以理解類與其伴生物件雙方具有完全的可見性。伴生物件中的protected成員是沒有意義的，因為單例物件沒有任何子類。