Конструкторы в Котлине

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

fun main() {
    val myCar = Car() // Call of the parameterless constructor
    println("Make: ${myCar.make}, Model: ${myCar.model}")
}  

// Class with a parameterless constructor
class Car{
    // Class properties
    var make: String = "Undefined"
    var model: String = "Undefined"
}

Но также можно создавать свои собственные конструкторы, используя ключевое слово конструктор чтобы определить класс. Различают начальный и вторичный Конструкторы. Класс может иметь первичный конструктор и несколько вторичных конструкторов. Эта гибкость обеспечивает дифференцированную инициализацию объектов.

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

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

class Car constructor(_make: String){
    
}

Подобно функциям, конструкторы в Kotlin могут иметь параметры, позволяющие Принять данные извне для инициализации объекта. Например, в примере выше конструктор имеет параметр сделать типа строка.

Если основной конструктор не имеет аннотаций или модификаторов доступа, ключевое слово конструктор быть опущено.

class Car(_make: String){
    
}

Инициализатор

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

class Car(_make: String){
      val make: String
      init{
          make = _make  
      }    
}

Конструктор принимает параметр _делать типа Строка. Внутри класса есть свойство сделать типа строка заявил. в в этом-Блок, инициализатор, это свойство становится значением параметра _делать назначенный. Это означает, что при создании класса объекта Авто, значение для сделать непосредственно через переданный параметр конструктора _делать определен.

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

Теперь мы используем наш класс для создания нескольких объектов: 

fun main() {
    val car1 = Car("Toyota")
    val car2 = Car("Ford")
    val car3 = Car("Volkswagen")     

    println(car1.make)   // Output: Toyota
    println(car2.make)   // Output: Ford
    println(car3.make)   // Output: Volkswagen
}

class Car(_make: String){
      val make: String
      init{
          make = _make  
      }    
}

Важно отметить, что если в классе определен основной конструктор, он будет использоваться для создания объекта. Невозможно одновременно использовать конструктор по умолчанию, созданный компилятором, и основной конструктор.

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

class Car(_make: String){
      val make: String
}

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

Первичный конструктор также можно использовать для определения свойств (атрибутов). Свойства можно создавать непосредственно в конструкторе, используя волна (для неизменяемых свойств) или вар (для переменных свойств). Это упрощает и сокращает структуру кода, поскольку свойства не нужно определять отдельно в теле класса, а назначаются непосредственно в конструкторе. Это делает код более понятным и эффективным.

fun main() { 
    val car1: Car = Car("Volkswagen", "Beetle", 2.0f)
 
    println("Make: ${car1.make}, Model: ${car1.model}, Engine size: ${car1.engineSize}")
}
 
class Car(val make: String, var model: String, var engineSize: Float){
 
}

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

Вторичные конструкторы в Kotlin используются для предоставления дополнительных и более гибких способов создания объектов класса. Они позволяют определять различную логику построения в одном классе, которые могут отличаться количеством и типом параметров. Это особенно полезно, когда вы хотите создавать объекты в разных условиях или с разными значениями инициализации.

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

class Car(_make: String){   // Primary constructor
      val make: String = _make
      var engineSize: Float = 0.00f

// Secondary constructor     
    constructor(_make: String, _engineSize: Float) : this(_make){
        engineSize = _engineSize
    }
}

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

class Car(_make: String){ 
      val make: String = _make

Он также становится изменяемым свойством размер двигателя инициализируется значением по умолчанию 0.00f.

var engineSize: Float = 0.00f

Вторичный конструктор принимает два параметра: _делать и _размер двигателя, в отличие от. Он вызывает основной конструктор это(_make) а затем устанавливает значение размер двигателя о ценности _размер двигателя.

    constructor(_make: String, _engineSize: Float) : this(_make){
        engineSize = _engineSize
    }

Теперь мы используем созданный класс Car и инициализируем два разных объекта:

fun main() {
    val car1 = Car("Volkswagen")
    val car2 = Car("Ford", 2.5f)

    println("Make: ${car1.make}, Engine size: ${car1.engineSize}")
    println("Make: ${car2.make}, Engine size: ${car2.engineSize}")
}

class Car(_make: String){   // Primary constructor
      val make: String = _make
      var engineSize: Float = 0.00f

// Secondary constructor     
    constructor(_make: String, _engineSize: Float) : this(_make){
        engineSize = _engineSize
    }
}

В дер- главный-Функция будет двумя объектами класса Авто созданный. Для создания объекта car1 используется основной конструктор, который принимает один параметр. Для создания объекта car2 применяется вторичный конструктор с двумя параметрами.

При необходимости можно определить любое количество вторичных конструкторов:

fun main() {
    val car1 = Car("Volkswagen")
    val car2 = Car("Ford", 2.5f)
    val car3 = Car("Toyota", 1.9f, "Diesel")

    println("Make: ${car1.make}, Engine size: ${car1.engineSize}")
    println("Make: ${car2.make}, Engine size: ${car2.engineSize}")
    println("Make: ${car3.make}, Engine size: ${car3.engineSize}, Fuel type: ${car3.fuelType}")
}

class Car(_make: String){   // Primary constructor
      val make: String = _make
      var engineSize: Float = 0.00f
      var fuelType: String = "Undefined"

// 1th secondary constructor     
    constructor(_make: String, _engineSize: Float) : this(_make){
        engineSize = _engineSize
    }

// 2th secondary constructor     
    constructor(_make: String, _engineSize: Float, _fuelType: String) : this(_make, _engineSize){
        fuelType = _fuelType
    }
}

В классе Авто стал новым объектом недвижимости тип топлива добавлено описание типа топлива автомобиля. Также был добавлен еще один конструктор, принимающий три параметра. Чтобы получить код для присвоения свойств сделать и размер двигателя Чтобы избежать дублирования, этот вторичный конструктор передает настройку этих свойств другому вторичному конструктору, который принимает два параметра, вызывая это (_make, _engineSize). Это означает, что этот вызов вызывает первый вторичный конструктор с двумя параметрами.

Результат:

Make: Volkswagen, Engine size: 0.0
Make: Ford, Engine size: 2.5
Make: Toyota, Engine size: 1.9, Fuel type: Diesel