Scala Sollicitatiegesprek Vragen

Voor het lezen van dit bericht, ga alstublieft door mijn vorige bericht op “Scala Basis Interviewvragen en Antwoorden” om wat basisinformatie over de Scala-taal te krijgen. In dit bericht gaan we enkele meer Scala-interviewvragen bespreken die nuttig zijn voor ervaren Scala-ontwikkelaars. Opmerking:- Aangezien deze lijst al erg lang is geworden, ga ik een ander bericht leveren met resterende vragen en antwoorden. Raadpleeg dat bericht op: “Scala Intermediate en Advanced Interviewvragen en Antwoorden“

Scala Interviewvragen

In deze sectie gaan we alle Scala Intermediate Interviewvragen opsommen en in de volgende sectie zullen we ze in detail bespreken.

1. Wat is de primaire constructor? Wat is de secundaire of hulpconstructor in Scala?
2. Wat is het gebruik van hulpconstructeurs in Scala? Gelieve de regels uit te leggen die moeten worden gevolgd bij het definiëren van hulpconstructeurs in Scala?
3. Wat zijn de verschillen tussen Array en ArrayBuffer in Scala?
4. Wat is een case class? Wat is een case object? Wat zijn de voordelen van case class?
5. Wat is het verschil tussen Case Object en Object (Normaal Object)?
6. Wanneer vergeleken met een Normale Klasse, wat zijn de belangrijkste voordelen of voordelen van een Case-klasse?
7. Wat is het gebruik van de methoden isInstanceOf en asInstanceOf in Scala? Is er een vergelijkbaar concept beschikbaar in Java?
8. Hoe bewijst u dat standaard een Case Object Serializable is en een Normaal Object niet?
9. Verschil tussen Array en Lijst in Scala?
10. Wat is het verschil tussen “val” en “lazy val” in Scala? Wat is Eager Evaluatie? Wat is Lazy Evaluatie?
11. Wat is de Relatie tussen de equals methode en == in Scala? Differentieer Scala’s == en Java’s == Operator?
12. Verschil tussen Scala’s Innerlijke klasse en Java’s Innerlijke klasse?
13. Wat is het Diamant Probleem? Hoe lost Scala het Diamant Probleem op?
14. Waarom heeft Scala GEEN “static” sleutelwoord? Wat is de belangrijkste reden voor deze beslissing?
15. Wat is het gebruik van het sleutelwoord “object” in Scala? Hoe maak je Singleton objecten in Scala?
16. Hoe definieer je Fabrieksmethoden met behulp van het sleutelwoord object in Scala? Wat is het nut van het definiëren van Fabrieksmethoden in object?
17. Wat is de apply methode in Scala? Wat is de unapply methode in Scala? Wat is het verschil tussen apply en unapply methoden in Scala?
18. Hoe werkt het achter de schermen, wanneer we een instantie van een Klasse creëren zonder het ‘new’ sleutelwoord te gebruiken in Scala? Wanneer kiezen we voor deze benadering?
19. Hoe verklaren we een private Primaire Constructor in Scala? Hoe maken we een oproep naar een private Primaire Constructor in Scala?
20. Geeft een Companion-object toegang tot de privéleden van zijn Companion-klasse in Scala?
21. Wat is de belangrijkste ontwerpsbeslissing over twee aparte trefwoorden: class en object in Scala? Hoe definiëren we instantieleden en statische leden in Scala?
22. Wat is een object in Scala? Is het een single object of een instantie van een klasse?
23. Wat is een Companion Object in Scala? Wat is een Companion Class in Scala? Wat is het gebruik van Companion Object in Scala?
24. Hoe implementeer je interfaces in Scala?
25. Wat is Range in Scala? Hoe maak je een Range in Scala aan?
26. Hoeveel waarden van het type Nothing zijn er in Scala?
27. Hoeveel waarden van het type Unit zijn er in Scala?
28. Wat is Range in Scala? Hoe maak je een Range in Scala aan?
29. Wat is het verschil tussen een functie en een procedure in FP?
30. Wat zijn de belangrijkste verschillen tussen de Hulpprogrammaconstructeurs van Scala en de constructeurs van Java?
31. Wat is het gebruik van het ‘yield’-trefwoord in de for-comprehension-constructie van Scala?
32. Wat is een guard in de for-comprehension-constructie van Scala?
33. Hoe lost Scala het Erfprobleem van de Overerving automatisch en gemakkelijker op dan Java 8?
34. Welk ontwerppatroon volgt Scala bij Pattern Matching? Welk ontwerppatroon volgt de ‘isinstanceof’-operator in Java?

