Scala-Interviewfragen

Tutorials
Scala

Bevor Sie diesen Beitrag lesen, gehen Sie bitte durch meinen vorherigen Beitrag unter „Scala Basic Interview Fragen und Antworten„, um grundlegende Kenntnisse über die Scala-Sprache zu erhalten. In diesem Beitrag werden wir einige weitere Scala-Interviewfragen diskutieren, die für erfahrene Scala-Entwickler nützlich sind. Hinweis:- Da diese Liste bereits sehr umfangreich geworden ist, werde ich einen weiteren Beitrag mit den verbleibenden Fragen und Antworten veröffentlichen. Bitte beachten Sie diesen Beitrag unter: „Scala Intermediate und Advanced Interview Fragen und Antworten„.

Scala Interview Fragen

In diesem Abschnitt werden wir alle Scala Intermediate Interviewfragen auflisten, und im nächsten Abschnitt werden wir sie im Detail besprechen.

  1. Was ist der Primärkonstruktor? Was ist der Sekundär- oder Hilfskonstruktor in Scala?
  2. Was ist die Verwendung von Hilfskonstruktoren in Scala? Bitte erklären Sie die Regeln, die beim Definieren von Hilfskonstruktoren in Scala zu beachten sind.
  3. Was sind die Unterschiede zwischen Array und ArrayBuffer in Scala?
  4. Was ist eine Case-Klasse? Was ist ein Case-Objekt? Was sind die Vorteile einer Case-Klasse?
  5. Was ist der Unterschied zwischen Case-Objekt und Objekt (normales Objekt)?
  6. Wenn man eine Case-Klasse mit einer Normalen Klasse vergleicht, welche sind die wichtigsten Vorteile oder Nutzen einer Case-Klasse?
  7. Was ist die Verwendung der Methoden isInstanceOf und asInstanceOf in Scala? Gibt es ein ähnliches Konzept in Java?
  8. Wie beweist man, dass standardmäßig ein Case-Objekt serialisierbar ist und ein normales Objekt nicht?
  9. Unterschied zwischen Array und Liste in Scala?
  10. Was ist der Unterschied zwischen „val“ und „lazy val“ in Scala? Was ist Eager Evaluation? Was ist Lazy Evaluation?
  11. Was ist die Beziehung zwischen der equals Methode und == in Scala? Unterscheide Scala’s == und Java’s == Operator?
  12. Unterschied zwischen Scala’s Innerer Klasse und Java’s Innerer Klasse?
  13. Was ist das Diamond Problem? Wie löst Scala das Diamond Problem?
  14. Warum hat Scala KEIN „static“ Schlüsselwort? Was ist der Hauptgrund für diese Entscheidung?
  15. Was ist die Verwendung des „object“ Schlüsselworts in Scala? Wie erstellt man Singleton-Objekte in Scala?
  16. Wie definiert man Factory-Methoden mit dem Schlüsselwort object in Scala? Was ist der Nutzen der Definition von Factory-Methoden in object?
  17. Was ist die apply Methode in Scala? Was ist die unapply Methode in Scala? Was ist der Unterschied zwischen apply und unapply Methoden in Scala?
  18. Wie funktioniert es unter der Haube, wenn wir eine Instanz einer Klasse ohne Verwendung des ’new‘ Schlüsselworts in Scala erstellen? Wann entscheiden wir uns für diesen Ansatz?
  19. Wie deklarieren wir einen privaten Primärkonstruktor in Scala? Wie rufen wir einen privaten Primärkonstruktor in Scala auf?
  20. Does a Companion object access private members of its Companion class in Scala?
  21. Was ist die Hauptdesignentscheidung bezüglich zweier separater Schlüsselwörter: Klasse und Objekt in Scala? Wie definieren wir Instanzmember und statische Member in Scala?
  22. Was ist ein Objekt in Scala? Ist es ein Singleton-Objekt oder eine Instanz einer Klasse?
  23. Was ist ein Companion-Objekt in Scala? Was ist eine Companion-Klasse in Scala? Wofür wird das Companion-Objekt in Scala verwendet?
  24. Wie implementiert man Schnittstellen in Scala?
  25. Was ist eine Reichweite in Scala? Wie erstellt man eine Reichweite in Scala?
  26. Wie viele Werte des Typs Nothing gibt es in Scala?
  27. Wie viele Werte des Typs Unit gibt es in Scala?
  28. Was ist eine Reichweite in Scala? Wie erstellt man eine Reichweite in Scala?
  29. Was ist der Unterschied zwischen einer Funktion und einem Verfahren in FP?
  30. Was sind die wesentlichen Unterschiede zwischen den Hilfskonstruktoren von Scala und den Konstruktoren von Java?
  31. Wofür wird das Schlüsselwort „yield“ im For-Comprehension-Konstrukt von Scala verwendet?
  32. Was ist ein Wächter im For-Comprehension-Konstrukt von Scala?
  33. Wie löst Scala das Problem des Diamanterbes automatisch und einfacher als Java 8?
  34. Welchem Designmuster folgt das Pattern Matching in Scala? Welchem Designmuster folgt der ‚isinstanceof‘-Operator in Java?

