Scala面試問題

教學
Scala

在閱讀本文前，請先閱讀我的上一篇帖子，“Scala 基本面試問題與答案”，以獲取有關 Scala 語言的基本知識。在這篇帖子中，我們將討論一些更多對有經驗的 Scala 開發人員有用的 Scala 面試問題。注意：由於此列表已變得非常龐大，我將提供另一篇帖子，其中包含剩餘的問題和答案。請參考該帖子：“Scala 中級和高級面試問題與答案”

Scala 面試問題

在本節中，我們將列出所有 Scala 中級面試問題，並在下一節中詳細討論它們。

  1. 什麼是主要構造函數？Scala 中的次要或輔助構造函數是什麼？
  2. Scala 中輔助構造函數的用途是什麼？請解釋定義 Scala 中輔助構造函數時需要遵循的規則。
  3. Array 和 ArrayBuffer 在 Scala 中的區別是什麼？
  4. 什麼是 case class？什麼是 case object？case class 的優點是什麼？
  5. Case Object 和 Object（普通 Object）之間的區別是什麼？
  6. 當比較普通類別時，Case 類別的主要優勢或好處是什麼？
  7. 在 Scala 中，isInstanceOf 和 asInstanceOf 方法的使用是什麼？在 Java 中有類似概念嗎？
  8. 如何證明預設情況下，Case 物件是可序列化的而普通物件不是？
  9. Scala 中 Array 和 List 的區別是什麼？
  10. 在 Scala 中，“val” 和 “lazy val” 有什麼區別？什麼是急切求值？什麼是惰性求值？
  11. equals 方法和 == 在 Scala 中的關係是什麼？Scala 的 == 和 Java 的 == 運算符有什麼不同？
  12. Scala 的內部類別和 Java 的內部類別有什麼區別？
  13. 什麼是 Diamond 問題？Scala 如何解決 Diamond 問題？
  14. 為什麼 Scala 沒有 “static” 關鍵字？這個決定的主要原因是什麼？
  15. 在 Scala 中，“object” 關鍵字有什麼用途？如何在 Scala 中創建單例對象？
  16. 如何使用 object 關鍵字在 Scala 中定義工廠方法？定義工廠方法在 object 中的用途是什麼？
  17. Scala 中的 apply 方法是什麼？Scala 中的 unapply 方法是什麼？apply 和 unapply 方法在 Scala 中有什麼區別？
  18. 在 Scala 中，當我們創建一個類的實例時，不使用 ‘new’ 關鍵字時，它是如何在幕後工作的？什麼時候我們會選擇這種方法？
  19. 我們如何在 Scala 中聲明一個私有的主要構造函數？我們如何在 Scala 中調用私有的主要構造函數？
  20. 一個 Companion 物件能否存取它的 Companion 類的私有成員在 Scala 中？
  21. 關於兩個分開的關鍵字：class 和 object 在 Scala 中的主要設計決定是什麼？我們如何在 Scala 中定義實例成員和靜態成員？
  22. 在 Scala 中 object 是什麼？它是單例對象還是類的實例？
  23. 在 Scala 中 Companion Object 是什麼？Companion Class 是什麼？Companion Object 在 Scala 中的用途是什麼？
  24. 如何在 Scala 中實現接口？
  25. Scala 中的 Range 是什麼？如何在 Scala 中創建一個 Range？
  26. 在 Scala 中類型 Nothing 有多少個值？
  27. 在 Scala 中類型 Unit 有多少個值？
  28. Scala 中的 Range 是什麼？如何在 Scala 中創建一個 Range？
  29. 在 FP 中，函數和過程之間有什麼區別？
  30. Scala 的輔助構造函數和 Java 的構造函數之間的主要區別是什麼？
  31. 在 Scala 的 for-推導結構中 ‘yield’ 關鍵字的用途是什麼？
  32. 在 Scala 的 for-推導結構中 guard 是什麼？
  33. Scala 如何比 Java 8 更自動且更容易地解決繼承鑽石問題？
  34. 在 Scala 中，模式匹配遵循哪種設計模式？在 Java 中，’isinstanceof’ 運算符遵循哪種設計模式？

