Fundamentals

Scala has two ways to name a value. val creates an immutable binding — once assigned, it can never point at anything else. var creates a mutable variable you can reassign. Idiomatic Scala uses val almost everywhere and reaches for var only for a local counter or accumulator, because code where names never change is easier to read, test and run in parallel.

@main def run(): Unit =
  val name = "Asha"
  var visits = 1
  println(s"$name has visited $visits time")

  visits = visits + 1
  visits += 1
  println(s"$name has visited $visits times")

Asha has visited 1 time
Asha has visited 3 times

@main def run(): Unit =
  val score = 10
  score = 20
  println(score)

-- [E052] Type Error: Main.scala:3:8
3 |  score = 20
  |  ^^^^^^^^^^
  |  Reassignment to val score
1 error found
Compilation failed

@main def run(): Unit =
  var score = 10
  score = 20
  println(score)

There is also lazy val: its right-hand side is not evaluated until the first time the value is used, and then the result is cached.

@main def run(): Unit =
  lazy val config =
    println("loading config...")
    "prod"
  println("program started")
  println(config)
  println(config)

program started
loading config...
prod
prod

Every value in Scala has a type known at compile time, but you rarely have to write it: the compiler infers it from the right-hand side. val n = 42 is an Int; val d = 4.2 is a Double. Write the type yourself with a colon when you want to document intent or force a wider type: val big: Long = 42.

@main def run(): Unit =
  val count = 42
  val price = 19.99
  val ok = true
  val grade = 'A'
  val big: Long = 3_000_000_000L
  println(count.getClass.getSimpleName)
  println(price.getClass.getSimpleName)
  println(s"$count $price $ok $grade $big")
  println(Int.MaxValue)
  println(Int.MaxValue + 1)

int
double
42 19.99 true A 3000000000
2147483647
-2147483648

getClass printed int and double because at runtime Scala's Int and Double compile to fast JVM primitives. In your code they are still full objects with methods: 42.max(7), 3.7.round, 'a'.isLetter.

@main def run(): Unit =
  val age: Int = "42"
  println(age)

-- [E007] Type Mismatch Error: Main.scala:2:17
2 |  val age: Int = "42"
  |                 ^^^^
  |                 Found:    ("42" : String)
  |                 Required: Int
1 error found
Compilation failed

@main def run(): Unit =
  val age: Int = "42".toInt
  println(age)

A Scala String is a Java string with extra methods. To put values inside a string, prefix the literal with an interpolator: s"..." substitutes $name or any expression inside ${...}; f"..." also takes printf-style formats like %.2f and checks them against the types at compile time; raw"..." leaves backslashes alone.

@main def run(): Unit =
  val item = "coffee"
  val qty = 3
  val price = 2.5
  println(s"$qty x $item")
  println(s"total: ${qty * price}")
  println(f"total: $$${qty * price}%.2f")
  println(f"$item%-8s|$qty%4d|")
  println("tab:\tend")
  println(raw"tab:\tend")

3 x coffee
total: 7.5
total: $7.50
coffee  |   3|
tab:	end
tab:\tend

Triple quotes make a multi-line string where nothing needs escaping. stripMargin removes everything up to and including a leading | on each line, so you can indent the literal with your code.

@main def run(): Unit =
  val sql =
    """SELECT name
      |FROM users
      |WHERE active = true""".stripMargin
  println(sql)

  val s = "  Hello, Scala  "
  println(s.trim.toUpperCase)
  println(s.trim.length)
  println(s.contains("Scala"))
  println("a,b,c".split(",").toList)
  println("scala" * 2)
  println("hello".capitalize.reverse)

SELECT name
FROM users
WHERE active = true
HELLO, SCALA
12
true
List(a, b, c)
scalascala
olleH

In Scala, 1 + 2 is really a method call: 1.+(2). Any method with one parameter can be written in this infix style, which is why a max b and list contains 3 are legal. It also means operators follow ordinary method rules — there is nothing special about + except its name.

@main def run(): Unit =
  println(1 + 2)
  println(1.+(2))
  println(7 / 2)
  println(7.0 / 2)
  println(7 % 3)
  println(-7 % 3)
  println(10 max 3)
  println(2 + 3 * 4)
  println(math.pow(2, 10))
  println(math.abs(-5))

3
3
3
3.5
1
-1
10
14
1024.0
5

@main def run(): Unit =
  val a = "scala"
  val b = "SCALA".toLowerCase  // built at run time: a different object
  println(a == b)
  println(a eq b)
  println(3 == 3.0)
  val age = 20
  println(age >= 18 && age < 65)
  println(!(age > 30))

true
false
true
true
true

scala.io.StdIn.readLine() reads one line typed by the user (without the newline) and returns it as a String. readInt() and readDouble() read a whole line and parse it as a number. The example below was run with the input shown under "stdin" fed to it.

import scala.io.StdIn.readLine

@main def run(): Unit =
  print("Your name: ")
  val name = readLine()
  print("Your age: ")
  val age = readLine().trim.toInt
  println()
  println(s"Hi $name, next year you will be ${age + 1}.")

Your name: Your age: 
Hi Meera, next year you will be 28.

Reading many numbers from one line is a common interview and competitive-programming pattern: split on whitespace and convert each piece.

import scala.io.StdIn.readLine

@main def run(): Unit =
  val nums = readLine().trim.split("\\s+").map(_.toInt)
  println(s"count=${nums.length} sum=${nums.sum} max=${nums.max}")

count=6 sum=108 max=42

Numbers convert with toInt, toLong, toDouble and friends. Anything converts to text with toString. Text converts to numbers with "42".toInt — but that throws if the text is not a number. The safe version, toIntOption, returns Some(42) or None instead, and you decide what to do with the failure.

@main def run(): Unit =
  println(3.99.toInt)
  println(3.99.round)
  println(7.toDouble / 2)
  println(65.toChar)
  println('A'.toInt)
  println(42.toString + "!")
  println("123".toInt + 1)
  println("12a".toIntOption)
  println("123".toIntOption)
  println("12a".toIntOption.getOrElse(0))

3
4
3.5
A
65
42!
124
None
Some(123)
0

@main def run(): Unit =
  val n = "4x2".toInt
  println(n)

Exception in thread "main" java.lang.NumberFormatException: For input string: "4x2"
	at java.base/java.lang.NumberFormatException.forInputString(Unknown Source)
	at java.base/java.lang.Integer.parseInt(Unknown Source)
	at scala.collection.StringOps$.toInt$extension(StringOps.scala:971)
	at Main$package$.run(Main.scala:2)
	at run.main(Main.scala:1)

@main def run(): Unit =
  val n = "4x2".toIntOption.getOrElse(0)
  println(n)

val

An immutable binding: the name always refers to the same value.

var

A mutable variable that can be reassigned with =.

lazy val

A val whose right-hand side is evaluated on first use and then cached.

Type inference

The compiler working out a type from the value, so you do not have to write it.

String interpolator

A prefix like s, f or raw before a string literal that substitutes $values into it.

Infix notation

Calling a one-argument method without dot and parentheses: a max b means a.max(b).

toIntOption

Parses text to Some(number), or None if it is not a valid Int — the non-throwing toInt.

Unit

The type with one value, (), returned by code run only for its side effect.