Scala学习之包、引用和访问修饰符

本文主要内容：
1、包
2、引用
3、访问修饰符

1、包

Scala采用了Java完整的包机制，不同点是Scala可以进行包的嵌套，而Java只能从包的层级的根开始。

package launch{
  class Booster3
}

package bobsrockets{
  package navigation{
    package launch{
      class Bosster1
    }
    class MissionControl{
      val booster1 = new launch.Booster1
      val booster2 = new bobsrockets.launch.Booster2
      //_root_代表顶层包
      val booster3 = new _root_.launch.Booster3
    }
  }
  package launch{
    class Booster2
  }
}

2、引用

我们来看个例子：

package aaa
abstract class Fruit{
 val name:String, val color:String
}
Object Fruits{
  Object Apple extends Fruit("apple","red")
  Object Orange extends Fruit("orange","Orange")
  Object Pear extends Fruit("pear","yellowwish")
  val menu = List(Apple,Orange,Pear)
}

import 子句让包或对象的成员可以直接通过名称访问而不用通过前缀包或对象的名称，比如：

//易于访问Fruit
import aaa.Fruit
//易于访问aaa的所有成员
import aaa._
//易于访问Fruit的所有成员
import aaa.Fruits._

Scala的包引用可以出现在任何地方。

//方法showFruit引用了Fruit的所有成员，之后println就可以直接用其成员
def showFruit(fruit:Fruit){
  import fruit._
  println(name+"s are"+color)
}

Scala的引用还可以重命名或者隐藏成员。

//只引用Fruits里所有成员
import Fruits._
//只引用Fruits里的Apple和Orange
import Fruits.{Apple,Orange}
//只引用Fruits里的Apple和Orange,且将Apple重命名为a
import Fruits.{Apple=>a,Orange}
//引用java.sql包，且重命名为S，这样调用可以直接写出S.Date
import java.{sql=>S}
//引用Fruits所有成员，Apple重命名为a
import Fruits.{Apple=>a,_}
//引用Fruits里的所有水果，除了Apple
import Fruits.{Apple=>_,_}

总结如下：

• 简单名x。把x包含进引用名集。
• 重命名子句x=>y。让名为x的成员以名称y出现。
• 隐藏子句x=>_。把x排除在引用名集外。
• 全包括"_"。引用除了前面字句提到的之外的全体成员。

3、访问修饰符

私有成员(private)

私有成员的处理方式与Java的相同。不同之处是，Scala里，同样的规则还应用在了内部类上。

class Outer{
  class Inner{
    private def f(){println("f")}
    class InnerMost{
      f()
    }
  }
}

在Scala里，(new Inner).f()访问非法，因为f在Inner被声明为private而访问不在类inner之内。相反，在类InnerMost里访问f没有问题，因为这个访问包含在Inner类之内。Java支持两种访问方式，因为它允许外部类访问其内部类的私有成员。

保护成员(protected)

在Scala里，对保护成员的访问也同样比Java严格一些。Scala里，保护成员只允许子类中可以被访问。而在Java中，还允许在同一个包的其他类中进行这种访问。

公开成员

任何没有标记为private或protected的成员都是公开的。公开成员没有显示的修饰符，被其修饰的成员可以在任何地方被访问。

保护的作用域：
Scala里的访问修饰符可以通过限定词强调。格式为private[X]或protected[X]的修饰符表示”直到”X的私有或保护，这里X指代某个所属的包、类或单例对象。

package bobsrockets{
  package navigation{
    private[bobsrockets] class Navigator{
      protected[navigation] def useStarChart(){}
      class LegOfJourney{
        private[Navigator] val distance = 100
      }
      private[this] var speed = 200
    }
  }
  package launch{
    import navigation._
    object Vehicle{
      private[launch] val guide = new Navigator
    }
  }
}

所有的限定词也可以用protected，在此处与private的意思相同。比如C类里的protected[X]修饰符允许C的所有子类及修饰符所属的包、类或对象X访问。

可见性与伴生对象

对于私有或保护访问来说，Scala中，类的所有访问权限对伴生对象开放。我们可以理解类与其伴生对象双方具有完全的可见性。伴生对象中的protected成员是没有意义的，因为单例对象没有任何子类。