Scala 面試問題與答案

在這一節中，我們將挑選上述列表中的每個問題，並進行詳細討論，並提供適當的示例（如果需要）。如果您想深入了解這些概念並附有示例，請閱讀我在 Scala 教程部分的先前帖子。

什麼是主要構造函數？Scala 中的次要或輔助構造函數是什麼？Scala 中輔助構造函數的目的是什麼？在 Scala 中是否可以重載構造函數？

Scala 有兩種類型的構造函數：

  • 主要構造函數
  • 輔助構造函數

主要構造函數在 Scala 中，主要構造函數是與類定義本身一起定義的構造函數。每個類必須有一個主要構造函數：可以是帶參數的構造函數或無參數的構造函數。例如：-

class Person

上面的 Person 類別有一個零參數或無參數的主要建構函式來建立此類別的實例。

class Person (firstName: String, lastName: String)

上面的 Person 類別有一個帶有兩個參數的主要建構函式來建立此類別的實例。輔助建構函式輔助建構函式也被稱為次要建構函式。我們可以使用以下方式使用 ‘def’ 和 ‘this’ 關鍵字來宣告次要建構函式：

class Person (firstName: String, middleName:String, lastName: String){
  def this(firstName: String, lastName: String){
      this(firstName, "", lastName)
  }
}

Scala 中輔助建構函式的用途是什麼？請解釋在 Scala 中定義輔助建構函式時應遵循的規則？

在 Scala 中，輔助建構函式的主要目的是重載建構函式。與 Java 類似，我們可以提供各種類型的建構函式，以便用戶根據自己的需求選擇適合的建構函式。輔助建構函式的規則：

  • 它們就像方法一樣。像方法一樣，我們應該使用 ‘def’ 關鍵字來定義它們。
  • 我們應該為所有輔助建構函式使用相同的名稱 ‘this’。
  • 每個輔助建構函式都應該以對先前定義的另一個輔助建構函式或主要建構函式的呼叫開始。否則會在編譯時出錯。
  • 每個輔助建構函式應該根據它們的參數列表不同: 可能是按照數量或類型。
  • 輔助建構函式不能調用超級類建構函式。它們只能通過主建構函式調用它們。
  • 所有輔助建構函式都會直接或間接地通過其他輔助建構函式調用它們的主建構函式。

注意:-如果您想了解Scala的建構函式，請參閱我的Scala文章：主建構函式和輔助建構函式。

Scala中Array和ArrayBuffer之間有什麼區別？

Scala中Array和ArrayBuffer的區別：

  • Array是固定大小的數組。一旦創建後，其大小就無法更改。
  • ArrayBuffer是可變大小的數組。它可以動態增加或減少其大小。
  • Array類似於Java的基本數組。
  • ArrayBuffer類似於Java的ArrayList。

什麼是案例類別？什麼是案例對象？案例類別的優點是什麼？

案例類別是一個用 “case class” 關鍵字定義的類別。案例對象是一個用 “case object” 關鍵字定義的對象。由於這個 “case” 關鍵字，我們將獲得一些好處，可以避免樣板代碼。我們可以在不使用 “new” 關鍵字的情況下創建案例類別對象。默認情況下，Scala 編譯器會為所有構造函數參數添加 “val” 前綴。這就是為什麼在不使用 val 或 var 的情況下，案例類別的構造函數參數將變為類成員，這對於普通類別來說是不可能的。案例類別的優點：

  • 默認情況下，Scala 編譯器會添加 toString、hashCode 和 equals 方法。我們可以避免編寫這些樣板代碼。
  • 默認情況下，Scala 編譯器會添加伴隨對象和 apply 和 unapply 方法，因此我們不需要使用 new 關鍵字來創建案例類別的實例。
  • 默認情況下，Scala 編譯器還會添加 copy 方法。
  • 我們可以在模式匹配中使用案例類別。
  • 默認情況下，案例類別和案例對象都是可序列化的。

案例對象和普通對象（Normal Object）之間的區別是什麼？

  • 普通對象是使用“object”關鍵字創建的。默認情況下，它是一個單例對象。