Fragen und Antworten zum Scala-Interview

In diesem Abschnitt werden wir jede Frage aus der obigen Liste aufgreifen und ausführlich mit geeigneten Beispielen diskutieren (falls erforderlich). Wenn Sie diese Konzepte mit Beispielen im Detail verstehen möchten, lesen Sie bitte meine vorherigen Beiträge im Abschnitt Scala-Tutorials.

Was ist der primäre Konstruktor? Was ist der sekundäre oder Hilfskonstruktor in Scala? Was ist der Zweck des Hilfskonstruktors in Scala? Ist es möglich, Konstruktoren in Scala zu überladen?

Scala hat zwei Arten von Konstruktoren:

  • Primärkonstruktor
  • Hilfskonstruktor

Primärkonstruktor In Scala ist der Primärkonstruktor ein Konstruktor, der bereits mit der Klassendefinition definiert ist. Jede Klasse muss einen Primärkonstruktor haben: Entweder einen Parameterkonstruktor oder einen parameterlosen Konstruktor. Beispiel:

class Person

Die obige Person-Klasse hat einen Nullparameter- oder keinen Parameter- oder parameterlosen Primärkonstruktor, um Instanzen dieser Klasse zu erstellen.

class Person (firstName: String, lastName: String)

Die oben genannte Person-Klasse verfügt über einen Zwei-Parameter-Primärkonstruktor, um Instanzen dieser Klasse zu erstellen. Hilfskonstruktor Ein Hilfskonstruktor ist auch als Sekundärkonstruktor bekannt. Wir können einen Sekundärkonstruktor mit den Schlüsselwörtern ‚def‘ und ‚this‘ deklarieren, wie unten gezeigt:

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

Wofür dienen Hilfskonstruktoren in Scala? Bitte erläutern Sie die Regeln für die Definition von Hilfskonstruktoren in Scala.

In Scala besteht der Hauptzweck von Hilfskonstruktoren darin, Konstruktoren zu überladen. Wie in Java können wir verschiedene Arten von Konstruktoren bereitstellen, damit der Benutzer den richtigen basierend auf seinen Anforderungen auswählen kann. Regeln für Hilfskonstruktoren:

  • Sie sind wie Methoden. Wie bei Methoden sollten wir das Schlüsselwort ‚def‘ verwenden, um sie zu definieren.
  • Wir sollten für alle Hilfskonstruktoren denselben Namen ‚this‘ verwenden.
  • Jeder Hilfskonstruktor sollte mit einem Aufruf zu einem zuvor definierten anderen Hilfskonstruktor oder Primärkonstruktor beginnen. Andernfalls gibt es einen Kompilierungsfehler.
  • Jeder Hilfskonstruktor sollte sich in seiner Parameterliste unterscheiden: entweder durch Anzahl oder Typen.
  • Hilfskonstruktoren können nicht direkt einen Konstruktor der Superklasse aufrufen. Sie müssen sie nur über den Primärkonstruktor aufrufen.
  • Alle Hilfskonstruktoren rufen entweder direkt oder indirekt ihren Primärkonstruktor auf.

