Capitolo 1

Il primo programma: far parlare il computer

Ogni programma, anche il più complicato, comincia da qui: mostrare un messaggio sullo schermo. In questo capitolo impari a stampare testo, a capire che cosa sono le stringhe e a lasciare commenti nel codice per ricordarti cosa hai fatto.

In questo capitolo impari

println(...): stampare una riga di testo e andare a capo;
print(...): stampare senza andare a capo;
le stringhe, cioè il testo fra virgolette doppie;
i commenti // e /* ... */;
come si scrive un programma completo con fun main() { ... }.

1.1 Stampare qualcosa sullo schermo

In Kotlin si stampa con println (si legge "print-line", cioè "stampa riga"). Fra parentesi tonde si mette quello che vuoi stampare, e il testo va sempre racchiuso fra virgolette doppie.

Le tre istruzioni sono tutte println: ognuna stampa il suo testo e va a capo, quindi l'output occupa tre righe.
La seconda è println(""), con una stringa vuota: println manda a capo anche quando non c'è testo da stampare. Per questo in mezzo all'output compare una riga vuota.
Se al posto suo ci fosse print(""), non vedresti nessuna riga vuota: print non va mai a capo.

Ogni println stampa il suo testo e poi va a capo: le due frasi finiscono su due righe diverse.

È un'anteprima: non serve capirla tutta oggi

Questo laboratorio mostra come il visualizzatore disegna le variabili di testo passo per passo. Il codice usa val e il template di stringa ($nome): sono argomenti del capitolo 2. Per adesso puoi limitarti a cambiare il testo fra le virgolette e guardare come cambia il disegno.

1.2 Le stringhe e le virgolette

Una stringa (in inglese String) è una sequenza di caratteri: lettere, numeri, spazi, simboli. In Kotlin le stringhe si scrivono fra virgolette doppie. Se metti del testo senza virgolette, il programma non sa che si tratta di testo e si ferma con un errore:

Le virgolette sono doppie

Si usa " e non '. Ad esempio println("ciao") funziona, println('ciao') no (l'apice singolo serve per un singolo carattere, lo vedrai nel capitolo 2).

1.3 print: stampare senza andare a capo

print stampa e resta sulla stessa riga. Serve per costruire frasi pezzo dopo pezzo o per mettere più valori vicini.

Le prime tre istruzioni finiscono tutte sulla stessa riga: due print restano sulla riga, e il println("3") la chiude. Risultato: 1 2 3.
println("4") scrive il 4 e va subito a capo: occupa una riga sua.
Le ultime due print costruiscono un'altra riga, 5 6, che resta senza ritorno a capo finale.
In tutto l'output occupa tre righe: per contarle devi seguire ogni print e ogni println nell'ordine.

Vuoi che dopo il comando il cursore vada a capo. Quale dei due comandi usi?

print(...)No: print scrive e lascia il cursore sulla stessa riga, quindi il testo successivo finirebbe attaccato.

println(...)Esatto: println scrive il testo e poi va a capo, come dice il nome "print-line".

Nessuno dei due: serve \n alla fineIn Kotlin si può fare anche così, ma esiste un comando apposta: println.

Regola pratica: println quando vuoi una riga nuova, print quando stai costruendo una riga a pezzi (per esempio due colonne).

1.4 I commenti: appunti per te (e per chi legge il codice)

I commenti sono righe che il computer ignora. Servono a spiegare il programma. Si scrivono in due modi: con // per una sola riga, con /* ... */ per più righe.

Quante righe stampa questo programma?

fun main() {
    println("uno") // println("due")
    /* println("tre") */
}

Una solaEsatto: il computer salta tutto quello che segue // sulla stessa riga e tutto il blocco /* ... */.

DueIl secondo println è dentro un commento //: non viene eseguito.

TreSolo il primo println è codice attivo: gli altri due sono commenti.

I commenti servono a te e a chi legge il codice, non al computer.

1.5 Il programma completo: fun main()

Tutti gli esempi che hai visto cominciano con fun main() { e finiscono con }. Non è una decorazione: main (si legge "mein") è il punto di partenza. Quando il programma parte, Kotlin cerca questa funzione e comincia da lì, riga per riga.