object MyNormalObject
  • 案例對象是使用“case object”關鍵字創建的。默認情況下，它也是一個單例對象。
case object MyCaseObject
  • 默認情況下，案例對象會獲得toString和hashCode方法，但普通對象不會。
  • 默認情況下，案例對象是可序列化的，但普通對象不是。

與普通類（Normal Class）相比，案例類（Case-class）的主要優勢或好處有哪些？

案例類相對於普通類的主要優勢或好處如下：

  • 通過自動添加一些有用的方法，避免了大量的樣板代碼。
  • 默認情況下支持不可變性，因為它的參數是‘val’。
  • 在模式匹配中使用方便。
  • 不需要使用‘new’關鍵字來創建案例類的實例。
  • 默認情況下，支持序列化和反序列化。

在Scala中，isInstanceOf和asInstanceOf方法的使用是什麼？Java中有類似的概念嗎？

isInstanceOf和asInstanceOf方法都定義在Any類中，因此不需要導入任何類或對象來獲取這些方法。isInstanceOf方法用於測試對象是否屬於給定類型。如果是，則返回true，否則返回false。

   scala> val str = "Hello"
   
   scala>str.isInstanceOf[String]
   res0: Boolean = false

asInstanceOf方法用於將對象轉換為給定類型。如果給定的對象和類型是相同的，則將其轉換為給定的類型。否則，它會拋出java.lang.ClassCastException異常。

 scala> val str = "Hello".asInstanceOf[String]
 str: String = Hello

在Java中，’instanceof’關鍵字類似於Scala的’isInstanceOf’方法。在Java中，以下類型轉換方式類似於Scala的’asInstanceOf’方法。

AccountService service = (AccountService)
 context.getBean("accountService");

如何證明默認情況下，Case Object是可序列化的，而Normal Object則不是？

是的，默认情况下，Case Object 是可序列化的。但普通对象不是。我们可以通过使用 isInstanceOf 方法来证明这一点，如下所示：

scala> object MyNormalObject
defined object MyNormalObject

scala> MyNormalObject.isInstanceOf[Serializable]
res0: Boolean = false

scala> case object MyCaseObject
defined object MyCaseObject

scala> MyCaseObject.isInstanceOf[Serializable]
res1: Boolean = true

Scala 中数组和列表的区别？

  • 数组始终是可变的，而列表始终是不可变的。
  • 一旦创建，我们可以更改数组的值，而无法更改列表对象。
  • 数组是固定大小的数据结构，而列表是可变大小的数据结构。列表的大小会根据我们在其上执行的操作自动增加或减小。
  • 数组是不变的，而列表是协变的。

注意：- 如果您对不变和协变不确定，请阅读我关于 Scala 面试问题的下一篇文章。

Scala 中“val”和“lazy val”之间有什么区别？什么是急切评估？什么是惰性评估？

正如我们在我关于基本 Scala 面试问题的讨论中所述，“val”表示值或常量，用于定义不可变变量。程序评估有两种类型：

  • 渴求評估
  • 懶惰評估

渴求評估意味著在編譯時或程序部署時評估程序，無論客戶是否使用該程序。懶惰評估意味著在運行時按需評估程序，這意味著當客戶訪問該程序時才進行評估。“val”和“lazy val”之間的區別在於，“val”用於定義急於評估的變量，“lazy val”也用於定義變量，但它們是懶惰評估的。

Scala中equals方法和==之間的關係是什麼？區分Scala的==和Java的==運算符？

在Scala中，我們無需調用equals()方法來比較兩個實例或對象。當我們使用==比較兩個實例時，Scala會自動調用該對象的equals()方法。Java的==運算符用於檢查引用相等性，即兩個引用是否指向同一個對象。Scala的==用於檢查實例相等性，即兩個實例是否相等。

Scala 的内部类与 Java 的内部类有何区别？

在 Java 中，内部类与外部类关联，即内部类是外部类的成员。与 Java 不同，Scala 对待外部类和内部类的关系有所不同。Scala 的内部类与外部类对象关联。

什么是 Diamond Problem？Scala 是如何解决 Diamond Problem 的？