HINWEIS: Wenn Sie mehr über die Konstruktoren in Scala erfahren möchten, lesen Sie bitte meine Scala-Beiträge zu Primärkonstruktor und Hilfskonstruktor.

Was sind die Unterschiede zwischen Array und ArrayBuffer in Scala?

Unterschiede zwischen Array und ArrayBuffer in Scala:

  • Ein Array hat eine feste Größe. Die Größe kann nach der Erstellung nicht geändert werden.
  • Ein ArrayBuffer hat eine variable Größe. Die Größe kann dynamisch vergrößert oder verkleinert werden.
  • Ein Array ähnelt den primitiven Arrays in Java.
  • Ein ArrayBuffer ähnelt dem ArrayList in Java.

Was ist eine Fallklasse? Was ist ein Fallobjekt? Was sind die Vorteile einer Fallklasse?

Eine Fallklasse ist eine Klasse, die mit den Schlüsselwörtern „case class“ definiert ist. Ein Fallobjekt ist ein Objekt, das mit den Schlüsselwörtern „case object“ definiert ist. Aufgrund dieses „case“-Schlüsselworts erhalten wir einige Vorteile, um Boilerplate-Code zu vermeiden. Wir können Fallklassenobjekte ohne Verwendung des Schlüsselworts „new“ erstellen. Standardmäßig fügt der Scala-Compiler allen Konstruktorparametern „val“ hinzu. Aus diesem Grund werden die Konstruktorparameter einer Fallklasse ohne Verwendung von val oder var zu Klassenmembern, was für normale Klassen nicht möglich ist. Vorteile einer Fallklasse:

  • Standardmäßig fügt der Scala-Compiler die Methoden toString, hashCode und equals hinzu. Wir können das Schreiben dieses Boilerplate-Codes vermeiden.
  • Standardmäßig fügt der Scala-Compiler ein Begleitobjekt mit den Methoden apply und unapply hinzu, weshalb wir kein neues Schlüsselwort benötigen, um Instanzen einer Fallklasse zu erstellen.
  • Standardmäßig fügt der Scala-Compiler auch die Methode copy hinzu.
  • Wir können Fallklassen im Pattern Matching verwenden.
  • Standardmäßig sind Fallklassen und Fallobjekte serialisierbar.

Was ist der Unterschied zwischen Case Object und normalem Objekt?

  • Ein normales Objekt wird mit dem Schlüsselwort „object“ erstellt. Standardmäßig handelt es sich um ein Singleton-Objekt.
object MyNormalObject
  • Ein Case-Objekt wird mit dem Schlüsselwort „case object“ erstellt. Standardmäßig handelt es sich auch um ein Singleton-Objekt
case object MyCaseObject
  • Standardmäßig erhält ein Case-Objekt die toString- und hashCode-Methoden. Ein normales Objekt jedoch nicht.
  • Standardmäßig ist ein Case-Objekt serialisierbar, ein normales Objekt jedoch nicht.

Im Vergleich zu einer normalen Klasse, was sind die wichtigsten Vorteile oder Nutzen einer Case-Klasse?

Die folgenden sind die wichtigsten Vorteile oder Nutzen einer Case-Klasse gegenüber normalen Klassen:

  • Vermeidet viel Boilerplate-Code, indem automatisch einige nützliche Methoden hinzugefügt werden.
  • Standardmäßig unterstützt sie Unveränderlichkeit, da ihre Parameter ‚val‘ sind.
  • Einfach in der Verwendung bei Pattern Matching.
  • Keine Notwendigkeit, das Schlüsselwort ’new‘ zu verwenden, um eine Instanz einer Case-Klasse zu erstellen.
  • Standardmäßig unterstützt Serialisierung und Deserialisierung.

