bytes.cat

La wiki d'FP d'informàtica

Eines de l'usuari

Eines del lloc

Camí: • selenium • git • python_web_test • introduccio_javascript • docker-compose • python_venv • django_api • java_sqlite • webscraping_apache • 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 23:01]
enric_mieza_sanchez [Operador !!] 		kotlin [2025/01/07 19:10] (actual)
enric_mieza_sanchez
Línia 1: Línia 1:
 +~~REVEAL~~
 ====== Kotlin ====== ====== Kotlin ======
  
Línia 61: 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 68: 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 79: 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 86: Línia 88:
 \\ \\
  
-===== 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 112: 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 121: 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 141: Línia 148:
 </WRAP> </WRAP>
  
-==== Operador !! ====+===== 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: 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:
  
Línia 155: Línia 162:
 \\ \\
  
-==== Elvis Operator ?: ====+===== Elvis Operator ?: ===== 
 + 
 +{{ :android:elvis-operator.jpg }} 
 L'Elvis Operator ''?:'' ens permet definir un valor per defecte si la variable és nul·la. Per exemple: L'Elvis Operator ''?:'' ens permet definir un valor per defecte si la variable és nul·la. Per exemple:
 <code kotlin> <code kotlin>
Línia 167: Línia 177:
   * ''name?.length ?: 0'' (//Elvis operator//) retorna 0 ja que és el valor per defecte, en cas que l'expressió sigui ''null''.    * ''name?.length ?: 0'' (//Elvis operator//) retorna 0 ja que és el valor per defecte, en cas que l'expressió sigui ''null''. 
  
-Aquest és una alternativa mes recomanable que l'operador ''!!''+<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.1735513296.txt.gz · Darrera modificació: 2024/12/29 23:01 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