Veremos un repaso las clases y constructores de Kotlin para solventar esas inquietudes que nos surgen a la hora de seguir este curso, que pueden ser como funciona realmente y porque se presentan las clases de ese modo, como es la interacción y el constructor a la hora de crear una nueva instancia de clase.

Las clases inicialmente en Kotlin son bastante parecidas a las que podríamos tener en Java. Veremos comparaciones entre ambas para que no quede dude de donde vienen el código que hemos hecho anteriormente.

Como crear una clase en Kotlin

Lo primero es crear el archivo de Kotlin en app > java > com.antonioleiva.androiddesdecero (haciendo click derecho) y le asignamos el nombre de Ejemplo con la primera letra en mayúscula.

Luego crearemos nuestra clase Person y vamos a definir una función fuera de nuestra clase Person que se llame main(), la cual tendrá una variable de p y que a su vez será una instancia de la clase Person. También haremos uso de la función print() para mostrar por pantalla, esto nos quiere decir que nuestro objeto ya existe dentro de nuestro programa.

package com.antonioleiva.androiddesdecero

class Person {
}

fun main() {
    val p = Person()
    print(p)
}

Para poder que se este ejecutando nuestro código anterior, al lado de la función main() aparece una un icono de color verde para ejecutar nuestro código y nos desplegara un consola con el resultado

Constructor en Kotlin

Aquí podemos ver que al momento de crear nuestro objeto de tipo Person, su constructor se encuentra vacío p = Person() pero lo habitual no será que nuestro constructor este vacío, seguramente querremos pasarle un estado, identificar de esa persona cuales son sus atributos. Por ejemplo podríamos definir dos argumentos a nuestro constructor, uno que se sea name y otro que sea age, luego de definir los argumentos le ponemos sus respectivos tipos, String e Int para la edad.

class Person(name: String, age: Int){
}

Si le decimos a esa clase Person que tiene dos argumentos y al momento de instanciar nuestras clase en nuestra variable P y no le pasamos esos datos entonces nos marcara en rojo que hay un error.

Procederíamos a pasarle un nombre y una edad

Luego necesitaríamos que nuestra clase guarde este estado en algún sitio, podríamos crearnos un par de propiedades, las propiedades vendrían siendo como los campos de la clase donde podemos guardar el estado. Dentro de la clase definimos

package com.antonioleiva.androiddesdecero

class Person (name: String, age: Int){
    val name = name
    val age = age
}

fun main() {
    val p = Person("Leonard", 30)
    print(p)
}

Si la asignación que le pasamos por el constructor es la misma que la que estamos guardando en la property, no necesitamos definir las propiedades y asignarlas, sino que definimos dentro del constructor antes del nombre con la palabra reservada val

Si queremos obtener el nombre que acabamos de guardar en nuestro estado, solo basta con pasarle a nuestra instancia de clase p.name y de este modo obtendríamos el nombre que hayamos definido.

Ahora supongamos que queremos tener un valor por defecto para nuestra propiedad age, ¿Cómo lo haríamos? luego del tipo de argumento que es le asignaremos un valor con el operador “=” y el valor que queramos.

Como crear una clase en Java

Haremos lo mismo que cuando creamos la clase en Kotlin, lo primero es crear el archivo de Java en app > java > com.antonioleiva.androiddesdecero (haciendo click derecho) y le asignamos el nombre de Person2 con la primera letra en mayúscula. Esto nos genera el archivo y de una vez define la clase con el nombre del archivo.

Luego de tener nuestra clase si queremos tener un código similar al de Kotlin tendríamos que definir nuestras propiedades de la siguiente manera

Por otra parte el constructor en Java se define usando el mismo nombre de la clase y los argumentos que recibirá

Dentro de nuestro constructor observemos que usamos la palabra reservada this que esta accediendo a nuestras nuestras propiedades que definimos con anterioridad para poder guardar el estado de esas variables y al lado de la igualación obtenemos el valor del argumento que recibe ese constructor.

Dicho esto para que nuestro constructor en Java pueda tener un argumento con un valor por defecto hay que definir otro constructor de la siguiente manera.

Nuevamente vemos la palabra reservada this, que en este caso hace referencia a nuestro constructor que tenemos debajo y que pose dos argumentos, entonces lo que hace es decirle que tomara el argumento con name y el otro al asignarle un valor cuando se instancie nuestra clase se podrá hacer con uno o dos valores.

¿Importancia de Java en Kotlin?

