Scalaの面接質問

2年 ago

7 minutes

この投稿を読む前に、「Scala基本的なインタビューの質問と回答」という私の前の投稿をご覧ください。Scala言語の基礎知識を得るためです。この投稿では、経験豊富なScala開発者にとって有用な、さらなるScalaインタビューの質問について話し合います。注意：このリストは既に非常に長くなっているため、残りの質問と回答を含む別の投稿を提供します。その投稿は「Scala中級および上級インタビューの質問と回答」を参照してください。

以下は、スカラインタビューの質問です。

このセクションでは、すべてのScalaの中級インタビューの質問をリストアップし、次のセクションではそれらについて詳しく説明します。

Scalaでは、パターンマッチングはどのデザインパターンに従いますか？Javaではisinstanceof演算子はどのデザインパターンに従いますか？

スカラインタビューの質問と回答

このセクションでは、上記のリストから全ての質問を取り上げ、必要に応じて適切な例を用いて詳しく説明します。もし例を使ってこれらの概念を深く理解したい場合は、Scalaチュートリアルセクションの私の以前の投稿をご覧ください。

Scalaにおけるプライマリーコンストラクタとは何ですか？Scalaにおけるセカンダリーコンストラクタまたは補助コンストラクタとは何ですか？Scalaにおける補助コンストラクタの目的は何ですか？Scalaにおいてコンストラクタをオーバーロードすることは可能ですか？

スカラには2種類のコンストラクタがあります。

Primary Constructor
Auxiliary Constructor

Scalaのプライマリコンストラクタは、クラス定義と一緒に定義されるコンストラクタです。すべてのクラスは、パラメータコンストラクタまたはパラメータなしコンストラクタのいずれかを持つ必要があります。例：

class Person

上記のPersonクラスには、このクラスのインスタンスを作成するためのゼロパラメータまたはパラメータのないプライマリコンストラクタがあります。

class Person (firstName: String, lastName: String)

上記のPersonクラスには、このクラスのインスタンスを作成するための2つのパラメーターを持つ主コンストラクターがあります。補助コンストラクタは、補助コンストラクタとも呼ばれます。以下に示すように、defキーワードとthisキーワードを使用して、補助コンストラクタを宣言することができます。

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

スカラにおける補助コンストラクタの利用方法は何ですか？Scalaで補助コンストラクタを定義する際には、どのようなルールに従うべきですか？

Scalaでは、補助コンストラクタの主な目的は、コンストラクタをオーバーロードすることです。Javaと同様に、さまざまな種類のコンストラクタを提供することができますので、使用者は自身の要件に基づいて適切なものを選択することができます。補助コンストラクタのルール：

They are like methods only. Like methods, we should use ‘def’ keyword to define them.
We should use same name ‘this’ for all Auxiliary Constructors.
Each Auxiliary Constructor should start with a call to previous defined another Auxiliary Constructor or Primary Constructor. Otherwise compile-time error.
Each Auxiliary Constructor should differ with their parameters list: may be by number or types.
Auxiliary Constructors cannot call a super class constructors. They should call them through Primary Constructor only.
All Auxiliary Constructors call their Primary Constructor either directly or indirectly through other Auxiliary Constructors.

「Scalaのコンストラクタについて学びたい場合は、私のScalaの記事を参照してください。プライマリコンストラクタと補助コンストラクタがあります。」

Scalaにおいて、ArrayとArrayBufferの違いは何ですか？

スカラにおけるArrayとArrayBufferの違いは次のとおりです。

Array is fixed size array. We cannot change its size once its created.
ArrayBuffer is variable size array. It can increase or decrease it’s size dynamically.
Array is something similar to Java’s primitive arrays.
ArrayBuffer is something similar to Java’s ArrayList.

ケースクラスとは何ですか？ケースオブジェクトとは何ですか？ケースクラスの利点は何ですか？

ケースクラスは、「case class」というキーワードで定義されたクラスです。ケースオブジェクトは、「case object」というキーワードで定義されたオブジェクトです。この「case」キーワードのおかげで、冗長なコードを回避するためのいくつかの利点が得られます。私たちは「new」キーワードを使用せずにケースクラスオブジェクトを作成することができます。デフォルトでは、Scalaコンパイラはコンストラクタのパラメータに対して「val」というプレフィックスを付けます。そのため、ケースクラスのコンストラクタのパラメータは、普通のクラスでは不可能ですが、valまたはvarを使用せずにクラスメンバーになります。ケースクラスの利点は以下の通りです。

