Kotlin Classes: A Deep Dive into Object-Oriented Programming

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

Kotlin, like many modern programming languages, embraces object-oriented programming (OOP) principles. At the heart of OOP lies the concept of the class, a blueprint for creating objects that encapsulate data (properties) and behavior (functions). This blog post will explore Kotlin classes in detail, covering everything from basic class definitions to advanced concepts like inheritance and casting.

Basic Classes

In Kotlin, a class is defined using the class keyword, followed by the class name and an optional body enclosed in curly braces:

class Foo {
    // Class content goes here
}

class Foo {

// Class content goes here

}

A class can be empty, but most classes contain properties and functions:

Properties: Represent the data associated with the class.
Functions: Define the actions that objects of the class can perform.

Creating Instances of Classes

To create an instance of a class (an object), you simply call the class name as if it were a function:

val foo = Foo() // Creates an instance of the Foo class

1 2	val foo = Foo() // Creates an instance of the Foo class

This invokes the class’s “constructor,” which we’ll explore in more detail later.

Packages

Kotlin uses packages to organize classes into namespaces, similar to Java. You declare a package at the top of a Kotlin file:

package com.example.myapp

class MyClass {
    // Class content
}

package com.example.myapp

class MyClass {

// Class content

}

Common Contents: Functions and Properties

Inside a class, you can define functions and properties that are specific to that class.

Functions

Functions within a class are declared using the fun keyword:

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

fun main() {
    val foo = Foo()
    foo.something() // Calls the something() function on the foo object
}