Was ist die Verwendung der isInstanceOf- und asInstanceOf-Methoden in Scala? Gibt es ein ähnliches Konzept in Java?

Sowohl die isInstanceOf- als auch die asInstanceOf-Methoden sind in der Any-Klasse definiert. Daher ist kein Import erforderlich, um diese Methoden in einer Klasse oder einem Objekt zu erhalten. Die Methode „isInstanceOf“ wird verwendet, um zu testen, ob das Objekt eines bestimmten Typs ist oder nicht. Wenn ja, gibt sie true zurück. Andernfalls wird false zurückgegeben.

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

Die Methode „asInstanceOf“ wird verwendet, um das Objekt auf den angegebenen Typ zu casten. Wenn das angegebene Objekt und der Typ denselben Typ haben, wird es auf den angegebenen Typ umgewandelt. Andernfalls wird eine java.lang.ClassCastException ausgelöst.

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

In Java ist das Schlüsselwort ‚instanceof‘ ähnlich der Methode ‚isInstanceOf‘ in Scala. In Java ist die folgende Art der manuellen Typumwandlung ähnlich der Methode ‚asInstanceOf‘ in Scala.

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

Wie beweisen Sie, dass standardmäßig Case Object Serializable ist und Normal Object nicht?

Ja, standardmäßig ist das Case-Objekt serialisierbar. Aber normale Objekte sind es nicht. Dies können wir durch Verwendung der Methode isInstanceOf wie unten gezeigt nachweisen:

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

Unterschied zwischen Array und Liste in Scala?

  • Arrays sind immer veränderbar, während Listen immer unveränderbar sind.
  • Nach der Erstellung können wir Array-Werte ändern, während wir das Listenobjekt nicht ändern können.
  • Arrays sind Datenstrukturen mit fester Größe, während Listen Datenstrukturen mit variabler Größe sind. Die Größe der Liste wird automatisch erhöht oder verringert, basierend auf den Operationen, die wir darauf ausführen.
  • Arrays sind Invarianten, während Listen Kovarianten sind.

HINWEIS: – Wenn Sie sich nicht sicher sind über Invariante und Kovariante, lesen Sie bitte meinen nächsten Beitrag zu Scala-Interviewfragen.

Was ist der Unterschied zwischen „val“ und „lazy val“ in Scala? Was ist Eager Evaluation? Was ist Lazy Evaluation?

Wie wir in meinen Grundlagen-Scala-Interviewfragen besprochen haben, bedeutet „val“ Wert oder Konstante, die verwendet wird, um unveränderliche Variablen zu definieren. Es gibt zwei Arten von Programmbewertungen:

  • Eifriges Auswerten
  • Faules Auswerten

Eifriges Auswerten bedeutet, dass das Programm zur Kompilierungszeit oder zur Bereitstellungszeit unabhängig davon ausgewertet wird, ob Clients dieses Programm verwenden oder nicht. Faules Auswerten bedeutet, dass das Programm zur Laufzeit bedarfsweise ausgewertet wird, das heißt, wenn Clients auf das Programm zugreifen, wird es erst dann ausgewertet. Der Unterschied zwischen „val“ und „lazy val“ besteht darin, dass „val“ verwendet wird, um Variablen zu definieren, die eifrig ausgewertet werden, und „lazy val“ ebenfalls verwendet wird, um Variablen zu definieren, die faul ausgewertet werden.

Was ist die Beziehung zwischen der equals-Methode und == in Scala? Unterscheide das == in Scala und das == in Java?

In Scala müssen wir NICHT die equals()-Methode aufrufen, um zwei Instanzen oder Objekte zu vergleichen. Wenn wir zwei Instanzen mit == vergleichen, ruft Scala automatisch die equals()-Methode dieses Objekts auf. Der == Operator in Java wird verwendet, um die Referenzgleichheit zu überprüfen, d. h. ob zwei Referenzen auf dasselbe Objekt zeigen oder nicht. Das == in Scala wird verwendet, um die Instanzgleichheit zu überprüfen, d. h. ob zwei Instanzen gleich sind oder nicht.