A Diamond Problem is a Multiple Inheritance problem. Some people calls this problem as Deadly Diamond Problem. In Scala, it occurs when a Class extends more than one Traits which have same method definition as shown below. Unlike Java 8, Scala solves this diamond problem automatically by following some rules defined in Language. Those rules are called “Class Linearization”. Example:-

trait A{   
  def display(){ println("From A.display")  }
}
trait B extends A{ 
  override def display() { println("From B.display") }
}
trait C extends A{ 
  override def display() { println("From C.display") }
}
class D extends B with C{ }

object ScalaDiamonProblemTest extends App {
    val d = new D
    d display
}

这里的输出是从特质 C 的 “From C.display”。Scala 编译器从右向左读取 “extends B with C”，并从最左边的特质 C 中获取 “display” 方法的定义。注意：查看我的关于 “Scala Traits in Depth” 的帖子，以获取清晰的解释。

为什么 Scala 没有 “static” 关键字？这个决定的主要原因是什么？

正如我們所知，Scala根本沒有“static”關鍵字。這是Scala團隊做出的設計決定。採取這一決定的主要原因是使Scala成為一個純粹的面向對象的語言。“static”關鍵字意味著我們可以在不創建對象或不使用對象的情況下訪問該類的成員。這與面向對象的原則完全相反。如果一種語言支持“static”關鍵字，那麼該語言就不是純粹的面向對象的語言。例如，由於Java支持“static”關鍵字，因此它不是一個純粹的面向對象的語言。但Scala是一個純粹的面向對象的語言。

在Scala中，“object”關鍵字的用途是什麼？如何在Scala中創建單例對象？

在Scala中，object關鍵字用於以下目的：

  • 它用於在Scala中創建單例對象。
object MySingletonObject

在這裡，MySingletonObject自動成為單例對象。- object關鍵字用於定義可執行的Scala應用程序，即可執行的Scala程序。

object MyScalaExecutableProgram{   
   def main(args: Array[String]){
       println("Hello World")
   }
}

當我們在對象中定義main方法（與Java中的main()方法相同）時，它將自動成為可執行的Scala程序。- 它用於定義靜態成員，如靜態變量和靜態方法，而無需使用“static”關鍵字。

object MyScalaStaticMembers{ 
  val PI: Double = 3.1414  
  def add(a: Int, b: Int) = a + b
}

透過定義 PI 變數並添加方法將成為靜態成員。這意味著我們可以在不創建單獨對象的情況下調用它們，如 MyScalaStaticMembers.add(10,20)。- 它被用來定義工廠方法。請參見我下一個關於此的問題。

如何使用對象關鍵字在 Scala 中定義工廠方法？定義對象中的工廠方法的用途是什麼？

在 Scala 中，我們使用 ‘object’ 關鍵字來定義工廠方法。這些工廠方法的主要目的是避免使用 ‘new’ 關鍵字。不使用 ‘new’ 關鍵字，我們就可以創建對象。定義工廠方法：我們可以使用 apply 方法在 Scala 中定義工廠方法。如果我們有主構造器和多個輔助構造器，那麼我們需要定義多個 apply 方法，如下所示。

class Person(val firstName: String, val middleName: String, val lastName: String){
  def this(firstName: String, lastName: String){
    this(firstName,"",lastName)
  }
}
object Person{
  def apply(val firstName: String, val middleName: String, val lastName: String) 
        = new Person(firstName,middleName,lastName)

  def apply(val firstName: String, val lastName: String) 
        = new Person(firstName, lastName)
}

現在我們可以不使用 new 關鍵字創建 Person 對象，或者根據你的願望使用 new 關鍵字。

val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")

Scala中的apply方法是什么？Scala中的unapply方法是什么？Scala中apply和unapply方法有什么区别？

在Scala中，apply和unapply方法发挥着非常重要的作用。它们在Play框架中在将表单数据和模型数据映射和取消映射之间也非常有用。简单来说，

  • apply方法：用于从组件中组合或组装对象。
  • unapply方法：用于从对象中分解或拆卸组件。

