Esercizi
- Home
- Esercizi Capitolo 1
Capitolo 1
Introduzione a Java
I seguenti esercizi sono stati pensati per chi inizia da zero. Questi hanno
l’unico scopo di far prendere un minimo di confidenza con l’ambiente di programmazione Java e la scrittura
del codice. Ricordiamo ancora una volta che, soprattutto se si sta iniziando, è importante iniziare a
scrivere tutto il codice a mano, senza copia incolla, o particolari aiuti da parte del tool di sviluppo
che si sta utilizzando.
Sarà sufficiente scrivere il codice sorgente su un editor di testo come il
blocco note di Windows (come descritto nel capitolo 1) e compilare da riga di comando (si raccomanda la
lettura dell’appendice A).
Sconsigliamo di svolgere gli esercizi dei primi 4 capitoli utilizzando un IDE complesso come Eclipse o
Netbeans, a meno che non siate già programmatori esperti. Infatti bisognerebbe studiare anche l’IDE, e
perdere di vista l’obiettivo principale, quello di studiare Java.
È invece consigliato (se non si vuole avere troppo a che fare con il blocco note e la riga di comando)
l’utilizzo di EJE, che offre delle
semplici utility
pensate proprio per chi inizia a programmare. Per
esempio permette di compilare e mandare in esecuzione i nostri file con la pressione di due semplici
pulsanti. Non c’è bisogno di installazione, basta decomprimere il file ZIP scaricato in una cartella
qualsiasi. Per eseguirlo bisogna fare un doppio clic sul file eje.bat. Potete leggere il file LEGGIMI.txt,
per lanciarlo su piattaforme diverse da Windows, o per avere una panoramica delle sue caratteristiche.
Infine, dopo aver svolto un esercizio, suggeriamo di consultare la soluzione relativa prima di passare al
successivo (spesso c’è propedeuticità tra un esercizio e il successivo). Questo consiglio vale per tutti
gli esercizi di tutti i capitoli e appendici.
Di seguito trovate gli esercizi del capitolo. Per ogni esercizio, cliccando sulla traccia potete vedere la
relativa soluzione.
Gli esercizi caratterizzati dall'icona sono considerati i più complessi
relativamente agli argomenti trattati.
Se preferite lavorare offline, è possibile scaricare tutti gli esercizi e le relative
soluzioni in formato PDF nella sezione download.
-
Esercizio 1.a)
Digitare, salvare, compilare ed eseguire il programma
HelloWorld
. Il lettore dovrà eseguire questo esercizio due volte: la prima volta utilizzando il Notepad e la prompt dei comandi (cfr. paragrafo 1.5), e la seconda utilizzando EJE.
Soluzione
Il listato è simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!"); } }
Per le operazioni da eseguire dalla prompt dei comandi per compilare ed eseguire il codice consultare il paragrafo 1.5.EJE permette d'inserire parti di codice pre-formattate tramite il menu Inserisci (o tramite shortcut). Nel video a questo link, viene mostrato come creare questo programma in pochi secondi con le shortcut. Il video è in inglese ma è possibile attivare i sottotitoli in italiano. -
Esercizio 1.b) Concetti base di informatica, Vero o
Falso:
1. Un computer è composto da hardware e software.
2. Il sistema operativo fa parte dell’hardware di un computer. Infatti un computer non può funzionare senza sistema operativo.
3. Blocco Note di Windows è un software.
4. Il cavo dell’alimentatore di un computer è un hardware.
5. Il linguaggio macchina è il linguaggio che il processore di un computer riesce ad interpretare.
6. Il linguaggio macchina è unico e standard.
7. Il linguaggio macchina ha un vocabolario formato solo da due simboli 0 e 1.
8. Sia il compilatore che l’interprete hanno il compito di tradurre le istruzioni scritte con un certo linguaggio di programmazione in istruzioni in linguaggio macchina.
9. In generale, un programma scritto in un linguaggio interpretato ha un tempo di esecuzione (runtime) più veloce rispetto ad un programma scritto con un linguaggio compilato.
10. Un programma eseguibile è composto dai suoi file sorgente.
Soluzione
1. Vero.
2. Falso, il sistema operativo è un software.
3. Vero.
4. Vero.
5. Vero.
6. Falso, ogni processore conosce il suo codice sorgente.
7. Vero.
8. Vero.
9. Falso, perché un linguaggio interpretato deve alternare alla fase di esecuzione la fase di traduzione, quindi è solitamente più lento.
10. Falso, un programma eseguibile è composto dai suoi file binari.
-
Esercizio 1.c) Caratteristiche di Java, Vero o
Falso:
1. Java è il nome di una tecnologia e contemporaneamente il nome di un linguaggio di programmazione.
2. Java è un linguaggio interpretato ma non compilato.
3. Java è un linguaggio veloce ma non robusto.
4. Java è un linguaggio difficile da imparare perché in ogni caso obbliga ad imparare l’Object Orientation.
5. La Java Virtual Machine è un software che supervisiona il software scritto in Java.
6. La JVM gestisce la memoria automaticamente mediante la Garbage Collection.
7. L'indipendenza dalla piattaforma è una caratteristica poco importante.
8. Java è un sistema chiuso.
9. La Garbage Collection garantisce l'indipendenza dalla piattaforma.
10. Java è un linguaggio gratuito che raccoglie le caratteristiche migliori di altri linguaggi, e ne esclude quelle ritenute peggiori e più pericolose.
Soluzione
1. Vero.
2. Falso.
3. Falso.
4. Vero.
5. Vero.
6. Vero.
7. Falso.
8. Falso.
9. Falso.
10. Vero.
-
Esercizio 1.d) Codice Java, Vero o Falso:
1. La seguente dichiarazione del metodo
main
è corretta:public static main(String argomenti[]) {...}
2. La seguente dichiarazione del metodo
main
è corretta:public static void Main(String args[]){...}
3. La seguente dichiarazione del metodo
main
è corretta:public static void main(String argomenti[]) {...}
4. La seguente dichiarazione del metodo
main
è corretta:public static void main(String Argomenti[]) {...}
5. La seguente dichiarazione di classe è corretta:
public class {...}
6. La seguente dichiarazione di classe è corretta:
public Class Auto {...}
7. La seguente dichiarazione di classe è corretta:
public class Auto {...}
8. È possibile dichiarare un metodo al di fuori del blocco di codice che definisce una classe.
9. Il blocco di codice che definisce un metodo è delimitato da due parentesi tonde.
10. Il blocco di codice che definisce un metodo è delimitato da due parentesi quadre.
Soluzione
1. Falso, manca il tipo di ritorno (
void
).
2. Falso, l’identificatore dovrebbe iniziare con lettera minuscola (main
).
3. Vero.
4. Vero.
5. Falso, manca l’identificatore.
6. Falso, la parola chiave si scrive con lettera iniziale minuscola (class
).
7. Vero.
8. Falso. 9. Falso, le parentesi sono graffe.
10. Falso, le parentesi sono graffe.
-
Esercizio 1.e) Ambiente e processo di sviluppo, Vero
o Falso:
1. La JVM è un software che simula un hardware.
2. Il bytecode è contenuto in un file con suffisso.class
.
3. Lo sviluppo Java consiste nello scrivere il programma, salvarlo, mandarlo in esecuzione ed infine compilarlo.
4. Lo sviluppo Java consiste nello scrivere il programma, salvarlo, compilarlo ed infine mandarlo in esecuzione.
5. Il nome del file che contiene una classe Java deve coincidere con il nome della classe, anche se non si tiene conto delle lettere maiuscole e minuscole.
6. Una volta compilato un programma scritto in Java è possibile eseguirlo su di un qualsiasi sistema operativo che abbia una JVM.
7. Per eseguire una qualsiasi applicazione Java basta avere un browser.
8. Il compilatore del JDK viene invocato tramite il comandojavac
e la JVM viene invocata tramite il comandojava
.
9. Per mandare in esecuzione un file che si chiamaPippo.class
, dobbiamo eseguire il seguente comando dalla prompt:java Pippo.java
.
10. Per mandare in esecuzione un file che si chiamaPippo.class
eseguire il seguente comando dalla prompt:java Pippo.class
.
Soluzione
1. Vero.
2. Vero.
3. Falso, bisogna prima compilarlo per poi mandarlo in esecuzione.
4. Vero.
5. Falso, bisogna anche tenere conto delle lettere maiuscole e minuscole.
6. Vero.
7. Falso, un browser è sufficiente solo per eseguire applet (che oggi non sono più supportate).
8. Vero.
9. Falso, il comando giusto èjava Pippo
.
10. Falso, il comando giusto èjava Pippo
.
-
Esercizio 1.f)
Eliminare il modificatore
static
del metodomain
dalla classeHelloWorld
. Utilizzando la prompt dei comandi, compilare ed eseguire il programma, e interpretare il messaggio di errore dell’esecuzione.Saper interpretare i messaggi di errore è assolutamente fondamentale. Nell’approfondimento 1.3, trovate la descrizione degli errori che si incontrano più frequentemente (sia in fase di compilazione che in fase di esecuzione del programma) quando si inizia a studiare Java.
Soluzione
Il listato dovrebbe essere simile al seguente:
public class HelloWorld { public void main(String args[]) { System.out.println("Hello World!"); } }
Il file compila tranquillamente, ma al momento del lancio ci avvertirà che abbiamo definito un metodomain
che non è un valido per poter far partire l’applicazione, proprio perché non è stato dichiaratostatic
. A seconda dell’errore, del vostro sistema operativo (o della virtual machine installata), i messaggi del compilatore potrebbero essere in italiano o in inglese. Se il messaggio è in italiano dovrebbe essere il seguente:
Errore: il metodo principale non è static nella classe HelloWorld. Definire il metodo principale come: public static void main(String[] args)
Nel caso i messaggi fossero in inglese si tenga presente che nel campo informatico un minimo di inglese tecnico lo si deve conoscere. -
Esercizio 1.g)
Eliminare la prima parentesi graffa aperta incontrata dalla classe
HelloWorld
. Utilizzando la prompt dei comandi, compilare il programma e interpretare il messaggio di errore della compilazione.
Soluzione
Il listato dovrebbe essere simile al seguente:
public class HelloWorld public static void main(String args[]) { System.out.println("Hello World!"); } }
Il messaggio di errore del compilatore (questa volta in inglese, ma di facile comprensione) è il seguente:
error: '{' expected public class HelloWorld ^ 1 error
-
Esercizio 1.h)
Eliminare l’ultima parentesi chiusa (ultimo simbolo del programma) dalla classe
HelloWorld
. Utilizzando la prompt dei comandi, compilare il programma e interpretare il messaggio di errore.
Soluzione
Il listato dovrebbe essere simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!"); }
Il messaggio di errore del compilatore (questa volta in inglese, ma di facile comprensione) è il seguente:
error: reached end of file while parsing } ^ 1 error
-
Esercizio 1.i)
Eliminare il simbolo di
;
dalla classeHelloWorld
. Utilizzando la prompt dei comandi compilare il programma e interpretare il messaggio di errore.
Soluzione
Il listato dovrebbe essere simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!") } }
Il messaggio di errore del compilatore in inglese è il seguente:
error: ';' expected System.out.println("Hello World!") ^ 1 error
Dove il compilatore ci avverte che manca un punto e virgola. -
Esercizio 1.j)
Raddoppiare la parentesi graffa finale della classe
HelloWorld
. Utilizzando la prompt dei comandi compilare il programma e interpretare il messaggio di errore.
Soluzione
Il messaggio di errore è il seguente:
HelloWorld.java:5: error: class, interface, or enum expected } ^ 1 error
Il messaggio è lo stesso che abbiamo già visto nell’approfondimento 1.5, dove avevamo definito una classe utilizzando erroneamente la lettera maiuscola per la parola chiaveclass
. In quel caso, come sappiamo un file sorgente Java deve obbligatoriamente definire al suo interno una classe. Il compilatore siccome non aveva trovato una definizione valida, reclamava la definizione di una classe (o un’interfaccia o una enumerazione, ma questi ultimi due concetti non sono stati ancora definiti). In questo caso invece, il compilatore si aspetta che al posto della parentesi graffa superflua, sia definita un’altra classe (o un’interfaccia o una enumerazione). Infatti, come vedremo più avanti è possibile definire anche altre classi all’interno di un unico file sorgente. -
Esercizio 1.k)
Aggiungere all’interno del metodo
main
, un blocco di parentesi graffe:
public class HelloWorld { public static void main(String args[]) { System.out.println(args); } }
Compilare, eseguire e trarre delle conclusioni.
Soluzione
Il file viene compilato ed eseguito come se la coppia di parentesi non esistesse. Infatti, è possibile utilizzare coppie di parentesi graffe all’interno dei nostri metodi, magari che circondano altre istruzioni. Per esempio potremmo anche scrivere:
public class HelloWorld { public static void main(String args[]) { { System.out.println("Hello World!"); } } }
In questo caso, le parentesi sono indubbiamente superflue, ma esistono rari casi in cui la parentesi possono essere utilizzate per isolare dei pezzi di codice, dal resto. Per ora ci dobbiamo solo sapere che le parentesi graffe, se usate in coppia, possono essere utilizzate all’interno dei nostri file sorgente. -
Esercizio 1.l)
Raddoppiare il simbolo di
;
nel programmaHelloWorld
compilare ed eseguire, cosa succede?
Soluzione
Il listato dovrebbe essere simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!");; } }
Il file però viene compilato ed eseguito senza errori. Infatti il simbolo;
superfluo, viene considerato dal compilatore come una terminazione (legale) di uno statement vuoto. Potremmo scriverlo anche al rigo successivo (visto che come abbiamo letto nel capitolo 1 non cambia nulla) per rendere l’idea un po’ più chiaramente:
public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!"); ; } }
-
Esercizio 1.m)
Scrivere il programma
HelloWorld
scrivendo ogni parola e ogni simbolo al rigo successivo. C’è qualche problema?
Soluzione
Il listato dovrebbe essere simile al seguente:
public class HelloWorld { public static void main ( String args [ ] ) { System . out . println ( "Hello World!" ) ; } }
Il file però viene compilato ed eseguito senza errori. Infatti, come vedremo nei prossimi capitoli, Java è un linguaggio a schema libero. Il problema è che diventa molto complicato da leggere. -
Esercizio 1.n)
Provare a far stampare una stringa a piacere al programma
HelloWorld
al posto della stringaHello World!
.
Soluzione
Il listato potrebbe essere simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("Una frase a piacere!"); } }
-
Esercizio 1.o)
Provare a far stampare un numero al programma
HelloWorld
al posto della stringaHello World!
.
Soluzione
Il listato potrebbe essere simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("8"); } }
Ma abbiamo stampato il numero come stringa (le stringhe saranno argomento del terzo capitolo), infatti l’abbiamo rinchiuso tra due virgolette. Potremmo scrivere anche direttamente:
public class HelloWorld { public static void main(String args[]) { System.out.println(8); } }
Questa volta stiamo stampando un tipo di dato diverso (non ci sono virgolette). Nel prossimo esercizio inizieremo a capire meglio la situazione. -
Esercizio 1.p)
Provare a far stampare la somma di due numeri al programma
HelloWorld
della stringaHello World!
, dopo aver letto la soluzione dell’esercizio precedente 1.o.
Soluzione
Il listato potrebbe essere simile al seguente:
public class HelloWorld { public static void main(String args[]) { System.out.println("25+7"); } }
L’output quindi non stamperà una somma ma semplicemente:
25+7
Potremmo scrivere anche questo direttamente:
public class HelloWorld { public static void main(String args[]) { System.out.println(25+7); } }
In questo caso l’output sarà quello desiderato:
32
Infatti i tipi di dati numerici (che vengono scritti senza virgolette come vedremo nel capitolo 3) ci permettono di eseguire operazioni aritmetiche. -
Esercizio 1.q)
Compilare ed eseguire il seguente programma:
public class HelloWorld { public static void main(String args[]) { } }
cosa viene stampato?
Soluzione
Il programma non stampa niente perché manca l’istruzione di stampa (
System.out.println
). -
Esercizio 1.r)
Compilare ed eseguire il seguente programma:
public class HelloWorld { public static void main(String args[]) { System.out.println(""); } }
cosa viene stampato?
Soluzione
Il programma non stampa niente perché all’istruzione di stampa non viene passato nulla da stampare. Si può notare però che il cursore è sceso alla riga successiva, per effetto del fatto che l’istruzione
System.out.println
va sempre a capo dopo aver stampato (ma anche dopo non aver stampato). Infattiprintln
, sta per "print line" (in italiano "stampa riga"). -
Esercizio 1.s)
Compilare ed eseguire il seguente programma:
public class HelloWorld { public static void main(String args[]) { System.out.println(args); } }
cosa viene stampato?
Soluzione
In questo caso l’output sarà simile al seguente:
[Ljava.lang.String;@5679c6c6
È stato "stampato un oggetto" (chiamatoargs
) e capiremo nei prossimi capitoli il perché abbia una rappresentazione sotto forma di stringa così misteriosa. -
Esercizio 1.t)
Scrivere il programma
Elenco
che stampa un elenco della spesa, dove ogni articolo da comprare risiede sul proprio rigo.
Soluzione
Il listato dovrebbe essere simile al seguente:
public class Elenco { public static void main(String args[]) { System.out.println("Pane"); System.out.println("caffè"); System.out.println("tè"); System.out.println("frutta"); } }
E l’output è il seguente:
Pane caffè tè frutta
-
Esercizio 1.u)
Scrivere il programma
ElencoCompatto
che stampa un elenco della spesa, dove ogni articolo è separato da un altro con una virgola.
Soluzione
Il listato dovrebbe essere simile al seguente:
public class ElencoCompatto { public static void main(String args[]) { System.out.println("Pane, caffè, tè, frutta"); } }
E l’output è il seguente:
Pane, caffè, tè, frutta
-
Esercizio 1.v)
Creare un nuovo file di nome
SayJava
che stampa la stringa "JAVA" come nel seguente esempio:
-------- | JAVA | --------
Soluzione
Il listato potrebbe essere simile al seguente:
public class SayJava { public static void main(String args[]) { System.out.println("--------"); System.out.println("| JAVA |"); System.out.println("--------"); } }
-
Esercizio 1.w)
Scrivere un programma definito dalla classe
Frecce
che stampi il seguente output:
<----<<< >>>---->
Soluzione
Il listato dovrebbe essere simile al seguente:
public class Frecce { public static void main(String args[]) { System.out.println("<----<<<"); System.out.println(""); System.out.println(">>>---->"); } }
Per stampare una riga vuota, la soluzione naturale è stata quella di usare l’istruzioneSystem.out.println("")
ln una stringa vuota""
. In realtà è possibile anche utilizzare in alternativa l’istruzioneSystem.out.println()
, senza passare nessun parametro al metodo. -
Esercizio 1.x)
Scrivere un programma definito dalla classe
StampaContatti
che stampi l’elenco di contatti di una rubrica. Ogni contatto dovrà essere stampato su tre righe: nella prima ci sarà il nome del contatto, nella seconda l’indirizzo, e nella terza il numero di telefono. Ogni contatto deve essere separato dal successivo da una riga vuota.
Soluzione
Il listato potrebbe essere simile al seguente:
public class StampaContatti { public static void main(String args[]) { System.out.println("Elenco Contatti"); System.out.println(); System.out.println("Claudio De Sio Cesari"); System.out.println("Via Java 15"); System.out.println("151515151515"); System.out.println(); System.out.println("Stevie Wonder"); System.out.println("Via Musica 10"); System.out.println("1010101010"); System.out.println(); System.out.println("Gennaro Capuozzo"); System.out.println("Piazza Quattro Giornate 1"); System.out.println("1111111111"); } }
Notare che per stampare le righe vuote, abbiamo usato il metodoSystem.out.println
senza passare nessun parametro. La soluzione sarebbe stata valida anche se avessimo usato una stringa vuota in questo modo:System.out.println("")
. -
Esercizio 1.y)
Creare una classe chiamata
StampaClasseRigaVuota
che stampi il seguente output:
public class RigaVuota { public static void main(String args[]) { System.out.println(); } }
Soluzione
Il listato dovrebbe essere simile al seguente:
public class StampaClasseRigaVuota { public static void main(String args[]) { System.out.println("public class RigaVuota {"); System.out.println(" public static void main(String args[]) {"); System.out.println(" System.out.println();"); System.out.println(" }"); System.out.println("}"); } }
Notare che non abbiamo fatto stampare nulla al metodoSystem.out.println
, perché altrimenti avremmo avuto problemi con le virgolette. Infatti, se avessimo scritto:
System.out.println(" System.out.println("");");
avremmo ottenuto il seguente errore:
StampaClasseRigaVuota.java:5: error: ')' expected System.out.println(" System.out.println("");"); ^ 1 error
Questo perché il compilatore non può capire che la seconda virgoletta che incontra deve essere considerata una virgoletta da stampare e non una virgoletta che chiude una stringa. La seconda virgoletta quindi, viene considerata la virgoletta di chiusura della stringa:
System.out.println(" System.out.println("");");
Quindi la successiva virgoletta non viene accettata, perché il compilatore si aspetta che venga chiusa la parentesi del metodoprintln
. Vedremo nei prossimi capitoli come risolvere questo problema. -
Esercizio 1.z)
Creare un nuovo file di nome
SayMyName
che stampa il vostro nome come nel seguente esempio:
***** * ****** * * *** * ***** * * * * * * * * * * * * * ****** * * * * * * * * * * * * * * * * * * ***** ***** * * ***** *** * *****
Ovviamente se il vostro nome è troppo lungo può bastare anche solo un soprannome, o le prime lettere. Questo esercizio è importante perché ci costringerà a compilare ed eseguire continuamente l’applicazione per verificare che l’output sia quello desiderato. Questo ci permetterà di fare esperienza, con l’ambiente di sviluppo.Si noti che per stampare ogni carattere sono state utilizzate 5 colonne e 5 righe (ad eccezione del carattereI
). Ogni carattere è separato da un altro di 3 colonne.
Se si vuole eseguire quest'applicazione con EJE, si consiglia di eseguire quest'applicazione dopo aver settato il font Consolas su Windows e Linux (Monaco su MAC). In alternativa potete eseguire l'applicazione da riga di comando.
Soluzione
Il listato potrebbe essere simile al seguente:
public class SayMyName { public static void main(String args[]) { System.out.println("***** * ****** * * ** * *****"); System.out.println("* * * * * * * * * * *"); System.out.println("* * ****** * * * * * * *"); System.out.println("* * * * * * * * * * *"); System.out.println("***** ***** * * ***** *** * *****"); } }
-
Esercizio 1.aa)
Creare la classe
SommaTreInteri
come descritto nel paragrafo 1.5.3.
Soluzione
Potremmo codificare la classe
SommaTreInteri
nel seguente modo:
import java.util.Scanner; public class SommaTreInteri { public static void main(String args[]) { System.out.println("Ciao, so sommare tre numeri interi."); System.out.println("Scrivi il primo valore e batti invio"); Scanner keyboardScanner = new Scanner(System.in); int operatore1 = keyboardScanner.nextInt(); System.out.println("Scrivi il secondo valore e batti invio"); int operatore2 = keyboardScanner.nextInt(); System.out.println("Scrivi il terzo valore e batti invio"); int operatore3 = keyboardScanner.nextInt(); int risultato = operatore1 + operatore2 + operatore3; System.out.println("Il risultato è:"); System.out.println(risultato); } }