By default, Scala Compiler adds toString, hashCode and equals methods. We can avoid writing this boilerplate code.
By default, Scala Compiler adds companion object with apply and unapply methods that’s why we don’t need new keyword to create instances of a case class.
By default, Scala Compiler adds copy method too.
We can use case classes in Pattern Matching.
By default, Case class and Case Objects are Serializable.

ケースオブジェクトと通常のオブジェクト（普通のオブジェクト）の違いは何ですか？

Normal object is created using “object” keyword. By default, It’s a singleton object.

object MyNormalObject

Case Object is created using “case object” keywords.By default, It’s also a singleton object

case object MyCaseObject

By Default, Case Object gets toString and hashCode methods. But normal object cannot.
By Default, Case Object is Serializable. But normal object is not.

通常のクラスと比較すると、ケースクラスの主な利点やメリットは何ですか？ (Tsūjō no kurasu to hikaku suru to, kēsu kurasu no shuyō riten ya meritto wa nanidesu ka?)

以下はCaseクラスが通常のクラスに比べて持つ主な利点またはメリットです：

Avoids lots of boiler-plate code by adding some useful methods automatically.
By default, supports Immutability because it’s parameters are ‘val’
Easy to use in Pattern Matching.
No need to use ‘new’ keyword to create instance of Case Class.
By default, supports Serialization and Deserialization.

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 は Serializable であり、Normal 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におけるArrayとListの違いは何ですか？

Arrays are always Mutable where as List is always Immutable.
Once created, We can change Array values where as we cannot change List Object.
Arrays are fixed-size data structures where as List is variable-sized data structures. List’s size is automatically increased or decreased based on it’s operations we perform on it.
Arrays are Invariants where as Lists are Covariants.

もし、InvariantとCovariantについて自信がない場合は、Scalaインタビューの質問に関しては、私の次の投稿を読んでください。

「val」と「lazy val」の違いは何ですか？イーガー評価とは何ですか？レイジー評価とは何ですか？

私たちは私の基本的なScalaインタビューの質問で話し合ったように、「val」は値または定数を意味し、イミュータブルな変数を定義するために使用されます。プログラムの評価には2種類あります。

Eager Evaluation
Lazy Evaluation

イーガー評価は、プログラムのコンパイル時またはプログラムの展開時に、クライアントがそのプログラムを使用しているかどうかに関係なく評価されることを意味します。レイジー評価は、クライアントがプログラムにアクセスする場合にのみ、プログラムを実行時に必要に応じて評価することを意味します。「val」と「lazy val」の違いは、「val」は積極的に評価される変数を定義するために使用され、また「lazy val」も変数を定義するために使用されますが、遅延評価が行われます。

Scalaにおいてequalsメソッドと==の関係は何ですか？ Scalaの==とJavaの==演算子の違いを説明してください。

Scalaでは、2つのインスタンスまたはオブジェクトを比較する際にequals()メソッドを呼び出す必要はありません。Scalaでは、==を使用して2つのインスタンスを比較すると、自動的にそのオブジェクトのequals()メソッドが呼び出されます。Javaの==演算子は、2つの参照が同じオブジェクトを指しているかどうかをチェックするために使用されます。Scalaの==は、2つのインスタンスが等しいかどうかをチェックするために使用されます。

Scalaの内部クラスとJavaの内部クラスの違いは何ですか？

Javaでは、内部クラスは外部クラスと関連付けられます。内部クラスは、外部クラスのメンバーです。しかし、Scalaでは、外部クラスと内部クラスの関係は異なります。Scalaの内部クラスは、外部クラスのオブジェクトと関連付けられます。

ダイヤモンド問題とは何ですか？スカラはダイヤモンド問題をどのように解決しますか？

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」というキーワードは、オブジェクトを作成せずにクラスのメンバーにアクセスすることを意味します。これは完全にOOPの原則に反しています。もし言語が「static」キーワードをサポートしているならば、その言語は純粋なオブジェクト指向言語ではありません。例えば、Javaは「static」キーワードをサポートしているため、純粋なオブジェクト指向言語ではありません。しかし、Scalaは純粋なオブジェクト指向言語です。

「Scalaの「object」キーワードの使い方は何ですか？また、Scalaでシングルトンオブジェクトを作成する方法はありますか？」

Scalaでは、objectキーワードは以下の目的で使用されます：

