Kotlin Variables: Understanding var vs val - A Beginner's Guide to Android Development

Daniel Ibisagba — Fri, 29 Aug 2025 09:33:40 +0000

Starting your Android development journey? One of the fundamental concepts you'll encounter is variable declaration in Kotlin. Let's dive deep into the differences between var and val, and understand when to use each one.

Introduction
As I began my Android development journey, one of the first things that caught my attention in Kotlin was how variables are declared differently from other programming languages I'd used before. Coming from languages like Java or JavaScript, Kotlin's approach to variable declaration with var and val initially seemed confusing, but it turns out to be one of Kotlin's most powerful features for writing safer, more predictable code.

What Are Variables in Kotlin?
Variables in Kotlin are containers that store data values. Unlike Java, Kotlin uses type inference, meaning you don't always need to explicitly specify the data type - the compiler can figure it out from the assigned value.
The Two Keywords: var vs val
Kotlin provides two keywords for variable declaration:

var - for mutable (changeable) variables
val - for immutable (read-only) variables

Let's explore each one with practical examples.
Understanding var - Mutable Variables
The var keyword is used to declare mutable variables. This means you can change their values after declaration.

// Basic var declaration
var userName = "John Doe"
println(userName) // Output: John Doe

// Changing the value
userName = "Jane Smith"
println(userName) // Output: Jane Smith

// Explicit type declaration (optional due to type inference)
var age: Int = 25
age = 30 // This is allowed

// Different data types
var isLoggedIn: Boolean = false
var score: Double = 95.5
var items: MutableList<String> = mutableListOf("Apple", "Banana")

When to Use var
Use var when:

The value needs to change during the program execution
You're working with counters, accumulators, or state variables
Dealing with user input that gets updated
Working with collections that need modification

// Example: User login state
var currentUser: String? = null

fun loginUser(username: String) {
    currentUser = username // Value changes based on login
}

// Example: Counter in a game
var playerScore = 0
fun increaseScore(points: Int) {
    playerScore += points // Score keeps changing
}

Understanding val - Immutable Variables
The val keyword creates immutable variables - once assigned, their value cannot be changed. Think of it as "value" or similar to final in Java.

kotlin// Basic val declaration
val appName = "My Android App"
println(appName) // Output: My Android App

// This would cause a compilation error:
// appName = "Different Name" // Error: Val cannot be reassigned

// Explicit type declaration
val maxRetries: Int = 3
val pi: Double = 3.14159
val isProduction: Boolean = true

// val with complex objects
val userList: List<String> = listOf("Alice", "Bob", "Charlie")

*When to Use val
*
Use val when:

The value should never change after initialization
Working with constants or configuration values
Dealing with immutable data structures
Following functional programming principles

// Example: App constants
val API_BASE_URL = "https://api.myapp.com"
val MAX_LOGIN_ATTEMPTS = 3
val DEFAULT_TIMEOUT = 30000L

// Example: Configuration values
val databaseName = "app_database"
val sharedPrefsName = "user_preferences"

// Example: Immutable data class
data class User(val id: String, val name: String, val email: String)
val currentUser = User("123", "John", "john@email.com")

*Key Differences: var vs val
*

Important Nuances and Gotchas

val with Mutable Objects This is a common source of confusion. val makes the reference immutable, not necessarily the object itself:

val mutableList = mutableListOf("Apple", "Banana")
// This is allowed - we're modifying the object, not reassigning the reference
mutableList.add("Orange")
mutableList.remove("Apple")
println(mutableList) // Output: [Banana, Orange]

// But this would cause an error:
// mutableList = mutableListOf("Different", "List") // Error!

Late Initialization Sometimes you need to declare a variable before you can initialize it:

kotlin// Using lateinit with var
lateinit var databaseInstance: Database

// Using lazy initialization with val
val expensiveResource: String by lazy {
    // This block runs only when first accessed
    computeExpensiveValue()
}

fun computeExpensiveValue(): String {
    // Simulate expensive computation
    return "Computed Value"
}

Nullable Variables Both var and val can be nullable:

kotlin
var nullableVar: String? = null
val nullableVal: String? = null

// Safe reassignment for var
nullableVar = "Now has value"

// val cannot be reassigned even if null
// nullableVal = "This would cause error" // Error!

Advantages of Kotlin's Variable System|