Unterschied zwischen der Inneren Klasse in Scala und der Inneren Klasse in Java?

In Java ist die Innere Klasse mit der Äußeren Klasse verbunden, wobei die Innere Klasse ein Mitglied der Äußeren Klasse ist. Im Gegensatz dazu behandelt Scala die Beziehung zwischen der Äußeren Klasse und der Inneren Klasse anders. Die Innere Klasse in Scala ist mit dem Objekt der Äußeren Klasse verbunden.

Was ist das Diamond Problem? Wie löst Scala das 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
}

Hier ist die Ausgabe „From C.display“ aus dem Trait C. Der Scala-Compiler liest „extends B with C“ von rechts nach links und nimmt die Methodendefinition „display“ vom linken Trait, also C. HINWEIS: Lesen Sie meinen Beitrag „Scala Traits in Depth“, um dies mit einer klaren Erklärung zu verstehen.

Warum hat Scala KEIN „static“ Schlüsselwort? Was ist der Hauptgrund für diese Entscheidung?

Wie wir wissen, hat Scala KEIN „static“ Schlüsselwort. Dies ist eine Designentscheidung des Scala-Teams. Der Hauptgrund für diese Entscheidung ist, Scala zu einer rein objektorientierten Sprache zu machen. Das „static“ Schlüsselwort bedeutet, dass wir auf Klassenmember zugreifen können, ohne ein Objekt zu erstellen oder ohne ein Objekt zu verwenden. Das widerspricht jedoch vollständig den Grundsätzen der objektorientierten Programmierung. Wenn eine Sprache das „static“ Schlüsselwort unterstützt, handelt es sich nicht um eine reine objektorientierte Sprache. Zum Beispiel ist Java aufgrund der Unterstützung des „static“ Schlüsselworts keine reine objektorientierte Sprache. Aber Scala ist eine reine objektorientierte Sprache.

Wofür wird das Schlüsselwort „object“ in Scala verwendet? Wie erstellt man Singleton-Objekte in Scala?

In Scala wird das Schlüsselwort „object“ für folgende Zwecke verwendet:

  • Es wird verwendet, um Singleton-Objekte in Scala zu erstellen.
object MySingletonObject

Hier wird das Singleton-Objekt „MySingletonObject“ automatisch erstellt.- Das Schlüsselwort „object“ wird verwendet, um ausführbare Scala-Anwendungen zu definieren, also ausführbare Scala-Programme.

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

Wenn wir die main-Methode im Objekt wie oben gezeigt definieren (entspricht der main()-Methode in Java), wird diese automatisch zu einem ausführbaren Scala-Programm.- Es wird verwendet, um statische Member wie statische Variablen und statische Methoden ohne Verwendung des Schlüsselworts „static“ zu definieren.

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

Durch Def PI Variable und Add-Methoden werden als statische Mitglieder. Das bedeutet, dass wir sie aufrufen können, ohne ein separates Objekt zu erstellen, wie z. B. MyScalaStaticMembers.add(10,20).- Es wird verwendet, um Factory-Methoden zu definieren. Bitte sehen Sie sich meine nächste Frage dazu an.

Wie definiert man Factory-Methoden unter Verwendung des Schlüsselworts „object“ in Scala? Was ist der Zweck der Definition von Factory-Methoden in einem Objekt?

In Scala verwenden wir das Schlüsselwort „object“, um Factory-Methoden zu definieren. Der Hauptzweck dieser Factory-Methoden in Scala besteht darin, das Schlüsselwort „new“ zu vermeiden. Ohne das Schlüsselwort „new“ können wir Objekte erstellen. Um Factory-Methoden zu definieren: Wir können die `apply`-Methode verwenden, um Factory-Methoden in Scala zu definieren. Wenn wir einen primären Konstruktor und mehrere Hilfskonstruktoren haben, müssen wir mehrere `apply`-Methoden definieren, wie unten gezeigt.

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)
}

