Kotlin - Appunti dettagliati con esempi di codice (42 pagine)

Indice

• Perché Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
• Diffusione, crescita e pareri nel mondo . . . . . . . . . . . . 4
• Caratteristiche fondamentali . . . . . . . . . . . . . . . . . . . . . . 7
• Sintassi e funzionalità di Kotlin . . . . . . . . . . . . . . . . . . . . 11
• Hello world . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
• Variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
• Tipi di dato . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
• Numeri . . . . . . . . . . . . . . . . . . . . . . . . . 15
• Caratteri . . . . . . . . . . . . . . . . . . . . . . . . 15
• Booleani . . . . . . . . . . . . . . . . . . . . . . . . . 16
• Vettori . . . . . . . . . . . . . . . . . . . . . . . . . . 16
• Stringhe e string templates . . . . . . . . . . . . . . . 17
• Inferenza di tipo . . . . . . . . . . . . . . . . . . . . . . . . 18
• Strict null safety . . . . . . . . . . . . . . . . . . . . . . . . 19
• Operatore di chiamata sicura . . . . . . . . . . . . . 20
• Operatore elvis . . . . . . . . . . . . . . . . . . . . . 21
• Operatore di asserzione non nulla . . . . . . . . . . . 22
• Operatore di cast sicuro . . . . . . . . . . . . . . . . 23
• Flusso di controllo . . . . . . . . . . . . . . . . . . . . . . . 24
• Operatore when . . . . . . . . . . . . . . . . . . . . . 24
• Cicli ed espressioni di range . . . . . . . . . . . . . . 25
• Classi e oggetti . . . . . . . . . . . . . . . . . . . . . . . . . 26
• Costruttori . . . . . . . . . . . . . . . . . . . . . . . 27
• Proprietà . . . . . . . . . . . . . . . . . . . . . . . . 28
• Data classes . . . . . . . . . . . . . . . . . . . . . . . 30
• Sealed classes . . . . . . . . . . . . . . . . . . . . . . 30
• Singleton . . . . . . . . . . . . . . . . . . . . . . . . 31
• Funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
• Lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
• Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
• Funzioni di estensione . . . . . . . . . . . . . . . . . 35
• Proprietà di estensione . . . . . . . . . . . . . . . . . 36
• Coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
• Novità di Kotlin 1.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
• Progetti multipiattaforma . . . . . . . . . . . . . . . . . . . 39
• Prestazioni in compilazione . . . . . . . . . . . . . . . . . . 40
• Altri miglioramenti del linguaggio e delle librerie . . . . . . . 40
• Bibliografia

Linguaggio Kotlin

Nel 2011 JetBrains, azienda conosciuta per aver creato IntelliJ IDEA, un IDE (Integrated Development Environment) per Java, ha annunciato lo sviluppo del linguaggio di programmazione Kotlin; a detta della compagnia, si sarebbe posto come valida alternativa alla scrittura di codice in linguaggi come Java e Scala, che girano su Java Virtual Machine (JVM). Kotlin è cresciuto rapidamente, suscitando sempre maggior interesse e imponendosi, sei anni dopo la sua nascita, come il linguaggio di programmazione di riferimento per le applicazioni del sistema operativo mobile più diffuso al mondo. Nell’ottobre del 2017 infatti, in occasione dell’uscita del nuovo IDE Android Studio 3.0, Google ha deciso di scegliere Kotlin come linguaggio ufficialmente supportato per lo sviluppo di app sul sistema operativo Android, affiancando Java e C/C++.

Presenta sintassi concisa, interoperabilità con Java ed altre caratteristiche che verranno via via descritte all’interno di questi appunti.

Perché Kotlin

Java è un linguaggio di programmazione robusto e ben testato nel corso del tempo ed è attualmente fra i più utilizzati al mondo. Tuttavia, da quando è stato rilasciato per la prima volta nel 1995, sono state numerose le nuove tecniche messe a punto per quanto riguarda le regole di buona programmazione e Java non sempre è riuscito ad adattarsi bene, come invece hanno dimostrato altri linguaggi più moderni, nati di recente. Kotlin è uno di questi: un linguaggio che cerca di trarre ispirazione dalle migliori tecniche di programmazione e progettazione.

• Per maggiori informazioni visitare: http://archive.fo/h3T7g

Kotlin non si configura solo come un linguaggio moderno per scrivere codice da eseguire su Java Virtual Machine, ma è anche un linguaggio multipiattaforma: è infatti in grado di essere compilato in codice JavaScript o direttamente in nativo tramite la struttura di compilazione LLVM ed essere, naturalmente, anche eseguito su dispositivi Android.

Non per ultimo, Kotlin si propone di essere un linguaggio di programmazione conciso, sicuro, "tool-friendly" e di diminuire le linee di codice di circa il 40% rispetto a quelle necessarie per la scrittura in Java.

Diffusione, crescita e pareri nel mondo