Immutability by Default Kotlin encourages immutable variables, leading to fewer bugs and more predictable code.

// Good practice: Start with val
val userName = getUserName()
val userAge = calculateAge()

// Only use var when necessary
var attempts = 0

2 Type Safety
Strong type inference reduces boilerplate while maintaining type safety:

kotlin
val name = "Kotlin" // Compiler infers String
val version = 1.8    // Compiler infers Int
val isStable = true  // Compiler infers Boolean

3 Null Safety
Explicit nullable types prevent null pointer exceptions:

kotlin
val nonNullableString: String = "Safe"
val nullableString: String? = null

Best Practices and Recommendations

Prefer val Over var Start with val by default. Only use var when you actually need to reassign the variable:

// Good
val userId = getCurrentUserId()
val userName = fetchUserName(userId)

// Only use var when reassignment is needed
var loadingState = false
fun toggleLoading() {
    loadingState = !loadingState
}

Use Descriptive Names

// Good
val maxRetryAttempts = 3
val userAuthToken = generateToken()

// Avoid
val x = 3
val t = generateToken()

Group Related Declarations

// User-related constants
val DEFAULT_USER_ROLE = "guest"
val MAX_USERNAME_LENGTH = 50
val MIN_PASSWORD_LENGTH = 8

// API-related constants
val API_TIMEOUT = 30000L
val MAX_API_RETRIES = 3

Real-World Android Example
Here's how you might use var and val in an actual Android activity:

class LoginActivity : AppCompatActivity() {

    // Constants - using val
    private val MAX_LOGIN_ATTEMPTS = 3
    private val SHARED_PREFS_NAME = "login_prefs"

    // Mutable state - using var
    private var currentAttempts = 0
    private var isLoading = false

    // Views - using val (reference won't change)
    private val emailEditText by lazy { findViewById<EditText>(R.id.email) }
    private val passwordEditText by lazy { findViewById<EditText>(R.id.password) }
    private val loginButton by lazy { findViewById<Button>(R.id.login_button) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)

        setupClickListeners()
    }

    private fun setupClickListeners() {
        loginButton.setOnClickListener {
            if (!isLoading && currentAttempts < MAX_LOGIN_ATTEMPTS) {
                performLogin()
            }
        }
    }

    private fun performLogin() {
        val email = emailEditText.text.toString() // val - won't change in this scope
        val password = passwordEditText.text.toString() // val - won't change in this scope

        if (validateInput(email, password)) {
            isLoading = true // var - state changes
            currentAttempts++ // var - counter increments

            // Perform actual login logic...
        }
    }
}

Common Pitfalls to Avoid

Overusing var

// Avoid
var result = calculateSomething()
return result

// Better
val result = calculateSomething()
return result

Confusion with Mutable Collections

// This val holds a mutable list - the list can change, but the reference cannot
val items = mutableListOf<String>()
items.add("New item") // OK

// This would be an error:
// items = mutableListOf<String>() // Error - cannot reassign val

Performance Considerations
Using val can lead to better performance because:

Compiler optimizations: The compiler can optimize immutable variables better
Memory efficiency: Immutable variables can be cached and reused
Thread safety: Less synchronization overhead in concurrent scenarios

// The compiler can optimize this better
val constantValue = "Hello World"

// This requires more careful handling
var changingValue = "Initial Value"

Conclusion

Understanding the difference between var and val is crucial for writing effective Kotlin code in Android development. Here are the key takeaways:

Use val by default - it leads to safer, more predictable code
Use var only when you need to reassign the variable
Remember that val makes the reference immutable, not necessarily the object
Embrace immutability - it reduces bugs and improves code quality
Leverage Kotlin's type inference while maintaining type safety

As you continue your Android development journey, you'll find that this simple distinction between var and val forms the foundation for writing clean, maintainable Kotlin code. The language's emphasis on immutability will help you avoid many common programming pitfalls and write more robust applications.
Start practicing with simple examples, and gradually incorporate these concepts into your Android projects. Remember, good variable declaration practices today will save you debugging time tomorrow!

Happy coding! 🚀

What's your experience with Kotlin variables? Share your thoughts and questions in the comments below.

DEV Community: Daniel Ibisagba

Kotlin Variables: Understanding var vs val - A Beginner's Guide to Android Development