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)