bytes.cat

La wiki d'FP d'informàtica

Eines de l'usuari

Eines del lloc

Camí:
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 23:42]
enric_mieza_sanchez 		kotlin [2025/01/07 19:10] (actual)
enric_mieza_sanchez
Línia 62: Línia 62:
 </WRAP> </WRAP>
  
-Una definició explícita d'una variable (juntament amb una assignació) seria aquesta:+Una definició explícita d'una variable (juntament amb una assignació):
 <code kotlin> <code kotlin>
 >>> var d : Double = 33.3 >>> var d : Double = 33.3
Línia 69: Línia 69:
 </code> </code>
  
-Kotlin admet definicions per **inferència del tipus**. L'anterior es podria fer igualment amb:+Kotlin admet definicions per **inferència del tipus**:
 <code kotlin> <code kotlin>
 >>> var d = 33.3 >>> var d = 33.3
Línia 80: Línia 80:
 var b = Button() var b = Button()
 </code> </code>
 +
 Enlloc del que podria ser en Java: Enlloc del que podria ser en Java:
 <code java> <code java>
Línia 89: Línia 90:
 ===== Nullable i Non-Nullable Objects ===== ===== 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 113: 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 122: 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 177: Línia 181:
 </WRAP> </WRAP>
  
 +==== Equivalent en Java ====
 En Java, caldria fer un codi com aquest: En Java, caldria fer un codi com aquest:
 <code java> <code java>
Línia 197: Línia 202:
  
 ===== lateinit ===== ===== lateinit =====
-''lateinit'' ens permet +''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: Per exemple:
Línia 207: Línia 212:
 } }
 </code> </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.1735515735.txt.gz · Darrera modificació: 2024/12/29 23:42 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