bytes.cat

La wiki d'FP d'informàtica

Eines de l'usuari

Eines del lloc

Camí: • kotlin
kotlin

Diferències

Ací es mostren les diferències entre la revisió seleccionada i la versió actual de la pàgina.

Enllaç a la visualització de la comparació

Ambdós costats versió prèvia Revisió prèvia
Següent revisió 		Revisió prèvia
kotlin [2024/12/29 13:21]
enric_mieza_sanchez [Nullable Objects i Safe Functions] 		kotlin [2025/01/07 19:10] (actual)
enric_mieza_sanchez
Línia 1: Línia 1:
 +~~REVEAL~~
 ====== Kotlin ====== ====== Kotlin ======
  
Línia 50: Línia 51:
   ^   ^
 </code> </code>
 +
 +\\
 +
 +===== Inferència de tipus =====
  
 <WRAP tip> <WRAP tip>
Línia 56: Línia 61:
 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ó. 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> </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 Objects i Safe Calls =====+===== 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 //not-nullable//. Si emprem un //not-nullable// podrem efectuar accions segures sobre l'objecte i el compilador ens pot advertir de possibles problemes del //runtime//.+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> <WRAP info>
-''Int'' : //not-nullable// vs ''Int?'' : //nullable//.+''Int'' : //non-nullable// vs ''Int?'' : //nullable//.
 </WRAP> </WRAP>
  
-Per defecte els tipus son //not-nullable// (Ex: ''Int''). Exemple amb inferència de tipus:+Per defecte els tipus son //non-nullable// (Ex: ''Int''). Exemple amb inferència de tipus:
 <code kotlin> <code kotlin>
 >>> var a = 1 >>> var a = 1
 >>> a >>> a
 res87: kotlin.Int = 1 res87: kotlin.Int = 1
->>> a=null+>>> a = null
 error: null can not be a value of a non-null type Int error: null can not be a value of a non-null type Int
-a=null +a = null 
-  ^+    ^
 </code> </code>
  
Línia 85: Línia 114:
 </code> </code>
  
-Això ens porta a certs "problemes": el compilador no estarà segur de sumar un ''Int'' amb un ''Int?'' , ja que el segon pot ser ''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'':
  
 +<WRAP prewrap>
 <code kotlin> <code kotlin>
 >>> var a : Int? = 20 >>> var a : Int? = 20
Línia 94: Línia 125:
  ^  ^
 </code> </code>
 +</WRAP>
 +
 +\\
  
-==== Safe call ==== +===== Safe call ?. ===== 
-Com es pot veure, l'operador ''+'' acaba cridant la funció ''.plus()'' . Es pot una crida segura o //safe call// amb ''?.plus()'' per fer la suma:+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> <code kotlin>
 >>> var a : Int? = 20 >>> var a : Int? = 20
Línia 114: Línia 148:
 </WRAP> </WRAP>
  
-==== Operador !! ==== +===== Operador !! ===== 
-Finalment, 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:+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> <code kotlin>
Línia 128: Línia 162:
 \\ \\
  
 +===== 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>
  
kotlin.1735478501.txt.gz · Darrera modificació: 2024/12/29 13:21 per enric_mieza_sanchez

Eines de la pàgina

Excepte on es digui una altra cosa, el contingut d'aquest wiki està subjecte a la llicència següent: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki