Kotlin constructor primario constructor secundario parámetros predeterminados init orden de inicialización del bloque de código

package set

import java.util.*
import kotlin.math.absoluteValue

//临时变量 只是用一次推荐使用下划线开头
class Player(
    _name: String, _age: Int, _isNormal: Boolean //构造参数
) {

    //属性

    var name = _name
        get() = field.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
        set(value) {
            field = value.trim()
        }
    //取绝对值
    var age = _age
        get() = field.absoluteValue
        set(value) {
            field = age.absoluteValue
        }
    var isNormal = _isNormal;

}

fun main() {
    val p = Player("Jack", 20, true)
    p.name = "rose"
    println(p.name)
    println(p.age)
    println(p.isNormal)
}

Puedes poner el atributo cuadrado a lo anterior para simplificar la escritura.

package set

import java.util.*
import kotlin.math.absoluteValue

//临时变量 只是用一次推荐使用下划线开头
class Player(
    _name: String,
    var age: Int, 
    var isNormal: Boolean //构造参数
) {

    //属性
    var name = _name
        get() = field.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
        set(value) {
            field = value.trim()
        }
   

}

fun main() {
    val p = Player("Jack", 20, true)
    p.name = "rose"
    println(p.name)
    println(p.age)
    println(p.isNormal)
}

Para java, es para reducir operaciones como this.age=age

bien conocido Puede escribir más de un constructor en Java. Cómo implementarlo con kotlin

Luego hablaremos del constructor secundario.

package set

import java.util.*
import kotlin.math.absoluteValue

//临时变量 只是用一次推荐使用下划线开头
class Player(
    _name: String, var age: Int, var isNormal: Boolean //构造参数
) {

    //属性
    var name = _name
        get() = field.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
        set(value) {
            field = value.trim()
        }

    //次构造函数
    constructor(name: String) : this(name, age = 20, isNormal = false) {
        //里面可以对代码进行操作
        this.name = name.uppercase(Locale.getDefault());
    }

}

fun main() {
    val p = Player("Jack", 20, true)
    p.name = "rose"
    println(p.name)
    println(p.age)
    println(p.isNormal)
    val p2 = Player("Jack Liu")
    println(p2.name)
}

El constructor secundario necesita llamar al constructor principal para inicializar y proporcionar valores predeterminados. 

parámetros predeterminados

De hecho, el escenario de uso del constructor secundario no se realiza en el constructor secundario. se puede escribir en el constructor

package set

import java.util.*
import kotlin.math.absoluteValue

//临时变量 只是用一次推荐使用下划线开头
class Player(
    _name: String, var age: Int=20, var isNormal: Boolean=false //构造参数
) {

    //属性
    var name = _name
        get() = field.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
        set(value) {
            field = value.trim()
        }

}

fun main() {
    val p = Player("Jack", 20, true)
    p.name = "rose"
    println(p.name)
    println(p.age)
    println(p.isNormal)
    val p2 = Player("Jack Liu")
    println(p2.name)
}

Aprenda el bloque de código de inicio a continuación

Había un bloque de código estático en Java antes

Se inicializa cuando la clase se carga en la máquina virtual

¿Cuándo se ejecuta el bloque de inicialización de init?

Se ejecuta cuando se reconstruye la función.

Podemos usarlo para verificar el valor pasado en

package set

import java.util.*
import kotlin.math.absoluteValue

//临时变量 只是用一次推荐使用下划线开头
class Player(
    _name: String, var age: Int = 20, var isNormal: Boolean = false //构造参数
) {

    //属性
    var name = _name
        get() = field.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
        set(value) {
            field = value.trim()
        }

    init {
        //检查是否
        require(age > 0) { "age 必须大于0" }
        require(name.isNotBlank()) { "姓名必须设置" }
    }
}

fun main() {
    val p = Player("Jack", 20, true)
    p.name = "rose"
    println(p.name)
    println(p.age)
    println(p.isNormal)
    val p2 = Player("Jack Liu")
    println(p2.name)
    val p3 = Player("Jack Liu", age = 0)
}

 ¿Cuál es el orden en el que hay muchos lugares donde se inicializan estos códigos?

Propiedades declaradas en el constructor principal.

Asignación de atributos a nivel de clase.

Asignaciones de propiedades y llamadas a funciones en bloques de inicialización init

Asignaciones de propiedades y llamadas a funciones en constructores secundarios