~~REVEAL~~
====== 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. 

  * [[https://developer.android.com/kotlin/learn?hl=es-419|Tutorial bàsic de Kotlin d'Android Developers]]
  * [[https://kotlinlang.org/docs/basic-syntax.html|Tutorial bàsic a Kotlinlang.org]]
  * [[https://github.com/android/views-widgets-samples|Android Samples]]
  * [[https://kotlinlang.org/docs/command-line.html|Kotlin CLI]]

{{tag> #Dam #DamMp08 #DamMp08Uf2 #DamMp08Uf02 Android mobile java kotlin }}

\\

===== 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 [[https://kotlinlang.org/docs/basic-syntax.html|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.<code kotlin>
>>> val a=1
>>> a=2
error: val cannot be reassigned
a=2
^
</code>
  * **var defineix valors mutables**, equivalents a les variables.<code kotlin>
>>> var a=1
>>> a=2
>>> a="hola"
error: type mismatch: inferred type is String but Int was expected
a="hola"
  ^
</code>

\\

===== Inferència de tipus =====

<WRAP tip>
Kotlin és un llenguatge fortament tipat, pel què les variables no poden canviar de tipus com en altres llenguatges de tipatge dinàmic (Python, PHP, Ruby, etc.).

La novetat respecte de Java és la **inferència de tipus**, que permet que el compilador conegui el tipus de la variable mitjançant la seva inicialització.
</WRAP>

Una definició explícita d'una variable (juntament amb una assignació):
<code kotlin>
>>> var d : Double = 33.3
>>> d
res14: kotlin.Double = 33.3
</code>

Kotlin admet definicions per **inferència del tipus**:
<code kotlin>
>>> var d = 33.3
>>> d
res20: kotlin.Double = 33.3
</code>

La inferència de tipus ajuda a que el codi sigui menys verbós que Java. Per exemple, per instanciar objectes:
<code kotlin>
var b = Button()
</code>

Enlloc del que podria ser en Java:
<code java>
Button b = new Button();
</code>

\\

===== 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.

<WRAP info>
''Int'' : //non-nullable// vs ''Int?'' : //nullable//.
</WRAP>

Per defecte els tipus son //non-nullable// (Ex: ''Int''). Exemple amb inferència de tipus:
<code kotlin>
>>> 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
    ^
</code>

Però podem definir els tipus com a //nullable// amb el símbol "?" (Ex.: ''Int?''). Exemple amb explicitació del tipus ''Int'':
<code kotlin>
>>> var a: Int? = null
>>> a
res100: kotlin.Int = null
</code>

===== 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'':

<WRAP prewrap>
<code kotlin>
>>> 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
 ^
</code>
</WRAP>

\\

===== 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:
<code kotlin>
>>> var a : Int? = 20
>>> a?.plus(5)
res29: kotlin.Int = 25
</code>

Això sí, si el valor de la variable fos //null//, el resultat de la //safe call// també ho seria:
<code kotlin>
>>> var a : Int? = null
>>> a?.plus(5)
res34: kotlin.Int = null
</code>

<WRAP tip>
Emprar //safe calls// evita excepcions ''NullPointerException'' sense haver d'implementar ''if''s i, en conseqüència, reduint el nombre de línies de codi.
</WRAP>

===== 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:

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

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

\\

===== Elvis Operator ?: =====

{{ :android:elvis-operator.jpg }}

L'Elvis Operator ''?:'' ens permet definir un valor per defecte si la variable és nul·la. Per exemple:
<code kotlin>
>>> val name: String? = null
>>> println(name?.length ?: 0) // Retorna 0 si name és null
0
</code>

  * ''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''. 

<WRAP tip>
L'operador Elvis és una alternativa mes recomanable que l'operador ''!!''
</WRAP>

==== Equivalent en Java ====
En Java, caldria fer un codi com aquest:
<code java>
String name = null;
if( name == null ) {
    System.out.println(0);
} else {
    System.out.println( name.length() );
}
</code>

Tot i que també hi ha l'operador ternari que ho faria mes curt (potser resulta una mica menys llegible):
<code java>
String name = null;
int length = (name != null) ? name.length() : 0;
System.out.println(length);
</code>

\\

===== 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:
<code kotlin>
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
}
</code>

<WRAP tip>
''lateinit'' pot ser molt útil per definit variables de classe en mètodes d'inicialització, com el típic ''onCreate()'' d'una ''Activity'' d'Android.
</WRAP>

\\

====== 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:

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

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