Il Corso Typescript Completo è online!

Storia e Evoluzione di Java

Edoardo Midali
Edoardo Midali

Java è uno dei linguaggi di programmazione più influenti e utilizzati al mondo. La sua storia inizia negli anni '90 e continua ancora oggi con continue innovazioni. In questa lezione, esploreremo l’evoluzione di Java dalle sue origini fino alle versioni più recenti.

Le Origini (1991-1995)

Il Progetto Green

Java nacque nel 1991 presso Sun Microsystems come parte del Progetto Green, guidato da James Gosling. L’obiettivo iniziale era creare un linguaggio per dispositivi elettronici di consumo come televisori e decoder.

// Il primo programma Java della storia
class HelloWorld {
    public static void main(String args[]) {
        System.out.println("Hello World!");
    }
}

Caratteristiche Innovative

Il team di Gosling sviluppò un linguaggio con caratteristiche rivoluzionarie:

  • Portabilità: “Write Once, Run Anywhere” (WORA)
  • Orientamento agli oggetti: Basato su classi e oggetti
  • Gestione automatica della memoria: Garbage Collection
  • Sicurezza: Sandboxing per applicazioni web

Il Nome “Java”

Il linguaggio fu inizialmente chiamato “Oak”, ma per problemi di trademark venne rinominato “Java” nel 1995, ispirato dal caffè bevuto dal team durante lo sviluppo.

L’Era delle Prime Versioni (1995-2000)

Java 1.0 (1996) - “Oak”

La prima versione pubblica di Java includeva:

  • JVM (Java Virtual Machine): Il cuore dell’ecosistema Java
  • Applet: Applicazioni web interattive
  • AWT (Abstract Window Toolkit): Interfacce grafiche primitive
  • Librerie base: java.lang, java.io, java.util
// Esempio di Applet Java 1.0
import java.applet.Applet;
import java.awt.Graphics;

public class HelloApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello World!", 20, 20);
    }
}

Java 1.1 (1997)

Introdusse miglioramenti significativi:

  • Inner Classes: Classi annidate
  • JavaBeans: Componenti riutilizzabili
  • JDBC: Connettività database
  • RMI: Remote Method Invocation
  • Reflection: Introspezione runtime

Java 1.2 (1998) - “Java 2”

Una versione rivoluzionaria che introdusse:

  • Swing: Framework GUI avanzato
  • Collections Framework: List, Set, Map
  • JIT Compiler: Compilazione Just-In-Time
  • Policy-based Security: Modello di sicurezza granulare
// Collections Framework introdotto in Java 1.2
import java.util.*;

List<String> lista = new ArrayList<>();
lista.add("Java");
lista.add("è");
lista.add("fantastico!");

L’Evoluzione Moderna (2000-2010)

Java 1.3 (2000) - “Kestrel”

  • HotSpot JVM: Ottimizzazioni performance significative
  • Java Sound: API per audio
  • JNDI: Java Naming and Directory Interface

Java 1.4 (2002) - “Merlin”

Aggiunse funzionalità enterprise:

  • Assertions: Debugging e testing migliorato
  • Regular Expressions: Pattern matching
  • NIO: New Input/Output con canali e buffer
  • XML Processing: Parser XML integrato
  • Logging API: Sistema di logging standardizzato
// Regular Expressions in Java 1.4
import java.util.regex.*;

Pattern pattern = Pattern.compile("\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b");
Matcher matcher = pattern.matcher("email@example.com");

Java 5 (2004) - “Tiger”

Una delle versioni più importanti con innovazioni drastiche:

  • Generics: Type safety a compile-time
  • Enhanced For Loop: Iterazione semplificata
  • Autoboxing/Unboxing: Conversione automatica
  • Enumerations: Tipi enumerati type-safe
  • Varargs: Parametri variabili
  • Annotations: Metadati nel codice
// Generics e Enhanced For Loop
List<String> nomi = Arrays.asList("Alice", "Bob", "Charlie");
for (String nome : nomi) {
    System.out.println(nome);
}

// Enumerations
enum Giorno {
    LUNEDI, MARTEDI, MERCOLEDI, GIOVEDI, VENERDI, SABATO, DOMENICA
}

Java 6 (2006) - “Mustang”

  • Scripting Support: Integrazione linguaggi di scripting
  • Compiler API: Compilazione programmatica
  • Desktop Integration: Migliore integrazione OS
  • Performance Improvements: Ottimizzazioni JVM

Java 7 (2011) - “Dolphin”

