博客來源:https://www.cnblogs.com/steamedbundad/p/scalaExercise.html
(個人感覺還是挺不錯的)
1、**[primary]**關於和Scala進行交互的基本方式REPL說法錯誤的是? C
A、R 讀取（read）
B、E 求值（evaluate）
C、P 解析（Parse）
D、L 循環（Loop）
2、**[primary]**不屬於Scala7種數值類型的是? D
A、Char
B、Int
C、Float
D、LongLong
3、**[primary]**如果需要使用scala庫中的sqrt函數,如sqrt(2)，下列引用包的方式錯誤的是? B
A、import scala.math._
B、import sqrt
C、import math._
D、import math.sqrt
4、**[primary]**Scala關於變量定義、賦值，錯誤的是？B
A、val a = 3
B、val a:String = 3
C、var b:Int = 3 ; b = 6
D、var b = "Hello World!" ; b = "123"
5、**[primary]**在Scala中如何獲取字符串“Hello”的首字符和尾字符？B
A、"Hello"(0)，"Hello"(5)
B、"Hello".take(1)，"Hello".reverse(0)
C、"Hello"(1)，"Hello"(5)
D、"Hello".take(0)， "Hello".takeRight(1)
6、**[primary]**下面輸出與其他不一致的是？D
A、println("Hello World")
B、print("Hello World\n")
C、printf("Hello %s", "World\n")
D、val w = "World" ; println("Hello $w")
7、**[primary]**關於函數def sum(args:Int*) = {var r = 0 ; for(arg <- args) r += arg ; r}} 輸出結果不一致的是？D
A、sum(1,2,3)
B、sum(6)
C、sum(2,4)
D、sum(1,1,1,2)
8、**[primary]**下列表達式不是過程的是？C
A、def foo(num:Int) = {println(num * 2)}
B、def foo() {println("Hello World")}
C、def foo(num:Int) = {num * 2}
D、def foo():Unit = {println("Hello World")}
9、**[primary]**下列數組定義與其他不一致的是？D
A、val a = Array[Int](0, 0)
B、val a = Array(0, 0)
C、val a = new Array[Int](2)
D、val a = Array[Int](1, 1)
10、**[primary]**下列關於數組緩衝val b = ArrayBuffer[Int]()操作結果的註釋說明錯誤的是？C
A、b += 1 // b 等於 ArrayBuffer(1)
B、b += (1,2,3) // b 等於 ArrayBuffer(1,2,3)
C、b += Array(1,2) // b 等於 ArrayBuffer(1,2)
D、b += (1,2,3,4,5);b.trimEnd(3) // b 等於 ArrayBuffer(1,2)
11、**[primary]**關於數組的常用算法，下列說法錯誤的是？B
A、Array(1,7,2,9).sum // 等於 19
B、Array(1,7,2,9).sorted // 等於 Array(9,7,2,1)
C、Array("one","two","three").max // 等於 "two"
D、Array("one","two","three").mkString("-") // 等於 "one-two-three"
12、**[primary]**關於元組 Tuple 說法錯誤的是？D
A、元組的可以包含不同類型的元素
B、元組是不可變的
C、訪問元組第一個元素的方式爲 pair._1
D、元組最多隻有2個元素
13、**[primary]**對於函數
def getGoodsPrice(goods:String) = {
val prices = Map(“book” -> 5, “pen” -> 2, “sticker” -> 1)
prices.getOrElse(goods, 0)
}
結果說法錯誤的是？D
A、getGoodsPrice("book") // 等於 5
B、getGoodsPrice("pen") // 等於 2
C、getGoodsPrice("sticker") // 等於 1
D、getGoodsPrice("sock") // 等於 “sock”
14、**[primary]**對於元組val t = (1, 3.14, "Fred")說法錯誤的是？A
A、
t_1等於 1
B、t 的類型爲 Tuple3[Int, Double, java.lang.String]
C、val (first, second, _) = t// second 等於 3.14
D、t._0無法訪問， 會拋出異常
15、**[primary]**對於拉鍊操作val t1 = Array(1, 3); val t2 = Array(2,4) ; t1.zip(t2)返回結果正確的是？C
A、（1,2,3,4)
B、（(1,3),(2,4))
C、（(1,2),(3,4))
D、（(1,4),(3,4))
16、**[intermediate]**Scala允許你用數字去乘字符串—去REPL中試一下"crazy"*3。這個操作結果返回什麼？C
A、“crazy”*3
B、ccrraazzyy
C、crazycrazycrazy
D、crazy
17、**[intermediate]**下面選項中a的取值不一致的是？B
A、val a = 3
B、val a:Double = 1 + 2
C、var a = 1; a += 2
D、val b = 1.+(2); val a = b.toInt
18、**[intermediate]**指出在Scala中何種情況下賦值語句x=y=1是合法的？A
A、var x={}
B、var x=1
C、var x="test"
D、var x=(1,1)
19、**[intermediate]**編寫一個過程countdown(n:Int)，打印從n到0的數字？C
A、
def countdown(n:Int){
0 to n foreach print
}
B、
def countdown(n:Int){
(0 until n).reverse foreach print
}
C、
def countdown(n:Int){
(0 to n).reverse foreach print
}
D、
def countdown(n:Int){
(0 to n-1).reverse foreach print
}
20、**[intermediate]**表達式for(i <- 1 to 3; for(j <- 1 to 3; if i != j ) print((10 * i + j)) + " "輸出結果正確的是？C
A、11 12 13 21 22 23 31 32 33
B、11 13 21 23 31 33
C、12 13 21 23 31 32
D、11 12 21 22 31 32
21、**[intermediate]**關於函數def fac(n:Int) = { var r = 1 ; for(i <- 1 to n) r = r * i ; r} fac(5)輸出結果正確的是？B
A、15
B、120
C、200
D、300
22、**[intermediate]**關於函數def fac(n:Int, x:String="x", y:Int=0) = {println(x*(n+y))} 輸出結果不一致的是？C
A、fac(2)
B、fac(1, y=1)
C、fac(1, "x")
D、fac(1, "x", 1)
23、**[intermediate]**關於數組val a = Array(1,2,3)下列說法錯誤的是？A
A、val b = 2 * a // b 等於 Array(2,4,6)
B、val b = a.map(_*2) // b 等於 Array(2,4,6)
C、val b = for(elem <- a) yield 2 * elem // b 等於 Array(2,4,6)
D、val b = for(elem <- a if elem % 2 == 0) yield 2 * elem // b 等於 Array(4)
24、**[intermediate]**關於數組Array.ofDim[Int](2,3)的初始化結果說明正確的是？B
A、Array(0，0，0，0，0，0）
B、Array(Array(0，0，0)，Array(0，0，0)）
C、Array(Array(0，0)，Array(0，0)，Array(0，0)）
D、(Array(0，0)，Array(0，0)，Array(0，0))
25、**[intermediate]**對於Map("book" -> 5, "pen" -> 2).map(m => m._1 -> m._2 * 2)結果說法正確的是？C
A、Map("bookbook" -> 5, "penpen" -> 2)
B、Map("bookbook" -> 10, "penpen" -> 4)
C、Map("book" -> 10, "pen" -> 4)
D、Map("book" -> 5, "pen" -> 2 ,"book" -> 5, "pen" -> 2)
26、**[intermediate]**對於val prices = Map("book" -> 5, "pen" -> 2, "sticker" -> 1)結果說法錯誤的是？D
A、prices("sticker") // 等於 1
B、(prices + ("shoes" -> 30))("shoes")// 等於 30
C、(prices - "pen")("book") // 等於 5
D、prices("sock") // 等於 0
27、**[intermediate]**對於表達式"New York".partition(_.isUpper)返回結果正確的是？B
A、("New", "York")
B、("NY", "er ork")
C、("er ork", "NY")
D、("New York", "NY")
28、**[intermediate]**對於表達式
val tokens = "one two three four two two three four".split(" ")
val map = new HashMap[String,Int]
for(key <- tokens){
map(key) = map.getOrElse(key,0) + 1
}
說法正確的是？D
A、map(“one”) 等於 2
B、map(“two”) 等於 2
C、map(“three”) 等於 3
D、map(“four”) 等於 2
29、**[intermediate]**編寫一個函數，返回Int數組中最大最小的數字？B
A、
def maxmin(nums:Array[Int]){
val max = nums.max
val min = nums.min
(max, min)
}
B、
def maxmin(nums:Array[Int]) = {
nums.max -> nums.min
}
C、
def maxmin(nums:Array[Int]) = {
val max = nums.max
val min = nums.min
max,min
}
D、
def maxmin(nums:Array[Int]) = {
val max = nums.sorted.head
val min = nums.sorted.last
(max,min)
}
30、**[intermediate]**對於拉鍊操作
val key = Array(1, 2)
val value = Array(“one”,”two”)
val m = key.zip(value).toMap
返回結果正確的是？A
A、m(1) 等於 “one”
B、m(2) 等於 “one”
C、m(“one”) 等於 “1”
D、m(“two”) 等於 1
31、**[primary]**scala中，下面的哪個類定義是不正確的？C
A.class Counter{def counter = “counter”}
B.class Counter{val counter = “counter”}
C.class Counter{var counter:String}
D.class Counter{def counter () {}}
32、**[primary]**scala的類在實現屬性時，下面說法中錯誤的是？B
A. var foo： Scala自動合成一個getter 和一個setter
B. val foo： Scala自動合成一個getter 和一個setter
C. 可以單獨定義foo方法
D. 可以單獨定義foo_=方法
33、[primary] 定義類Countter並實例化如下：
Class Countter(name:String){
val a = 1
var b = “counter”
}
val counter = new Countter(“computer”)，下列操作正確的是？C
A. counter.name = “cpu”
B. counter.a = 2
C. counter.b = “conter2”
D. counter.a = counter.b
34、**[primary]**類和單例對象間的差別是？B
A. 單例對象不可以定義方法，而類可以
B. 單例對象不可以帶參數，而類可以
C. 單例對象不可以定義私有屬性，而類可以
D. 單例對象不可以繼承，而類可以
35、**[primary]**關於輔助構造器，以下說法正確的是？C
A. 輔助構造器的必須調用主構造器
B. 輔助構造器的可以直接調用超類的主構造器
C. 輔助構造器的參數可以是任意多個
D. 輔助構造器的名稱和類名相同
36、**[primary]**關於主構造器，以下說法錯誤的是？A
A. 主構造器在每個類都可以定義多個
B. 主構造器的參數可以直接放在類名後。
C. 主構造器的會執行類定義中的所有語句。
D. 主構造器中可以使用默認參數。
37、**[primary]**定義類 Class Person（private val name: String）{},以下說法正確是？B
A. name是對象私有字段
B. name是類私有字段，有私有的getter方法
C. name是類公有字段，有公有的getter和setter方法
D. name是類私有字段，可以在類內部被改變
38、**[primary]**scala 中，以下說法錯誤是？C
A. scala 中， 可以在類中定義類。
B. scala 中， 可以在函數中定義函數。
C. scala 中， 不可以在類中定義object。
D. scala 中， 可以在函數中定義類。
39、**[primary]**scala 中，類成員的缺省訪問級別是？A
A. public
B. private
C. protected
D. 以上都不對
40、**[primary]**以下單例對象，定義錯誤的是？B
A. object A{var str = “”}。
B. object A(str:String){}
C. object A{def str = “”}
D. object A{val str = “”}
41、**[primary]**scala中，關於包的說法不正確的是？A
A. 包的名稱不能重複。
B. 同一個包可以定義在多個文件中。
C. 包路徑不是絕對路徑。
D. 包對象可以持有函數和變量。
42、**[primary]**scala中，關於包的引用錯誤的是？D
A. 包和其成員可以用import
B. 可以引用某個文件夾下的特定文件
C. 可以引用某個文件夾下的所有文件
D. 包引用只能在編譯單元的開始處
43、**[primary]**下面關於override修飾符的描述錯誤的是？D
A. Scala裏所有重載了父類具體成員的成員都需要這樣的修飾符
B. Scala裏如果子類成員實現的是同名的抽象成員則這個修飾符是可選的
C. Scala裏如果子類中並未重載或實現什麼基類裏的成員則禁用這個修飾符
D. Scala裏如果子類是抽象類則子類的同名成員不可以使用這個修飾符
44、**[primary]**Scala裏，final修飾符的描述正確的是？B
A. 類的聲明上添加final修飾符確保成員不被子類重載
B. 類的聲明上添加final修飾符把整個類聲明爲final，這個類不能被繼承
C. 類的聲明上添加final修飾符確保成員只能被子類重載一次
D. 以上說法都是錯誤的
45、**[primary]**scala語言中，關於List的定義。不正確的是？C
A. val list = List(1,2,3)。
B. val list = List[Int](1,2,3)。
C. val list = List[String](‘a’,’b’,’c’)。
D. val list = List[String]()。
46、**[intermediate]**定義一個類，定義正確的是？D
A.
class House（name）{
def getname = “beijing”
}
B.
class house {
name = “nanjing”
}
C.
class House {
public var counter:String = “shanghai”
}
D.
class house (var name:String){
private def getName = name
}
47、**[intermediate]**Scala類中的公有字段自帶getter和setter，類class Persen{var age=0} ，age字段默認定義的方法是？D
A. getter ,setter
B. getAge, setAge
C. age, age_
D. age, age_=
48、**[intermediate]**關於輔助構造器，以下說法不正確的是？D
A. 輔助構造器的名稱爲this。
B. 輔助構造器的定義要調用已定義的輔助構造器或主構造器。
C. 輔助構造器可以有任意多個
D. 輔助構造器必須要帶參數
49、**[intermediate]**Scala中的類，以下說法正確的是？B
A. Scala中，類內部的不是從構造器定義的代碼，都會在主構造器中執行
B. Scala中，類內部的不是字段的部分或者方法定義的代碼，都會在主構造器中執行
C. Scala中，類內部的所有的代碼，都會在主構造器中執行
D. 以上說法都是錯誤的。
50、**[intermediate]**scala 中，類和它的伴生對象說法錯誤的是？B
A. 類和它的伴生對象定義在同一個文件中。
B. 類和它的伴生對象可以有不同的名稱。
C. 類和它的伴生對象可以互相訪問私有特性。
D. 類和它的伴生對象可以實現既有實例方法又有靜態方法。
51、**[intermediate]**關於對象的apply方法，正確的是？A
A. apply方法返回的是伴生類的對象。
B. apply方法不可以帶參數。
C. apply方法返回的是Unit。
D. apply方法定義在類裏面。
52、**[intermediate]**scala中，關於引入語句的說法不正確的是？D
A. 引入語句可以引入包、類和對象。
B. 引入語句可以出現在任意位置。
C. 引入語句可以重命名。
D. 引入語句不可以隱藏特定成員。
53、**[intermediate]**對於下述代碼說法正確的是？A
class Cat extends Animal{}
A. Cat是Animal的子類。
B. Animal是Cat的子類
C. Cat是Animal的超類
D. Animal一定是抽象類
54、**[intermediate]**scala中的類，下面說法正確的是？A
A. scala 中，使用extends進行類的擴展。
B. scala 中, 聲明爲final的類可以被繼承。
C. scala中，超類必須是抽象類。
D. scala中，抽象類可以被實例化。
55、**[intermediate]**scala中，下列描述錯誤的是？B
A. Scala裏，字段和方法屬於相同的命名空間。
B. Scala一共有四個命名空間。
C. Scala裏，字段可以重載無參數方法。
D. Scala類和特質屬於相同的命名空間。
56、**[intermediate]**下面定義的代碼和哪個選項是等效的？D
class ArrayElement(x123: Array[String]) extends Element{
val contents: Array[String] = x123
}
A.
class ArrayElement(var x123: Array[String])extends Element{
val contents: Array[String] = x123
}
B.
class ArrayElement( val x123: Array[String] )extends Element{
val contents: Array[String] = x123
}
C.
class ArrayElement(var contents: Array[String])extends Element
D.
class ArrayElement( val contents: Array[String] )extends Element
57、**[intermediate]**類定義如下，描述不正確的是？C
abstract class Element
{
def contents: Array[String]
}
A. Element是一個抽象類。
B. Element不能實例化。
C. Contents成員定義錯誤，沒有初始化。
D. contents方法是類Element的抽象成員。
58、**[intermediate]**scala語言中，下面描述正確的是？D
A. scala中，Float是Double的子類。
B. scala中，Int是Long的子類。
C. scala中，Double是AnyRef的子類
D. scala中，Long是AnyVal的子類
59、**[intermediate]**Scala中，下面的代碼執行正確的是?C
A. val list = 1 :: 2 :: 3。
B. val list = 1.::(2).:: (3).::(Nil)
C. val list = 1 :: “s” :: “b” :: Nil。
D. var list = 1 ::: 2 ::: 3 ::: Nil
60、**[intermediate]**類ArrayElement定義如下,它的子類定義正確的是？B
class ArrayElement(val str:String){
def height =1
}
A.
class LineElement(str: String) extends ArrayElement{
def width = str.length
}
B.
class LineElement(s: String) extends ArrayElement(s) {
def width = str.length
}
C.
class LineElement(str: String) extends ArrayElement(str){
def height =1
}
D.
class LineElement(s String) extends ArrayElement{
def str = s
}
61、**[primary]**對於由scala.io.Source.fromFile創建的Source對象的使用以下描述正確的是？A
A. 在使用完此Source對象後，需要調用close方法來釋放相關資源。
B. 可以使用此Source對象向其指定的文件中寫入內容。
C. 可以修改此Source對象所指定的文件名稱。
D. 以上說法均不正確。
62、**[primary]**在正則表達式中，如下哪個符號用於匹配單個字符？B
A. .
B. ?
C. *
D. +
63、**[primary]**在正則表達式中，如下哪個符號用於匹配一次或多次？D
A. .
B. ?
C. *
D. +
64、**[primary]**可以正確匹配" 12340 "的正則表達式是？C
A. "\s+[0-9]+\s+".r
B. ""\s+[0-4]+\s+".r
C. """\s+\d+\s+""".r
D. 以上均不正確。
65、**[primary]**如下選項中，不能做爲Scala標識符的是？C
A.
`type`
B. |>
C. 2K
D. hello
66、**[primary]**下述關於中置表達式(a 操作符 b)的描述錯誤的是？B
A. 其中的“操作符”代表一個帶有兩個參數的方法(一個隱式的參數和一個顯式的參數)。
B. 中置表達式，一定可以提高代碼的可閱讀性。
C. Scala在當方法只有一個參數時，可以省略點號、以及括號，從而形式上變成中置表達式。
D. 通常可以將此中置表達式修改爲"a.操作符(b)"，若此操作符具有右結合性則應修改爲"b.操作符(a)"。
67、**[primary]**有關操作符結合性的描述不正確的是？D
A. 操作符的結合性決定了它們是從左到右求值還是從右到左求值。
B. |操作符是左結合的。
C. 以冒號結尾的操作符是右結合的。
D. 賦值操作符是左結合的。
68、**[primary]**以下代碼的執行結果的描述正確的是？C
object Name {
def unapplySeq(input: String): Option[Seq[String]] = {
if(input.trim == "") None else Some(input.trim.split("\\s+"))
}
}
val Name(xing, ming) = " Yuan Jianzheng "
A. 編譯過程報錯。
B. 運行過程中報錯。
C. 執行後，xing的結果是"Yuan"，ming的結果是"Jianzheng"。
D. 以上描述全部錯誤。
69、**[primary]**以下關於閉包描述錯誤的是？D
A. 閉包是一個函數，其返回值依賴於聲明在函數包部的一個或多個變量。
B. 通常來講，可以將閉包看作是可以訪問一個函數裏面局部變量的另一個函數。
C. 對於def mulBy(factor: Double) = (x: Double) => factor * x; val triple = mulBy(3);,函數triple是一個閉包。
D. 對於def mulBy(factor: Double) = (x: Double) => 3 * x; val triple = mulBy(3);,函數triple是一個閉包。
70、**[primary]**有關柯里化描述錯誤的是？D
A. 柯里化是指將原來接受兩個參數的函數變成新的接受一個參數的函數的過程。新的函數返回一個以原有第二個參數作爲參數的函數。
B. 有時，使用柯里化將某個函數參數單拎出來，可以提供更多用於類型推斷的信息。
C. 將函數def add(x: Int, y: Int) = x + y，變形爲def add(x: Int)(y: Int) = x + y的過程是一個柯里化過程。
D. 柯里化是多參數列表函數的特例。
71、**[primary]**高階函數是指？C
A. 在程序中應該首先被定義的函數。
B. 將函數作爲參數，並返回結果爲函數的函數。
C. 函數參數爲函數或返回結果爲函數的函數。
D. 執行時間長的函數。
72、**[primary]**以下選項中，哪一個可以在Scala中定義一個按名調用(call-by-name)的函數？B
A. def functionOne(x: Int)
B. def functionOne(x: => Int)
C. def functionOne(x: -> Int)
D. def functionOne(x: Name)
73、**[primary]**如下代碼執行結果是？A
def someCurring(y: Int):(Int) => Int = {
def s(y:Int) = 2*y
s
}
val result = somCurring(4)(3)
A. 6
B. 4
C. 8
D. 9
74、**[primary]**集合可以分爲三大類，以下描述中不是這三大類的是？A
A. 列表(List)
B. 序列(Seq)
C. 集(Set)
D. 映射(Map)
75、**[primary]**以下對集合的描述有誤的是？D
A. Set是一組沒有先後次序的值。
B. Map是一組(鍵，值)對偶。
C. 每個Scala集合特質或類都有一個帶有apply方法的伴生對象，可以用此方法來構建該集合中的實例。
D. 爲了顧及安全性問題，Scala僅支持不可變集合而不支持可變集合。
76、 **[primary]**如下的操作中，哪一個不能將val names = List("Petter", "Paul", "Mary")中的相應地字符串全部變成大寫？D
A. names.map(_.toUpperCase)
B. for (name <- names) yield name.toUpperCase
C. for (name <- names) yield
for(c <- name) yield c.toUpper
D. for(name <- names;
c <- name) yield c.toUpper
77、**[primary]**以下關於case class描述有誤的是？A
A. 默認情況下可對其屬性進行修改。
B. 在模式匹配時會進行解構操作。
C. 兩個case class進行比較時進行全等比較，而非按是否引用同一個對象進行比較。
D. 相比於class而言更簡潔的實例化過程(不需要使用new操作符)及其它操作語法。
78、**[primary]**下面有關sealed類的描述有誤的是？D
A. 若樣例類的通用超類聲明爲sealed，則在使用樣例類來做模式匹配時，編譯器可以確保你已經列出了所有可能的選擇。
B. 對於用sealed聲明的類，其子類必須與其處於同一個文件中。
C. 聲明爲sealed的類可以有效防止繼承濫用。
D. 聲明爲sealed的類由於是密封的，故不能對此類中實現的方法在子類中進行修改。
79、**[primary]**下面有Option類型描述有誤的是？C
A. Option類型可以用來表示那種可能存在、也可能不存在的值。
B. Option類型的兩種狀態分別是Some和None。
C. Option類型的兩種狀態分別是Success和Failure。
D. 可以使用isEmpty方法來判斷是否存在值。
80、**[primary]**對於以下代碼描述有誤的是？B
val data = Map(1 -> "One", 2 -> "Two")
val res = for((k, v) <- data; if(k > 1)) yield v
A. 運行後res的結果爲List("Two")。
B. 運行後res的結果爲List("One", "Two")。
C. 對映射data中的每一個(鍵，值)對，k被綁定對鍵，而v則被綁定到值。
D. 其中的if(k > 1)是一個守衛表達式。
81、**[intermediate]**對於scala.io.Source對象的fromFile來說，以下哪一種描述是錯誤的？C
A. 可以使用指定文件名(String)來創建一個Source
B. 可以使用一個文件的URI(java.net.URI)來創建一個Source
C. 可以使用一個文件的URL(java.net.URL)來創建一個Source
D. 可以使用一個File對象(java.io.File)來創建一個Source
82、**[intermediate]**對於在scala中文件相關操作描述正確的是？D
A. 可以直接使用scala的庫來讀取二進制文件。
B. 可以直接使用scala的庫來寫入文件文件。
C. 在讀取文件時，如果不指定文件編碼格式則scala會推斷出正確的格式進行讀取。
D. 以上描述均不正確。
83、**[intermediate]**對於scala.sys.process提供用於與shell交互的工具而言，對於"ls -al .." !如下描述正確的是？C
A. 表示僅執行ls -al ..命令並沒有任何返回值。
B. 表示執行ls -al ..命令，並返回執行的結果。
C. 表示執行ls -al ..命令，並將此命令執行的退出碼返回。
D. 以上描述均不正確。
84、**[intermediate]**以下關於特質的說法錯誤的是？C
A. 類可以實現任意數量的特質。
B. 特質可以要求實現它們的類具備特定的字段、方法或超類。
C. 與Java接口(Interface)相同，Scala特質也可以提供方法和字段的實現。
D. 當將多個特質疊加在一起時，順序很重要——其方法先被執行的特質排在更後面。
85、**[intermediate]**關於Scala中不支持多重繼承的原因描述正確的是？D
A. 在實際使用中，真正必須使用多重繼承的時機很少。
B. 若多重繼承的兩個基類具有相同的字段或方法，就會引發菱形繼承問題，造成問題的複雜性。
C. 通過使用Trait可以達到多重繼承的類似效果。
D. 以上均正確。
86、**[intermediate]**關於Scala中的trait和Java中的Interface描述錯誤的是？A
A. Scala特質和Java接口都可以包含抽象方法和具體實現。
B. Scala和Java都不允許多重繼承，但可以疊加多個特質或接口。
C. Java只能在類層面上添加接口的實現，而Scala可以在類和對象層面上“混入”特質。
D. 以上描述至少有一項有誤。
87、**[intermediate]**對於Scala中混入了特質的對象，關於其在構造時構造器執行順序的描述錯誤的是？C
A. 首先調用超類的構造器。
B. 特質構造器在超類構造器之後、類構造器之前執行。所有特質構造完畢，子類被構造。
C. 特質由右到左被構造。如果多個特質共有一個父特質，而那個父特質已經被構造，則不會再次構造。
D. 每個特質中，父特質先被構造。
88、**[intermediate]**對於下述代碼描述錯誤的是？D
class MyClass
trait TestLog {
val testName: String
val realName = testName + ".log"
}
val log = new MyClass with TestLog{
val testName = "test"
}
A. log.realName並不是期望的"test.log"。
B. 可以通過val log = new MyClass {val testName = "test";} with TestLog，來達到log.realName的值爲"test.log"。
C. 可以通過將TestLog中的realName定義修改爲，lazy val realName = testName + ".log"，來達到log.realName的值爲"test.log"。
D. 以上描述最多有兩個描述正確。
89、**[intermediate]**對於以this: 類型 =>代碼開始定義的特質，描述錯誤的是？D
A. 此描述叫作“自身類型(self type)”，表示此特質只能被混入指定類型的子類中。
B. 在此特質的方法中，可以調用上述類型中所具有的任何方法。
C. 此類型，可以是一個方法的集合，如{def getMessage(): String}用於表示此特質可以被混入任何擁有getMessage方法的類中。
D. 以上描述最多有兩個描述正確。
90、**[intermediate]**Scala將特質翻譯成JVM的類和接口的描述錯誤的是？D
A. 只有抽象方法的特質被簡單地變成一個Java接口。
B. 如果特質中包含具體方法，則Scala會幫我們創建出一個伴生類，該伴生類用靜態方法存放特質的方法。
C. 特質中的字段對應到接口中的抽象的getter和setter方法。
D. 以上描述至少有一個是錯誤的。
91、**[intermediate]**對於一元操作符下述描述錯誤的是？B
A. "+"、"-"、"!"、"~"這四個操作符可以作爲前置操作符，出現在參數之前。
B. 前置表達式"操作符 a"，可以表示爲"a.unary_操作符(1)"。
C. 如果此操作符出現在參數之後，那麼它就是一個後置操作符，如"a 操作符"。
D. 後置表達式"a 操作符"，可以表示爲"a.操作符()"。
92、**[intermediate]**有關操作符優先級的描述不正確的是？C
A. *=的優先級低於+。
B. >的優先級高於&。
C. 後置操作符的優先級高於中置操作符。
D. %的優先級高於+。
93、**[intermediate]**對於f(arg1, arg2, ...)描述有誤的是？D
A. 若其未出現在賦值表達式的左側，若f是函數或方法，則其只是對其的調用。
B. 若其未出現在賦值表達式的左側，且f不是函數或方法，則其等同於f.apply(arg1, arg2, ...)。
C. 若其出現在賦值表達式的左側，如"f(arg1, arg2, ...) = value"，則其等同於f.update(arg1, arg2, ..., value)。
D. 以上描述至少有一個是錯誤的。
94、**[intermediate]**以下關於Scala中函數的描述錯誤的是?B
A. 函數是“頭等公民”，就和數字一樣。
B. 可以將函數賦值給變量，如val fun = scala.math.ceil。
C. 支持非具名函數，也即匿名函數。
D. 可以將函數作爲參數，傳遞給其它函數。
95、**[intermediate]**對集(Set)進行操作"Set(2, 0, 1) + 1 + 1 - 1"之後的結果爲？C
A. Set(2, 0, 1, 1)
B. Set(2, 0, 1)
C. Set(2, 0)
D. 已上均不正確。
96、**[intermediate]**下述方法中，哪一個不能將"val tmp = List(1, 2, 3)"中的所有元素求和，並將最終結果6返回？D
A. tmp.foldLeft(0)(_ + _)
B. tmp.reduceLeft(_ + _)
C. (0 /: tmp)(_ + _)
D. tmp.scanLeft(0)(_ + _)
97、**[intermediate]**下面有關val f: PartialFunction[Char, Int] = {case '+' => 1; case '-' => -1}的描述有誤的是？D
A. f是一個偏函數，且其參數類型爲Char、返回類型爲Int。
B. f('-')的結果是返回-1。
C. f.isDefinedAt('0')的結果是返回false。
D. f('0')在執行時由於沒有對應的case語句，故會返回一個任意Int值。
98、**[intermediate]**在下述代碼基礎上，不能正確執行的操作是？C
case class Currency(value: Double, unit: String)
val amt = Currency(29.95, "EUR")
A. amt.copy(value = 19.2)
B. amt.copy()
C. amt.copy("CHF")
D. amt.copy(unit = "CHF")
99、**[intermediate]**對於下述代碼，哪個描述是正確的？A
val one: PartialFunction[Option[Int], String] = {
case Some(_) => "one"
}
A. one.isDefinedAt(Some(1)) == true
B. one.isDefinedAt(1) == true
C. one.isDefinedAt(Some(100)) == false
D. one.isDefinedAt(None) == true
100、**[intermediate]**在對htmlText進行匹配時，應該使用哪一種case語句？B
def getHtml(url: String): Try[String] = {...}
val myUrl = "http://justtest.org"
val htmlText = getHtml(myUrl)
val result = htmlText match {
???
}
A. case Some(x) =>
case None(x) =>
B. case Success(v) =>
case Failure(e) =>
C. case String(x) =>
case Url(y)
D. case Try1(v) =>
case Try2(v) =>