La comunità interessata a Kotlin è in espansione: esistono attualmente oltre 100 gruppi di utenti in tutto il mondo e numerosi talk e conferenze. In figura 1 sono riportati i talk su Kotlin attualmente riconosciuti in giro per il mondo:

• Per maggiori informazioni visitare: https://kotlinlang.org/
• Per maggiori informazioni visitare: https://kotlinlang.org/docs/reference/faq.html
• Per maggiori informazioni visitare: http://kotlinlang.org/community/talks.html

Figura 1: Kotlin talks in tutto il mondo (primo trimestre 2018)

Per quanto riguarda invece la crescita di Kotlin: su GitHub ha ormai superato abbondantemente 25 milioni di linee di codice, con crescita pressoché esponenziale, mentre su Stack Overflow è etichettato come uno dei linguaggi di programmazione con la crescita più veloce, nonché uno tra i più apprezzati in assoluto.

• Per maggiori informazioni visitare: http://archive.is/P1A0E

Figura 2: Crescita di Kotlin nel tempo (in ascissa l’anno, in ordinata il numero di linee di codice espresse in milioni)

In figura 3, sono mostrate le percentuali di gradimento per ognuna delle caratteristiche più rilevanti di Kotlin. Non è un caso che la feature più votata sia la null safety, essa è difatti molto richiesta dagli sviluppatori ma assente in molti altri linguaggi di programmazione.

Figura 3: Le caratteristiche di Kotlin che vengono maggiormente apprezzate dagli sviluppatori

Caratteristiche fondamentali

Kotlin è un linguaggio di programmazione a tipizzazione statica che possiede sia i costrutti tipici del paradigma di programmazione ad oggetti, sia alcuni di quelli del paradigma di programmazione funzionale, permettendo perciò l’utilizzo di entrambi gli stili, anche contemporaneamente.

Fu creato dietro ispirazione di linguaggi già esistenti, quali Scala, C#, Ceylon, Groovy, e Java. Per questo motivo, e per essere stato progettato in modo tale che sia semplice e intuitivo da imparare, possiede una buona curva di apprendimento per qualunque programmatore (specialmente se quest’ultimo mostra dimestichezza con i linguaggi sopra elencati), che può iniziare a padroneggiare le sue basi dopo soli pochi giorni di studio. Tuttavia, per poter utilizzare le caratteristiche di dettaglio e le funzionalità più avanzate di Kotlin è necessario un maggior impegno e un tempo superiore; nonostante ciò, non viene considerato un linguaggio particolarmente complicato.

Di seguito vengono elencate le principali caratteristiche di Kotlin e messe a confronto, ove necessario, con quelle presenti in Java. Tuttavia è bene ricordare che in questa sezione si accennano soltanto le proprietà basilari, per cercare di dare un’idea iniziale e generale del linguaggio; altre importanti caratteristiche di Kotlin verranno esposte in seguito all’interno di questi appunti.

• Concisione ed espressività
  È possibile scrivere molto utilizzando poco codice (in media circa il 40% in meno rispetto a quello necessario in Java). Con Kotlin è molto semplice evitare sezioni di codice verboso perché i pattern più comuni sono supportati di default direttamente dal linguaggio. Ad esempio, in Java, se si vuole creare una data class (o POJO, Plain Old Java Object, cioè un oggetto contenente i campi e i soli metodi per accedere e settare tali campi), bisogna scrivere (o almeno generare) il codice presente nel listato 1:

  public class Product {
      private long id;
      private String name;
      private String description;
  
      public long getId() {
          return this.id;
      }
  
      public void setId(final long id) {
          this.id = id;
      }
  
      public String getName() {
          return this.name;
      }
  
      public void setName(final String name) {
          this.name = name;
      }
  
      public String getDescription() {
          return this.description;
      }
  
      public void setDescription(final String description) {
          this.description = description;
      }
  
      @Override
      public String toString() {
          return "Product { id = " + this.id + ", name = " + this.name + ", description = " + this.description + " }";
      }
  }
          

  Listato 1: Creazione di un POJO in Java
• In Kotlin, invece, creare lo stesso POJO con metodi getters, setters, equals(), hashCode(), toString() e copy() necessita molto meno codice:

  data class Product(
      var id: Long,
      var name: String,
      var description: String
  )
          

  Listato 2: Creazione di un POJO in Kotlin

Ora vengono mostrate invece le linee di codice necessarie a creare un singleton in Kotlin:

object ThisIsASingleton {
    val favoriteLanguage: String = "Kotlin"
}

Ed infine, per dimostrare ancora una volta come Kotlin sia un linguaggio di programmazione conciso ed espressivo, di seguito viene mostrata l’operazione di filtraggio di una lista utilizzando le lambda expression:

val list = listOf(-2, -1, 0, 1, 2, 3)
val positiveNumbers = list.filter { it > 0 }

