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