Scala教程(七)package实战

Scala教程(七)package实战

1 包package

1.1 引用包

Scala的代码采用了Java平台的完整的包机制，可以通过把package子句放在文件顶端的方式把整个文件内容放进包里。指定了package全文档的作用域

// 全文档的作用域
package com.scala.base

1.2 定义包

// 定义包
package hadoop {}

1.3 嵌套包

    // 定义包
    package hadoop {
      package navigation {
          // 在hadoop.navigation包中
          class Navigator
      }
      package launch {
          class Booster{
            /*
             * 不用写 var nav = new hadoop.navigation.Navigator();
             * 不用写 var nav = new com.scala.base.hadoop.navigation.Navigator();        
             */
              val nav = new navigation.Navigator
          }
      }
    }

1.4 链式结构包

// 包的链接形式结构
package sprak.navigation {
// 定义抽象类
abstract class Navigator{
// 定义抽象方法
def act;
}

// Scala包是可以嵌套的
package tests{
// 在sprak.navigation.tests包中
class NavigatorSuite
}

// 实现包
package impls {
// Navigator类所在的包com.scala.base.sprak.navigation.Navigator
class Action extends Navigator{
def act = {
println("===Action===");
}
}
}
}

1.5 包对象

包对象可以包含类、对象和特征，但是不能包含函数的定义。

    // 包的链接形式结构
    package sprak.navigation {
      // 定义抽象类
      abstract class Navigator{
          // 定义抽象方法
          def act;
      }
      
      // Scala包是可以嵌套的
      package tests{
          // 在sprak.navigation.tests包中
          class NavigatorSuite
      }
      
      // 实现包
      package impls {
          // Navigator类所在的包com.scala.base.sprak.navigation.Navigator
          class Action extends Navigator{
               def act = {
                   println("===Action===");
               }
          }
      }
    }

1.6 隐式引用的包

Scala隐式地添加了一些引用到每个程序中。本质上，就好象下列的三个引用子句已经被加载了每个以“.scala”为扩展名的源文件的顶端：

    /*
     * Scala隐式引用的包
     * _下划线表示所有的东西，和Java中*作用一样。
     */
    import java.lang._    // java.lang包的所有的东西
    import scala._        // scala包下所有的东西
    import Predef._       // Predef对象所有的东西

1.7 包的访问修饰符

package可以用访问修饰符private和protected做标记。这些修饰符把对成员的访问限制在代码确定的作用域中。

package com.scala.base

package spark
package navigation {
// 只允许[packageName] <= 可访问
private[spark] class Navigator {
/* protected[navigation]
* Navigator类可用
* Navigator子类可用
* 当前com.scala.base.spark.navigation包可访问
*/
protected[navigation] def useStarChart(){}
class LegOfJourney {
// 对内部的成员都是可见的
private[Navigator] val distance = 100;
}
// 被private[this]标记的定义仅能在包含了定义的同一个对象中被访问。
// 这种定义被称为对象私有：object-private。
private[this] var speed = 200;
}
}

package launch {
// 引用navigation包下所有的属性及方法
import navigation._
object Vehicle {
// com.scala.base.spark.launch包中所有的作用域都可以访问 guide属性
private[launch] val guide = new Navigator;
}
}

没有修饰符	公开访问
private[spark]	在外部包中访问
private[navigation]	与Java的包可见度相同
private[Navigator]	与Java的private相同
private[LegOfJourney]	与Scala的private相同
private[this]	仅在同一个对象中可以访问

1.8 可见度和伴生对象

Java里，静态成员和实例成员属于同一个类，因此访问修饰符可以统一地应用在他们之上。你已经知道在Scala里没有静态成员；代之以可以拥有包含成员的仅存在一个的伴生对象。

// 伴生类
// 伴生类和伴生对象可以时访问
class PackageOps_Advanced{
import PackageOps_Advanced.power
private def canMakeItTrue = power > 10001
}

// 伴生对象
// 伴生类和伴生对象可以时访问
object PackageOps_Advanced {
private def power = 10000;
def makeItTrue(p:PackageOps_Advanced):Boolean = {
// 调用伴生类canMakeItTrue的方法
var result = p.canMakeItTrue;
return result;
}
}

--以上为package实战的内容,谢谢大家对我的关注。
——厚积薄发(yuanxw)