Jetzt können wir Person-Objekte ohne Verwendung des Schlüsselworts „new“ oder mit dem Schlüsselwort „new“ nach Belieben erstellen.

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

Was ist die apply-Methode in Scala? Was ist die unapply-Methode in Scala? Was ist der Unterschied zwischen den apply- und unapply-Methoden in Scala?

In Scala spielen die apply- und unapply-Methoden eine sehr wichtige Rolle. Sie sind auch im Play Framework sehr nützlich, um Daten zwischen Formulardaten und Modelldaten abzubilden und umzuwandeln. In einfachen Worten,

  • apply-Methode: Zum Komponieren oder Zusammenstellen eines Objekts aus seinen Komponenten.
  • unapply-Methode: Zum Zerlegen oder Auseinandernehmen eines Objekts in seine Komponenten.

Scala’s apply-Methode: Sie wird verwendet, um ein Objekt mithilfe seiner Komponenten zu komponieren. Angenommen, wir möchten ein Person-Objekt erstellen, verwenden wir die beiden Komponenten firstName und lastName und komponieren das Person-Objekt wie unten gezeigt.

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

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

Scala’s unapply-Methode: Sie wird verwendet, um ein Objekt in seine Komponenten zu zerlegen. Sie folgt dem umgekehrten Prozess der apply-Methode. Angenommen, wir haben ein Person-Objekt, dann können wir dieses Objekt in seine zwei Komponenten zerlegen: firstName und lastName wie unten gezeigt.

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)
}

Wie funktioniert es unter der Haube, wenn wir eine Instanz einer Klasse in Scala ohne Verwendung des ’new‘-Schlüsselworts erstellen? Wann entscheiden wir uns für diesen Ansatz? Wie deklarieren wir private Konstruktoren in Scala?

In Scala, wenn wir eine Instanz einer Klasse ohne Verwendung des ’new‘-Schlüsselworts erstellen, wird intern ein Aufruf an die entsprechende `apply`-Methode im Begleitobjekt gemacht. Hier bedeutet eine geeignete `apply`-Methode, die mit den Parametern übereinstimmt. Wann wählen wir diese Option: Wenn wir einen privaten Konstruktor bereitstellen müssen und wir das ’new‘-Schlüsselwort vermeiden möchten, können wir nur die `apply`-Methode mit dem gleichen Satz von Parametern implementieren und es unseren Klassenbenutzern ermöglichen, sie ohne das neue Schlüsselwort zu erstellen.

Wie deklarieren wir einen privaten Primärkonstruktor in Scala? Wie rufen wir einen privaten Primärkonstruktor in Scala auf?

In Scala können wir einen privaten Primärkonstruktor sehr einfach deklarieren. Definieren Sie einfach einen Primärkonstruktor wie üblich und fügen Sie unmittelbar nach dem Klassennamen und vor der Parameterliste das Wort ‚private‘ hinzu, wie unten gezeigt:

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

Da es sich um einen privaten Konstruktor handelt, können wir ihn von außen nicht aufrufen. Wir sollten eine Fabrikmethode (das heißt die apply-Methode) wie oben gezeigt bereitstellen und diesen Konstruktor indirekt verwenden.

Kann ein Begleitobjekt in Scala auf private Elemente seiner Begleitklasse zugreifen?

Allgemein bedeutet private Elemente, dass sie nur innerhalb dieser Klasse zugänglich sind. In Scala bietet die Begleitklasse und das Begleitobjekt jedoch eine weitere Funktion. In Scala kann ein Begleitobjekt auf private Elemente seiner Begleitklasse zugreifen, und die Begleitklasse kann auf private Elemente seines Begleitobjekts zugreifen.

Was ist die Hauptdesignentscheidung bezüglich zweier separater Schlüsselwörter: Klasse und Objekt in Scala? Wie definieren wir Instanzmember und statische Member in Scala?