Scala的apply方法：用于通过使用其组件来组合对象。假设我们想要创建一个Person对象，然后使用firstName和lastName两个组件组合Person对象，如下所示。

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)
}

Scala的unapply方法：用于将对象分解为其组件。它遵循apply方法的相反过程。假设我们有一个Person对象，然后我们可以将该对象分解为其两个组件：firstName和lastName，如下所示。

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)

    def unapply(p: Person): (String,String) 
        = (p.firstName, p.lastName)
}

在 Scala 中，當我們創建一個類的實例時，如果不使用 ‘new’ 關鍵字，它是如何在內部運作的？什麼情況下我們會採用這種方法？如何在 Scala 中聲明私有構造函數？

在 Scala 中，當我們創建一個類的實例時，如果不使用 ‘new’ 關鍵字，內部會調用 Companion 對象中相應的 apply 方法。這裡的「相應的 apply 方法」是指與參數匹配的方法。我們何時選擇這個選項：當我們需要提供私有構造函數並且需要避免使用 ‘new’ 關鍵字時，我們可以僅實現具有相同參數集的 apply 方法，並允許我們的類用戶在不使用 new 關鍵字的情況下創建它。

在Scala中，我們如何聲明私有的主構造函數？在Scala中如何調用私有的主構造函數？

在Scala中，我們可以非常輕鬆地聲明一個私有的主構造函數。只需像定義普通主構造函數一樣，在類名之後、參數列表之前加上“private”即可，如下所示：

class Person private (name: String)
object Person{
 def apply(name: String) = new Person(name)
}

由於這是一個私有構造函數，我們無法從外部調用它。我們應該提供一個工廠方法（即apply方法），如上所示間接使用該構造函數。

在Scala中，伴生對象能訪問其伴生類的私有成員嗎？

通常，私有成員意味着僅在該類內部可訪問。然而，Scala的伴生類和伴生對象提供了另一個功能。在Scala中，伴生對象可以訪問其伴生類的私有成員，伴生類也可以訪問其伴生對象的私有成員。

Scala 中關於兩個獨立關鍵字 class 和 object 的主要設計決策是什麼？在 Scala 中我們如何定義實例成員和靜態成員？

在 Scala 中，我們使用 class 關鍵字來定義實例成員，並使用 object 關鍵字來定義靜態成員。Scala 中沒有 static 關鍵字，但我們仍然可以使用 object 關鍵字來定義它們。這個主要設計決策是為了清晰地區分實例和靜態成員，使它們鬆散耦合。另一個主要原因是避免 static 關鍵字，從而使 Scala 成為一個純粹的面向對象的語言。

在 Scala 中，object 是什麼？它是一個單例對象還是類的實例？

不像 Java，Scala 對於 ‘object’ 有兩個意思。不要困惑，我會清楚地解釋。在 Java 中，我們對於 ‘object’ 只有一個含義，那就是“類的實例”。

  • 與 Java 類似，object 的第一個含義是“類的實例”。
val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")
  • 第二層含義是在Scala中，object是一個關鍵字。它用於定義Scala可執行程序、伴生對象、單例對象等。

Scala中的伴生對象是什麼？Scala中的伴生類是什麼？Scala中伴生對象的用途是什麼？

簡單來說，如果一個Scala類和對象具有相同的名稱並且在同一源文件中定義，那麼該類被稱為“伴生類”，該對象被稱為“伴生對象”。當我們使用Scala的“class”關鍵字創建一個類，並使用相同的名稱和同一源文件中的Scala的“object”關鍵字創建一個對象時，那麼該類被稱為“伴生類”，該對象被稱為“伴生對象”。例子：- Employee.scala

class Employee{ }
object Employee{ }

在Scala中，伴生對象的主要目的是定義apply方法，並避免在創建該伴生類對象的實例時使用new關鍵字。

如何在Scala中實現接口？

正如我們從Java的背景中知道，我們使用interface來定義接口。然而，在Scala中並沒有interface的概念，甚至沒有interface這個關鍵字。Scala有一個更強大和靈活的概念，即trait，用於這個目的。

在Scala中，Range是什麼？如何在Scala中創建Range？

