Why Scala?

• JVM
• Statically typed
• Mixed paradigm
  • OOP
  • FP
• Sophisticated type system
• Elegant, flexible syntax
• Scalable

Data types

val - var

immutable - mutable

							val name: Type = initialization // recommended
var name: Type = initialization
						

Demo

Conditional expressions

The entire if itself is an expression. Which means it produces a result.

							if (expression) {
  /* ... */
} else if (expression) {
  /* ... */
} else {
  /* ... */
}
						

Demo

Compound Expressions

A compound expression can contain any number of other expressions, including other curly-braced expressions

						{ expressions }
					

Demo

Methods & Functions

Functions are values; methods are not.

Methods

Evaluated, every time, on call.

							def name(arg1: Type1, arg2: Type2): ReturnType = {
  /* ... */
}
						

Functions

Evaluated on initialization.

lazy val will evaluate on first call; only once.

							(n: Int) => { /* ... */ }
						

Demo

Classes

							class MyClass
val o = new MyClass
						

Fields

							class Company(var name: String)
class Company(val name: String)
class Company(name: String)
class Company(private var name: String)
class Company(private val name: String)
class Company { val name = "CGI" }
						

Named & default arguments

							// Named arguments
class Company(name: String, country: String)
new Company(name = "CGI", country = "Belgium")

// Default arguments
class Company(name: String = "CGI", country: String = "Belgium")
new Company("Telenet")
new Company(country = "Canada")
						

Overloading

							class Foo {
  def bar() = /* ... */
  def bar(n: Int) = /* ... */
}
						

Note: overloading doesn't work in the REPL. Use REPL's :paste mode

Constructors

							class Foo() {
  println("Called on creation")
}
						

Auxiliary constructors

							class Point(x: Int, y: Int) {
  def this(x: Int) {
    this(x, 0)
  }
}
						

Case classes

							case class Name(arg1: Type, arg2: Type, ...)
						

Companion Objects

							class Company() { /* ... */ }
object Company() { /* ... */ }
						

placeholder

more coming

Demo

Loops

For loops

							for (var <- list) statement
for (var <- range) statement
for (var <- [range/list] if condition1; if condition2; ...) statement
						

While loops

							while (condition) {
  /* ... */
}
						

Do While loop

							do {
  /* ... */
} while (condition)
						

Demo

Collections

scala.collection

High-level abstract classes/traits

scala.collection.immutable

scala.collection.mutable

Best practice immutable/mutable

• Prefer immutable
• Use the mutable namespace explicitly

							// Do
import scala.collection.mutable
val set = mutable.Set()

// Don't
import scala.collection.mutable._
val set = Set()
						

Common used

Demo

Pattern Matching

							x match {
  case 1 => "one"
  case 2 => "two"
  case _ => "many"
}
						

With types

							x match {
  case s: String => "A String"
  case i: Int if i < 10 => "An Int less than 10"
  case i: Int => "An Int"
  case c: Company => "A company"
}
						

With Case Classes

							transport match {
  case Car(passengers, seats) => /* ... */
  case Bicycle(passengers, seats) => /* ... */
  case Passenger => /* ... */
}
						

Inheritance

                        class Animal
class Bird extends Animal
class Ape extends Animal
                    

Superclass Initialization

                            class Animal(val age: Int)
class Bird(age: Int) extends Animal(age)
class Ape(age: Int, val weight: Double) extends Animal(age)
                        

Overriding

							class Bar {
  def run = 2
}

class Foo extends Bar {
  override def toString = "Hello World!"
  override def run = super.run * 2
}