It is used to create singleton object in Scala.

object MySingletonObject

ここでは、MySingletonObjectは自動的にシングルトンオブジェクトになります。オブジェクトキーワードは、実行可能な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でobjectキーワードを使用してFactoryメソッドを定義する方法は何ですか？オブジェクトでのFactoryメソッドの定義の利点は何ですか？

Scalaでは、ファクトリーメソッドを定義するために「object」キーワードを使用します。Scalaにおけるこれらのファクトリーメソッドの主な目的は、「new」キーワードを使用せずにオブジェクトを作成することです。ファクトリーメソッドを定義するためには、次に示すようにapplyメソッドを使用することができます。プライマリコンストラクタと複数の補助コンストラクタがある場合、次のように複数の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オブジェクトを作成することができます。

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

Scalaにおけるapplyメソッドは何ですか？Scalaにおけるunapplyメソッドは何ですか？applyメソッドとunapplyメソッドの違いは何ですか？

Scalaでは、applyメソッドとunapplyメソッドは非常に重要な役割を果たします。また、Play Frameworkでは、FormデータとModelデータの間でデータをマッピングおよびアンマッピングする際に非常に便利です。簡単に言えば、

apply method: To compose or assemble an object from it’s components.
unapply method: To decompose or dis-assemble an object into it’s components.

Scalaのapplyメソッドは、そのコンポーネントを使用してオブジェクトを構成するために使用されます。例えば、Personオブジェクトを作成したい場合、firstNameとlastNameの2つのコンポーネントを使用して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の2つのコンポーネントに分解することができます。

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メソッドのみを実装し、クラスのユーザーが新たなキーワードを使用せずにインスタンスを作成できるようにします。

Scalaでプライベートなプライマリコンストラクタを宣言する方法はありますか？Scalaでプライベートなプライマリコンストラクタを呼び出す方法はありますか？

Scalaでは、プライベートなプライマリコンストラクタを簡単に宣言できます。以下に示すように、クラス名の後ろ、パラメータリストの前に「private」を追加して、プライマリコンストラクタを定義するだけです。

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

プライベートなコンストラクターであるため、外部からは呼び出すことができません。上記に示されたように、ファクトリーメソッド（applyメソッド）を提供し、そのコンストラクターを間接的に使用する必要があります。

スカラのコンパニオンオブジェクトは、自身のコンパニオンクラスのプライベートメンバーにアクセスしますか？

一般的に、プライベートメンバーはそのクラス内でのみアクセス可能です。しかし、Scalaのコンパニオンクラスとコンパニオンオブジェクトでは、別の機能が提供されています。Scalaでは、コンパニオンオブジェクトは自身のコンパニオンクラスのプライベートメンバーにアクセスできますし、またコンパニオンクラスも自身のコンパニオンオブジェクトのプライベートメンバーにアクセスできます。

スカラにおける「クラス」と「オブジェクト」という2つの異なるキーワードに関する主なデザインの決定事項は何ですか？また、スカラではインスタンスメンバーと静的メンバーをどのように定義しますか？

Scalaでは、インスタンスメンバーを定義するためにclassキーワードを使用し、静的メンバーを定義するためにobjectキーワードを使用します。Scalaにはstaticキーワードはありませんが、objectキーワードを使用してそれらを定義することができます。これに関する主な設計上の決定は、インスタンスメンバーと静的メンバーの明確な分離です。それらは緩く結合されています。もう1つの主な理由は、Scalaが純粋なオブジェクト指向言語になるためにstaticキーワードを避けるためです。

Scalaにおける「オブジェクト」とは何ですか？シングルトンオブジェクトのことですか、クラスのインスタンスのことですか？

Javaとは異なり、Scalaには「オブジェクト」という言葉には2つの意味があります。これについて混乱しないでください、私が明確に説明します。Javaでは、「クラスのインスタンス」という意味しかありません。

Like Java, the first meaning of object is “An instance of a class”.

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

Second meaning is that object is a keyword in Scala. It is used to define Scala Executable programs, Companion Objects, Singleton Objects etc.

スカラにおけるCompanion Objectとは何ですか？スカラにおけるCompanion Classとは何ですか？スカラにおけるCompanion Objectの利用方法は何ですか？