Scala Interviewvragen en Antwoorden

In dit gedeelte zullen we elke vraag uit de bovenstaande lijst oppakken en gedetailleerd bespreken met geschikte voorbeelden (indien nodig). Als je deze concepten diepgaand met voorbeelden wilt begrijpen, ga dan door mijn eerdere berichten in de Scala Tutorials-sectie.

Wat is de Hoofdconstructor? Wat is de Secundaire of Hulpconstructor in Scala? Wat is het doel van de Hulpconstructor in Scala? Is het mogelijk om constructors in Scala te overbelasten?

Scala heeft twee soorten constructors:

• Hoofdconstructor
• Hulpconstructor

Hoofdconstructor In Scala is de Hoofdconstructor een constructor die wordt gedefinieerd bij de class-definitie zelf. Elke class moet één Hoofdconstructor hebben: Ofwel een constructor met parameters of een parameterloze constructor. Voorbeeld:-

class Person

Bovenstaande Persoon klasse heeft één nul-parameter of Geen-Parameter of Parameterloze Primaire constructor om instanties van deze klasse te maken.

class Person (firstName: String, lastName: String)

Bovenstaande Persoon klasse heeft een Primaire constructor met twee parameters om instanties van deze klasse te maken. Hulpconstructor Hulpconstructor staat ook bekend als Secundaire Constructor. We kunnen een Secundaire Constructor declareren met behulp van de ‘def’ en ’this’ trefwoorden zoals hieronder getoond:

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

Wat is het gebruik van Hulpconstructors in Scala? Gelieve de regels uit te leggen die gevolgd moeten worden bij het definiëren van Hulpconstructors in Scala?

In Scala is het voornaamste doel van Hulpconstructors het overbelasten van constructors. Net als in Java kunnen we verschillende soorten constructors aanbieden zodat de gebruiker de juiste kan kiezen op basis van zijn vereisten. Regels voor Hulpconstructors:

• Ze zijn net als methoden. Net als bij methoden moeten we het trefwoord ‘def’ gebruiken om ze te definiëren.
• We moeten dezelfde naam ’this’ gebruiken voor alle Hulpconstructors.
• Elke Hulpconstructor moet beginnen met een oproep naar een eerder gedefinieerde andere Hulpconstructor of Primaire Constructor. Anders compileertijd fout.
• Elke hulpmethode moet verschillen in hun parameterlijst: mogelijk door aantal of types.
• Hulpmethoden kunnen geen superklassemethoden aanroepen. Ze moeten ze alleen aanroepen via de primaire constructor.
• Alle hulpmethoden roepen hun primaire constructor aan, direct of indirect via andere hulpmethoden.

OPMERKING: Als je meer wilt weten over de constructors van Scala, raadpleeg dan mijn Scala-posts op: Primaire Constructor en Hulpmethode.

Wat zijn de verschillen tussen Array en ArrayBuffer in Scala?

Verschillen tussen Array en ArrayBuffer in Scala:

• Array is een array van vaste grootte. We kunnen de grootte ervan niet veranderen nadat deze is aangemaakt.
• ArrayBuffer is een array van variabele grootte. Het kan dynamisch van grootte veranderen.
• Array is vergelijkbaar met de primitieve arrays in Java.
• ArrayBuffer is vergelijkbaar met de ArrayList in Java.

Wat is een case class? Wat is een case object? Wat zijn de voordelen van een case class?

