Scala--包

  主要作用就是用来管理类。给类划分一个自己的空间,这样即使相同的文件只要在不同的包名下也是可以。

基本结构

包下面可以嵌套包,下面写一个,PackageTest类和ObjectTest对象,让后把它放到com.xiaoxiaomo.demo.ch07.test下,那我们来看一下scala包结构和java的一些不同写法,如下实例1代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
* 包
* Created by xiaoxiaomo on 2016/3/30.
*/

package com.xiaoxiaomo.demo.ch07{
package test{

//类在:com.xiaoxiaomo.demo.ch07.test下
class PackageTest {
//对象
object ObjectTest{
//方法
def test( num : Int ) {
println("num:"+num)
}
}
}

object ObjectTest{
def ObjTestMethod{
println("Hello!")
}
}

package test2{
object ObjTestMethod2{
//可以直接调用上级方法
ObjectTest.ObjTestMethod
}
}
}
}

包结构可以嵌套,如上例中定义了两级嵌套结构,等价于:com.xiaoxiaomo.demo.ch07.test

作用域

作用域同样支持嵌套,命名空间下级包可以直接访问上层作用域的对象或类,例如上例中的包test2可以访问它的上级包的类或对象而无须引入。

  • 作用域引发的一个问题

下面看看一个《快学Sacla》中的事例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
* 找不到scala.collection
* Created by xiaoxiaomo on 2016/3/30.
*/

package com {
package horstmann {
package impatient {

//即使引入包名
import scala.collection.mutable

class Manager {
// 因为scala包总是被引入,所以下面的collection包实际是指scala.collection
val subordinates = new collection.mutable.ArrayBuffer[String]
}
}
}
}

//如果再有一个包这样定义,上面“mutable”任然会报错
//new collection.mutable.ArrayBuffer[String]
package com {
package horstmann {
package collection {
//....
}
}
}

在Java中包名是绝对的,总是从包层级的最顶端开始,所以就不会出现上例中的问题。在Scala中包名是相对的,相对的包名可能会带来问题。所以解决办法就是使用绝对包名,以_root_开始。

1
val subordinates = new _root_.scala.collection.mutable.ArrayBuffer[String]

串联式包语句

上面的问题,主要来源于,包名相对的问题,如果我们使用串联的包名也是同样可以避免的。
如下代码:

1
2
3
4
5
6
package com.horstmann.horstmann {

class Manager {
val subordinates = new collection.mutable.ArrayBuffer[String]
}
}

文件顶部标记

如果文件中的所有代码都属于同一个包,在文件顶部标记包是更好的做法。这样看着代码模块化一点,并且不需要包含在括号之中,如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.xiaoxiaomo.demo
package ch07
class demo{
//info
}


// 上面的等同于
package com.xiaoxiaomo.demo {
package ch07 {
class demo{
//info
}

}
}

引入

引入,import即引入包名的命名空间。如下代码,去调用实例1中的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com {

import com.xiaoxiaomo.demo.ch07.test.{PackageTest, ObjectTest}

object PackageCom{
//test
def main(args: Array[String]) {

//调用com.xiaoxiaomo.demo.ch07.test下

//1、ObjectTest的ObjTestMethod方法
ObjectTet.ObjTestMethod ;
//2、PackageTest类的ObjectTest对象的test方法
new PackageTest().ObjectTest.test(888)
}
}
}

import语句可以出现在任何地方,而不是只能在文件顶部;
多个成员可以使用“{A,B}”;
引入包内所用成员使用“_”,在Java中使用*,eg:java.util.
scala引入还可以进行重命名,使用=>。eg:import java.util.{HashMap=>JavaHashMap}
还可以进行隐藏,eg:import java.util.{HashMap=>
,_},此时HashMap被隐藏。这种可以用于如果发现引入包中存在相同引入,可以隐藏不使用的。

隐式引入

隐式引入,就是指Scala总会引入java.lang._scala._Predef._

1、java.lang总会被引入;
2、然后引入scala包,scala包将会覆盖java.lang中的内容;
3、最后引入Predef包。

当前网速较慢或者你使用的浏览器不支持博客特定功能,请尝试刷新或换用Chrome、Firefox等现代浏览器