Scala Getting Started

Question 1

Expression

Answer 1

Expressions are computable statements
1 + 1

Question 2

Declare a value

Answer 2

• Use the val keyword
  val x = 1 + 1 ‘
• Values cannot be re-assigned
  x = 3 // This does not compile.
• The type of a value can be omitted and inferred, or it can be explicitly stated
  val x: Int = 1 + 1

Question 3

Declare a variable

Answer 3

• Variables are like values, except you can re-assign them.
• You can define a variable with the var keyword.

var x = 1 + 1
x = 3 // This compiles because "x" is declared with the "var" keyword.

Question 4

Anonymous function

Explain and write an example

Answer 4

• Function that has no name.
  (x: Int) => x + 1
• On the left of ` =>` is a list of parameters. On the right is an expression involving the parameters.

Question 5

Function

Short explanation

Answer 5

• Function that has name.

Question 6

Function with 0 param

Write example

Answer 6

val getAge = () => 32

Question 7

Function with 1 param

Write example

Answer 7

val addOne = (x: Int) => x + 1

Question 8

Function with > 1 params

Write example

Answer 8

val add = (x: Int, y: Int) => x + y

Question 9

Method

Answer 9

• Methods look and behave very similar to functions but with differences.
• Defined with the def keyword.
• Followed by a name, parameter list(s), a return type, and a body.
  def add(x: Int, y: Int): Int = x + y

Question 10

Method with 1 param list

Write example

Answer 10

def add(x: Int, y: Int): Int = x + y

Question 11

Method with > 1 param lists

Write example

Answer 11

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier

Question 12

Method with 0 param list

Write example

Answer 12

def name: String = System.getProperty("user.name")

Question 13

Methods with multi-line expressions

Write example

Answer 13

def getSquareString(input: Double): String = {
  val square = input * input
  square.toString
}

Question 14

Class

Write a class with a name, 2 params, and a method that doesn’t return any value

Answer 14

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

Question 15

Create a new instance of a class

Write example

Answer 15

val greeter = new Greeter("Hello, ", "!")

Question 16

Case class

Explain

Answer 16

A special type of class that is primarily used to hold immutable data. It is designed to be used in functional programming and is often employed for modeling immutable data structures, such as records or data transfer objects (DTOs)

By default, instances of case classes are immutable, and they are compared by value (unlike classes, whose instances are compared by reference). This makes them additionally useful for pattern matching.

Question 17

Define a case class

Write example

Answer 17

case class Point(x: Int, y: Int)

Question 18

Instantiate a case class

Write example

Answer 18

• ` val point = Point(1, 2)`
• val anotherPoint = Point(1, 2)

You can instantiate case classes without the new keyword

Question 19

Compare instances of case classes

Write example

Answer 19

if (point == anotherPoint) {
  println(s"$point and $anotherPoint are the same.")
} else {
  println(s"$point and $anotherPoint are different.")
} // Point(1,2) and Point(1,2) are the same.

Instances of case classes are compared by value, not by reference

Question 20

String interpolation

write example

Answer 20

val name = "Linh"  	
print(s"Hello $name")

Question 21

Keyword object

Definition

Answer 21

• An object is a singleton instance of a class. It is a way to define a single instance of a class directly, without needing to create an explicit instance.
• It is commonly used for creating utility classes, holding global state, or implementing design patterns like the Factory pattern.
• An object can have methods, fields, and implement interfaces.
• Singleton objects are lazily instantiated and their initialization is thread-safe.

object MySingleton {
  def sayHello(): Unit = {
    println("Hello, I am a singleton object!")
  }
}

Question 22

Access an object

Answer 22

By inferring to its name

val newId: Int = IdFactory.create()

Question 23

Keyword class

Definition

Answer 23

• A class is a blueprint for creating objects.
• It defines the properties (fields) and behavior (methods) that objects of that class will have.
• You can create multiple instances (objects) from a class, each with its own state.
• Classes can also extend other classes or implement interfaces.
• To create an instance of the class and access its methods, you need to instantiate it using the new keyword.

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

Question 24

Keyword trait

Definition

Answer 24

• Traits are abstract data types containing certain fields and methods.
• In Scala inheritance, a class can only extend one other class, but it can extend multiple traits.

trait Greeter {
  def greet(name: String): Unit
}

• Traits can also have default implementations:

trait Greeter {
  def greet(name: String): Unit =
    println("Hello, " + name + "!")
}

Question 25

Program entry point | Definition

Answer 25

The main method is the entry point of a Scala program. The Java Virtual Machine requires a main method, named main, that takes one argument: an array of strings. ## Footnote In Scala 2 you must define a main method manually. Using an object, you can define the main method as follows: ``` object Main { def main(args: Array[String]): Unit = println("Hello, Scala developer!") } ```

Question 26

Automatic generated methods of a `case class`

Answer 26

* `equals()` * `hashCode()` * `toString()` * `copy()` * pattern matching support