Ready to face interview for Scala? Do not worry, we are here to help you with job interview preparation. If you are preparing for Scala interview and not sure which questions are likely asked in interview, we suggest you to go through Wisdomjobs Scala interview questions and answers page to crack your job interview. Scala is one type of programming language. It runs parallel to java. Its source code is compiled and can be run on JVM. It imbibes features of functional programming. There are some differences when compared to Java. One must note all these points. There are many jobs related to this across the globe. Below is the list of frequently askedScala interview questions and answers which gets you ready to face the interviews:
Question 1. Explain What Is Scala?
Answer :
Scala is an object functional programming and scripting language for general software applications designed to express solutions in a concise manner.
Question 2. What Is A ‘scala Set’? What Are Methods Through Which Operation Sets Are Expressed?
Answer :
Scala set is a collection of pairwise elements of the same type. Scala set does not contain any duplicate elements. There are two kinds of sets, mutable and immutable.
Question 3. What Is A ‘scala Map’?
Answer :
Scala map is a collection of key or value pairs. Based on its key any value can be retrieved. Values are not unique but keys are unique in the Map.
Question 4. What Is The Advantage Of Scala?
Answer :
Question 5. In What Ways Scala Is Better Than Other Programming Language?
Answer :
Question 6. What Are The Scala Variables?
Answer :
Values and variables are two shapes that come in Scala. A value variable is constant and cannot be changed once assigned. It is immutable, while a regular variable, on the other hand, is mutable, and you can change the value.
The two types of variables are
var myVar : Int=0;
val myVal: Int=1;
Question 7. Mention The Difference Between An Object And A Class ?
Answer :
A class is a definition for a description. It defines a type in terms of methods and composition of other types. A class is a blueprint of the object. While, an object is a singleton, an instance of a class which is unique. An anonymous class is created for every object in the code, it inherits from whatever classes you declared object to implement.
Question 8. What Is Recursion Tail In Scala?
Answer :
‘Recursion’ is a function that calls itself. A function that calls itself, for example, a function ‘A’ calls function ‘B’, which calls the function ‘C’. It is a technique used frequently in functional programming. In order for a tail recursive, the call back to the function must be the last function to be performed.
Question 9. What Is ‘scala Trait’ In Scala?
Answer :
‘Traits’ are used to define object types specified by the signature of the supported methods. Scala allows to be partially implemented but traits may not have constructor parameters. A trait consists of method and field definition, by mixing them into classes it can be reused.
Question 10. When Can You Use Traits?
Answer :
There is no specific rule when you can use traits, but there is a guideline which you can consider.
Question 11. What Is Case Classes?
Answer :
Case classes provides a recursive decomposition mechanism via pattern matching, it is a regular classes which export their constructor parameter. The constructor parameters of case classes can be accessed directly and are treated as public values.
Question 12. What Is The Use Of Tuples In Scala?
Answer :
Scala tuples combine a fixed number of items together so that they can be passed around as whole. A tuple is immutable and can hold objects with different types, unlike an array or list.
Question 13. What Is Function Currying In Scala?
Answer :
Currying is the technique of transforming a function that takes multiple arguments into a function that takes a single argument Many of the same techniques as language like Haskell and LISP are supported by Scala. Function currying is one of the least used and misunderstood one.
Question 14. What Are Implicit Parameters In Scala?
Answer :
Implicit parameter is the way that allows parameters of a method to be “found”. It is similar to default parameters, but it has a different mechanism for finding the “default” value. The implicit parameter is a parameter to method or constructor that is marked as implicit. This means if a parameter value is not mentioned then the compiler will search for an “implicit” value defined within a scope.
Question 15. What Is A Closure In Scala?
Answer :
A closure is a function whose return value depends on the value of the variables declared outside the function.
Question 16. What Is Monad In Scala?
Answer :
A monad is an object that wraps another object. You pass the Monad mini-programs, i.e functions, to perform the data manipulation of the underlying object, instead of manipulating the object directly. Monad chooses how to apply the program to the underlying object.
Question 17. What Is Scala Anonymous Function?
Answer :
In a source code, anonymous functions are called ‘function literals’ and at run time, function literals are instantiated into objects called function values. Scala provides a relatively easy syntax for defining anonymous functions.
Question 18. Explain ‘scala Higher Order’ Functions?
Answer :
Scala allows the definition of higher order functions. These are functions that take other functions as parameters, or whose result is a function. In the following example, apply () function takes another function ‘f’ and a value ‘v’ and applies function to v.
Example:
object Test {
def main(args: Array[String]) {
println( apply( layout, 10) )
}
def apply(f: Int => String, v: Int) = f(v)
def layout[A](x: A) = "[" + x.toString() + "]"
When the above code is compiled and executed, it produces following result.
C:/>scalac Test.scala
C:/>scala Test
[10]
C:/>
Question 19. What Is The Difference Between Var And Value?
Answer :
In scala, you can define a variable using either a, val or var keywords. The difference between val and var is, var is much like java declaration, but val is little different. We cannot change the reference to point to another reference, once the variable is declared using val. The variable defined using var keywords are mutable and can be changed any number of times.
Question 20. What Are Option, Some And None In Scala?
Answer :
‘Option’ is a Scala generic type that can either be ‘some’ generic value or none. ‘Queue’ often uses it to represent primitives that may be null.
Question 21. How Do I Append To The List?
Answer :
In scala to append into a list, use “:+” single value
var myList = List.empty[String]
myList :+= "a"
myList :+= "b"
myList :+= "c"
use++ for appending a list
var myList = List.empty[String]
myList ++= List("a", "b", "c")
Question 22. How Can You Format A String?
Answer :
To format a string, use the .format () method, in scala you can use
Val formatted= “%s %i”.format (mystring.myInt)
Question 23. Why Scala Prefers Immutability?
Answer :
Scala prefers immutability in design and in many cases uses it as default. Immutability can help when dealing with equality issues or concurrent programs.
Question 24. What Are The Four Types Of Scala Identifiers ?
Answer :
The four types of identifiers are
Question 25. What Are The Different Types Of Scala Literals?
Answer :
The different types of literals in scala are
Answer :
Scala has two kinds of constructors:
Primary Constructor: In Scala, Primary Constructor is a constructor which is defined with class definition itself. Each class must have one Primary Constructor: Either Parameter constructor or Parameterless constructor.
Example:-
class Person
Above Person class has one Zero-parameter or No-Parameter or Parameterless Primary constructor to create instances of this class.
class Person (firstName: String, lastName: String)
Above Person class has a two Parameters Primary constructor to create instances of this class.
Auxiliary Constructor: Auxiliary Constructor is also known as Secondary Constructor. We can declare a Secondary Constructor using ‘def’ and ‘this’ keywords as shown below:
class Person (firstName: String, middleName:String, lastName: String){
def this(firstName: String, lastName: String){
this(firstName, "", lastName)
}
}
Answer :
In Scala, The main purpose of Auxiliary Constructors is to overload constructors. Like Java, We can provide various kinds of constructors so that use can choose the right one based on his requirement.
Auxiliary Constructor Rules:
NOTE:- If you want to learn about Scala’s Constructors, please refer my Scala posts at: Primary Constructor and Auxiliary Constructor.
Question 28. What Are The Differences Between Array And Arraybuffer In Scala?
Answer :
Differences between Array and ArrayBuffer in Scala:
Question 29. What Is Case Class? What Is Case Object? What Are The Advantages Of Case Class?
Answer :
Case class is a class which is defined with “case class” keywords. Case object is an object which is defined with “case object” keywords. Because of this “case” keyword, we will get some benefits to avoid boilerplate code.
We can create case class objects without using “new” keyword. By default, Scala compiler prefixes “val” for all constructor parameters. That’s why without using val or var, Case class’s constructor parameters will become class members, it is not possible for normal classes.
Advantages of case class:
Answer :
The following are the major advantages or benefits of a Case class over Normal Classes:
Answer :
Both isInstanceOf and asInstanceOf methods are defined in Any class. So no need import to get these methods into any class or object.
“isInstanceOf” method is used to test whether the object is of a given type or not. If so, it returns true. Otherwise returns false.
scala> val str = "Hello"
scala>str.isInstanceOf[String]
res0: Boolean = false
“asInstanceOf” method is used to cast the object to the given a type. If the given object and type are of same type, then it cast to given type. Otherwise, it throws java.lang.ClassCastException.
scala> val str = "Hello".asInstanceOf[String]
str: String = Hello
In Java, ‘instanceof’ keyword is similar to Scala’s ‘isInstanceOf’ method. In Java, the following kind of manual type casting is similar to Scala’s ‘asInstanceOf’ method.
AccountService service = (AccountService)
context.getBean("accountService");
Question 32. How Do You Prove That By Default, Case Object Is Serializable And Normal Object Is Not?
Answer :
Yes, By Default, Case Object is Serializable. But normal object is not. We can prove this by using isInstanaceOf method as shown below:
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
Question 33. Difference Between Array And List In Scala?
Answer :
Answer :
As we discussed in my Basic Scala Interview Questions, “val” means value or constant which is used to define Immutable variables.
There are two kinds of program evaluations:
Eager Evaluation means evaluating program at compile-time or program deployment-time irrespective of clients are using that program or not.
Lazy Evaluation means evaluating program at run-time on-demand that means when clients access the program then only its evaluated.
The difference between “val” and “lazy val” is that “val” is used to define variables which are evaluated eagerly and “lazy val” is also used to define variables but they are evaluated lazily.
Answer :
compare two instances with ==, Scala calls that object’s equals() method automatically.
Java’s == operator is used to check References Equality that is whether two references are pointing to the same object or not. Scala’s == is used to check Instances Equality that is whether two instances are equal or not.
Question 36. Difference Between Scala’s Inner Class And Java’s Inner Class?
Answer :
In Java, Inner class is associated with Outer class that is Inner class a member of the Outer class.
Unlike Java, Scala treats the relationship between Outer class and Inner class differently. Scala’s Inner class is associated with Outer class object.
Question 37. What Is Diamond Problem? How Scala Solves Diamond Problem?
Answer :
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.
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
}
Here output is “From C.display” form trait C. Scala Compiler reads “extends B with C” from right to left and takes “display” method definition from lest most trait that is C.
Question 38. Why Scala Does Not Have “static” Keyword? What Is The Main Reason For This Decision?
Answer :
As we know, Scala does NOT have “static” keyword at all. This is the design decision done by Scala Team.
The main reason to take this decision is to make Scala as a Pure Object-Oriented Language. “static” keyword means that we can access that class members without creating an object or without using an object. This is completely against with OOP principles.
If a Language supports “static” keyword, then that Language is not a Pure Object-Oriented Language. For instance, as Java supports “static” keyword, it is NOT a Pure Object-Oriented Language. But Scala is a Pure Object-Oriented Language.
Question 39. What Is The Use Of “object” Keyword In Scala? How To Create Singleton Objects In Scala?
Answer :
In Scala, object keyword is used the following purposes:
object keyword is used to define Scala Applications that is executable Scala programs.
object MyScalaExecutableProgram{
def main(args: Array[String]){
println("Hello World")
}
}
When we define main method in object as shown above (its same as main() method in Java), it becomes automatically as a executable Scala program.
It is used to define static members like static variables and static methods without using ‘static’ keyword.
object MyScalaStaticMembers{
val PI: Double = 3.1414
def add(a: Int, b: Int) = a + b
}
By def PI variable and add methods will become as static members. That means we can call them without creating a separate object like MyScalaStaticMembers.add(10,20).
Answer :
In Scala, we use ‘object’ keyword to define Factory methods. The main purpose of these Factory methods in Scala is to avoid using ‘new’ keyword. Without using ‘new’ keyword we can create objects.
To define Factory methods:
We can use apply method to define Factory methods in Scala. If we have Primary Constructor and Multiple Auxiliary constructors, then we need to define multiple apply methods as shown below.
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)
}
Now we can create Person objects without using new keyword or with new keyword upto your wish.
val p1 = new Person("Scala","Java")
or
val p1 = Person("Scala","Java")
Answer :
In Scala, apply and unapply methods play very important role. They are also very useful in Play Framework in mapping and unmapping data between Form data and Model data.
In simple words,
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’s apply method: It is used to compose an object by using its components. Suppose if we want to create a Person object, then use firstName and laststName two components and compose Person object as shown below.
class Person(val firstName: String, val lastName: String)
object Person{
def apply(firstName: String, lastName: String)
= new Person(firstName, lastName)
}
Scala’s unapply method:
It is used to decompose an object into its components. It follows reverse process of apply method. Suppose if we have a Person object, then we can decompose this object into it’s two components: firstName and laststName as shown below.
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)
}
Answer :
In Scala, when we create an instance of a Class without using ‘new’ keyword, internally it make a call to appropriate apply method available in Companion object. Here appropriate apply method means that matched with parameters.
When do we choose this option: When we need to provide private private constructor and we need to avoid using ‘new’ keyword, we can implement only apply method with same set of parameters and allow our class users to create it without new keyword.
Answer :
In Scala, we can declare a private Primary Constructor very easily. Just define a Primary Constructor as it is and add ‘private’ just after class name and before parameter list as shown below:
class Person private (name: String)
object Person{
def apply(name: String) = new Person(name)
}
As it’s a private constructor, we cannot call it from outside. We should provide a factory method (that is apply method) as shown above and use that constructor indirectly.
Question 44. Does A Companion Object Access Private Members Of It’s Companion Class In Scala?
Answer :
Generally, private members means accessible only within that class. However Scala’s Companion class and Companion Object has provided another feature.
In Scala, a Companion object can access private members of it’s Companion class and Companion class can access it’s Companion object’s private members.
Answer :
In Scala, we use class keyword to define instance members and object keyword to define static members. Scala does not have static keyword, but still we can define them by using object keyword.
The main design decision about this is that the clear separation between instance and static members. Loosely coupling between them. And other major reason is to avoid static keyword so that Scala will become a Pure-OOP Language.
Question 46. What Is Object In Scala? Is It A Singleton Object Or Instance Of A Class?
Answer :
Unlike Java, Scala has two meanings about ‘object’. Don’t get confuse about this, I will explain it clearly. In Java, we have only one meaning for object that is “An instance of a class”.
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.
Answer :
In simple words, if a Scala class and object shares the same name and defined in the same source file, then that class is known as “Companion Class” and that object is known as “Companion Object”.
When we create a Class by using Scala “class” keyword and Object by using Scala “object” keyword with same name and within the same source file, then that class is known as “Companion Class” and that object is known as “Companion Object”.
Example:-
Employee.scala
class Employee{ }
object Employee{ }
In Scala, The main purpose of Companion Object is to define apply methods and avoid using new keyword in creating an instance of that Companion class object.
Question 48. How To Implement Interfaces In Scala?
Answer :
As we know from Java background, we use interface to define contact.
However, there is no interface concept in Scala. Even, Scala doesn’t have interface keyword. Scala has a more powerful and flexible concept i.e. trait for this purpose.
Question 49. What Is Range In Scala? How To Create A Range In Scala?
Answer :
Range is a Lazy Collection in Scala. Range is a class available in ‘scala’ package like ‘scala.Range’. It is used to represent a sequence of integer values. It is an ordered sequence of integers.
Example:-
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)
Question 50. How Many Values Of Type Nothing Have In Scala?
Answer :
In Scala, Nothing type have no values that is zero. It does not have any values. It is a subtype of all Value classes and Reference classes.
Question 51. How Many Values Of Type Unit Have In Scala?
Answer :
In Scala, Unit is something similar to Java’s void keyword. It is used to represent “No value exists”. It has one and only one value that is ().
Question 52. What Is A Pure Function?
Answer :
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
Here “+” a pure function available in Int class. It gives same result 30 for same inputs 10 and 30, irrespective how many times we call it.
Question 53. In Fp, What Is The Difference Between A Function And A Procedure?
Answer :
Both are used to perform computation, however they have one major difference in Functional Programming world.
A function is a computation unit without side-effect where as a Procedure is also a computation unit with side-effects.
Answer :
Scala’s Auxiliary constructor is almost similar to Java’s constructor with few differences.
Compared to Java’s constructors, Auxiliary constructors have the following few differences:
Question 55. What Is The Use Of ‘yield’ Keyword In Scala’s For-comprehension Construct?
Answer :
We can use ‘yield’ keyword in Scala’s for-comprehension construct. ‘for/yield’ is used to iterate a collection of elements and generates new collection of same type. It does not change the original collection. It generates new collection of same type as original collection type.
For example, if we use ‘for/yield’ construct to iterate a List then it generates a new List only.
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)
Question 56. What Is Guard In Scala’s For-comprehension Construct?
Answer :
In Scala, for-comprehension construct has an if clause which is used to write a condition to filter some elements and generate new collection. This if clause is also known as “Guard”.
If that guard is true, then add that element to new collection. Otherwise, it does not add that element to original collection.
Example:- For-comprehension Guard to generate only Even numbers into new collection.
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)
Question 57. How Scala Solves Inheritance Diamond Problem Automatically And Easily Than Java 8?
Answer :
If we use Java 8’s Interface with Default methods, we will get Inheritance Diamond Problem. Developer has to solve it manually in Java 8. It does not provide default or automatic resolution for this problem.
In Scala, we will get same problem with Traits but Scala is very clever and solves Inheritance Diamond Problem automatically using Class Linearization concept.
Answer :
In Scala, Pattern Matching follows Visitor Design Pattern. In the same way, Java’s ‘isinstanceof’ operator also follows Visitor Design Pattern.
Answer :
Current Scala’s stable is 2.11.7. It supports Java SE 7.
The major change or update in Scala 2.12 version is that it supports Java SE 8 or later versions only. Scala 2.12 is not a binary compatible with the 2.11.x series. It’s still in Mile Stone Builds only.
Answer :
In Scala, Option is used to represent optional values that is either exist or not exist.
Option is an abstract class. Option has two subclasses: Some and None. All three (Option, Some and None) are defined in “scala” package like “scala.Option”.
Option is a bounded collection in Scala, which contains either zero or one element. If Option contains zero elements that is None. If Option contains one element, that is Some.
Some is used to represent existing value. None is used to represent non-existent value.
Example:-
def get(val index: Int): Option[String]
Let us assume that this method is from List. This method has a return type of Option[String]. If List contains elements, this get method returns “Some[String]” element available in that index position. Otherwise, it returns “None” (that is no elements)
Some is a case class and None is an Object. As both are case class/object, we can use them in Pattern Matching very well.
The combination of all these three definitions is known as Option/Some/None Design Pattern in Scala.
Answer :
In Scala, Either is an abstract class. It is used to represent one value of two possible types. It takes two type parameters: Either[A,B].
It exactly have two subtypes: Left and Right. If Either[A,B] represents an instance A that means it is Left. If it represents an instance B that means it is Right.
This is known as Either/Left/Right Design Pattern in Scala.
Answer :
Scala’s Option is similar to Java SE 8’s Optional. Java SE 8 has introduced a new utility class Optional to represent existing or non-existing of some value. Optional is available in java.util package.
Both Scala’s Option and Java SE 8’s Optional are used to represent optional values. Both are used to avoid unwanted null checks and NullPointerException.
Question 63. What Are The Advantages Of Functional Programming (fp) Or Advantages Of Pure Functions?
Answer :
The following are the Advantages of Functional Programming (FP) or Advantages of Pure Functions:
Answer :
There are many Scala-Based Framework to develop RESTful Web Services. Most popular frameworks are:
Answer :
Swagger is is the best tool for this purpose. It is very simple and open-source tool for generating REST APIs documentation with JSON for Scala-based applications.
Answer :
Like JPA, Hibernate and Toplink etc ORM Frameworks for Java-based applications, There are many ORM frameworks to use in Play/Scala based applications.
Popular ORM frameworks for Play/Scala based applications:
Answer :
ReactiveMongo is the best Scala Driver to develop Play/Scala applications to persist data in MongoDB NoSQL data store. It supports fully non-blocking and asynchronous I/O operations.
Question 68. Popular Clients Who Are Using Play And Scala To Develop Their Applications?
Answer :
Thousands of clients are using Play and Scala in Production. The following list is the more popular clients who are using Play and Scala actively.
Question 69. What Is The Best Language To Use With Play Framework: Scala Or Java?
Answer :
Play 2 is completely written in Scala. If we use Java with Play framework, we need to face many issues because Java does not support full FP features.
Scala is the best option to use with Play framework to develop Highly Scalable, Better Performance with Concurrency/Parallelism and Low latency applications, because:
Question 70. How Scala Supports Both Highly Scalable And Highly Performance Applications?
Answer :
As Scala supports Multi-Paradigm Programming(Both OOP and FP) and uses Actor Concurrency Model, we can develop very highly Scalable and high-performance applications very easily.
Question 71. What Are The Available Build Tools To Develop Play And Scala Based Applications?
Answer :
The following three are most popular available Build Tools to develop Play and Scala Applications:
Question 72. What Is Sbt? What Is The Best Build Tool To Develop Play And Scala Applications?
Answer :
SBT stands for Scala Build Tool. Its a Simple Build Tool to develop Scala-based applications.
Most of the people uses SBT Build tool for Play and Scala Applications. For example, IntelliJ IDEA Scala Plugin by default uses SBT as Build tool for this purpose.
Answer :
The following are most popular available Unit Testing, Functional Testing and/or BDD Frameworks for Play/Scala Based applications:
Question 74. What Is The Best Code-coverage Tool Available For Play And Scala Based Applications?
Answer :
SCoverage is the Code-coverage tool for Play and Scala based applications.
SCoverage stands for Scala Code-coverage tool. It has three separate plug-ins to supports the following build tools:
Answer :
Like Checkstyle for Java-Based Applications, Scalastyle is best Scala style checker tool available for Play and Scala based applications.
Scalastyle observes our Scala source code and indicates potential problems with it. It has three separate plug-ins to supports the following build tools:
It has two separate plug-ins to supports the following two IDEs:
Question 76. Which Ides Support Play And Scala-based Applications Development And How?
Answer :
The following two popular IDEs support Play and Scala-Based Applications Development:
They support by using Scala Plugins like Eclipse IDE has a Scala IDE for Eclipse to support Play and Scala-Based Applications Development.
IntelliJ IDEA has a plug-in like “Scala Plugin for IntelliJ IDEA” to support “Scala, SBT and Play 2 Framework” based applications.
Answer :
Play Framework’s default Unit and Functional Testing Framework is Spec2. It is very easy to test Play/Scala based applications using Spec2 Framework.
Play Framework’s Default built-in template is “Twirl”. It was developed in Scala. By using these templates, we can develop Play/Scala based applications very easily.
The Built-in or Default Web Server available for Play Framework is Netty Server.
Answer :
Because Scala supports the following extra features, it is better than Java 8:
Answer :
Anonymous Function is also a Function but it does not have any function name. It is also known as a Function Literal.
The advantages of a Anonymous Function/Function Literal in Scala:
Question 80. What Is An Higher-order Function (hof)?
Answer :
Higher Order Function (HOF) is also a function but which performs one, two or both of the following things:
Question 81. What Are The Differences Between Case Class And Normal Class?
Answer :
Case class is also a class, however when we compare it with normal class, it gives the following extra features or benefits:
All these features are added by Scala Compiler at compile-time. It is not possible with normal class.
Question 82. What Are The Advantages Of Play/scala Stack To Develop Web Applications?
Answer :
The following are the major advantages of Play/Scala stack to develop web applications:
Answer :
Java’s OOP constructs, which are not supported by Scala:
Scala’s OOP constructs, which are not supported by Java:
OR
The new OOPs constructs introduced by Scala, but not supported by Java:
Answer :
Call-by-name means evaluates method/function parameters only when we need them or we access them. If we don’t use them, then it does not evaluate them.
Scala supports both call-by-value and call-by-name function parameters. However, Java supports only call-by-value, but not call-by-name.
Difference between call-by-value and call-by-name:
The major difference between these two are described below:
Call-by-value:
1 def myFunction(a: Int, b: Int) { }
Here both a and b are Call-by-value parameters to myFunction.
Call-by-name:
1 def myFunction(a: Int, b: => Int) { }
Here both a is a Call-by-value parameter and b is Call-by-name to myFunction.
Question 85. What Are The Popular Mvc Frameworks For Scala Language To Develop Web Applications?
Answer :
The following are the most popular MVC frameworks available for Scala Language to develop Web Applications:
Answer :
Not only in Java and Scala, in almost all OOP languages Constructor is used to create (or assemble) an object or an instance of a Class using it’s parameters (or components). Extractor is quite opposite to Constructor.
In Scala, Extractor is used to decompose or disassemble an object into it’s parameters (or components).
In Scala, apply method is a Constructor. Internally, Extractor uses unapply method to decompose an objects into it’s parts (or parameters). In Scala, Extractor is mainly used in Pattern Matching concept. We will discuss Pattern Matching concept soon.
Question 87. What Is The Use Of ‘???’ In Scala-based Applications?
Answer :
This ‘???’ three question marks is not an operator, a method in Scala. It is used to mark a method which is ‘In Progress’ that means Developer should provide implementation for that one.
This method is define in scala.PreDef class as shown below:
def ??? : Nothing = throw new NotImplementedError
If we run that method without providing implementation, then it throws ‘NotImplementedError’ error as shown below:
scala> def add(a:Int, b:Int) : Int = ???
add: (a: Int, b: Int)Int
scala> add(10,20)
scala.NotImplementedError: an implementation is missing
Answer :
In Scala, both List and Stream are from Collection API and works almost similar. Both are Immutable collections.
However, there is one main difference between List and Stream in Scala Collection API: That is List elements are evaluated Eagerly and Stream elements are evaluated Lazily that means when we access them.
scala> var list1 = List(1,2,3,4)
list1: List[Int] = List(1, 2, 3, 4)
Here we can observe that all List elements evaluated at the time of creating List object. However, if we do same thing on Stream, we cannot see all elements. We can see only first evaluated element and remaining elements are evaluated lazily as shown below:
scala> var s1 = Stream(1,2,3,4)
s1: scala.collection.immutable.Stream[Int] = Stream(1, ?)
When we want Lazy collection to evaluate elements only when we access them then it’s better to use Stream.
Answer :
In Scala Collection API,
Question 90. If I Want To Become A Fullstack Scala Developer, Which Technology Stack I Should Learn?
Answer :
If you want to become a Fullstack Scala Developer, you should learn the following technology stack:
Scala Related Practice Tests |
|
---|---|
Python Practice Tests | Adv Java Practice Tests |
Hadoop Practice Tests | Ruby on Rails Practice Tests |
MongoDB Practice Tests |
All rights reserved © 2020 Wisdom IT Services India Pvt. Ltd
Wisdomjobs.com is one of the best job search sites in India.