Классы

Первичный конструктор

Первичный конструктор задаёт начальное состояние экземпляра при его создании.

Чтобы объявить первичный конструктор, укажите его в заголовке класса после имени класса:

class Person constructor(name: String) { /*...*/ }

Если у первичного конструктора нет аннотаций или модификаторов видимости, ключевое слово constructor можно опустить:

class Person(name: String) { /*...*/ }

Первичный конструктор может объявлять параметры как свойства. Используйте ключевое слово val перед именем аргумента, чтобы объявить свойство, доступное только для чтения, и ключевое слово var — для изменяемого свойства:

class Person(val name: String, var age: Int) { /*...*/ }

Эти свойства-параметры конструктора хранятся в экземпляре и доступны за пределами класса.

Можно также объявить параметры первичного конструктора, которые не являются свойствами. Перед такими параметрами не указываются val или var, поэтому они не сохраняются в экземпляре и доступны только внутри тела класса:

// Primary constructor parameter that is also a property
class PersonWithProperty(val name: String) {
    fun greet() {
        println("Hello, $name")
    }
}

// Primary constructor parameter only (not stored as a property)
class PersonWithAssignment(name: String) {
    // Must be assigned to a property to be usable later
    val displayName: String = name
    
    fun greet() {
        println("Hello, $displayName")
    }
}

К свойствам, объявленным в первичном конструкторе, могут обращаться функции-члены класса:

// Class with a primary constructor declaring properties
class Person(val name: String, var age: Int) {
    // Member function accessing class properties
    fun introduce(): String {
        return "Hi, I'm $name and I'm $age years old."
    }
}

Первичному конструктору также можно назначить значения свойств по умолчанию:

class Person(val name: String = "John", var age: Int = 30) { /*...*/ }

Если при создании экземпляра конструктору не передано значение, для свойств используются значения по умолчанию:

// Class with a primary constructor 
// including default values for name and age
class Person(val name: String = "John", var age: Int = 30)

fun main() {
    // Creates an instance using default values
    val person = Person()
    println("Name: ${person.name}, Age: ${person.age}")
    // Name: John, Age: 30
}

Параметры первичного конструктора можно использовать для инициализации дополнительных свойств класса непосредственно в теле класса:

// Class with a primary constructor 
// including default values for name and age
class Person(
    val name: String = "John",
    var age: Int = 30
) {
    // Initializes the description property 
    // from the primary constructor parameters
    val description: String = "Name: $name, Age: $age"
}

fun main() {
    // Creates an instance of the Person class
    val person = Person()
    // Accesses the description property
    println(person.description)
    // Name: John, Age: 30
}

Как и в функциях, в объявлениях конструкторов можно использовать завершающие запятые:

class Person(
    val name: String,
    val lastName: String,
    var age: Int,
) { /*...*/ }

Блоки инициализации

Первичный конструктор инициализирует класс и задаёт его свойства. В большинстве случаев для этого достаточно простого кода.

Если при создании экземпляра нужно выполнить более сложные операции, поместите эту логику в блоки инициализации внутри тела класса. Эти блоки выполняются при вызове первичного конструктора.

Объявите блоки инициализации с помощью ключевого слова init, за которым следуют фигурные скобки {}. Внутри фигурных скобок укажите код, который должен выполняться при инициализации:

// Class with a primary constructor that initializes name and age
class Person(val name: String, var age: Int) {
    init {
        // Initializer block runs when an instance is created
        println("Person created: $name, age $age.")
    }
}

fun main() {
    // Creates an instance of the Person class
    Person("John", 30)
    // Person created: John, age 30.
}

Добавьте столько блоков инициализации (init {}), сколько необходимо. Они выполняются в том порядке, в котором указаны в теле класса, вместе с инициализаторами свойств:

//sampleStart
// Class with a primary constructor that initializes name and age
class Person(val name: String, var age: Int) {
    // First initializer block
    init {
        // Runs first when an instance is created
        println("Person created: $name, age $age.")
    }

    // Second initializer block
    init {
        // Runs after the first initializer block
        if (age < 18) {
            println("$name is a minor.")
        } else {
            println("$name is an adult.")
        }
    }
}

