1.2 Hello World!
1.2.1 Funzionalità del programma
Il programma scrive sullo standard output il messaggio Ciao <nome>! per un numero di volte passato come “argomento”. Se il programma prodotto si chiama hello-1.0.jar (ad esempio creato dal comando gradle jar nella cartella build libs)
java -jar hello-1.0.jar Ada 5
stampa:
Ciao Ada!
Ciao Ada!
Ciao Ada!
Ciao Ada!
Ciao Ada!
L’esecuzione con gradle run usa gli “argomenti di default” (vedi sotto) Cynthia e
2. È comunque possibile ridefinirli con l’opzione --args: es. gradle run --args
"Carlo 4"Suggerimenti
• Creare un nuovo progetto Java, scegliendo Gradle nel menù a sinistra della finestra di creazione.
• Creare le nuove classi nella cartella src main java secondo la convenzione di Gradle.
• Muovere le classi nel
packageit.unimi.di.prog2 (
Move class)
• Aggiungere a build.gradle il plugin application (oltre a quello java aggiun-to auaggiun-tomaticamente da IDEA). Definire poi la classe principale da eseguire, per esempio:
application {
mainClassName = 'it.unimi.di.prog2.MiaApp' }
• Definire gli argomenti di default
run {
args = ['Cynthia', '2']
}
• Definire la classe principale nel .jar da distribuire
jar {
manifest {
attributes 'Main-Class': application.mainClassName }
}
• Per convertire una stringa con un numero in un intero usare Integer
.parseInto
Integer.parseUnsignedInt
1.2.2 Soluzioni
Con IDEA è sufficiente creare un nuovo progetto con
Create New Project, scegliendo Grad-le e Java (SDK 11) come tipologia di progetto. Serve anche una terna di identificatori:
un gruppo, un nome (verrà usato per creare una cartella per il progetto) e un tag di versione. Il progetto creato è vuoto, ma contiene già tutto l’albero di cartelle conven-zionale adatto a Gradle: basterà creare le classi Java in src main java. In più viene anche creato automaticamente un file build.gradle che può essere adattato alle esigenze dell’esercizio.
Tutto ciò può naturalmente anche essere fatto a mano: i punti essenziali sono la cartella src main java e il build.gradle. Si può anche usare Gradle per inizializzare una cartella vuota.
gradle init --type java-application
È poi possibile importare il progetto in IDEA selezionando build.gradle, in questo modo l’IDE e il sistema di build automation Gradle sono collegati (eventuali modifiche di-rette a build.gradle vanno re-importate, a meno che non venga attivata l’importazione automatica).
Possiamo ora creare la classe principale del programma (con IDEA:
New Java class).
Come richiesto, spostiamo poi la classe nel
packageit.unimi.di.prog2 (con IDEA:
Refactor Move class
). Il nome del
packageè del tutto arbitrario: quello suggerito rispetta la convenzione Java di usare come prefisso il nome di dominio (a rovescio) dell’organiz-zazione in cui si lavora. Anche qui l’operazione può essere fatta a mano creando tutte le sotto-cartelle src main java it unimi di prog2, spostando lì la classe principale e aggiungendovi
package it.unimi.di.prog2;all’inizio.
La classe principale, quella cioè da cui inizia l’esecuzione di un programma Java, deve avere un metodo
publice
static(che quindi è accessibile anche prima che vengano istanziati oggetti) dal nome convenzionale main. Per crearlo con IDEA è sufficiente scri-vere main e premere
tab: nel gergo di IDEA si tratta di un “Live Template
3”. Se per caso il tipo String risulta non disponibile (e viene quindi segnalato un errore perché il codice scritto non compila), probabilmente c’è qualche problema con le impostazioni dell’SDK:
si può controllare tramite
Project Structure Project Settings Project. Eventualmente con
Project Structure Platform Settings SDKs
si possono cancellare tutte le impostazioni già presenti e creare un nuovo SDK cercandolo nel proprio file system. Lo scheletro della classe principale in Hello.java (si noti che il nome del file corrisponde a quello della classe
publicche contiene):
package it.unimi.di.prog2;
public class Hello {
public static void main(String[] args) { } }
3Può essere utile dare un’occhiata a Settings Editor Live Templates per vedere quali altre abbreviazioni sono disponibili, in particolare quelle per le iterazioni.
1.2 Hello World!
Aggiorniamo anche il build.gradle, in modo che utilizzi il plugin application e identifichi correttamente la classe principale. Inoltre definiamo gli argomenti di default e la classe principale anche nella produzione di un Java ARchive (jar) “autocontenuto”.
plugins { id 'java'
id 'application' // usa il plugin application }
group 'prog2'
version '1.0-SNAPSHOT' sourceCompatibility = 1.8
application { // configura il plugin application con la classe principale mainClassName = 'it.unimi.di.prog2.Hello'
}
run { // argomenti di default aggiunti al task run args = ['Cynthia', '2']
}
jar { // la classe principale del jar è la stessa dell'application manifest {
attributes 'Main-Class': application.mainClassName }
}
repositories { mavenCentral() }
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' }
Ora possiamo eseguire il programma. Usando il task run di Gradle verrà eseguita la classe principale (Hello, il cui main al momento è vuoto) con gli argomenti
"Cynthia"e
"2". Possiamo anche produrre il jar con il task jar: ne risulterà il file build libs hello-1.0-SNAPSHOT.jar (il nome di default dipende dai tag scelti in fase di creazione del progetto) che può anche essere eseguito direttamente.
java -jar build/libs/hello-1.0-SNAPSHOT.jar Carlo 4
Dato che il main è vuoto, però, l’esecuzione non emette alcun output. Completia-mo quindi l’esercizio, interpretando i due argomenti che ci si aspetta (che gli argomen-ti siano esattamente due è quindi una precondizione per il corretto funzionamento del programma).
public class Hello {
public static void main(String[] args) {
assert args.length == 2 : "Il programma necessita di 2 argomenti";
final int times = Integer.parseUnsignedInt(args[1]);
for (int i = 0; i < times; i++) {
System.out.println("Ciao " + args[0] + "!");
} } }
La variabile times non è destinata a essere cambiata dopo l’inizializzazione, perciò è opportuno marcarla come
final, cioè costante. Vale la pena di notare che affinchél’asserzione sia efficace occorre lanciare il programma con la Java Virtual Machine in modalità “Enable Assertions”.
java -ea -jar build/libs/hello-1.0-SNAPSHOT.jar
Oppure nel build.gradle:
run {
args = ['Cynthia', 2]
enableAssertions = true }
2 Lab02: Pokerhand
2.1 Repository
Il punto di partenza di questo laboratorio è disponibile all’indirizzo:
https://gitlab.com/programmazione2/lab02
Scritto da Martin P. Robillard e adattato per il corso di “Programmazione II” @ Unimi.
2.2 Esercizi
Il codice fornito è una versione (adattata secondo le convenzioni Gradle) del programma Deck, scritto da Martin P. Robillard.
In questo esercizio si richiede di utilizzare le classi del package ca.mcgill.cs.stg.s
⌋olitaire.cards