Il linguaggio Kotlin è stato inventato nel 2011 dall’azienda JetBrains (la stessa che ha prodotto IntelliJ, l’IDE che ha costituito la base di Android Studio). E’ nato come un linguaggio basato su Java Virtual Machine, rapido da imparare e con tutti i vantaggi che una tecnologia più complessa come Java offre. E’ stato largamente apprezzato da molti sviluppatori ma la notizia bomba è arrivata a maggio del 2017 al Google I/O, l’evento annuale che presenta tutte le novità delle tecnologie che fanno capo a Mountain View: a partire da Android Studio 3.0, Kotlin potrà essere usato per sviluppare app Android al pari di Java e C++.

Questa situazione dovrebbe rilanciare le prospettive di questo giovane linguaggio pertanto sembra proprio il momento di iniziare a studiarlo in maniera pratica nei nostri tutorial.

Installare l’ambiente

Per iniziare ad usare Kotlin, ci sono varie possibilità indicate dal sito ufficiale del progetto tra cui il nativo IntelliJ o la terza major release di Android Studio, come abbiamo detto. Noi useremo Eclipse, l’ambiente tanto caro ai programmatori Java.

Esiste un plugin Eclipse già pronto, recuperabile da marketplace passando per il menu Help > Eclipse Marketplace

e digitando “Kotlin” come stringa di ricerca

Una volta individuato il Kotlin Plugin for Eclipse sarà sufficiente pigiare il pulsante “Install”, posto sulla destra, per concludere le operazioni (il nostro appare con etichetta “Installed” ma solo perchè abbiamo già a disposizione il plugin).

Fatto ciò, potremo usare il plugin Kotlin e tra le Perspective dell’IDE esisterà anche una dedicata a questo linguaggio: la potremo impostare tramite il menu Window > Perspective > Open perspective.

Il primo programma: Ciao mondo!

Tanto per iniziare, affidiamoci ai classici della programmazione, realizzando un “Hello world”.

Dal menu File > New creiamo un nuovo progetto Kotlin, in maniera analoga a ciò che faremmo per Java. Vi si può mettere all’interno, almeno per ora, un semplice file Kotlin creandolo sempre dallo stesso menu.

Questo il codice che useremo:

/*
 * Questo è un commento su più righe
 */

fun main(args : Array<String>) {
  // questo è un commento su una riga
  println("Ciao mondo!") 
}

Possiamo eseguirlo con il consueto comando Run e vedremo così apparire nella console il messaggio “Ciao mondo!”: insomma tutto come siamo abituati a fare nel linguaggio Java.

Quello che abbiamo scritto nelle poche righe di codice è un classico metodo main, anche qui punto di inizio dell’esecuzione. Le parentesi graffa rappresentano sempre il delimitatore dei blocchi di codice mentre il simbolo punto e virgola, alla fine di ogni riga, non è più obbligatorio (anche se non vietato): l’uso del punto e virgola rimane necessario solo come separatore per inserire più comandi sulla stessa riga.

Notiamo ancora altri aspetti:

• la parola chiave fun serve ad introdurre una nuova funzione;
• i commenti possono essere definiti come in Java: doppio slash per quelli contenuti in una riga e /* … */ per delimitare quelli su più righe;
• la sintassi appare molto più snella già a giudicare dall’invocazione a println così diretta per la stampa di una riga in output.

Secondo esempio: le variabili

In questo secondo esempio, vediamo subito come dichiarare le variabili in Kotlin:

fun main(args : Array<String>) {
  val importo=1200.00f
  val sconto =25f
  val risultato=importo*(1-sconto/100)
  println("Il prezzo scontato è ${risultato}") 
}

Dichiariamo tre variabili: importo che contiene il prezzo di un prodotto; sconto che indica la percentuale di sconto da applicare (in questo caso il 25%); risultato che conterrà il prezzo scontato calcolato.

Per dichiarare le variabili in Kotlin si deve tenere a mente due aspetti. Innanzitutto, l’eventuale mutabilità della variabile. In questo linguaggio, infatti, si può dichiarare una variabile che non cambierà più una volta inizializzata con la parola chiave val (come in questi casi) oppure con var si potrà dichiarare una variabile in grado di essere riassegnata a piacimento.

