- come funzionano i riquadri di codice (esecuzione automatica, console, input, variabili);
- l'elenco degli 11 capitoli con gli argomenti trattati;
- i consigli per usare al meglio il manuale.
Come funziona questo manuale
Ogni esempio è un laboratorio: una casella con dentro del codice Kotlin.
Puoi cambiare il codice come vuoi e l'esecuzione parte da sola dopo mezzo secondo;
sotto la casella c'è una console che mostra il risultato vero del programma
(quello che Kotlin chiama output). Funziona come la finestra Run di IntelliJ:
se il programma chiede un dato con readln() (o readlnOrNull()),
l'output si ferma lì e il
cursore di scrittura compare in coda al testo, nel punto esatto in cui il
programma sta leggendo. Nessun dato viene dato al posto tuo: scrivi tu il valore
(le lettere compaiono nella console, una dopo l'altra) e premi Invio.
| Elemento del laboratorio | A cosa serve |
|---|---|
▶ Esegui | lancia il programma subito (con Ctrl+Invio dalla casella del codice) |
↺ Ripristina | rimette il codice originale dell'esempio |
| Console scura | l'output del programma; i valori che scrivi tu compaiono in giallo nella sequenza, come in una console vera |
| Cursore nella console | quando il programma aspetta un dato, il cursore si posiziona in fondo all'output (anche subito dopo una print senza a capo): scrivi il valore e premi Invio, un valore per ogni readln(). Un clic in un punto qualsiasi della console riporta il cursore in fondo |
| Barra sotto la console | ti dice quando il programma è in attesa, e ti dà i pulsanti ⏎ prova con i dati dell'esempio (facoltativo: riempie lui i dati preparati per l'esempio), ✕ azzera i dati e ⏹ fine dei dati |
⏹ fine dei dati / Ctrl+D | come in una console vera: dichiara che i dati sono finiti. Da quel momento readlnOrNull() restituisce null e readln() si ferma con un errore: è il modo per vedere come il programma gestisce i dati che mancano |
Stato ⏸ in attesa di dati… | il programma è fermo e sta aspettando che tu scriva nella console: niente va avanti se prima non premi Invio |
| Variabili | la fotografia delle variabili dopo l'esecuzione, con tipo e valore |
⚡ auto: on | in alto a destra: spegne o riaccende l'esecuzione automatica |
Se vedi un errore, non ti preoccupare: gli errori fanno parte dell'imparare. Il manuale traduce i messaggi di errore in italiano e, dove serve, ti dice come rimediare. I progressi (capitoli completati ed esercizi risolti) vengono salvati in questo browser.
Qui impari le basi con un motore didattico che esegue direttamente nella pagina i costrutti spiegati
(variabili, input/output, condizioni, cicli, array, liste, mappe, stringhe, classi e data class).
Quando vuoi provare altro, passa a un vero ambiente di sviluppo: copia il codice con
📋 Copia e incollalo in
IntelliJ IDEA, l'ambiente gratuito con cui si programma Kotlin sul serio.
Il capitolo 11 ti guida passo passo: installazione, primo progetto e
come scrivere i dati in input.
Attenzione ai siti di prova online ("playground"): vanno bene per esperimenti senza input,
ma non permettono di scrivere i dati durante l'esecuzione, quindi i programmi con
readln() restano bloccati. Con IntelliJ IDEA funzionano tutti.
Metodo di studio in quattro passi
Questo manuale non è fatto per essere letto come un romanzo: è fatto per essere usato. Ogni capitolo segue sempre lo stesso ritmo, e seguirlo ti farà risparmiare tempo.
| Passo | Che cosa fai | Perché serve |
|---|---|---|
| 1. Ripasso lampo | rispondi alle due domande in apertura di capitolo | richiamare quello che sai già rende più facile agganciare le cose nuove |
| 2. Leggi ed esegui | segui gli esempi, cambia il codice e guarda che cosa succede | il codice che hai modificato tu si ricorda molto meglio |
| 3. Prevedi l'output | nei riquadri Prevedi l'output scrivi che cosa stampa il programma prima di eseguirlo | è il modo più rapido per scoprire se hai davvero capito |
| 4. Esercitati e verifica | fai gli esercizi guidati, poi l'esercizio Trova e correggi gli errori, la verifica a fine capitolo e l'autovalutazione | allenarsi su casi sempre nuovi, imparare a leggere i messaggi di errore e sapere che cosa ripassare |
Sei un docente? C'è anche una guida didattica, con la mappa dei capitoli, i tipi di esercizio con il loro scopo, i prerequisiti fra capitoli e un percorso di lezioni già pronto.
I riquadri che incontrerai
Oltre ai laboratori di codice, il manuale usa alcuni riquadri pensati per farti ragionare. Eccoli tutti, con quello che devi fare quando li incontri.
| Riquadro | Come funziona |
|---|---|
Laboratorio (▶ Esegui, console, variabili) | modifichi il codice ed esegui: la console in basso mostra l'output vero e, quando il programma chiede un dato, il cursore compare in coda all'output e aspetta quello che scrivi tu |
| Visualizzatore (🏷 visualizzatore) | mostra come il programma arriva al risultato: vedi le variabili disegnate una per una, le stringhe carattere per carattere, le caselle degli array con i loro indici, le coppie chiave-valore delle mappe, i campi degli oggetti, la pista dei giri dei cicli e il ramo scelto dalle condizioni. Puoi scorrere i passi avanti e indietro |
| Prevedi l'output | scrivi la tua previsione riga per riga, premi Confronta e vedi evidenziate le differenze fra quello che ti aspettavi e quello che il programma fa davvero |
| Quiz | scegli una risposta: se sbagli ti dice perché quella risposta è sbagliata, poi puoi ritentare |
| Esercizio guidato | provi da solo, puoi chiedere un suggerimento e poi confrontarti con la soluzione spiegata passo per passo |
| Trova e correggi gli errori | il programma di partenza contiene errori tipici: lo esegui, leggi il messaggio, correggi un errore alla volta e confronti il risultato con la soluzione |
| Verifica (🎲) | esercizi sempre nuovi sugli argomenti che hai già studiato; il contatore ti dice quanti ne hai risolti |
| Autovalutazione | a fine capitolo spunti quello che sai fare: quello che resta vuoto è la tua lista di ripasso |
Come si usa il visualizzatore
Nei laboratori con l'etichetta visualizzatore il pannello grafico mostra lo stato del programma passo per passo. Non è un disegno decorativo: è la fotografia di quello che il computer ha in memoria mentre esegue, e sotto ogni passo trovi la spiegazione in italiano di che cosa è appena successo.
| Comando | A cosa serve |
|---|---|
◀ e ⏭ | un passo indietro e un passo avanti: ottimo per capire dove una variabile cambia valore |
▶ anima | fa scorrere i passi da sola, come un filmato; ripremuto mette in pausa |
| Barra dei passi | ti porta dove vuoi: puoi anche usare ← e → da tastiera |
| Codice a sinistra | la riga in esecuzione è evidenziata; le altre restano leggibili per contesto |
| Schede a destra | una scheda per variabile, con il tipo e il valore disegnato secondo il tipo di dato |
| Bordo verde o giallo | verde: variabile appena creata; giallo: variabile che è appena cambiata |
| Riquadro del flusso | per i cicli: la pista dei giri con quello attivo evidenziato; per le condizioni: l'esito true/false e il ramo scelto |
| Console | mostra solo l'output stampato fino a quel passo: tornando indietro si accorcia, come se il programma non fosse ancora arrivato a quella riga |
| Riga «rispetto all'esecuzione precedente» | dopo che hai modificato il codice ti dice in una riga che cosa è cambiato nel risultato, per esempio somma 21 → 18: è l'effetto della tua modifica |
I laboratori con il visualizzatore servono proprio a questo: cambi un valore nel codice, per esempio i numeri dentro un array, e guardi che cosa cambia nel disegno. Il pannello si rifà da solo, ti lascia al passo che stavi guardando (così vedi l'effetto proprio sul punto che ti interessava) e sotto la barra dei comandi ti dice che cosa è cambiato rispetto all'esecuzione precedente. La prima volta è lui a invitarti a provare, con la riga ✎ Prova a cambiare i valori nel codice.
Se il codice è scritto a metà — una parentesi aperta, un numero incompleto — il disegno dell'ultima versione eseguibile resta al suo posto, con un avviso che lo spiega, invece di sparire a ogni tasto: puoi continuare a sperimentare senza perdere il punto.
- "Perché il risultato è questo?" Scorri i passi e guarda la variabile cambiare, invece di indovinare.
- "Quante volte gira questo ciclo?" Conta le caselle accese nella pista dei giri e confrontale con la condizione.
- "Che cosa succede davvero in memoria?" Guarda il disegno della lista, della mappa o dell'oggetto: le stringhe sono caselle per carattere, le mappe sono coppie chiave
→valore, gli oggetti sono i loro campi convalovar.
Quando un riquadro ti segnala un errore, non cancellare tutto: leggi il messaggio, trova la riga indicata e cambia una cosa alla volta. Il messaggio dice sempre che cosa Kotlin non ha capito, e nella maggior parte dei casi il problema è una parentesi, una virgoletta o un nome scritto in modo diverso.
Prova il riquadro "Prevedi l'output"
Funziona così: scrivi che cosa secondo te compare nella console, poi premi Confronta. Prova con questo esempio, anche sbagliando: le differenze evidenziate sono la parte più utile.
puntiparte da 4 e diventa 5: la prima riga stampaGiulia ha 5 punti.- Il template
$nomeinserisce il valore della variabile dentro al testo. - La seconda riga non usa il template ma la concatenazione con
+: il risultato è lo stesso testo,Ciao Giulia.
Glossario: i termini del manuale
Ogni termine con il capitolo in cui viene spiegato. Quando non ricordi una parola, cerca qui prima di rileggere tutto il capitolo.
| Termine | Che cosa significa | Dove |
|---|---|---|
Int | tipo dei numeri interi (5, -12) | 2 |
Double | tipo dei numeri con la virgola, scritti con il punto (3.5) | 2 |
String | tipo del testo, sempre fra virgolette doppie | 1, 8 |
Boolean | tipo che vale solo true o false | 2 |
Char | un singolo carattere, fra apici singoli ('a') | 2 |
val | costante: il valore non cambia più | 2 |
var | variabile: il valore può cambiare durante il programma | 2 |
| template di stringa | scrivere $nome o ${espressione} dentro al testo per inserirci un valore | 2 |
| conversione | cambiare tipo a un valore: "42".toInt(), 7.toString() | 2, 3 |
readln() | legge una riga scritta dall'utente e la restituisce come testo | 3 |
readlnOrNull() | come readln(), ma restituisce null se i dati sono finiti | 3 |
null | "nessun valore": non è 0, non è "", è l'assenza del valore | 3 |
?. e ?: | operatori per usare un valore che può mancare: "se c'è" e "altrimenti questo" | 3 |
| condizione | espressione che vale true o false, usata da if e while | 4 |
when | modo ordinato di scegliere fra molti casi | 4 |
| ciclo | blocco di istruzioni ripetuto più volte | 5 |
| intervallo | sequenza di numeri come 1..5, 0 until 5, 10 downTo 1 | 5 |
| contatore | variabile che conta quante volte succede qualcosa | 5 |
| accumulatore | variabile che somma (o moltiplica) i valori uno dopo l'altro | 5 |
break / continue | esci subito dal ciclo / salta al giro successivo | 5 |
| array | collezione a dimensione fissa, con posizioni numerate da 0 | 6, 10 |
| lista | collezione che cresce e si accorcia: mutableListOf (modificabile), listOf (no) | 6 |
| indice | la posizione di un elemento, che parte da 0; l'ultimo è size - 1 | 6 |
| lambda | il pezzetto di codice fra graffe che si passa a filter, map, sortedBy: { it * 2 } | 6 |
| mappa | collezione di coppie chiave-valore: si legge la voce con la chiave, non con la posizione | 7 |
| chiave / valore | nella mappa "Anna" to 30, la chiave è "Anna" e il valore è 30 | 7 |
split / joinToString | spezza un testo in una lista / rimette insieme una lista in un testo | 8 |
substring | prende un pezzo di testo: dall'indice di inizio (compreso) a quello di fine (escluso) | 8 |
format | dà al numero l'aspetto che vuoi: "%.2f".format(prezzo) (extra: per i report) | 8 |
padStart / padEnd / repeat | completa un testo a sinistra / a destra / ripete un testo n volte (extra: per tabelle e codici) | 8 |
isEmpty / isBlank | controlla se un testo è vuoto o fatto di soli spazi | 8 |
trimStart / trimEnd | toglie gli spazi solo dall'inizio o solo dalla fine del testo | 8 |
lastIndexOf | come indexOf, ma cerca l'ultima occorrenza invece della prima | 8 |
replaceFirst | sostituisce solo la prima occorrenza (extra: replace le sostituisce tutte) | 8 |
reversed | restituisce il testo letto al contrario (utile per i palindromi) | 8 |
until / downTo / step | varianti dell'intervallo: esclude l'ultimo / conta all'indietro / va a salti | 5 |
| classe | descrizione di un "tipo di cosa", con i suoi dati e le sue funzioni | 9 |
data class | classe pensata per tenere dati: toString, ==, copy e destrutturazione arrivano gratis | 9 |
| oggetto / istanza | una cosa concreta creata da una classe: Persona("Mario", 30) | 9 |
| proprietà | un dato dell'oggetto: persona.nome. Con val non cambia, con var sì | 9 |
| metodo | una funzione che appartiene a una classe e si chiama con oggetto.metodo() | 9 |
copy() | crea un oggetto nuovo con gli stessi valori, tranne quelli che indichi | 9 |
find / filter | cerca il primo elemento che rispetta una condizione / tiene tutti quelli che la rispettano | 10 |
sortedBy / sortedByDescending | ordina un elenco di oggetti in base a una proprietà, in modo crescente / decrescente | 10 |
maxByOrNull | trova l'oggetto con il valore più alto (può dare null se l'elenco è vuoto) | 10 |
groupBy | raggruppa gli oggetti per categoria: restituisce una mappa categoria → elenco | 10 |
| report | programma che scorre un elenco di dati, calcola dei totali e li stampa in modo ordinato | 10 |
| IDE | ambiente di sviluppo integrato: l'editor con cui si scrivono i programmi veri (IntelliJ IDEA) | 11 |
| JDK | il pacchetto che serve a compilare ed eseguire i programmi Kotlin | 11 |
fun main() | la funzione da cui parte ogni programma Kotlin completo | 1, 11 |
| compilazione | la traduzione del codice in istruzioni eseguibili: se qualcosa non va, il programma non parte | 11 |
- Su che riga? Il messaggio dice sempre la riga: guarda prima quella.
- Che tipo di errore è? Parentesi o virgolette non chiuse, nome scritto diversamente, valore
nullusato senza protezione, indice fuori dai limiti. - Che cosa mi aspettavo? Se il programma parte ma il risultato è sbagliato, il problema non è la sintassi ma la logica: rileggi un'istruzione alla volta e stampa i valori intermedi con
println.
Il percorso in 11 capitoli
Segui l'ordine: ogni capitolo usa solo quello che hai imparato nei capitoli precedenti.
Come si danno i dati in input: la console interattiva
Quando un programma ha bisogno di dati (per esempio chiede il nome all'utente), Kotlin usa
readln(): legge una riga di testo e la restituisce come String.
Nel manuale funziona esattamente come nella finestra Run di
IntelliJ: l'output scorre nella console e, quando serve un dato, il cursore
compare lì dove il programma sta leggendo. Tu scrivi il valore e premi
Invio: un valore per ogni readln(), nell'ordine in cui il
programma li chiede. Quello che hai scritto resta nella console insieme al resto dell'output.
L'esempio qui sotto chiede tre dati, uno alla volta: il cursore si ferma dopo ogni domanda. Scrivi Giulia e premi Invio; poi 2008; poi l'anno in cui siamo. Ogni volta il programma riparte da dove si era fermato. Prova anche a cambiare il codice in modo che chieda un dato in più.
Se invece vuoi vedere che cosa fa il programma quando i dati finiscono, premi
Ctrl+D (o il pulsante ⏹ fine dei dati): da quel momento
readln() si ferma con l'errore "non ha trovato altri dati in input", mentre
readlnOrNull() restituisce null — è la differenza che spiega il
capitolo 3.
- Scrivi un'istruzione per riga: Kotlin capisce dove finisce un'istruzione dalla fine della riga.
- Usa nomi chiari per le variabili:
totaleVenditesi capisce,tno. - Quando un programma non funziona, guarda la riga segnalata nell'errore e controlla parentesi e virgolette.