Mastering Kotlin Properties: Initialization, Visibility, and Scope

March 2025
M	T	W	T	F	S	S
	1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

Introduction

Kotlin offers a modern, concise, and expressive syntax for defining properties in your classes. While properties may seem straightforward at first glance, Kotlin provides a wide array of features that go beyond the basics. In this blog, we will explore the different ways to initialize properties, manage visibility, and understand the scope of properties in Kotlin.

1. Property Initialization in Kotlin

In Kotlin, properties are an essential part of class definitions. They can be initialized in various ways, depending on the circumstances and your coding needs. Let’s dive into the most common methods:

When Declared

The most common way to initialize a property is directly at the point of declaration. This is ideal when you know the property’s value upfront.

class Foo {
    var count = 0
}

class Foo {

var count = 0

}

Here, count is initialized with a value of 0 when the class is instantiated.

In an Init Block

You can also initialize properties in the init block. This is useful when the property depends on constructor parameters or requires more complex logic to be assigned.

class Foo(sillyCount: String) {
    var count: Int
    init {
        count = sillyCount.toInt()
    }
}

class Foo(sillyCount: String) {

var count: Int

init {

count = sillyCount.toInt()

}

In this example, the count property is initialized inside the init block, based on the sillyCount parameter.

Late Initialization

Sometimes, the property can’t be initialized immediately. This is where the lateinit modifier comes into play. lateinit promises that the property will be initialized before being used.

class Foo {
    lateinit var label: String
    fun defineTag(tag: String) {
        label = tag
    }
}

class Foo {

lateinit var label: String

fun defineTag(tag: String) {

label = tag

}

Remember, lateinit can’t be used with primitive types like Int or Boolean.

Lazy Initialization

Kotlin also offers by lazy for deferred initialization. With this approach, the property is only initialized when it’s accessed for the first time.

class Foo(val rawLabel: String) {
    val label: String by lazy { rawLabel.toUpperCase() }
}

class Foo(val rawLabel: String) {

val label: String by lazy { rawLabel.toUpperCase() }

}

In this case, label will be initialized only when it’s first used, and the lambda expression will convert the label to uppercase.

2. Visibility in Kotlin Properties

Visibility modifiers in Kotlin help control what parts of your code can access certain properties. Understanding these modifiers ensures better encapsulation and organization of your code.

Default: Public

By default, all classes, properties, and functions in Kotlin are public. This means they are accessible from anywhere in the project.

class Foo {
    fun something() {
        println("Hello, world!")
    }
}

class Foo {

fun something() {

println("Hello, world!")

}

Private

private restricts the visibility to within the class or file. Code outside the class cannot access private members.

class Foo {
    private fun something() {
        println("Hello, world!")
    }
}

class Foo {

private fun something() {

println("Hello, world!")

}

In this case, calling foo.something() outside the class would result in a compilation error.

Protected

protected allows access within the class and its subclasses. This is useful for inheritance scenarios.

open class Foo {
    protected fun something() {
        println("Hello, world!")
    }
}
class Bar : Foo() {
    fun somethingElse() {
        something()
    }
}

open class Foo {

protected fun something() {

println("Hello, world!")

}

class Bar : Foo() {

fun somethingElse() {

something()

}

The Bar class can access the something() method from Foo because it’s protected.

Internal

internal limits access to the same module. This is particularly useful for modularized projects, like Android apps.

internal class Foo {
    fun something() {
        println("Internal visibility")
    }
}

internal class Foo {

fun something() {

println("Internal visibility")

}

In this case, only code within the same module can access the Foo class and its members.

3. Scope of Properties

The scope of a property determines where it is accessible. Kotlin supports different levels of scope that impact its lifetime and accessibility.

Global Scope

Top-level properties and functions have a global scope. These exist for the lifetime of the program and are accessible from anywhere in the code.

val foo = Foo()
foo.something()

val foo = Foo()

foo.something()

Here, both foo and the Foo class are globally accessible.

Instance Scope

Instance properties are specific to the instance of the class. Each object of the class has its own separate properties.

class Foo(val count: Int)

fun main() {
    val instanceOne = Foo(1)
    val instanceTwo = Foo(2)
    println(instanceOne.count)
    println(instanceTwo.count)
}

class Foo(val count: Int)

fun main() {

val instanceOne = Foo(1)

val instanceTwo = Foo(2)

println(instanceOne.count)

println(instanceTwo.count)

}

Each instance of Foo has its own value for count, independent of other instances.

Local Scope

Properties defined within a function, block, or lambda are local to that scope.

class Foo {
    fun something(message: String) {
        val length = message.length
        println("'$message' has $length characters")
    }
}

class Foo {

fun something(message: String) {

val length = message.length

println("'

m e s s a g e^{'} h a s

length characters")

}

Here, length is only accessible within the something() function.

Conclusion

Kotlin offers a wide range of ways to initialize, manage visibility, and control the scope of properties. Understanding how to use these features effectively will help you write clean, efficient, and maintainable code. Whether you’re dealing with simple properties, utilizing lateinit for deferred initialization, or controlling access with visibility modifiers, Kotlin has the tools to help you organize your code to suit your needs.