Skip to content

4. Clases, interfaces y data classes

4.1. Objetos mediante ejemplos

4.1.1. Descripción general

Exploraremos ahora la programación orientada a objetos mediante ejemplos. Un objeto es una entidad que contiene datos que definen su estado (denominados campos, atributos, propiedades, etc.) y funciones (denominadas métodos). Un objeto se crea a partir de una plantilla llamada clase. Por ejemplo, una clase llamada [C1] declara dos propiedades ([var p1: Type1] y [var p2: Type2]) y dos métodos ([fun m3(...): Type3 { ... }] y [fun m4(...): Type4 { ... }]), todos encerrados entre las llaves de la declaración [class C1 { ... }].

A partir de la clase [C1], podemos crear muchos objetos como [o1], [o2], … Todos tendrán las propiedades [p1], [p2], … y los métodos [m3], [m4], … Sin embargo, tendrán valores diferentes para sus propiedades [pi], por lo que cada uno tendrá su propio estado. Si [o1] es un objeto de tipo [C1], [o1.p1] hace referencia a la propiedad [p1] de [o1], y [o1.m3(...)] hace referencia a la llamada al método [m3] de [o1].

Consideremos un modelo de objetos inicial: la clase [Person].

4.1.2. Un programa compuesto por varios archivos

En los ejemplos del capítulo anterior, un programa cabía en un único archivo fuente. De ahora en adelante, un programa puede constar de varios archivos fuente: por ejemplo, una clase por archivo, más el programa principal. A diferencia de Java, Kotlin no exige ninguna relación entre el nombre de un archivo y las clases que contiene: un archivo puede contener varias clases y funciones de nivel superior. La convención, que seguiremos, es, no obstante, colocar una clase importante en un archivo que lleve su nombre: la clase *[Person] está en el archivo *[Person.kt].

Los programas de este capítulo están agrupados en el proyecto Gradle [04-classes], estructurado como el del capítulo anterior ([03-basics]): cada programa es un paquete dentro del directorio [src/main/kotlin]. El programa de varios archivos que vamos a estudiar es el paquete [persons]:

1
2
3
4
04-classes/src/main/kotlin/
  persons/
    Person.kt       the Person class
    Main.kt         the main program

Ambos archivos comienzan con la línea [package persons]: pertenecen al mismo paquete y pueden verse entre sí sin una instrucción de importación. El archivo [Main.kt] contiene la función de nivel superior [main]; el compilador la coloca en una clase JVM con el nombre del archivo, [MainKt], cuyo nombre completo es [persons.MainKt]. Este es el nombre que se proporciona a Gradle para ejecutar el programa:

> gradlew -q run -Pmain=persons.MainKt
[Jean, Dupont, 30]

Gradle compila todos los archivos del proyecto y luego ejecuta el método [main] de la clase especificada. En IntelliJ IDEA, basta con hacer clic en el triángulo verde que aparece en el margen, junto a la función [main]. El compilador escribe un archivo [.class] (que contiene el código intermedio, el “bytecode”, de la JVM) para cada clase: en este caso, [persons/Person.class] y [persons/MainKt.class], en la carpeta [build] del proyecto.

4.1.3. Definición de la clase Person

La definición de la clase [Person] en el archivo fuente [Person.kt] será la siguiente:

package persons

class Person {
    // propiedades privadas
    private var firstName = ""
    private var lastName = ""
    private var age = 0

    // método
    fun initialize(p: String, n: String, age: Int) {
        this.firstName = p
        this.lastName = n
        this.age = age
    }

    // método
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • línea 1: la clase pertenece al paquete [persons]. Los paquetes se tratan más adelante en este capítulo;
  • línea 3: la clase no está precedida por ninguna palabra clave de visibilidad; es pública y puede ser utilizada por todas las demás clases. En Kotlin, [public] es la visibilidad predeterminada;
  • Líneas 5–7: las tres propiedades de la clase. La palabra clave [var] indica que son mutables (la palabra clave [val] las haría de solo lectura). Kotlin exige que una propiedad sea inicializada (aquí con la cadena vacía y 0): a diferencia de Java, no existen valores predeterminados implícitos ([null], 0, [false]). Los tipos de las propiedades, [String] e [Int], se infieren a partir de estos valores iniciales, igual que con una variable local;
  • líneas 10–13: un método que establece el estado del objeto;
  • líneas 17–18: un método que muestra el estado del objeto.

Aquí tenemos la definición de una clase y, por lo tanto, de un tipo de datos. Cuando creamos variables de este tipo, nos referiremos a ellas como objetos o instancias de la clase. Una clase es, entonces, una plantilla a partir de la cual se construyen objetos. Por convención, el nombre de una clase comienza con mayúscula ([Person]), mientras que el nombre de una propiedad o de un método comienza con minúscula ([firstName], [initialize]).

Kotlin utiliza el término “propiedades” en lugar de “campos”: veremos un poco más adelante que una propiedad es un campo acompañado de sus métodos getter y setter, de forma similar a las propiedades de C#. Una propiedad privada, como la que se muestra aquí, es simplemente un campo. Los miembros de una clase pueden ser datos (propiedades) o métodos (funciones). Estos miembros pueden ir acompañados de una de las siguientes palabras clave:

Palabra clave
Acceso
[private]
Un miembro privado solo es accesible mediante los métodos de la propia clase
[protected]
Un miembro protegido es accesible mediante los métodos de la clase y los de sus clases derivadas (véase más adelante el concepto de herencia). A diferencia de Java, no es accesible desde otras clases del paquete
[internal]
Un miembro interno es accesible mediante cualquier método del mismo módulo, es decir, el conjunto de archivos que se compilan juntos (un proyecto o subproyecto de Gradle, un módulo de IntelliJ IDEA)
[public]
Un miembro público es accesible mediante cualquier método, esté o no definido dentro de la clase. Este es el nivel de acceso predeterminado cuando no se especifica ninguna palabra clave

En general, los datos de una clase se declaran privados, mientras que sus métodos son públicos. Esto significa que el usuario de un objeto (el programador):

  • no tendrá acceso directo a los datos privados del objeto;
  • puede llamar a los métodos públicos del objeto, incluidos los que dan acceso a sus datos privados.

El orden en que se declaran los miembros es arbitrario. Observe que el nivel de acceso predeterminado es público, a diferencia de Java, donde el predeterminado es el acceso de paquete (package-private): en Kotlin, hay que escribir explícitamente [private] para que un miembro sea privado. Kotlin no tiene acceso de “paquete”; el acceso [internal], a nivel de módulo, cumple esa función.

Las palabras clave [private], [internal] y [public] también se aplican a las declaraciones de nivel superior (clases, funciones y propiedades definidas fuera de cualquier clase). Una declaración de nivel superior [private] solo es visible dentro de su propio archivo.

4.1.4. El método initialize

¿Cuál es la función del método [initialize]? Como [lastName], [firstName] y [age] son miembros privados de la clase [Person], una instrucción como [p1.firstName = "Jean"], escrita en el programa principal, no es válida. El compilador la rechaza:

1
2
3
Main.kt:5:8: error: cannot access 'var firstName: String': it is private in 'persons.Person'.
    p1.firstName = "Jean"
       ^^^^^^^^^

El mensaje indica el archivo, la línea y la columna del error ([5:8]) y luego lo resalta con acentos circunflejos. En IntelliJ IDEA, el error aparece subrayado en rojo en cuanto se escribe, y Gradle muestra el mismo mensaje, precedido por [e:] y la ruta completa del archivo. El mensaje está en inglés: el compilador de Kotlin no ofrece traducciones al francés de sus mensajes. Debemos inicializar un objeto de tipo [Person] mediante un método público. Esa es la finalidad del método [initialize]. Escribiremos [p1.initialize("Jean", "Dupont", 30)]. Esta sintaxis es válida porque [initialize] es de acceso público.

4.1.5. Creación de un objeto: sin el operador new

Sin embargo, aún falta algo. Hay que crear el objeto. En el programa [Main.kt], la expresión [Person()] crea un objeto de tipo [Person]: la clase se “llama” como una función. Kotlin no tiene un operador new , a diferencia de Java y C#. El objeto creado aún no está inicializado: sus propiedades tienen sus valores predeterminados, que son la cadena vacía para [lastName] y [firstName], y 0 para [age].

La declaración [val p1 = Person()] declara [p1] como una referencia a este objeto. Si declaramos la variable sin inicializarla, [val p1: Person]***, y luego escribimos ***[p1.initialize("Jean", "Dupont", 30)]***, estamos llamando al método [initialize] sobre un objeto que no existe, y el compilador informa el error: a la variable [p1]* no se le ha asignado un valor.

1
2
3
Main.kt:5:5: error: variable 'p1' must be initialized.
    p1.initialize("Jean", "Dupont", 30)
    ^^

En Java, se puede escribir [Person p1 = null;] para indicar que la variable aún no referencia ningún objeto; la llamada [p1.initialize(...)] es aceptada por el compilador y provoca una excepción [NullPointerException] en tiempo de ejecución. Como vimos en el capítulo anterior, Kotlin distingue entre los tipos que admiten el valor [null] y los que no. El tipo [Person] no lo admite:

1
2
3
Main.kt:4:22: error: null cannot be a value of a non-null type 'Person'.
    val p1: Person = null
                     ^^^^

El tipo *[Person?]* sí lo admite, pero entonces el compilador rechaza una llamada directa a un método:

1
2
3
Main.kt:5:7: error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'Person?'.
    p1.initialize("Jean", "Dupont", 30)
      ^

Hay que escribir [p1?.initialize(...)], que llama al método solo si [p1] no es [null], o [p1!!.initialize(...)], que le indica al compilador que [p1] no es [null]. En este último caso, si la aserción es falsa, se lanza la excepción de Java en tiempo de ejecución:

1
2
3
4
> gradlew -q run -Pmain=persons.MainKt
Exception in thread "main" java.lang.NullPointerException
    at persons.MainKt.main(Main.kt:5)
    at persons.MainKt.main(Main.kt)

La mayoría de los errores que Java detecta en tiempo de ejecución son detectados así por el compilador de Kotlin. Para que [p1] referencie un objeto, escribimos [val p1 = Person()]. Ahora que [p1] hace referencia a un objeto, la instrucción de inicialización de ese objeto, [p1.initialize("Jean", "Dupont", 30)], es válida.

4.1.6. La palabra clave this

Veamos el código del método [initialize]:

1
2
3
4
5
    fun initialize(p: String, n: String, age: Int) {
        this.firstName = p
        this.lastName = n
        this.age = age
    }

La instrucción [this.firstName = p] significa que a la propiedad [firstName] del objeto actual ([this]) se le asigna el valor [p]. La palabra clave [this] se refiere al objeto actual: aquel sobre el que se ejecuta el método. ¿Cómo lo sabemos? Veamos cómo se inicializa el objeto referenciado por [p1] en el programa que lo llama: [p1.initialize("Jean", "Dupont", 30)]. Se llama al método [initialize] del objeto [p1] . Cuando, dentro de este método, se hace referencia al objeto [this], en realidad se hace referencia al objeto [p1].

Cuando un método de un objeto hace referencia a una propiedad [a] de ese objeto, la notación [this.a] está implícita: el método [initialize] podría haber escrito [firstName = p] y [lastName = n]. Se debe usar [this] de forma explícita cuando hay un conflicto de identificadores. Este es el caso de la instrucción [this.age = age] (línea 4), donde [age] se refiere tanto a una propiedad del objeto actual como al parámetro [age] que recibe el método. Dentro del método, el nombre [age] por sí solo se refiere al parámetro; la propiedad debe referenciarse como [this.age]. Observe que un parámetro de función es de solo lectura: la instrucción [age = 0] escrita dentro del método sería rechazada por el compilador.

4.1.7. Un programa de prueba

A continuación se muestra un programa de prueba breve. Está escrito en el archivo fuente [Main.kt]:

1
2
3
4
5
6
7
8
9
package persons

// el programa principal
fun main() {
    // un objeto Person
    val p1 = Person()
    p1.initialize("Jean", "Dupont", 30)
    p1.identify()
}
  • línea 4: la función [main] es el punto de entrada del programa. Como en el capítulo anterior, es una función de nivel superior, escrita fuera de cualquier clase;
  • línea 6: creación de un objeto [Person] referenciado por [p1]. Como la clase [Person] pertenece al mismo paquete, se reconoce sin necesidad de importarla. El tipo de [p1], [Person], es inferido por el compilador;
  • línea 7: inicialización del objeto;
  • línea 8: visualización de su estado.

Resultados:

> gradlew -q run -Pmain=persons.MainKt
[Jean, Dupont, 30]

4.1.8. Varias clases en un solo archivo

Para un ejemplo breve, un paquete con varios archivos resulta innecesariamente grande. Como en el capítulo anterior, escribiremos por lo tanto un único archivo ([Classes01.kt], por ejemplo) que contenga la función [main], posiblemente otras funciones y las clases que necesite el programa. Cada archivo se coloca en un paquete con su nombre ([classes01]), lo que permite que cada programa del proyecto tenga su propia clase [Person]: la clase [Person] del archivo [Classes01.kt] tiene el nombre completo [classes01.Person]; la clase del archivo [Classes02.kt] tiene el nombre completo [classes02.Person], y así sucesivamente. Se ejecuta mediante el comando [gradlew -q run -Pmain=classes01.Classes01Kt].

Es importante entender cómo procesa el compilador un archivo de este tipo. Las clases del archivo son clases ordinarias de nivel superior, exactamente como si estuvieran escritas en su propio archivo; las funciones de nivel superior, incluida [main], se agrupan en una clase con el nombre del archivo, [Classes01Kt]. La compilación del archivo lo demuestra:

1
2
3
4
> kotlinc src/main/kotlin/classes01/Classes01.kt -d classes
> ls classes/classes01
Classes01Kt.class
Person.class

Esto tiene una consecuencia que distingue a Kotlin de Java. En Java, las clases de un archivo fuente compacto están anidadas dentro de una clase implícita y comparten sus miembros privados con el método [main] del archivo. En Kotlin no existe una clase envolvente: un miembro [private] de una clase sigue siendo inaccesible para la función [main], aunque esté escrita en el mismo archivo. Por lo tanto, los ejemplos breves de este capítulo mostrarán los mismos errores de compilación que el programa [persons].

4.1.9. Otra forma de inicializar: la sobrecarga

Continuemos con la clase [Person] y agreguémosle un segundo método, [initialize]. El programa [Classes01.kt] es el siguiente:

// sobrecarga del método initialize
package classes01

fun main() {
    val p1 = Person()
    p1.initialize("Jean", "Dupont", 30)
    p1.identify()
    val p2 = Person()
    p2.initialize(p1)
    p2.identify()
}

// la clase Person se declara después de la función main
class Person {
    // propiedades privadas
    private var firstName = ""
    private var lastName = ""
    private var age = 0

    // inicialización a partir de tres valores
    fun initialize(p: String, n: String, age: Int) {
        firstName = p
        lastName = n
        this.age = age
    }

    // inicialización a partir de otra persona
    fun initialize(p: Person) {
        firstName = p.firstName
        lastName = p.lastName
        age = p.age
    }

    // identidad de la persona
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • línea 2: el paquete del programa;
  • líneas 4–10: el programa principal;
  • línea 14: la clase [Person] se declara después de la función [main]. En Kotlin, el orden de las declaraciones en un archivo no importa;
  • líneas 21–24: el método [initialize] del apartado anterior;
  • líneas 28–31: un segundo método [initialize].

Ahora tenemos dos métodos llamados [initialize]: esto es válido siempre que acepten parámetros diferentes (en número o tipo). Se dice que el método [initialize] está sobrecargado. El compilador elige qué método llamar según los parámetros reales: [p1.initialize("Jean", "Dupont", 30)] (línea 6) llama al primero, y [p2.initialize(p1)] (línea 9) llama al segundo. El tipo de retorno por sí solo no basta para distinguir dos métodos: dos métodos con el mismo nombre y los mismos parámetros que solo difieran en el tipo de retorno serían rechazados. Veremos que, en Kotlin, los valores predeterminados de los parámetros suelen eliminar la necesidad de escribir varias versiones del mismo método.

El parámetro del segundo método es una referencia ([p]) a una persona. Las propiedades de la persona ([p]) se asignan entonces al objeto actual ([this]). Observe que el método [initialize] tiene acceso directo a las propiedades del objeto [p] aunque sean privadas (líneas 29–31). Esto siempre es así: un método de una clase [C] tiene acceso a los miembros privados de todos los objetos de esa misma clase [C].

Resultados:

1
2
3
> gradlew -q run -Pmain=classes01.Classes01Kt
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Constructores de la clase Person

Un constructor es una función que se llama cuando se crea un objeto. Generalmente se utiliza para inicializar el objeto. Puede aceptar parámetros pero no devuelve ningún valor. Si una clase [C] tiene un constructor que acepta n parámetros, la creación de un objeto de esa clase se escribe [val obj = C(arg1, arg2, ... argn)].

Cuando una clase [C] tiene uno o más constructores, se debe usar uno de ellos para crear un objeto de esa clase. Si una clase [C] no declara ningún constructor, tiene un constructor predeterminado sin parámetros que no hace nada. Las propiedades del objeto conservan entonces sus valores iniciales. Esto fue lo que ocurrió en los programas anteriores, donde escribimos [Person()].

Kotlin distingue dos tipos de constructores:

  • el constructor primario, como máximo uno por clase, declarado en el encabezado de la clase inmediatamente después del nombre de la clase: [class Person(firstName: String, lastName: String, age: Int)];
  • los constructores secundarios, declarados en el cuerpo de la clase con la palabra clave [constructor]. Cuando una clase tiene un constructor primario, todo constructor secundario debe llamarlo, ya sea directamente o a través de otro constructor secundario.

El programa [Classes02.kt] proporciona tres constructores para la clase [Person]:

// constructores de la clase Person
package classes02

fun main() {
    val p1 = Person("Jean", "Dupont", 30)
    p1.identify()
    val p2 = Person(p1)
    p2.identify()
    val p3 = Person()
    p3.identify()
}

// el constructor primario se declara en el encabezado de la clase:
// sus parámetros precedidos por val (o var) también son propiedades de la clase
class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // constructor secundario de copia: llama al constructor primario
    constructor(p: Person) : this(p.firstName, p.lastName, p.age)

    // constructor secundario sin parámetros: también llama al constructor primario
    constructor() : this("?", "?", 0)

    // identidad de la persona
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • Línea 15: el constructor primario. Sus tres parámetros están precedidos por [private val]: es una notación abreviada que declara a la vez un parámetro del constructor y una propiedad privada de solo lectura con el mismo nombre, inicializada con el valor del parámetro. La clase no tiene otras propiedades: estas se declaran en el encabezado;
  • Línea 17: el constructor secundario de copia. La notación [: this(p.firstName, p.lastName, p.age)] llama al constructor de la misma clase que acepta tres parámetros: [String], [String] e [Int], en este caso, el constructor primario. Esto se conoce como constructores encadenados. Como resultado, el código de inicialización se escribe una sola vez. Este constructor no tiene cuerpo: no tiene nada más que hacer;
  • línea 20: el constructor secundario sin parámetros, también encadenado al constructor primario. Como la clase ha declarado un constructor primario con parámetros, ya no tiene un constructor predeterminado: si queremos poder escribir [Person()], debemos declararlo;
  • Líneas 4–10: se utilizan los tres constructores.

La notación abreviada de la línea 15 equivale a la siguiente notación, más larga, en la que los parámetros del constructor primario (sin *[val]*) son simplemente parámetros que se utilizan para inicializar propiedades declaradas en el cuerpo de la clase:

1
2
3
4
5
6
7
class Person(firstName: String, lastName: String, age: Int) {
    // propiedades inicializadas con los parámetros del constructor primario
    private val firstName: String = firstName
    private val lastName: String = lastName
    private val age: Int = age
    ...
}

Esto es mucho más corto que la versión en Java, donde hay que declarar los campos y luego inicializarlos uno por uno en el constructor ([this.firstName = firstName;]…). El constructor primario no tiene cuerpo: las instrucciones que se deben ejecutar cuando se construye el objeto se colocan en bloques [init], que veremos un poco más adelante. También veremos que, gracias a los valores predeterminados de los parámetros, Kotlin a menudo no necesita constructores secundarios: [class Person(..., private val age: Int = 0)] permite escribir tanto [Person("Jean", "Dupont", 30)] como [Person("Jean", "Dupont")].

Resultados:

1
2
3
4
> gradlew -q run -Pmain=classes02.Classes02Kt
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. Referencias a objetos

Utilizamos la clase [Person] del programa anterior, omitiendo su constructor sin parámetros pero incluyendo el método [initialize(String, String, Int)] del comienzo del capítulo. Por lo tanto, sus propiedades se declaran con [var] en lugar de [val]. El programa de prueba pasa a ser el siguiente [Classes03.kt]:

// referencias de objetos
package classes03

fun main() {
    // p1
    val p1 = Person("Jean", "Dupont", 30)
    print("p1="); p1.identify()
    // p2 referencia el mismo objeto que p1
    val p2 = p1
    print("p2="); p2.identify()
    // p3 referencia un objeto que es una copia del objeto referenciado por p1
    val p3 = Person(p1)
    print("p3="); p3.identify()
    // cambiamos el estado del objeto referenciado por p1
    p1.initialize("Micheline", "Benoît", 67)
    print("p1="); p1.identify()
    // como p2 = p1, el objeto referenciado por p2 cambió de estado
    print("p2="); p2.identify()
    // p3 no referencia el mismo objeto que p1: el objeto referenciado por p3 no cambió
    print("p3="); p3.identify()
    // ¿p1 y p2 son la misma referencia? ¿y p1 y p3?
    println("p1 === p2 : ${p1 === p2}, p1 === p3 : ${p1 === p3}")
}

class Person(private var firstName: String, private var lastName: String, private var age: Int) {
    // constructor secundario de copia
    constructor(p: Person) : this(p.firstName, p.lastName, p.age)

    // inicialización
    fun initialize(p: String, n: String, age: Int) {
        firstName = p
        lastName = n
        this.age = age
    }

    // identidad de la persona
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}

La función [print] (líneas 7, 10, …) escribe su parámetro sin iniciar una nueva línea. Las dos instrucciones de esas líneas están separadas por un punto y coma, que en Kotlin solo es necesario para escribir varias instrucciones en una misma línea. Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=classes03.Classes03Kt
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 === p2 : true, p1 === p3 : false

Cuando la variable [p1] se declara mediante [val p1 = Person("Jean", "Dupont", 30)] (línea 6), [p1] referencia el objeto [Person("Jean", "Dupont", 30)] pero no es el objeto en sí. En C, esto se llamaría un puntero, es decir, la dirección del objeto creado. Si [p1] se declarara como [var p1: Person? = ...] y luego escribiéramos [p1 = null], no se modificaría el objeto [Person("Jean", "Dupont", 30)] , sino la referencia [p1] , que cambiaría su valor. El objeto se “perdería” si ninguna otra variable lo referenciara: la memoria que ocupa sería recuperada posteriormente por el recolector de basura de la máquina virtual de Java, que ejecuta los programas Kotlin igual que los programas Java.

Cuando escribimos [val p2 = p1] (línea 9), inicializamos la referencia [p2]: esta “apunta” al mismo objeto (hace referencia al mismo objeto) que la referencia [p1]. Así, si se modifica el objeto “apuntado” (o referenciado) por [p1], también se modifica el referenciado por [p2] (líneas 4–5 de los resultados). Observe que [p1] y [p2] se declaran con [val]: la palabra clave impide cambiar la referencia contenida en la variable, no modificar el objeto referenciado, que es lo que hace la llamada a [p1.initialize(...)] (línea 15).

Cuando se escribe [val p3 = Person(p1)] (línea 12), se crea un nuevo objeto [Person]. Este nuevo objeto será referenciado por [p3]. Si se modifica el objeto referenciado por [p1], esto no afecta al objeto referenciado por [p3] (línea 6 de los resultados).

Finalmente, en la línea 22, el operador [===], aplicado a dos referencias a objetos, indica si hacen referencia al mismo objeto: [p1] y [p2] hacen referencia al mismo objeto, mientras que [p1] y [p3] hacen referencia a dos objetos diferentes, aunque tengan el mismo contenido (línea 7 de los resultados). Este es el operador [] de Java. En Kotlin, el operador [] compara el contenido de los objetos llamando a su método [equals]: veremos más adelante cómo definirlo. Para una clase que no define [equals], como en este caso, [p1 == p3] sigue comparando las referencias y se evalúa como [false].

4.1.12. Paso de referencias a objetos como parámetros

En el capítulo anterior vimos que Kotlin, como Java, pasa los parámetros de las funciones por valor: la función recibe una copia del valor del parámetro real. Veamos qué significa esto cuando el parámetro es una referencia a un objeto. Para ello, usaremos la clase [StringBuilder] (la clase del JDK, que Kotlin utiliza directamente). Un objeto [String] no se puede modificar: una operación como [s.uppercase()] devuelve un nuevo [String] como resultado. En cambio, un objeto [StringBuilder] es una cadena mutable: su método [append] agrega caracteres a la cadena sin crear un nuevo objeto.

En Java, el ejemplo asignaba un nuevo objeto al parámetro [sbf1] de la función llamada. Esto no es posible en Kotlin: un parámetro de función es de solo lectura, igual que una variable [val]. El compilador rechaza la instrucción [sbf1 = StringBuilder("test1*****")]:

1
2
3
Classes04.kt:5:5: error: 'val' cannot be reassigned.
    sbf1 = StringBuilder("test1*****")
    ^^^^

Por lo tanto, el programa [Classes04.kt] copia el parámetro [sbf1] en una variable local modificable:

// paso de parámetros de tipo referencia a objeto
package classes04

fun main() {
    val sb0 = StringBuilder("test0")
    val sb1 = StringBuilder("test1")
    println("In calling function before the call: sb0=$sb0, sb1=$sb1")
    val sb2 = changeStringBuilder(sb0, sb1)
    println("In calling function after the call: sb0=$sb0, sb1=$sb1, sb2=$sb2")
}

// la función llamada
fun changeStringBuilder(sbf0: StringBuilder, sbf1: StringBuilder): StringBuilder {
    println("Start of called function: sbf0=$sbf0, sbf1=$sbf1")
    // modificamos el objeto referenciado por sbf0
    sbf0.append("*****")
    // un parámetro es de solo lectura: sbf1 = StringBuilder(...) sería rechazado.
    // La variable local sbl primero referencia el mismo objeto que sbf1, luego un nuevo objeto
    var sbl = sbf1
    sbl = StringBuilder("test1*****")
    // se devuelve un nuevo objeto al llamador
    val sbf2 = StringBuilder("test2*****")
    println("End of called function: sbf0=$sbf0, sbf1=$sbf1, sbl=$sbl, sbf2=$sbf2")
    return sbf2
}
  • Líneas 5–6: dos referencias, [sb0] y [sb1], a objetos de tipo [StringBuilder];
  • línea 8: estas se pasan a la función [changeStringBuilder], cuyo resultado (una tercera referencia) se asigna a [sb2];
  • líneas 13–24: una función de nivel superior, que tiene los parámetros formales [sbf0] y [sbf1]. Cuando la función se inicia, [sbf0] y [sb0] son dos referencias distintas que apuntan al mismo objeto: la referencia [sb0] se copió en [sbf0] (las referencias se pasan por valor). Lo mismo se aplica a [sbf1] y [sb1];
  • líneas 19–20: la variable local [sbl] recibe primero la referencia [sbf1] y luego la referencia a un nuevo objeto. Esto es lo que hacía el programa en Java con el propio parámetro [sbf1] .

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=classes04.Classes04Kt
In calling function before the call: sb0=test0, sb1=test1
Start of called function: sbf0=test0, sbf1=test1
End of called function: sbf0=test0*****, sbf1=test1, sbl=test1*****, sbf2=test2*****
In calling function after the call: sb0=test0*****, sb1=test1, sb2=test2*****

Explicaciones:

  • [sb0] y [sbf0] son dos referencias distintas al mismo objeto. Este objeto fue modificado mediante [sbf0] (línea 16). Esta modificación es visible mediante [sb0] (línea 4 de los resultados);
  • [sb1], [sbf1] y, inicialmente, [sbl] son tres referencias distintas al mismo objeto. A [sbl] se le asigna un nuevo valor y ahora apunta a un nuevo objeto (línea 20). Esto no cambia el valor de [sbf1] ni el de [sb1], que siguen apuntando al objeto original, sin modificar (líneas 3 y 4 de los resultados);
  • por lo tanto, una función de Kotlin no puede cambiar el valor de una variable que pertenece a quien la llama. Para pasar un nuevo objeto a quien la llama, lo devuelve como resultado (líneas 22 y 24). Cuando hay varios resultados, se agrupan en un objeto: un par ([Pair]), como vimos en el capítulo anterior, o una clase de datos (véase más adelante).

Recuerde que una función puede modificar el objeto referenciado por un parámetro, pero no la variable de quien la llama que contiene la referencia. Como Java, y a diferencia de C#, Kotlin no pasa parámetros por referencia; va un paso más allá que Java al prohibir cualquier asignación a un parámetro, lo que evita la confusión entre el parámetro y la variable de quien llama.

4.1.13. Objetos temporales

En una expresión, se puede llamar explícitamente al constructor de un objeto: el objeto se crea, pero no hay ninguna variable para acceder a él posteriormente (para modificarlo, por ejemplo). Este objeto temporal se crea para evaluar la expresión y luego se descarta. El espacio de memoria que ocupaba será recuperado automáticamente más adelante por el recolector de basura, cuya función es recuperar el espacio de memoria ocupado por los objetos que ya no están referenciados por los datos del programa.

Consideremos el siguiente programa, [Classes05.kt], en el que los constructores de la clase [Person] muestran un mensaje. Es una oportunidad para presentar el bloque de inicialización [init]:

// objetos temporales
package classes05

fun main() {
    Person(Person("Jean", "Dupont", 30)).identify()
}

class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // el bloque init es ejecutado por el constructor primario
    init {
        println("Constructor Person(String, String, Int)")
    }

    // el constructor secundario primero llama al constructor primario, luego ejecuta su cuerpo
    constructor(p: Person) : this(p.firstName, p.lastName, p.age) {
        println("Constructor Person(Person)")
    }