In Scala verwenden wir das Schlüsselwort „class“, um Instanzmember zu definieren, und das Schlüsselwort „object“, um statische Member zu definieren. Scala hat kein Schlüsselwort „static“, aber dennoch können wir sie durch Verwendung des Schlüsselworts „object“ definieren. Die Hauptdesignentscheidung dabei ist die klare Trennung zwischen Instanz- und statischen Membern. Lose Kopplung zwischen ihnen. Ein weiterer wichtiger Grund ist die Vermeidung des Schlüsselworts „static“, damit Scala zu einer reinen OOP-Sprache wird.

Was ist ein Objekt in Scala? Ist es ein Singleton-Objekt oder eine Instanz einer Klasse?

Im Gegensatz zu Java hat Scala zwei Bedeutungen für „object“. Lassen Sie sich davon nicht verwirren, ich werde es klar erklären. In Java haben wir nur eine Bedeutung für „object“, nämlich „eine Instanz einer Klasse“.

  • Wie in Java ist die erste Bedeutung von „object“ „eine Instanz einer Klasse“.
val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")
  • Second bedeutet, dass Objekt ein Schlüsselwort in Scala ist. Es wird verwendet, um Scala ausführbare Programme, Begleitobjekte, Singleton-Objekte usw. zu definieren.

Was ist ein Begleitobjekt in Scala? Was ist eine Begleitklasse in Scala? Wofür wird ein Begleitobjekt in Scala verwendet?

In einfachen Worten, wenn eine Scala-Klasse und ein Objekt denselben Namen teilen und in derselben Quelldatei definiert sind, dann wird diese Klasse als „Begleitklasse“ bezeichnet und das Objekt wird als „Begleitobjekt“ bezeichnet. Wenn wir eine Klasse mit dem Scala-Schlüsselwort „class“ und ein Objekt mit dem Scala-Schlüsselwort „object“ mit demselben Namen und innerhalb derselben Quelldatei erstellen, dann wird diese Klasse als „Begleitklasse“ bezeichnet und das Objekt wird als „Begleitobjekt“ bezeichnet. Beispiel: – Employee.scala

class Employee{ }
object Employee{ }

In Scala ist der Hauptzweck des Begleitobjekts, apply-Methoden zu definieren und das Verwenden des neuen Schlüsselworts bei der Erstellung einer Instanz dieses Begleitklassenobjekts zu vermeiden.

Wie implementiert man Schnittstellen in Scala?

Wie wir aus dem Java-Hintergrund wissen, verwenden wir ein Interface, um einen Vertrag zu definieren. In Scala gibt es jedoch kein Interface-Konzept, und sogar das Schlüsselwort „Interface“ existiert nicht. Scala hat ein leistungsfähigeres und flexibleres Konzept, nämlich das Trait, für diesen Zweck.

Was ist eine Range in Scala? Wie erstellt man eine Range in Scala?

Eine Range ist in Scala eine Lazy Collection. Range ist eine Klasse im Paket ’scala‘ wie ’scala.Range‘. Sie wird verwendet, um eine Sequenz von ganzen Zahlen darzustellen – eine geordnete Sequenz von Ganzzahlen. Beispiel:

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)

Wie viele Werte vom Typ Nothing gibt es in Scala?

In Scala hat der Typ Nothing keine Werte, das heißt null. Er hat keine Werte. Er ist ein Untertyp aller Wertklassen und Referenzklassen.

Wie viele Werte vom Typ Unit gibt es in Scala?

In Scala ist Unit etwas Ähnliches wie das void-Schlüsselwort in Java. Es wird verwendet, um „Kein Wert existiert“ darzustellen. Es hat einen und nur einen Wert, der () ist.

Was ist eine reine Funktion?

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

Hier ist „+“ eine reine Funktion, die in der Int-Klasse verfügbar ist. Sie liefert bei gleichen Eingaben von 10 und 30 jedes Mal dasselbe Ergebnis von 30, unabhängig davon, wie oft wir sie aufrufen.

