《快学Scala》第7章 包和引入 练习

1. 编写示例程序，展示为什么

package com.horstmann.impatient

不同于

package com

package horstmann

package impatient

//假如定义有这样的一个包
package com {
  object Test1 {}
  package horstmann {
    object Test2 {}
    package impatient {
      object Test3 {}
    }
  }
}

package com
package horstmann
package impatient

object Test4 {
  val x = Test1 //可访问
  val y = Test2 //可访问
  val z = Test3 //可访问
}

package com.horstmann.impatient

object Test4 {
  val x = Test1 //不可访问
  val y = Test2 //不可访问
  val z = Test3 //可访问
}

2. 编写一段让你的Scala朋友们感到困惑的代码，使用一个不在顶部的com包。

package com.horstmann.impatient
object Funny {
  def foo {
    println("top level com")
  }
}

package scala.com.horstmann.impatient
object Funny {
  def foo {
    println("not a top level com")
  }
}

import scala._ //如果有这句，则输出not a top level com，没有则输出top level com
object ScalaApp {
  def main(args: Array[String]) {
    com.horstmann.impatient.Funny.foo
  }
}

3. 编写一个包random，加入函数nextInt():Int、nextDouble: Double和setSeed(seed:Int):Unit。生成随机数的算法使用线性同余生成器：

后值=(前值 x a + b) mod 2^n

其中，a=1664525，b=1013904223，n=32，前值的初始值为seed。

/**
 * Created by Ibuki Suika on 2014/5/26.
 */

package random {
  package object random {
    private val a: Long = 1664525
    private val b: Long = 1013904223
    private val n: Long  = 2147483647
    private var prev: Long = 1

    def setSeed(seed: Int) {
      prev = seed
    }

    def nextInt() = {
      prev = (prev * a + b) % n
      prev.toInt
    }

    def nextDouble() = {
      nextInt.toDouble / n
    }
  }
}

object ScalaApp {
  def main(args: Array[String]) {
    import random._
    random.setSeed(9999)
    for (_ <- 1 to 10) {
      println(random.nextInt())
    }
    for (_ <- 1 to 10) {
      println(random.nextDouble())
    }
  }
}

4. 在你看来，Scala的设计者为什么要提供package object语法而不是简单地让你将函数和变量添加到包中呢？

这是因为Java虚拟机的局限

5. private[com] def giveRaise(rate:Double)的含义是什么？有用吗？

限制giveRaise函数在com包内可见

6. 编写一段程序，将Java哈希映射中的所有元素拷贝到Scala哈希映射。用引入语句重命名这两个类。

/**
 * Created by Ibuki Suika on 2014/5/26.
 */

import scala.collection.JavaConversions.mapAsScalaMap
import java.util.{HashMap => JavaHashMap}
import scala.collection.mutable.{Map =>ScalaHashMap}

object ScalaApp {
  def main(args: Array[String]) {
    val m1 = new JavaHashMap[String,Int]()
    m1.put("a", 1)
    m1.put("b", 2)
    m1.put("c", 3)
    val m2: ScalaHashMap[String,Int] = m1
    println(m2.mkString(", "))
  }
}

7. 在前一个练习中，将所有引入语句移动到尽可能小的作用域里。

/**
 * Created by Ibuki Suika on 2014/5/26.
 */


object ScalaApp {
  def main(args: Array[String]) {
    import scala.collection.JavaConversions.mapAsScalaMap
    import java.util.{HashMap => JavaHashMap}
    import scala.collection.mutable.{Map =>ScalaHashMap}
    
    val m1 = new JavaHashMap[String,Int]()
    m1.put("a", 1)
    m1.put("b", 2)
    m1.put("c", 3)
    val m2: ScalaHashMap[String,Int] = m1
    println(m2.mkString(", "))
  }
}

8. 以下代码的作用是什么？这是个好主意吗？

import java._

import javax._

完全引入java和javax包的所有成员，在编写代码时可以使用更短的名称。
从多个源引入大量名称总是让人担心，会增加名称冲突的风险，通过将引入放置在需要这些引入的地方，可以大幅减少可能的名称冲突。

9. 编写一段程序，引入java.lang.System类，从user.name系统属性读取用户名，从Console对象读取一个密码，如果密码不是"secret"，则在标准错误流中打印一个消息，如果密码是“secret”，则在标准输出流中打印一个问候消息。不要使用任何其他引入，也不要使用任何限定词（带句点的那种）。

/**
 * Created by Ibuki Suika on 2014/5/26.
 */

import java.lang.System.getProperty
import java.lang.System.err.{println => perror}

object ScalaApp {
  def main(args: Array[String]) {
    val name = getProperty("user.name")
    print("password:")
    if (readLine() == "secret") {
      println("welcome, " + name)
    } else {
      perror("wrong password")
    }
  }
}

10. 除了StringBuilder，还有哪些java.lang的成员是被scala包覆盖的？

参考文档。