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.