Introduzione a Java
Java è uno dei linguaggi di programmazione più utilizzati al mondo, nato nel 1995 da Sun Microsystems (ora Oracle). La sua filosofia "Write Once, Run Anywhere" lo ha reso la scelta preferita per applicazioni enterprise, Android e sistemi distribuiti.
Cosa Imparerai
- Storia e filosofia di Java
- Differenza tra JVM, JRE e JDK
- Configurazione dell'ambiente di sviluppo
- Struttura di un programma Java
- Convenzioni di naming
Storia di Java
Java nasce nel 1991 come progetto interno di Sun Microsystems chiamato "Oak", guidato da James Gosling. L'obiettivo era creare un linguaggio per dispositivi embedded, ma con l'esplosione del web, Java trovo la sua nicchia nelle applet e nelle applicazioni server-side.
Tappe Fondamentali
- 1995: Prima release pubblica (Java 1.0)
- 2004: Java 5 introduce generics, annotations, enum
- 2014: Java 8 porta lambda expressions e Stream API
- 2017: Oracle adotta release semestrali
- 2021: Java 17 LTS (Long Term Support)
- 2023: Java 21 LTS con virtual threads
JVM, JRE e JDK
Comprendere la differenza tra questi tre componenti è fondamentale per ogni sviluppatore Java.
JVM (Java Virtual Machine)
La JVM è il cuore dell'ecosistema Java. È una macchina virtuale che esegue il bytecode Java, rendendo i programmi indipendenti dalla piattaforma.
Codice Sorgente (.java)
|
v
Compilatore (javac)
|
v
Bytecode (.class)
|
v
JVM (esecuzione)JRE (Java Runtime Environment)
Il JRE include la JVM più le librerie standard necessarie per eseguire applicazioni Java. È sufficiente per gli utenti finali che devono solo eseguire programmi Java.
JDK (Java Development Kit)
Il JDK include il JRE più gli strumenti di sviluppo: compilatore (javac), debugger, documentazione e utility varie. È necessario per sviluppare applicazioni Java.
+------------------------------------------+
| JDK |
| +------------------------------------+ |
| | JRE | |
| | +------------------------------+ | |
| | | JVM | | |
| | +------------------------------+ | |
| | + Librerie Standard | | |
| +------------------------------------+ |
| + Compilatore (javac) |
| + Debugger |
| + Tools (jar, javadoc, etc.) |
+------------------------------------------+Setup Ambiente di Sviluppo
1. Installazione JDK
Per sviluppare in Java, consiglio di installare una distribuzione LTS (Long Term Support) come Java 21.
# Aggiorna i repository
sudo apt update
# Installa OpenJDK 21
sudo apt install openjdk-21-jdk
# Verifica l'installazione
java --version
javac --version# Installa OpenJDK 21
brew install openjdk@21
# Aggiungi al PATH
echo 'export PATH="/opt/homebrew/opt/openjdk@21/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
# Verifica
java --version# Scarica da: https://adoptium.net/
# Oppure usa winget:
winget install EclipseAdoptium.Temurin.21.JDK
# Verifica (PowerShell)
java --version2. Configurazione IDE
IntelliJ IDEA è l'IDE più utilizzato per lo sviluppo Java professionale. La versione Community è gratuita e sufficiente per questo corso.
IDE Consigliati
- IntelliJ IDEA: Il più completo, ottimo per progetti enterprise
- VS Code: Leggero, con estensioni Java (Extension Pack for Java)
- Eclipse: Storico, ancora usato in ambito enterprise
Struttura di un Programma Java
Il Primo Programma
Ogni programma Java inizia con una classe che contiene il metodo main.
/**
* Il mio primo programma Java.
* Questo è un commento Javadoc.
*/
public class HelloWorld {
/**
* Punto di ingresso dell'applicazione.
* @param args argomenti da linea di comando
*/
public static void main(String[] args) {
// Questo è un commento su singola riga
System.out.println("Ciao, Mondo!");
/*
* Questo è un commento
* su più righe
*/
}
}Analisi della Struttura
public class HelloWorld // Dichiarazione della classe
{ // La classe DEVE avere lo stesso nome del file
public // Modificatore di accesso (visibile ovunque)
static // Metodo di classe (non richiede istanza)
void // Tipo di ritorno (nessun valore)
main // Nome del metodo (entry point)
(String[] args) // Parametri (array di stringhe)
System.out.println() // Stampa su console con newline
}Compilazione ed Esecuzione
# Compila il file sorgente
javac HelloWorld.java
# Viene generato HelloWorld.class (bytecode)
# Esegui il programma
java HelloWorld
# Output: Ciao, Mondo!Convenzioni di Naming
Java ha convenzioni di naming ben definite che rendono il codice leggibile e professionale.
// CLASSI: PascalCase (maiuscola iniziale ogni parola)
public class StudenteUniversitario { }
public class GestoreOrdini { }
// METODI e VARIABILI: camelCase (minuscola iniziale)
public void calcolaMedia() { }
private String nomeCompleto;
int conteggioStudenti;
// COSTANTI: UPPER_SNAKE_CASE
public static final int MAX_STUDENTI = 30;
public static final String CODICE_SCUOLA = "SC001";
// PACKAGE: tutto minuscolo, dominio invertito
package com.scuola.gestione.studenti;
package it.istituto.registro.voti;Best Practices per i Nomi
Regole da Seguire
- Descrittivi:
calcolaMediaVoti()invece dicalc() - Evita abbreviazioni:
studenteinvece distd - Verbi per metodi:
getVoto(),setNome(),isPromosso() - Sostantivi per classi:
Studente,Corso,Voto - Plurale per collezioni:
List<Studente> studenti
Tipi di Commenti
// 1. Commento su singola riga
int voto = 8; // Voto dello studente
// 2. Commento su più righe
/*
* Questo blocco di codice calcola
* la media dei voti di uno studente
* considerando tutti i trimestri.
*/
// 3. Commento Javadoc (per documentazione)
/**
* Calcola la media aritmetica dei voti.
*
* @param voti array dei voti da mediare
* @return la media calcolata
* @throws IllegalArgumentException se l'array è vuoto
*/
public double calcolaMedia(int[] voti) {
// implementazione
}Esempio Completo: Registro Scolastico
package it.scuola.registro;
/**
* Classe principale del Registro Scolastico.
* Dimostra la struttura base di un programma Java.
*
* @author Federico Calo
* @version 1.0
*/
public class RegistroScolastico {
// Costanti della classe
public static final String NOME_SCUOLA = "Liceo Scientifico Einstein";
public static final int ANNO_SCOLASTICO = 2025;
/**
* Punto di ingresso dell'applicazione.
*
* @param args argomenti da linea di comando (non utilizzati)
*/
public static void main(String[] args) {
// Stampa intestazione
System.out.println("================================");
System.out.println(" " + NOME_SCUOLA);
System.out.println(" Anno Scolastico: " + ANNO_SCOLASTICO);
System.out.println("================================");
// Dati di esempio
String nomeStudente = "Mario Rossi";
String classe = "3A";
int[] votiMatematica = {7, 8, 6, 9, 8};
// Calcolo media
double media = calcolaMedia(votiMatematica);
// Stampa risultato
System.out.println("\nStudente: " + nomeStudente);
System.out.println("Classe: " + classe);
System.out.println("Media Matematica: " + media);
System.out.println("Esito: " + (media >= 6 ? "Promosso" : "Rimandato"));
}
/**
* Calcola la media aritmetica di un array di voti.
*
* @param voti array contenente i voti
* @return la media aritmetica dei voti
*/
public static double calcolaMedia(int[] voti) {
if (voti == null || voti.length == 0) {
return 0.0;
}
int somma = 0;
for (int voto : voti) {
somma += voto;
}
return (double) somma / voti.length;
}
}================================
Liceo Scientifico Einstein
Anno Scolastico: 2025
================================
Studente: Mario Rossi
Classe: 3A
Media Matematica: 7.6
Esito: PromossoConclusione
In questo primo articolo abbiamo visto le basi di Java: la sua storia, l'architettura JVM/JRE/JDK, come configurare l'ambiente di sviluppo e la struttura di un programma Java.
Nel prossimo articolo approfondiremo i tipi di dato primitivi e il controllo del flusso: variabili, operatori, condizioni e cicli.
Punti Chiave da Ricordare
- JDK: Necessario per sviluppare (include compilatore)
- JRE: Necessario per eseguire (include JVM + librerie)
- JVM: Esegue il bytecode, garantisce portabilita
- main: Punto di ingresso di ogni applicazione Java
- Naming: PascalCase per classi, camelCase per metodi/variabili
- Javadoc: Documenta il codice in modo professionale