fun main() {
    // Creates an instance of the Person class
    Person("John", 30)
    // Person created: John, age 30.
    // John is an adult.
}
//sampleEnd

В блоках инициализации можно использовать параметры первичного конструктора. Например, в приведённом выше коде первый и второй блоки инициализации используют параметры name и age первичного конструктора.

Блоки init часто используются для проверки данных. Например, можно вызвать функцию require:

class Person(val age: Int) {
    init {
        require(age > 0) { "age must be positive" }
    }
}

Вторичные конструкторы

В Kotlin вторичные конструкторы — это дополнительные конструкторы класса, помимо первичного. Они полезны, когда нужно несколько способов инициализации класса, а также для взаимодействия с Java.

Чтобы объявить вторичный конструктор, используйте ключевое слово constructor внутри тела класса и укажите параметры конструктора в круглых скобках (). Логику конструктора поместите в фигурные скобки {}:

// Class header with a primary constructor that initializes name and age
class Person(val name: String, var age: Int) {

    // Secondary constructor that takes age as a
    // String and converts it to an Int
    constructor(name: String, age: String) : this(name, age.toIntOrNull() ?: 0) {
        println("$name created with converted age: ${this.age}")
    }
}

fun main() {
    // Uses the secondary constructor with age as a String
    Person("Bob", "8")
    // Bob created with converted age: 8
}

В приведённом выше коде вторичный конструктор делегирует вызов первичному с помощью ключевого слова this, передавая name и значение age, преобразованное в целое число.

В Kotlin вторичные конструкторы должны делегировать вызов первичному конструктору. Благодаря этому вся логика инициализации первичного конструктора выполняется до запуска логики вторичного конструктора.

Делегирование конструктора может быть:

• Прямым, когда вторичный конструктор сразу вызывает первичный конструктор.

• Косвенным, когда один вторичный конструктор вызывает другой, а тот делегирует вызов первичному конструктору.

Ниже показано, как работает прямое и косвенное делегирование:

// Class header with a primary constructor that initializes name and age
class Person(
    val name: String,
    var age: Int
) {
    // Secondary constructor with direct delegation 
    // to the primary constructor
    constructor(name: String) : this(name, 0) {
        println("Person created with default age: $age and name: $name.")
    }

    // Secondary constructor with indirect delegation: 
    // this("Bob") -> constructor(name: String) -> primary constructor
    constructor() : this("Bob") {
        println("New person created with default age: $age and name: $name.")
    }
}

fun main() {
    // Creates an instance based on the direct delegation
    Person("Alice")
    // Person created with default age: 0 and name: Alice.

    // Creates an instance based on the indirect delegation
    Person()
    // Person created with default age: 0 and name: Bob.
    // New person created with default age: 0 and name: Bob.
}

В классах с блоками инициализации (init {}) код этих блоков становится частью первичного конструктора. Поскольку вторичные конструкторы сначала делегируют вызов первичному, все блоки инициализации и инициализаторы свойств выполняются до тела вторичного конструктора. Даже если у класса нет первичного конструктора, делегирование всё равно происходит неявно:

// Class header with no primary constructor
class Person {
    // Initializer block runs when an instance is created
    init {
        // Runs before the secondary constructor
        println("1. First initializer block runs")
    }

    // Secondary constructor that takes an integer parameter
    constructor(i: Int) {
        // Runs after the initializer block
        println("2. Person $i is created")
    }
}

fun main() {
    // Creates an instance of the Person class
    Person(1)
    // 1. First initializer block runs
    // 2. Person 1 created
}

Классы без конструкторов

У классов, в которых не объявлены конструкторы (первичный или вторичные), есть неявный первичный конструктор без параметров:

// Class with no explicit constructors
class Person {
    // No primary or secondary constructors declared
}

fun main() {
    // Creates an instance of the Person class 
    // using the implicit primary constructor
    val person = Person()
}

Этот неявный первичный конструктор имеет общедоступный уровень видимости, то есть к нему можно обратиться из любого места. Если вы не хотите, чтобы у класса был общедоступный конструктор, объявите пустой первичный конструктор с другим уровнем видимости:

class Person private constructor() { /*...*/ }