Sintassi Java: guida completa con esempi
La sintassi di Java definisce le regole con cui si scrivono classi, metodi, variabili e istruzioni. Conoscerla in modo chiaro è essenziale per evitare errori di compilazione, scrivere codice leggibile e sfruttare al meglio le funzionalità del linguaggio.
In questa guida trovi una panoramica completa della sintassi Java di base, con esempi pratici che puoi copiare, eseguire e modificare per fare esperienza reale.
Struttura e sintassi Java di base
Classe e file sorgente Java
Ogni file sorgente Java ha estensione .java e di solito contiene almeno una classe. In particolare, se una classe è dichiarata come pubblica, il nome del file deve coincidere esattamente con il nome della classe pubblica.
// File: HelloWorld.java
public class HelloWorld {
}
Un progetto reale contiene molte classi, organizzate in package. Ad ogni modo, il compilatore si aspetta che ogni file .java definisca almeno una classe o interfaccia.
Il metodo main nella sintassi Java
Un programma Java eseguibile deve definire almeno un metodo main con una firma precisa. In particolare, questo metodo è il punto di ingresso da cui la JVM inizia l’esecuzione.
// File: HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Ciao, mondo");
}
}
Inoltre, il metodo main deve essere pubblico, statico, restituire void e accettare come parametro un array di String denominato args o con un altro nome a scelta.
Package e import in Java
I package servono a organizzare le classi in spazi dei nomi logici. In particolare, la dichiarazione di package, se presente, deve essere la prima istruzione non commento del file.
package it.example.basics;
import java.time.LocalDate;
import java.util.List;
public class Ordine {
private String id;
private LocalDate data;
private List<String> prodotti;
}
L’istruzione import permette di utilizzare i nomi brevi dei tipi senza specificare ogni volta il package completo. Tuttavia, se non dichiari alcun package, le classi si trovano nel package di default, soluzione sconsigliata per progetti strutturati.
Commenti nel linguaggio Java
Commenti a singola linea in Java
I commenti a singola linea iniziano con due barre oblique e terminano a fine riga. In particolare, sono utili per note brevi e per disattivare temporaneamente una riga di codice.
public class CommentiSingolaLinea {
public static void main(String[] args) {
// Stampa un messaggio di benvenuto
System.out.println("Benvenuto");
// System.out.println("Questa riga è commentata e non verrà eseguita");
}
}
Commenti multilinea nel codice Java
I commenti multilinea iniziano con /* e terminano con */. Inoltre, sono usati per spiegazioni più lunghe o per commentare blocchi di codice durante il debug.
public class CommentiMultilinea {
public static void main(String[] args) {
/*
* Questo è un commento multilinea.
* Può estendersi su più righe senza problemi.
*/
System.out.println("Esempio di commento multilinea");
}
}
Commenti Javadoc nella sintassi Java
I commenti Javadoc rappresentano una forma speciale di commento che inizia con \/** e viene usata per generare automaticamente la documentazione delle API.
/**
* Rappresenta un conto bancario semplice.
*/
public class ContoBancario {
private double saldo;
/**
* Deposita un importo positivo sul conto.
*
* @param importo valore maggiore di zero da depositare
*/
public void deposita(double importo) {
saldo = saldo + importo;
}
/**
* Restituisce il saldo corrente.
*
* @return saldo del conto
*/
public double getSaldo() {
return saldo;
}
}
Variabili e dichiarazione in Java
Dichiarazione di variabili in Java
Una variabile in Java si dichiara specificando prima il tipo e poi il nome. Inoltre, è possibile dichiarare e inizializzare la variabile nello stesso punto.
public class VariabiliBase {
public static void main(String[] args) {
int eta;
eta = 25;
double prezzo = 19.99;
boolean attivo = true;
char iniziale = 'A';
System.out.println("Età: " + eta);
System.out.println("Prezzo: " + prezzo);
System.out.println("Attivo: " + attivo);
System.out.println("Iniziale: " + iniziale);
}
}
Variabili locali, di istanza e statiche in Java
Una variabile locale è dichiarata dentro un metodo o un blocco di codice e vive solo al suo interno. Diversa è la variabile di istanza, che viene dichiarata nella classe ma fuori dai metodi e appartiene a ogni oggetto. La variabile statica appartiene invece alla classe e viene condivisa da tutte le istanze.
public class Contatore {
private static int contatoreGlobale = 0; // variabile statica
private int contatoreIstanze = 0; // variabile di istanza
public void incrementa() {
int passo = 1; // variabile locale
contatoreIstanze = contatoreIstanze + passo;
contatoreGlobale = contatoreGlobale + passo;
}
}
Tipi di dati primitivi in Java
I tipi primitivi rappresentano valori di base memorizzati direttamente in memoria, non oggetti. In totale, Java definisce otto tipi primitivi, ognuno con dimensione e intervallo propri.
Tipi interi nella sintassi Java: byte, short, int, long
public class TipiInteri {
public static void main(String[] args) {
byte b = 10; // 8 bit
short s = 2000; // 16 bit
int i = 100000; // 32 bit
long l = 1000000000L; // 64 bit, lettera L obbligatoria per i long letterali grandi
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
}
}
Float e double nella sintassi Java
I tipi float e double rappresentano numeri in virgola mobile in formato IEEE 754. In particolare, double è il tipo di default per i valori decimali e offre maggiore precisione.
public class TipiDecimali {
public static void main(String[] args) {
float f = 3.14F; // suffisso F obbligatorio per i float
double d = 3.14159;
System.out.println(f);
System.out.println(d);
}
}
Boolean e char in Java
Il tipo boolean può assumere solo i valori true e false, mentre char rappresenta invece un singolo carattere Unicode.
public class TipiBooleanChar {
public static void main(String[] args) {
boolean acceso = true;
boolean valido = false;
char lettera = 'J';
char cifra = '7';
System.out.println(acceso);
System.out.println(valido);
System.out.println(lettera);
System.out.println(cifra);
}
}
Operatori nella sintassi Java
Gli operatori permettono di combinare valori e variabili per produrre nuove espressioni. In particolare, Java include operatori aritmetici, di confronto, logici, di assegnazione e bitwise.
Operatori aritmetici in Java
public class OperatoriAritmetici {
public static void main(String[] args) {
int a = 7;
int b = 3;
int somma = a + b;
int differenza = a - b;
int prodotto = a * b;
int divisioneIntera = a / b;
int resto = a % b;
System.out.println("somma = " + somma);
System.out.println("differenza = " + differenza);
System.out.println("prodotto = " + prodotto);
System.out.println("divisioneIntera = " + divisioneIntera);
System.out.println("resto = " + resto);
}
}
Operatori di confronto e logici in Java
Gli operatori di confronto restituiscono un booleano. Inoltre, gli operatori logici combinano valori booleani usando connettivi come and, or e not.
public class OperatoriConfrontoLogici {
public static void main(String[] args) {
int eta = 20;
boolean haPatente = true;
boolean maggiorenne = eta >= 18;
boolean puoGuidare = maggiorenne && haPatente;
boolean isTeen = eta >= 13 && eta <= 19;
boolean accessoSenior = eta >= 65;
System.out.println("maggiorenne = " + maggiorenne);
System.out.println("puoGuidare = " + puoGuidare);
System.out.println("isTeen = " + isTeen);
System.out.println("accessoSenior = " + accessoSenior);
}
}
Operatori di assegnazione e incremento in Java
public class OperatoriAssegnazione {
public static void main(String[] args) {
int numero = 10;
numero = numero + 5;
numero += 3;
numero -= 2;
numero *= 2;
int x = 1;
int preIncremento = ++x;
int y = 1;
int postIncremento = y++;
System.out.println("numero = " + numero);
System.out.println("x = " + x + ", preIncremento = " + preIncremento);
System.out.println("y = " + y + ", postIncremento = " + postIncremento);
}
}
Convenzioni di naming nel linguaggio Java
CamelCase, PascalCase e costanti nel linguaggio Java
Le convenzioni di naming non sono imposte dal compilatore ma sono fondamentali per la leggibilità. Ad esempio, in Java si usano schemi diversi per classi, metodi, variabili e costanti.
package it.example.naming;
public class OrderService { // PascalCase per classi
private static final int MAX_RETRY = 3; // UPPER_SNAKE_CASE per costanti
private int currentRetry; // camelCase per variabili di istanza
public void processOrder() { // camelCase per metodi
System.out.println("Elaborazione ordine");
}
}
Convenzioni per i package in Java
Per i package si usa solo minuscolo, senza underscore. In genere, è comune partire dal dominio invertito dell’azienda seguito dal nome del progetto e del modulo.
package it.miaazienda.app.ordini;
public class OrderController {
}
Input e output in Java: System.out e Scanner
Output con System.out.println in Java
La classe System espone un campo statico out, un oggetto di tipo PrintStream collegato all’output standard. In particolare, i metodi più usati sono print, println e printf.
public class OutputEsempio {
public static void main(String[] args) {
System.out.print("Senza newline");
System.out.print(" continua sulla stessa riga");
System.out.println();
System.out.println("Con newline alla fine");
String nome = "Alice";
int eta = 30;
double saldo = 1234.5678;
System.out.printf("Nome: %s, Età: %d, Saldo: %.2f%n", nome, eta, saldo);
}
}
Input da tastiera con Scanner in Java
Per leggere dati inseriti dall’utente tramite tastiera si utilizza spesso la classe Scanner, costruita a partire da System.in. Inoltre, è importante gestire gli errori di formato e chiudere correttamente le risorse.
import java.util.InputMismatchException;
import java.util.Scanner;
public class InputEsempio {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(System.in)) {
System.out.print("Inserisci il tuo nome: ");
String nome = scanner.nextLine();
System.out.print("Inserisci la tua età: ");
int eta = scanner.nextInt();
System.out.println("Ciao " + nome + ", hai " + eta + " anni.");
} catch (InputMismatchException e) {
System.err.println("Formato età non valido. Inserisci un numero intero.");
}
}
}
Esempi pratici di sintassi Java
Dichiarazioni, espressioni e statement in Java
Una dichiarazione introduce una nuova variabile o metodo. Un’espressione, invece, produce un valore. Infine, uno statement è un’istruzione completa, spesso terminata dal punto e virgola.
public class EspressioniEStatement {
public static void main(String[] args) {
int a = 10;
int b = 5;
int c = a + b * 2;
if (c > 15) {
System.out.println("c è maggiore di 15");
} else {
System.out.println("c è minore o uguale a 15");
}
String risultato = (c % 2 == 0) ? "pari" : "dispari";
System.out.println("c è " + risultato);
}
}
Scope delle variabili in Java
Scope delle variabili in Java e blocchi
public class ScopeEsempio {
private int field = 10;
public void metodo() {
int locale = 20;
if (locale > 0) {
int internoIf = 30;
System.out.println(field + locale + internoIf);
}
// La variabile internoIf non è visibile qui
}
public void loops() {
for (int i = 0; i < 3; i++) {
int dentroFor = i * 2;
System.out.println(dentroFor);
}
// Le variabili i e dentroFor non sono visibili fuori dal ciclo
}
}
Esempio completo di sintassi Java
Il seguente programma mette insieme variabili, input, output, operatori e strutture di controllo per calcolare l’indice di massa corporea di un utente. In questo modo è possibile vedere all’opera tutti gli elementi della sintassi Java.
import java.util.Scanner;
public class CalcolatoreImc {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(System.in)) {
System.out.print("Inserisci il peso in kg: ");
double peso = scanner.nextDouble();
System.out.print("Inserisci l'altezza in metri: ");
double altezza = scanner.nextDouble();
double imc = peso / (altezza * altezza);
System.out.println("Il tuo IMC è: " + imc);
if (imc < 18.5) {
System.out.println("Sottopeso");
} else if (imc < 25) {
System.out.println("Normopeso");
} else if (imc < 30) {
System.out.println("Sovrappeso");
} else {
System.out.println("Obesità");
}
}
}
}
Conclusione sulla sintassi Java e risorse correlate
In questa guida hai visto la struttura di base di un programma Java, come usare commenti, dichiarare variabili, lavorare con i tipi primitivi, utilizzare gli operatori e gestire input e output. In sintesi, questi sono i mattoni fondamentali su cui si costruiscono applicazioni reali.
Per continuare a studiare Java in modo strutturato puoi approfondire questi argomenti correlati sul sito:
- Programmazione orientata agli oggetti in Java: classi, oggetti e interfacce
- Strutture di controllo in Java: if, else, switch e cicli
- Array e collezioni di base in Java
- Variabili, tipi di dato e casting in Java
Inoltre, con una buona padronanza della sintassi e delle convenzioni di base ti sarà molto più semplice comprendere framework, librerie e pattern avanzati del mondo Java.
Lascia un commento