Case class is een klasse die wordt gedefinieerd met het trefwoord “case class”. Case object is een object dat wordt gedefinieerd met het trefwoord “case object”. Vanwege dit “case” trefwoord krijgen we enkele voordelen om boilerplate-code te vermijden. We kunnen case class-objecten maken zonder het “new” trefwoord te gebruiken. Standaard voegt de Scala-compiler “val” toe aan alle constructieparameters. Daarom worden zonder het gebruik van val of var de constructieparameters van een case class klassenleden, wat niet mogelijk is voor normale klassen. Voordelen van case class:

• Standaard voegt de Scala-compiler toString, hashCode en equals-methoden toe. We kunnen deze boilerplate-code vermijden.
• Standaard voegt de Scala-compiler een companion object toe met apply- en unapply-methoden, waardoor we het new-trefwoord niet nodig hebben om instanties van een case class te maken.
• Standaard voegt de Scala-compiler ook de copy-methode toe.
• We kunnen case classes gebruiken in patroonmatching.
• Standaard zijn case class en case objects serialiseerbaar.

Wat is het verschil tussen een Case Object en een Object (Normaal Object)?

• Een normaal object wordt aangemaakt met het sleutelwoord “object”. Standaard is het een singleton-object.

object MyNormalObject

• Een Case Object wordt aangemaakt met het sleutelwoord “case object”. Standaard is het ook een singleton-objectKeywords. Standaard krijgt het ook toString- en hashCode-methoden, maar een normaal object niet.

case object MyCaseObject

• Standaard is een Case Object Serializable, terwijl een normaal object dat niet is.

Vergeleken met een normale klasse, wat zijn de belangrijkste voordelen van een Case-klasse?

De volgende zijn de belangrijkste voordelen van een Case-klasse ten opzichte van normale klassen:

• Vermijdt veel boilerplate-code door automatisch enkele nuttige methoden toe te voegen.
• Ondersteunt standaard onveranderlijkheid omdat de parameters ‘val’ zijn.
• Gemakkelijk te gebruiken in patroonmatching.
• Geen behoefte aan het gebruik van het ‘new’ sleutelwoord om een instantie van een Case-klasse te maken.
• Standaard ondersteunt het Serialisatie en Deserialisatie.

Wat is het gebruik van de methoden isInstanceOf en asInstanceOf in Scala? Is er een vergelijkbaar concept beschikbaar in Java?

Beide methoden isInstanceOf en asInstanceOf zijn gedefinieerd in de Any-klasse. Dus er is geen import nodig om deze methoden in een klasse of object te krijgen. De methode “isInstanceOf” wordt gebruikt om te testen of het object van een gegeven type is. Als dat het geval is, retourneert het true. Anders retourneert het false.

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

De methode “asInstanceOf” wordt gebruikt om het object naar het opgegeven type te casten. Als het gegeven object en type van hetzelfde type zijn, wordt het naar het opgegeven type gecast. Anders wordt java.lang.ClassCastException gegenereerd.

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

In Java is het sleutelwoord ‘instanceof’ vergelijkbaar met de methode ‘isInstanceOf’ in Scala. In Java is het handmatige typecasting zoals de volgende vergelijkbaar met de methode ‘asInstanceOf’ in Scala.

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

Hoe bewijs je dat standaard een Case Object Serializable is en een normaal object niet?

Ja, standaard is het Case Object Serializable. Maar een normaal object is dat niet. We kunnen dit bewijzen door de isInstanceOf-methode te gebruiken zoals hieronder getoond:

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

Verschil tussen Array en List in Scala?

• Arrays zijn altijd mutabel, terwijl List altijd onveranderlijk is.
• Eenmaal gemaakt, kunnen we de waarden van een Array wijzigen, terwijl we het List-object niet kunnen wijzigen.
• Arrays zijn datastructuren met een vaste grootte, terwijl List datastructuren met een variabele grootte zijn. De grootte van de lijst wordt automatisch vergroot of verkleind op basis van de bewerkingen die we erop uitvoeren.
• Arrays zijn invariante, terwijl Lists covariant zijn.

