Variables & Data Types

Introduction

Variables are how a program stores and names the data it works with. Kotlin gives you two keywords for declaring them — `val` for values that cannot be reassigned, and `var` for values that can — plus a rich set of built-in types and a type inference system that keeps code concise without sacrificing safety.

This lesson covers `val` and `var`, Kotlin's core data types, type inference, string templates, and how to convert between types explicitly.

val vs var

`val` declares a read-only reference — once assigned, it cannot be reassigned to point at a different value (this is similar to `final` in Java). `var` declares a mutable reference that can be reassigned later. Idiomatic Kotlin strongly favors `val` by default, only reaching for `var` when reassignment is genuinely needed.

fun main() {
    val name = "Alice"      // read-only — cannot be reassigned
    var score = 90           // mutable — can be reassigned

    score = 95                // OK
    // name = "Bob"           // Compile error: val cannot be reassigned

    println("$name scored $score")
}

Type Inference

Kotlin is statically typed, but you rarely have to write types out explicitly, because the compiler infers them from the assigned value. You can still write the type explicitly when you want to be clear, or when there is no initial value to infer from.

val age = 30              // inferred as Int
val price = 19.99          // inferred as Double
val name: String            // explicit type, no value yet
name = "PrograMinds"        // must be assigned before use

Basic Data Types

Kotlin's built-in types cover whole numbers, decimals, characters, booleans, and text. Unlike Java, every type in Kotlin — even `Int` and `Boolean` — is an object with methods, though the compiler optimizes most of them down to efficient primitives under the hood.

String Templates

Kotlin lets you embed expressions directly inside string literals using `$`, called string templates. This removes the need for clunky string concatenation with `+` that Java requires.

fun main() {
    val user = "Priya"
    val itemCount = 3

    println("Hello, $user!")
    println("You have ${itemCount * 2} points remaining.")
}

A bare `$name` works for a simple variable; curly braces (`${expression}`) are required whenever you want to embed a full expression, like a calculation or a method call, inside the string.

Type Conversion

Unlike Java, Kotlin does not perform implicit widening conversions between number types — an `Int` is never silently promoted to a `Long` or `Double`. This is a deliberate safety decision: implicit numeric conversions are a common source of subtle bugs. You must convert explicitly using functions like `.toLong()`, `.toDouble()`, or `.toInt()`.

fun main() {
    val wholeNumber: Int = 10
    val asDouble: Double = wholeNumber.toDouble()   // explicit conversion required
    val asString: String = wholeNumber.toString()

    println(asDouble)
    println(asString)
}

A Note on Nullable Types

Every type you've seen so far — `Int`, `String`, `Double`, and the rest — is non-nullable by default, meaning it can never hold `null`. Kotlin has a separate, explicit syntax (`String?`, `Int?`, and so on) for types that are allowed to be null. This lesson deliberately doesn't use nullable types yet — you'll cover them thoroughly, with all the operators for working with them safely, in the dedicated Null Safety lesson.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You now know how to declare variables, work with Kotlin's core types, and build strings with templates. Next, you'll learn how to control the flow of your programs with if, when, and loops.