Classes and objects

Why classes?

Real apps deal with things: users, products, orders, bus tickets. Each thing has data (a name, a price) and actions (add to cart, cancel). A class keeps the data and the actions together in one named type. An object (or instance) is one actual thing made from the class, like one particular student.

Declaring a class with a primary constructor

class Student(val name: String, var marks: Int) {
    fun result(): String = if (marks >= 33) "Pass" else "Fail"
}

fun main() {
    val s = Student("Kavya", 72)     // create an object: no "new" keyword
    println(s.name)                  // Kavya
    s.marks = 28                     // var property can change
    println(s.result())              // Fail
}

A property is a value that belongs to an object. val properties are read-only after creation; var properties can change. A function inside a class is often called a method; it can use the object's properties directly.

Each object has its own copy of the properties. Changing s.marks for Kavya does not change the marks of any other Student object, just as filling one admission form does not change anyone else's form.

init blocks and validation

class BankAccount(val holder: String, initialBalance: Long) {
    var balance: Long = initialBalance
        private set                  // outside code can read but not change it

    init {
        require(initialBalance >= 0) { "Balance cannot be negative" }
    }

    fun deposit(amount: Long) {
        require(amount > 0) { "Deposit must be positive" }
        balance += amount
    }
}

Note that initialBalance has no val or var, so it is just a constructor parameter, not a property. private set lets everyone read balance but only the class itself change it, so nobody can set balance = 1_000_000 from outside.

Visibility

Custom getters

class Rectangle(val width: Int, val height: Int) {
    val area: Int
        get() = width * height       // computed every time it is read
}

Secondary constructors and lateinit

Most Kotlin classes need only the primary constructor; default values usually replace extra constructors. You may meet secondary constructors (constructor(...) : this(...)) in code that talks to Java. You will also see lateinit var in Android code for properties set up a little after creation; reading one before it is set throws an exception, so use it carefully.

Common mistakes

• Writing new Student(...). Kotlin has no new keyword.
• Forgetting val or var in the constructor, then wondering why s.name does not exist.
• Making every property var and public. Start with val; expose changes through methods that check the rules.
• Putting too much in one class. A class should represent one idea.