LET OP: Als je niet zeker bent van Invariant en Covariant, lees dan mijn volgende bericht over Scala Interviewvragen.

Wat is het verschil tussen “val” en “lazy val” in Scala? Wat is Eager Evaluation? Wat is Lazy Evaluation?

Zoals we bespraken in mijn basis Scala Interviewvragen, betekent “val” waarde of constante en wordt het gebruikt om onveranderlijke variabelen te definiëren. Er zijn twee soorten programma-evaluaties:

• Eager Evaluation
• Lazy Evaluation

Eager Evaluation betekent het evalueren van een programma tijdens de compileer- of implementatietijd, ongeacht of klanten dat programma gebruiken of niet. Lazy Evaluation betekent het evalueren van een programma tijdens runtime op verzoek, dat wil zeggen wanneer klanten toegang krijgen tot het programma, wordt het pas geëvalueerd. Het verschil tussen “val” en “lazy val” is dat “val” wordt gebruikt om variabelen te definiëren die gretig worden geëvalueerd en “lazy val” wordt ook gebruikt om variabelen te definiëren, maar ze worden lui geëvalueerd.

Wat is de relatie tussen de equals-methode en == in Scala? Onderscheid maken tussen Scala’s == en Java’s == Operator?

In Scala hoeven we de equals () methode NIET te bellen om twee instanties of objecten te vergelijken. Wanneer we twee instanties vergelijken met ==, roept Scala automatisch de equals () methode van dat object aan. De == operator van Java wordt gebruikt om referentie-gelijkheid te controleren, dat wil zeggen of twee verwijzingen naar hetzelfde object wijzen of niet. Scala’s == wordt gebruikt om instantie-gelijkheid te controleren, dat wil zeggen of twee instanties gelijk zijn of niet.

Verschil tussen de binnenklasse van Scala en de binnenklasse van Java?

In Java is een binnenklasse geassocieerd met de buitenklasse, wat betekent dat de binnenklasse een lid is van de buitenklasse. In tegenstelling tot Java behandelt Scala de relatie tussen de buitenklasse en de binnenklasse anders. De binnenklasse van Scala is geassocieerd met het object van de buitenklasse.

Wat is het Diamantprobleem? Hoe lost Scala het Diamantprobleem op?

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 is de uitvoer “Van C.display” vanuit trait C. De Scala-compiler leest “extends B with C” van rechts naar links en neemt de definitie van de methode “display” van het meest linkse trait, dat wil zeggen C. OPMERKING: Bekijk mijn bericht over “Scala Traits in Depth” voor een duidelijke uitleg hierover.

Waarom heeft Scala GEEN “static” trefwoord? Wat is de belangrijkste reden voor deze beslissing?

Zoals we weten, heeft Scala helemaal geen “static” trefwoord. Dit is de ontwerpbeslissing genomen door het Scala-team. De belangrijkste reden om deze beslissing te nemen is om Scala te maken als een Puur Objectgeoriënteerde Taal. Het trefwoord “static” betekent dat we toegang kunnen krijgen tot de leden van die klasse zonder een object te maken of zonder een object te gebruiken. Dit gaat volledig in tegen de principes van OOP. Als een taal het trefwoord “static” ondersteunt, dan is die taal geen Puur Objectgeoriënteerde Taal. Bijvoorbeeld, omdat Java het trefwoord “static” ondersteunt, is het geen Puur Objectgeoriënteerde Taal. Maar Scala is een Puur Objectgeoriënteerde Taal.

Wat is het gebruik van het “object” trefwoord in Scala? Hoe maak je Singleton-objecten in Scala?

In Scala wordt het trefwoord “object” gebruikt voor de volgende doeleinden:

• Het wordt gebruikt om singleton-object in Scala te maken.

object MySingletonObject

Hier wordt MySingletonObject automatisch een singleton-object.- Het trefwoord “object” wordt gebruikt om Scala-toepassingen te definiëren die uitvoerbare Scala-programma’s zijn.

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