In Kotlin le istruzioni devono stare dentro una funzione: fuori si possono scrivere solo le dichiarazioni (le funzioni e le classi, che incontrerai dal capitolo 6 e dal capitolo 9). Una println fuori da main, in un progetto vero, non compila. Per questo in ogni esempio del manuale il tuo codice sta dentro main: così quello che provi qui lo puoi incollare in IntelliJ senza cambiare niente.

Dentro main le righe vengono eseguite dall'alto in basso: tre righe di stampa, quindi tre righe di output.
La riga commentata è invisibile a Kotlin: non stampa niente e non conta.
La riga vuota fra le istruzioni serve solo a leggere meglio il codice: non stampa una riga vuota. Un modo per stampare una riga vuota esiste, e l'hai visto nella prima previsione: println("").

Indentazione: solo per gli occhi

Gli spazi all'inizio delle righe (dentro main) non cambiano il risultato, ma rendono il codice molto più leggibile: usa 4 spazi per ogni livello.

1.6 Riepilogo

Scrivi	Significato
`println("ciao")`	stampa `ciao` e va a capo
`print("ciao")`	stampa `ciao` e resta sulla riga
`println()`	stampa una riga vuota (va solo a capo)
`// commento`	riga ignorata dal computer
`"testo"`	una stringa: il testo va sempre fra virgolette doppie

Errori tipici del primo capitolo

Nome non definito: pippo → hai scritto del testo senza virgolette.
Atteso ")" → hai dimenticato una parentesi tonda.
Stringa non chiusa → hai aperto le virgolette e non le hai chiuse.

1.7 Esercizi guidati

Scrivi un programma che stampa tre righe: il tuo nome, la tua classe e la tua scuola. Poi aggiungi un commento sopra ogni riga che spiega che cosa stai stampando.

Ti servono tre istruzioni println. Ogni testo va fra virgolette doppie e ogni riga può avere sopra un commento che inizia con //.

Ogni println stampa una riga e va a capo: tre println → tre righe di output.
I commenti con // vengono ignorati: servono a spiegare il codice a chi lo legge.
Il testo è fra virgolette doppie perché Kotlin deve sapere che si tratta di una stringa.

Stampa uno scontrino di tre prodotti con i prezzi, incolonnati, usando print e println insieme: il nome del prodotto con print, il prezzo con println, in modo che ogni prodotto stia su una riga.

print non va a capo: stampa il nome, poi alcuni spazi, poi con println stampi il prezzo e vai a capo. Ripeti tre volte lo stesso schema.

print("Cappuccino") scrive il nome e lascia il cursore sulla stessa riga.
print(" ") aggiunge soltanto spazi: in questo modo i prezzi risultano allineati.
println("1.30 euro") scrive il prezzo e va a capo: la riga del prodotto è completa.
L'ultima coppia di righe usa print per "TOTALE" e println per il totale, mostrando che i due comandi si possono mescolare come vuoi.

Questo programma è pieno di errori da principiante. Eseguilo, leggi il messaggio di errore, correggi un errore alla volta e fai in modo che stampi tre righe di testo corrette.

Guarda bene: il nome del comando è tutto minuscolo (println), ogni testo va fra virgolette doppie aperte e chiuse, e ogni chiamata finisce con una parentesi tonda chiusa.

Println con la P maiuscola non esiste: Kotlin distingue maiuscole e minuscole, quindi si scrive println.
Nella prima riga mancava la virgoletta di chiusura e la parentesi tonda finale: la stringa deve essere completa, "Prima riga".
Nella seconda riga il testo era senza virgolette: Kotlin pensava fossero nomi di variabili.
Nella terza riga mancava la parentesi tonda di chiusura della chiamata println.

so stampare una riga di testo con println

so stampare senza andare a capo con print

so scrivere del testo fra virgolette doppie e so riconoscere l'errore quando le dimentico

so scrivere un commento su una riga (//) e su più righe (/* ... */)

so scrivere un programma completo con fun main() { ... }

so leggere il messaggio di errore e trovare la riga che lo ha causato