Dopo 5 anni di sviluppo:

  • Diamond Operator: Inferenza di tipo
  • Switch con Stringhe: Switch statement più flessibili
  • Try-with-resources: Gestione automatica risorse
  • Multi-catch: Gestione eccezioni multiple
  • Binary Literals: Letterali binari
// Try-with-resources in Java 7
try (FileReader file = new FileReader("file.txt");
     BufferedReader buffer = new BufferedReader(file)) {
    return buffer.readLine();
}

// Diamond Operator
Map<String, List<String>> map = new HashMap<>();

L’Era Oracle e le Release Moderne (2010-presente)

Acquisizione Oracle (2010)

Nel 2010, Oracle acquisì Sun Microsystems, diventando il proprietario di Java e assumendo la responsabilità del suo sviluppo futuro.

Java 8 (2014) - “LTS”

Una versione rivoluzionaria che introdusse la programmazione funzionale:

  • Lambda Expressions: Programmazione funzionale
  • Stream API: Elaborazione dati funzionale
  • Optional: Gestione valori null-safe
  • Default Methods: Evoluzione interfacce
  • New Date/Time API: java.time package
// Lambda Expressions e Stream API
List<String> nomi = Arrays.asList("Alice", "Bob", "Charlie", "David");

nomi.stream()
    .filter(nome -> nome.startsWith("A"))
    .map(String::toUpperCase)
    .forEach(System.out::println);

// Optional
Optional<String> nome = Optional.of("Java");
nome.ifPresent(System.out::println);

Nuovo Ciclo di Release (2017)

Oracle introdusse un ciclo di release semestrale:

  • Marzo e Settembre: Nuove versioni ogni 6 mesi
  • LTS (Long Term Support): Ogni 3 anni
  • Maggiore velocità: Innovazione accelerata

Java 9 (2017)

  • Module System (Jigsaw): Modularizzazione della piattaforma
  • JShell: REPL interattivo
  • Process API: Gestione processi migliorata
  • Reactive Streams: Flow API
// Module System
module com.example.app {
    requires java.base;
    requires java.logging;
    exports com.example.app.public;
}

Java 10 (2018)

  • Local Variable Type Inference: Parola chiave var
  • Application Class-Data Sharing: Startup più veloce
  • Garbage Collector Interface: API unificata GC
// Var keyword
var lista = new ArrayList<String>();
var mappa = new HashMap<String, Integer>();

Java 11 (2018) - “LTS”

  • HTTP Client: Client HTTP moderno
  • String Methods: Nuovi metodi per stringhe
  • Files Methods: Lettura/scrittura file semplificata
  • Lambda Parameter Annotations: Annotazioni nei lambda
// HTTP Client
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com"))
    .build();

Java 12-16 (2019-2021)

Innovazioni continue:

  • Switch Expressions (Java 12-14)
  • Text Blocks (Java 13-15)
  • Records (Java 14-16)
  • Pattern Matching (Java 14-16)
  • Sealed Classes (Java 15-17)
// Records (Java 16)
public record Persona(String nome, int età) {}

// Text Blocks (Java 15)
String json = """
    {
        "nome": "Alice",
        "età": 30
    }
    """;

Java 17 (2021) - “LTS Corrente”

  • Pattern Matching per switch: Migliorato
  • Sealed Classes: Finalizzate
  • Strong Encapsulation: JDK internals
  • macOS/AArch64 Port: Supporto Apple Silicon

Java 18-21 (2022-2023)

  • Virtual Threads (Project Loom)
  • Pattern Matching avanzato
  • Vector API (Project Panama)
  • Foreign Function Interface

Versioni LTS e Strategia di Rilascio

Long Term Support

Le versioni LTS ricevono supporto esteso:

  • Java 8: LTS fino a 2030+
  • Java 11: LTS fino a 2026
  • Java 17: LTS fino a 2029
  • Java 21: LTS fino a 2031

Strategia di Adozione

// Raccomandazioni per la produzione
// Usa sempre versioni LTS per applicazioni critiche
// Testa nuove feature nelle versioni intermedie
// Pianifica migrazioni con largo anticipo

Conclusione

La storia di Java è una storia di innovazione continua e adattamento. Da linguaggio per dispositivi elettronici a pilastro dell’enterprise computing, Java ha dimostrato una resilienza e capacità di evoluzione straordinarie.

Con il nuovo modello di rilascio e i progetti futuri, Java continua a evolversi mantenendo la compatibilità all’indietro che l’ha resa la piattaforma di sviluppo più affidabile al mondo. La sua filosofia “Write Once, Run Anywhere” rimane più rilevante che mai nell’era del cloud computing e dei microservizi.

PrecedenteCommentiSuccessivoCaratteristiche del Linguaggio