Wanneer we de hoofdmethode in een object definiëren zoals hierboven getoond (hetzelfde als de main() methode in Java), wordt het automatisch een uitvoerbaar Scala-programma.- Het wordt gebruikt om statische leden zoals statische variabelen en statische methoden te definiëren zonder het ‘static’ trefwoord te gebruiken.

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

object: Door de definitie van de PI-variabele en add-methoden zullen deze worden omgezet naar statische leden. Dit betekent dat we ze kunnen oproepen zonder een apart object te maken, zoals bijvoorbeeld MyScalaStaticMembers.add(10, 20). Het wordt gebruikt om fabrieksmethoden te definiëren. Zie mijn volgende vraag hierover.

Hoe worden fabrieksmethoden gedefinieerd met het ‘object’-sleutelwoord in Scala? Wat is het nut van het definiëren van fabrieksmethoden in een object?

In Scala gebruiken we het ‘object’-sleutelwoord om fabrieksmethoden te definiëren. Het belangrijkste doel van deze fabrieksmethoden in Scala is om het gebruik van het ‘new’-sleutelwoord te vermijden. Zonder het ‘new’-sleutelwoord te gebruiken, kunnen we objecten creëren. Om fabrieksmethoden te definiëren: We kunnen de ‘apply’-methode gebruiken om fabrieksmethoden in Scala te definiëren. Als we een primaire constructor en meerdere hulpconstructeurs hebben, moeten we meerdere ‘apply’-methoden definiëren zoals hieronder getoond.

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

Nu kunnen we persoon-objecten maken zonder het ‘new’-sleutelwoord te gebruiken, of met het ‘new’-sleutelwoord, afhankelijk van uw voorkeur.

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

Wat is de apply-methode in Scala? Wat is de unapply-methode in Scala? Wat is het verschil tussen de apply- en unapply-methoden in Scala?

In Scala spelen de apply- en unapply-methoden een zeer belangrijke rol. Ze zijn ook erg handig in het Play Framework om gegevens tussen formuliergegevens en modelgegevens te mappen en te ontmapen. In eenvoudige bewoordingen,

• apply-methode: Om een object samen te stellen of te assembleren uit zijn componenten.
• unapply-methode: Om een object te decomponeren of te demonteren in zijn componenten.

Scala’s apply-methode: Het wordt gebruikt om een object samen te stellen door zijn componenten te gebruiken. Stel dat we een Persoon-object willen maken, dan gebruiken we de twee componenten firstName en lastName en stellen we het Persoon-object als volgt samen.

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

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

Scala’s unapply-methode: Het wordt gebruikt om een object te decomponeren in zijn componenten. Het volgt het omgekeerde proces van de apply-methode. Stel dat we een Persoon-object hebben, dan kunnen we dit object decomponeren in zijn twee componenten: firstName en lastName zoals hieronder getoond.

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

Hoe werkt het onder de motorkap wanneer we een instantie van een Klasse maken zonder het ‘new’-trefwoord te gebruiken in Scala? Wanneer kiezen we voor deze aanpak? Hoe kunnen we private constructors declareren in Scala?

In Scala, wanneer we een instantie van een Klasse maken zonder het ‘new’-trefwoord te gebruiken, wordt intern een oproep gedaan naar de juiste ‘apply’-methode die beschikbaar is in het Companion object. Hier betekent de juiste ‘apply’-methode dat deze overeenkomt met de parameters. Wanneer kiezen we voor deze optie: Wanneer we een private constructor moeten bieden en we het gebruik van het ‘new’-trefwoord moeten vermijden, kunnen we alleen de ‘apply’-methode implementeren met dezelfde set parameters en onze klassegebruikers toestaan deze te maken zonder het ‘new’-trefwoord.

Hoe verklaren we een private Primary Constructor in Scala? Hoe roepen we een private Primary Constructor aan in Scala?

In Scala kunnen we heel eenvoudig een private Primary Constructor verklaren. Definieer gewoon een Primary Constructor zoals deze is en voeg ‘private’ toe vlak na de klassenaam en voor de parameterlijst, zoals hieronder getoond:

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

