Kotlin

Llenguatge fortament tipat amb inferència de tipus.

Compila sobre Dalvik bytecode, una variant compatible amb el bytecode de Java però orientada principalment a apps Android.

Inicialment ha estat introduït per Google per al desenvolupament d'aplicacions per a Android, però després s'ha anat ampliant el seu us en d'altres àmbits.

• Tutorial bàsic de Kotlin d'Android Developers
• Tutorial bàsic a Kotlinlang.org
• Android Samples
• Kotlin CLI

Primeres passes

Instal·lar Kotlin a Ubuntu (també es pot amb apt però la versió és anterior):

$ sudo snap install kotlin --classic

Permet obrir una shell per provar instruccions directament sobre el CLI:

$ kotlin
>>> println("hola!")
hola!

També ens posarà a disposició el compilador kotlinc.

Fes-li un cop d'ull als bàsics de Kotlin.

val (immutable) vs var (mutable)

Hi ha 2 paraules claus per definir símbols:

• val defineix valors immutables, equivalents a constants en altres llenguatges.

  >>> val a=1
  >>> a=2
  error: val cannot be reassigned
  a=2
  ^

• var defineix valors mutables, equivalents a les variables.

  >>> var a=1
  >>> a=2
  >>> a="hola"
  error: type mismatch: inferred type is String but Int was expected
  a="hola"
    ^

Inferència de tipus

Una definició explícita d'una variable (juntament amb una assignació):

>>> var d : Double = 33.3
>>> d
res14: kotlin.Double = 33.3

Kotlin admet definicions per inferència del tipus:

>>> var d = 33.3
>>> d
res20: kotlin.Double = 33.3

La inferència de tipus ajuda a que el codi sigui menys verbós que Java. Per exemple, per instanciar objectes:

var b = Button()

Enlloc del que podria ser en Java:

Button b = new Button();

Nullable i Non-Nullable Objects

Kotlin intenta evitar errors de Java en runtime com el típic null pointer exception, quan intentem efectuar una acció sobre una variable que no ha estat inicialitzada. Així, s'etiqueten adientment els tipus com a nullable o non-nullable. Si emprem un non-nullable podrem efectuar accions segures sobre l'objecte.

Per defecte els tipus son non-nullable (Ex: Int). Exemple amb inferència de tipus:

>>> var a = 1
>>> a
res87: kotlin.Int = 1
>>> a = null
error: null can not be a value of a non-null type Int
a = null
    ^

Però podem definir els tipus com a nullable amb el símbol «?» (Ex.: Int?). Exemple amb explicitació del tipus Int:

>>> var a: Int? = null
>>> a
res100: kotlin.Int = null

Què fa el compilador amb els nulls?

Disposar de variables non-nullable ens porta a certs «problemes»: el compilador no estarà segur de sumar un Int amb un Int? , ja que el segon pot ser null:

>>> var a : Int? = 20
>>> a+2
error: operator call corresponds to a dot-qualified call 'a.plus(2)' which is not allowed on a nullable receiver 'a'.
a+2
 ^

Safe call ?.

Com es pot veure, l'operador + acaba cridant la funció .plus() . Es pot fer una crida segura o safe call amb ?.plus() per fer la suma:

>>> var a : Int? = 20
>>> a?.plus(5)
res29: kotlin.Int = 25

Això sí, si el valor de la variable fos null, el resultat de la safe call també ho seria:

>>> var a : Int? = null
>>> a?.plus(5)
res34: kotlin.Int = null

Operador !!

Igualment podem dir-li al compilador de Kotlin que no comprovi els nullables i «tiri milles» sense comprovar amb l'operador !!. Això, però, pot resultar en una excepció NullPointerException que justament era el què volíem evitar de bon principi:

>>> var a: Int? = null
>>> a!!+5   
java.lang.NullPointerException
	at Line_53.<init>(Line_53.kts:1)

Sempre ens quedarà el bon clàssic try…catch per solucionar aquests possibles problemes.

Elvis Operator ?:

L'Elvis Operator ?: ens permet definir un valor per defecte si la variable és nul·la. Per exemple:

>>> val name: String? = null
>>> println(name?.length ?: 0) // Retorna 0 si name és null
0

• name és String amb valor null
• name?.length retorna null (safe call)
• name?.length ?: 0 (Elvis operator) retorna 0 ja que és el valor per defecte, en cas que l'expressió sigui null.

Equivalent en Java

En Java, caldria fer un codi com aquest:

String name = null;
if( name == null ) {
    System.out.println(0);
} else {
    System.out.println( name.length() );
}

Tot i que també hi ha l'operador ternari que ho faria mes curt (potser resulta una mica menys llegible):

String name = null;
int length = (name != null) ? name.length() : 0;
System.out.println(length);

lateinit

lateinit permet no inicialitzar una variable i que el compilador no doni error. Això sí, si després es fa servir i no s'ha inicialitzat, podríem tenir un error de runtime.

Per exemple:

lateinit var x: String // Variable de tipus String que no s'ha inicialitzat
fun main() {
    val y = fes_coses_variades() // realitza diverses accions i inicialitza x
    println(x) // Imprimeix el valor de la variable x
}

Objectes

Els constructors es defineixen amb la paraula constructor.

Les variables i funcions estàtiques dins de classes son variables que estan definides abans d'instanciar cap objecte. Es poden utilitzar, entre d'altres usos, per a implementar patrons de com Factory o Singleton.

En Kotlin es defineixen dins l'anomenat companion object, per exemple:

class MyClass {
    private val a = 1
    
    constructor(valor: Int) {
        this.a = valor
    }

    companion object {
        private val myStaticVar = 10
        
        fun myStaticFunction() {
            // ...
        }        
    }
}