Kotlin como crear clases

Examinemos en este post como crear una clase en Kotlin

Como se crea una clase en Kotlin

Una clase especifica el detalle o prototipo que tendrá el objeto. A partir de ese prototipo se crea cada objeto.

En Kotlin una clase se crea esta forma.

class Person() {}

Agreguemos algunos atributos obligatorios que puede tener una persona, como el nombre, apellido, la fecha de nacimiento. En Kotlin puedes definir estos atributos directamente en el constructor primario .

Observa con cuidado que estas variables las defines directamente en el constructor y no es necesario definir estas variables en el cuerpo de la clase como lo harías en Java.
Kotlin se encarga de definir las variables y realizar la asignación de lo que recibe en el constructor hacia la variable.

class Person(var name: String, var surname: String, var birthDate: LocalDate) {}

Además de estos atributos obligatorios podríamos tener algunos otros no obligatorios. Supongamos el teléfono y la dirección.

Otra vez, observa que no es necesario definir set / get para cada variable que creamos.

class Person(var name: String, var surname: String, var birthDate: LocalDate) {
    var phone: String = ""
    var address: String = ""
}

Creamos un objeto en Kotlin

Ya tenemos definida nuestra clase Person con algunos atributos obligatorios y otros opcionales. Ahora, veamos cómo crear una instancia de esta clase y darle valores a sus variables.

val person = Person("Ken", "Thompson", LocalDate.of(1943, 2, 4))
person.phone = "22334455"
person.address = "Street 123"

..

Hagamos un print de los valores que tiene la clase.

fun main() {
    val person = Person("Ken", "Thompson", LocalDate.of(1943, 2, 4))
    person.phone = "22334455"
    person.address = "Street 123"
    // print 
    println("Person name=${person.name}, surname='${person.surname}', age=${person.birthDate}, phone='${person.phone}', address='${person.address}'")
}

Kotlin Class

Constructor primario y secundario

Hasta aquí definimos una clase con un constructor que recibe algunos parámetros que quisimos sean obligatorios al construir la clase.

Este primer constructor es el constructor primario . Al crear la instancia de la clase, nos vemos forzados a pasar los parámetros que pide.

Además del constructor primario, podemos crear otros constructores secundarios .

¿Cómo agregar un constructor secundario?

En Kotlin para definir un segundo constructor debes usar la palabra constructor en el cuerpo de la clase. Pasemos en este secondary constructor un nuevo argumento “passport”.

Observa que debes llamar al constructor primario desde el constructor secundario de forma explicita.

class Person(var name: String, var surname: String, var birthDate: LocalDate) {
    var phone: String = ""
    var address: String = ""
    var passport: String = ""

    constructor(name: String, surname: String, birthDate: LocalDate, passport: String) : this(name, surname, birthDate) {
        this.passport = passport
    }
}

Creamos otro objeto utilizando el constructor secundario.

fun main() {
    val person2 = Person("Dennis", "Ritchie", LocalDate.of(1941, 9, 9), "D12345B")
    // print person 2
    println("Person name=${person2.name}, surname='${person2.surname}', age=${person2.birthDate}, phone='${person2.phone}', address='${person2.address}', address='${person2.passport}'")
}

Kotlin Class

Bloques de inicialización

En los bloques de inicialización (init Block) asignamos valores a las variables o realizamos alguna operación. Ls bloques de inicialización siempre son llamados después de que se ejecuta el constructor primario. Podríamos tener más de un bloque de inicialización en una clase.

init {
    // some code
}

Agreguemos a nuestra clase Person un bloque de inicialización.

class Person(var name: String, var surname: String, var birthDate: LocalDate) {
    var phone: String = ""
    var address: String = ""
    var passport: String = ""

    init {
        println("This is Init Block")
        name = name.toUpperCase()
        surname = surname.toUpperCase()
    }

    constructor(name: String, surname: String, birthDate: LocalDate, passport: String) : this(name, surname, birthDate) {
        this.passport = passport
    }
}

Ejecutemos este código para observar la salida.

fun main() {
    val person = Person("Ken", "Thompson", LocalDate.of(1943, 2, 4))
    person.phone = "22334455"
    person.address = "Street 123"
    // print
    println("Person name=${person.name}, surname='${person.surname}', age=${person.birthDate}, " +
            "phone='${person.phone}', address='${person.address}'")

    val person2 = Person("Dennis", "Ritchie", LocalDate.of(1941, 9, 9), "D12345B")
    // print person 2
    println("Person name=${person2.name}, surname='${person2.surname}', age=${person2.birthDate}, " +
            "phone='${person2.phone}', address='${person2.address}', passport='${person2.passport}'")

}

Vemos que el bloque de inicialización ha aplicado toUpperCase tal como esperábamos luego del constructor primario.

Kotlin Class

Métodos en clases

Los métodos se crean con el keyword fun . Calculemos dentro de nuestra clase Person la edad, para que nos sirva como ejemplo.

class Person(var name: String, var surname: String, var birthDate: LocalDate) {
    var phone: String = ""
    var address: String = ""
    var passport: String = ""

    init {
        println("This is Init Block")
        name = name.toUpperCase()
        surname = surname.toUpperCase()
    }

    constructor(name: String, surname: String, birthDate: LocalDate, passport: String) : this(name, surname, birthDate) {
        this.passport = passport
    }

    fun age(): Int {
        return Period.between(birthDate, LocalDate.now()).years;
    }
}

Imprimiendo el resultado de esta función…

fun main() {
    val person = Person("Ken", "Thompson", LocalDate.of(1943, 2, 4))
    person.phone = "22334455"
    person.address = "Street 123"
    // print
    println("Person name=${person.name}, surname='${person.surname}', age=${person.birthDate}, " +
            "phone='${person.phone}', address='${person.address}'")

    val person2 = Person("Dennis", "Ritchie", LocalDate.of(1941, 9, 9), "D12345B")
    // print person 2
    println("Person name=${person2.name}, surname='${person2.surname}', age=${person2.birthDate}, " +
            "phone='${person2.phone}', address='${person2.address}', passport='${person2.passport}'")

    // print age 
    println("The age of ${person.name} is ${person.age()}")

}

Kotlin Class

Conclusión

Vimos en este artículo como crear una clase en Kotlin con un constructor primario y otro secundario. Entendimos lo que es un bloque de inicialización y agregamos una función dentro de la clase.

Kotlin