Scala Getting Started Flashcards
Expression
Expressions are computable statements1 + 1
Declare a value
- Use the
valkeywordval 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
Declare a variable
- 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.
~~~
Anonymous function
Explain and write an example
- 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.
Function
Short explanation
- Function that has name.
Function with 0 param
Write example
val getAge = () => 32
Function with 1 param
Write example
val addOne = (x: Int) => x + 1
Function with > 1 params
Write example
val add = (x: Int, y: Int) => x + y
Method
- Methods look and behave very similar to functions but with differences.
- Defined with the
defkeyword. - Followed by a name, parameter list(s), a return type, and a body.
def add(x: Int, y: Int): Int = x + y
Method with 1 param list
Write example
def add(x: Int, y: Int): Int = x + y
Method with > 1 param lists
Write example
def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
Method with 0 param list
Write example
def name: String = System.getProperty("user.name")
Methods with multi-line expressions
Write example
def getSquareString(input: Double): String = {
val square = input * input
square.toString
}Class
Write a class with a name, 2 params, and a method that doesn’t return any value
class Greeter(prefix: String, suffix: String) {
def greet(name: String): Unit =
println(prefix + name + suffix)
}Create a new instance of a class
Write example
val greeter = new Greeter("Hello, ", "!")
Case class
Explain
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.
Define a case class
Write example
case class Point(x: Int, y: Int)
Instantiate a case class
Write example
- ` val point = Point(1, 2)`
val anotherPoint = Point(1, 2)
You can instantiate case classes without the new keyword
Compare instances of case classes
Write example
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
String interpolation
write example
val name = "Linh" print(s"Hello $name")
Keyword object
Definition
- An
objectis 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!")
}
}Access an object
By inferring to its name
~~~
val newId: Int = IdFactory.create()
~~~
Keyword class
Definition
- 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
newkeyword.
class Greeter(prefix: String, suffix: String) {
def greet(name: String): Unit =
println(prefix + name + suffix)
}Keyword trait
Definition
- 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 + “!”)
}
~~~
Program entry point
Definition
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.
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!")
}
Automatic generated methods of a case class
equals()hashCode()toString()copy()- pattern matching support
