SCALA Basics

Chapter 1: Introduction to Scala

Scala is a state-of-the-art language that unifies object-oriented and functional programming in one
concise package. Running on the Java Virtual Machine (JVM), it seamlessly integrates with Java’s
ecosystem. Its design focuses on simplicity, expressiveness, and power—providing developers with
advanced abstractions while keeping the code clean and maintainable.

Highlights:

 Java Interoperability: Easily use Java libraries and frameworks.

 Concise Syntax: Reduces unnecessary boilerplate.

 Functional Paradigms: Embraces immutability, higher-order functions, and pattern matching.

 Concurrent Programming: Utilizes Akka for scalable, reactive systems.

 Static Typing: Ensures robust code by catching errors at compile time.

Chapter 2: Scala vs. Java

Scala builds on the strengths of Java while incorporating modern features that streamline
development:

Aspect Java Scala

Syntax Verbose, many lines Compact and expressive

Type Inference Requires explicit declarations Automatically infers types

Concurrency Uses Threads & Executors Leverages Akka for reactive design

Functional Support Limited built-in support Fully embraces functional programming

Pattern Matching Manual implementation required Integrated into the language

Scala’s design is particularly suited for big data, web applications, and distributed systems.

Chapter 3: Variables and Data Types

Scala differentiates between two variable types to manage data effectively:

 Immutable (val): Once assigned, the value remains constant.

 Mutable (var): The value can be updated later.

Example:

scala

CopyEdit
val immutableVar = 10 // Constant value

var mutableVar = 20 // Can be reassigned

mutableVar = 30 // Updated value

Primary Data Types:

 Int: 32-bit integers (e.g., 10, -3)

 Double: Floating-point numbers (e.g., 3.14)

 Boolean: True or false values

 String: Sequences of characters (e.g., "Hello")

Chapter 4: Control Flow and Loops

Control structures in Scala guide the execution of code blocks:

 Conditionals: Use if-else statements to branch logic.

 Loops: Employ for and while loops to iterate over collections or ranges.

Conditional Example:

scala

CopyEdit

val x = 15

if (x > 10) println("Greater than 10")

else println("Less or equal to 10")

Loop Example:

scala

CopyEdit

for (i <- 1 to 5) println(i) // Prints numbers 1 to 5

Chapter 5: Functions in Scala

Functions in Scala are treated as first-class citizens, meaning they can be passed, returned, and
stored in variables.

Simple Function:

scala

CopyEdit

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

Higher-Order Function Example:

scala

CopyEdit

val multiply = (x: Int, y: Int) => x * y

println(multiply(3, 4)) // Output: 12

Chapter 6: Collections and Functional Programming

Scala offers an extensive collection library to simplify data manipulation:

 Lists: Ordered sequences.

 Sets: Collections with unique elements.

 Maps: Key-value pairs.

Example:

scala

CopyEdit

val numbers = List(1, 2, 3, 4, 5)

val squaredNumbers = numbers.map(x => x * x)

println(squaredNumbers) // Output: List(1, 4, 9, 16, 25)

Chapter 7: Object-Oriented Programming in Scala

Scala fully embraces object-oriented design, supporting classes, objects, inheritance, and
polymorphism.

Example:

scala

CopyEdit

class Person(val name: String, val age: Int) {

def greet(): String = s"Hello, my name is $name and I am $age years old."

val person = new Person("Alice", 25)

println(person.greet())
Chapter 8: Pattern Matching & Case Classes

Pattern matching simplifies decision-making by directly comparing values and structures, much like
an enhanced switch-case.

Example:

scala

CopyEdit

def matchTest(x: Int): String = x match {

case 1 => "One"

case 2 => "Two"

case _ => "Other"

println(matchTest(2)) // Output: Two

Chapter 9: Concurrency with Akka

Scala’s integration with Akka facilitates the development of concurrent and distributed systems using
the actor model.

Example:

scala

CopyEdit

import akka.actor._

class HelloActor extends Actor {

def receive = {

case "hello" => println("Hello, Akka!")

case _ => println("Unknown message")

val system = ActorSystem("HelloSystem")

val helloActor = system.actorOf(Props[HelloActor], name = "helloactor")

Chapter 10: Scala for Web Development

Scala powers modern web applications through frameworks like Play Framework, known for its
reactive and scalable architecture.

Example:

scala

CopyEdit

import play.api._

import play.api.mvc._

object HelloController extends Controller {

def hello = Action { Ok("Hello, Scala Web!") }