Scala通过不同的包能使用很多类型的表达式，而包的引入在Scala中相当灵活。包是用来管理名称的。
包的定义
在文件顶部，使用package定义包，与java一样。
package cn.sjq.scala
嵌套形式的包定义：
package com{
package horstmann{
package impatient{
class Employee{
// ...
}
}
}
}
Scala的这种写包的方法使用的并不多。Scala写的Play框架使用的较多。
与对象和类的定义不同，同一个包可以定义在多个文件中。
例：
如下代码位于Employee.scala
package com{
package horstmann{
package impatient{
class Employee{
// ...
}
}
}
}
如下代码位于Manager.scala
package com{
package horstmann{
package impatient{
class Manager{
// ...
}
}
}
}
源文件的目录和包没有强制关系。不需要将Employee.class与Manager.scala放在com/horstmann/impatient目录中。
同样的，也可以在同一个文件中定义为多个包：
package com{
package horstmann{
package impatient{
class Employee{
// ...
}
}
}
}
package com{
package horstmann{
package impatient{
class Manager{
// ...
}
}
}
}
作用域规则
包声明链com.horstmann.impatient并不使com与com.horstmann可见。
包声明链也不对包含的包进行声明。即声明com.horstmann并不意味着声明com.horstmann.impatient。
包对象
类成员对于包的可见性
在Java中，没有声明为public、private或protected的类成员在包含该类的包中可见。
scala中，对于包的可见性可以任意定义。
例：
package com.horstmann.impatient.people
class Person{
private [people] def description = “A person with name” +
description对于people包是可见的。
people包下的所有成员，可以使用这个类成员。
也可以将成员的可见度延展到上层包。
package com.horstmann.impatient.people
class Person{
private [impatient] def description = “A person with name” + name
}
例：一个更复杂的示例。
package com{
package python{
private[com] class List{
protected[python] def get(i:Int){}
class ArrayList{
private[ArrayList] def size{}
}
private[this] var size = 0
}
}
package csharp{
import com.python._
object Obj{
private[csharp] val pythonList = new List;
}
}
}
Scala包的引入
Scala使用包，可以在任何地方引入。
例：
class Manager{
import scala.collection.mutable._
val subordinates = new ArrayBuffer[Employee]
}
直接使用
直接在使用该名称时引入：
val Y= scala.collection.mutable.Map( (a1, b1) , (a2, b2) , (a3, b3))
利用import语句引入
import scala.collection.mutable.ArrayBuffer
val C= new ArrayBuffer[T]()
利用import语句引入包的全部成员：
import scala.collection._
这里的“_”相当于Java中的“*”。
引入同一个包中的几个成员：
import scala.collection.{Map,Set}
重命名
当需要引入不同的包中同名的成员时，可以对成员进行重命名。
import scala.collection.mutable.HashMap
import java.util.{ HashMap => JavaHashMap}
隐藏引入
隐藏引入的对象
import java.util.{ HashMap => _, _}
该语句表示，java.util.HashMap 将被隐藏，无法被使用。而java.util中其他的全部成员，都被引入。
自动引入
Scala默认引入以下三个包：
import java.lang._
import scala._
import Predef._
在适当的地方引入适当的包
可以在脚本开头引入。
可以在具体使用前引入。
包的引入是有作用范围的，且跟函数与声明的作用范围是一致的。
例：
import scala.math._
这样就可以使用
sqrt(2)
pow(2,4)
min(3,pi)
Scala没有静态方法。但有单例对象。
通常，一个类对应一个伴生对象。方法与Java的静态方法一样。
Scala文件访问
scala中访问文件需要使用scala.io.Source对象。
例：读取本地文件。
def main(args: Array[String]) {
// 访问文件
val file = Source.fromFile("D:\\scala-test.txt")
for(line <- file.getLines){
println(line)
}
}
若使用：
for(line <- file){
println(line)
}
则不会一行一行的读取数据，而是一个字一个字的读取并输出。
例：读取网络文件。
def main(args: Array[String]) {
// 访问网络URL
val file = Source.fromURL("http://www.baidu.com")
for(line <- file.getLines){
println(line)
}
}