danilo.pianini@unibo.itgianluca.aguzzi@unibo.itangelo.filaseta@unibo.itCompiled on: 2025-10-22 — versione stampabile
void main() {
System.out.println("Hello, World!");
}
In C sarebbe:
#include <stdio.h>
int main(void) {
printf("Hello, World!\n");
return 0;
}
Come leggerlo?
System che rappresenta il sistema (creato automaticamente dalla virtual machine)out, e risponde fornendo un oggetto che rappresenta lo standard outputprint, analogo a printf in C, che stampa a video la stringa fornitaprintln, come print, ma va a capo sempre anche se non viene specificato \nHelloWorld.java.class)*.java) in file binari (*.class)javac (Java Compiler)
javac HelloWorld.javaHelloWorld.class
javapjava HelloWorld
HelloWorld, e non HelloWorld.class!.class dove si trova la classe viene fatta automaticamente dalla JVMHello, World!JShelljshellJava distingue due macro-categorie di tipi: tipi primitivi e tipi non-primitivi.
I tipi primitivi in Java sono boolean, byte, short, int, long, float, double, char, void
null)boolean[], byte[], String[], String[][], $\ldots$
String
Boolean, Byte, Short, Integer, Long, Float, Double, Char, Void
Integer.MAX_VALUE)| Type name | Size (bits) | Minimum | Maximum |
|---|---|---|---|
char |
16 | \u0000 ($0$) |
\uFFFF ($2^{16}-1$) |
byte |
8 | $-128$ | $128$ |
short |
16 | $-2^{15}$ | $2^{15}-1$ |
int |
32 | $-2^{31}$ | $2^{31}-1$ |
long |
64 | $-2^{63}$ | $2^{63}-1$ |
float |
32 | IEEE754 | IEEE754 |
double |
64 | IEEE754 | IEEE754 |
boolean |
8 | – | – |
void |
– | – | – |
booleanRappresentano valori di verità
true, false! (not)& (and), | (or), ^ (xor), && (and-c), || (or-c)
&& e || valutano il secondo argomento solo se necessario (short-circuiting)
false && X restituisce false senza valutare Xtrue || X restituisce true senza valutare XGli operatori di confronto e uguaglianza restituiscono boolean
==, !=>, <, >=, <=Gli operatori e le strutture di controllo che operano sulla base di valori di verità
(operatore ternario ?:, strutture if, while, e for)
si aspettano valori di tipo boolean
byte, short, int, long+, -, *, /, % (resto della divisione)& (and), | (or), ^ (xor)<< (sinistra), >> (destra con segno), >>> (destra senza segno)+, - (inversione del segno), ~ (complemento bit-a-bit), ++ (incremento), -- (decremento)
++ e -- possono essere prefissi o postfissi
++x e --x incrementano/decrementano e restituiscono il nuovo valorex++ e x-- restituiscono il vecchio valore e poi incrementano/decrementano200), ottale (0310), esadecimale (0xC8)int, per avere un long va aggiunta una L (15L)byte e short (usati di rado): si usano “cast” espliciti ((byte) 5)_) per separare le cifre
1_000_000 è più leggibile di 1000000*.MAX_VALUE, *.MIN_VALUE, e.g. Integer.MAX_VALUEfloat, doubleNumeri con virgola mobile, con valori speciali che rappresentano valori non numerici o infiniti
+ e -+, -, *, /, % (resto della divisione)0.1 + 0.2 in JShell)-128.345), o scientifica (-1.2835E+2)double, per avere un float va aggiunta una fFloat.NaN, Double.NaN),Float.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)Float.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY)*.MAX_VALUE, *.MIN_VALUEvoid main() {
System.out.println(10 + 20); // 30
System.out.println(010 + 020); // 24
System.out.println(0xFFFFFFFF); // -1
System.out.println(0x7FFFFFFF); // 2147483647
System.out.println(0x80000000); // -2147483648
System.out.println(0x80000000 - 1); // 2147483647
System.out.println(2147483647 + 1); // -2147483648
System.out.println(2147483647L + 1); // 2147483648
System.out.println((0x0F0F | 0xF0F0) == 0xFFFF); // true
System.out.println((0x0F0F & 0xF0F0) == 0); // true
System.out.println((0x0F0F << 4) == 0xF0F0); // true
System.out.println((0x0F0F >> 4) == 0x00F0); // true
System.out.println(~0x0F0F == 0xFFFFF0F0); // true
System.out.println(10 / 3); // 3
System.out.println(10 % 3); // 1
System.out.println(3.5 / 51 * 51); // 3.5000000000000004
System.out.println(3.5f / 51 * 51);// 3.5000002
}
In Java, come in C, è possibile assegnare dei nomi a dei valori (variabili).
var al posto del tipoint x; // dichiarazione
int y = 5; // dichiarazione + inizializzazione
var z = 5; // dichiarazione + inizializzazione con inferenza del tipo
x = 5; // assegnamento
// z = 3.14; // ERRORE: stiamo provando ad assegnare un double a una variabile di tipo int
(tipo) valoreboolean(int) 3.33, ((double) 10)/3, (short) 100_000byte$\rightarrow$short$\rightarrow$int$\rightarrow$long$\rightarrow$float$\rightarrow$doublelong a float!
(long) ((float) Long.MAX_VALUE - 1) == Long.MAX_VALUE - 1long l = 100; diventa long l = 100L;10.1 + 10 diventa 10.1 + 10.0char'a', 'z', 'A', '=', '✀''A'), 66 ('B'), 9984 ('✀')'\n', '\\', '\0'…'\u2603' ('☃')char (surrogate pairs)
"\uD83E\uDD96" ("🦖") (notare che produce una stringa di due caratteri)Oggetti della classe String (vedremo le classi in dettaglio più avanti).
Si rappresentano con sequenze di caratteri racchiusi da doppi apici: "Ciao Mondo!"
Le istanze di String sono immutabili: una volta create non possono essere modificate.
+ concatena stringhe:"Ciao " + "Mondo!" // "Ciao Mondo!"
String s = "Ciao";
s = s + " Mondo"; // crea una nuova String
String.valueOf(42), oppure Integer.toString(42)
T, T.toString(x) converte x in StringInteger.parseInt("42"), Double.parseDouble("3.14")
T, T.parseT(s) converte la stringa s in un valore di tipo TAttenzione: le conversioni non sono cast!
ArrayIndexOutOfBoundsException)
int[] array = {10, 20, 30}; (inizializzazione per elenco)arr.length // 3 (lunghezza)
arr[0] // espressione per leggere 0-esimo elemento
arr[0] = 10; // assegnamento del 0-esimo elemento
System.out.println("array: " + array[0] + " " + array[1] + " " + array[2]);
System.out.println(array); // [I@1794d431};
System.out.println("c.length: " + array.length); // 3
String[] words = { "Hello", "World!" };
words[0] = "Ciao!";
System.out.println(words[0]);
// System.out.println(words[2]); --> OutOfBoundException
}
boolean (cf. strong typing)
if, for, while e do è un booleanboolean b = 1; // ERROR: incompatible types: int cannot be converted to boolean
boolean b = (boolean) 1; // incompatible types: int cannot be converted to boolean
if(1){ /* ... */ } // ERROR: incompatible types: int cannot be converted to boolean
ifif(condizione) {
// blocco eseguito se condizione è true
}
boolean.int x = 10;
if (x > 0) {
System.out.println("Positivo");
}
if-else e else ifif(cond1) {
...
} else if(cond2) {
...
} else {
...
}
int n = Integer.parseInt(s);
if (n < 0) {
System.out.println("Negativo");
} else if (n == 0) {
System.out.println("Zero");
} else {
System.out.println("Positivo");
}
whilewhilewhile (condizione) {
// corpo
}
condizione (deve restituire boolean)true, esegue il corpo e torna a 1.Esempio:
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
do-whiledo-whiledo {
// corpo
} while (condizione);
condizione (deve restituire boolean)true, torna a 1.Utile se il corpo deve essere eseguito almeno una volta.
Esempio:
int i = 0;
do {
System.out.println(i);
i++;
} while (i < 5);
for (classico)for (inizializzazione; condizione; aggiornamento) {
// corpo
}
inizializzazionecondizione (deve restituire boolean)true, esegue il corpoaggiornamentofor (int i = 0; i < 10; i++) {
System.out.println(i);
}
int i) ha scopo limitato al for (non è visibile fuori)In Java si può usare il classico for (come in C):
void main() {
String[] words = {"Hello", "World!"};
for(int i = 0; i < words.length; i++) {
System.out.print(words[i] + " ");
}
System.out.println();
}
forfor(int v: array){ /* uso di v */ }
var:for(var v: array){ /* uso di v */ }
array è una espressione che restituisce un int[]for, v vale via via ogni elemento dell’arrayv in array esegui il corpo”void main() {
int[] elements = {10, 20, 30};
var sum = 0;
for (var element: elements) {
sum += element;
}
System.out.println(sum);
}
danilo.pianini@unibo.itgianluca.aguzzi@unibo.itangelo.filaseta@unibo.itCompiled on: 2025-10-22 — versione stampabile