Was ist der Unterschied zwischen einer Funktion und einer Prozedur in der funktionalen Programmierung?

Beide werden zur Berechnung verwendet, haben jedoch einen wesentlichen Unterschied in der Welt der funktionalen Programmierung. Eine Funktion ist eine Berechnungseinheit ohne Seiteneffekt, während eine Prozedur auch eine Berechnungseinheit mit Seiteneffekten ist.

Was sind die Hauptunterschiede zwischen den Hilfskonstruktoren von Scala und den Konstruktoren von Java?

Der Hilfskonstruktor von Scala ist fast ähnlich wie der Konstruktor von Java mit einigen Unterschieden. Im Vergleich zu den Konstruktoren von Java haben Hilfskonstruktoren folgende wenige Unterschiede:

  • Die Hilfskonstruktoren werden mit dem Schlüsselwort „this“ aufgerufen.
  • Alle Hilfskonstruktoren werden mit demselben Namen definiert, nämlich „this“. In Java verwenden wir den Klassennamen, um Konstruktoren zu definieren.
  • Jeder Hilfskonstruktor muss mit einem Aufruf zu einem zuvor definierten Hilfskonstruktor oder dem primären Konstruktor beginnen.
  • Wir verwenden das Schlüsselwort „def“, um Hilfskonstruktoren wie Methoden-/Funktionsdefinitionen zu definieren. In Java ist die Definition von Konstruktoren und Methoden unterschiedlich.

Wofür wird das Schlüsselwort „yield“ in der For-Comprehension-Konstruktion von Scala verwendet?

Wir können das Schlüsselwort „yield“ in der For-Comprehension-Konstruktion von Scala verwenden. „for/yield“ wird verwendet, um eine Sammlung von Elementen zu durchlaufen und eine neue Sammlung desselben Typs zu generieren. Es ändert nicht die ursprüngliche Sammlung. Es generiert eine neue Sammlung desselben Typs wie der ursprüngliche Sammlungstyp. Zum Beispiel, wenn wir die „for/yield“-Konstruktion verwenden, um eine Liste zu durchlaufen, generiert sie nur eine neue Liste.

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)

Was ist ein Wächter im For-Comprehension-Konstrukt von Scala?

In Scala hat das For-Comprehension-Konstrukt eine if-Klausel, die dazu dient, eine Bedingung zum Filtern einiger Elemente festzulegen und eine neue Sammlung zu generieren. Diese if-Klausel wird auch als „Guard“ bezeichnet. Wenn dieser Wächter wahr ist, wird das Element zur neuen Sammlung hinzugefügt. Andernfalls wird das Element nicht zur Originalsammlung hinzugefügt. Beispiel:- For-Comprehension-Guard zum Generieren nur gerader Zahlen in eine neue Sammlung.

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)

Wie löst Scala das Vererbungsdiamantenproblem automatisch und einfacher als Java 8?

Wenn wir Java 8-Interfaces mit Standardmethoden verwenden, erhalten wir das Vererbungsdiamantenproblem. Der Entwickler muss es in Java 8 manuell lösen. Es bietet keine Standard- oder automatische Lösung für dieses Problem. In Scala erhalten wir dasselbe Problem mit Traits, aber Scala ist sehr klug und löst das Vererbungsdiamantenproblem automatisch mithilfe des Konzepts der Klassenlinearisierung.

In Scala folgt das Pattern Matching dem Visitor Design Pattern. Ebenso verwendet der ‚instanceof‘-Operator in Java das Visitor Design Pattern.

In Scala folgt das Pattern Matching dem Visitor Design Pattern. Genauso verwendet der ‚instanceof‘-Operator in Java das Visitor Design Pattern. Das ist alles zu „Scala Intermediate Interview Questions and Answers“. In meinen kommenden Beiträgen werden wir einige fortgeschrittene Scala-Interviewfragen und -Antworten besprechen. Bitte hinterlassen Sie einen Kommentar, wenn Ihnen mein Beitrag gefällt oder wenn Sie Probleme/Vorschläge haben.

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