Range在Scala中是一個惰性集合。Range是在’scala’包中可用的類，就像’scala.Range’一樣。它用於表示整數值的序列。它是有序的整數序列。例子：-

scala> 1 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 until 10
res1: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

在Scala中，Nothing類型有多少個值？

在Scala中，Nothing類型沒有值，即為零。它沒有任何值。它是所有Value類和Reference類的子類。

在Scala中，Unit類型有多少個值？

在Scala中，Unit与Java的void关键字类似。它用于表示”没有值存在”。它只有一个值，即()。

什么是纯函数？

A pure function is a function without any observable side-effects. That means it returns always same results irrespective how many times we call it with same inputs. A pure function always gives same output for the same inputs. For Example:-

scala> 10 + 20
res0: Int = 30
scala>
scala> 10 + 20
res0: Int = 30

在Int类中，“+”是一个纯函数。对于相同的输入10和30，无论调用多少次，它都会给出相同的结果30。

在函数式编程中，函数和过程之间有什么区别？

它们都用于执行计算，但在函数式编程世界中它们有一个主要区别。函数是没有副作用的计算单元，而过程是带有副作用的计算单元。

Scala的辅助构造函数和Java的构造函数之间的主要区别是什么？

Scala的輔助構造函數幾乎與Java的構造函數相似，但有一些不同之處。與Java的構造函數相比，輔助構造函數有以下幾個不同之處：

  • 輔助構造函數使用“this”關鍵字調用。
  • 所有輔助構造函數都以相同的名稱“this”定義。在Java中，我們使用類名來定義構造函數。
  • 每個輔助構造函數必須以對先前定義的輔助構造函數或主構造函數的調用開始。
  • 我們使用“def”關鍵字來定義輔助構造函數，就像定義方法/函數一樣。在Java中，構造函數定義和方法定義是不同的。

Scala中的for-comprehension結構中，“yield”關鍵字的用途是什麼？

我們可以在Scala的for-comprehension結構中使用“yield”關鍵字。“for/yield”用於遍歷一組元素並生成相同類型的新集合。它不會更改原始集合。它生成與原始集合類型相同的新集合。例如，如果我們使用“for/yield”結構來遍歷一個List，那麼它只會生成一個新的List。

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)

scala> for(l <- list) yield l*2
res0: List[Int] = List(2, 4, 6, 8, 10)

Scala 的 for-comprehension 架構中的 guard 是什麼？

在 Scala 中，for-comprehension 架構具有 if 子句，用於撰寫條件以過濾某些元素並生成新的集合。這個 if 子句也被稱為 “Guard”。如果 guard 為真，則將該元素添加到新集合中。否則，它不會將該元素添加到原始集合中。例子：- For-comprehension 的 Guard 以生成僅為偶數的數字到新集合中。

scala> val list = List(1,2,3,4,5,6,7,8,9,10)
list: List[Int] = List(1, 2, 3, 4, 5 , 6 , 7 , 8 , 9 , 10)

scala> for(l <- list if l % 2 =0 ) yield l
res0: List[Int] = List(2, 4, 6, 8, 10)

Scala 如何比 Java 8 更自動且更容易地解決繼承鑽石問題？

如果我們使用 Java 8 的帶有默認方法的介面，將會遇到繼承鑽石問題。在 Java 8 中，開發者必須手動解決這個問題。它不提供此問題的默認或自動解決方案。在 Scala 中，使用 Trait 也會遇到相同的問題，但 Scala 非常聰明，使用類線性化概念自動解決了繼承鑽石問題。

在Scala中，模式匹配遵循哪种设计模式？在Java中，’isinstanceof’运算符遵循哪种设计模式？

在Scala中，模式匹配遵循访问者设计模式。同样，Java的’isinstanceof’运算符也遵循访问者设计模式。这就是关于“Scala中级面试问题和答案”的全部内容。我们将在我的后续帖子中讨论一些高级Scala面试问题和答案。如果您喜欢我的帖子或有任何问题/建议，请给我留言。

Source:
https://www.digitalocean.com/community/tutorials/scala-interview-questions