【2019-05-24】包和引用

scala代码采用Java代码完整的包机制。

//同一个文件嵌入不同的包
package bobsrockets {
  package navigation {

    // In package bobsrockets.navigation
    class Navigator

    package tests {

      // In package bobsrockets.navigation.tests
      class NavigatorSuite
    }
  }
}

引用，scala里，包和其他成员可以用import引用，之后的引用可以用File这样的简单名访问。

package bobsdelights

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", "yellowish")
  val menu = List(Apple, Orange, Pear)
}

object Ex5 {
  // easy access to Fruit
  import bobsdelights.Fruit
  
  // easy access to all members of bobsdelights
  import bobsdelights._
  
  // easy access to all members of Fruits
  import bobsdelights.Fruits._
  def showFruit(fruit: Fruit) {
//引用规范的（不是单例）对象的成员
    import fruit._
    println(name +"s are "+ color)
  }
  def main(args: Array[String]) {
    println("Apple [" + Apple + "]")
    showFruit(Fruits.Apple)
  }
}


//引用包名
//访问java.util.regex包的Pattern单例对象
object Ex6 {
  import java.util.regex
  class AStarB {
    // Accesses java.util.regex.Pattern
    val pat = regex.Pattern.compile("a*b")
  }
  def main(args: Array[String]) {
    println("(new AStarB).pat [" + (new AStarB).pat + "]")
  }
}

scala灵活引用
（1）可以出现在任何地方
（2）可以指的是（单例或正统的）对象及包
（3）可以重命名或隐藏一些被引用的成员

隐式引用
scala为每个程序隐式地添加了一些引用

import java.lang._ // everything in the java.lang package
import scala._     // everything in the scala package
import Predef._    // everything in the Predef object

访问修饰符
包、类或对象的成员可以访问修饰符private和protected做标记。这些修饰符把对成员的访问限制在代码确定的区域中。

//私有成员
class Outer {
  class Inner {
    private def f() { println("f") }
    class InnerMost {
      f() // OK
    }
  }
  (new Inner).f() // error: f is not accessible
}
//保护成员
package p {
  class Super {
    protected def f() { println("f") }
  }
  class Sub extends Super {
    f()
  }
  class Other {
    (new Super).f()  // error: f is not accessible
  }
}
//保护的作用域
//访问修饰符可以通过限定词强调，格式为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
   }
 }
}

可见性和伴生对象
scala里没有静态成员，作为替代，可以拥有包含成员的单例的伴生对象。

//Rocket对象是Rocket类的伴生
//访问伴生类和对象的私有成员
class Rocket {
  import Rocket.fuel
  private def canGoHomeAgain = fuel > 20
}

object Rocket {
  private def fuel = 10
  def chooseStrategy(rocket: Rocket) {
    if (rocket.canGoHomeAgain)
      goHome()
    else
      pickAStar()
  }
  def goHome() {}
  def pickAStar() {}
}