Aunque en nuestro proyecto estemos trabajando en Kotlin todo el framework de Android, todas las APIs de Android están escritas en Java y por tanto tenemos que hacer ciertas cosas para que nuestro código sea compatible con Java. Normalmente no se necesita hacer nada, pero en este caso sí que necesitamos.

Ejemplo MoviewView con Java

Vamos a volver a nuestro proyecto a una de las clases que ya teníamos en la parte del constructor que es nuestra MovieView y generaremos otra pero en Java, y tendrá el mismo nombre pero con el numero 2, sumado a esto heredaremos del LinearLayout con la palabra reservada en Java, extend.

Lo que esta pasando aquí es que no hay un constructor por defecto, ¿Qué tenemos que hacer para solucionar esto? tenemos que crear al menos 3 constructores de los que nos recomiendo el Android Studio, si te fijas en la imagen anterior aparece un bombillo rojo que si le haces click desplegara opciones, le daremos a la que dice .

Le damos Ok y nos genera los tres constructores, esto se debe a que:

• El primer constructor se utiliza cuando estamos creando las clases por código.
• El segundo se utiliza cuando las clases las escribimos por XML y le estamos pasando un listado de atributos, siempre que añadimos un nuevo atributo al XML, por ejemplo el color de fondo, se va a guardar en este componente.
• El ultimo porque también en función de los componentes del XML que tenemos vamos a necesitar el tercer argumento

Ejemplo MoviewView con Kotlin

Empezaremos creando otra clase MovieView3 pero con Kotlin para explicar el tema de como definir más de un constructor.

Recordemos que para heredar en Kotlin hacemos uso de los dos puntos “:”

Para definir más de un constructor hacemos uso de la palabra reservada constructor() y le pasamos los argumentos que necesitemos.

Si bien ya tenemos los constructores para que se parezca a nuestra clase principal MovieView en la que estamos trabajando realmente le hace falta la función init, la cual podremos hacer la definición de 4 formas:

La primera es crear un método que se ejecute dentro de todos los constructores

La segunda forma que es la que usamos en Java usando this para decirle al constructor con cuántos argumentos puede comenzar haciendo referencia al anterior constructor. Si nos fijamos en vez de tener una función init ejecutamos todo dentro del constructor que tiene los tres argumentos.

La tercera forma es en vez de usar los tres constructores usar uno solo, porque los tres anteriores lo que nos dicen es que pueden ser usados con valores por defecto y para ello aprovechamos las ventajas de Kotlin. Agarraremos el ultimo constructor que tiene todos los argumentos y los copiaremos para definir luego de nuestra clase uno solo y a su vez pasarle al padre que es nuestro LinearLayout cuales argumentos estamos usando de el. Por ultimo lo que queremos hacer en el constructor lo hacemos en el bloque init.

Pero ¿Qué pasa aquí? esto en Kotlin funciona muy bien, tenemos una clase que se puede crear con tres constructores distintos, pero esto tiene que ser utilizado desde Java porque el Framework de Android esta escrito en Java y esto así no va a funcionar…

Si nos vamos en la parte superior de nuestro Android Studio y en la barra de navegación elegimos la opción Tools > Kotlin > Show Kotlin Bytecode nos mostrar lo que este código de Kotlin nos esta generando.

Este Bytecode vendría siendo las instrucciones que entiende la maquina virtual de Java porque al final es la que va a ejecutar nuestro código dentro de Android.

Si le damos a donde dice Decompile veremos el equivalente a Java de este código en Bytecode

Podremos observar que el único constructor que se podrá usar desde Java será le primero, que tiene los tres argumentos, entonces aquí tendríamos un problema, porque si intentáramos usar el resto de constructores desde Java no se podrá usar porque Kotlin usa una forma especial de hacer las cosas.

Entonces, ¿Qué podemos hacer? podemos marcar el constructor con la notación @JvmOverloads esto lo que le dice al compilador es que cuando vaya a generar esta clase, genere todas las distintas sobrecargas de este posible constructor de tal forma que a nivel de Bytecode tengamos las mismas opciones con Java cuando sobre escribamos los tres constructores.

Lo que tenemos que tenemos que hacer al código que teníamos anteriormente es agregarle lo siguiente:

Así que con esto ya lo tendríamos listo para usarlo desde Java.

La cuarta forma y ultima para evitar este engorroso proceso es usar las sugerencias del Android Studio al momento de extender de nuestro LinearLayout

Y listo nos quedaría así para no tener que hacerlo nosotros