    // identidad de la persona
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • línea 5: el objeto [Person("Jean", "Dupont", 30)] se construye y luego se pasa al constructor de copia, que construye un segundo objeto; a continuación se llama al método [identify] sobre ese objeto. Ninguno de los dos objetos está referenciado por una variable;
  • líneas 9–11: como el constructor primario no tiene cuerpo, las instrucciones que se deben ejecutar cuando se construye el objeto se colocan en un bloque [init]. Una clase puede tener varios bloques [init]: estos se ejecutan, junto con las inicializaciones de las propiedades declaradas en el cuerpo de la clase, en el orden en que están escritos. Forman parte del constructor primario y tienen acceso a sus parámetros;
  • líneas 15–16: un constructor secundario puede tener cuerpo. Se ejecuta después del constructor llamado por [: this(...)], en este caso, el constructor primario con sus bloques [init].

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=classes05.Classes05Kt
Constructor Person(String, String, Int)
Constructor Person(String, String, Int)
Constructor Person(Person)
[Jean, Dupont, 30]

Los resultados muestran la construcción secuencial de los dos objetos temporales. El primero lo construye el constructor primario (línea 1 de los resultados). El segundo lo construye el constructor secundario, que comienza llamando al constructor primario (de ahí la ejecución del bloque [init], línea 2) y luego ejecuta su propio cuerpo (línea 3). En Java, el constructor de copia del ejemplo no estaba encadenado al constructor primario y mostraba únicamente su propio mensaje; en Kotlin, mientras una clase tenga un constructor primario, todo objeto pasa por él: los bloques [init] siempre se ejecutan.

4.1.14. Propiedades: métodos getter y setter

En Java, la convención es declarar campos privados y dar acceso a sus valores mediante métodos públicos: getters, como [getAge()], y setters, como [setAge(int)]. Estos métodos se escriben a mano (o los genera el entorno de desarrollo), y el usuario de la clase escribe [p.setAge(p.getAge() + 1)]. Kotlin, como C#, tiene propiedades: una propiedad pública es un dato que el usuario lee y escribe con la notación de punto, como un campo, pero que en realidad se lee y se escribe a través de un getter y un setter. El compilador los genera. El programa [Classes06.kt] lo demuestra:

// propiedades en lugar de getters y setters
package classes06

fun main() {
    val p = Person("Jean", "Michelin", 34)
    // lectura de las propiedades: llamada implícita a su getter
    println("p=(${p.firstName},${p.lastName},${p.age})")
    // escritura de una propiedad: llamada implícita a su setter
    p.age = 56
    println("p=(${p.firstName},${p.lastName},${p.age})")
}

// tres propiedades públicas de lectura y escritura
class Person(var firstName: String, var lastName: String, var age: Int)
  • línea 14: la clase *[Person]* cabe en una sola línea. Los tres parámetros del constructor primario están precedidos por *[var]*: son tres propiedades públicas (visibilidad predeterminada), que se pueden leer y escribir. Como la clase no tiene cuerpo, se omiten las llaves;
  • línea 7: lectura de las propiedades [p.firstName], [p.lastName] y [p.age]. Cada operación de lectura es una llamada al descriptor de acceso de la propiedad;
  • Línea 9: escritura de la propiedad [age], es decir, llamada a su setter.

Resultados:

1
2
3
> gradlew -q run -Pmain=classes06.Classes06Kt
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

La herramienta [javap] del JDK, que muestra el contenido de un archivo [.class], muestra lo que el compilador de Kotlin generó para la clase [Person] (la opción [-p] también muestra los miembros privados):

> javap -p -cp build/classes/kotlin/main classes06.Person
Compiled from "Classes06.kt"
public final class classes06.Person {
  private java.lang.String firstName;
  private java.lang.String lastName;
  private int age;
  public classes06.Person(java.lang.String, java.lang.String, int);
  public final java.lang.String getFirstName();
  public final void setFirstName(java.lang.String);
  public final java.lang.String getLastName();
  public final void setLastName(java.lang.String);
  public final int getAge();
  public final void setAge(int);
}

Cada propiedad dio lugar a un campo privado (líneas 3–5), un getter público y un setter público (líneas 7–12), que siguen la convención de nomenclatura establecida en los primeros días de Java, a saber, “JavaBeans”: el getter de la propiedad [age] se llama [getAge], y su setter es [setAge]; una propiedad booleana cuyo nombre comienza con [is], como [isActive], tiene un getter con el mismo nombre, [isActive], y un setter llamado [setActive]. Esto es importante: muchas bibliotecas de Java (como Jackson para JSON e Hibernate para bases de datos, que usaremos más adelante) se basan en esta convención para localizar los datos de un objeto; pueden encontrar los datos de los objetos de Kotlin sin ninguna dificultad. A la inversa, un programa Kotlin que utiliza una clase de Java escribe [p.age] para llamar a [p.getAge()], y [p.age = 56] para llamar a [p.setAge(56)]. También observamos que la clase y sus métodos son [final]: veremos con la herencia que, en Kotlin, las clases y los métodos son final de manera predeterminada.

La notación [p.age = 56] se parece a la asignación de un campo público. La diferencia es significativa: como utiliza un setter, podemos, sin cambiar nada en el código escrito por los usuarios de la clase, asignar más adelante a la propiedad un setter que controle los valores que recibe. Este es el tema de la siguiente sección. Por lo tanto, en Kotlin nunca escribimos getters ni setters al estilo de Java: declaramos propiedades.

4.1.15. Setters que validan los valores recibidos

La ventaja de los setters sobre los campos públicos es la posibilidad de controlar los valores asignados a los campos: un setter puede validar el valor recibido y lanzar una excepción si no es válido. Kotlin permite dotar a una propiedad de un getter personalizado ([get]) y de un setter personalizado ([set]). Consideremos el programa [Classes07.kt]:

// setters que verifican la validez de los valores recibidos
package classes07

fun main() {
    val p = Person("Jean", "Michelin", 34)
    println("p=(${p.firstName},${p.lastName},${p.age})")
    p.age = 56
    println("p=(${p.firstName},${p.lastName},${p.age})")
    try {
        p.age = -4
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    // constructor sin parámetros y luego asignación de las propiedades
    val p2 = Person()
    p2.age = 7
    p2.firstName = "Arthur"
    p2.lastName = "Martin"
    println("p2=(${p2.firstName},${p2.lastName},${p2.age})")
    try {
        val p3 = Person()
        p3.firstName = "Paul"
        p3.lastName = " "
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    // el constructor también verifica los valores recibidos
    try {
        val p4 = Person("", "Durand", 20)
        println("p4=(${p4.firstName},${p4.lastName},${p4.age})")
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
}

// la clase tiene un constructor primario sin parámetros
class Person() {
    // propiedades con un setter personalizado (set)
    var firstName = ""
        set(value) {
            // ¿nombre válido?
            require(value.isNotBlank()) { "invalid first name ($value)" }
            // field designa el campo de respaldo que almacena el valor de la propiedad
            field = value
        }

    var lastName = ""
        set(value) {
            // ¿apellido válido?
            require(value.isNotBlank()) { "invalid last name ($value)" }
            field = value
        }

    var age = 0
        set(value) {
            // ¿edad válida?
            require(value >= 0) { "invalid age ($value)" }
            field = value
        }

    // constructor secundario: pasa por los setters para beneficiarse de sus verificaciones
    constructor(firstName: String, lastName: String, age: Int) : this() {
        this.firstName = firstName
        this.lastName = lastName
        this.age = age
    }
}

Las tres propiedades tienen un setter personalizado que valida el valor recibido:

  • líneas 39–44: la propiedad [firstName]. Su declaración va seguida, en las líneas siguientes, de la definición de su setter, [set(value) { ... }]. El parámetro [value] es el valor asignado a la propiedad (el nombre [value] es convencional, como en C#); su tipo es el de la propiedad. La propiedad no tiene un descriptor de acceso personalizado: conserva el generado, que devuelve el valor almacenado;
  • Línea 42: la función [require(condition) { message }], tratada en el capítulo anterior, lanza una excepción [IllegalArgumentException] (la excepción diseñada para señalar un parámetro no válido) si la condición es falsa. El mensaje, calculado por la expresión lambda entre llaves, se construye solo en ese caso. La función [isNotBlank] devuelve [true] si la cadena contiene al menos un carácter distinto de un espacio. No es necesario probar el valor [null] como en Java: la propiedad es de tipo [String], no [String?], y el compilador prohíbe asignarle [null];
  • Línea 44: en un getter o un setter, la palabra clave [field] hace referencia al campo que almacena el valor de la propiedad (conocido como “campo de respaldo”). No escriba [firstName = value]: sería una llamada al propio setter, que se llamaría a sí mismo indefinidamente;
  • líneas 47–58: las propiedades [lastName] y [age] se construyen con el mismo patrón;
  • línea 37: la clase tiene un constructor primario sin parámetros. Los valores iniciales de las propiedades ([""] y 0) se asignan directamente a los campos, sin pasar por los setters;
  • Líneas 62–65: un constructor secundario que inicializa el objeto mediante los setters. Esto le permite aprovechar las verificaciones realizadas por los setters, que se escriben una sola vez. Aquí, [this.firstName = firstName] es la llamada al setter de la propiedad [firstName] con el valor del parámetro [firstName].

¿Por qué no escribir [class Person(firstName: String, lastName: String, age: Int)] con propiedades inicializadas mediante [var age = age]? Porque inicializar una propiedad en su declaración afecta directamente al campo sin llamar al setter: una edad de -4 sería aceptada sin error. Para verificar los valores recibidos por el constructor primario, escribimos las verificaciones en un bloque [init] o, como se muestra aquí, pasamos los valores a través de los setters.

En Java, los setters llamados por el constructor debían declararse como [final]: de lo contrario, una clase derivada podía redefinirlos, y el constructor de la clase padre habría llamado a la nueva versión incluso antes de que se ejecutara el constructor de la clase derivada. En Kotlin, las clases y sus miembros son final de manera predeterminada: esta precaución es innecesaria.

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=classes07.Classes07Kt
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
invalid age (-4)
p2=(Arthur,Martin,7)
invalid last name ( )
invalid first name ()

La línea 3 de los resultados muestra que la asignación [p.age = -4] (línea 10) fue rechazada por el setter: [ex.message] es el mensaje de la excepción. Líneas 15–18: se crea un objeto mediante el constructor sin parámetros y luego se inicializa mediante sus setters. Líneas 21–23: el nombre que contiene un espacio es rechazado (línea 5 de los resultados). Líneas 29–30: el constructor de tres parámetros rechaza un nombre vacío (línea 6 de los resultados).

Java no tiene inicializadores de objetos, una sintaxis que permitiría establecer varias propiedades dentro de la propia expresión de creación del objeto. Kotlin tampoco, pero ofrece dos soluciones equivalentes: los parámetros del constructor con nombre y con valores predeterminados, y la función [apply]. Las trataremos en los dos párrafos siguientes.

4.1.16. Propiedades de solo lectura y parámetros opcionales

Una propiedad declarada con [val] debe recibir un valor exactamente una vez (en el momento de su declaración, en el constructor primario o dentro de un bloque [init]) y no puede modificarse después. El compilador lo exige. Esto equivale al campo [final] de Java: la propiedad solo tiene un getter, sin setter. El programa [Classes08.kt] ilustra varios casos, así como los parámetros predeterminados y los argumentos con nombre:

// propiedades de solo lectura, setter privado, propiedad calculada,
// parámetros obligatorios y opcionales, argumentos con nombre
package classes08

fun main() {
    val p = Person("Jean", "Dupont", 30, "Angers")
    println(p.identity)
    // el nombre se lee / escribe
    p.firstName = "Jacques"
    // la edad solo puede modificarse dentro de la clase
    p.growOlder()
    println(p.identity)
    // el compilador rechaza las líneas siguientes
    // p.lastName = "Durand" // lastName es una propiedad val
    // p.age = 40            // el setter de age es privado
    // p.identity = "?"      // identity es una propiedad (calculada) val

    // un parámetro obligatorio y un parámetro opcional
    val c1 = Contact("jean.dupont@example.com")
    println("Contact : ${c1.email}, ${c1.phone}")
    // argumentos con nombre, en cualquier orden
    val c2 = Contact(phone = "02 41 00 00 00", email = "paul.martin@example.com")
    println("Contact : ${c2.email}, ${c2.phone}")
    // el compilador rechaza Contact(null); un correo electrónico vacío se rechaza en tiempo de ejecución
    try {
        val c3 = Contact(" ")
        println("Contact : ${c3.email}")
    } catch (ex: IllegalArgumentException) {
        println("Error: ${ex.message}")
    }
}

class Person(var firstName: String, val lastName: String, age: Int, val city: String) {
    // todos pueden leer la edad, pero su setter es privado
    var age = age
        private set

    // una propiedad calculada: no tiene campo de respaldo, su getter calcula su valor
    val identity: String
        get() = "[$firstName, $lastName, $age, $city]"

    // la edad solo la modifican los métodos de la clase
    fun growOlder() {
        age++
    }
}

// el correo electrónico es obligatorio, el teléfono opcional: su parámetro tiene un valor por defecto
class Contact(val email: String, val phone: String = "unknown") {
    // verificación ejecutada cuando se construye el objeto
    init {
        require(email.isNotBlank()) { "the email is mandatory" }
    }
}
  • línea 33: el nombre es una propiedad [var], de lectura y escritura; el apellido y la ciudad son propiedades [val], de solo lectura. El constructor les asigna un valor, que no se puede cambiar después. El parámetro [age], sin [val] ni [var], es simplemente un parámetro del constructor;
  • líneas 35–36: la propiedad [age] se inicializa con el parámetro [age]. Es legible por todos, pero su setter es privado ([private set]): solo puede ser modificada por los métodos de la clase, como [growOlder] (líneas 43–44). El setter conserva su comportamiento predeterminado: no requiere cuerpo;
  • líneas 39–40: una propiedad calculada. Tiene un descriptor de acceso personalizado, [get() = ...], que calcula su valor cada vez que se lee a partir de las demás propiedades; no tiene un campo donde almacenar un valor. Para el usuario de la clase, nada la distingue de otra propiedad: [p.identity] (línea 7). Esto equivale al método [getIdentity()] de la versión en Java;
  • líneas 14–16: tres instrucciones que el compilador rechaza, por las razones indicadas en los comentarios. Si las descomentamos, el compilador informa lo siguiente (también hemos descomentado la instrucción [Contact(null)] mencionada en la línea 24):
Classes08.kt:14:7: error: 'val' cannot be reassigned.
    p.lastName = "Durand" // lastName is a val property
      ^^^^^^^^
Classes08.kt:15:7: error: cannot access 'age': it is private in 'classes08.Person'.
    p.age = 40            // the setter of age is private
      ^^^
Classes08.kt:16:7: error: 'val' cannot be reassigned.
    p.identity = "?"      // identity is a val (computed) property
      ^^^^^^^^
Classes08.kt:24:13: error: null cannot be a value of a non-null type 'String'.
    Contact(null)
            ^^^^
  • línea 49: la clase [Contact] tiene una propiedad obligatoria, email, y una propiedad opcional, phone. El carácter opcional de la propiedad phone se expresa mediante un valor predeterminado para el parámetro [phone] del constructor: [val phone: String = "unknown"]. Si se omite el argumento, como en la línea 19, el parámetro toma este valor. En Java, que no tiene parámetros opcionales, se requería un segundo constructor, encadenado al primero; en Kotlin basta un solo constructor. Los valores predeterminados se usan de la misma manera para los parámetros de cualquier función;
  • línea 22: los argumentos tienen nombre: [phone = "02 41 00 00 00"]. Se pueden proporcionar entonces en cualquier orden, y la llamada es más legible cuando varios parámetros tienen el mismo tipo. Los argumentos con nombre también permiten omitir un solo parámetro opcional entre varios: con [f(a: Int = 0, b: Int = 0)], se puede escribir [f(b = 5)];
  • Líneas 51–52: el carácter obligatorio del correo electrónico se expresa primero mediante el tipo del parámetro: [String] no acepta el valor [null], y la llamada [Contact(null)] se rechaza en tiempo de compilación (último error anterior). En Java, esto debía verificarse en tiempo de ejecución ([Objects.requireNonNull]). El siguiente paso es rechazar una dirección de correo vacía: esa es la función del bloque [init], que se ejecuta cuando se construye el objeto. En la línea 26, una dirección de correo formada por un solo espacio es rechazada.

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=classes08.Classes08Kt
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact : jean.dupont@example.com, unknown
Contact : paul.martin@example.com, 02 41 00 00 00
Error: the email is mandatory

Observe lo cortas que son las declaraciones: la clase [Person], que ocupaba unas cincuenta líneas en Java con sus getters, setters y validaciones, ocupa solo unas quince líneas en Kotlin.

4.1.17. Las funciones apply y also en lugar de mutadores encadenados

En Java, cuando un objeto tiene muchos campos opcionales, el número de constructores aumenta y las llamadas a setters se vuelven más largas. Una técnica común es hacer que cada setter devuelva el objeto actual ([this]): las llamadas pueden entonces encadenarse, lo que se denomina métodos “encadenados”: [new Person().setFirstName("jean").setLastName("Dupont").setAge(30)]. En Kotlin, los parámetros predeterminados y los argumentos con nombre hacen que esta técnica sea mucho menos útil. Y cuando se quieren establecer varias propiedades de un objeto inmediatamente después de su creación, la biblioteca estándar ofrece “funciones de alcance” (scope functions) que se pueden usar con cualquier objeto, entre ellas [apply] y [also]. El programa [Classes09.kt] las ilustra y, de paso, presenta las propiedades [lateinit]:

// en lugar de setters "fluidos": las funciones de alcance apply y also
// una propiedad lateinit
package classes09

fun main() {
    // apply ejecuta el bloque con el objeto como objeto actual (this), luego devuelve el objeto
    val p = Person().apply {
        firstName = "  jean "
        lastName = "Dupont"
        age = 30
    }
    println(p.identity)
    try {
        p.lastName = ""
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    try {
        p.age = -4
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    println(p.identity)
    // also ejecuta el bloque con el objeto como parámetro (it), luego devuelve el objeto
    val p2 = Person().apply { firstName = "Arthur"; lastName = "Martin"; age = 7 }
        .also { println("Creation of ${it.identity}") }
    // lectura de una propiedad lateinit que aún no ha recibido un valor
    try {
        println(p2.city)
    } catch (ex: UninitializedPropertyAccessException) {
        println(ex.message)
    }
    p2.city = "Angers"
    println("${p2.identity} lives in ${p2.city}")
}

class Person {
    // propiedades verificadas por su setter
    var firstName = ""
        set(value) {
            field = validate(value, "first name")
        }

    var lastName = ""
        set(value) {
            field = validate(value, "last name")
        }

    var age = 0
        set(value) {
            require(value >= 0) { "invalid age ($value)" }
            field = value
        }

    // una propiedad sin valor inicial: recibirá su valor más adelante
    lateinit var city: String

    // identity: el tipo de la propiedad se infiere a partir de su getter
    val identity get() = "[$firstName, $lastName, $age]"
}

// verificación de una cadena obligatoria: se devuelve sin espacios iniciales ni finales
// (función privada de nivel superior: solo es visible en este archivo)
private fun validate(value: String, label: String): String {
    require(value.isNotBlank()) { "invalid $label ($value)" }
    return value.trim()
}
  • líneas 7–10: [obj.apply { ... }] ejecuta el bloque entre llaves con [obj] como objeto actual: dentro del bloque, [firstName = " jean "] equivale a [this.firstName = " jean "], donde [this] es la nueva persona. Luego [apply] devuelve el propio objeto, que se asigna a [p]. La asignación actúa como un inicializador de objeto; cada asignación pasa por el setter de la propiedad y, por lo tanto, por sus validaciones;
  • líneas 39–46: los setters del nombre y del apellido asignan al campo el valor devuelto por la función [validate];
  • líneas 64–66: las validaciones del nombre y del apellido, que son idénticas, se factorizan en la función [validate]. Esta no utiliza ninguna propiedad de una persona: la hemos hecho una función de nivel superior, declarada como [private] y, por lo tanto, visible solo en el archivo [Classes09.kt]. En Java, esto habría tenido que implementarse como un método estático privado de la clase. La función [trim] elimina los espacios iniciales y finales de la cadena;
  • línea 59: el tipo de la propiedad calculada [identity], [String], se infiere de la expresión de su descriptor de acceso;
  • Líneas 25–26: [obj.also { ... }] ejecuta el bloque pasándole el objeto como parámetro, referido como [it], y luego devuelve el objeto. Se utiliza para una acción secundaria, como una visualización de seguimiento, como se muestra aquí, sin interrumpir la cadena de llamadas. Aquí, [apply] devuelve la persona, [also] la muestra y luego la devuelve a su vez, y se asigna a [p2]. Línea 25: las tres asignaciones del bloque [apply] se escriben en una sola línea, separadas por punto y coma;
  • Línea 56: una propiedad de un tipo distinto de [null] debe, en principio, recibir un valor en el momento de su creación. La palabra clave [lateinit] (“inicialización tardía”) elimina este requisito: la propiedad [city] recibirá su valor más tarde (línea 33). Si se accede a ella antes, se lanza una excepción [UninitializedPropertyAccessException] (líneas 29–31). [lateinit] solo se aplica a una propiedad [var] de un tipo de objeto que no es [null] ([String], pero no [Int] ni [String?]) y sin descriptores de acceso personalizados. Se utiliza cuando el valor se proporciona después de construir el objeto, por ejemplo mediante un framework de inyección de dependencias como Spring (capítulo 6) o mediante un método de inicialización en una prueba. Dentro de la clase, la expresión [::city.isInitialized] indica si a la propiedad se le ha asignado un valor.

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=classes09.Classes09Kt
[jean, Dupont, 30]
invalid last name ()
invalid age (-4)
[jean, Dupont, 30]
Creation of [Arthur, Martin, 7]
lateinit property city has not been initialized
[Arthur, Martin, 7] lives in Angers

El nombre "jean", que se ingresó con espacios alrededor (línea 8), se almacenó sin ellos (línea 1 de los resultados). Los intentos de modificación no válidos fueron rechazados y la persona no cambió (líneas 2–4 de los resultados). La línea 6 de los resultados es el mensaje de la excepción [UninitializedPropertyAccessException].

Hay otras tres funciones de alcance: [let], vista en el capítulo anterior con los valores [null], [run], y [with]. Se diferencian en cómo se refiere el bloque al objeto ([this] o [it]) y en lo que devuelven (el objeto o el resultado del bloque):

Función
Objeto en el bloque
Resultado
Uso típico
[apply]
[this]
El objeto
Configurar un objeto recién creado
[also]
[it]
El objeto
Acción de seguimiento (monitoreo, verificación) en una secuencia
[let]
[it]
El resultado del bloque
Procesar un valor no [null]: [x?.let { ... }]
[run]
[this]
El resultado del bloque
Calcular un valor a partir de un objeto
[with]
[this]
El resultado del bloque
[with(obj) { ... }]: Varias llamadas sobre el mismo objeto

Para construir objetos complejos, Java suele utilizar el patrón de diseño “Builder”: una clase auxiliar, provista de métodos fluidos, recopila valores y luego construye el objeto final. En Kotlin, un constructor con parámetros con nombre y valores predeterminados reemplaza este patrón en la mayoría de los casos.

4.1.18. Miembros de clase: el objeto complementario (companion object)

Supongamos que queremos contar el número de objetos [Person] creados en una aplicación. Podríamos gestionar un contador nosotros mismos, pero corremos el riesgo de pasar por alto los objetos temporales que se crean aquí y allá. Parece más seguro incluir en el constructor de la clase [Person] una instrucción que incremente un contador. Este contador no puede ser una propiedad ordinaria, ya que cada objeto tiene sus propias propiedades: es una propiedad de la clase misma, no de una instancia particular de esa clase.

Java declara un miembro de este tipo con la palabra clave [static]. Kotlin no tiene la palabra clave [static]: los miembros de clase se declaran en un companion object ([companion object { ... }]), un único objeto asociado a la clase y declarado dentro del cuerpo de la clase. Sus miembros se utilizan con el nombre de la clase: [Person.nbPersons], [Person.unknown()]. Este es un ejemplo, [Classes10.kt]:

// miembros de clase: el companion object; un objeto singleton (object)
package classes10

fun main() {
    val p1 = Person("Jean", "Dupont", 30)
    val p2 = Person(p1)
    Person(p1)
    Log.write("Number of persons created: ${Person.nbPersons}")
    // un método de clase
    val p3 = Person.unknown()
    p3.identify()
    p2.identify()
    Log.write("Number of persons created: ${Person.nbPersons}")
}

class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // constructor secundario de copia
    constructor(p: Person) : this(p.firstName, p.lastName, p.age)

    // el bloque init forma parte del constructor primario: cada construcción incrementa el contador
    init {
        nbPersons++
    }

    // identidad de la persona
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }

    // el companion object: sus miembros son los de la propia clase
    companion object {
        // propiedad de clase: legible por todos, modificable solo por la clase Person
        var nbPersons = 0L
            private set

        // método de clase
        fun unknown() = Person("?", "?", 0)
    }
}

// un objeto singleton: la clase Log y su única instancia se declaran juntas
object Log {
    // el estado del objeto: el número del último mensaje escrito
    private var number = 0

    fun write(message: String) {
        number++
        println("[$number] $message")
    }
}
  • líneas 31–37: el companion object de la clase [Person];
  • líneas 33–34: la propiedad de clase [nbPersons], inicializada en 0 (de tipo [Long] debido al sufijo [L]). Es legible por todos ([Person.nbPersons], línea 8), pero su setter es privado: solo la clase [Person] puede modificarla. No es necesario definir, como en Java, un campo privado y un método de acceso estático [getNbPersons()];
  • línea 37: un método de clase. Se llama utilizando el nombre de la clase: [Person.unknown()] (línea 10). Un método del companion object no tiene un objeto [Person] actual: no puede utilizar directamente las propiedades de una persona. Un método que crea y devuelve un objeto de su clase, como este, se denomina una “fábrica” (factory);
  • líneas 21–22: el bloque [init] incrementa el contador. Forma parte del constructor primario y, por lo tanto, el constructor de copia, que está encadenado al constructor primario, también lo ejecuta.

El último elemento del programa es un objeto singleton, [Log], declarado con la palabra clave [object] (líneas 42–48):

  • Una declaración como [object Log { ... }] declara a la vez una clase y su única instancia, que se crea automáticamente la primera vez que se utiliza. No hay constructor: no se puede crear ningún otro objeto [Log]. Se hace referencia al objeto por su nombre: [Log.write(...)];
  • un objeto tiene un estado (en este caso, el número del último mensaje escrito) que se conserva de una llamada a la siguiente;
  • Un companion object es un caso particular de objeto singleton: uno que está asociado a una clase.

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=classes10.Classes10Kt
[1] Number of persons created: 3
[?, ?, 0]
[Jean, Dupont, 30]
[2] Number of persons created: 4

El programa contó correctamente el objeto temporal creado en la línea 7. El registro numeró sus dos mensajes. La compilación produce una clase para el companion object, [Person$Companion], junto con las clases [Person], [Log], y [Classes10Kt]; un método del companion object es, por lo tanto, para la JVM, un método de instancia del objeto [Person.Companion]. Para permitir que un programa Java lo llame como un método estático ([Person.unknown()] en lugar de [Person.Companion.unknown()]), se anota con [@JvmStatic].

Desde el principio hemos estado utilizando funciones que, en Java, serían métodos estáticos: [println], [readln]… En Kotlin, estas son funciones de nivel superior, declaradas fuera de cualquier clase. Esta es la forma en que Kotlin escribe lo que Java llama una clase de utilidades, como la clase [Math]: un archivo que contiene funciones de nivel superior (la biblioteca estándar proporciona [kotlin.math.sqrt] y [kotlin.math.PI]) o, si se desea agrupar funciones bajo un único nombre, un [object]. El companion object se reserva para los elementos que realmente son específicos de la clase: fábricas, constantes y contadores.

4.1.19. Un arreglo de personas

Un objeto es un dato como cualquier otro y, como tal, varios objetos pueden agruparse en un arreglo [Classes11.kt]:

// un arreglo de personas
package classes11

fun main() {
    // un arreglo de 3 referencias, todas inicializadas en null
    val friends = arrayOfNulls<Person>(3)
    friends[0] = Person("Jean", "Dupont", 30)
    friends[1] = Person("Sylvie", "Vartan", 52)
    friends[2] = Person("Neil", "Armstrong", 66)
    // visualización: los elementos son de tipo Person?
    for (friend in friends) {
        friend?.identify()
    }
}

class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // identidad de la persona
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • Línea 6: crea un arreglo de 3 elementos. La función [arrayOfNulls<Person>(3)] inicializa estos elementos con el valor [null], lo que significa que no referencian ningún objeto: por lo tanto, el tipo del arreglo es [Array<Person?>], un arreglo de referencias que pueden contener el valor [null]. Coloquialmente, lo llamamos un “arreglo de objetos”, aunque en realidad es solo un arreglo de referencias a objetos. La creación del arreglo, que es en sí mismo un objeto, no crea ningún objeto del mismo tipo que sus elementos; esto debe hacerse posteriormente;
  • líneas 7–9: creación de los 3 objetos de tipo [Person];
  • líneas 11–12: visualización del contenido del arreglo [friends]. La variable [friend] es de tipo [Person?]: el compilador exige la llamada segura [friend?.identify()], que no hace nada si [friend] es igual a [null].

Resultados:

1
2
3
4
> gradlew -q run -Pmain=classes11.Classes11Kt
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

El tipo de elemento [Person?] indica que un arreglo creado vacío en Java contiene [null]. Esto se evita en Kotlin creando el arreglo con sus elementos, como se muestra en el siguiente párrafo.

4.1.20. Inferencia de tipos e inicialización de arreglos

El programa [Classes12.kt] demuestra la sintaxis que simplifica la creación de objetos y arreglos:

// inferencia de tipos e inicialización de arreglos
package classes12

fun main() {
    // el tipo de la variable se infiere a partir de la expresión que la inicializa
    val p1 = Person("Jean", "Dupont", 30)
    val p2 = Person()
    p2.firstName = "Arthur"
    p2.lastName = "Martin"
    p2.age = 7
    // un arreglo creado e inicializado con una lista de valores
    val friends = arrayOf(
        p1,
        p2,
        Person("Sylvie", "Vartan", 52),
        Person("Neil", "Armstrong", 66),
    )
    for (friend in friends) {
        println(friend.identity)
    }
    // un arreglo creado sobre la marcha, pasado como parámetro
    display(arrayOf(Person("Pauline", "Leduc", 12), p1))
    // un arreglo cuyos elementos se calculan con una lambda a partir de su índice
    val children = Array(3) { i -> Person("Child${i + 1}", "Martin", i + 2) }
    display(children)
}

// una función que recibe un arreglo de personas
fun display(persons: Array<Person>) {
    for (p in persons) {
        println("Display : ${p.identity}")
    }
}

// todas las propiedades tienen un valor por defecto: Person() es posible
class Person(var firstName: String = "", var lastName: String = "", var age: Int = 0) {
    // identidad
    val identity get() = "[$firstName, $lastName, $age]"
}
  • Línea 6: el tipo de la variable, [Person], se infiere a partir de la expresión que la inicializa. La variable, no obstante, tiene tipo: [p1] solo puede referirse a una persona. Esta ha sido la notación estándar en Kotlin desde el comienzo del curso; el equivalente en Java es la palabra clave [var]. Kotlin va un paso más allá que Java: la inferencia de tipos también se aplica a las propiedades ([identity], línea 38) y al tipo de retorno de las funciones cuyo cuerpo es una expresión;
  • línea 36: todas las propiedades tienen un valor predeterminado. Por lo tanto, el constructor primario puede llamarse sin argumentos, [Person()] (línea 7), y luego se asignan las propiedades a la persona (líneas 8–10). No es necesario declarar un constructor sin parámetros;
  • Líneas 12–16: un arreglo creado y poblado por la función [arrayOf(...)], que recibe los valores de los elementos. El tamaño del arreglo es el número de valores; su tipo, [Array<Person>], se deriva del tipo de los valores: los elementos no pueden ser de tipo [null]. Se permite una coma final (línea 16) en una lista de argumentos, como en cualquier lista de parámetros: facilita agregar un elemento;
  • línea 18: la variable de bucle [friend] es de tipo [Person]: esta vez no hay llamada segura;
  • línea 22: un arreglo creado sobre la marcha y pasado como parámetro. Esto se denomina arreglo anónimo: no está referenciado por ninguna variable en la función [main]. A diferencia de Java, no hay diferencia de sintaxis según el arreglo se cree en una declaración o en otro lugar;
  • línea 24: el constructor [Array(size) { i -> ... }] crea un arreglo en el que cada elemento es calculado por la expresión lambda a partir de su índice [i];
  • líneas 29–31: una función de nivel superior que recibe un arreglo de personas.

Resultados:

> gradlew -q run -Pmain=classes12.Classes12Kt
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display : [Pauline, Leduc, 12]
Display : [Jean, Dupont, 30]
Display : [Child1, Martin, 2]
Display : [Child2, Martin, 3]
Display : [Child3, Martin, 4]

Haremos poco uso de los arreglos de objetos: el siguiente capítulo presenta las listas ([List], [MutableList]), que son más flexibles ([listOf(p1, p2)] se escribe como [arrayOf(p1, p2)]).

4.2. La herencia mediante un ejemplo

4.2.1. Visión general

Aquí abordamos el concepto de herencia. El propósito de la herencia es “personalizar” una clase existente para que satisfaga nuestras necesidades. Supongamos que queremos crear una clase [Teacher]: un docente es un tipo específico de persona. Tiene atributos que otras personas no tienen: la materia que enseña, por ejemplo. Pero también tiene los atributos comunes a todas las personas: nombre, apellido y edad. Un docente es, por lo tanto, un miembro de pleno derecho de la clase [Person] pero tiene atributos adicionales. En lugar de crear una clase [Teacher] desde cero, preferimos apoyarnos en la clase existente [Person] y adaptarla a las características específicas de los docentes. Esto es posible gracias al concepto de herencia.

Para indicar que la clase [Teacher] hereda de la clase [Person], escribimos [class Teacher(...) : Person(...)]: el nombre de la clase padre sigue a los dos puntos, como en C#, mientras que Java escribe [extends Person].

[Person] se denomina clase padre (o clase base, o superclase), y [Teacher] es la clase derivada (o clase hija, o subclase). Un objeto [Teacher] tiene todas las características de un objeto [Person]: tiene las mismas propiedades y métodos. Estas propiedades y métodos de la clase padre no se repiten en la definición de la clase hija; simplemente se especifican las propiedades y los métodos que agrega la clase hija. Una clase de Kotlin puede heredar de una sola clase padre.

Una diferencia importante con Java: en Kotlin, una clase es final de manera predeterminada, es decir, no se puede heredar de ella. Para permitir la derivación, la clase padre debe declararse [open] (“abierta”). Esta es una decisión deliberada de los diseñadores del lenguaje: una clase debe estar diseñada para ser derivada, y quien la escribe debe indicarlo explícitamente.

Los ejemplos de este párrafo son dos programas de varios archivos, ubicados en los paquetes [inheritance1] y [inheritance2]. En el paquete [inheritance1], la clase [Person] se define de la siguiente manera en [Person.kt]:

package inheritance1

// open: la clase Person puede tener clases derivadas
open class Person(firstName: String, lastName: String, age: Int) {
    // propiedades verificadas por su setter
    var firstName = ""
        set(value) {
            field = validate(value, "first name")
        }

    var lastName = ""
        set(value) {
            field = validate(value, "last name")
        }

    var age = 0
        set(value) {
            require(value >= 0) { "invalid age ($value)" }
            field = value
        }

    // identidad de la persona
    val identity get() = "[$firstName, $lastName, $age]"

    // construcción: inicialización mediante los setters, conteo, traza
    init {
        this.firstName = firstName
        this.lastName = lastName
        this.age = age
        nbPersons++
        println("Constructor Person(String, String, Int)")
    }

    companion object {
        // número de personas creadas
        var nbPersons = 0L
            private set
    }
}

// verificación de una cadena obligatoria
private fun validate(value: String, label: String): String {
    require(value.isNotBlank()) { "invalid $label ($value)" }
    return value
}
  • línea 4: la clase es abierta ([open]): se pueden derivar subclases de ella. El constructor primario tiene tres parámetros, que no son propiedades (sin [val] ni [var]);
  • líneas 6–19: tres propiedades cuyos setters verifican el valor recibido (véase el programa [Classes07.kt]). Las verificaciones del nombre y del apellido, que son idénticas, se factorizan en la función privada [validate] (líneas 42–44), como en el programa [Classes09.kt];
  • línea 23: el método [identify] de los primeros ejemplos ha sido reemplazado por la propiedad calculada [identity], que devuelve la identidad de la persona en lugar de mostrarla;
  • Líneas 26–31: el bloque [init] del constructor primario inicializa el objeto mediante los setters de las propiedades, incrementa el contador de personas y muestra un mensaje de seguimiento. Se coloca después de las declaraciones de las propiedades: las inicializaciones de propiedades y los bloques [init] se ejecutan en el orden en que están escritos, y una propiedad debe haber sido inicializada (aquí con [""] o 0) antes de poder utilizarse;
  • líneas 34–37: el contador de personas de la sección sobre el companion object.

Creamos una clase [Teacher] que hereda de la clase [Person] [Teacher.kt]:

package inheritance1

// la clase Teacher deriva de la clase Person:
// su constructor primario pasa tres de sus parámetros al constructor de la clase padre
class Teacher(firstName: String, lastName: String, age: Int, var section: Int) :
    Person(firstName, lastName, age) {

    // traza
    init {
        println("Constructor Teacher(String, String, Int, Int)")
    }
}

La clase [Teacher] agrega a las propiedades y métodos de la clase [Person]:

  • líneas 5–6: la clase [Teacher] deriva de la clase [Person]. El encabezado se escribe en dos líneas para que quepa en la página;
  • línea 5: una propiedad [section], declarada en el constructor primario ([var section: Int]), que es el número de la sección a la que pertenece el docente dentro de la facultad (aproximadamente una sección por materia). La propiedad es de lectura y escritura: reemplaza al getter y al setter de la versión en Java;
  • líneas 9–10: un bloque [init] que muestra un mensaje de seguimiento.

4.2.2. Creación de un objeto Teacher

Una clase hija no hereda los constructores de su clase padre. Debe definir sus propios constructores. El encabezado de la clase [Teacher] es el siguiente:

class Teacher(firstName: String, lastName: String, age: Int, var section: Int) :
    Person(firstName, lastName, age) {

El constructor primario recibe cuatro parámetros ([firstName], [lastName], [age], [section]) y pasa tres ([firstName], [lastName], [age]) a su clase padre (en este caso, la clase [Person]) mediante la sintaxis [: Person(firstName, lastName, age)] (línea 2). Sabemos que esta clase tiene un constructor, [Person(String, String, Int)], que nos permitirá crear una persona con los parámetros pasados. Una vez que termina la construcción de la parte [Person] (inicializaciones y bloques [init] de la clase [Person]), la construcción del objeto [Teacher] continúa con la inicialización de su propiedad [section] y la ejecución de sus propios bloques [init]. La notación [: Person(firstName, lastName, age)] corresponde a la instrucción [super(firstName, lastName, age);] del constructor en Java; si la clase derivada no tiene un constructor primario, cada uno de sus constructores secundarios llama al constructor de la clase padre mediante [constructor(...) : super(...)].

En resumen, el constructor de una clase derivada:

  • pasa a su clase padre los parámetros que esta necesita para construirse;
  • utiliza los parámetros restantes para inicializar sus propias propiedades.

Podría haber sido preferible inicializar directamente las propiedades [firstName], [lastName] y [age] directamente en la clase [Teacher], mediante instrucciones como [this.firstName = firstName]. Esto es posible aquí porque estas propiedades son públicas y mutables, pero sería una mala solución, y sería imposible si fueran privadas: los miembros privados de la clase [Person] solo son accesibles para los métodos de la clase [Person]. Todos los demás objetos, incluidos los objetos de clases derivadas como en este caso, deben acceder a ellos a través de miembros públicos (o protegidos, como [protected]). Lo más importante es que la parte [Person] del objeto debe, en cualquier caso, ser instanciada por un constructor de la clase [Person]. Si se escribe [: Person()] sin argumentos, el compilador informa que faltan los parámetros del constructor de la clase padre:

1
2
3
4
5
6
7
8
9
Teacher.kt:6:5: error: no value passed for parameter 'firstName'.
    Person() {
    ^^^^^^
Teacher.kt:6:5: error: no value passed for parameter 'lastName'.
    Person() {
    ^^^^^^
Teacher.kt:6:5: error: no value passed for parameter 'age'.
    Person() {
    ^^^^^^

Por lo tanto, utilizar el constructor de la clase padre es la solución correcta y el enfoque estándar: al crear un objeto hijo, primero se llama al constructor del objeto padre y luego se completan las inicializaciones específicas del objeto hijo ([section] en nuestro ejemplo).

Finalmente, si se omite la palabra clave [open] antes de la clase [Person], la derivación es rechazada:

1
2
3
Teacher.kt:6:5: error: this type is final, so it cannot be extended.
    Person(firstName, lastName, age) {
    ^^^^^^

4.2.3. Métodos heredados

La clase [Teacher] no define una propiedad llamada [identity]. La expresión [e.identity], donde [e] es un docente, hace referencia por lo tanto a la propiedad [identity] heredada de la clase [Person]: es pública y, por herencia, se convierte en una propiedad pública de la clase [Teacher]. Lo mismo se aplica a los métodos. El programa de prueba [Main.kt] del paquete [inheritance1] es el siguiente:

package inheritance1

fun main() {
    // un profesor
    val e = Teacher("Lucile", "Dumas", 56, 61)
    // la propiedad identity heredada de la clase Person
    println(e.identity)
    // la propiedad section propia de la clase Teacher
    println("section=${e.section}")
    // una persona
    val p = Person("Jean", "Dupont", 30)
    // la función display recibe una Person o un objeto de una clase derivada
    display(e)
    display(p)
    // el método toString heredado de la clase Any
    println(e.toString())
    println(p.toString())
    println("Number of persons created: ${Person.nbPersons}")
}

// muestra la identidad de p
fun display(p: Person) {
    println(p.identity)
}
  • línea 5: creación de un docente;
  • línea 7: visualización de la identidad del docente, obtenida mediante la propiedad [identity] heredada de la clase [Person];
  • línea 9: la propiedad [section], específica de la clase [Teacher];
  • líneas 13–14: llamada a la función [display] (líneas 22–23) con un docente y luego con una persona. Volveremos sobre esto en el siguiente párrafo;
  • líneas 16–17: llamada al método [toString] sobre ambos objetos. También volveremos sobre esto.

Resultados:

> gradlew -q run -Pmain=inheritance1.MainKt
Constructor Person(String, String, Int)
Constructor Teacher(String, String, Int, Int)
[Lucile, Dumas, 56]
section=61
Constructor Person(String, String, Int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
inheritance1.Teacher@2f0e140b
inheritance1.Person@7440e464
Number of persons created: 2

Podemos observar que:

  • un objeto [Person] (línea 1 de los resultados) se construyó antes que el objeto [Teacher] (línea 2);
  • [e.identity] proporcionó la identidad de la parte [Person] del docente, sin su sección (línea 3);
  • el contador de personas también cuenta al docente (línea 10): un docente es una persona.

Para obtener la identidad completa de un docente, la clase [Teacher] debe definir su propia propiedad [identity]. Esto es lo que hace el paquete [inheritance2].

4.2.4. Polimorfismo

Consideremos una jerarquía de clases: C0 ← C1 ← C2 ← … ← Cn, donde Ci ← Cj indica que la clase Cj deriva de la clase Ci. Esto implica que la clase Cj tiene todas las características de la clase Ci más otras adicionales. Sean Oi objetos de tipo Ci. Es válido escribir [Oi = Oj] con j > i. En efecto, por herencia, la clase Cj tiene todas las características de la clase Ci más otras adicionales. Por lo tanto, un objeto Oj de tipo Cj contiene un objeto de tipo Ci. La operación [Oi = Oj] hace que la variable Oi, de tipo Ci, referencie el objeto Oj: a través de ella solo se puede acceder a los miembros definidos en la clase Ci.

El hecho de que una variable Oi de la clase Ci pueda referenciar no solo un objeto de la clase Ci sino cualquier objeto derivado de la clase Ci se denomina polimorfismo: la capacidad de una variable de referenciar diferentes tipos de objetos.

Veamos un ejemplo y consideremos la función [display] del programa anterior:

1
2
3
fun display(p: Person) {
    println(p.identity)
}

Podemos pasarle un *[Person] o un *[Teacher]: en este último caso, el parámetro formal [p], que es de tipo [Person], recibe un valor de tipo [Teacher]. Como el tipo [Teacher] deriva del tipo [Person], esto es válido. La expresión [p.identity] utilizó aquí la propiedad [identity] de la clase [Person], la única que existe en el programa: para el docente (línea 6 de los resultados), solo obtenemos la identidad de su parte “Person”.” Veamos qué ocurre cuando la clase [Teacher] tiene su propia propiedad [identity].

4.2.5. Redefinición de métodos y enlace dinámico

En el paquete [inheritance2], la clase [Person] es la misma que la del paquete [inheritance1], con dos cambios:

1
2
3
4
5
    // identidad de la persona: open, puede sobrescribirse en una clase derivada
    open val identity get() = "[$firstName, $lastName, $age]"

    // sobrescritura del método toString de la clase Any
    override fun toString() = identity
  • Línea 2: la propiedad [identity] se declara como [open]: puede ser sobrescrita en una clase derivada. En Kotlin, los métodos y las propiedades son final de manera predeterminada, igual que las clases: solo los miembros [open] de una clase [open] pueden ser sobrescritos;
  • líneas 4–5: una sobrescritura del método [toString], tratada en el siguiente párrafo.

En la clase [Teacher], la propiedad [identity] se redefine de la siguiente manera:

package inheritance2

// una clase de Kotlin es final por defecto: no se puede derivar de la clase Teacher
class Teacher(firstName: String, lastName: String, age: Int, var section: Int) :
    Person(firstName, lastName, age) {

    // traza
    init {
        println("Constructor Teacher(String, String, Int, Int)")
    }

    // la propiedad identity sobrescribe la de la clase padre
    override val identity get() = "Teacher[${super.identity},$section]"
}
  • Línea 13: la propiedad [identity] sobrescribe la propiedad de la clase padre; tiene el mismo nombre y el mismo tipo. Utiliza la propiedad [identity] de su clase padre, designada como [super.identity], para obtener la parte “Person” y luego la complementa con la sección específica de la clase [Teacher]. Un método se redefine de la misma manera: mismo nombre, mismos parámetros, mismo tipo de retorno y la palabra clave [override];
  • Línea 13: la palabra clave [override] es obligatoria. Cumple la misma función que la anotación [@Override] de Java, que es opcional: si la propiedad no redefiniera nada (por ejemplo, por un error tipográfico en el nombre o un tipo diferente), el compilador informaría el error en lugar de crear silenciosamente un nuevo miembro. A la inversa, una redefinición sin *[override]* es rechazada:
1
2
3
Teacher.kt:13:9: error: 'identity' hides member of supertype 'Person' and needs an 'override' modifier.
    val identity get() = "Teacher[${super.identity},$section]"
        ^^^^^^^^
  • y si la propiedad [identity] de la clase [Person] no se declara como [open], la redefinición es rechazada:
1
2
3
Teacher.kt:13:5: error: 'identity' in 'Person' is final and cannot be overridden.
    override val identity get() = "Teacher[${super.identity},$section]"
    ^^^^^^^^
  • Línea 3: la clase [Teacher] no se declara como [open]: es final, como explicaremos un poco más adelante.

Consideremos un objeto [Teacher] [E]. Este objeto contiene un objeto [Person]:

Image

La propiedad [identity] está definida tanto en la clase [Teacher] como en su clase padre [Person]. La versión utilizada por [p.identity] se determina en tiempo de ejecución, según el tipo real del objeto referenciado por [p], y no en tiempo de compilación según el tipo declarado de la variable. Esto se conoce como enlace dinámico. Para ejecutar [o.m()], la máquina virtual busca un método llamado [m] en el siguiente orden:

  • en la clase del objeto [o];
  • en su clase padre, si la tiene;
  • en la clase padre de su clase padre, si existe;
  • y así sucesivamente.

Lo mismo se aplica a una propiedad, donde la lectura de la propiedad implica llamar a su descriptor de acceso, que es un método. Por lo tanto, la herencia permite redefinir en la clase hija miembros que tienen la misma firma que los de la clase padre. Esto es lo que permite adaptar la clase hija a sus propias necesidades. El programa [Main.kt] del paquete [inheritance2] es el siguiente:

package inheritance2

fun main() {
    // un profesor
    val e = Teacher("Lucile", "Dumas", 56, 61)
    display(e)
    // una persona
    val p = Person("Jean", "Dupont", 30)
    display(p)
    // visto como una Person, el profesor sigue siendo un profesor
    val pe: Person = e
    println(pe.identity)
    println((e as Person).identity)
    // println(Any?) muestra el resultado del método toString del objeto
    println(e)
    println(p)
    // un arreglo de personas de tipos diferentes
    val persons = arrayOf(p, e)
    for (person in persons) {
        println("${person::class.simpleName} : $person")
    }
}

// muestra la identidad de p
fun display(p: Person) {
    println(p.identity)
}

Resultados:

> gradlew -q run -Pmain=inheritance2.MainKt
Constructor Person(String, String, Int)
Constructor Teacher(String, String, Int, Int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(String, String, Int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

Esta vez, en la línea 3 de los resultados, la función [display] mostró correctamente la identidad completa del profesor. Las líneas 11–13 del programa muestran que, al verlo a través de una variable de tipo [Person] o al convertirlo a [Person] mediante el operador [as] (el equivalente del operador de Java [(Person)]), el profesor sigue siendo un profesor: es la propiedad [identity] de la clase [Teacher] la que se utiliza (líneas 6–7 de los resultados). La conversión cambia el tipo de la referencia, no el del objeto.

En este aspecto, Kotlin se parece más a C# que a Java. En C#, un método solo puede redefinirse si se declara virtual ([virtual]), y la redefinición se indica con [override]; en Kotlin, [open] cumple la misma función que [virtual]. En Java, en cambio, todos los métodos son redefinibles por defecto, salvo los declarados como [final]. En todos los casos, una vez redefinido el método, el enlace es dinámico.

4.2.6. La clase Any y el método toString

La clase [Any] es la clase “padre” de todas las clases de Kotlin. Así, cuando se escribe [class Person], se está escribiendo implícitamente [class Person : Any()]. Corresponde a la clase de Java [java.lang.Object]: en tiempo de ejecución, en la JVM, es en realidad [Object].

La clase *[Any] define tres métodos, todos ellos *[open], de los que heredan todos los objetos:

  • [toString(): String]: devuelve una representación textual del objeto. Por defecto, es el nombre completo de la clase del objeto, seguido del carácter [@] y de un código hash escrito en hexadecimal;
  • [equals(other: Any?): Boolean]: indica si el objeto es “igual” al objeto [other]. Por defecto, solo es igual a sí mismo: el método compara referencias, igual que el operador [===]. Este es el método al que llama el operador [==];
  • [hashCode(): Int]: devuelve un código hash del objeto, utilizado por los diccionarios y los conjuntos (próximo capítulo). Los métodos [equals] y [hashCode] se tratan más adelante.

El método [getClass()] de la clase de Java [Object] no es un método de [Any]: en Kotlin, la expresión [obj::class] devuelve la descripción en Kotlin de la clase real del objeto (de tipo [KClass]), cuya propiedad [simpleName] es el nombre de la clase; [obj::class.java], o [obj.javaClass], devuelve la descripción en Java ([Class]).

Fue el método [toString] de la clase [Any] el que se utilizó en las llamadas [e.toString()] y [p.toString()] del paquete [inheritance1]: [inheritance1.Teacher@2f0e140b] y [inheritance1.Person@7440e464] (líneas 8–9 de los resultados; los números varían de una ejecución a otra). Aunque no redefinimos el método [toString] en las clases [Person] y [Teacher] , el método [toString] de la clase [Any] pudo mostrar el nombre real de la clase del objeto.

En el paquete [inheritance2], la clase [Person] redefine el método [toString]: [override fun toString() = identity]. La palabra clave [override] también es obligatoria aquí. Volvamos al programa [Main.kt] del paquete [inheritance2]:

1
2
3
4
5
6
7
8
    // println(Any?) muestra el resultado del método toString del objeto
    println(e)
    println(p)
    // un arreglo de personas de tipos diferentes
    val persons = arrayOf(p, e)
    for (person in persons) {
        println("${person::class.simpleName} : $person")
    }

En la línea 2, la función [println(message: Any?)] acepta un parámetro de tipo [Any?]; por lo tanto, dado que [Any] es la superclase de todas las clases, se le puede pasar cualquier objeto (en este caso, un [Teacher]). Imprime en la consola el resultado del método [toString] del objeto. Como el enlace es dinámico, se utiliza el método [toString] del objeto real; en este caso, el heredado de la clase [Person]. Este método devuelve [identity], una propiedad redefinida: para el profesor [e], es por lo tanto la propiedad [identity] de la clase [Teacher] la que se utiliza, como se muestra en la línea 8 de los resultados. Por lo tanto, no es necesario redefinir [toString] en la clase [Teacher].

El mismo mecanismo se aplica a las plantillas de cadena: en ["... : $person"] (línea 7), el objeto [person] se convierte en cadena mediante su método [toString]. El bucle de la línea 6 recorre un arreglo de referencias a [Person], que en realidad apuntan a objetos de distintos tipos: [person::class.simpleName] devuelve el nombre real de la clase de cada objeto (líneas 10–11 de los resultados).

4.2.7. Clases finales, abiertas y selladas

La clase [Teacher] del paquete [inheritance2] se declara como [class Teacher(...) : Person(...)], sin la palabra clave [open]: es final. La declaración [class TeacherResearcher(...) : Teacher(...)] sería rechazada por el compilador con el mensaje ya conocido: [this type is final, so it cannot be extended]. En Java ocurre lo contrario: una clase es abierta por defecto, y se la hace final con la palabra clave [final]. El enfoque de Kotlin evita la creación accidental de subclases de una clase que no estaba pensada para ello. Lo mismo vale para los miembros: un método o una propiedad solo puede redefinirse si se declara como [open]. Un miembro que redefine a otro ([override]) es a su vez redefinible en las clases derivadas posteriores, a menos que se declare como [final override].

Entre una clase abierta a toda derivación y una clase final, Kotlin ofrece (como Java desde la versión 17) una opción intermedia: la clase sellada ([sealed]), cuyas clases derivadas directas son todas conocidas en tiempo de compilación. El programa [Classes13.kt] lo ilustra:

// clases finales, clases abiertas y clases selladas
package classes13

fun main() {
    val persons = arrayOf(
        Teacher("Lucile", "Dumas", 61),
        Student("Paul", "Martin", "computer science"),
        Adjunct("Marc", "Petit"),
        Consultant("Lise", "Morel", "Airbus"),
    )
    for (p in persons) {
        println("${p::class.simpleName} : ${p.identity}")
    }
    // when sobre una clase sellada: el compilador sabe que se manejan todos los casos
    for (p in persons) {
        println("${p.firstName} is ${description(p)}")
    }
    // las subclases directas permitidas de la clase sellada Person
    println("Person is sealed: ${Person::class.java.isSealed}")
    for (c in Person::class.java.permittedSubclasses) {
        println("allowed subclass: ${c.simpleName}")
    }
}

// una expresión when sin rama else
fun description(p: Person): String = when (p) {
    is Teacher -> "a teacher in section ${p.section}"
    is Student -> "a student in ${p.major}"
    is Adjunct -> "an adjunct"
}

// una clase sellada: todas sus clases derivadas directas se conocen en tiempo de compilación
sealed class Person(val firstName: String, val lastName: String) {
    open val identity get() = "[$firstName, $lastName]"
}

// una clase derivada es final por defecto
class Teacher(firstName: String, lastName: String, val section: Int) : Person(firstName, lastName) {
    override val identity get() = "${super.identity}, section $section"
}

class Student(firstName: String, lastName: String, val major: String) : Person(firstName, lastName) {
    override val identity get() = "${super.identity}, major $major"
}

// open: la jerarquía vuelve a quedar abierta a partir de esta clase
open class Adjunct(firstName: String, lastName: String) : Person(firstName, lastName)

// una clase derivada de Adjunct: permitido, ya que Adjunct es open
class Consultant(firstName: String, lastName: String, val company: String) : Adjunct(firstName, lastName) {
    override val identity get() = "${super.identity}, company $company"
}
  • línea 33: la clase [Person] es sellada. Sus subclases directas deben declararse en el mismo paquete y módulo que ella (en cualquier archivo de ese paquete). A diferencia de Java, no hay una lista de clases permitidas ([permits]): incluye todas las clases del paquete que son sus subclases directas, en este caso [Teacher], [Student], y [Adjunct]. Una clase sellada es implícitamente abstracta (véase más adelante: no se pueden crear objetos de esta clase, solo de sus clases derivadas) y su constructor es protegido: está destinado únicamente a las clases derivadas;
  • línea 34: la propiedad [identity] es abierta: las clases derivadas pueden redefinirla;
  • Líneas 38–43: las clases [Teacher] y [Student] son finales por defecto. En Java, una clase derivada de una clase sellada debe declararse como [final], [sealed], o [non-sealed]; en Kotlin, basta con la regla por defecto;
  • Línea 47: la clase [Adjunct] es abierta ([open]): reabre la jerarquía y permite que cualquier clase derive de ella. Esto equivale al [non-sealed] de Java. Una tercera opción es declararla a su vez como [sealed]. La clase no tiene cuerpo: no hay nada que agregar a la clase [Person];
  • línea 50: la clase [Consultant] deriva de [Adjunct], lo cual está permitido;
  • líneas 5–9: el tipo del arreglo, [Array<Person>], lo infiere el compilador: es el tipo común más específico de los cuatro objetos;
  • líneas 26–29: la expresión [when], vista en el capítulo anterior, comprueba aquí el tipo de la persona mediante el operador [is]. En cada rama, el compilador sabe que [p] es del tipo comprobado: [p.section] se acepta en la rama [is Teacher] sin conversión explícita. Esto es el “smart cast” (conversión inteligente), que se explica con más detalle al final del capítulo. Lo más importante es que la expresión [when] no tiene la rama [else]: dado que la clase [Person] es sellada, el compilador sabe que toda persona es un [Teacher], un [Student] o un [Adjunct], y que los tres casos están cubiertos. Un consultor es un adjunto: la tercera rama se encarga de él;
  • líneas 19–21: la descripción en Java de la clase ([Person::class.java]) indica si es sellada ([isSealed]) y enumera sus subclases directas permitidas ([permittedSubclasses]). Para una clase sellada, el compilador de Kotlin produce la misma información que el compilador de Java: en la JVM, la clase [Person] es una clase sellada de Java.

Resultados:

> gradlew -q run -Pmain=classes13.Classes13Kt
Teacher : [Lucile, Dumas], section 61
Student : [Paul, Martin], major computer science
Adjunct : [Marc, Petit]
Consultant : [Lise, Morel], company Airbus
Lucile is a teacher in section 61
Paul is a student in computer science
Marc is an adjunct
Lise is an adjunct
Person is sealed: true
allowed subclass: Adjunct
allowed subclass: Student
allowed subclass: Teacher

Si se escribe una clase [Artist] derivada de [Person] en otro paquete (en este caso, el paquete [others]), el compilador informa:

1
2
3
Artist.kt:6:53: error: a class can only extend a sealed class or interface declared in the same package.
class Artist(firstName: String, lastName: String) : Person(firstName, lastName)
                                                    ^^^^^^

Y si se elimina la rama [is Adjunct] de la expresión [when], el compilador informa que no se están cubriendo todos los casos:

1
2
3
Classes13.kt:26:38: error: 'when' expression must be exhaustive. Add the 'is Adjunct' branch or an 'else' branch.
fun description(p: Person): String = when (p) {
                                     ^^^^

¿Para qué sirve una clase sellada? Permite al autor de una jerarquía de clases mantener el control sobre ella: el autor sabe que toda [Person] es un [Teacher], un [Student], o un [Adjunct]. El compilador también lo sabe y lo aprovecha en la expresión [when]: si más adelante se agrega una cuarta clase derivada de [Person], todas las expresiones [when] que no la contemplen se señalan durante la compilación. Una rama como [else], en cambio, habría ocultado esta omisión. Este mecanismo también se aplica a las interfaces ([sealed interface]), que se tratan más adelante, y es una forma muy común en Kotlin de modelar un conjunto cerrado de casos: los resultados posibles de una operación (éxito, fallo), los estados de una pantalla, los mensajes intercambiados entre dos programas…

4.3. Sobrecarga de operadores

Algunos lenguajes, como C# o C++, permiten redefinir el significado de los operadores ([+], [==], [<]…) para una clase. Java no lo permite: hay que escribir métodos, como [a.add(b)] en lugar de [a + b], [s1.equals(s2)] en lugar de [s1 == s2], [a.compareTo(b) < 0] en lugar de [a < b]. Kotlin lo permite de una forma sencilla y controlada: cada operador corresponde a un método con un nombre fijo, y basta con declarar un método con ese nombre, precedido de la palabra clave [operator], para que el operador pueda usarse con objetos de esa clase. La expresión [a + b] es traducida así por el compilador a [a.plus(b)]. No se pueden inventar nuevos operadores ni cambiar su precedencia. Las convenciones principales son las siguientes:

Expresión
Traducida a
Nota
[a + b], [a - b], [a * b], [a / b], [a % b]
[a.plus(b)], [a.minus(b)], [a.times(b)], [a.div(b)], [a.rem(b)]
operadores aritméticos
[-a], [+a], [!a]
[a.unaryMinus()], [a.unaryPlus()], [a.not()]
operadores unarios
[a++], [a--]
[a.inc()], [a.dec()]
El método devuelve el nuevo valor
[a += b]
[a.plusAssign(b)], o bien [a = a.plus(b)]
lo mismo se aplica a [-=], [*=]…
[a == b], [a != b]
[a?.equals(b) ?: (b === null)]
[equals] se hereda de [Any]: se redefine como [override]
[a < b], [a <= b], [a > b], [a >= b]
[a.compareTo(b) < 0]…
[compareTo] devuelve un entero negativo, cero o positivo
[b in a], [b !in a]
[a.contains(b)], [!a.contains(b)]
pertenencia
[a[i]], [a[i] = v]
[a.get(i)], [a.set(i, v)]
indexadores (próximo párrafo)
[a(x)]
[a.invoke(x)]
un objeto “llamado” como una función
[a..b]
[a.rangeTo(b)]
intervalos
[for (x in a)]
[a.iterator()]
iteración

Los operadores [===] y [!==], que comparan referencias, no pueden redefinirse. Las clases de la biblioteca estándar de Kotlin utilizan estas convenciones y, gracias a las funciones de extensión (que se tratan más adelante en este capítulo), Kotlin también las aplica a clases del JDK como [BigDecimal]. En una clase de Java, un método con el nombre y la firma esperados ([compareTo], [get]…) también puede usarse como operador sin la palabra clave [operator].

4.3.1. Un ejemplo

El paquete [lists] contiene una clase llamada [ListOfPersons], una lista de personas, cuyos métodos definen los operadores [+], [+=], [in], la iteración y los indexadores. Las clases [Person] y [Teacher] de este paquete son versiones simplificadas de las del paquete [inheritance2]: las propiedades son de solo lectura ([val]) y ya no hay validaciones, mensajes de progreso ni contadores. La clase [Person] incorpora un operador de comparación, [Person.kt]:

package lists

open class Person(val firstName: String, val lastName: String, val age: Int) {
    // identidad de la persona
    open val identity get() = "[$firstName, $lastName, $age]"

    override fun toString() = identity

    // los operadores de comparación <, <=, >, >=: las personas se comparan por edad
    operator fun compareTo(other: Person) = age.compareTo(other.age)
}
  • Línea 10: el método [compareTo], declarado como [operator], define los cuatro operadores [<], [<=], [>], y [>=] entre dos personas: [p1 < p2] se traduce a [p1.compareTo(p2) < 0]. El método debe devolver un entero negativo si el objeto actual precede al objeto [other], cero si son equivalentes y un entero positivo en caso contrario. Aquí, las personas se comparan por edad: el método [compareTo] de los enteros hace el trabajo.

Las personas se almacenan en una lista mutable de tipo [MutableList<Person>] (las listas se tratan en el próximo capítulo). En lugar de hacer que la clase [ListOfPersons] herede de una clase de lista, colocamos la lista en una propiedad privada de la clase. Esto se conoce como usar composición en lugar de herencia: la clase *[ListOfPersons]* expone así solo las operaciones que ha elegido. De la lista, utilizamos únicamente los siguientes elementos:

  • el método [l.add(p)], que agrega la persona [p] a la lista [l], y el método [l.addAll(l2)], que le agrega todos los elementos de la lista [l2];
  • la propiedad [l.size], que devuelve el número de elementos de la lista [l], y la propiedad [l.indices], el rango [0..size-1] de sus índices;
  • la notación [l[i]], que se refiere al elemento número i de la lista [l], tanto para lectura como para escritura: las listas de Kotlin tienen indexadores;
  • el método [l.iterator()], que devuelve un iterador sobre los elementos de la lista, y el método [l.joinToString(...)], que construye una cadena a partir de sus elementos.

La definición de la clase [ListOfPersons] es la siguiente: [ListOfPersons.kt]:

package lists

class ListOfPersons {
    // las personas de la lista
    private val persons = mutableListOf<Person>()

    // número de personas en la lista
    val size get() = persons.size

    // el operador +: devuelve una nueva lista que contiene las personas
    // de la lista actual y la persona p
    operator fun plus(p: Person): ListOfPersons {
        val result = ListOfPersons()
        result.persons.addAll(persons)
        result.persons.add(p)
        return result
    }

    // el operador +=: agrega p a la lista actual
    operator fun plusAssign(p: Person) {
        persons.add(p)
    }

    // el operador in: ¿la lista contiene una persona con el apellido dado?
    operator fun contains(lastName: String) = indexOf(lastName) != -1

    // el operador de iteración: permite escribir for (p in list)
    operator fun iterator(): Iterator<Person> = persons.iterator()

    // los indexadores: list[i] para leer y escribir
    operator fun get(i: Int) = persons[i]

    operator fun set(i: Int, p: Person) {
        persons[i] = p
    }

    // un segundo indexador de lectura: list[lastName] devuelve la persona con ese apellido, o null
    operator fun get(lastName: String): Person? {
        val i = indexOf(lastName)
        return if (i != -1) persons[i] else null
    }

    // posición de la persona con el apellido dado, -1 si no hay ninguna
    fun indexOf(lastName: String): Int {
        for (i in persons.indices) {
            if (persons[i].lastName == lastName) {
                return i
            }
        }
        return -1
    }

    // toString: devuelve (person1,person2,...)
    override fun toString() = persons.joinToString(",", "(", ")")
}
  • línea 5: la lista de personas. La función [mutableListOf<Person>()] crea una lista vacía y mutable de elementos de tipo [Person]. La palabra clave [val] indica que la propiedad siempre se referirá a la misma lista; el contenido de la lista puede cambiar. No es necesaria ninguna importación: las listas forman parte de la biblioteca estándar de Kotlin y se importan automáticamente;
  • Línea 8: el número de personas, como propiedad calculada;
  • Líneas 12–16: el método [plus] define el operador [+] para la operación [l + p], donde [l] es de tipo [ListOfPersons] y [p] es de tipo [Person] o de una clase derivada. Crea una nueva lista (línea 13), copia en ella las personas de la lista actual (línea 14) y luego agrega la persona [p] (línea 15). Como ocurre con el operador [+] para números o cadenas, los operandos no se modifican. Dado que la lista [result] es de la misma clase, el método tiene acceso a su propiedad privada [result.persons]. La lista devuelta es de tipo [ListOfPersons], lo que permite encadenar operaciones como en [l + p1 + p2];
  • líneas 20–21: el método [plusAssign] define el operador [+=]: modifica la lista actual agregándole la persona [p] y no devuelve nada;
  • línea 25: el método [contains] define el operador [in]: ["leduc" in l] se traduce a [l.contains("leduc")]. Aquí el parámetro es un nombre; es el método [indexOf], que se trata en el párrafo siguiente, el que busca a la persona;
  • línea 28: el método [iterator] permite recorrer la lista con un bucle [for (p in l)]. Mantiene privado el iterador de la lista, de tipo [Iterator<Person>], que solo permite acceso de lectura a los elementos;
  • línea 54: redefinimos el método [toString] para mostrar una lista de personas en la forma (persona1, persona2, ...), donde personai es a su vez el resultado del método [toString] de la persona. El método [joinToString(separator, prefix, postfix)] de las listas construye una cadena a partir de los elementos sucesivos (convertidos en cadenas mediante su método [toString]), separándolos con el separador indicado (aquí, una coma) y encerrándolos entre un prefijo y un sufijo (aquí, paréntesis).

Observe que la clase [ListOfPersons] no tiene constructor. Por lo tanto, utiliza el constructor por defecto, que no recibe parámetros y solo inicializa la propiedad [persons] con el valor indicado en su declaración. Las líneas 30–50 se tratan en la sección siguiente.

El programa de prueba [Main.kt] comienza así:

package lists

import java.math.BigDecimal

fun main() {
    // - los operadores de las cadenas y de los números BigDecimal
    val s1 = "jean"
    val s2 = StringBuilder("je").append("an").toString()
    println("s1 == s2 : ${s1 == s2}, s1 === s2 : ${s1 === s2}")
    println("s1 < \"paul\" : ${s1 < "paul"}, s1.compareTo(\"paul\") : ${s1.compareTo("paul")}")
    val a = BigDecimal("0.10")
    val b = BigDecimal("0.20")
    println("a + b = ${a + b}, a * b = ${a * b}, -a = ${-a}, a < b : ${a < b}")

    // - el operador compareTo de la clase Person
    val jean = Person("jean", "martin", 10)
    val pauline = Person("pauline", "leduc", 12)
    println("jean < pauline : ${jean < pauline}, jean >= pauline : ${jean >= pauline}")

    // - el operador +
    // una lista de personas
    var l = ListOfPersons()
    // agregar personas
    l = l + jean + pauline
    // visualización
    println("l=$l")
    // l + p devuelve una nueva lista: l no se modifica
    val l2 = l + Person("louis", "durand", 8)
    println("l=$l")
    println("l2=$l2")

    // - el operador +=
    val l3 = l
    // += modifica la lista referenciada por l3 (y por l), sin crear una nueva lista
    l3 += Teacher("camille", "germain", 27, 60)
    println("l=$l")
    // l y l3 siguen referenciando el mismo objeto
    println("l3 === l : ${l3 === l}")

    // - los operadores in y !in, iteración
    println("\"leduc\" in l : ${"leduc" in l}, \"xx\" !in l : ${"xx" !in l}")
    for (p in l) {
        print("${p.firstName} ")
    }
    println("(${l.size} persons)")
  • Líneas 7–10: dos cadenas con el mismo contenido pero distintas: la cadena [s2] se construye en tiempo de ejecución. El operador [] compara los contenidos (llama a [equals]*), mientras que el operador *[=] compara las referencias. Por lo tanto, en Kotlin, dos cadenas se comparan con [==], lo que en Java es un error clásico. El operador [<] compara dos cadenas según el orden de los códigos de sus caracteres: llama al método [compareTo], que aquí devuelve un número negativo porque “jean” va antes que “paul”;
  • Líneas 11–13: la clase [BigDecimal] del JDK (números decimales exactos, que usaremos para los montos) contiene solo métodos: [add], [multiply], [negate], [compareTo]. La biblioteca estándar de Kotlin agrega los operadores unarios [+], [*], [-]…: se escribe [a + b] en lugar de [a.add(b)], y [-a] en lugar de [a.negate()]. Los operadores de comparación, en cambio, usan directamente el método [compareTo] de [BigDecimal]. La importación de la línea 3 es necesaria: [BigDecimal] es una clase del JDK;
  • líneas 16–18: los operadores de comparación definidos por el método [compareTo] de la clase [Person];
  • línea 22: creación de una lista vacía de personas [l]. La variable se declara como [var]: su valor cambiará;
  • línea 24: agrega dos personas con el operador [+], que devuelve una lista nueva cada vez;
  • línea 28: [l + p] crea una lista nueva, [l2]; la lista [l] permanece sin cambios;
  • línea 35: se agrega un profesor con el operador [+=], es decir, el método [plusAssign];
  • línea 41: los operadores [in] y [!in];
  • Líneas 42–45: recorrido de la lista con un bucle [for], mediante el método [iterator] y la propiedad [size];
  • línea 26 y siguientes: una plantilla de cadena que contiene un objeto utiliza el método redefinido [toString] de la clase [ListOfPersons].

Resultados (inicio):

> gradlew -q run -Pmain=lists.MainKt
s1 == s2 : true, s1 === s2 : false
s1 < "paul" : true, s1.compareTo("paul") : -6
a + b = 0.30, a * b = 0.0200, -a = -0.10, a < b : true
jean < pauline : true, jean >= pauline : false
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3 === l : true
"leduc" in l : true, "xx" !in l : true
jean pauline camille (3 persons)

¿Por qué hay dos operadores, si [l = l + p] produce el mismo resultado que [l += p]? El operador [+] crea una lista nueva, copia en ella a todas las personas de [l] y luego [l] se refiere a esta nueva lista, mientras que la anterior se descarta y queda a cargo del recolector de basura. El operador [+=], definido por [plusAssign], agrega la persona a la lista existente sin copiarla. La línea 33 almacena una segunda referencia, [l3], a la lista [l]; después de la operación [l3 += ...], ambas referencias siguen apuntando al mismo objeto (línea 9 de los resultados), y la persona agregada aparece en [l] (línea 8), lo que demuestra que la lista no se volvió a crear. Para una lista grande, o dentro de un bucle, la diferencia de rendimiento es significativa. La elección entre los dos estilos se refleja en la biblioteca: los objetos inmutables [String] y [BigDecimal] devuelven objetos nuevos; las listas mutables y [StringBuilder] se modifican.

¿Por qué se escribió [l3 += ...] y no [l += ...]? Porque [l] es una variable de tipo [var]: para esa variable, [l += p] podría significar tanto [l.plusAssign(p)] como [l = l.plus(p)], y el compilador se niega a elegir:

1
2
3
4
5
Main.kt:35:7: error: ambiguity between assign operator candidates:
fun plus(p: Person): ListOfPersons
fun plusAssign(p: Person): Unit
    l += Teacher("camille", "germain", 27, 60)
      ^^

Con una variable como [val] (o [l3]) solo es posible la primera traducción. En la práctica, una clase define una u otra: [plus] para una clase inmutable, [plusAssign] para una clase mutable. Las listas de Kotlin siguen esta regla: una [List] (de solo lectura) tiene el operador [+], una [MutableList] tiene el operador [+=]; para una [MutableList] referenciada por una variable [var], el compilador informa la misma ambigüedad.

La sobrecarga de operadores no debe abusarse: solo tiene sentido si el operador conserva su significado habitual (suma, comparación, pertenencia, etc.). En los demás casos, es preferible un método con un nombre explícito.

4.4. Indexadores: los operadores get y set

Aquí seguimos utilizando la clase [ListOfPersons]. Si *[l]* es un objeto [ListOfPersons] , queremos poder referirnos a la persona número i de la lista *[l] tanto para leer como para escribir, con la notación de arreglo ***[l[i]]***. C# lo llama indexador. Java no lo permite: la notación [[i]] está reservada para los arreglos en Java, y los métodos se escriben como [get(int i)] y [set(int i, value)]. En Kotlin, estos dos métodos, declarados como [operator], definen la notación [l[i]]: [l[i]] se traduce a [l.get(i)], y [l[i] = p] se traduce a [l.set(i, p)]*. Así es como se usan las listas y los diccionarios de Kotlin como arreglos.

    // los indexadores: list[i] para leer y escribir
    operator fun get(i: Int) = persons[i]

    operator fun set(i: Int, p: Person) {
        persons[i] = p
    }

    // un segundo indexador de lectura: list[lastName] devuelve la persona con ese apellido, o null
    operator fun get(lastName: String): Person? {
        val i = indexOf(lastName)
        return if (i != -1) persons[i] else null
    }

    // posición de la persona con el apellido dado, -1 si no hay ninguna
    fun indexOf(lastName: String): Int {
        for (i in persons.indices) {
            if (persons[i].lastName == lastName) {
                return i
            }
        }
        return -1
    }
  • línea 2: el método [get] devuelve la persona n.º i de la lista privada [persons], que a su vez se identifica por su índice;
  • líneas 4–5: el método [set] le asigna la persona [p];
  • líneas 9–11: un segundo indexador, de solo lectura (no existe el método [set(String, Person)]). El índice no es necesariamente un entero: [l["martin"]] devuelve la persona llamada “martin”, o [null] si esa persona no está en la lista. El tipo del resultado, [Person?], lo indica. Los dos métodos [get] son sobrecargas: el compilador elige según el tipo del índice. Un indexador también puede tener varios parámetros: [m[i, j]] se traduce a [m.get(i, j)];
  • líneas 15–21: también queremos poder obtener la posición en la lista de la persona con un nombre dado, o -1 si esa persona no está en la lista. El nombre [indexOf] es el del método equivalente de las listas y las cadenas. El bucle recorre los índices de la lista ([persons.indices]); los nombres se comparan con el operador [==] (línea 17).

El programa de prueba continúa así:

    // - los indexadores: los operadores get y set
    // cambio del elemento n.º 1
    l[1] = Person("franck", "gallon", 5)
    // visualización del elemento n.º 1
    println("l[1]=${l[1]}")
    // visualización de la lista l
    println("l=$l")
    // búsqueda de personas por su apellido, con indexOf
    val names = arrayOf("martin", "germain", "xx")
    for (name in names) {
        val iname = l.indexOf(name)
        if (iname != -1) {
            println("Person($name)=${l[iname]}")
        } else {
            println("Person($name) does not exist")
        }
    }
    // la misma búsqueda con el indexador l[name]
    for (name in names) {
        println("l[\"$name\"]=${l[name] ?: "does not exist"}")
    }
}
  • línea 3: llamada al método [set];
  • línea 5: llamada al método [get];
  • línea 11: llamada al método [indexOf];
  • línea 13: llamada al método [get] con un índice entero;
  • línea 20: llamada al método [get] con un nombre. El operador [?:] reemplaza el resultado [null] por un mensaje.

Resultados (final):

1
2
3
4
5
6
7
8
9
...
l[1]=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist
l["martin"]=[jean, martin, 10]
l["germain"]=Teacher[[camille, germain, 27],60]
l["xx"]=does not exist

4.5. Valor y referencia

4.5.1. Tipos básicos y clases

Otros lenguajes, como C o C#, ofrecen estructuras además de clases: tipos cuyas variables contienen directamente los datos, en lugar de una referencia a un objeto. Java no las tiene: distingue entre los ocho tipos primitivos ([int], [double], [boolean]…), cuyas variables contienen el valor mismo, y los tipos de referencia (clases, arreglos…), cuyas variables contienen una referencia a un objeto. Kotlin tampoco tiene estructuras y, desde el punto de vista del programador, ni siquiera tiene tipos primitivos: todo es un objeto; [Int], [Double] y [Boolean] son clases cuyos métodos ([10.toString()], [age.coerceAtLeast(0)]) se pueden llamar. Pero, como vimos en el capítulo anterior, el compilador traduce los tipos básicos [Int], [Long], [Double], [Boolean], [Char]… a los tipos primitivos de la JVM ([int], [long]…) siempre que sea posible: una variable [Int] contiene entonces el valor mismo. El programa [Classes14.kt] pone de relieve la diferencia con una clase:

// tipos y clases básicos: copia de valor, copia de referencia
package classes14

fun main() {
    // dos variables de tipo Int
    val age1 = 10
    var age2 = age1
    println("age1=$age1, age2=$age2")
    // age2 se modifica
    age2 = 30
    // verificación de age1 y age2
    println("age1=$age1, age2=$age2")

    // un objeto op1
    val op1 = CPerson()
    op1.name = "paul"
    op1.age = 10
    println("op1=CPerson(${op1.name},${op1.age})")
    // un objeto op2
    val op2 = op1
    println("op2=CPerson(${op2.name},${op2.age})")
    // op2 se modifica
    op2.name = "nicole"
    op2.age = 30
    // verificación de op1 y op2
    println("op1=CPerson(${op1.name},${op1.age})")
    println("op2=CPerson(${op2.name},${op2.age})")

    // una copia explícita del objeto
    val op3 = CPerson()
    op3.name = op1.name
    op3.age = op1.age
    op3.age = 50
    println("op1=CPerson(${op1.name},${op1.age})")
    println("op3=CPerson(${op3.name},${op3.age})")
}

// clase CPerson: dos propiedades públicas modificables
class CPerson {
    var name = ""
    var age = 0
}
  • líneas 39–41: una clase con dos propiedades públicas y mutables: [name], [age].

Resultados:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=classes14.Classes14Kt
age1=10, age2=10
age1=10, age2=30
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)
op1=CPerson(nicole,30)
op3=CPerson(nicole,50)

La declaración [val age1 = 10] (línea 6) reserva una ubicación de memoria que contiene el entero 10: el valor de [age1] es el entero mismo. En el caso de la clase, el objeto ([name], [age]) se crea explícitamente llamando al constructor [CPerson()] (línea 15). El objeto se coloca en una zona de memoria administrada por el recolector de basura, el heap, y el valor de [op1] es la dirección (la referencia) de este objeto.

Cuando se escribe [var age2 = age1] en el programa (línea 7), el valor de [age1] (el entero 10) se copia en [age2]: es una copia de valor. Modificar [age2] no modifica [age1] (línea 2 de los resultados). Consideremos ahora la instrucción [val op2 = op1] (línea 20). El valor de [op1] se copia en [op2], pero como ese valor es la dirección del objeto, el objeto en sí no se duplica: [op1] y [op2] se refieren al mismo objeto. Si se modifica el objeto al que apunta [op2], el objeto al que apunta [op1] también se modifica, ya que son el mismo (líneas 5–6 de los resultados). Para obtener un segundo objeto, hay que crearlo y copiar en él las propiedades del primero (líneas 30–32): modificar la copia no modifica el original (líneas 7–8 de los resultados).

Image

De estas explicaciones podemos concluir que:

  • el valor de una variable de un tipo básico ([Int], [Double]…) es el dato mismo;
  • el valor de una variable de un tipo de clase es la dirección del objeto al que apunta;
  • la asignación y el paso de parámetros siempre copian el valor de la variable: el dato, en el caso de un tipo básico; la referencia, en el caso de un objeto.

El compilador no siempre puede usar un tipo primitivo de la JVM. Una variable de tipo [Int?] debe poder contener un valor [null], lo que un [int] no puede hacer, y un elemento de una lista [List<Int>] debe ser un objeto (los genéricos de la JVM solo aceptan tipos de referencia; véase más adelante): en estos casos, el entero se coloca dentro de un objeto [java.lang.Integer], lo que Java llama “autoboxing”. El programador de Kotlin no necesita preocuparse por esto, con una excepción: no debe comparar dos números con el operador [===], que compararía las referencias de los objetos [Integer]. Para ello, el compilador emite una advertencia ([identity equality for arguments of types 'Int?' and 'Int?' is prohibited]). Los números se comparan con [==], que siempre compara los valores.

Para representar un tipo de dato compuesto simple (un punto, un color, una fecha, un monto) que se trata como un valor, se utilizan clases inmutables: sus objetos no pueden modificarse después de su creación. Compartir una referencia a un objeto inmutable es seguro: nadie puede modificarlo, y el objeto se comporta entonces como un valor. Dos herramientas completan el sistema: el método [equals], al que llama el operador [==], que compara dos objetos por su contenido, y las clases de datos ([data class]), que declaran en una sola línea una clase inmutable provista de este método. Este es el tema de los dos párrafos siguientes.

4.5.2. Igualdad de dos objetos: equals y hashCode

Como hemos visto, el operador [===], aplicado a dos referencias, indica si estas se refieren al mismo objeto. El operador [] llama al método [equals], y el heredado de [Any]* hace lo mismo que *[=]. Para que dos objetos distintos con el mismo contenido se consideren iguales, una clase debe redefinir el método [equals] y, necesariamente junto con él, el método [hashCode]. El programa [Classes15.kt] lo demuestra:

// igualdad de dos objetos: equals y hashCode
package classes15

import java.util.Objects

fun main() {
    val p1 = Person("paul", 10)
    val p2 = Person("paul", 10)
    val p3 = Person("nicole", 30)
    // === compara referencias, == compara valores (método equals)
    println("p1 === p2 : ${p1 === p2}, p1 == p2 : ${p1 == p2}, p1 == p3 : ${p1 == p3}")
    // dos objetos iguales tienen el mismo código hash
    println("p1.hashCode() == p2.hashCode() : ${p1.hashCode() == p2.hashCode()}")
    // un conjunto (Set) no contiene dos objetos iguales
    val persons = hashSetOf(p1, p2, p3)
    println("size of the set: ${persons.size}")
    println("the set contains (paul,10): ${Person("paul", 10) in persons}")
    // el operador == acepta el valor null
    val unknown: Person? = persons.find { it.name == "pierre" }
    println("unknown == p1 : ${unknown == p1}, unknown == null : ${unknown == null}")
}

class Person(val name: String, val age: Int) {
    // dos personas son iguales si tienen el mismo nombre y la misma edad
    override fun equals(other: Any?): Boolean {
        // ¿el mismo objeto?
        if (this === other) {
            return true
        }
        // ¿other es una Person (y no es null)?
        if (other !is Person) {
            return false
        }
        // comparación de las propiedades: ahora se sabe que other es una Person
        return age == other.age && name == other.name
    }

    // código hash coherente con equals
    override fun hashCode() = Objects.hash(name, age)

    override fun toString() = "Person($name,$age)"
}
  • líneas 25–35: el método [equals] redefine el de la clase [Any]. Su parámetro es de tipo [Any?]: una persona puede compararse con cualquier objeto, e incluso con [null]. El método sigue un patrón estándar:
    • líneas 27–28: un objeto es igual a sí mismo;
    • líneas 31–32: la expresión [other !is Person] es verdadera si [other] no referencia a un objeto de tipo [Person] (o de una clase derivada), en particular si es igual a [null]. En ese caso se devuelve [false];
    • línea 35: se comparan las propiedades. Después de la prueba de la línea 31, el compilador sabe que [other] es una [Person]: [other.age] puede usarse sin conversión. Este es el “smart cast” que ya encontramos con la expresión [when]. Los nombres se comparan con [==], que llama al método [equals] de las cadenas;
  • línea 39: el método [hashCode] devuelve un entero calculado a partir de las mismas propiedades, en este caso mediante el método [Objects.hash] del JDK (de ahí la importación de la línea 4). La regla es obligatoria: dos objetos que son iguales en el sentido de [equals] deben tener el mismo código hash. Los diccionarios y los conjuntos (próximo capítulo) organizan los objetos según este código y dejarían de funcionar si no se respetara la regla;
  • línea 11: [===] compara referencias, mientras que [==] compara contenidos. En Java escribiríamos [p1.equals(p2)]; en Kotlin escribimos [p1 == p2], que es más legible;
  • líneas 15–17: un conjunto [HashSet], creado por la función [hashSetOf], nunca contiene dos objetos iguales: agregar [p2], que es igual a [p1], no tiene ningún efecto, y la búsqueda de una nueva persona ([paul, 10]) con el operador [in] tiene éxito;
  • líneas 19–20: la función [find] de las colecciones devuelve el primer elemento que cumple la condición dada por la lambda, o [null] si no hay ninguno (las lambdas se tratan en el capítulo 7). Por lo tanto, la variable [unknown] es igual a [null]. El operador [==] acepta un operando [null]: [a == b] se traduce a [a?.equals(b) ?: (b === null)]. No hay que preocuparse por una excepción [NullPointerException], a diferencia de la llamada de Java [a.equals(b)] cuando [a] es igual a [null].

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=classes15.Classes15Kt
p1 === p2 : false, p1 == p2 : true, p1 == p3 : false
p1.hashCode() == p2.hashCode() : true
size of the set: 2
the set contains (paul,10): true
unknown == p1 : false, unknown == null : true

Escribir [equals] y [hashCode] a mano es tedioso y propenso a errores; IntelliJ IDEA puede generarlos (mediante el menú “Code / Generate…”). Las clases de datos, en cambio, los proporcionan automáticamente.

4.5.3. Objetos inmutables

El programa [Classes16.kt] ofrece tres formas de definir datos inmutables:

// objetos inmutables: una clase inmutable, una data class, una value class
package classes16

fun main() {
    val a = Point(1, 2)
    // a.x = 5   // rechazado: x es una propiedad val
    val b = a.move(3, 4)
    println("a=$a, b=$b")

    // una data class: se generan toString, equals, hashCode, copy...
    val red = Color(255, 0, 0)
    val red2 = Color(255, 0, 0)
    println("red=$red, r=${red.r}")
    println("red == red2 : ${red == red2}, red === red2 : ${red === red2}")
    // una copia modificada: el método copy y los argumentos con nombre
    val pink = red.copy(g = 128, b = 128)
    println("red=$red, pink=$pink")
    // desestructuración de un objeto de una data class
    val (r, g, blue) = pink
    println("r=$r, g=$g, b=$blue")

    // una value class: un Int envuelto y verificado
    val age = Age(30)
    println("age=$age, age.value + 1 = ${age.value + 1}")
    try {
        val age2 = Age(-4)
        println("age2=$age2")
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
}

// una clase inmutable: propiedades val, sin setter; es final por defecto
class Point(val x: Int, val y: Int) {
    // no modificamos el punto: devolvemos uno nuevo
    fun move(dx: Int, dy: Int) = Point(x + dx, y + dy)

    override fun toString() = "($x,$y)"
}

// una data class: una clase inmutable declarada en una línea
data class Color(val r: Int, val g: Int, val b: Int)

// una value class: en tiempo de ejecución, un objeto Age es casi siempre un simple int
@JvmInline
value class Age(val value: Int) {
    init {
        require(value >= 0) { "invalid age ($value)" }
    }
}
  • líneas 34–38: una clase inmutable escrita a mano. Sus propiedades son de solo lectura ([val]); es final (como todas las clases de Kotlin por defecto), de modo que ninguna clase derivada pueda agregarle estado mutable. Para “mover” un punto, el método [move] devuelve un punto nuevo (línea 36). La instrucción [a.x = 5] (línea 6) sería rechazada por el compilador: ['val' cannot be reassigned];
  • línea 42: una clase de datos ([data class]). El encabezado [data class Color(val r: Int, val g: Int, val b: Int)] declara una clase con tres propiedades, un constructor de tres parámetros y los métodos [toString], [equals] y [hashCode], todos los cuales usan las propiedades del constructor primario, así como los métodos [copy] y [component1], [component2] y [component3], que se presentan más adelante. Es el equivalente en Kotlin del record de Java, que apareció mucho después; como las propiedades se declaran con [val], la clase es inmutable;
  • línea 13: se accede a una propiedad por su nombre, [red.r];
  • línea 14: dos objetos con el mismo contenido son iguales en el sentido de [==], aunque sean distintos;
  • línea 16: como una clase de datos es inmutable, no puede modificarse; en su lugar, se crea una copia en la que se han cambiado ciertas propiedades. Este es el papel del método generado [copy], donde el valor por defecto de cada parámetro es el valor actual de la propiedad: con argumentos con nombre, solo se especifican las propiedades que cambian. En Java, hay que escribir a mano métodos “wither” ([withG(int g)]…) para lograr el mismo resultado;
  • línea 19: desestructuración, como se vio en el capítulo anterior con los pares: las tres variables reciben los valores de las tres propiedades, en el orden indicado por el constructor. Esto se basa en los métodos generados [component1], [component2] y [component3]. Los nombres de las variables pueden elegirse libremente: escribimos [blue] porque [b] ya está en uso;
  • líneas 45–48: una clase de valor ([value class]), anotada con [@JvmInline]. Tiene una sola propiedad (en este caso, un entero) que “envuelve” para darle su propio tipo y sus propias reglas de validación: una [Age] no es simplemente un [Int]; una función que espera una *[Age] no aceptará un peso ni un número de hijos, y una edad negativa es rechazada por el bloque *[init] (línea 26). La ventaja de la clase de valor es que, en tiempo de ejecución, el compilador normalmente la reemplaza por el valor envuelto: una variable de tipo [Age] es simplemente un [int] de la JVM, sin que se cree ningún objeto en el heap. Esto ofrece la seguridad de un tipo distinto sin su costo. Una clase de valor es inmutable; tiene [toString], [equals] y [hashCode] generados, igual que una clase de datos.

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=classes16.Classes16Kt
a=(1,2), b=(4,6)
red=Color(r=255, g=0, b=0), r=255
red == red2 : true, red === red2 : false
red=Color(r=255, g=0, b=0), pink=Color(r=255, g=128, b=128)
r=255, g=128, b=128
age=Age(value=30), age.value + 1 = 31
invalid age (-4)

El método [toString] generado para una clase de datos muestra el nombre de la clase y sus propiedades (línea 2 de los resultados); lo mismo ocurre con la clase de valor (línea 6). Observe aquí que una clase de datos es la forma más concisa de declarar un dato pequeño e inmutable: este es el tipo que usaremos para los tramos del impuesto en la aplicación de ejemplo de este capítulo. Las clases de datos se tratan en detalle más adelante.

4.6. Interfaces

4.6.1. Un primer ejemplo

Una interfaz es un conjunto de declaraciones de métodos (y, en Kotlin, de propiedades) que forma un contrato. Una clase que decide implementar una interfaz se compromete a proporcionar una implementación para todos los miembros abstractos definidos en la interfaz. El compilador verifica esta implementación.

Por ejemplo, esta es la definición (simplificada) de la interfaz [Iterator<T>] de la biblioteca estándar de Kotlin, que permite recorrer los elementos de una colección: [interface Iterator<out T> { operator fun next(): T; operator fun hasNext(): Boolean }]. Los métodos de la interfaz se definen solo por sus firmas: no tienen cuerpo y son implícitamente públicos y abstractos (la palabra clave [out] se explicará en la sección sobre genéricos; la palabra clave [operator] indica que el bucle [for] puede usar estos métodos). Son las clases que implementan la interfaz las que proporcionan el código de sus métodos. Una clase llamada [C] declara que implementa la interfaz enumerándola después de los dos puntos, igual que una clase padre pero sin paréntesis (una interfaz no tiene constructor): [class C : Iterator<String>], y debe entonces definir los dos métodos [override fun hasNext(): Boolean { ... }] y [override fun next(): String { ... }]. Mientras que Java distingue entre [extends] (herencia) e [implements] (implementación), Kotlin, al igual que C#, utiliza los mismos dos puntos; la palabra clave [override] es obligatoria para implementar un miembro de una interfaz, igual que para redefinir un método de la clase padre.

Una convención común (aunque no universal; ni el JDK ni la biblioteca de Kotlin la siguen) es comenzar el nombre de una interfaz con la letra I. Los siguientes ejemplos conforman el paquete [statistics] (directorio [src/main/kotlin/statistics]). Consideremos la siguiente interfaz [IStats.kt]:

package statistics

// las estadísticas de una serie de valores
interface IStats {
    // promedio de la serie: una propiedad abstracta
    val average: Double

    // desviación estándar de la serie
    val standardDeviation: Double
}

La interfaz [IStats] tiene:

  • una propiedad [average]: la media de una serie de valores;
  • una propiedad [standardDeviation]: la desviación estándar de esta serie.

Observe que en ninguna parte se especifica a qué serie de valores se refiere. Podrían ser las notas promedio de una clase, las ventas mensuales promedio de un producto determinado, la temperatura promedio en un lugar dado… Este es el principio de las interfaces: suponen la existencia de miembros en el objeto, pero no la de datos específicos.

Mientras que la interfaz de Java declaraba dos métodos, [double average()] y [double standardDeviation()], la interfaz de Kotlin declara dos propiedades abstractas, [val average: Double] y [val standardDeviation: Double]. Una propiedad de una interfaz no dice nada sobre cómo se obtiene el valor: una clase de implementación puede almacenarlo en un campo, calcularlo cada vez que se lee mediante un descriptor de acceso *[get]*, o calcularlo en la primera lectura y luego almacenarlo. Esto se demuestra con las dos clases siguientes. Una propiedad [val] de una interfaz promete solo acceso de lectura; una propiedad [var] prometería además acceso de escritura.

Una posible implementación de la interfaz [IStats] podría ser una clase utilizada para almacenar las notas de los estudiantes de una clase en una materia determinada. Un estudiante se caracteriza por la siguiente clase de datos [Student]: [Student.kt]:

1
2
3
4
package statistics

// un estudiante
data class Student(val firstName: String, val lastName: String)

El estudiante se identifica por su nombre y apellido. La clase de datos, introducida anteriormente (en la sección “Objetos inmutables”) y tratada en detalle más adelante, puede resumirse en una sola línea: reemplaza al record de la versión en Java. Una nota se representa mediante la siguiente clase de datos: [Grade] [Grade.kt]:

1
2
3
4
5
6
package statistics

// la nota de un estudiante
data class Grade(val student: Student, val value: Double) {
    override fun toString() = "[${student.firstName},${student.lastName},$value]"
}

La nota se define por el estudiante evaluado y la nota en sí. La clase redefine el método [toString] generado por el compilador para mostrar una nota con la forma [firstName,lastName,value]. Observe la forma [fun f() = expression]: una función cuyo cuerpo consiste en una sola expresión puede escribirse con el símbolo [=], sin llaves ni [return], en cuyo caso el tipo del resultado se infiere de la expresión.

Las notas de todos los estudiantes de una materia determinada se recopilan en la siguiente clase [ArrayOfGrades]:

package statistics

import kotlin.math.pow
import kotlin.math.sqrt

// notas almacenadas en un arreglo, fijadas en la construcción
class ArrayOfGrades(val subject: String, val grades: Array<Grade>) : IStats {
    // implementación de las propiedades de la interfaz IStats:
    // el promedio y la desviación estándar se calculan una sola vez, en la construcción
    override val average: Double =
        if (grades.isNotEmpty()) grades.sumOf { it.value } / grades.size else -1.0

    override val standardDeviation: Double =
        if (grades.isNotEmpty()) sqrt(grades.sumOf { (it.value - average).pow(2) } / grades.size) else -1.0

    override fun toString() = "subject=$subject, grades=${grades.contentToString()}"
}
  • Línea 7: la clase [ArrayOfGrades] implementa la interfaz [IStats], indicada después de los dos puntos. Por lo tanto, debe implementar las propiedades [average] y [standardDeviation]. Su constructor primario declara dos propiedades de solo lectura: la materia en la que el objeto almacena las notas y el arreglo de notas;
  • líneas 10–14: la implementación de las dos propiedades de la interfaz, precedidas de la palabra clave [override]. Aquí suponemos que las notas pasadas al constructor no cambiarán después. Por lo tanto, la media y la desviación estándar de estas notas se calculan de inmediato y se almacenan en los campos de las propiedades: los inicializadores de las propiedades se ejecutan cuando se construye el objeto, en el orden en que están escritos, lo que permite que el cálculo de la desviación estándar use la media ya calculada. En Java habrían hecho falta cuatro campos ([final]) y un constructor para obtener el mismo resultado;
  • línea 11: [if] es una expresión de Kotlin: reemplaza al operador de Java [condition ? value1 : value2] y establece la media de un arreglo vacío en -1. La función de extensión [sumOf] para arreglos y colecciones suma los valores que la lambda [{ it.value }] calcula para cada elemento (las lambdas se tratan en el capítulo 7; [it] se refiere allí al elemento actual): reemplaza al bucle acumulativo [for] de la versión en Java;
  • línea 14: [x.pow(2)] calcula x², y [sqrt] calcula la raíz cuadrada. Estas son funciones del paquete [kotlin.math], importado en las líneas 3–4; reemplazan a los métodos estáticos [Math.pow] y [Math.sqrt] de Java (que siguen siendo utilizables);
  • línea 16: el método [toString] utiliza la función de extensión de arreglos [contentToString], que devuelve los elementos del arreglo entre corchetes y separados por comas, con cada elemento convertido en cadena mediante su método [toString], aquí el de la clase [Grade]. Esto equivale al método estático [Arrays.toString] de Java. El método [toString] de un arreglo de Kotlin, como el de un arreglo de Java, muestra solo su tipo y un código hash.

En la clase anterior, las notas se almacenaban en un arreglo. No era posible agregar una nueva nota después de construido el objeto [ArrayOfGrades]. Proponemos ahora una segunda implementación de la interfaz [IStats], llamada [ListOfGrades], donde esta vez las notas se almacenan en una lista, con la posibilidad de agregar notas después de la construcción inicial de los objetos [ListOfGrades] y [ListOfGrades.kt] :

package statistics

import kotlin.math.pow
import kotlin.math.sqrt

// notas almacenadas en una lista, a la que se pueden agregar notas
class ListOfGrades(val subject: String, grades: List<Grade>) : IStats {
    // la lista mutable privada: una copia de la lista recibida
    private val _grades = grades.toMutableList()

    // la vista pública de solo lectura de esta lista
    val grades: List<Grade>
        get() = _grades

    // promedio y desviación estándar en caché (null: aún no calculados)
    private var averageCache: Double? = null
    private var standardDeviationCache: Double? = null

    // agregar una nota
    fun add(grade: Grade) {
        _grades.add(grade)
        // el promedio y la desviación estándar tendrán que recalcularse
        averageCache = null
        standardDeviationCache = null
    }

    // promedio de las notas: se calcula en la primera solicitud
    override val average: Double
        get() = averageCache ?: computeAverage().also { averageCache = it }

    // desviación estándar de las notas: se calcula en la primera solicitud
    override val standardDeviation: Double
        get() = standardDeviationCache ?: computeStandardDeviation().also { standardDeviationCache = it }

    private fun computeAverage(): Double =
        if (_grades.isEmpty()) -1.0 else _grades.sumOf { it.value } / _grades.size

    private fun computeStandardDeviation(): Double {
        if (_grades.isEmpty()) return -1.0
        val m = average
        return sqrt(_grades.sumOf { (it.value - m).pow(2) } / _grades.size)
    }

    override fun toString() = "subject=$subject, grades=$_grades"
}
  • Línea 7: la clase [ListOfGrades] implementa la interfaz [IStats]. El parámetro del constructor [grades] no está precedido de [val]: es un simple parámetro que sirve solo para inicializar la propiedad de la línea 9;
  • Línea 9: las notas se colocan ahora en una lista mutable ([MutableList<Grade>]), una copia de la lista recibida mediante la función de extensión [toMutableList]. Kotlin distingue entre colecciones de solo lectura ([List]) y colecciones mutables ([MutableList]); la copia garantiza que quien llama no pueda modificar a nuestras espaldas la lista almacenada por el objeto (véase el capítulo 5);
  • líneas 12–13: la lista se expone con el tipo [List<Grade>], que es de solo lectura: el código externo puede leer las notas pero no puede agregar nuevas sin llamar al método [add]. Este par formado por una propiedad privada [_grades] y una propiedad pública [grades] de un tipo más restringido es un modismo común de Kotlin conocido como “propiedad de respaldo” (backing property);
  • líneas 20–24: ahora podemos agregar una nota a las ya almacenadas. La media y la desviación estándar ya no se calculan en el momento de la construcción, sino bajo demanda, dentro de los descriptores de acceso de las propiedades de la interfaz: [average] (líneas 28–29) y [standardDeviation] (líneas 32–33). Una vez calculados, estos valores se almacenan para no recalcularlos en cada consulta: se dice que están en caché. Agregar una nota invalida la caché;
  • líneas 16–17: la caché. Su tipo, [Double?], es un tipo anulable (capítulo 3): el valor [null] significa “aún no calculado”. Mientras que Java usaba la clase envoltorio *[Double] para poder tener el valor *[null], Kotlin simplemente agrega un signo de interrogación al tipo;
  • Línea 29: el descriptor de acceso se lee así: el valor en caché si no es [null] (operador Elvis [?:]), y en caso contrario el resultado de ***[computeAverage()]***, que la función *[also] almacena en la caché antes de devolverlo. [x.also { ... }] ejecuta el bloque con [it = x] y luego devuelve [x]: sirve para injertar una acción secundaria (en este caso, el almacenamiento en caché) en una expresión. El compilador sabe que el resultado de la expresión nunca es [null]: es de tipo [Double]*, como lo exige la interfaz;
  • líneas 35–41: los dos cálculos, escritos con [sumOf]. Observe, en la línea 39, el estilo de “salida anticipada”: la función devuelve -1 de inmediato si la lista está vacía;
  • línea 44: el método [toString] de una lista muestra sus elementos entre corchetes, sin necesidad de una función especial.

Un programa de prueba podría tener el siguiente aspecto [Main.kt]:

package statistics

fun main() {
    // algunos estudiantes y sus notas de inglés
    val students = arrayOf(Student("Paul", "Martin"), Student("Maxime", "Germain"), Student("Berthine", "Samin"))
    val grades = arrayOf(Grade(students[0], 14.0), Grade(students[1], 16.0), Grade(students[2], 18.0))
    // que se registran en un objeto ArrayOfGrades
    val english = ArrayOfGrades("English", grades)
    // visualización del promedio y la desviación estándar
    displayStats(english)
    // las mismas notas en un objeto ListOfGrades
    val french = ListOfGrades("French", grades.toList())
    displayStats(french)
    // agregamos una nota
    french.add(Grade(Student("Jérôme", "Jaric"), 10.0))
    displayStats(french)
    // una variable puede tener una interfaz como tipo
    var stats: IStats = english
    println("English average: ${stats.average}")
    stats = french
    println("French average: ${stats.average}")
}

// visualización del promedio y la desviación estándar de un objeto que implementa IStats
fun displayStats(values: IStats) {
    println("$values, Average=${values.average}, Standard deviation=${values.standardDeviation}")
}
  • línea 5: crea un arreglo de estudiantes con la función [arrayOf];
  • línea 6: creación de un arreglo de notas. Las notas se escriben como [14.0], no como [14]: Kotlin no convierte implícitamente un [Int] en un [Double], y el constructor de [Grade] espera un [Double];
  • línea 8: un objeto [ArrayOfGrades] cuya media y desviación estándar se muestran en la línea 10;
  • línea 12: un objeto [ListOfGrades], cuya media y desviación estándar se muestran en la línea 13. La función de extensión [toList] convierte el arreglo en una lista; la clase [ListOfGrades] crea una copia modificable de ella. En Java, habría que escribir [new ArrayList<>(List.of(grades))];
  • línea 15: agrega una nueva nota y luego actualiza la visualización;
  • Líneas 25–26: la función [displayStats] recibe como parámetro un tipo [IStats], que es un tipo de interfaz. Esto significa que el parámetro real puede ser cualquier objeto que implemente la interfaz [IStats]. Al usar un objeto de dato de un tipo de interfaz, solo se utilizan los miembros de la interfaz implementados por ese objeto. El resto se ignora. Esta propiedad es similar al polimorfismo que vimos con las clases. Si un conjunto de clases Ci que no están relacionadas entre sí por herencia (y que, por lo tanto, no pueden usar el polimorfismo basado en la herencia) tiene un conjunto de métodos con la misma firma, puede ser útil agrupar esos métodos en una interfaz I que todas las clases pertinentes implementarían. Las instancias de estas clases Ci pueden entonces usarse como parámetros reales de funciones que aceptan un parámetro formal de tipo I, es decir, funciones que usan solo los miembros de los objetos Ci definidos en la interfaz I, y no las propiedades y métodos específicos de las distintas clases Ci;
  • líneas 18–21: una variable puede ser del tipo de una interfaz. Puede entonces referirse a cualquier objeto de una clase que implemente la interfaz. El compilador solo permite acceder a los miembros de la interfaz (y a los de la clase *[Any]*, como [toString]*). Aquí hay que especificar el tipo; sin él, el compilador habría inferido el tipo [ArrayOfGrades]* a partir del valor inicial, y la asignación de la línea 20 habría sido rechazada.

El paquete contiene dos funciones de nivel superior, [main] y [displayStats], definidas en el archivo [Main.kt]: la clase de la JVM que las contiene se llama, por lo tanto, [statistics.MainKt].

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=statistics.MainKt
subject=English, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=French, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=French, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0], [Jérôme,Jaric,10.0]], Average=14.5, Standard deviation=2.958039891549808
English average: 16.0
French average: 14.5

En una plantilla de cadena, un número [Double] se convierte en cadena mediante el método [Double.toString] de la JVM, que siempre escribe el número con un punto decimal y al menos un decimal (16.0), independientemente del idioma de la estación de trabajo. Para una presentación al estilo francés, utilice ["%.2f".format(x)], como en el ejemplo siguiente.

Por último, observe que las interfaces pueden implementarse varias veces; es decir, se puede escribir [class DerivedClass : BaseClass(), I1, I2, ..., In], donde las Ij son interfaces: una clase hereda de una sola clase (cuyo constructor se llama, de ahí los paréntesis), pero puede implementar tantas interfaces como desee. Una interfaz puede a su vez heredar de una o varias otras interfaces: [interface I3 : I1, I2].

4.6.2. Métodos de interfaz con cuerpo

Una interfaz de Kotlin puede proporcionar una implementación por defecto para algunos de sus métodos: basta con darles un cuerpo, sin ninguna palabra clave específica (Java requiere la palabra clave [default]). Una clase que implementa la interfaz puede entonces usar esta implementación o proporcionar la suya. Esto permite, por ejemplo, agregar un método a una interfaz ya publicada sin obligar a modificar todas las clases que la implementan. Una propiedad de una interfaz puede tener igualmente un descriptor de acceso por defecto [get]. Una interfaz también puede contener funciones privadas. Sin embargo, Kotlin no tiene miembros estáticos ([static]), ni en las interfaces ni en las clases: su función la cumple el objeto complementario ([companion object]), tratado anteriormente, que una interfaz puede tener igual que una clase. El programa [Classes17.kt] proporciona un ejemplo:

package classes17

import kotlin.math.PI

// interfaces: métodos con cuerpo por defecto, miembros "estáticos" (companion object),
// funciones privadas, implementación de varias interfaces
fun main() {
    val shapes = arrayOf(Square(2.0), Circle(1.0), IShape.unitSquare())
    for (shape in shapes) {
        println(shape.description())
    }
    // la clase Square hereda el método por defecto
    val square = Square(3.0)
    println(square.description())
    // una clase que implementa dos interfaces
    val redSquare = ColoredSquare(1.5, "red")
    println(redSquare.description())
    println("name=${redSquare.name}, color=${redSquare.color}")
}

interface IShape {
    // método abstracto: debe implementarse
    fun area(): Double

    // método con una implementación por defecto
    fun description(): String = "${this::class.simpleName} of area ${formatNumber(area())}"

    // propiedad con un getter por defecto (una interfaz no tiene campo de respaldo)
    val name: String
        get() = "shape"

    // función privada: solo la pueden usar los métodos de la interfaz
    private fun formatNumber(value: Double) = "%.2f".format(value)

    // el companion object de la interfaz: sus miembros se llaman con el nombre de la interfaz
    companion object {
        fun unitSquare(): IShape = Square(1.0)
    }
}

// Square usa la implementación por defecto de description
open class Square(private val side: Double) : IShape {
    override fun area() = side * side
}

// Circle proporciona su propia implementación de description
class Circle(private val radius: Double) : IShape {
    override fun area() = PI * radius * radius

    override fun description() = "Circle of radius %s and area %.2f".format(radius, area())
}

// una segunda interfaz, que también tiene un método description por defecto
interface IColored {
    // propiedad abstracta: debe implementarse
    val color: String

    fun description(): String = "$color object"
}

// una clase derivada de Square que también implementa IColored:
// hereda dos métodos description y por lo tanto debe sobrescribirlo
class ColoredSquare(side: Double, override val color: String) : Square(side), IColored {
    override fun description() = "${super<Square>.description()}, ${super<IColored>.description()}"

    override val name = "colored square"
}
  • líneas 21–37: la interfaz [IShape]:
    • línea 23: un método abstracto [area], que debe implementarse;
    • línea 26: un método [description] con una implementación por defecto. Esta implementación puede usar los otros métodos de la interfaz ([area], [formatNumber]). La expresión [this::class.simpleName] devuelve el nombre simple de la clase del objeto ([Square]): [this::class] es la clase de Kotlin ([KClass]) del objeto, equivalente a [getClass()] en Java;
    • líneas 29–30: una propiedad con un descriptor de acceso por defecto. Una interfaz no tiene estado: no puede almacenar un valor y, por lo tanto, una propiedad de interfaz nunca tiene un campo. O es abstracta o se calcula mediante un descriptor de acceso;
    • línea 33: una función privada, accesible solo para los métodos de la interfaz. ["%.2f".format(value)] formatea el número con dos decimales, siguiendo las convenciones de la configuración regional del sistema (en este caso, la coma decimal francesa). La función de extensión de cadenas [format] es el equivalente en Kotlin de [String.format];
    • líneas 36–37: el objeto complementario de la interfaz. Su método [unitSquare] se llama usando el nombre de la interfaz: [IShape.unitSquare()] (línea 8), igual que el método estático de la versión en Java. Es una fábrica;
  • Líneas 42–43: la clase [Square] solo implementa [area]; utiliza por defecto el método [description]. Se declara como [open] porque más adelante otra clase hereda de ella. En Java, la clase [Square] habría tenido que declararse como [static] porque la interfaz crea cuadrados; en Kotlin, todas las clases declaradas en un archivo son de nivel superior, por lo que este problema no se presenta;
  • Líneas 47–50: la clase [Circle] proporciona su propio método [description]. El formato [%s] inserta el radio convertido en cadena por [Double.toString] (“1.0”), mientras que el formato [%.2f] inserta el área con dos decimales. La constante [PI] proviene del paquete [kotlin.math];
  • línea 14: el método por defecto es heredado por la clase [Square] como cualquier otro método: puede llamarse sobre una variable de tipo [Square];
  • líneas 54–58: una segunda interfaz, con una propiedad abstracta [color] y un método por defecto [description], con la misma firma que el de [IShape];
  • líneas 63–66: la clase [ColoredSquare] deriva de [Square] (que implementa [IShape]) e implementa [IColored]. Por lo tanto, hereda dos métodos [description] por defecto. El compilador exige entonces que la clase redefina el método; de lo contrario, rechaza la clase (véase más adelante). El nuevo método puede llamar a cualquiera de las versiones heredadas con la sintaxis [super<Type>.method()], donde [Type] es la clase padre o la interfaz cuya versión se desea: en la línea 64, el método combina ambas. Java escribe [I1.super.method()];
  • línea 63: la propiedad abstracta [color] de la interfaz [IColored] se implementa directamente en el constructor primario mediante [override val color: String];
  • línea 66: la propiedad [name] de la interfaz [IShape], que tenía un descriptor de acceso por defecto, se redefine como una propiedad con un campo: la clase misma puede almacenar un valor.

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=classes17.Classes17Kt
Square of area 4,00
Circle of radius 1.0 and area 3,14
Square of area 1,00
Square of area 9,00
ColoredSquare of area 2,25, red object
name=colored square, color=red

Estos son los errores que genera el compilador cuando una clase [C] implementa dos interfaces, [I1] y [I2], cada una de las cuales tiene un método [fun f() = ...] sin redefinirlo, y cuando una interfaz intenta inicializar una propiedad ([val counter: Int = 0]):

Error17.kt:9:1: error: class 'C' must override 'f' because it inherits multiple interface methods for it.
Error17.kt:12:24: error: property initializers in interfaces are prohibited.

A diferencia de una clase abstracta, una interfaz no tiene, por lo tanto, estado: no puede declarar propiedades almacenadas. Las constantes, que en Java son campos [static final] de la interfaz, se colocan en Kotlin dentro de su objeto complementario ([const val]).

Por último, para los lectores que provienen de Java, observe que un método de interfaz de Kotlin con cuerpo se compila (desde Kotlin 2.2) en un método [default] de la interfaz Java generada: una clase de Java puede, por lo tanto, implementar una interfaz de Kotlin sin reescribir esos métodos.

4.7. Clases abstractas

Una clase abstracta es una clase que no puede instanciarse. Hay que crear clases derivadas, que sí pueden instanciarse. Las clases abstractas pueden usarse para factorizar código en una línea de clases. Examinemos el siguiente ejemplo, que forma el paquete [users] [User.kt]:

package users

// una clase abstracta: no se puede instanciar
abstract class User protected constructor(
    private val login: String,
    private val password: String,
) {
    // el rol del usuario, obtenido mediante el método abstracto identify
    // usuario no identificado: excepción
    private val role: String = identify() ?: throw UnknownUserException("[$login,$password]")

    override fun toString() = "User[$login,$password,$role]"

    // identificación: devuelve el rol del usuario o null si no se reconoce
    protected abstract fun identify(): String?
}
  • Línea 4: la clase se declara abstracta con la palabra clave [abstract]. Una clase abstracta es implícitamente abierta a la herencia: no es necesario agregar [open];
  • Líneas 4–6: el constructor primario de la clase [User]. Esta clase almacena información sobre los usuarios de una aplicación web. La aplicación tiene varios tipos de usuarios que se autentican mediante un nombre de usuario y una contraseña (líneas 5–6). Estos dos datos se verifican contra un directorio (LDAP) para algunos usuarios, contra una base de datos para otros, etc. Para hacer visible el constructor primario, hay que incluir explícitamente la palabra clave [constructor] después del nombre de la clase: [protected constructor(...)]. El constructor es [protected]: está destinado a los constructores de las clases derivadas. La coma que sigue al último parámetro (línea 6) está permitida: facilita agregar un parámetro más adelante;
  • línea 10: la información se verifica mediante un método llamado [identify]. Como en este nivel no se conoce el método de identificación, se declara abstracto (línea 15) con la palabra clave [abstract]. Un método abstracto no tiene cuerpo: las clases derivadas proporcionarán uno. Una clase que tiene un método abstracto debe declararse a su vez abstracta. El método [identify] devuelve una cadena que especifica el rol del usuario (básicamente, lo que está autorizado a hacer), o [null] si el usuario no es reconocido: su tipo es, por lo tanto, [String?];
  • Línea 10: si el usuario no es reconocido, se lanza una excepción. El operador Elvis [?:] evalúa la expresión como el rol devuelto por [identify] si no es [null], y en caso contrario ejecuta la expresión de la derecha, en este caso [throw UnknownUserException(...)]. En Kotlin, [throw] es una expresión (de tipo [Nothing]), lo que permite esta sintaxis compacta. La propiedad [role] es de tipo [String] y no es anulable: el compilador sabe que no puede ser [null]. No es necesaria ninguna cláusula [throws]: Kotlin no tiene excepciones verificadas (capítulo 3);
  • línea 12: el método *[toString],* que identifica una instancia de la clase.

Suponemos aquí que el desarrollador quiere controlar la construcción de las instancias de la clase [User] y de sus clases derivadas, quizá porque quiere asegurarse de que se lance una excepción de cierto tipo si el usuario no es reconocido. Las clases derivadas podrán apoyarse en este constructor. Para ello, deben proporcionar el método [identify]. Observe que la inicialización de la propiedad [role], que forma parte de la construcción del objeto, llama a un método redefinido por las clases derivadas aunque estas todavía no hayan realizado su propia inicialización: el método *[identify] no debe, por lo tanto, utilizar propiedades de la clase derivada, que aún no se han inicializado (¡incluso una propiedad no anulable podría valer *[null] allí!). Es una práctica que debe manejarse con precaución. El compilador de Kotlin no la señala; es IntelliJ IDEA el que la resalta mediante una inspección de código (“Leaking 'this' in constructor of non-final class”). En este caso, es intencional y segura, porque los métodos de las clases derivadas no utilizan ninguna propiedad.

La clase [UnknownUserException] es la siguiente:

1
2
3
4
package users

// una excepción específica de la aplicación
class UnknownUserException(message: String) : Exception(message)
  • Línea 4: deriva de la clase [Exception] (un alias de [java.lang.Exception]) y tiene un único constructor que recibe como parámetro un mensaje de error, que se pasa de inmediato al constructor de la clase padre. Basta con una línea. En Java, una clase derivada de [Exception] es una excepción verificada: el compilador comprueba que todo método capaz de lanzarla la declare mediante una cláusula [throws]. Kotlin no realiza esta comprobación: todas las excepciones en Kotlin se comportan como las excepciones no verificadas de Java. Si un método de Kotlin va a ser llamado desde código Java que quiere capturar la excepción, se marca para Java mediante la anotación [@Throws(UnknownUserException::class)]. El compilador de Kotlin tampoco exige un número de versión [serialVersionUID].

Derivamos ahora la clase [Administrator] de la clase padre [User]:

package users

class Administrator(login: String, password: String) : User(login, password) {
    // identificación
    override fun identify(): String {
        // identificación LDAP
        // ...
        return "admin"
    }
}
  • Línea 3: el constructor primario simplemente pasa los parámetros que recibe a su clase padre: [: User(login, password)]. Los parámetros [login] y [password] no están precedidos de [val]: son simples parámetros, y las propiedades correspondientes se declaran en la clase padre;
  • Líneas 5–8: el método [identify] de la clase [Administrator]. Supongamos que un administrador se identifica mediante un directorio llamado LDAP. Este método implementa el método abstracto [identify] de su clase padre. Conserva el nivel de acceso [protected] del método que redefine: en Kotlin, un método redefinido hereda por defecto la visibilidad del método redefinido (puede ampliarla, pero no restringirla). Su tipo de retorno es *[String]*, no *[String?]: un método redefinido puede devolver un tipo más específico que el del método que redefine, y un *[String] es un caso particular de *[String?]*.

Las clases [Observer] y [Unknown] también derivan de la clase [User]. Se diferencian de la clase [Administrator] solo en su método [identify]. El método de la clase [Observer] supone que un observador se identifica mediante una base de datos y devuelve el rol “observer”:

1
2
3
4
5
6
    // identificación
    override fun identify(): String {
        // identificación mediante una base de datos
        // ...
        return "observer"
    }

El método de la clase [Unknown] devuelve la referencia [null] para indicar que el usuario no fue reconocido; por lo tanto, su tipo de resultado es [String?]:

1
2
3
4
5
6
    // identificación
    override fun identify(): String? {
        // usuario desconocido
        // ...
        return null
    }

En definitiva, los objetos [Administrator], [Observer], y [Unknown] se inicializan con el mismo código, el de la clase padre [User]. Esta clase utiliza el método [identify] proporcionado por esas clases. Un programa de prueba podría tener el siguiente aspecto [Main.kt]:

package users

fun main() {
    try {
        println(Observer("observer", "pwd1"))
        println(Administrator("admin", "pwd2"))
        println(Unknown("xx", "yy"))
    } catch (e: UnknownUserException) {
        println("Unknown user: ${e.message}")
    }
    // val u = User("x", "y")   // rechazado: la clase User es abstracta
}

Observe que en las líneas 5 y 6, el método [User.toString()] es utilizado por la función [println]. En la línea 7, el constructor lanza una excepción [UnknownUserException], que se captura en la línea 8: el objeto no se crea y no se muestra nada con [println]. El compilador no exige el bloque [try], como sí ocurría en Java: sin él, la excepción terminaría el programa. La línea 11, si se descomenta, es rechazada por el compilador, que da dos razones:

Main.kt:11:13: error: cannot access 'constructor(login: String, password: String): User': it is protected in 'users.User'.
Main.kt:11:13: error: cannot create an instance of an abstract class.

No se puede llamar a un constructor protegido fuera de las clases derivadas y, más importante aún, no se puede crear un objeto de una clase abstracta.

Resultados:

1
2
3
4
> gradlew -q run -Pmain=users.MainKt
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

Una clase abstracta es similar a una interfaz: ambas declaran miembros que otras clases deben implementar. Sin embargo, una clase abstracta puede tener estado (propiedades almacenadas), constructores y código común a sus clases derivadas; en cambio, una clase solo puede derivar de una única clase abstracta, mientras que puede implementar varias interfaces. Con frecuencia se combinan: una interfaz define el contrato, mientras que una clase abstracta que la implementa reúne el código común a varias implementaciones. Eso es lo que hará la aplicación de ejemplo de este capítulo. Por último, recuerde que la clase sellada ([sealed class]), vista anteriormente, es una clase abstracta cuyas clases derivadas son todas conocidas por el compilador: la usaremos más adelante con la expresión [when].

4.8. Clases, interfaces y funciones genéricas

4.8.1. Clases y funciones genéricas

Supongamos que queremos escribir una clase [IntPair] que almacene dos enteros y pueda intercambiarlos: dos propiedades, [var first: Int] y [var second: Int], y un método, [swap()], que intercambie sus valores mediante una variable temporal, [val temp]. Si luego quisiéramos un par de cadenas y después un par de personas, escribiríamos dos clases más, [StringPair] y [PersonPair], idénticas a la anterior salvo por el tipo: [String] o [Person] en lugar de [Int].

Las clases, interfaces y funciones genéricas responden a la necesidad de tener código que solo difiere en el tipo de ciertos datos. Kotlin las tiene desde su primera versión; se basan en los genéricos introducidos en la JVM con Java 5 (2004), con los que comparten las fortalezas y ciertas limitaciones (el borrado de tipos, que se analiza más adelante), junto con algunas mejoras notables (varianza declarativa, tipos reificados). Cabe señalar que Kotlin, al igual que Java, no admite el paso de parámetros por referencia: una función no puede intercambiar los valores de dos variables del código que la llama, pero sí puede intercambiar dos elementos de un objeto, de un par o de un arreglo.

El programa [Classes18.kt] contiene una clase genérica, una función genérica y una segunda clase genérica:

package classes18

// clases y funciones genéricas
fun main() {
    // - una clase genérica Pair<T>
    // Int
    val pi = Pair<Int>(1, 2)
    pi.swap()
    println("pi=$pi")
    // String: el tipo T se infiere a partir de los parámetros reales
    val ps = Pair("s1", "s2")
    ps.swap()
    println("ps=$ps")
    // Person
    val p1 = Person("jean", "clu", 20)
    val p2 = Person("pauline", "dard", 55)
    val pp = Pair(p1, p2)
    pp.swap()
    println("pp=$pp")
    // el primer elemento es de tipo Person: sin conversión
    val firstOne: Person = pp.first
    println("first element: $firstOne")

    // - una función genérica swap<T>
    val integers = arrayOf(1, 2, 3)
    swap<Int>(integers, 0, 2)
    println("integers=${integers.contentToString()}")
    // el compilador infiere T a partir del tipo de los parámetros reales
    val persons = arrayOf(p1, p2)
    swap(persons, 0, 1)
    println("persons=${persons.contentToString()}")

    // - una clase genérica con estado: una pila de elementos de tipo T
    val stack = MyStack<Person>()
    stack.push(p1)
    stack.push(p2)
    println("The stack contains ${stack.size} persons")
    val top = stack.pop()
    println("Person popped: $top, ${stack.size} left")
    // stack.push("x")   // rechazado: la pila solo acepta objetos Person
}

// una clase genérica: un par de dos elementos de tipo T
class Pair<T>(first: T, second: T) {
    // dos propiedades legibles desde el exterior, modificables solo por la clase
    var first = first
        private set
    var second = second
        private set

    // intercambiamos los dos elementos
    fun swap() {
        val temp = first
        first = second
        second = temp
    }

    override fun toString() = "($first,$second)"
}

// una función genérica de nivel superior:
// intercambia los elementos n.º i y j de un arreglo de elementos de tipo T
fun <T> swap(array: Array<T>, i: Int, j: Int) {
    val temp = array[i]
    array[i] = array[j]
    array[j] = temp
}

// una pila de elementos de tipo T
class MyStack<T> {
    // los elementos de la pila
    private val elements = mutableListOf<T>()

    // número de elementos
    val size: Int
        get() = elements.size

    // agregar un elemento en la cima de la pila
    fun push(element: T) {
        elements.add(element)
    }

    // quitar el elemento de la cima de la pila
    fun pop(): T {
        check(elements.isNotEmpty()) { "empty stack" }
        return elements.removeLast()
    }
}

// una persona
data class Person(val firstName: String, val lastName: String, val age: Int) {
    override fun toString() = "[$firstName, $lastName, $age]"
}
  • líneas 44–58: la clase [Pair] está parametrizada por un tipo denotado [T], encerrado entre paréntesis angulares después del nombre de la clase. Se le puede dar cualquier nombre; por convención, es una letra mayúscula ([T] para tipo, [E] para elemento, [K] y [V] para clave y valor). Este tipo, [T], se usa luego en la clase como cualquier otro tipo: para los parámetros del constructor, las dos propiedades y la variable temporal [temp] (línea 53), de la cual el compilador infiere el tipo [T]. Se dice que la clase [Pair] es una clase genérica;
  • líneas 46–49: dos propiedades inicializadas con los parámetros del constructor, que tienen los mismos nombres. Se declaran como [var] porque el método [swap] las modifica, pero su acceso [set] es privado ([private set]): el código externo puede leer [pp.first], pero no puede asignarle un valor. Esto equivale a los campos privados y a sus métodos de acceso [getFirst] y [getSecond] en la versión de Java;
  • líneas 52–55: intercambio de los dos elementos. Los aficionados a los modismos de Kotlin a veces escriben esto en una sola línea: [first = second.also { second = first }] ([also] devuelve el valor de [second] después de ejecutar la asignación en el bloque). La versión con variable temporal es más legible;
  • línea 7: al usar una clase genérica parametrizada por los tipos T1, T2, …, estos tipos pueden especificarse entre paréntesis angulares. Aquí, [Pair<Int>] es un par de enteros. A diferencia de Java, que exige [Pair<Integer>] y rechaza [Pair<int>], Kotlin tiene un solo tipo, [Int]: el compilador utiliza la clase envoltorio *[java.lang.Integer]* para la JVM dondequiera que se requiera un objeto, como se muestra aquí;
  • líneas 11 y 17: la mayoría de las veces no se especifica el tipo; el compilador lo infiere a partir de los parámetros reales del constructor, aquí [String] y luego [Person]. Es el equivalente del operador “diamante” de Java [new Pair<>(...)], pero más conciso;
  • línea 21: la propiedad [first] de un [Pair<Person>] es de tipo [Person], sin conversión;
  • líneas 63–66: una función genérica de nivel superior. El parámetro de tipo [<T>] se declara entre la palabra clave [fun] y el nombre de la función. En Java era necesaria una clase llamada [Generic2] para contener el método estático; en Kotlin, una función puede existir fuera de cualquier clase. Intercambia los elementos i y j de un arreglo de elementos de tipo [T]. El tipo [Array<T>] es un arreglo de objetos de Kotlin (el equivalente de [T[]] en Java);
  • línea 26: se llama a la función [swap] especificando el tipo [T] entre [<>]. En realidad, el compilador es capaz de inferir [T] a partir del tipo de los parámetros reales. Por lo tanto, la sintaxis de la línea 30 es válida, y es la que se usa en la práctica. Observe que [arrayOf(1, 2, 3)] crea un [Array<Int>] (un arreglo de objetos [Integer]), al que se aplica la función; un arreglo [IntArray] (creado por [intArrayOf]), que es un arreglo de enteros primitivos [int[]], no se aceptaría: como en Java, un parámetro de tipo no puede referirse a un tipo primitivo de la JVM;
  • líneas 70–86: una clase genérica con estado: una pila de elementos de tipo [T]. Los elementos se apilan en la parte superior de la pila y se desapilan desde ella. Los elementos se almacenan en una lista genérica mutable de tipo [MutableList<T>] (línea 72), creada por la función genérica [mutableListOf<T>()], que a su vez está parametrizada por el tipo de la pila, [T]. El número de elementos es una propiedad calculada [size]. La función [removeLast] obtiene y devuelve el último elemento de la lista. Una pila vacía provoca una excepción [IllegalStateException], la excepción que se lanza cuando se solicita una operación a un objeto que no está en el estado esperado: es precisamente la excepción que lanza la función de Kotlin [check(condition) { message }] cuando la condición es falsa (línea 85);
  • línea 34: una pila de personas. Aquí es necesario especificar el tipo, ya que el compilador no tiene forma de inferirlo. El compilador garantiza que solo contendrá personas: la instrucción de la línea 40, al descomentarla, es rechazada ([argument type mismatch: actual type is 'String', but 'Person' was expected]). El método [pop] devuelve un objeto de tipo [Person], sin conversión;
  • líneas 91–92: la persona es una clase de datos cuyo método [toString] ha sido redefinido.

Resultados:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=classes18.Classes18Kt
pi=(2,1)
ps=(s2,s1)
pp=([pauline, dard, 55],[jean, clu, 20])
first element: [pauline, dard, 55]
integers=[3, 2, 1]
persons=[[pauline, dard, 55], [jean, clu, 20]]
The stack contains 2 persons
Person popped: [pauline, dard, 55], 1 left

4.8.2. Límites de los parámetros genéricos

En la clase [Pair<T>], el compilador no sabe nada sobre el tipo [T]: solo permite los métodos de la clase [Any] ([toString], [equals], [hashCode]), y aun así, solo mediante el operador [?.]: por defecto, ¡[T] puede ser, en efecto, un tipo que admite valores nulos! El límite implícito de un parámetro genérico es [Any?]. Para usar otros métodos, es necesario restringir el parámetro genérico especificando, después de los dos puntos, el tipo del que debe derivar:

Restricción
Significado
[<T : SomeClass>]
T debe ser la clase especificada o una clase derivada
[<T : Interface>]
T debe implementar la interfaz especificada
[<T> ... where T : I1, T : I2]
Restricciones múltiples: se enumeran en una cláusula [where] colocada antes del cuerpo de la función o de la clase
[<T : Comparable<T>>]
un límite que usa el propio T: T debe ser comparable con T
[<T : Any>]
T debe ser un tipo que no admite valores nulos

La sintaxis es la misma que la de la herencia: Java escribe [<T extends SomeClass>] y [<T extends SomeClass & I1 & I2>], mientras que C# escribe [where T : SomeClass]. Como en Java, no existe una restricción que exija un constructor sin parámetros: no se puede escribir [T()] en una clase genérica (véase el borrado de tipos más adelante). El programa [Classes19.kt] utiliza una restricción:

package classes19

import kotlin.random.Random

// los límites de los parámetros genéricos
fun main() {
    // - T puede ser cualquier tipo, incluidos Int y un tipo que admite nulos
    val pi = Pair(1, 2)
    println("pi=$pi")
    val pn = Pair<String?>("a", null)
    println("pn=$pn")

    // - el límite T : IValue
    // ordenamiento de pares de objetos de tipo RandomValue
    repeat(5) {
        val pair = Pair(RandomValue(), RandomValue())
        print("Before --> $pair")
        order(pair)
        println("   After --> $pair")
    }
    // ordenamiento de un par de objetos de tipo StringValue
    val strings = Pair(StringValue("xxxxxxxxxxxxxx"), StringValue("xx"))
    println("Before --> $strings")
    order(strings)
    println("After --> $strings")
    // order(pi)   // error: Int no implementa IValue
}

// un par de dos elementos de tipo T
class Pair<T>(first: T, second: T) {
    var first = first
        private set
    var second = second
        private set

    fun swap() {
        val temp = first
        first = second
        second = temp
    }

    override fun toString() = "($first,$second)"
}

// el tipo T debe implementar IValue
fun <T : IValue> order(pair: Pair<T>) {
    // si el 1.er elemento es mayor que el 2.º, los elementos se intercambian
    if (pair.first.value > pair.second.value) {
        pair.swap()
    }
}

// un objeto que tiene un valor entero
interface IValue {
    val value: Int
}

// un objeto que tiene un valor aleatorio
class RandomValue : IValue {
    // valor del objeto
    override val value = generator.nextInt(100)

    override fun toString() = value.toString()

    companion object {
        // generador de números aleatorios compartido por todas las instancias
        // (inicializado con una semilla fija para que los resultados sean reproducibles)
        private val generator = Random(2026)
    }
}

// un objeto cuyo valor es la longitud de una cadena
class StringValue(private val s: String) : IValue {
    override val value: Int
        get() = s.length

    override fun toString() = s
}
  • línea 8: un par de enteros. A diferencia de la versión de Java, aquí no hay ningún error que señalar: [Pair<Int>] está permitido, y el compilador usa la clase [Integer] en el código generado;
  • línea 10: dado que el límite implícito es [Any?], el tipo [T] puede ser un tipo que admite valores nulos: el par [pn] contiene una cadena y el valor [null]. Para impedirlo, habríamos declarado [class Pair<T : Any>];
  • líneas 46–49: la función genérica [order] exige que el tipo [T] implemente la interfaz [IValue] (líneas 54–55). Esta interfaz tiene una propiedad [value], usada en la línea 48, que devuelve el valor del objeto de tipo [T]. Sin el límite, el compilador rechazaría la expresión [pair.first.value]: un tipo [T] cualquiera no tiene una propiedad [value]. Los dos elementos del par se intercambian solo si el valor del primero es mayor que el del segundo: la función [order] ordena los dos elementos de forma ascendente según su valor;
  • líneas 59–68: la clase [RandomValue] implementa la interfaz [IValue]. El valor de una instancia es un número aleatorio entre 0 y 99 (línea 61), proporcionado por un generador de números aleatorios de la clase [kotlin.random.Random] compartido por todas las instancias: se almacena en el objeto complementario (companion object) de la clase (línea 68), que cumple la misma función que el campo estático en la versión de Java. Este generador se inicializa con una “semilla” fija: por lo tanto, siempre produce la misma secuencia de números, lo que hace reproducibles los resultados. No es el mismo algoritmo que el de la clase [java.util.Random]: por lo tanto, la secuencia resultante no es la misma que la de la versión de Java. Si no se requiere reproducibilidad, se usa el generador predeterminado [Random.Default] (por ejemplo, [Random.nextInt(100)]); o, por motivos de seguridad, la clase [java.security.SecureRandom];
  • líneas 73–77: la clase [StringValue] también implementa la interfaz [IValue]: el valor de una instancia es la longitud de la cadena de caracteres pasada al constructor, calculada por el método de acceso de la propiedad;
  • líneas 15–19: se ordenan pares de objetos de tipo [RandomValue] . La función [repeat(5) { ... }] ejecuta el bloque cinco veces;
  • líneas 22–25: se ordena un par de objetos de tipo [StringValue] ;
  • línea 26: si se descomenta esta línea, el compilador informa que el tipo [Int] no es válido.

Resultados:

> gradlew -q run -Pmain=classes19.Classes19Kt
pi=(1,2)
pn=(a,null)
Before --> (67,8)   After --> (8,67)
Before --> (73,41)   After --> (41,73)
Before --> (28,53)   After --> (28,53)
Before --> (26,93)   After --> (26,93)
Before --> (31,39)   After --> (31,39)
Before --> (xxxxxxxxxxxxxx,xx)
After --> (xx,xxxxxxxxxxxxxx)

Estos son los errores encontrados durante la compilación una vez descomentada la línea 26:

Classes19.kt:26:5: error: cannot infer type for type parameter 'T'. Specify it explicitly.
Classes19.kt:26:11: error: argument type mismatch: actual type is 'Pair<Int>', but 'Pair<uninferred T (of fun <T : IValue> order)>' was expected.

El compilador intentó inferir el tipo [T]: la restricción del par exige [T] = [Int], y la restricción del límite exige que [T] implemente [IValue]; como las dos restricciones son incompatibles, no puede encontrar un tipo [T] (“uninferred T”). Si usted mismo especifica el tipo, [order<Int>(pi)], el mensaje es más directo: [type argument is not within its bounds: type parameter 'T (of fun <T : IValue> order)' must be subtype of 'IValue', but actual: 'Int'].

4.8.3. Interfaces genéricas: Comparable<T> y Comparator<T>

Para ilustrar el concepto de interfaz genérica, ordenaremos una lista de personas según distintos criterios. Para ello, Kotlin ofrece funciones para listas mutables (y arreglos) que ordenan la colección en el lugar, y funciones para todas las colecciones que devuelven una nueva lista ordenada sin modificar la original. Usaremos varias de ellas:

  • [list.sort()] ordena la lista según el orden natural de sus elementos: estos elementos deben implementar la interfaz [Comparable<T>], cuyo único método, [operator fun compareTo(other: T): Int], compara el objeto actual con el objeto [other]. Es la interfaz de Java [java.lang.Comparable], vista desde Kotlin;
  • [list.sortWith(comparator)] ordena la lista según el orden definido por un objeto comparador que implementa la interfaz [Comparator<T>] (un alias de [java.util.Comparator]), cuyo método [fun compare(a: T, b: T): Int] compara dos objetos;
  • [list.sortedWith(comparator)], [list.sortedBy { ... }] y [list.sortedByDescending { ... }] devuelven una nueva lista ordenada.

Los métodos [compareTo] y [compare] siguen la misma regla: devuelven un número positivo si x > y, 0 si x == y y un número negativo si x < y. Corresponde al desarrollador definir el significado de los operadores <, == y >. Por ejemplo, si [p1] y [p2] son dos objetos [Person], podemos decir que p1 > p2 si el nombre de [p1] va después del nombre de [p2] en orden alfabético. Esto dará como resultado un orden ascendente según los nombres de las personas. Si queremos ordenar por edad, diremos que p1 > p2 si la edad de [p1] es mayor que la edad de [p2]. Para ordenar de forma descendente, basta con invertir los signos de los resultados.

Ya sabemos lo suficiente para ordenar una lista de personas. El programa [Classes20.kt] es el siguiente:

package classes20

import java.text.Collator
import java.util.Locale

// las interfaces genéricas Comparable<T> y Comparator<T>: ordenamiento de una lista de personas
fun main() {
    val persons = mutableListOf(
        Person("claude", "pollon", 25),
        Person("valentine", "germain", 35),
        Person("paul", "germain", 32),
    )
    // visualización
    display("List to sort", persons)
    // ordenar según el orden natural de las personas (Comparable): la edad
    persons.sort()
    display("List after sorting by age", persons)
    // ordenar por apellido y nombre (Comparator)
    persons.sortWith(CompareNames())
    display("List after sorting by last and first name", persons)
    // ordenar por edad decreciente, con un objeto anónimo
    persons.sortWith(object : Comparator<Person> {
        override fun compare(p1: Person, p2: Person) = p2.age.compareTo(p1.age)
    })
    display("List after sorting by decreasing age", persons)
    // el operador > usa el método compareTo de Comparable
    println("${persons[0]} > ${persons[1]} : ${persons[0] > persons[1]}")
    // comparadores construidos con compareBy y thenBy; sortedWith devuelve una nueva lista
    val collator = Collator.getInstance(Locale.FRENCH)
    val byNames = compareBy<Person, String>(collator) { it.lastName }.thenBy(collator) { it.firstName }
    display("New list sorted by last and first name", persons.sortedWith(byNames))
    // un ordenamiento por una sola propiedad
    display("New list sorted by first name", persons.sortedBy { it.firstName })
    // la lista original no ha cambiado
    display("Original list", persons)
}

// visualización de una lista de personas
fun display(text: String, persons: List<Person>) {
    println(text + "-".repeat(50 - text.length))
    for (p in persons) {
        println(p)
    }
}

// una persona, comparable con otra persona
class Person(val firstName: String, val lastName: String, val age: Int) : Comparable<Person> {
    // el orden natural de las personas: el orden de las edades
    override fun compareTo(other: Person) = age.compareTo(other.age)

    override fun toString() = "[$firstName, $lastName, $age]"
}

// comparación de los apellidos y nombres de dos personas
class CompareNames : Comparator<Person> {
    // comparación de cadenas según las reglas del idioma francés
    private val collator = Collator.getInstance(Locale.FRENCH)

    override fun compare(p1: Person, p2: Person): Int {
        // comparamos los apellidos
        val i = collator.compare(p1.lastName, p2.lastName)
        if (i != 0) {
            return i
        }
        // apellidos iguales: comparamos los nombres
        return collator.compare(p1.firstName, p2.firstName)
    }
}
  • líneas 8–11: la lista editable de personas. La versión de Java ordenaba un arreglo; las mismas funciones [sort] y [sortWith] existen para los arreglos de Kotlin;
  • líneas 47–51: la clase [Person] implementa la interfaz genérica [Comparable<Person>]: sus objetos son comparables con otras personas. Su método [compareTo] (línea 49) define el orden natural de las personas, en este caso, el orden de las edades. El método [a.compareTo(b)] para enteros devuelve un número negativo, cero o positivo según si [a] es menor que, igual a o mayor que [b]: es exactamente lo que espera el método [compareTo] (Java escribe [Integer.compare(a, b)]). El parámetro se llama [other] en la interfaz; conservamos ese nombre al redefinirlo, de lo contrario el compilador, que admite argumentos con nombre, emitiría una advertencia;
  • línea 16: ordenamiento en orden natural;
  • línea 19: ordenamiento de la lista de personas por apellido y nombre. El parámetro de la función [sortWith] es una instancia de la clase [CompareNames], que implementa la interfaz genérica [Comparator<Person>];
  • líneas 55–66: la clase [CompareNames]. Su método [compare] implementa el método [compare(a: T, b: T)] de la interfaz [Comparator<T>], donde [T] = [Person]. Las cadenas no se comparan con el método [compareTo], que sigue el orden de los códigos de los caracteres (las mayúsculas antes que las minúsculas, las letras acentuadas después de la "z"), sino mediante un objeto [java.text.Collator] (línea 57) que aplica las reglas de ordenamiento del idioma francés. Aquí Kotlin utiliza directamente una clase del JDK;
  • líneas 22–24: ordenamiento por edad descendente. Esta vez, el comparador es un objeto anónimo: la expresión [object : Comparator<Person> { ... }] declara una clase sin nombre que implementa la interfaz [Comparator<Person>] y crea de inmediato una instancia de esa clase. Equivale a la clase anónima de Java ([new Comparator<Person>() { ... }]). El cuerpo del objeto proporciona el método [compare]. Un objeto anónimo evita tener que declarar una clase que se usa una sola vez;
  • línea 27: el método [compareTo] de la interfaz [Comparable] se declara como [operator]: por lo tanto, los operadores [<], [>], [<=] y [>=] pueden aplicarse a las personas ([p1 > p2] se traduce como [p1.compareTo(p2) > 0]), como vimos antes con la sobrecarga de operadores;
  • líneas 29–30: la biblioteca de Kotlin crea comparadores: [compareBy(comparator) { it.lastName }] devuelve un comparador de personas que compara sus apellidos (el valor calculado por la lambda) con el comparador especificado, en este caso [Collator]; [thenBy(comparator) { it.firstName }] agrega un segundo criterio, que se usa en caso de empate en el primer criterio. Los dos tipos de [compareBy] (el del elemento y el de la clave) se especifican entre paréntesis angulares, ya que el compilador no puede inferirlos solo a partir de la lambda. Sin un comparador específico, basta con escribir [compareBy<Person> { it.lastName }.thenBy { it.firstName }]: las claves se comparan entonces en su orden natural. El comparador [byNames] es un mejor reemplazo de la clase [CompareNames];
  • línea 31: la función [sortedWith] devuelve una nueva lista ordenada según el comparador; la lista [persons] permanece sin cambios;
  • línea 33: la función [sortedBy] ordena según la clave calculada por la expresión lambda (en este caso, el nombre) en su orden natural ([sortedByDescending] ordenaría de forma descendente);
  • línea 35: las funciones [sortedWith] y [sortedBy] no han modificado la lista original;
  • línea 40: la función [repeat] repite una cadena: la línea del título se rellena con guiones hasta completar 50 caracteres.

Resultados:

> gradlew -q run -Pmain=classes20.Classes20Kt
List to sort--------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
List after sorting by age-------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
List after sorting by last and first name---------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
List after sorting by decreasing age--------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]
[valentine, germain, 35] > [paul, germain, 32] : true
New list sorted by last and first name------------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
New list sorted by first name---------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
Original list-------------------------------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]

En este caso, la versión de Java presentaba tres tipos de clases declaradas dentro de otra clase. Kotlin tiene los mismos tipos, pero con nombres distintos: una clase declarada dentro de otra es anidada por defecto (el equivalente de la clase de Java [static class]: no está vinculada a ningún objeto de la clase envolvente); una clase interna, asociada a un objeto de la clase envolvente, se declara con la palabra clave [inner] ([inner class]); por último, la expresión [object : ...] crea un objeto anónimo. Veremos en el capítulo 7 que se puede hacer aún más corto que un objeto anónimo para una interfaz que tiene un solo método abstracto, como [Comparator]: una lambda, [persons.sortWith { p1, p2 -> p2.age.compareTo(p1.age) }], o, como acabamos de hacer, un comparador construido a partir de una lambda: [persons.sortWith(compareByDescending { it.age })].

4.8.4. Varianza, proyecciones y borrado de tipos

Una [MutableList<Int>] no es una [MutableList<Number>], aunque [Int] deriva de [Number]: si lo fuera, se podría agregar un [Double] a una lista de enteros mediante una variable de tipo [MutableList<Number>]. Se dice que el tipo [MutableList<T>] es invariante: una función que acepta una [MutableList<Number>] rechaza una [MutableList<Int>]. En cambio, una lista de solo lectura de tipo [List<Int>] is a [List<Number>]: como no se le puede agregar nada, el riesgo anterior no existe, y todo entero leído de la lista es, efectivamente, un número. Se dice que el tipo [List<T>] es covariante.

Esta es una diferencia significativa con respecto a Java. En Java, todas las interfaces genéricas son invariantes y hay que escribir comodines en cada uso: [List<? extends Number>] para una lista de la que se lee, [List<? super Integer>] para una lista que se está llenando. Kotlin permite especificar la varianza de una vez por todas, en la declaración de la clase o la interfaz: es la varianza en la declaración. La interfaz [List] se declara como [interface List<out E>]: la palabra clave [out] significa que el tipo [E] aparece solo como “salida” (el resultado de los métodos y de las propiedades de tipo [val]), lo que hace que el tipo sea covariante. De forma similar, la interfaz [Comparable] se declara como [interface Comparable<in T>]: el tipo [T] aparece allí solo como “entrada” (parámetro de [compareTo]), lo que hace que el tipo sea contravariante: un [Comparable<Number>] es un [Comparable<Int>] (quien puede comparar cualquier número puede comparar un entero). El compilador verifica que la clase respete su declaración.

Para tipos invariantes como [MutableList], Kotlin también ofrece proyecciones de tipos, que equivalen a los comodines de Java:

Kotlin
Java
Significado
[MutableList<out Number>]
[List<? extends Number>]
Una lista de elementos de un tipo desconocido derivado de [Number]: se puede leer [Number] de ella, pero no se le pueden agregar elementos
[MutableList<in Int>]
[List<? super Integer>]
una lista de elementos de un tipo desconocido del cual deriva [Int] ([Int], [Number], [Any]): a esta lista se le puede agregar [Int]
[MutableList<*>]
[List<?>]
una lista de elementos de un tipo desconocido (proyección con asterisco): se puede leer [Any?]

El programa [Classes21.kt] ilustra la varianza, las proyecciones y una característica específica de los genéricos de la JVM (el borrado de tipos), así como la solución parcial de Kotlin a este problema: los parámetros de tipo reificados:

package classes21

// varianza (out, in), proyecciones, proyección de estrella, borrado de tipos y tipos reificados
fun main() {
    val integers: List<Int> = listOf(1, 2, 3)
    val reals: List<Double> = listOf(1.5, 2.25)
    // List<out E> es covariante: un List<Int> es un List<Number>
    println("Sum of integers: ${sum(integers)}")
    println("Sum of reals: ${sum(reals)}")
    // MutableList<in Int>: una lista mutable que puede recibir Int
    val numbers = mutableListOf<Number>()
    addIntegers(numbers, 3)
    numbers.add(2.5)
    println("numbers=$numbers, sum=${sum(numbers)}")
    // MutableList<out Number>: una lista mutable cuyos elementos solo se leen
    val mutableIntegers = mutableListOf(10, 20)
    println("Sum of a mutable list: ${mutableSum(mutableIntegers)}")
    // un límite recursivo: T debe ser comparable consigo mismo
    println("max : ${max(listOf("paul", "jean", "valentine"))}, ${max(integers)}")
    // varianza en el sitio de declaración en nuestras propias clases
    val box: Box<Number> = Box(5)
    println("box : ${box.content}")
    // la proyección de estrella: una lista de elementos de un tipo desconocido
    displaySize(listOf("a", "b"))
    displaySize(mutableIntegers)
    // borrado de tipos: en tiempo de ejecución, una lista es una lista
    val l1 = ArrayList<String>()
    val l2 = ArrayList<Int>()
    println("same class: ${l1.javaClass == l2.javaClass} (${l1.javaClass.name})")
    // los parámetros de tipo reificados de las funciones inline
    val mixed = listOf(1, "two", 3.0, "four", 5)
    println("strings : ${countOf<String>(mixed)}, integers : ${countOf<Int>(mixed)}")
    println("the strings : ${mixed.filterIsInstance<String>()}")
    println("type name : ${typeName<Double>()}")
}

// suma de los elementos de una lista de números (List es covariante)
fun sum(values: List<Number>): Double {
    var sum = 0.0
    for (value in values) {
        sum += value.toDouble()
    }
    return sum
}

// suma de los elementos de una lista mutable de números (MutableList es invariante)
fun mutableSum(values: MutableList<out Number>): Double {
    // values.add(1)   // rechazado: se desconoce el tipo exacto de los elementos
    return values.sumOf { it.toDouble() }
}

// agregar los enteros 1, 2, ..., n a una lista capaz de recibir Int
fun addIntegers(list: MutableList<in Int>, n: Int) {
    for (i in 1..n) {
        list.add(i)
    }
}

// el mayor elemento de una lista no vacía
fun <T : Comparable<T>> max(elements: List<T>): T {
    var max = elements.first()
    for (element in elements) {
        if (element > max) {
            max = element
        }
    }
    return max
}

// una clase covariante: T solo aparece en la salida (resultado de método, propiedad val)
class Box<out T>(val content: T)

// una lista cuyo tipo de elemento se desconoce
fun displaySize(list: List<*>) {
    println("list of ${list.size} elements, first element: ${list.firstOrNull()}")
}

// el tipo T se conoce en tiempo de ejecución gracias a reified (función inline)
inline fun <reified T> countOf(elements: List<Any>) = elements.count { it is T }

inline fun <reified T : Any> typeName() = T::class.simpleName
  • líneas 38–43: la función [sum] acepta una [List<Number>]; por lo tanto, dado que [List] es covariante, acepta una lista de elementos de cualquier tipo derivado de [Number]: [Int], [Double], [BigDecimal]… Lee los elementos como [Number] y usa su método [toDouble]. Kotlin, al igual que Java, no admite la aritmética genérica: no se puede escribir [a + b] para dos objetos de tipo [T] o [Number], de ahí el uso de [Double]. Donde Java tendría que escribir ***[List<? extends Number>], basta con el tipo simple ***[List<Number>] ;
  • líneas 8–9: la misma función suma una lista de [Int] y una lista de [Double]. [listOf(...)] crea una lista de solo lectura;
  • líneas 47–49: una lista editable, en cambio, es invariante. Para aceptar una [MutableList<Int>] (línea 17), la función declara una proyección [MutableList<out Number>]. Puede leer elementos como [Number], pero agregar un elemento (línea 48) es rechazado: el compilador no sabe si es una lista de [Int] o de [Double] ([receiver type 'MutableList<out Number>' contains out projection which prohibits the use of 'fun add(element: E): Boolean']);
  • líneas 53–55: la función [addIntegers] acepta cualquier lista mutable capaz de contener [Int], en este caso una [MutableList<Number>] (línea 11). Seguimos la regla “productor: [out], consumidor: [in]”: una lista de la que se leen elementos se escribe como [out], y una lista que se llena se escribe como [in]. Las palabras clave de Kotlin expresan directamente lo que Java transmite mediante [extends] y [super];
  • líneas 60–67: la función genérica [max] devuelve el elemento más grande de una lista. El límite [T : Comparable<T>] exige que los elementos sean comparables entre sí; se aplica tanto a cadenas como a enteros (línea 19). En Java, hay que escribir [T extends Comparable<? super T>] para aceptar también un tipo cuya clase padre es comparable; en Kotlin, dado que la interfaz [Comparable] es contravariante ([in T]), basta con [T : Comparable<T>]. La función [first] devuelve el primer elemento de la lista, y el operador [>] llama a [compareTo]. (La biblioteca de Kotlin ya ofrece la función [maxOf] y, para las colecciones, [max()].);
  • línea 71: nuestra propia clase covariante. El tipo *[T] aparece allí solo como salida, como tipo de una propiedad *[val]*. Línea 21: un ***[Box<Int>] se acepta, por lo tanto, donde se espera un ***[Box<Number>] . Si agregamos a la clase un método [fun replace(newValue: T)], donde [T] aparece como entrada, el compilador rechaza la clase: [type parameter 'T' is declared as 'out' but occurs in 'in' position in type 'T (of class Box<out T>)']*;
  • líneas 74–75: la función [displaySize] acepta una lista de elementos de cualquier tipo: [List<*>]. No puede hacer ninguna suposición sobre sus elementos, que lee como [Any?]. La función [firstOrNull] devuelve el primer elemento, o [null] si la lista está vacía;
  • líneas 27–29: en tiempo de ejecución, un ***[ArrayList<String>] y un ***[ArrayList<Int>] son dos objetos de la misma clase *[java.util.ArrayList] (*[javaClass] devuelve la clase de Java de un objeto). El compilador verifica los tipos genéricos y luego los borra: el código compilado solo reconoce [ArrayList] y [Object], y se insertan conversiones donde son necesarias. Este “borrado de tipos”, adoptado por Java en 2004 para garantizar que el código genérico siga siendo compatible con el código existente, también se aplica a Kotlin, que genera código para la misma JVM. Esto explica varias limitaciones: no se puede escribir [T()] ni evaluar [o is List<String>] ([cannot check for instance of erased type 'List<String>']); en cambio, sí se puede evaluar [o is List<*>];
  • líneas 79–81: Kotlin evita parcialmente el borrado de tipos en las funciones [inline]. El compilador copia el código de una función [inline] en cada punto donde se la llama (volveremos sobre esto en el capítulo 7): en ese punto, el tipo [T] es conocido. Si el parámetro de tipo se declara como [reified] (“reificado”), la función puede usarlo como un tipo real: para evaluar [it is T] (línea 79), o para obtener su clase [T::class] (línea 81). Sin [reified], la evaluación [it is T] es rechazada: [cannot check for instance of erased type 'T (of fun <T> countOf)'];
  • líneas 31–34: uso de funciones reificadas. El tipo se especifica entre paréntesis angulares: [countOf<String>(mixed)] cuenta las cadenas de la lista. La biblioteca de Kotlin hace un uso extensivo de este mecanismo, por ejemplo en la función [filterIsInstance<String>()], que devuelve los elementos de una colección que son cadenas como tipo [List<String>].

Resultados:

> gradlew -q run -Pmain=classes21.Classes21Kt
Sum of integers: 6.0
Sum of reals: 3.75
numbers=[1, 2, 3, 2.5], sum=8.5
Sum of a mutable list: 30.0
max : valentine, 3
box : 5
list of 2 elements, first element: a
list of 2 elements, first element: 10
same class: true (java.util.ArrayList)
strings : 2, integers : 2
the strings : [two, four]
type name : Double

A diferencia de otros lenguajes como C#, donde las interfaces pueden declarar miembros estáticos abstractos para implementar cálculos genéricos, Kotlin no permite exigir que un tipo [T] tenga un método “de clase”: los miembros del objeto complementario de una interfaz se invocan con el nombre de la interfaz y no son heredados por las clases que la implementan.

4.9. Paquetes

Para imprimir una línea en pantalla, usamos la función [println(...)]. Si consultamos su definición en la documentación de la biblioteca de Kotlin (kotlinlang.org/api), vemos que forma parte del paquete [kotlin.io]. Esto significa que su nombre completo es [kotlin.io.println] y que podríamos escribir [kotlin.io.println(...)]. Un paquete de Kotlin contiene clases, así como funciones, propiedades y objetos de nivel superior. Varios paquetes se importan automáticamente en cada archivo de Kotlin: [kotlin.*] ([Any], [String], [Int]…), [kotlin.io.*] ([println], [readln]), [kotlin.collections.*] ([List], [listOf]…), [kotlin.text.*] ([StringBuilder], [Regex]…), [kotlin.ranges.*], [kotlin.sequences.*], [kotlin.comparisons.*] ([compareBy]…), [kotlin.annotation.*]y, en la JVM, [java.lang.*], y [kotlin.jvm.*]. Para los demás, se usa una cláusula [import] ubicada al comienzo del archivo, después de la declaración del paquete:

  • [import java.text.Collator] importa la clase [Collator] del paquete [java.text] (sin punto y coma final, como en todas las instrucciones de Kotlin);
  • [import java.util.*] importa bajo demanda todas las declaraciones públicas del paquete [java.util];
  • [import kotlin.math.sqrt] importa una función de nivel superior, que luego se puede usar sin su paquete: [sqrt(2.0)]. Kotlin no requiere la cláusula [import static] de Java: las clases, funciones, propiedades e incluso los miembros estáticos de una clase de Java ([import java.lang.Math.PI]) se importan de la misma manera;
  • [import namespaces.e2.Person as PersonE2] importa una declaración con un nombre diferente (un alias) que es válido solo dentro de ese archivo.

Cuando el compilador encuentra un nombre simple, lo busca en el paquete actual y entre las declaraciones importadas. Una cláusula [import] no agrega nada al programa: simplemente evita tener que escribir los nombres completos.

Al crear una clase, se la coloca en un paquete. El propósito de los paquetes es evitar conflictos de nombres entre clases, por ejemplo, cuando se distribuyen. Consideremos dos empresas, E1 y E2, que distribuyen clases empaquetadas en los archivos [e1.jar] y [e2.jar], respectivamente. Supongamos que un cliente C compra estos dos conjuntos de clases, en los que ambas empresas han definido una clase llamada [Person]. Si la empresa E1 crea sus clases en un paquete llamado [e1] y la empresa E2 crea sus clases en un paquete llamado [e2], las dos clases [Person] se llamarán entonces [e1.Person] y [e2.Person]. El cliente puede importar una de ellas y referirse a la otra por su nombre completo, o darle un alias. El paquete resuelve la ambigüedad. Por convención, los nombres de paquetes van en minúsculas y comienzan con el nombre de dominio invertido de la organización que los publica ([com.mysql.cj.jdbc], [org.hibernate], [kotlinx.coroutines]…); para nuestros ejemplos, usaremos nombres cortos.

Para colocar las declaraciones de un archivo en un paquete, se escribe la declaración [package name] al comienzo del archivo. Es lo que hemos hecho desde el inicio de este curso: cada programa está en un paquete con su propio nombre. A diferencia de Java, Kotlin no exige una correspondencia uno a uno entre paquetes y carpetas, pero la recomienda, e IntelliJ IDEA señala los archivos que no están bien organizados: los archivos fuente del paquete [namespaces.e1] se encuentran en una carpeta llamada [namespaces/e1], a partir de la raíz de los fuentes ([src/main/kotlin]). El paquete [namespaces] y sus dos subpaquetes ilustran estos conceptos:

1
2
3
4
5
6
src/main/kotlin/namespaces/
  Main.kt               the main program (namespaces package)
  e1/
    Person.kt           the namespaces.e1.Person class
  e2/
    Person.kt           the namespaces.e2.Person class

La primera clase [Person] [e1/Person.kt]:

1
2
3
4
5
6
7
8
9
// las declaraciones de este archivo pertenecen al paquete namespaces.e1
package namespaces.e1

class Person(private val firstName: String, private val lastName: String) {
    override fun toString() = "e1.Person[$firstName, $lastName]"
}

// una función de nivel superior también pertenece a un paquete
fun greet(person: Person) = "Hello $person"
  • Línea 2: la declaración del paquete. Todas las declaraciones del archivo pertenecen a este paquete: la clase [Person] y la función de nivel superior [greet] (línea 9), cuyo nombre completo es [namespaces.e1.greet]. En la JVM, esta función se coloca en una clase llamada [namespaces.e1.PersonKt], que recibe su nombre del archivo.

La segunda, [e2/Person.kt]:

// las declaraciones de este archivo pertenecen al paquete namespaces.e2
package namespaces.e2

class Person(val name: String) {
    override fun toString() = "e2.Person[$name]"
}

// una constante visible en todo el módulo, y solo en el módulo
internal const val VERSION = "e2-1.0"

// una función visible solo en este archivo
private fun tool() = "private tool"
  • línea 4: una clase llamada [Person], que tiene el mismo nombre que la anterior pero está en un paquete diferente;
  • línea 9: una constante con visibilidad [internal]: es accesible solo para las declaraciones del mismo módulo. En Kotlin, un módulo es un conjunto de archivos compilados juntos: un proyecto (o subproyecto) de Gradle, un módulo de IntelliJ IDEA… Aquí, es el proyecto [04-classes];
  • línea 12: una función privada de nivel superior: es accesible solo para las declaraciones de su propio archivo. Un intento de importarla desde [Main.kt] es rechazado: [cannot access 'fun tool(): String': it is private in file].

Ambas clases son públicas, que es la visibilidad predeterminada de Kotlin (una clase de Java sin la palabra clave [public] es accesible solo para las clases de su propio paquete). Resumamos los cuatro niveles de visibilidad de una declaración de nivel superior:

Visibilidad
Accesible desde
[public] (predeterminada)
cualquier lugar
[internal]
el mismo módulo
[private]
el mismo archivo
[protected]
(solo se aplica a los miembros de una clase: la clase y sus clases derivadas)

Kotlin no tiene un equivalente de la visibilidad “de paquete” de Java, que es la visibilidad predeterminada de las declaraciones de Java sin modificador: en Kotlin, un paquete es simplemente un espacio de nombres, y es el módulo el que define lo que una biblioteca expone a sus usuarios. El programa principal [Main.kt] es el siguiente:

package namespaces

// importación de una clase de un paquete
import namespaces.e1.Person
// importación de una función de nivel superior
import namespaces.e1.greet
// importación de una clase con otro nombre
import namespaces.e2.Person as PersonE2
// importación de una constante interna del módulo
import namespaces.e2.VERSION
// importación de una función de la biblioteca de Kotlin
import kotlin.math.sqrt

fun main() {
    // Person designa namespaces.e1.Person, que ha sido importada
    val p1 = Person("Jean", "Dupont")
    // el nombre completo de una clase elimina cualquier ambigüedad
    val p2 = namespaces.e2.Person("Durand")
    // el alias PersonE2 designa la clase namespaces.e2.Person
    val p3 = PersonE2("Martin")
    println("$p1 $p2 $p3")
    // una función de nivel superior del paquete namespaces.e1
    println(greet(p1))
    // nombre completo y paquete de una clase
    println("${Person::class.qualifiedName}, ${PersonE2::class.qualifiedName}")
    println("package of the Person class: ${Person::class.java.packageName}")
    // el módulo JPMS que contiene una clase
    println("e1.Person is in a named module: ${Person::class.java.module.isNamed}")
    println("${String::class.java.name} is in the module ${String::class.java.module.name}")
    // StringBuilder se conoce sin importación
    val sb = StringBuilder("abc")
    println(sb.append("def"))
    // sqrt se conoce gracias a la importación
    println("sqrt(2)=${sqrt(2.0)}")
    // una declaración internal es accesible en todo el módulo
    println("version=$VERSION")
}
  • línea 4: importación de la clase [namespaces.e1.Person];
  • línea 6: importación de la función de nivel superior [greet], tal como se importa una clase;
  • línea 8: importación de la clase [namespaces.e2.Person] con el nombre [PersonE2]. En este archivo, el nombre [PersonE2] se refiere a esta clase. Java no admite alias: no se puede dar a una clase un nombre diferente en Java. (Kotlin también permite declarar un alias de tipo para el nombre completo, como [typealias PersonE2 = namespaces.e2.Person]: ya hemos visto ejemplos, en los que [Comparator] y [Exception] son alias de tipos de Java);
  • línea 10: importación de la constante [internal], lo cual está permitido porque [Main.kt] está en el mismo módulo;
  • línea 12: importación de la función [sqrt] del paquete [kotlin.math];
  • línea 16: [Person] se refiere a la clase [namespaces.e1.Person], que fue importada;
  • línea 18: el nombre completo de la clase [namespaces.e2.Person] elimina cualquier ambigüedad;
  • línea 20: el alias produce el mismo resultado, pero es más legible;
  • línea 23: llamada a la función importada;
  • líneas 25–26: la propiedad [qualifiedName] de la descripción de Kotlin de una clase ([Person::class]) devuelve su nombre completo, con el prefijo de su paquete. La propiedad [java] devuelve la descripción de Java de la clase ([java.lang.Class]), cuyo método [getPackageName], visto en Kotlin como una propiedad [packageName], devuelve el nombre del paquete;
  • líneas 28–29: el método [getModule] de la clase de Java devuelve el módulo JPMS que contiene la clase (véase más adelante);
  • líneas 31–32: la clase [StringBuilder] se reconoce sin importación (es un alias, definido en el paquete [kotlin.text], de la clase [java.lang.StringBuilder]);
  • línea 34: uso de la función importada;
  • línea 36: uso de la constante [internal].

Resultados:

> gradlew -q run -Pmain=namespaces.MainKt
e1.Person[Jean, Dupont] e2.Person[Durand] e2.Person[Martin]
Hello e1.Person[Jean, Dupont]
namespaces.e1.Person, namespaces.e2.Person
package of the Person class: namespaces.e1
e1.Person is in a named module: false
java.lang.String is in the module java.base
abcdef
sqrt(2)=1.4142135623730951
version=e2-1.0

Si reemplazamos las importaciones de [Person] por las dos importaciones bajo demanda [import namespaces.e1.*] y [import namespaces.e2.*], sin el alias, el nombre [Person] se vuelve ambiguo. Las dos importaciones se anulan mutuamente y el compilador ya no puede encontrar la clase:

Main.kt:7:14: error: unresolved reference 'Person'.

Observe que una importación con alias oculta el nombre original en el archivo: con la cláusula [import namespaces.e2.Person as PersonE2], el nombre [Person] ahora solo puede referirse a la clase del paquete [e1], incluso si ambos paquetes se importan bajo demanda.

4.9.1. Módulos

El término módulo tiene dos significados para un desarrollador de Kotlin. Acabamos de ver el primero: el módulo de Kotlin, un conjunto de archivos compilados juntos, que define el alcance de [internal]. El segundo significado proviene de Java: desde Java 9, los paquetes se agrupan en módulos (el “Java Platform Module System”, JPMS). El JDK está dividido en módulos: [java.base] contiene los paquetes básicos ([java.lang], [java.util], [java.math], [java.io]…), [java.sql] proporciona acceso a bases de datos, [java.net.http] es el cliente HTTP, y así sucesivamente. Un módulo JPMS declara, en un archivo llamado [module-info.java], su nombre, los módulos de los que depende ([requires java.sql;]) y los paquetes que pone a disposición de otros módulos ([exports tax.business;]). Un proyecto de Kotlin puede declarar uno (el archivo [module-info.java], escrito en Java, se coloca junto a los archivos fuente de Kotlin y debe depender entonces del módulo [kotlin.stdlib]). Las clases de una aplicación que no declara un módulo JPMS, como la nuestra, pertenecen al módulo sin nombre (línea 5 de la salida), que tiene acceso a todos los módulos. Este es el caso de la mayoría de las aplicaciones y de todas las de este curso: los módulos JPMS interesan principalmente a los autores de bibliotecas y al propio JDK.

4.10. Clases de datos

Muchas clases se usan únicamente para transportar datos: una persona, una nota, un tramo de impuestos… Para ellas, siempre escribimos el mismo código: propiedades de solo lectura, un método [toString] que las muestre y los métodos [equals] y [hashCode] . El constructor primario de Kotlin ya evita tener que escribir los campos, el constructor y los métodos de acceso; la palabra clave [data], colocada antes de [class], también indica al compilador que genere el resto. Las clases de datos existen desde la primera versión de Kotlin (2016); Java las alcanzó, con sus registros (records), en 2021. Las encontramos antes (en la sección “Objetos inmutables”) y varias veces desde entonces; el programa [Classes22.kt] las presenta de forma más completa:

package classes22

// clases de datos (data class)
fun main() {
    val r1 = Person("Jean", "Dupont", 30)
    val r2 = Person("Jean", "Dupont", 30)
    // toString generado por el compilador
    println(r1)
    // las propiedades son las declaradas por el constructor primario
    println("firstName=${r1.firstName}, identity=${r1.identity()}")
    // igualdad por valor: r1 y r2 son dos objetos diferentes pero iguales
    println("r1 == r2 : ${r1 == r2}, r1 === r2 : ${r1 === r2}, equal hashCodes : ${r1.hashCode() == r2.hashCode()}")
    // las propiedades val son de solo lectura
    // r1.age = 31   // rechazado: age es una propiedad val
    // una copia modificada, con el método copy y un argumento con nombre
    val r3 = r1.copy(age = 31)
    println(r3)
    println("r1 == r3 : ${r1 == r3}")
    // desestructuración en variables, gracias a las funciones component1(), component2()...
    val (firstName, lastName, age) = r1
    println("firstName=$firstName, lastName=$lastName, age=$age")
    println("component2()=${r1.component2()}")

    // lo mismo con una clase ordinaria
    val c1 = PersonC("Jean", "Dupont", 30)
    val c2 = PersonC("Jean", "Dupont", 30)
    println(c1)
    println("c1 == c2 : ${c1 == c2}")

    // dos data classes que implementan la misma interfaz
    val e = Teacher("Lucile", "Dumas", 56, 61)
    println(e)
    println(e.identity())
    // la igualdad tiene en cuenta el tipo: una Person no es igual a un Teacher
    val pe = Person("Lucile", "Dumas", 56)
    println("pe == e : ${pe == e}")
    // el tipo común: la interfaz HasIdentity
    val identities = listOf(pe, e)
    for (i in identities) {
        println(i.identity())
    }
}

// una interfaz implementada por las data classes
interface HasIdentity {
    fun identity(): String
}

// una data class: firstName, lastName, age son sus propiedades
data class Person(val firstName: String, val lastName: String, val age: Int) : HasIdentity {
    // se pueden agregar métodos
    override fun identity() = "[$firstName, $lastName, $age]"
}

// no se puede derivar de una data class (es final)
data class Teacher(val firstName: String, val lastName: String, val age: Int, val section: Int) : HasIdentity {
    override fun identity() = "Teacher[[$firstName, $lastName, $age],$section]"
}

// una clase ordinaria equivalente... o casi
class PersonC(val firstName: String, val lastName: String, val age: Int)
  • líneas 50–52: la clase de datos [Person]. La declaración [data class Person(val firstName: String, val lastName: String, val age: Int)] genera, a partir de las propiedades declaradas en el constructor primario:
    • tres propiedades de solo lectura [firstName], [lastName], [age] (lo que también hace una clase normal), a las que se accede por sus nombres: [r1.firstName] (línea 10);
    • un método [toString] que muestra el nombre de la clase y sus propiedades (línea 1 de los resultados);
    • los métodos [equals] y [hashCode], que comparan los valores de las propiedades en lugar de las referencias;
    • un método [copy], que crea una copia del objeto cuyas propiedades pueden modificarse;
    • los métodos [component1], [component2] y [component3], que devuelven las propiedades en el orden en que fueron declaradas y permiten la desestructuración;
  • el constructor primario de una clase de datos debe tener al menos un parámetro, y todos sus parámetros deben ser propiedades ([val] o [var]). Se pueden declarar propiedades de tipo [var]: la clase de datos es entonces mutable. Esto está permitido pero no se recomienda, porque un objeto cuyo [hashCode] cambia se pierde en un conjunto o diccionario que lo contiene; las clases de datos se reservan para datos inmutables;
  • línea 52: una clase de datos, como una clase, puede tener métodos adicionales e implementar interfaces (línea 50);
  • línea 12: [r1] y [r2] son dos objetos distintos ([===], que compara si las referencias son iguales, da como resultado [false]) pero son iguales en el sentido de [==], que llama a [equals], porque sus propiedades tienen los mismos valores. Por lo tanto, sus códigos hash son iguales. En una clase ordinaria, [equals] compara las referencias (línea 28);
  • línea 14: al descomentarla, esta línea es rechazada: ['val' cannot be reassigned];
  • línea 16: una clase de datos inmutable no se puede modificar; se crea una copia modificada. El método generado [copy] tiene un parámetro por cada propiedad, cuyo valor predeterminado es el valor de la propiedad en el objeto copiado; con un argumento con nombre, solo se especifican las propiedades que cambian. Esta es la expresión [with] que faltaba en Java, donde hay que escribir manualmente métodos “wither” ([withAge(31)]);
  • línea 20: desestructuración: las propiedades de *[r1] se extraen en las variables *[firstName]*, *[lastName], y *[age]. El compilador traduce esta declaración a [val firstName = r1.component1()], [val lastName = r1.component2()], etc.: la correspondencia se basa en la posición y no en el nombre (línea 22, el método [component2] se llama directamente). Se puede omitir una propiedad con el carácter [_]: [val (firstName, _, age) = r1]. Esto equivale al patrón de registro (record pattern) de Java 21 ([r1 instanceof Person(String firstName, String lastName, int age)]*); volveremos a la desestructuración con el filtrado por patrones;
  • líneas 56–57: una clase de datos es final; no se puede heredar de ella (la palabra clave [open] está prohibida aquí). Sin embargo, a diferencia de un record de Java, ella misma puede derivar de una clase abierta, abstracta o sellada. Para dar a las clases [Person] y [Teacher] un tipo común, hacemos que implementen la misma interfaz, en este caso [HasIdentity] (líneas 45–46). Por lo tanto, la clase [Teacher] hereda las propiedades de la persona;
  • línea 36: la igualdad de las clases de datos tiene en cuenta el tipo real de los objetos: un [Person] nunca es igual a un [Teacher], incluso si sus propiedades compartidas son iguales;
  • líneas 38–40: la interfaz común permite tratar ambas clases de forma polimórfica. El compilador infiere el tipo de la lista, [List<HasIdentity>]: es el tipo común más específico de los dos elementos;
  • línea 61: una clase ordinaria que se parece a la clase [Person]. Gracias al constructor primario, también cabe en una sola línea… pero no se proporcionan la igualdad por valor, [toString], [copy] ni la desestructuración. En Java, también había que escribir los campos, el constructor y los getters y setters.

Resultados:

> gradlew -q run -Pmain=classes22.Classes22Kt
Person(firstName=Jean, lastName=Dupont, age=30)
firstName=Jean, identity=[Jean, Dupont, 30]
r1 == r2 : true, r1 === r2 : false, equal hashCodes : true
Person(firstName=Jean, lastName=Dupont, age=31)
r1 == r3 : false
firstName=Jean, lastName=Dupont, age=30
component2()=Dupont
classes22.PersonC@4554617c
c1 == c2 : false
Teacher(firstName=Lucile, lastName=Dumas, age=56, section=61)
Teacher[[Lucile, Dumas, 56],61]
pe == e : false
[Lucile, Dumas, 56]
Teacher[[Lucile, Dumas, 56],61]

Observe que el método [toString] de la clase [PersonC] es el mismo que el de la clase [Any]: el nombre completo de la clase seguido de un código hash, que cambia de una ejecución a otra (línea 8 de los resultados), y que la igualdad de los dos objetos [PersonC] es falsa (línea 9). El formato de [toString] para una clase de datos, [Person(firstName=Jean, lastName=Dupont, age=30)], difiere ligeramente del de un record de Java, [Person[firstName=Jean, lastName=Dupont, age=30]].

Resumamos las diferencias entre una clase normal y una clase de datos:

 
Clase
Clase de datos
Igualdad: [==] ([equals])
el mismo objeto (salvo que se redefina)
los mismos valores en las propiedades del constructor primario, el mismo tipo
[toString]
nombre de la clase y código hash
nombre de la clase y propiedades
Propiedades, constructor
declarados por el constructor primario
declarados por el constructor primario (al menos una propiedad, solo propiedades)
estado
editable o no
inmutable con [val] (recomendado); se pueden declarar otras propiedades en el cuerpo
copia modificada
debe escribirse
[copy(prop = value)] generado
desestructuración
debe escribirse ([operator fun componentN])
generada
herencia
de una clase, de varias interfaces; abierta con [open]
de una clase, de varias interfaces; siempre final

Una clase de datos se usa para datos definidos por su valor (una persona obtenida de una base de datos, un mensaje intercambiado por la red, un tramo de impuestos), mientras que una clase ordinaria se usa para un objeto con identidad y comportamiento (un servicio de cálculo, una conexión, una lista mutable). Veremos en el capítulo 11 que las entidades de Hibernate, que tienen identidad, no son clases de datos. Nota: una clase de datos con propiedades de tipo [val] es inmutable “de forma superficial”: si una propiedad hace referencia a un objeto mutable, por ejemplo una [MutableList], el contenido de esa lista sigue siendo mutable. En ese caso, usamos propiedades de solo lectura de tipo [List], inicializadas con una copia ([list.toList()]). Para los lectores que vienen de Java: una clase de datos se compila en una clase de Java normal y final (no en un record); la anotación [@JvmRecord] permite compilarla en un verdadero record de Java si es necesario.

4.11. Constructores de las clases de datos

El constructor primario de una clase de datos simplemente copia sus parámetros en las propiedades. Sin embargo, es posible que se quiera validar o normalizar esos parámetros. Java ofrece para ello el constructor compacto de los records, que puede modificar los parámetros antes de almacenarlos. Kotlin no tiene un equivalente exacto: los parámetros de una clase de datos son sus propiedades y se almacenan tal cual. En cambio, disponemos de las herramientas de cualquier clase: el bloque [init] para la validación, los constructores secundarios y las fábricas del objeto complementario para la normalización. El programa [Classes23.kt] los ilustra:

package classes23

import kotlin.math.sqrt

// constructores de data classes: validación, constructor secundario, fábrica
fun main() {
    val p = Person.create("  Jean ", "Dupont", 30)
    println(p.identity())
    // una data class es inmutable: growOlder devuelve una nueva persona
    val p2 = p.growOlder()
    println("${p.identity()} -> ${p2.identity()}")
    // un constructor secundario
    val unknown = Person("Martin")
    println(unknown.identity())
    // las verificaciones de la fábrica y del bloque init
    try {
        Person.create("Paul", " ", 20)
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    try {
        Person.create("Paul", "Martin", -4)
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    // una data class con una propiedad calculada y un companion object
    val pt = Point(3.0, 4.0)
    println("pt=$pt, distance to the origin: ${pt.distance}, origin=${Point.ORIGIN}")
}

// el constructor primario es privado: una persona se crea con la fábrica create
// o con el constructor secundario; copy es privado como él (@ConsistentCopyVisibility)
@ConsistentCopyVisibility
data class Person private constructor(val firstName: String, val lastName: String, val age: Int) {
    // el bloque init verifica el objeto, sea cual sea la manera en que se construye
    init {
        require(age >= 0) { "invalid age ($age)" }
    }

    // un constructor secundario debe llamar al constructor primario
    constructor(lastName: String) : this("?", validate(lastName, "last name"), 0)

    // un método que devuelve una nueva persona
    fun growOlder() = copy(age = age + 1)

    fun identity() = "[$firstName, $lastName, $age]"

    companion object {
        // la fábrica: verifica y normaliza los parámetros antes de la construcción
        fun create(firstName: String, lastName: String, age: Int) =
            Person(validate(firstName, "first name"), validate(lastName, "last name"), age)

        // una función de validación privada
        private fun validate(value: String, label: String): String {
            require(value.isNotBlank()) { "invalid $label ($value)" }
            return value.trim()
        }
    }
}

data class Point(val x: Double, val y: Double) {
    // una propiedad declarada en el cuerpo de la clase: no forma parte
    // de las propiedades usadas por toString, equals, hashCode, copy
    val distance: Double
        get() = sqrt(x * x + y * y)

    companion object {
        val ORIGIN = Point(0.0, 0.0)
    }
}
  • líneas 36–37: el bloque [init] se ejecuta en cada construcción, después de que se hayan inicializado las propiedades del constructor primario. Valida el objeto: se rechaza una edad negativa. La función [require(condition) { message }] lanza una excepción [IllegalArgumentException] con el mensaje calculado por la lambda si la condición es falsa: es la excepción destinada a un parámetro no válido. Todos los constructores de una clase pasan por el constructor primario y, por lo tanto, por el bloque [init]: no hay manera de crear una [Person] con una edad negativa, ni siquiera con [copy], que también llama al constructor primario;
  • línea 34: el bloque [init] no puede modificar las propiedades [val] del constructor primario, que ya están inicializadas. Para normalizar los parámetros (en este caso, eliminar los espacios alrededor del nombre y del apellido), hacemos privado el constructor primario ([private constructor]) y proporcionamos en su lugar un método de fábrica: la función [create] del objeto complementario (líneas 50–51). Valida y normaliza los parámetros antes de llamar al constructor primario, para lo cual está autorizada porque forma parte de la clase. Se la llama con el nombre de la clase: [Person.create(" Jean ", "Dupont", 30)] (línea 7);
  • línea 33: el método generado [copy] llama al constructor primario; si fuera público, permitiría eludir el método de fábrica ([p.copy(firstName = " x ")]). La anotación [@ConsistentCopyVisibility] indica al compilador que le dé la visibilidad del constructor primario, que aquí es privada. Sin ella, Kotlin 2.4 emite la advertencia [non-public primary constructor is exposed via the generated 'copy()' method of the 'data' class], que especifica que la visibilidad del método generado [copy] cambiará en una versión futura (tendrá entonces la misma visibilidad que el constructor);
  • línea 41: un constructor secundario, que recibe solo el nombre. Como cualquier constructor secundario de una clase con constructor primario, debe llamar al constructor primario con [: this(...)]; para calcular los parámetros, puede llamar a funciones del objeto complementario, incluso privadas ([validate]). Un constructor secundario puede ser público cuando el constructor primario es privado;
  • línea 44: una clase de datos es inmutable: envejecer significa crear una nueva instancia, lo que se hace con el método [copy] (privado, pero utilizable dentro de la clase);
  • líneas 54–56: una función de validación privada en el objeto complementario. [isNotBlank()] devuelve true si la cadena contiene algo más que espacios; [trim()] elimina los espacios iniciales y finales de la cadena. El mensaje de error se construye con una plantilla de cadena dentro de la lambda pasada a [require]: se calcula solo si ocurre un error;
  • líneas 61–68: una clase de datos puede tener, además de las propiedades de su constructor primario, propiedades declaradas en su cuerpo; en este caso, la propiedad calculada [distance]. Estas no contribuyen a [toString], [equals], [hashCode] ni a [copy]. También puede tener un objeto complementario, en este caso con la propiedad [ORIGIN], que equivale al campo estático de la versión de Java. (A diferencia de un record, una clase de datos puede incluso tener propiedades almacenadas en su cuerpo, pero esto es de poca utilidad para datos inmutables.)

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=classes23.Classes23Kt
[Jean, Dupont, 30]
[Jean, Dupont, 30] -> [Jean, Dupont, 31]
[?, Martin, 0]
invalid last name ( )
invalid age (-4)
pt=Point(x=3.0, y=4.0), distance to the origin: 5.0, origin=Point(x=0.0, y=0.0)

El nombre, proporcionado con espacios a ambos lados (línea 7), se almacenó sin ellos (líneas 1 y 2 de los resultados). El bloque [init] es la forma idiomática de garantizar que un objeto sea siempre válido; una fábrica, con un constructor privado, permite además normalizar los datos.

4.12. Funciones de extensión

¿Cómo se agrega un método a una clase que no se puede modificar, como la clase [String]? Java no ofrece una solución integrada: se escriben métodos estáticos, agrupados en una clase de utilidades ([Arrays], [Collections], [Objects], [Math]…), y se los llama con el nombre de su clase, pasando el objeto como parámetro: [Tools.initials(p)]. Kotlin, como C# con sus métodos de extensión, ofrece funciones de extensión: funciones declaradas fuera de la clase que se usan como métodos de la clase extendida: [p.initials()]. Las usamos desde el comienzo de este curso: [toInt], [sumOf], [contentToString], [toMutableList], [repeat], [also]… son funciones de extensión de la biblioteca de Kotlin, que enriquecen las clases del JDK ([String], arreglos, colecciones) sin modificarlas. El programa [Classes24.kt] muestra cómo escribir las propias:

package classes24

import java.time.DayOfWeek
import java.time.LocalDate

// funciones y propiedades de extensión
fun main() {
    val p = Person("jean", "dupont", 30)
    // las funciones de extensión se llaman como métodos del objeto
    println(p.initials())
    println("jean".firstUpper())
    println("${p.fullName} is an adult: ${p.isAdult}")
    println("\"the weather is fine\" has ${"the weather is fine".nbWords()} words")
    // una función del companion object de la propia clase
    val unknown = Person.unknown()
    println("${unknown.fullName} is an adult: ${unknown.isAdult}")
    // una extensión de una clase de Java
    val date = LocalDate.of(2026, 10, 4)
    println("$date is a weekend day: ${date.isWeekend}")
    // una extensión de un tipo que admite nulos: se puede llamar sobre null
    val absent: Person? = null
    println("${p.description()} / ${absent.description()}")
    // la resolución de las extensiones es estática: lo que cuenta es el tipo declarado
    val shape: Shape = Square()
    println("shape.name()=${shape.name()}, Square().name()=${Square().name()}")
    // ...mientras que la llamada a un método sobrescrito es polimórfica
    println("shape.category()=${shape.category()}")
}

// una persona
data class Person(val firstName: String, val lastName: String, val age: Int) {
    companion object {
        // fábrica: una persona desconocida
        fun unknown() = Person("?", "?", 0)
    }
}

// funciones de extensión de la clase Person
fun Person.initials() = "${firstName[0].uppercaseChar()}.${lastName[0].uppercaseChar()}."

// propiedades de extensión (calculadas: una extensión no puede almacenar un valor)
val Person.isAdult: Boolean
    get() = age >= 18

val Person.fullName: String
    get() = "${firstName.firstUpper()} ${lastName.uppercase()}"

// funciones de extensión de la clase String
fun String.firstUpper() = if (isEmpty()) this else this[0].uppercaseChar() + substring(1)

fun String.nbWords() = if (isBlank()) 0 else trim().split(Regex("\\s+")).size

// una propiedad de extensión de una clase del JDK
val LocalDate.isWeekend: Boolean
    get() = dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY

// una función de extensión de un tipo que admite nulos
fun Person?.description() = if (this == null) "absent person" else "person $firstName"

// resolución estática de las extensiones
open class Shape {
    open fun category() = "shape"
}

class Square : Shape() {
    override fun category() = "square"
}

fun Shape.name() = "a shape"

fun Square.name() = "a square"
  • línea 39: una función de extensión para la clase [Person]. El nombre de la función lleva como prefijo el tipo extendido, conocido como tipo receptor ([Person.]). En el cuerpo de la función, [this] se refiere al objeto sobre el que se llama a la función (el receptor) y se accede a sus miembros sin prefijo, igual que en un método: [firstName], [lastName]. [firstName[0]] devuelve el primer carácter de la cadena y [uppercaseChar()] lo convierte en mayúscula;
  • líneas 42–46: dos propiedades de extensión. Se declaran como las funciones, con un tipo receptor, y deben tener un método de acceso [get]: una extensión no agrega nada al objeto, por lo que no puede almacenar un valor (una propiedad de extensión no tiene campo y no puede tener inicializador). Se leen como propiedades: [p.isAdult], [p.fullName] (línea 12);
  • líneas 49–51: dos extensiones de la clase [String], usadas como métodos de cualquier cadena: ["jean".firstUpper()]. En [firstUpper], [this] es la propia cadena. La función [nbWords] divide la cadena con la función [split], a la que se pasa una expresión regular ([Regex]): ["\\s+"] designa una secuencia de uno o más caracteres de espacio (las expresiones regulares se tratan en el capítulo 5);
  • líneas 54–55: una propiedad de extensión de una clase de Java del JDK, [java.time.LocalDate]. Una extensión se aplica a cualquier tipo, incluida una clase de Java o una clase final. Observe que Kotlin trata el método [getDayOfWeek] de la clase de Java como una propiedad [dayOfWeek];
  • línea 58: una extensión de un tipo que admite valores nulos, [Person?]. Se la puede llamar sobre una referencia a [null] sin el operador [?.] (línea 22): esto es lo que verifica si [this] es igual a [null]. Después de la verificación, el compilador sabe que [this] no es [null] en la rama [else] y permite acceder a [firstName] (es la conversión inteligente de tipos, que el párrafo siguiente explica con más detalle). La función [toString()] de la biblioteca de Kotlin, que se puede llamar sobre una referencia nula, se declara así: [fun Any?.toString(): String];
  • líneas 8–13: las funciones y propiedades de extensión se llaman como miembros: [p.initials()], no [Tools.initials(p)];
  • líneas 32–34: cuando el tipo se puede modificar, sus métodos se colocan de forma natural en él: la fábrica [unknown] es una función del objeto complementario de la clase [Person] (línea 15);
  • líneas 61–71: una clase [Shape] y su clase derivada [Square], cada una dotada de un método redefinido [category] y de una función de extensión [name]. En la línea 25, la variable [shape], declarada de tipo [Shape], hace referencia a un [Square]: sin embargo, la llamada a [shape.name()] ejecuta en realidad la extensión de [Shape]. La resolución de las extensiones es estática: el compilador elige la función según el tipo declarado de la variable y no según el tipo real del objeto en tiempo de ejecución. En la línea 27, el método [category] es polimórfico: se ejecuta el método de la clase [Square].

Resultados:

> gradlew -q run -Pmain=classes24.Classes24Kt
J.D.
Jean
Jean DUPONT is an adult: true
"the weather is fine" has 4 words
? ? is an adult: false
2026-10-04 is a weekend day: true
person jean / absent person
shape.name()=a shape, Square().name()=a square
shape.category()=square

Este comportamiento se explica por la forma en que el compilador traduce una función de extensión: en un método estático cuyo primer parámetro es el receptor. La función [fun Person.initials()] del archivo [Classes24.kt] se convierte en el método de Java [public static final String initials(Person $this$initials)] de la clase [classes24.Classes24Kt] (la propiedad de extensión *[isAdult] se convierte igualmente en un método estático ***[isAdult(Person)]), y la llamada ***[p.initials()] se convierte en ***[Classes24Kt.initials(p)]**. En otras palabras, Kotlin escribe por nosotros la clase de utilidades de Java y hace su uso más legible. Un programa de Java que usa una biblioteca de Kotlin llama a sus extensiones de esta manera. De ello se derivan varias reglas:

  • una extensión tiene acceso solo a los miembros públicos del receptor: no puede ver sus miembros privados ni protegidos;
  • una extensión no se puede redefinir en una clase derivada: no es polimórfica;
  • si la clase tiene un miembro con la misma firma, siempre se llama a ese miembro, y el compilador advierte que la extensión es innecesaria ([this extension is shadowed by a member: 'fun g(): Int' defined in 'C']);
  • para usarla en otro paquete, una extensión debe importarse, igual que una función de nivel superior ([import tools.initials]).

Las funciones de extensión son una de las características más distintivas de Kotlin. Sirven para enriquecer tipos sobre los que no tenemos control, pero también para separar, dentro de nuestras propias clases, el núcleo de la clase (sus miembros) de las funciones de utilidad que solo acceden a ella desde el exterior. En el capítulo 7 veremos las lambdas con receptor, que se basan en el mismo principio ([buildString { append(...) }]).

4.13. Coincidencia de patrones en objetos

La expresión [when] no se limita a valores simples (números, cadenas, enumeraciones): también se aplica a objetos. Se puede verificar el tipo de un objeto, agregar una condición y usar el objeto con el tipo correcto sin conversión explícita, todo en una sola expresión. Kotlin no tiene, estrictamente hablando, “patrones” como Java 21: logra esencialmente el mismo resultado mediante el operador [is], la conversión inteligente de tipos y la desestructuración. El programa [Classes25.kt] usa una interfaz sellada y tres clases de datos que la implementan:

package classes25

// coincidencia de patrones sobre objetos: is, smart cast, when, desestructuración
fun main() {
    val objects: List<Any?> = listOf(
        Individual("Jean", "Dupont", 30),
        Individual("Lise", "Morel", 12),
        Teacher("Lucile", "Dumas", 56, 61),
        Teacher("Marc", "Petit", 44, 27),
        Student("Paul", "Martin", 19, "computer science"),
        "a string",
        42,
        null,
    )

    // 1 - la prueba de tipo is y el smart cast
    for (o in objects) {
        if (o is Person) {
            // aquí o es una Person
            println("${o.firstName} is of type ${o::class.simpleName}")
        }
    }

    // 2 - la prueba de tipo seguida de una condición
    for (o in objects) {
        if (o is Person && o.age >= 18) {
            println("${o.firstName} is an adult")
        }
    }

    // 3 - when sobre el tipo del objeto, con guardias y desestructuración
    for (o in objects) {
        println(describe(o))
    }

    // 4 - un when exhaustivo sobre una interfaz sellada
    for (o in objects) {
        if (o is Person) {
            println("${o.firstName} : ${category(o)}")
        }
    }

    // 5 - las conversiones explícitas as y as?
    val first = objects[0] as Person
    val string = objects[0] as? String
    println("first=${first.firstName}, string=$string")
    try {
        val s = objects[0] as String
        println(s)
    } catch (ex: ClassCastException) {
        println("ClassCastException : ${ex.message}")
    }
}

fun describe(o: Any?): String = when (o) {
    is Teacher if o.section == 27 -> "${o.firstName} teaches computer science"
    is Teacher -> "${o.firstName} teaches in section ${o.section}"
    is Student -> {
        val (firstName, _, _, major) = o
        "$firstName studies $major"
    }
    is Person if o.age < 18 -> "${o.firstName} is a minor"
    is Person -> "${o.firstName} is ${o.age} years old"
    is String -> "a string of ${o.length} characters"
    is Int if o > 0 -> "the positive integer $o"
    null -> "the null reference"
    else -> "an unknown object"
}

// sin else: el compilador sabe que los tres casos cubren todas las personas
fun category(p: Person) = when (p) {
    is Individual -> "individual"
    is Teacher -> "teacher"
    is Student -> "student"
}

// una interfaz sellada y las tres data classes que la implementan
sealed interface Person {
    val firstName: String
    val lastName: String
    val age: Int
}

data class Individual(override val firstName: String, override val lastName: String, override val age: Int) : Person

data class Teacher(
    override val firstName: String,
    override val lastName: String,
    override val age: Int,
    val section: Int,
) : Person

data class Student(
    override val firstName: String,
    override val lastName: String,
    override val age: Int,
    val major: String,
) : Person
  • líneas 78–97: una interfaz sellada [Person] ([sealed interface]), implementada por tres clases de datos: [Individual], [Teacher] y [Student]. Al igual que una clase sellada (véase la sección “Clases finales, abiertas y selladas”), una interfaz sellada solo puede ser implementada por clases del mismo paquete y del mismo módulo: el compilador conoce, por lo tanto, todas sus implementaciones sin necesidad de enumerarlas explícitamente, como exige la cláusula de Java [permits]. La interfaz declara las propiedades abstractas [firstName], [lastName] y [age]; las clases de datos las implementan mediante propiedades de su constructor primario, con el prefijo [override];
  • líneas 5–13: una lista de objetos de varios tipos, entre ellos un entero y la referencia [null]. Su tipo es [List<Any?>]: [Any?] es el tipo más general de Kotlin, que acepta cualquier objeto y el valor [null];
  • línea 18: la expresión [o is Person] es verdadera si [o] hace referencia a un objeto de tipo [Person] (es falsa si [o] es igual a [null]). En el bloque siguiente, el compilador sabe que [o] es un [Person]: permite [o.firstName] sin conversión. Esta es la conversión inteligente de tipos: se prueba el tipo de una variable, y la propia variable cambia de tipo allí donde la prueba es verdadera con certeza. Java 16 logra el mismo resultado declarando una nueva variable ([o instanceof Person p]); Kotlin no necesita hacerlo. La conversión inteligente de tipos se aplica a las variables locales [val], a las variables [var] que no han cambiado entre la prueba y el uso, y a las propiedades [val] del mismo módulo sin métodos de acceso personalizados: el compilador debe tener la certeza de que el valor no pudo haber cambiado entre la prueba y el uso;
  • línea 26: la conversión inteligente de tipos también se aplica en el resto de la condición, después de [&&];
  • líneas 55–67: la expresión [when] con sujeto evalúa las ramas en orden y devuelve el valor asociado a la primera que coincide:
    • línea 56: un profesor de la sección 27. En una rama [is Type], se aplica la conversión inteligente de tipos al sujeto [o] ; la cláusula [if] agrega una condición, llamada guarda (Kotlin 2.2), que equivale a [when] en los patrones de Java;
    • línea 57: cualquier otro profesor. El orden es importante: si se la colocara antes de la anterior, este caso la habría vuelto inaccesible. El compilador de Kotlin no lo señala (Java lo rechazaría): la rama simplemente nunca se elegiría;
    • líneas 58–60: un estudiante, cuyas propiedades se extraen mediante desestructuración: [val (firstName, _, _, major) = o] llama a [component1()] y a [component4()] de la clase de datos ([_] ignora una propiedad). Esto equivale al patrón de registro de Java ([case Student(var firstName, _, _, var major)]), en dos pasos: la verificación del tipo, seguida de la desestructuración. Una rama puede contener un bloque; su valor es el de la última expresión del bloque;
    • líneas 62–63: un menor de edad y luego cualquier otra persona;
    • línea 64: una cadena, cuya propiedad [length] se puede utilizar;
    • línea 65: un entero positivo. Se verifica el tipo [Int], no [Integer] como en Java;
    • línea 66: el caso [null], un valor simple, comparado con el sujeto mediante [==]. Sin este caso, la referencia nula caería en la rama [else]: un [when] sobre una referencia nula nunca lanza una excepción;
    • línea 67: la rama [else] cubre todo lo demás. Sin ella, el compilador informaría que la expresión [when] no maneja todos los casos: una expresión [when], que devuelve un valor, debe ser exhaustiva;
  • líneas 71–74: un [when] sobre una [Person], sin una rama [else]. Sin embargo, es exhaustivo: como la interfaz es sellada, el compilador sabe que una persona es un [Individual], un [Teacher] o un [Student];
  • líneas 44–51: conversiones explícitas de tipo. [o as Person] convierte [o] a [Person] y lanza una excepción [ClassCastException] si el objeto no es una persona (línea 48); equivale a [(Person) o] en Java. [o as? String] es la conversión de tipo “segura”: devuelve [null] en lugar de lanzar una excepción, lo que funciona bien con el operador Elvis ([o as? String ?: "default"]). Con la conversión inteligente de tipos, esto rara vez es necesario.

Resultados:

> gradlew -q run -Pmain=classes25.Classes25Kt
Jean is of type Individual
Lise is of type Individual
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference
Jean : individual
Lise : individual
Lucile : teacher
Marc : teacher
Paul : student
first=Jean, string=null
ClassCastException : class classes25.Individual cannot be cast to class java.lang.String (classes25.Individual is in unnamed module of loader 'app'; java.lang.String is in module java.base of loader 'bootstrap')

Si elimina el caso [Student] de la función [category], el compilador lo señala:

Classes25.kt:71:27: error: 'when' expression must be exhaustive. Add the 'is Student' branch or an 'else' branch.

Este es el gran beneficio de combinar tipos sellados con la expresión [when]: si se agrega una cuarta clase a la jerarquía, el compilador señala todas las instancias de [when] como pendientes de completar. Observe también que la prueba [is] corresponde a los tipos que implementan la interfaz: el bucle de verificación de tipos (líneas 16–20) ha identificado los tres tipos de personas. La prueba [when] sobre tipos es un reemplazo útil de las pruebas [if (o is ...)] en cascada; sin embargo, no debe sustituir al polimorfismo: cuando el comportamiento depende del tipo del objeto y usted controla la jerarquía de clases, un método redefinido en cada clase suele ser la solución orientada a objetos. El filtrado mediante [when] es adecuado para jerarquías de datos (clases de datos selladas) sobre las que se desea escribir una lógica de procesamiento externa a esos datos.

4.14. Manejo del valor null

En Java, cualquier variable de tipo referencia puede ser null, y usar una referencia nula provoca la excepción NullPointerException, el error de ejecución más común. Vimos en el Capítulo 3 cómo lo maneja Kotlin: el compilador distingue entre los tipos que pueden ser [null] ([String?]) y los que no ([String]), y solo permite acceder a los miembros de una referencia anulable después de una verificación, o mediante los operadores [?.], [?:], y [!!]. Donde Java usa la clase [Optional<T>], los métodos [Objects.requireNonNull] y [Objects.requireNonNullElse] , o anotaciones como las de la biblioteca JSpecify ([@Nullable], [@NullMarked]), Kotlin se apoya en el propio sistema de tipos. Aquí exploramos estos conceptos con más detalle en el contexto de las clases: propiedades anulables, propiedades de inicialización tardía y la frontera con el código Java. El programa [Classes26.kt] retoma el ejemplo de la versión Java:

package classes26

// manejo del valor null en las clases: tipos que admiten nulos, ?., ?:, ?.let, requireNotNull, !!,
// lateinit, tipos de plataforma
fun main() {
    val jean = Person("Jean", "Dupont")
    jean.middleName = "Marie"
    val persons = listOf(jean, Person("Paul", "Martin"))
    for (p in persons) {
        // un valor por defecto cuando la referencia es null: el operador Elvis
        val middle = p.middleName ?: "(none)"
        // la llamada segura ?.: null si la referencia es null
        val length = p.middleName?.length
        println("${p.firstName} : middle name=$middle, length=$length")
    }

    // una función que puede no encontrar nada: devuelve una Person?
    var found = find(persons, "Durand")
    println("Durand found: ${found != null}")
    println(found?.firstName ?: "Durand: person not found")
    // la referencia se prueba antes de usarse: smart cast
    found = find(persons, "Martin")
    if (found != null) {
        println("Martin : ${found.firstName}")
    }
    // ?.let: el bloque se ejecuta solo si la referencia no es nula
    find(persons, "Dupont")?.let { it.middleName = "Louise" }
    find(persons, "Durand")?.let { it.middleName = "Louise" }
    println(jean.middleName)
    // requireNotNull: afirmamos que la referencia no es nula, de lo contrario se lanza una excepción
    val martin = requireNotNull(find(persons, "Martin")) { "Martin cannot be found" }
    println(martin.firstName)
    try {
        requireNotNull(find(persons, "Durand")) { "Durand cannot be found" }
    } catch (ex: IllegalArgumentException) {
        println("Error: ${ex.message}")
    }
    // el operador !!: una NullPointerException si la referencia es null
    try {
        val lise = Person("Lise", "Morel")
        println(lise.middleName!!.length)
    } catch (ex: NullPointerException) {
        println("Error: $ex")
    }

    // una propiedad lateinit: inicializada después de la construcción
    val paul = persons[1]
    println("Paul's email initialized: ${paul.hasEmail}")
    try {
        println(paul.email)
    } catch (ex: UninitializedPropertyAccessException) {
        println("Error: ${ex.message}")
    }
    paul.email = "paul.martin@example.com"
    println("Paul's email: ${paul.email}, initialized: ${paul.hasEmail}")

    // tipos de plataforma: un método de Java puede devolver null
    val variable = System.getenv("NONEXISTENT_VARIABLE")
    println("variable=$variable, length=${variable?.length}")
    try {
        val value: String = System.getenv("NONEXISTENT_VARIABLE")
        println(value.length)
    } catch (ex: NullPointerException) {
        println("Error: ${ex.message}")
    }
}

// búsqueda de una persona por apellido: null si no se encuentra
fun find(persons: List<Person>, lastName: String): Person? = persons.firstOrNull { it.lastName == lastName }

class Person(val firstName: String, val lastName: String) {
    // propiedad opcional: null significa "sin segundo nombre"
    var middleName: String? = null

    // propiedad obligatoria, pero inicializada después de la construcción
    lateinit var email: String

    // ¿se ha inicializado la propiedad lateinit?
    val hasEmail: Boolean
        get() = this::email.isInitialized
}
  • Líneas 71–80: la clase [Person] tiene dos propiedades obligatorias, de tipo [String], inicializadas por el constructor primario, y una propiedad opcional, [middleName], de tipo [String?]: [null] significa “sin segundo nombre”. El constructor no necesita validar sus parámetros como lo hacía la versión Java con [Objects.requireNonNull]: el compilador rechaza una llamada a [Person(null, "Morel")] ([null cannot be a value of a non-null type 'String']). El error se detecta incluso antes de la ejecución;
  • línea 11: el operador Elvis [?:] devuelve el valor de la izquierda si no es igual a [null], y el valor de la derecha en caso contrario. Equivale a [Objects.requireNonNullElse(value, defaultValue)];
  • línea 13: la llamada segura [?.] devuelve [null] si la referencia es [null], y en caso contrario la longitud de la cadena: [length] es de tipo [Int?]. El acceso directo a [p.middleName.length] es rechazado por el compilador: [only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'String?'];
  • línea 69: la función [find] devuelve a la persona buscada, o [null] si no la encuentra: su tipo de retorno, [Person?], advierte al llamador que el resultado puede faltar, y el compilador exige que el llamador maneje este caso para poder usar a la persona. Este es el papel que desempeña [Optional<Person>] en Java, sin objetos adicionales. La función de extensión [firstOrNull] devuelve el primer elemento de la lista que cumple la condición, o [null];
  • línea 19: la presencia de un valor se prueba comparándolo con [null] (el equivalente de [isPresent()]);
  • línea 20: la combinación [?.] seguida de [?:] convierte a cualquier persona presente en su nombre y proporciona un valor predeterminado. Equivale a [found.map(Person::getFirstName).orElse(...)];
  • Líneas 23–24: después de la prueba [found != null], la conversión inteligente de tipo cambia [found] a [Person] dentro del bloque: se accede directamente a [found.firstName]. La conversión inteligente de tipo funciona aquí aunque [found] sea una variable de tipo [var], porque no se modifica entre la prueba y su uso;
  • Líneas 27–28: [x?.let { ... }] ejecuta el bloque solo si [x] no es igual a [null]; dentro del bloque, [it] se refiere al valor, que es de un tipo no anulable. Equivale a [ifPresent]. Dupont existe y se le asigna un nuevo segundo nombre; Durand no existe, y la instrucción no hace nada;
  • Línea 31: [requireNotNull(value) { message }] devuelve el valor si no es [null], como un tipo no anulable, y en caso contrario lanza una excepción [IllegalArgumentException] con el mensaje especificado (líneas 34–36). Se usa cuando la ausencia de un valor constituye un error: es el equivalente de [orElseThrow]. Su contraparte, [checkNotNull], lanza una excepción [IllegalStateException];
  • Líneas 40–41: el operador [!!] verifica si la referencia es igual a [null] y, si lo es, lanza la excepción [NullPointerException] . Aquí, la excepción no tiene mensaje: se prefieren [requireNotNull] o [checkNotNull], que sí proporcionan uno. El operador [!!] debe reservarse para los casos en que usted tiene la certeza… y el compilador no puede saberlo;
  • Línea 76: una propiedad [lateinit] (“inicializada tarde”). Una propiedad no anulable normalmente debe inicializarse en la construcción. Pero algunos valores solo se conocen después: una dependencia inyectada por Spring (Capítulo 6), un objeto preparado por un método de inicialización de pruebas, etc. En lugar de declarar la propiedad como anulable —y tener que escribir [?.] o [!!] cada vez que se usa— la declaramos como [lateinit var]: es de tipo [String] y se usa como tal. Una propiedad marcada como [lateinit] debe ser una [var] de un tipo no anulable y no primitivo ([lateinit var n: Int] está prohibido);
  • líneas 50–51: la lectura de una propiedad [lateinit] antes de que se inicialice lanza la excepción [UninitializedPropertyAccessException], cuyo mensaje nombra la propiedad; esto es más claro que una excepción [NullPointerException] que ocurra más tarde;
  • líneas 79–80: la expresión [this::email.isInitialized] indica si la propiedad ha sido inicializada. [this::email] es una referencia a propiedad (Capítulo 7); esta prueba solo se permite dentro de la clase que declara la propiedad;
  • líneas 58–62: la frontera con Java. El método Java [System.getenv(name)] devuelve el valor de una variable de entorno, o [null] si no existe; sin embargo, nada en su firma Java se lo indica al compilador de Kotlin. Su valor de retorno tiene un tipo de plataforma, denotado como [String!] en los mensajes del compilador y en IntelliJ IDEA: un tipo para el cual Kotlin no sabe si es anulable, y que permite al desarrollador usar como *[String] o como *[String?], bajo su propio riesgo. En la línea 58, la variable [variable] es del tipo de plataforma, y la tratamos con cautela mediante [?.]. En la línea 61, afirmamos que no es nula declarándola como [String]: el compilador inserta entonces una verificación, y la excepción [NullPointerException] se lanza inmediatamente en la asignación, con un mensaje que identifica el método responsable ([getenv(...) must not be null]), en lugar de más tarde, durante el uso. Cuando el código Java está anotado ([@Nullable], [@NonNull] de JSpecify, o de JetBrains), Kotlin lo tiene en cuenta y el tipo deja de ser un tipo de plataforma: es el caso de gran parte de Spring Framework 7, que utilizaremos.

Resultados:

> gradlew -q run -Pmain=classes26.Classes26Kt
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand found: false
Durand: person not found
Martin : Paul
Louise
Paul
Error: Durand cannot be found
Error: java.lang.NullPointerException
Paul's email initialized: false
Error: lateinit property email has not been initialized
Paul's email: paul.martin@example.com, initialized: true
variable=null, length=null
Error: getenv(...) must not be null

La clase Java *[Optional]* sigue siendo utilizable en Kotlin cuando una biblioteca Java proporciona una (la función de extensión ***[getOrNull()] del paquete *[kotlin.jvm.optionals] la convierte entonces en un tipo anulable), pero no la usamos en el código Kotlin: un tipo anulable hace lo mismo —verificado por el compilador— sin crear un objeto. En este curso, declaramos como anulables solo los valores opcionales; preferimos los objetos siempre completos (construidos con todos sus valores obligatorios) a los objetos poblados de forma incremental; reservamos [lateinit] para las propiedades inicializadas por un framework, y manejamos con cautela los valores provenientes de Java.

4.15. Aplicación de ejemplo - V2

Retomamos el cálculo del impuesto ya tratado en el capítulo anterior (versión 1) y ahora lo implementamos usando clases e interfaces. Recordemos el problema. Queremos escribir un programa para calcular el impuesto de un contribuyente. Consideraremos el caso simplificado de un contribuyente que solo debe declarar su salario (la tabla de impuestos de 2004 para los ingresos de 2003, usada tal cual: es un ejercicio):

  • se calcula el número de partes del empleado: partes = nbChildren / 2 + 1 si no está casado, nbChildren / 2 + 2 si está casado, donde nbChildren es el número de sus hijos;
  • si tiene al menos tres hijos, recibe media parte adicional;
  • su ingreso gravable R se calcula como R = 0.72 × S, donde S es su salario anual;
  • se calcula su cociente familiar como QF = R / partes;
  • su impuesto I se calcula usando la tabla siguiente:
límite
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada fila tiene tres campos. Para calcular el impuesto I, se busca la primera fila donde QF ≤ el límite. Por ejemplo, si QF = 5,000, se encontrará la fila (8,382; 0.068; 291.09). El impuesto I es entonces igual a 0.068 × R - 291.09 × partes. Si QF es tal que la condición QF ≤ límite nunca se cumple, se usan los coeficientes de la última fila, lo que da un impuesto I = 0.481 × R - 9,505.54 × partes.

La aplicación crea el paquete [taxv2]. Las clases de cálculo se organizan en un subpaquete [taxv2.tax]:

1
2
3
4
5
6
7
src/main/kotlin/taxv2/
  Main.kt                   the dialog program with the user
  tax/
    TaxBracket.kt           a bracket of the tax scale
    ITax.kt                 the tax calculation interface
    AbstractTax.kt          an abstract class implementing ITax
    HardwiredTax.kt         a derived class, with hard-coded data

Primero, definimos un tipo capaz de encapsular una fila de la tabla anterior [TaxBracket.kt]:

1
2
3
4
5
6
package taxv2.tax

import java.math.BigDecimal

// un tramo de la escala de impuestos
data class TaxBracket(val limit: BigDecimal, val coeffR: BigDecimal, val coeffN: BigDecimal)

Usamos una clase de datos:

  • porque un tramo es un pequeño dato sin identidad, definido únicamente por su valor, y no hay razón para modificarlo una vez creado: sus propiedades son [val];
  • porque el compilador genera [toString], el operador de igualdad, [copy], y la desestructuración a partir de una sola línea.

Las propiedades son de tipo [BigDecimal] (paquete [java.math], de ahí la importación en la línea 3): Kotlin usa esta clase directamente del JDK. Los tipos [Float] y [Double] representan números en binario: un número decimal como 0.068 no tiene representación exacta en estos tipos, y los cálculos acumulan pequeños errores de redondeo. La clase [BigDecimal] representa números decimales de forma exacta: es el tipo que se debe usar para los montos. En Java, su inconveniente es la falta de operadores: hay que escribir [a.add(b)], [a.multiply(b)], [a.compareTo(b)]. La biblioteca de Kotlin agrega los operadores [+], [-], [*], [/], [%], y el operador de menos unario; y dado que [BigDecimal] implementa [Comparable], los operadores de comparación [<], [<=]… también se aplican. Aprovecharemos esto, con una excepción: la división.

Luego definimos una interfaz [ITax] capaz de calcular el impuesto [ITax.kt]:

1
2
3
4
5
6
package taxv2.tax

interface ITax {
    // cálculo del impuesto de un contribuyente
    fun calculate(married: Boolean, nbChildren: Int, salary: Int): Int
}
  • Línea 5: el método para calcular el impuesto a partir de tres datos: el estado civil del contribuyente, el número de hijos y el salario anual. Redondea el impuesto hacia abajo al euro más cercano.

A continuación, definimos una clase abstracta que implementa esta interfaz [AbstractTax.kt]:

package taxv2.tax

import java.math.BigDecimal
import java.math.MathContext

abstract class AbstractTax : ITax {
    // los tramos impositivos necesarios para el cálculo provienen de una fuente externa
    // que solo conocen las clases derivadas
    protected abstract val taxBrackets: List<TaxBracket>

    // cálculo del impuesto
    override fun calculate(married: Boolean, nbChildren: Int, salary: Int): Int {
        // cálculo del número de partes
        var shares = nbChildren.toBigDecimal().divide(BigDecimal.TWO) + (if (married) 2 else 1).toBigDecimal()
        if (nbChildren >= 3) {
            shares += BigDecimal("0.5")
        }
        // cálculo del ingreso imponible y del cociente familiar
        val income = BigDecimal("0.72") * salary.toBigDecimal()
        val quotient = income.divide(shares, MathContext.DECIMAL128)
        // búsqueda del tramo impositivo: se usa el último si ningún límite corresponde
        val brackets = taxBrackets
        val bracket = brackets.dropLast(1).firstOrNull { quotient <= it.limit } ?: brackets.last()
        // cálculo del impuesto
        return (income * bracket.coeffR - shares * bracket.coeffN).toInt()
    }
}
  • Línea 1: la clase pertenece al paquete [taxv2.tax]; su archivo se almacena en la carpeta [taxv2/tax];
  • línea 6: la clase [AbstractTax] implementa la interfaz [ITax];
  • línea 9: los datos del baremo, proporcionados por una propiedad abstracta protegida (la versión Java usaba un método abstracto [getTaxBrackets()]). La clase [AbstractTax] no sabe de dónde provienen estos datos (escritos en el código, leídos de un archivo, de una base de datos, etc.). Deja esta tarea a las clases derivadas. Por eso se declara abstracta, lo que impide instanciarla. La propiedad abstracta obliga a las clases derivadas a proporcionar los tramos del impuesto: el compilador lo verifica. Su tipo, [List<TaxBracket>], es el de una lista de solo lectura: la clase no puede modificar el baremo que se le proporciona;
  • Líneas 12–25: la implementación del método [calculate] de la interfaz [ITax]. Las clases derivadas no necesitarán sobrescribir este método. La clase [AbstractTax] sirve así como clase base para las clases derivadas: contiene lo que es común a todas ellas;
  • línea 14: el número de partes. La función de extensión [toBigDecimal()] convierte un entero a [BigDecimal] (como [BigDecimal.valueOf(n)]); la división entre [BigDecimal.TWO] es exacta (3 / 2 = 1.5), a diferencia de la división entera entre [nbChildren / 2] (3 / 2 = 1). La expresión [if (married) 2 else 1] es igual a 2 para un contribuyente casado, y a 1 en caso contrario. La suma se escribe con el operador [+]. En cambio, la división se realiza con el método [divide] de Java, no con el operador [/]: el operador [/] de Kotlin aplicado a [BigDecimal] conserva el número de decimales del dividendo y redondea el resultado; [3.toBigDecimal() / BigDecimal.TWO] ¡es igual a 2, no a 1.5! Es una trampa conocida que conviene evitar escribiendo siempre las divisiones de [BigDecimal] con [divide], que obliga a pensar en la precisión deseada;
  • Líneas 15–16: la media parte adicional. Un [BigDecimal] es inmutable: [shares += x] se convierte en [shares = shares + x], lo que crea un nuevo objeto asignado a la variable; por eso [shares] es una [var];
  • Líneas 19–20: el ingreso gravable y el cociente familiar. Las constantes decimales se crean a partir de cadenas ([BigDecimal("0.72")]) para garantizar que sean exactas. Dividir un [BigDecimal] puede producir un número infinito de decimales (1 / 3): especificamos la precisión deseada, en este caso [MathContext.DECIMAL128] (34 dígitos significativos);
  • línea 23: búsqueda del intervalo, en una sola línea. [brackets.dropLast(1)] devuelve la lista de tramos excepto el último; [firstOrNull { quotient <= it.limit }] busca el primer tramo cuyo límite es mayor o igual que el cociente familiar (el operador [<=] llama a [compareTo]), o devuelve [null] si no hay ninguno; el operador Elvis devuelve entonces el último tramo ([brackets.last()]). La versión Java usaba un bucle [for] y un [break]; las dos expresiones son equivalentes;
  • línea 25: el cálculo del impuesto, escrito con los operadores [*] y [-], es mucho más legible que [income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN()))]. La función [toInt] trunca el resultado a su parte entera.

Una clase que implementa la interfaz [ITax] puede crearse derivando de la clase [AbstractTax]. Eso es lo que hacemos ahora con [HardwiredTax.kt]:

package taxv2.tax

class HardwiredTax : AbstractTax() {
    // los tramos impositivos, construidos a partir de los datos escritos directamente en el código
    override val taxBrackets: List<TaxBracket> = LIMITS.indices.map { i ->
        TaxBracket(LIMITS[i].toBigDecimal(), COEFF_R[i].toBigDecimal(), COEFF_N[i].toBigDecimal())
    }

    companion object {
        // datos del cálculo del impuesto (escala de impuestos de 2004 sobre ingresos de 2003), "escritos directamente en el código"
        private val LIMITS = doubleArrayOf(4962.0, 8382.0, 14753.0, 23888.0, 38868.0, 47932.0, 0.0)
        private val COEFF_R = doubleArrayOf(0.0, 0.068, 0.191, 0.283, 0.374, 0.426, 0.481)
        private val COEFF_N = doubleArrayOf(0.0, 291.09, 1322.92, 2668.39, 4846.98, 6883.66, 9505.54)
    }
}
  • Líneas 9–13: la clase [HardwiredTax] codifica directamente los datos necesarios para calcular el impuesto. Estos datos se almacenan en el objeto complementario (companion object) y son compartidos por todas las instancias, de forma similar a los campos [static final] de la versión Java. Son arreglos de [Double] ([DoubleArray], creados con [doubleArrayOf]); sus elementos se escriben como [4962.0] y no como [4962], ya que no existe conversión implícita de [Int] a [Double]. Por convención, los nombres de constantes se escriben en mayúsculas;
  • Líneas 5–6: la implementación de la propiedad abstracta de la clase padre, inicializada cuando se construye el objeto. [LIMITS.indices] es el rango de índices del arreglo (0..6); la función [map] construye la lista de resultados de la lambda para cada uno de ellos, en este caso un tramo por índice. La función de extensión [Double.toBigDecimal()] convierte un [Double] en un [BigDecimal] a través de su representación decimal más corta: [0.068.toBigDecimal()] es exactamente 0.068, igual que [BigDecimal.valueOf(0.068)] en Java. No utilice el constructor [BigDecimal(0.068)], que reproduce todos los decimales del valor binario aproximado (0.068000000000000004884981308350688…);
  • la lista devuelta por [map] se expone como tipo [List<TaxBracket>], de solo lectura: ninguna clase podrá modificar el baremo a través de esta propiedad (la versión Java creaba una copia de solo lectura con [List.copyOf]). La propiedad redefinida conserva la visibilidad ([protected]) de la propiedad abstracta.

El próximo capítulo presentará clases adicionales derivadas de [AbstractTax], que leerán los tramos desde un archivo de texto o JSON: solo necesitarán proporcionar la propiedad [taxBrackets].

Un programa de prueba podría verse como el siguiente [Main.kt]:

// programa interactivo de cálculo del impuesto
// el usuario escribe tres datos en el teclado: married nbChildren salary
// el programa luego muestra el impuesto por pagar
package taxv2

import taxv2.tax.HardwiredTax
import taxv2.tax.ITax

// el mensaje de ayuda
private val SYNTAX = """
    syntax: Married NbChildren Salary
    Married: y for married, n for not married
    NbChildren: number of children
    Salary: annual salary in euros
""".trimIndent()

fun main() {
    // creación de un objeto ITax
    val tax: ITax = HardwiredTax()

    // bucle de entrada
    while (true) {
        // pedimos los parámetros del cálculo del impuesto
        print("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ")
        val parameters = readlnOrNull()
        // fin de la entrada estándar o línea vacía: nos detenemos
        if (parameters.isNullOrBlank()) {
            break
        }
        // verificación del número de campos de la línea escrita
        val fields = parameters.trim().split(Regex("\\s+"))
        if (fields.size != 3) {
            println(SYNTAX)
            continue
        }
        // verificación de la validez de los parámetros
        // married
        val married = fields[0].lowercase()
        if (married != "y" && married != "n") {
            println("$SYNTAX\nIncorrect married argument: type y or n")
            continue
        }
        // nbChildren
        val nbChildren = positiveInteger(fields[1])
        if (nbChildren == null) {
            println("$SYNTAX\nIncorrect NbChildren argument: type a positive or zero integer")
            continue
        }
        // salary
        val salary = positiveInteger(fields[2])
        if (salary == null) {
            println("$SYNTAX\nIncorrect salary argument: type a positive or zero integer")
            continue
        }
        // los parámetros son correctos: calculamos el impuesto
        println("Tax=${tax.calculate(married == "y", nbChildren, salary)} euros")
    }
}

// devuelve el entero positivo o cero representado por la cadena, null si la cadena no representa uno
fun positiveInteger(string: String): Int? = string.toIntOrNull()?.takeIf { it >= 0 }

El programa anterior permite al usuario realizar simulaciones repetidas de cálculo de impuestos.

  • líneas 4–7: el programa principal está en el paquete [taxv2]; importa los dos tipos que necesita del subpaquete [taxv2.tax]. El comentario de encabezado puede preceder a la declaración del paquete;
  • Líneas 10–15: el mensaje de ayuda es una propiedad de nivel superior, privada al archivo, escrita como una cadena sin procesar (raw string) delimitada por tres comillas dobles; la cadena puede abarcar varias líneas. La función [trimIndent()] elimina la sangría común de las líneas, así como la primera y la última línea si están vacías: por lo tanto, la cadena no termina con un salto de línea. Una propiedad [const val] no es posible aquí, ya que el valor lo calcula una función;
  • Línea 19: creación de un objeto [tax] que implementa la interfaz [ITax]. Este objeto se obtiene instanciando un tipo [HardwiredTax], un tipo que implementa la interfaz [ITax]. Observe que no dejamos que el compilador infiera el tipo *[HardwiredTax] de la variable *[tax]*; en su lugar, le asignamos explícitamente el tipo *[ITax]. Al escribir esto, indicamos que solo nos interesa el método [calculate] del objeto [tax] y no el resto. Para usar datos de un archivo, basta con cambiar esta única línea;
  • líneas 22–56: el bucle de simulaciones de cálculo de impuestos;
  • líneas 24–25: los tres parámetros requeridos por el método [calculate] se ingresan en una sola línea escrita con el teclado. [print] muestra el mensaje sin saltar a la línea siguiente, y luego [readlnOrNull()] lee una línea; devuelve [null] si la entrada estándar está cerrada;
  • línea 27: la función de extensión [isNullOrBlank], definida sobre el tipo [String?], es verdadera si la cadena es [null] o contiene solo espacios; el programa termina entonces. Después de esta prueba, el compilador sabe que [parameters] no es [null] (la función se lo indica al compilador mediante un “contrato”): esto permite la llamada a [parameters.trim()] sin [?.];
  • línea 31: la función [split] divide la línea —sin sus espacios iniciales y finales— en palabras separadas por uno o más caracteres de espacio en blanco (expresión regular ["\\s+"]). Devuelve una [List<String>], cuyo tamaño se prueba mediante [size];
  • Líneas 38–39: la función [lowercase] convierte la cadena a minúsculas; las cadenas se comparan con [==] y [!=], que comparan su contenido;
  • líneas 44–51: la función [positiveInteger] (línea 61) verifica que los dos últimos campos sean enteros positivos o cero. Devuelve un [Int?]: [null] señala un error, mientras que la versión Java devolvía el valor -1. [toIntOrNull()] devuelve [null] si la cadena no representa un entero (en lugar de lanzar una excepción como [Integer.parseInt]), y [takeIf { it >= 0 }] devuelve el valor si la condición es verdadera, y [null] en caso contrario. Después de las pruebas [nbChildren == null] y [salary == null], seguidas de [continue], el compilador sabe que las dos variables no son iguales a [null]: son de tipo [Int] durante el resto del bucle;
  • línea 56: llamada al método [calculate] del objeto [tax] que implementa la interfaz [ITax].

Este es un ejemplo de ejecución del programa, lanzado desde la carpeta del proyecto [04-classes]. La entrada, proporcionada mediante redirección de la entrada estándar, se ha reinsertado en la salida en los puntos donde el programa la lee, tal como aparecería al ingresarla con el teclado:

> gradlew -q run -Pmain=taxv2.MainKt
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop:

Los valores del cálculo del impuesto son correctos: 4,282 euros para un contribuyente casado con dos hijos y un salario anual de 60,000 euros (línea 25 de los resultados), y 2,959 euros con tres hijos (línea 27). Un contribuyente soltero sin hijos paga 11,519 euros por el mismo salario (línea 29). Estos son los resultados de la versión Java.

En comparación con la versión 1, el cálculo ahora está encapsulado en clases detrás de una interfaz: el programa de diálogo solo conoce la interfaz [ITax]. Las versiones siguientes aprovecharán esta separación: la versión 3 (próximo capítulo) cambiará el origen de los datos derivando nuevas clases de [AbstractTax], y luego la aplicación se organizará en capas (Capítulo 6).