Explore topic-wise InterviewSolutions in .

Scala automatically GENERATES getter-setter METHODS for each field DEFINED in a class after compilation. If there is a field as, value:Int

the getter-setter methods for this field would be, 

These methods are public for a public field whereas those are private for a private one.

However, the developer may create such public methods for a private field.

Also, they may declare getter-setter of a DIFFERENT pattern, like getXXX and setXXX .

When a class extends multiple traits, it might happen that they have a common method. Now when that method is executed, it is very important to know the trait on which the method is INVOKED first. The linearization rule says that the common method execution WOULD start in the traits from right to left as it is mentioned in the extends list.

Even if the traits have a common super trait or abstract class, the execution order would be linear so that no conflicts arise. Let’s take an example:

Though the class hierarchy is like a graph, the execution of the method stringValue FOLLOWS a particular order based on the linearization rule:

D CT AT BT A

This implies that if a class or trait extends multiple traits, such a common method execution starts from the extreme right in the extends list. That’s why stringValue of AT executed before that of BT.

A statement is an instruction that performs some operation, whereas, an expression evaluates a value. In SCALA, the basic control structures such as if and for-loop are expressions, as they RETURN value and it can be ASSIGNED to a variable. For example, 

In Scala, every package permits one package object to declare. It is a singleton object where the defined members can be imported in a class through the package import. It lets the developer define top-level FUNCTIONS. Please note that overloading is not ALLOWED in package objects. Let’s see an example:

Scala import provides a NUMBER of flexibilities. We can EXCLUDE certain CLASSES while importing the whole package:

Also, it’s POSSIBLE while importing that we can rename the existing classes. 

Scala defines 3 types of access modifiers:
Default: This is equivalent to the publicin Java, i.e., accessible from anywhere.
Protected: This makes members accessible in class, companion classes, and subclasses. However, one can mention the scope within which it can be accessible.
Private: The members with this access are available only in the same class and in the companion class - not in a subclass.

We can take an example to understand the scope of private and protected: 

In the above code, as the protected scope is bound inside package amt, the variable is accessible inside B. On the other hand, the scope of private is MENTIONED like this, that’s why it is not accessible OUTSIDE its instance.

Scala allows passing a block of code in a function which is evaluated only when it is used. This kind of parameters are called a by-name parameter. By-name parameters are often used while DEFINING a new CONTROL structure. Let’s take an example.

Immutability is a very important concept in software development. Immutable objects don’t change their state after construction. So they are very safe to USE as a shared object in a multi-threaded environment. They also reduce the parts of code which need explicit synchronization and LOCKS. This IMPROVES the overall performance of the system. Immutable objects HELP in writing pure functions or methods. There are no side effects in pure functions. That is why they make the whole application less bug-prone and easily TESTABLE.

A trait is like a Java interface declaring a SET of methods and fields. The difference is that the members of a trait may not be abstract. If a class extends a trait, it should implement the abstract methods and fields declared by the trait. On the other hand, it may or may not override those methods having bodies. For example,

Traits help us to build rich interfaces where a number of methods define their body in terms of a few abstract methods. This is useful when we INTEND to extend the functionalities of a trait without breaking the client code.

Traits are also very useful in mixing features in a TYPE. A class can extend multiple traits. Moreover, one instance of a class can be created mixing in a number of traits inline as in:

These features provide with a lot of flexibility to play with object creation with different attributes and behavior.

Scala doesn’t have a static keyword to DEFINE the OBJECT-independent METHODS. We can directly define them in a singleton object. Otherwise, we can use a companion object for a given class for holding those methods. For example, we can create a List in Scala in the following way,

This is POSSIBLE as there is a method named apply defined in the object - List .

Scala PERMITS defining the auxiliary constructors of a class using this keyword. If we define one or more than one methods in the class body, they BECOME the auxiliary constructors. The first statement of an auxiliary CONSTRUCTOR must be either a call to the primary constructor or any other auxiliary constructor. For example,

In Scala, while declaring a class, sometimes we SPECIFY some PARAMETERS which are mandatory to pass while instantiating an object of that type. These parameters are called the class parameters.

As the body of the class plays the ROLE of the primary CONSTRUCTOR in Scala, these parameters actually define its arguments. If we declare the parameters with val or var, they become a member of the class. In the example below, id, name, and salary are the class parameters for the Employee class. Here, id and name are the members of the class, but the salary is not.

Function and method both terms are used when a CODE block takes a SET of parameters and computes a value or performs some action based on the INPUTS. Such a block is called a function when it is not associated with any class. On the other hand, one such block is called a method when it is a member of a class.

For example, in the code below, getSalary() is a method of the class Employee, but sortBySalaryis function.

In Scala, val and LAZY val both are used to declare a value. When we declare a val and ASSIGN some expression in it, the expression is evaluated and assigned in that place. Whereas, for lazy val, the expression is evaluated and the value is assigned at the time of its first use.

Lazy VALS are useful when OBJECT creation or expression evaluation is costly in terms of CPU and memory and the value may or may not be used based on some condition.

SCALA has a feature to define a function in the body of another function. The scope of these functions are the declaring function only. That is they are not accessible from anywhere else in the CODE. These functions are called local functions.

Sometimes we need a set of small functions to define a complete functionality. Those functions are not contextual in other places. In that scenario, local functions COME into the picture. LET’s TAKE an example.

Here, the recursive function gcd() inside gcdList() is a local function.

A function that TAKES another function as an argument or returns a function is called a higher-order function. For EXAMPLE, the sumApplied() function as defined below is a higher-order function.

In Scala, FUNCTIONS can be written as LITERALS. They can be assigned to any variable, can be passed to another function as an argument or can be returned from a function as a value. These functions are called first-order functions. For example, in the following code snippet, X => x*x is a first-order function which has been assigned to a value NAMED SQUARE.

val square = x => x*x

Scala is a general-purpose language which runs on JVM. It has some unique features which make it very useful to develop programs of different shapes and sizes. Starting from a SMALL script to enterprise level multi-module applications, Scala GIVES the developers a lot of flexibility in design and implementation. Inferring types, implicit conversions and its conciseness help defining custom control structures and domain-specific languages. On one side, its object-oriented features help to design systems with complex ENTITIES. On the other hand, the functional programming constructs help to develop bug-free and reusable code. In short, the language FITS in serving all kinds of requirements. That’s why it is called a scalable language.