シンプルに言えば、Scalaのクラスとオブジェクトが同じ名前で同じソースファイル内に定義されている場合、そのクラスは「コンパニオンクラス」と呼ばれ、そのオブジェクトは「コンパニオンオブジェクト」と呼ばれます。Scalaの「class」キーワードを使用してクラスを作成し、同じ名前の「object」キーワードを使用してオブジェクトを作成すると、そのクラスが「コンパニオンクラス」として認識され、そのオブジェクトが「コンパニオンオブジェクト」として認識されます。例：Employee.scala

class Employee{ }
object Employee{ }

スカラでは、コンパニオンオブジェクトの主な目的は、適用メソッドを定義し、そのコンパニオンクラスのオブジェクトのインスタンスを作成する際にnewキーワードを使用しないようにすることです。

Scalaでインターフェースを実装する方法はどのようなものですか？

Javaのバックグラウンドからわかるように、私たちはインターフェースを利用してコンタクトを定義します。しかし、Scalaにはインターフェースの概念はありません。さらに、Scalaにはインターフェースのキーワードもありません。Scalaには、より強力かつ柔軟な概念であるトレイトがこの目的で利用されます。

スカラにおける「レンジ（Range）」とはどのようなものですか？スカラでレンジを作成する方法はありますか？

範囲はスカラ（Scala）における遅延コレクションです。範囲は、scala.Rangeのような「scala」パッケージにあるクラスです。整数の値のシーケンスを表すために使用されます。整数の順序付きシーケンスです。例：

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はJavaのvoidキーワードに似たものです。これは「値が存在しない」ことを表すために使用されます。その値は()という唯一の値です。

純粋関数とは何ですか？

純粋関数とは、どんな観察可能な副作用も持たない関数のことを指します。つまり、同じ入力を何回呼び出しても常に同じ結果を返します。純粋関数は常に同じ入力に対して同じ出力を返します。例えば、

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

ここでは、Intクラスで使用できる「+」という純粋な関数があります。同じ入力である10と30に対して、何回呼び出しても同じ結果である30を返します。

FPにおいて、関数と手続きの違いは何ですか？ (FPにおいて、かんすうとしゅじきのちがいはなんですか？)

両者は計算を実行するために使用されますが、関数型プログラミングの世界においては1つの大きな違いがあります。関数は副作用のない計算単位ですが、手続きは副作用を持つ計算単位となります。

Scalaの補助コンストラクタとJavaのコンストラクタの主な違いは何ですか？

Scalaの補助コンストラクタは、Javaのコンストラクタとほぼ同じですが、若干の違いがあります。Javaのコンストラクタと比較すると、補助コンストラクタは以下のようなわずかな違いがあります。

The auxiliary constructors are called using “this” keyword.
All auxiliary constructor are defined with the same name that is “this”. In Java, we use class name to define constructors.
Each auxiliary constructor must start with a call to a previously defined auxiliary constructor or the primary constructor.
We use ‘def’ keyword to define auxiliary constructors like method/function definition. In Java, constructor definition and Method definition is different.

Scalaのfor-comprehension構文における ‘yield’ キーワードの用途は何ですか？

Scalaのforコンプリヘンション構文では、「yield」キーワードを使用することができます。「for/yield」は、要素のコレクションを反復処理し、同じタイプの新しいコレクションを生成するために使用されます。これによってオリジナルのコレクションは変更されません。オリジナルのコレクションと同じタイプの新しいコレクションが生成されます。たとえば、Listを反復処理するために「for/yield」構文を使用すると、新しい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コンプリヘンション構文には、要素をフィルタリングし新しいコレクションを生成するための条件を記述するif節があります。このif節は「ガード」とも呼ばれます。ガードが真の場合、その要素を新しいコレクションに追加します。そうでなければ、元のコレクションには追加しません。例：- forコンプリヘンションのガードを使用して、新しいコレクションに偶数のみを生成します。

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でもTraitsを使用すると同じ問題が発生しますが、Scalaは非常に賢く、Class Linearizationの概念を使用して自動的に継承のダイヤモンド問題を解決します。

Scalaでは、パターンマッチングはどのデザインパターンに従いますか？Javaでは、’isinstanceof’演算子はどのデザインパターンに従いますか？

Scalaでは、パターンマッチングはVisitorデザインパターンに従います。同様に、Javaの「isinstanceof」演算子もVisitorデザインパターンに従います。これが「Scala Intermediate Interview Questions and Answers」についてのすべてです。来る投稿では、いくつかのAdvanced Scala Interview Questions and Answersについて議論します。私の投稿が気に入ったり、問題や提案がある場合は、コメントを残してください。