• Null-safety
  Quando si utilizza Java, buona parte del codice viene scritto a scopo ‘difensivo’; è opportuno difatti controllare correttamente che un oggetto non sia nullo prima di impiegarlo, altrimenti si potrebbe incorrere in una NullPointerException. Kotlin, come altri linguaggi moderni, è null-safe: i tipi in Kotlin definiscono infatti se un oggetto può essere nullo (attraverso l’uso del suffisso punto interrogativo ?) oppure se non può esserlo (assenza del suffisso ?).
• Inoltre Kotlin è tipizzato staticamente, questo significa che tutti i tipi presenti in ogni sua espressione sono conoscibili a tempo di compilazione: indicati esplicitamente dal programmatore oppure inferiti dal compilatore stesso. In questo modo gli eventuali errori di tipo vengono intercettati prima che il codice venga eseguito. Di seguito, alcuni esempi:

  var output: String // output can't be null
  output = null // Compilation error
  
  var artist: Artist? = null // artist can be null
  artist.print() // Compilation error, artist could be null
  artist?.print() // Will print only if artist is not null
  
  var name = "John" // Inferred type is String
  name = "Cathy"
  name = 3 // Error, because name type is String
          

  Listato 5: Null-safety in Kotlin
• Un’altra funzionalità di Kotlin, che aiuta a renderlo più solido e conciso, è l'auto-cast:

  fun calculateTotal(obj: Any) {
      if (obj is Invoice) {
          obj.calculateTotal() // Cast is not necessary
      }
  }
          

  Listato 6: Auto-cast in Kotlin

• Interoperabilità
  È possibile continuare ad utilizzare librerie e codice scritto in Java, poiché esso è interoperabile con Kotlin. Si può dunque facilmente richiamare codice Kotlin da codice Java e viceversa, e creare progetti con i due linguaggi utilizzati contemporaneamente. Infine, è presente anche un convertitore Java-to-Kotlin automatizzato integrato negli IDE IntelliJ IDEA ed Eclipse, semplificando la migrazione del codice esistente.
• Approccio funzionale
  Kotlin, come già accennato, è fondamentalmente un linguaggio orientato agli oggetti, non un puro linguaggio funzionale; tuttavia, come molti altri linguaggi moderni, utilizza molti concetti dalla programmazione funzionale (come per esempio espressioni lambda, i function types e le funzioni di ordine superiore) per risolvere alcuni problemi in maniera molto più semplice.
• Le funzioni in Kotlin sono di ‘prima classe’ (first-class), cioè significa che possono essere memorizzate all’interno di variabili o in strutture dati, passate come argomenti o ritornate da parte di altre funzioni di grado superiore. È possibile quindi gestire le funzioni in tutti i modi con i quali è possibile gestire gli altri tipi di valori. Kotlin è perciò usabile da chi abitualmente programma in maniera funzionale ed è una buona scelta per iniziare ad esplorare questo paradigma di programmazione.
• Tool-friendly
  Kotlin è supportato da tutti i principali IDE Java tra cui IntelliJ IDEA, Android Studio, Eclipse e NetBeans.
• Ottima curva di apprendimento
  Come detto, Kotlin è dotato di un plugin che permette la conversione automatica da Java a Kotlin; è però presente anche una guida che percorre le funzionalità principali del linguaggio attraverso una serie di esercizi interattivi. Tendendo conto anche delle sue somiglianze con Java, Kotlin risulta avere una curva di apprendimento ottima per quasi qualunque programmatore avvezzo a Java o Scala.

Sintassi e funzionalità di Kotlin

In questa importante sezione verranno descritte le principali funzionalità di Kotlin e la sua sintassi, partendo dalle basi del linguaggio, sino ad arrivare ad argomenti più complessi. Si tralascia di esporre alcuni concetti di base già presenti in Java, assumendo che il lettore ne sia in generale a conoscenza.

Hello world

La modalità più rapida per provare il linguaggio senza necessità di installare alcun software è quella di utilizzare Kotlin Koans Online: è infatti possibile eseguire codice utilizzando le implementazioni JVM Kotlin o JavaScript e scegliere la versione di Kotlin desiderata fra le differenti disponibili.

• Per maggiori informazioni visitare: https://try.kotlinlang.org/

La funzione main, come per Java, rimane il punto di partenza per ogni applicazione Kotlin; questa funzione viene chiamata quando il programma si avvia:

fun main(args: Array<String>) {
    println("Hello world!")
}

Nelle applicazioni Android, tuttavia, la funzione main non viene mai scritta direttamente dal programmatore; essa viene infatti chiamata implicitamente dal framework, quindi in questo specifico caso non può essere utilizzata in maniera esplicita per eseguire un Hello world in Kotlin. Nel successivo listato viene dunque mostrato il codice Kotlin necessario per far apparire un messaggio di saluto all’interno di una TextView nell’activity principale:

import kotlinx.android.synthetic.main.activity_main.textView

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        textView.text = "Hello world!"
    }
}