class / Constructor

// Primary constructor (most common form)
class Person(val name: String, var age: Int)

// Use an init block for initialization logic.
class User(val name: String, val age: Int) {
    init {
        require(age >= 0) { "Age must be 0 or greater" }
    }
}

// Secondary constructor (constructor keyword)
class Point {
    val x: Double
    val y: Double
    constructor(x: Double, y: Double) {
        this.x = x
        this.y = y
    }
    constructor(value: Double) : this(value, value)  // delegation
}

// Primary constructor with property declarations
class Person(
    val name: String,
    var age: Int,
    val email: String = ""  // default argument
) {
    // The init block runs after the constructor.
    init {
        require(name.isNotBlank()) { "Name cannot be blank" }
        require(age >= 0) { "Age must be 0 or greater" }
        println("Person instance created: $name (age $age)")
    }

    // Computed property
    val greeting: String
        get() = "Hello, I'm ${name}!"
}

// Example of a secondary constructor
class Rectangle(val width: Double, val height: Double) {
    val area: Double = width * height

    // Secondary constructor for squares
    constructor(side: Double) : this(side, side)
}

// Private constructor (factory pattern)
class Database private constructor(val url: String) {
    companion object {
        fun create(url: String): Database {
            println("Connecting to database: $url")
            return Database(url)
        }
    }
}

fun main() {
    // Create an instance using the primary constructor
    val alice = Person("Alice", 30, "alice@example.com")
    println(alice.greeting)

    // Use the default argument.
    val bob = Person("Bob", 25)
    println("Bob's email: '${bob.email}'")  // empty string

    // Call the constructor with named arguments.
    val carol = Person(name = "Carol", age = 28)
    println("Carol's age: ${carol.age}")

    // Secondary constructor
    val rect = Rectangle(4.0, 3.0)
    val square = Rectangle(5.0)  // square
    println("Rectangle area: ${rect.area}")  // 12.0
    println("Square area: ${square.area}")  // 25.0

    // Factory pattern
    val db = Database.create("jdbc:mysql://localhost/mydb")
    println("Connected to: ${db.url}")

    // Validation in init (invalid arguments throw an exception)
    try {
        Person("", 25)
    } catch (e: IllegalArgumentException) {
        println("Error: ${e.message}")
    }
}

Kotlin classes are far more concise than their Java equivalents when it comes to constructors. Because you can declare properties directly in the primary constructor, the field declaration, constructor body, and assignment that Java requires are all condensed into a single line.

You can write multiple init blocks; they are executed in order from top to bottom. A secondary constructor must always delegate to the primary constructor using : this(...).

For classes focused purely on holding data, see data class. For inheritance and overriding, see open / override.