Doordat dit een private constructor is, kunnen we er geen directe oproepen van buitenaf aan doen. We moeten een fabrieksmethode voorzien (dat is de apply-methode) zoals hierboven getoond, en die constructor indirect gebruiken.

Kan een Companion-object in Scala toegang krijgen tot private leden van zijn Companion-klasse?

Over het algemeen betekenen private leden dat ze alleen toegankelijk zijn binnen die klasse. Scala’s Companion-klasse en Companion-object hebben echter een andere functie voorzien. In Scala kan een Companion-object toegang krijgen tot private leden van zijn Companion-klasse en de Companion-klasse kan private leden van zijn Companion-object benaderen.

Wat is het belangrijkste ontwerpbesluit over twee afzonderlijke trefwoorden: class en object in Scala? Hoe definiëren we instantieleden en statische leden in Scala?

In Scala gebruiken we het trefwoord class om instantieleden te definiëren en het trefwoord object om statische leden te definiëren. Scala heeft geen static trefwoord, maar we kunnen ze nog steeds definiëren door het trefwoord object te gebruiken. Het belangrijkste ontwerpbesluit hierover is de duidelijke scheiding tussen instantie- en statische leden. Losse koppeling tussen hen. En een andere belangrijke reden is om het static trefwoord te vermijden, zodat Scala een Pure-OOP-taal zal worden.

Wat is object in Scala? Is het een singleton object of een instantie van een klasse?

In tegenstelling tot Java heeft Scala twee betekenissen over ‘object’. Raak hier niet in de war, ik zal het duidelijk uitleggen. In Java hebben we slechts één betekenis voor object, namelijk “Een instantie van een klasse”.

• Net als in Java is de eerste betekenis van object “Een instantie van een klasse”.

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

• Tweede betekenis is dat object een trefwoord is in Scala. Het wordt gebruikt om Scala-uitvoerbare programma’s, Companion Objects, Singleton Objects, enz. te definiëren.

Wat is een Companion Object in Scala? Wat is een Companion Class in Scala? Wat is het gebruik van Companion Object in Scala?

In eenvoudige bewoordingen, als een Scala-klasse en object dezelfde naam delen en gedefinieerd zijn in hetzelfde bronbestand, dan staat die klasse bekend als “Companion Class” en dat object staat bekend als “Companion Object”. Wanneer we een klasse maken met behulp van het Scala-trefwoord “class” en een object met behulp van het Scala-trefwoord “object” met dezelfde naam en binnen hetzelfde bronbestand, dan staat die klasse bekend als “Companion Class” en dat object staat bekend als “Companion Object”. Voorbeeld: Employee.scala

class Employee{ }
object Employee{ }

In Scala is het belangrijkste doel van Companion Object om apply-methoden te definiëren en het gebruik van het nieuwe trefwoord te vermijden bij het maken van een instantie van dat Companion Class-object.

Hoe implementeer je interfaces in Scala?

Zoals we weten uit de Java-achtergrond, gebruiken we een interface om contact te definiëren. Er is echter geen interfaceconcept in Scala. Zelfs heeft Scala geen interface-sleutelwoord. Scala heeft een krachtiger en flexibeler concept, namelijk een ’trait’ voor dit doel.

Wat is een Bereik in Scala? Hoe maak je een Bereik in Scala?

Een Bereik is een Luie Verzameling in Scala. Bereik is een klasse beschikbaar in het ‘scala’-pakket zoals ‘scala.Range’. Het wordt gebruikt om een ​​reeks gehele getalwaarden voor te stellen. Het is een geordende reeks gehele getallen. Voorbeeld:-

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)

Hoeveel waarden van het type Niets zijn er in Scala?

In Scala heeft het type Niets geen waarden, dat is nul. Het heeft geen enkele waarde. Het is een subtype van alle Waardeklassen en Referentieklassen.

Hoeveel waarden van het type Unit zijn er in Scala?