class Foo {

fun something() {

println("Hello, world!")

}

fun main() {

val foo = Foo()

foo.something() // Calls the something() function on the foo object

}

Properties

Properties are declared using var (for mutable properties) or val (for read-only properties):

class Foo {
    var count = 0 // Mutable property
    fun something() {
        count += 1
        println("something() was called $count times")
    }
}

fun main() {
    val foo = Foo()
    foo.something()
    println("The final count was ${foo.count}")
}

class Foo {

var count = 0 // Mutable property

fun something() {

count += 1

println("something() was called $count times")

}

fun main() {

val foo = Foo()

foo.something()

println("The final count was ${foo.count}")

}

`this` Keyword

The this keyword refers to the current instance of the object. You can use it to access properties and functions of the object:

class Foo {
    var count = 0
    fun something() {
        this.count += 1 // Using 'this' to access the count property
        println("something() was called $count times")
    }
}

class Foo {

var count = 0

fun something() {

this.count += 1 // Using 'this' to access the count property

println("something() was called $count times")

}

Constructors

Constructors are special functions that initialize objects when they are created.

Primary Constructors

The primary constructor is part of the class declaration itself:

class Foo(var count: Int) { // Primary constructor with a parameter
    fun something() {
        count += 1
        println("something() was called $count times")
    }
}

fun main() {
    val foo = Foo(0) // Pass the initial count to the constructor
    foo.something()
}

class Foo(var count: Int) { // Primary constructor with a parameter

fun something() {

count += 1

println("something() was called $count times")

}

fun main() {

val foo = Foo(0) // Pass the initial count to the constructor

foo.something()

}

The var keyword in the primary constructor parameter list declares the count as a property of the class.

Formal Approach

You can also use the constructor keyword explicitly, but it’s often omitted for primary constructors:

class Foo constructor(var count: Int) {
    // ...
}

class Foo constructor(var count: Int) {

// ...

}

Init Blocks

Init blocks are used to execute code during object initialization. They are declared using the init keyword:

class Foo(sillyCount: String) {
    var count = 0
    init {
        count = sillyCount.toInt() // Initialize count from the sillyCount string
    }
}

class Foo(sillyCount: String) {

var count = 0

init {

count = sillyCount.toInt() // Initialize count from the sillyCount string

}

A class can have multiple init blocks, which are executed in the order they appear.
Init blocks can reference properties declared before them in the class.

Secondary Constructors

Secondary constructors are declared within the class body using the constructor keyword:

class Foo(var count: Int) {
    constructor(sillyCount: String) : this(sillyCount.toInt()) {
        // Additional initialization code (optional)
    }
}

class Foo(var count: Int) {

constructor(sillyCount: String) : this(sillyCount.toInt()) {

// Additional initialization code (optional)

}

Secondary constructors must call the primary constructor using this().

Default Parameter Values

Kotlin allows you to define default values for constructor parameters:

class View(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0,
    defStyleRes: Int = 0
) {
    // ...
}

class View(

context: Context,

attrs: AttributeSet? = null,

defStyleAttr: Int = 0,

defStyleRes: Int = 0

) {

// ...

}

This allows you to call the constructor with varying numbers of arguments, using the default values for any omitted parameters.

Inheritance

Kotlin supports inheritance, allowing you to create new classes (subclasses) that inherit properties and functions from existing classes (superclasses).

Extending a Class

Use a colon (:) to indicate inheritance:

open class Base(val tag: String) // 'open' allows inheritance
class Foo(var count: Int) : Base("Foo Example") {
    // ...
}

open class Base(val tag: String) // 'open' allows inheritance

class Foo(var count: Int) : Base("Foo Example") {

// ...

}

Note: Classes are final by default in Kotlin. You must use the open keyword to allow a class to be inherited.

Chaining to Superclass Constructors

The subclass constructor must call the superclass constructor, passing any required parameters:

open class Base(val tag: String)
class Foo(var count: Int) : Base("Foo Example") {
    // ...
}

open class Base(val tag: String)

class Foo(var count: Int) : Base("Foo Example") {

// ...

}

Open Classes

By default, Kotlin classes are final, meaning they cannot be inherited from. To allow inheritance, you must mark a class as open.

open class Base { // Can be inherited
}

class Foo : Base() {
    // ...
}

open class Base { // Can be inherited

}

class Foo : Base() {

// ...

}

Overriding Functions

Subclasses can override functions from their superclasses. The superclass function must be marked as open, and the overriding function must be marked with override:

open class Base {
    open fun gimmeTheTag() = "Base Tag"
}

class Foo : Base() {
    override fun gimmeTheTag() = "Foo Tag"
}

open class Base {

open fun gimmeTheTag() = "Base Tag"

}

class Foo : Base() {

override fun gimmeTheTag() = "Foo Tag"

}

Overriding Properties

Properties can also be overridden in subclasses. The superclass property must be declared as open, and the overriding property must be marked with override:

open class Base(open val tag: String)

class Foo(override val tag: String) : Base(tag)

open class Base(open val tag: String)

class Foo(override val tag: String) : Base(tag)

Chaining to Superclass Functions

You can call the superclass implementation of a function using the super keyword:

open class Base {
    open fun gimmeTheTag() = "Base Tag"
}

class Foo : Base() {
    override fun gimmeTheTag() = super.gimmeTheTag() + " - Extended"
}

open class Base {

open fun gimmeTheTag() = "Base Tag"

}

class Foo : Base() {

override fun gimmeTheTag() = super.gimmeTheTag() + " - Extended"

}

Inheritance Tests

Kotlin provides the is keyword to check if an object is an instance of a particular type:

open class Animal
class Frog : Animal()

fun main() {
    val critter: Animal = Frog()
    if (critter is Frog) {
        println("It's a frog!")
    }
}

open class Animal

class Frog : Animal()

fun main() {

val critter: Animal = Frog()

if (critter is Frog) {

println("It's a frog!")

}

Casting

Casting converts a reference to a supertype into a subtype.

Manual Casting

You can use the as keyword for manual casting:

val critter: Animal = Frog()
val kermit = critter as Frog

val critter: Animal = Frog()

val kermit = critter as Frog

Smart Casts

Kotlin’s “smart casts” automatically cast a variable to a subtype within if and when blocks if the compiler can determine that the variable is of that subtype:

open class Animal
class Frog : Animal() {
    fun hop() = println("Hop!")
}

fun main() {
    val critter: Animal = Frog()
    if (critter is Frog) {
        critter.hop() // No explicit cast needed
    }
}

open class Animal

class Frog : Animal() {

fun hop() = println("Hop!")

}

fun main() {

val critter: Animal = Frog()

if (critter is Frog) {

critter.hop() // No explicit cast needed

}

Conclusion

Kotlin’s object-oriented features provide a powerful and flexible way to structure your code. Understanding classes, constructors, inheritance, and casting is crucial for building robust and maintainable Kotlin applications. By leveraging these concepts effectively, you can create well-designed, reusable components that make your code easier to understand and extend.

Citations: [1] https://commonsware.com/licenses