Ya hemos visto las clases en un artículo anterior, pero las data classes van un poco más allá en lo que a simplificación de código se refiere.

Si quieres empezar hoy, te recomiendo que le eches un vistazo a mi training gratuito, donde tendrás una hora y media de contenido para saber cuáles son tus siguientes pasos a dar para convertirte en un experto en Kotlin.

¿Qué es una data class?

Una data class no es más que una clase que sólo contiene estado y no realiza ninguna operación.

La ventaja de utilizar data classes en vez de clases normales es que Kotlin nos aporta una cantidad inmensa de código autogenerado.

En particular, nos da todo esto de gratis:

• Las properties declaradas en el constructor: esto técnicamente no es exclusivo de una data class, pero nos evita todo el boilerplate de los getters y los setters, además del constructor.
• Un par equals() / hashCode()
• Una serie de funciones llamadas componentX(), que nos permiten hacer una cosa muy chula que veremos después.
• Un método copy(), que nos será de mucha utilidad cuando utilicemos objetos inmutables.

¿Cómo se compara el código de Java con una data class?

Aquí viene lo increíble. Aunque este código es casi todo autogenerado, en Java necesitamos esto para implementar una clase de datos:

public class Person {

    private String name;
    private String surname;
    private String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (name != null ? !name.equals(person.name) : person.name != null) return false;
        if (surname != null ? !surname.equals(person.surname) : person.surname != null)
            return false;
        return id != null ? id.equals(person.id) : person.id == null;

    }

    @Override public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (surname != null ? surname.hashCode() : 0);
        result = 31 * result + (id != null ? id.hashCode() : 0);
        return result;
    }

    @Override public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", surname='" + surname + '\'' +
                ", id='" + id + '\'' +
                '}';
    }
}

Y aún así estaríamos lejos de conseguir la misma cantidad de funcionalidad que en Kotlin se consigue con esta línea:

data class Person(var name: String, var surname: String, var id: String)

Aquí es donde verdaderamente vemos el potencial de Kotlin, en la cantidad de código inútil que nos ahorra.

Desestructuración de clases

Para esto sirven las funciones componentX de las que hablábamos antes. Gracias a ellas puedes descomponer una data class en variables de la siguiente forma:

val person = Person("x", "y", "z")
val (n, s, i) = person

Gracias a esto, podemos hacer cosas tan curiosas como descomponer los pares de un map en un bucle:

val map = mapOf(1 to "a", 2 to "b")

for ((key, value) in map) {
    toast("key: $key, value: $value")
}

Copia de objetos

Como hemos hablado en otras ocasiones, por defecto se considera buena práctica hacer inmutable todo lo que sea posible. Si implementamos la clase anterior como inmutable:

data class Person(val name: String, val surname: String, val id: String)

Si queremos cambiar por ejemplo el apellido, ahora ya no podemos.

Cuando se trabaja con inmutabilidad, para cambiar un estado de un objeto, en realidad lo que se hace es copiarlo con el nuevo valor, y para eso la función copy de las data classes.

val person = Person("John", "Smith", "123abc")
val person2 = person.copy(surname="Rogers")

La función copy puede recibir tantos parámetros como valores a cambiar. Como ves, los parámetros de una función pueden ser nombrados, de tal forma que podemos especificar cuál es el que queremos modificar.

Conclusión

Las data classes nos ahorran un montón de boilerplate que Java nos obliga a generar, y hacen el código mucho más sencillo de entender.

Si te gusta lo que has visto, te animo a que te apuntes al training gratuito, donde te contaré todo lo que necesitas para aprender a crear tus Apps Android en Kotlin desde cero.