Seconda cosa, il tipo di dato che caratterizzerà la variabile: ogni variabile ne avrà sempre uno anche se il programmatore non lo specificherà esplicitamente. Di tipi di dato ne esistono molti ed i principali sono:

• numeri: possono essere interi (Byte, Short, Int, Long rispettivamente ampi 8, 16, 32, 64 bit) e a virgola mobile (Float e Double, rispettivamente di 32 e 64 bit);
• booleani cui corrispondono solo due possibili valori: true e false;
• caratteri, tipo Char, i cui elementi saranno espressi con singoli apici;
• stringhe, racchiuse tra doppi apici ed indicanti una sequenza alfanumerica.

Abbiamo dichiarato tutte le variabili con val, semplicemente perché non abbiamo intenzione di modificarle dopo l’inizializzazione. Eppure nessuna di esse ha ricevuto un’esplicita assegnazione di tipo di dato: in questo caso, sarà l’ambiente di esecuzione a sceglierne uno. Trattandosi di numeri con virgola, per importo e sconto sarebbe stato scelto di default il tipo Double ma non avendo bisogno di tale precisione numerica abbiamo specificato una “f” al termine del valore di inizializzazione per indicare che lo intendiamo come Float.

Dichiarazione ed inizializzazione di variabile possono essere volti in diversi modi equivalenti tra loro:

// 1. il tipo di dato è identificato in base al valore di inizializzazione
val sconto = 25f

// 2. il tipo di dato è specificato immediatamente
val sconto: Float=25f

// 3. si esegue dichiarazione e, successivamente, inizializzazione
// ATTENZIONE: non si potrà più modificare il valore perché dichiarata con val
 val sconto: Float
 sconto=25f

Notare ancora che la stampa di una stringa in parte fissa ed in parte derivante dalla variabile non richiede concatenazione ma l’utilizzo di uno string template (che approfondiremo più avanti) il quale permette, usando il simbolo dollaro e le parentesi graffa, di espandere il contenuto di una variabile all’interno di una stringa.

Terzo esempio: definizione di funzioni

Il terzo esempio propone lo stesso esercizio del secondo ma racchiudendo in una funzione il calcolo dello sconto:

fun calcolaSconto(importo: Float, sconto:Float)=importo*(1-sconto/100)

fun main(args : Array<String>) {
  val importo=1200.00f
  val sconto:Float =25f
  
  println("Il prezzo scontato è ${calcolaSconto(importo, sconto)}") 
}

La funzione calcolaSconto accetta due parametri Float in input ed il suo corpo è estremamente ridotto: ciò è stato permesso dall’atomicità dell’operazione da svolgere che richiede un singolo calcolo.

La versione estesa della nostra funzione sarebbe stata (ed è ciò che è obbligatorio quando il body richiesto è più articolato) come la seguente:

fun calcolaSconto(importo: Float, sconto:Float): Float
{
	return importo*(1-sconto/100)
}

Come si può vedere:

• il blocco di codice è racchiuso tra parentesi graffa;
• viene fatto uso della parola chiave return per indicare il risultato da restituire;
• viene specificato un tipo di ritorno apponendo “: Float” al termine della prima riga.

Interessante notare come nello string template si sia potuto espandere direttamente l’invocazione alla funzione calcolaSconto.

Conclusioni

Al termine di questo incontro su Kotlin, non abbiamo potuto ignorare la sintassi estremamente essenziale che ci accompagnerà in tutta la nostra vita con questo linguaggio. L’aspetto importante è che nonostante si possa esprimere le operazioni da svolgere in maniera estremamente ridotta non manca nulla della ricchezza di Java dal punto di vista delle funzionalità e della definizione dei dati.

Inoltre, nonostante il modello a oggetti sia un punto saldo di Kotlin, abbiamo potuto svolgere il tutto seguendo il modello procedurale senza definizione di alcuna classe.

Non perdete il prossimo appuntamento con Kotlin e, nel frattempo, esercitatevi!