Scala--包

2016-03-30

Scala

包
基本结构
引入
1. 隐式引入

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

包

基本结构

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

/**
 * 包
 * 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》中的事例：

/**
 * 找不到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]

串联式包语句

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

package com.horstmann.horstmann {

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

文件顶部标记

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

package com.xiaoxiaomo.demo
package ch07
class demo{
    //info
}


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

    }
}

引入

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

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包。

上一篇：Java-类文件结构

下一篇：Scala--对象