In Scala is Unit iets vergelijkbaars met het void-keyword in Java. Het wordt gebruikt om “Geen waarde bestaat” voor te stellen. Het heeft één en slechts één waarde, dat is ().

Wat is een zuivere functie?

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 is “+” een zuivere functie die beschikbaar is in de Int-klasse. Het geeft hetzelfde resultaat 30 voor dezelfde invoeren 10 en 30, ongeacht hoe vaak we het aanroepen.

In FP, wat is het verschil tussen een functie en een procedure?

Beide worden gebruikt om berekeningen uit te voeren, maar ze hebben één groot verschil in de wereld van Functioneel Programmeren. Een functie is een berekeningseenheid zonder bijwerking, terwijl een Procedure ook een berekeningseenheid is met bijwerkingen.

Wat zijn de belangrijkste verschillen tussen Scala’s hulpconstructeurs en Java’s constructeurs?

De hulpconstructor van Scala lijkt bijna op de constructor van Java met enkele verschillen. Vergeleken met de constructors van Java hebben hulpconstructors de volgende paar verschillen:

• De hulpconstructors worden aangeroepen met het sleutelwoord “this”.
• Alle hulpconstructors worden gedefinieerd met dezelfde naam, namelijk “this”. In Java gebruiken we de klassenaam om constructors te definiëren.
• Elke hulpconstructor moet beginnen met een oproep naar een eerder gedefinieerde hulpconstructor of de primaire constructor.
• We gebruiken het sleutelwoord ‘def’ om hulpconstructors te definiëren, net als bij het definiëren van een methode/functie. In Java is de definitie van een constructor anders dan de definitie van een methode.

Wat is het gebruik van het ‘yield’-sleutelwoord in de Scala for-comprehension-constructie?

We kunnen het ‘yield’-sleutelwoord gebruiken in de Scala for-comprehension-constructie. ‘for/yield’ wordt gebruikt om door een verzameling elementen te itereren en een nieuwe verzameling van hetzelfde type te genereren. Het verandert de oorspronkelijke verzameling niet. Het genereert een nieuwe verzameling van hetzelfde type als het oorspronkelijke verzamelingstype. Als we bijvoorbeeld de ‘for/yield’-constructie gebruiken om door een lijst te itereren, genereert het alleen een nieuwe lijst.

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)

Wat is de wachter in de for-comprehension-constructie van Scala?

In Scala heeft de for-comprehension-constructie een if-clausule die wordt gebruikt om een voorwaarde te schrijven om sommige elementen te filteren en een nieuwe verzameling te genereren. Deze if-clausule staat ook bekend als “Wachter”. Als die wachter waar is, wordt dat element toegevoegd aan de nieuwe verzameling. Anders wordt dat element niet toegevoegd aan de oorspronkelijke verzameling. Voorbeeld:- For-comprehension Wachter om alleen even getallen in een nieuwe verzameling te genereren.

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)

Hoe lost Scala het probleem van de diamant van overerving automatisch en gemakkelijker op dan Java 8?

Als we Java 8’s Interface met Standaardmethoden gebruiken, krijgen we het probleem van de diamant van overerving. De ontwikkelaar moet het in Java 8 handmatig oplossen. Het biedt geen standaard- of automatische oplossing voor dit probleem. In Scala krijgen we hetzelfde probleem met Traits, maar Scala is erg slim en lost het probleem van de diamant van overerving automatisch op met behulp van het concept van Klasse Linearisatie.

In Scala volgt Pattern Matching welk ontwerppatroon? In Java volgt de ‘isinstanceof’-operator welk ontwerppatroon?

In Scala volgt Pattern Matching het Visitor Design Pattern. Op dezelfde manier volgt de ‘isinstanceof’-operator in Java ook het Visitor Design Pattern. Dat is alles over “Scala Intermediate Interview Questions and Answers”. We zullen enkele geavanceerde Scala-interviewvragen en antwoorden bespreken in mijn komende berichten. Laat me een opmerking achter als je mijn bericht leuk vindt of als je problemen/suggesties hebt.