1.編寫示例程式展示為什麼
package com.horseman.impatient不同於
package com
package horseman
package impatient

第一種方式中，T3可以訪問T1，T2類
package com{
    class T1{

    }
    package horseman{
      class T2{

      }
      package impatient{
        class T3(t1:T1,t2:T2){

        }
      }
    }
}
第二種方式則訪問不了
package
 
 com.horseman.impatient{
  class T4(t3:T1){

  }
}

2.編寫一個令人困惑的scala 程式碼，使用一個不再頂部的com包，需要注意的是包的引入可以在程式的任意位置，並且引入最上級的包並不能使用子包中元素

package com{
    class T1{

    }
    package horseman{
      class T2{

      }
      package impatient{
        class T3(t1:T1,t2:T2){

        }
      }
    }
}
import com._;
 

class TT(t2:T1){

}

3.編寫一個包random，加入函式nextInt():Int，nextDouble():Double 和 SetSeed(seed:Int):Unit,生成隨機數的演算法採用線性同餘生成器
線性同餘生成器演算法如下
Nj+1= (A * Nj + B ) mod M
將seed當做首值，A，B，M均為固定值，這裡取A= 1664525,B=1013904223,n = 2的32次方

package random{
package object random{
    val A=math.BigDecimal(1664525);
    val
 
 b=math.BigDecimal(101304223);
    val M=math.BigDecimal(2).pow(32);
    var lastvalue=0;
    def nextInt():Int={
      val ranInt=((lastvalue *A+b)%M).toInt;
      lastvalue=ranInt;
      lastvalue;
    }
    def SetSeed(seed:Int){
      this.lastvalue=seed;
    }
    def nextDouble():Double={
       val ranDouble=((lastvalue *A+b)%M);
       lastvalue=ranDouble.toInt;
       ranDouble.toDouble;
    }

}
}
object packageTest extends App {
  override def main(args:Array[String]){
    import random._;
     random.SetSeed(111);
     println(random.nextInt());
     println(random.nextInt());
     println(random.nextDouble());
     println(random.nextDouble());
  }

}

4.在你看來scala設計者為什麼要提供package object而不是簡單的將函式和變數新增到包中

因為java的虛擬機器不支援。。。。

5.private[com] def giveRaise(rate: Double)的含義是什麼？有用嗎？

此方法僅在com包中可見，有用，可以定義包的可見性

6.編寫一段程式，將java雜湊對映中的所有元素拷貝到scala雜湊對映。用引入語句重新命名這兩個類。

import java.util.{HashMap => javaHashMap}
import scala.collection.mutable.HashMap;

object packageTest extends App {
  override def main(args:Array[String]){
    import random._;
     random.SetSeed(111);
     println(random.nextInt());
     println(random.nextInt());
     println(random.nextDouble());
     println(random.nextDouble());
     val map:javaHashMap[String,Int]=new javaHashMap[String,Int]();
     map.put("zacks",1);
     map.put("cloud",2);
     map.put("tifa",3);
     val setmap=JavaCopyToScalaHashMap(map);
     setmap.foreach(println)
  }
  def JavaCopyToScalaHashMap(map:javaHashMap[String,Int]):HashMap[String,Int]={
    var setmap=new HashMap[String,Int]();
    for(key<- map.keySet().toArray()){
      setmap+=(key.toString() -> map.get(key));
    }

    setmap;
  }

7.在前一個練習中將所有引入語句引入到儘可能小的作用域裡
大致就是在需要用到的地方引用，引用語句在任何地方都可以使用

3.import java.util.{HashMap => JavaHashMap}  
4.  
5.  val map = new JavaHashMap[String,String]()  
6.  map.put("1","a")  
7.  map.put("2","b")  
8.  map.put("3","c")  
9.  
10.  import scala.collection.mutable.HashMap  
11.  
12.  val smap = new HashMap[String,String]()  
13.  
14.  for(key <- map.keySet().toArray){  
15.    smap += (key.toString -> map.get(key))  
16.  }  
17.  
18.  println(smap.mkString)  

8.以下程式碼的作用是什麼？這是個好主意嗎？
import java._
import javax._

作用是引入java，javax包下的所有內容，但java和javax下並沒有任何類，所以此語句並沒有啥卵用

9.編寫一段程式，引入java.lang.System類，從user.name系統屬性讀取使用者名稱，從Console物件讀取一個密碼,如果密碼不是”secret”，則在標準錯誤流中列印一個訊息；如果密碼是”secret”，則在標準輸出流中列印一個問候訊息。不要使用任何其他引入，也不要使用任何限定詞(帶句點的那種)

  val Map:scala.collection.Map[String,String]=System.getProperties();
     Map.foreach((f:(String,String)) => if(f._1=="user.name") println(f._2));
     val passwd=Console.readLine();
     if(passwd=="secret"){
       println("welcome back"+Map.get("user.name"));
     }else{
       System.err.println("passwd error");
     }

10.除了StringBuilder,還有那些java.lang的成員被scala所包含
直接比對java.lang下的類和scala包下的類即可 ，這裡不一一列舉了