In informatica Java è un linguaggio di programmazione ad alto livello, orientato agli oggetti e a tipizzazione statica, che si appoggia sull’omonima piattaforma software di esecuzione, specificamente progettato per essere il più possibile indipendente dalla piattaforma hardware di esecuzione (tramite compilazione in bytecode prima e interpretazione poi da parte di una JVM) (sebbene questa caratteristica comporti prestazioni in termini di computazione inferiori a quelle di linguaggi direttamente compilati come C e C++ ovvero dunque perfettamente adattati alla piattaforma hardware).

ava è stato creato a partire da ricerche effettuate alla Stanford University agli inizi degli anni novanta. Nel 1992 nasce il linguaggio Oak (in italiano “quercia”), prodotto da Sun Microsystems e realizzato da un gruppo di esperti sviluppatori capitanati da James Gosling.^[1] Questo nome fu successivamente cambiato in Java per problemi di copyright: il linguaggio di programmazione Oak esisteva già.^[2]

Per facilitare il passaggio a Java ai programmatori old-fashioned, legati in particolare a linguaggi come il C++, la sintassi di base (strutture di controllo, operatori ecc.) è stata mantenuta pressoché identica a quella del C++^[3][4]; tuttavia a livello di linguaggio non sono state introdotte caratteristiche ritenute fonte di complessità non necessaria e che favoriscono l’introduzione di determinati bug durante la programmazione, come l’aritmetica dei puntatori e l’ereditarietà multipla delle classi.^[5] Per le caratteristiche orientate agli oggetti del linguaggio ci si è ispirati al C++ e soprattutto all’Objective C.^[6]

In un primo momento Sun decise di destinare questo nuovo prodotto alla creazione di applicazioni complesse per piccoli dispositivi elettronici; fu solo nel 1993 con l’esplosione di internet che Java iniziò a farsi notare come strumento per iniziare a programmare per internet.

Contemporaneamente Netscape Corporation annunciò la scelta di dotare il suo allora omonimo e celeberrimo browser della Java Virtual Machine (JVM). Questo segna una rivoluzione nel mondo di Internet: grazie agli applet le pagine web diventarono interattive a livello client, ovvero le applicazioni vengono eseguite direttamente sulla macchina dell’utente di internet e non su un server remoto. Per esempio gli utenti poterono utilizzare giochi direttamente sulle pagine web e usufruire di chat dinamiche e interattive.

Java fu annunciato ufficialmente il 23 maggio 1995 a SunWorld.

Il 13 novembre 2006 la Sun Microsystems ha distribuito la sua implementazione del compilatore Java e della macchina virtuale sotto licenza GPL. Non tutte le piattaforme Java sono libere. L’ambiente Java libero si chiama IcedTea.^[7]

L’8 maggio 2007 Sun ha pubblicato anche le librerie, tranne alcuni componenti non di sua proprietà, sotto licenza GPL, rendendo Java un linguaggio di programmazione la cui implementazione di riferimento è libera.^[8]

Il linguaggio è definito da un documento chiamato The Java Language Specification, spesso abbreviato JLS. La prima edizione del documento è stata pubblicata nel 1996.^[9] Da allora il linguaggio ha subito numerose modifiche e integrazioni, aggiunte di volta in volta nelle edizioni successive. A fine 2018 la versione più recente delle specifiche è la Java SE 11 Edition.^[9]

Descrizione

Uno dei principi fondamentali del linguaggio è espresso dal motto WORA (write once, run anywhere, ossia “scrivi una volta, esegui ovunque”): il codice compilato che viene eseguito su una piattaforma non deve essere ricompilato per essere eseguito su una piattaforma diversa. Infatti il prodotto della compilazione è in un formato chiamato bytecode che può essere eseguito da una qualunque implementazione di un processore virtuale detto Java Virtual Machine.

Al 2014 Java risulta essere uno dei linguaggi di programmazione più usati al mondo, specialmente per applicazioni client-server, con un numero di sviluppatori stimato intorno ai 9 milioni.^[10][11]

Un buon punto di partenza per imparare Java è il tutorial ufficiale^[12].

I principi

Java venne creato per soddisfare cinque obiettivi primari:^[13]

1. essere “semplice, orientato agli oggetti e familiare”;
2. essere “robusto e sicuro”;
3. essere indipendente dalla piattaforma;
4. contenere strumenti e librerie per il networking;
5. essere progettato per eseguire codice da sorgenti remote in modo sicuro.

Piattaforma Java

Schema delle varie piattaforme Java esistenti

I programmi scritti in linguaggio Java, dopo una fase iniziale di compilazione con ottenimento del cosiddetto bytecode, sono destinati all’esecuzione sulla piattaforma Java attraverso una fase di interpretazione (per questo motivo il linguaggio Java è detto anche semi-interpretato) ad opera di una Java Virtual Machine e in esecuzione hanno accesso alle API della libreria standard. Questi due passi forniscono un livello di astrazione che permette alle applicazioni di essere interamente indipendenti dal sistema hardware su cui esse saranno eseguite.

Un’implementazione della piattaforma java è il Java Runtime Environment (JRE), necessario per l’esecuzione del programma compilato, mentre per lo sviluppo dei programmi in Java a partire dal codice sorgente è necessario il Java Development Kit (JDK) che include anche il JRE.

Portabilità

Schema che illustra il funzionamento del bytecode sulle diverse piattaforme.

L’esecuzione di programmi scritti in Java deve avere un comportamento simile in contesti di esecuzione diversi. Per raggiungere questo obiettivo si lavora su livelli diversi e il primo di essi è naturalmente il linguaggio che è stato progettato appositamente proprio per questo scopo. Ad esempio esso fornisce una sintassi unificata per definire le sezioni critiche, compito che in altri linguaggi si svolge tipicamente ricorrendo a librerie di terze parti o primitive di sistema.^[14] Inoltre praticamente non lascia spazio ai comportamenti non definiti (undefined behavior) o dipendenti dall’implementazione dell’ambiente di esecuzione.

Le specifiche di linguaggio richiedono un ambiente di esecuzione che vigila sull’esecuzione del programma e che proibisce determinate operazioni che altrimenti risulterebbero insicure. Esse fanno riferimento esplicito alla Java Virtual Machine, indicandola come il destinatario tipico del bytecode prodotto dalla compilazione iniziale di un programma Java, e infatti il compilatore javac incluso nel JDK compila proprio in bytecode. Tuttavia è possibile la compilazione verso architetture diverse, infatti è possibile produrre codice oggetto specifico di un certo sistema operativo servendosi di un compilatore apposito, ad esempio il GNU Compiler Collection.

In linea di principio si dovrebbe essere in grado di scrivere il programma una sola volta e di farlo eseguire dovunque, di qui il famoso slogan di Sun: “write once, run everywhere”. La portabilità è un obiettivo tecnicamente difficile da raggiungere e il successo di Java in questo ambito è materia di alcune controversie. Sebbene in effetti sia possibile scrivere in Java programmi che si comportano in modo coerente attraverso molte piattaforme hardware diverse, questi dipendono dalle macchine virtuali che sono programmi a sé e che hanno inevitabilmente i loro bug, diversi l’una all’altra: per questo è nata una parodia dello slogan di Sun “Write once, run everywhere” (“Scrivi una volta, esegui ovunque”), che è diventato “Write once, debug anywhere” (“Scrivi una volta, correggi ovunque”).^[15]

Librerie

Versioni della piattaforma

Il linguaggio in sé definisce solo una minima parte delle librerie utilizzabili in combinazione con il linguaggio stesso. La parte restante è definita dalla piattaforma su cui il programma è eseguito.

La Oracle mette a disposizione tre piattaforme ufficiali, ciascuna destinata ad ambiti diversi:

• Java Platform, Standard Edition
• Java Platform, Micro Edition
• Java EE

Librerie di terze parti

In aggiunta il programmatore può utilizzare un numero arbitrario di librerie di terze parti. Queste librerie, contenute in vari package, vengono utilizzate dal programmatore per utilizzare determinati metodi o attributi comuni per semplificare e uniformare i programmi e renderli maggiormente leggibili ai programmatori. Esistono numerosissimi package utilizzabili dai programmatori nel linguaggio Java. Ad esempio esistono package:

• di input e output (java.io);
• per i metodi e le costanti matematiche (java.Math);
• per la creazione di applet (java.applet);
• per creare applicazioni di rete (javax.net);
• per la stampa (javax.print);
• per la sicurezza (java.security e javax.security).

Applet

La piattaforma Java fu uno dei primi sistemi a fornire un largo supporto per l’esecuzione del codice da sorgenti remote. Un Java applet è un particolare tipo di applicazione che può essere avviata all’interno del browser dell’utente eseguendo codice scaricato da un server web remoto. Questo codice viene eseguito in un’area (sandbox) altamente ristretta per proteggere l’utente da codice malevolo o che abbia un comportamento non desiderato; chi pubblica il codice può applicare un certificato che usa per firmare digitalmente gli applet dichiarandoli “sicuri”, dando loro il permesso di uscire dall’area ristretta e accedere al filesystem e al network, presumibilmente con l’approvazione e sotto il controllo dell’utente. In realtà gli applet non hanno avuto molta fortuna. Infatti si presuppone che il client in cui essi vengono eseguiti abbia installata la JRE che deve eseguire il codice dell’applet. Hanno avuto fortuna le applicazioni che prevedono il cosiddetto thin-client, cioè un client ‘leggero’ che non ha bisogno di particolari strumenti per eseguire il codice remoto, a volte è necessario solo il browser.

Linguaggio

Esempio di codice sorgente Java

Hello, world!

Segue il codice sorgente di un semplice programma che stampa il testo “Hello world” sulla console.

 class HelloWorld
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World");
     }
 }

Un programma minimale in Java deve obbligatoriamente contenere la definizione di classe tramite la parola chiave class seguita dal nome_classe e il metodo main o metodo principale nonché entry point del programma in cui vengono definite variabili globali, oggetti e richiamati metodi statici su variabili e/o dinamici sugli oggetti.

Nell’esempio soprastante il main contiene l’istruzione per la stampa a video della stringa Hello World; pur essendo perfettamente funzionante e semplice da comprendere, non viene sfruttata la filosofia ad oggetti che viene normalmente applicata ad ogni programma scritto in Java.

Segue il codice sorgente di un programma che svolge lo stesso compito del precedente usando la programmazione orientata agli oggetti.

public class Messaggio
{
     private String toPrint;

     public Messaggio(String print)
     {
          this.toPrint = print;
     }

     public void print()
     {
          System.out.println(this.toPrint);
     }

     public static void main(String args[])
     {
          Messaggio ciaoMondo = new Messaggio("Hello World!");
          ciaoMondo.print();
     }
}

Il metodo main affida la stampa del messaggio a un oggetto creato apposta per questo compito, su cui è invocato il metodo dinamico print definito prima del main assieme al costruttore della classe ovvero quel particolare metodo (con ugual nome della classe) che serve per inizializzare l’attributo della classe toPrint dell’oggetto creato/istanziato nel main. I metodi definibili possono essere dichiarati privati (contrassegnati dalla parola chiave private) se richiamabili solo all’interno della stessa classe oppure pubblici (contrassegnati dalla parola chiave public) se richiamabili anche da altre classi, di tipo statico (contrassegnati dalla parola chiave static) se invocabili liberamente all’interno della classe (ad es. su variabili globali), dinamici se invocabili su oggetti.

Scrivendo nuove classi che supportano l’operazione print, si può adattare il programma per mostrare messaggi di tipi radicalmente diversi, lasciando il main pressoché immutato, cambiando soltanto la metà riga che segue il new. Per esempio si può considerare un messaggio la scritta in una finestra che appare sullo schermo del computer in uso, oppure una stringa inviata su connessione di rete per apparire sulla finestra di un computer client. Oppure il programma può dialogare con l’utente sulla riga di comando o in una finestra (considerando il dialogo come un “messaggio interattivo”).

Si può modificare radicalmente il comportamento del programma con modifiche circoscritte e in punti predisposti a priori (polimorfismo): il programma può resistere ad aggiornamenti ed esigenze non previste.

Segue il codice sorgente di due programmi che mostrano lo stesso testo all’interno di una finestra. Il primo crea una finestra standard dove viene scritta la stringa inserita come parametro mentre il secondo programma crea una finestra rispettando i parametri (ad esempio la grandezza della finestra) inseriti nel codice.

import javax.swing.JOptionPane;
public class HelloWorld
{
   public static void main( String[] args) 
   {
        JOptionPane.showMessageDialog(null, "Hello World!");
   }
}

//HelloWorld.java
package helloworld;
 
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
 
public class HelloWorld extends Application
{
    @Override
    public void start(Stage primaryStage) 
    {
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction(new EventHandler<ActionEvent>() 
        {
             @Override
            public void handle(ActionEvent event) 
            {
                System.out.println("Hello World!");
            }
        });
        
        StackPane root = new StackPane();
        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 250);

        primaryStage.setTitle("Hello World!");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    public static void main(String[] args) 
    {
        launch(args);
    }
}

Il codice proposto crea degli oggetti utilizzati per gestire l’interfaccia grafica. Viene inizialmente creata una finestra il cui titolo è Hello World!; all’interno di questa finestra viene inserita un’etichetta che contiene al centro la scritta Hello World!. Infine viene stabilita la dimensione della finestra che, finalmente, viene resa visibile assieme all’etichetta che porta la scritta da visualizzare.

Anche in questo codice si fa uso della programmazione a oggetti, ma in un modo diverso: il main non conosce i meccanismi necessari per creare una interfaccia grafica sullo schermo e questi sono decisi dalle classi JFrame e JLabel che sono state predisposte a priori (incapsulamento).

Type system

Duke, la mascotte di Java

Java è un linguaggio type safe, a tipizzazione statica, con un nominative type system, e dotato di manifest typing. In virtù di queste caratteristiche, viene generalmente considerato un linguaggio a tipizzazione forte.

Il linguaggio distingue chiaramente i tipi primitivi che definiscono valori atomici dai tipi strutturati che definiscono strutture dati composte.
I tipi primitivi sono detti anche tipi atomici e tipi base e sono definiti nelle specifiche di linguaggio: di ognuno sono noti l’insieme esatto dei valori ammessi e gli operatori supportati.

I tipi strutturati sono anche tipi riferimento, cioè definiscono oggetti, e sono classi o interfacce. Tra queste, le classi degli array sono definite nelle specifiche di linguaggio; tutti gli altri tipi strutturati sono “definiti dall’utente” (user-defined), cioè dal programmatore. I tipi definiti dall’utente che sono legati al linguaggio per qualche motivo sono riuniti nel package java.lang e nei suoi sottopackage; il linguaggio stabilisce per alcuni di essi (Object, String, Iterable, e altri) delle regole sintattiche o semantiche aggiuntive.

I tipi riferimento includono le classi per la gestione delle stringhe, gli array e le collezioni (liste, mappe, ecc.).Tipi base

Da tutto ciò consegue che i valori dei tipi base non sono oggetti. Tuttavia per ogni tipo base è definita una corrispondente classe, definita in gergo tipo wrapper o tipo contenitore, nel package java.lang, classe che permette di incapsulare dentro un oggetto un valore di tipo primitivo. Opportuni metodi della classe wrapper permettono di ottenere l’oggetto che incapsula un certo valore, e il valore incapsulato da un certo oggetto.

Dalla versione 5.0 in poi sono supportati l’autoboxing e l’unboxing che permettono di convertire da tipo primitivo a corrispondente classe wrapper e viceversa. Il compilatore, “dietro le quinte”, traduce la conversione in una opportuna invocazione a metodo sulla classe contenitore; quindi non si tratta di una vera conversione, ma di una sintassi comoda che “nasconde” la creazione di un oggetto della classe wrapper.

Come molti altri linguaggi di programmazione anche Java possiede tra le strutture dati gli array (vedi array in Java).

Costanti

Valori costanti in Java si identificano con le parole chiave prefisse: static final seguita dal tipo, nome della costante e dal valore assegnato:

static final tipo_costante <nome_costante> = valore;

es:

static final String SALUTO = "Ciao";

Per convenzione i nomi delle costanti sono tutti maiuscoli.

Strutture di controllo

Sono supportate le seguenti strutture di controllo:

• Strutture selettive: if ... else e switch, come in C
• Strutture iterative:
  • while e do ... while come in C
  • for mutuato dal C
  • for each che agisce su un array o collezione^[16]
• La gestione delle eccezioni in Java viene gestita dalla sintassi try ... catch ... finally simile a quella del C++.

Al di là dei costrutti per la programmazione ad oggetti il resto della sintassi di Java è detta like C, cioè derivata o simile a quella del linguaggio C.

Orientamento agli oggetti

Java è un linguaggio object-oriented. L’idea che sta alla base della OOP è di rappresentare le entità reali o astratte che determinano le dinamiche del problema risolto dal software sotto forma di entità unitarie, dotate di specifiche d’uso e di funzionamento definite a priori. Queste entità sono chiamate oggetti. Le specifiche che definiscono le caratteristiche di queste unità e in base a cui le stesse vengono create o in gergo istanziate, sono chiamate classi.
Java tuttavia non è un linguaggio ad oggetti puro, ma solamente object oriented (orientato agli oggetti): per esempio i valori dei tipi primitivi non sono oggetti.

Nel linguaggio Java gli oggetti sono dotati di campi (definiti anche attributi o variabili di istanza o di esemplare) e di metodi. I metodi sono abitualmente usati per implementare agevolmente molti altri costrutti che alcuni altri linguaggi forniscono nativamente, come la gestione degli eventi (implementata attraverso i listener) o delle proprietà, implementate tramite gli accessor method e, più in generale, con oggetti JavaBeans.

In Java non esistono le funzioni: i blocchi di codice che “non appartengono a nessun oggetto” sono implementati come metodi statici di una certa classe e quindi sono sempre dei metodi.

In Java si pone un forte accento sulla distinzione tra interfaccia e implementazione di una classe o oggetto: la prima è l’insieme delle specifiche pubbliche di cui gli utilizzatori di un certo oggetto possono servirsi, mentre la seconda è l’insieme delle strutture interne e delle istruzioni eseguibili che, nel complesso, adempiono a tali specifiche. Il termine interfaccia è usato anche in un’altra accezione, spiegata nel seguito.

Ereditarietà

Esempio di polimorfismo: dalla base comune Shape discendono molti tipi differenti, dotati di comportamenti diversi

È supportata l’ereditarietà tra tipi. Questo permette di stabilire la gerarchia delle classi che compongono un programma. Il linguaggio impone che a capo della gerarchia ci sia la nota classe java.lang.Object.^[17]

In Java non esiste ereditarietà multipla tra classi.^[18] Da un lato questo vincolo permette di avere una gerarchia di classi lineare e previene gli svantaggi introdotti dall’ereditarietà multipla. Dall’altro esso viene agevolmente superato facendo ricorso alle interfacce, ovvero a tipi analoghi alle classi, ma progettati apposta per essere estesi e soggetti a determinate restrizioni imposte dal linguaggio.^[19][20] Di conseguenza esse forniscono alcuni vantaggi dell’ereditarietà multipla, come la possibilità che uno stesso oggetto appartenga a tipi diversi tra loro, senza gli svantaggi come l’ambiguità introdotta dal fatto che una classe possa ereditare implementazioni diverse di uno stesso metodo.

Dopo l’avvento di Java l’ereditarietà singola si è gradualmente affermata come modello standard di ereditarietà nelle tecnologie object-oriented ed è stata abbracciata anche dai linguaggi del framework .NET Microsoft.

Dal Java 8 è possibile sfruttare i default method delle interfacce per costruire una seppur limitata ereditarietà multipla. Questa non intacca la linea ereditaria principale che rimane singola, ma permette di ereditare metodi da più interfacce allo stesso tempo.^[21]

Ambienti di sviluppo

Per sviluppare programmi in Java è teoricamente sufficiente un qualsiasi editor di testo; in pratica, se si vuole scrivere qualcosa di più del classico hello world, occorre un ambiente di sviluppo integrato (IDE). Esistono diversi IDE (Integrated Development Environment, ambiente di sviluppo integrato), alcuni gratuiti ed altri a pagamento.

Java Development Kit[modifica | modifica wikitesto]

Sun (ora Oracle) mette a disposizione un software development kit specifico, chiamato Java Development Kit (o JDK). Esso include un certo numero di tool di uso comune, fra cui javac, javadoc, jar, e altri, atti ad elaborare (compilare) i file sorgenti e/o già compilati, includendo dunque il Java Runtime Environment (JRE).

Essi lavorano sul codice già scritto e salvato sul sistema: nessuno di essi fornisce un ambiente visivo di scrittura con quelle caratteristiche che tornano utili nella realizzazione di programmi complessi come l’evidenziazione della sintassi tramite colori diversi, l’autocompletamento, o la possibilità di navigare tra i sorgenti tramite il click del mouse.

Ambienti di sviluppo integrato[modifica | modifica wikitesto]

La Oracle stessa ha promosso lo sviluppo di un ambiente di sviluppo gratuito e open source chiamato NetBeans. Può essere scaricato da solo^[22], oppure (facoltativamente) con il JDK^[23].

• Un ambiente di sviluppo integrato open-source largamente utilizzato è Eclipse, donato alla comunità di sviluppatori da IBM e il cui sviluppo è seguito da una enorme comunità di utenti.
• Uno degli ambienti di sviluppo integrato commerciali più diffusi è JBuilder prodotto dalla Borland.
• Un ambiente di sviluppo integrato che ha vinto diversi premi^[24] è IntelliJ IDEA.
• Un ambiente di sviluppo per Java gratuito, e soprattutto leggero, è BlueJ, di chiara impostazione didattica.
• Un altro ambiente di sviluppo integrato per Java è JCreator, i cui pregi sono soprattutto la semplicità dell’interfaccia e la leggerezza.

Documentazione[modifica | modifica wikitesto]

Le specifiche di linguaggio non impongono una determinata sintassi per la documentazione dei sorgenti, tuttavia nel tempo si è imposto come formato standard quello riconosciuto dal tool Javadoc e regolato da specifiche ufficiali ben definite (seppure esterne al linguaggio)^[25]. Questo standard prevede che la documentazione sia fornita all’interno di commenti inseriti direttamente nei sorgenti e dotati di una speciale formattazione, che viene ignorata dal compilatore, ma riconosciuta da tool specializzati. Ciò rende facile aggiornare la documentazione, in quanto essa accompagna direttamente l’elemento sintattico da essa marcato; inoltre, durante la lettura dei sorgenti di un programma, ciò permette di avere sott’occhio insieme le specifiche e l’implementazione dell’elemento di programma preso in considerazione.

Un altro strumento utilizzabile per la documentazione sono le annotazioni, introdotte nella terza versione delle specifiche di linguaggio^[26]. Pur avendo una sintassi formalmente differente dai commenti Javadoc, esse sono usate per lo stesso scopo, cioè fornire metadati che descrivono le entità di programma marcate. Tuttavia, mentre i commenti riportano le specifiche in maniera discorsiva (seppure strutturata), le annotazioni per loro stessa natura sono ideali per l’elaborazione tramite i tool, più che per la lettura da parte di esseri umani. Inoltre, sotto opportune condizioni^[27], le informazioni che forniscono sono compilate insieme al codice e possono essere lette perfino a tempo di esecuzione, cosa che i commenti non possono fare.

Versioni[modifica | modifica wikitesto]

A partire dal 2017, solo Java 8 e 10 sono supportati pubblicamente. Non verranno più rilasciate security update per Java 9^[28].

• JDK 1.0 (none) 23 gennaio 1996
• JDK 1.1 (none) 19 febbraio 1997
  • JDK 1.1.4 (Sparkler) 12 settembre 1997
  • JDK 1.1.5 (Pumpkin) 3 dicembre 1997
  • JDK 1.1.6 (Abigail) 24 aprile 1998
  • JDK 1.1.7 (Brutus) 28 settembre 1998
  • JDK 1.1.8 (Chelsea) 8 aprile 1999
• J2SE 1.2 (Playground) 4 dicembre 1999
  • J2SE 1.2.1 (none) 30 marzo 1999
  • J2SE 1.2.2 (Cricket) 8 luglio 1999
• J2SE 1.3 (Kestrel) 8 maggio 2000
  • J2SE 1.3.1 (Ladybird) 17 maggio 2001
• J2SE 1.4.0 (Merlin) 13 febbraio 2002
  • J2SE 1.4.1 (Hopper) 16 settembre 2002
  • J2SE 1.4.2 (Mantis) 26 giugno 2003
• J2SE 5.0 (1.5.0) (Tiger) 29 settembre 2004
• Java SE 6 (1.6.0) (Mustang) 11 dicembre 2006
• Java SE 7 (1.7.0) (Dolphin) 28 luglio 2011
• Java SE 8 (1.8.0) 18 marzo 2014
• Java SE 9, 21 settembre 2017
• Java SE 10, 20 marzo 2018
• Java SE 11, 25 settembre 2018
• Java SE 12, 19 marzo 2019
• Java SE 13, 17 settembre 2019

Java fu inizialmente distribuito come Java Development Kit 1.0 (JDK 1.0). Questo comprende il runtime Java (la virtual machine e le librerie di classi), e gli strumenti di sviluppo (il compilatore Java e altri strumenti). Successivamente, Sun fornì un pacchetto che comprendeva solo il runtime, chiamato Java Runtime Environment (JRE). Normalmente le persone si riferiscono ad una particolare versione di Java attraverso la versione del JDK (es. JDK 1.4) Le versioni JDK 1.2 e successive sono spesso chiamate Java 2. Per esempio, il nome ufficiale del JDK 1.4 è Java (TM) 2 Platform, Standard Edition 1.4.

Il linguaggio è rimasto stabile dal JDK 1.0 al JDK 1.4.x, con la J2SE 5.0 sono state introdotte nuove funzionalità nel linguaggio. La libreria di classi che viene fornita con JDK è stata progressivamente ampliata e modificata in alcune parti.Versioni delle specifiche di linguaggio

I cambiamenti nel linguaggio sono formalizzati nelle specifiche di linguaggio. Ogni nuova edizione delle specifiche integra i cambiamenti richiesti fino a quel momento tramite le Java Specification Request e conseguentemente implementati nel compilatore javac.

• The Java Programming Language, First Edition
• The Java Programming Language, Second Edition
• The Java Programming Language, Third Edition
• The Java Programming Language, Java SE 7 Edition
• The Java Programming Language, Java SE 8 Edition
• The Java Programming Language, Java SE 9 Edition

Curiosità[modifica | modifica wikitesto]

• Sembra che il nome Oak derivi dal fatto che Gosling e i suoi colleghi, nel periodo in cui svilupparono il linguaggio, avessero avuto come unica compagnia quella di una quercia che si trovava proprio fuori la finestra dell’ufficio in cui lavoravano.
• Una leggenda metropolitana -mai confermata- vuole che il nome del linguaggio sia stato inteso, in un secondo momento e dagli stessi creatori, come acronimo per “Just Another Vacuum Acronym” (“Soltanto un altro vuoto Acronimo“), con riferimento ironico all’altissimo numero di abbreviazioni utilizzate in ambiente informatico.
• Dato che gli ideatori del linguaggio si trovavano spesso ad un caffè presso il quale discutevano del progetto, sembrerebbe che il linguaggio prese il nome e il simbolo da tale abitudine (Java è una qualità di caffè dell’omonima isola dell’Indonesia), tanto che il magic number che identifica un file di bytecode ottenuto dalla compilazione di un file Java è 0xCAFEBABE, che in inglese significa ragazza (babe) del caffè (cafe)^[29].

Note[modifica | modifica wikitesto]

1. ^ The Java Language Specification, su java.sun.com. URL consultato il 5 maggio 2011.
2. ^ JavaWorld.com, “So why did they decide to call it Java?”, su javaworld.com. URL consultato il 5 maggio 2011.
3. ^ Come indicato in Design Goals of the Java(TM) Programming Language: Simple, Object Oriented, and Familiar, su java.sun.com. URL consultato il 6 maggio 2011.
4. ^ The Java Language Environment
5. ^ The Java Language Environment
6. ^ The Java(tm) Language: An Overview
7. ^ “Q: What components of the JDK software are you open sourcing today? A: We’re open sourcing the Java programming language compiler (“javac”), and the Java HotSpot virtual machine.”Free and Open Source Java FAQ; the source is being released via the OpenJDK Archiviato l’11 giugno 2007 in Internet Archive. project.
8. ^ Open JDK is here! (TXT), Sun Microsystems, 8 maggio 2007. URL consultato il 9 maggio 2007.
9. ^ ^{Salta a:a b} The Java Language Specification, su java.sun.com. URL consultato il 5 maggio 2011.
10. ^ Programming Language Popularity, su langpop.com, 2014. URL consultato il 7 febbraio 2014 (archiviato dall’url originale il 27 maggio 2012).
11. ^ TIOBE Programming Community Index, su tiobe.com, 2009. URL consultato il 6 maggio 2009.
12. ^ The Java Tutorials
13. ^ Design Goals of the Java(TM) Programming Language, su java.sun.com. URL consultato il 6 maggio 2011.
14. ^ The Java Language Environment, su java.sun.com. URL consultato il 6 maggio 2011.
15. ^ William Wong, Write Once, Debug Everywhere, electronicdesign.com. URL consultato il 3 agosto 2008 (archiviato dall’url originale il 21 marzo 2009). So far, the “write-once, run-everywhere” promise of Java hasn’t come true. The bulk of a Java application will migrate between most Java implementations, but taking advantage of a VM-specific feature causes porting problems.
16. ^ in particolare è definito per lavorare su un qualunque oggetto che sia istanza di java.lang.Iterable
17. ^ James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Chapter 4. Types, Values, and Variables, in The Java Language Specification, Third Edition. URL consultato il 6 maggio 2011.
18. ^ Le specifiche di linguaggio non ammettono l’indicazione di più di una superclasse nella definizione di una data classe: vedi Java SE Specifications, Java SE Specifications.
19. ^ The Java Language Environment, “Java language Interfaces”, su java.sun.com. URL consultato il 6 maggio 2011.
20. ^ James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Chapter 9. Interfaces, in The Java Language Specification, Third Edition. URL consultato il 7 maggio 2011.
21. ^ Java 8 explained: Default methods, su zeroturnaround.com. URL consultato il 3 aprile 2016.
22. ^ Welcome to NetBeans
23. ^ Java SE Downloads
24. ^ Awards
25. ^ How to Write Doc Comments for the Javadoc Tool, su oracle.com. URL consultato il 16 giugno 2011.
26. ^ The Java Language Specification, Annotations, su java.sun.com. URL consultato il 16 giugno 2011.
27. ^ Il tipo che definisce l’annotazione in uso deve essere stato marcato con la meta-annotazione @Retention. Vedi The Java Language Specification, Interfaces, su java.sun.com. URL consultato il 16 giugno 2011.
28. ^ Oracle Java SE Support Roadmap, su http://www.oracle.com. URL consultato il 4 ottobre 2018.
29. ^ James Gosling private communication to Bill Bumgarner, su radio.weblogs.com. URL consultato il 1º agosto 2011 (archiviato dall’url originale il 23 maggio 2009).

Bibliografia[modifica | modifica wikitesto]

Fonti usate per la stesura della voce

• Claudio De Sio Cesari, Object Oriented && Java 5. URL consultato il 29 giugno 2019.
• Sezione “Storia“: Java 2 Micro Edition basics (PDF), su oracle.com. URL consultato il 5 maggio 2011.
• The Java Language Specification, Java SE 7 Edition (vedi sotto)
• Fabrizia Scorzoni, Informatica Programmazione in Java, Torino, Loescher, 2009, ISBN 978-88-8433-030-7.

Specifiche di linguaggio

Le diverse edizioni delle specifiche sono accessibili sul sito della Oracle. L’ultima edizione è la seguente:

• (EN) James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Alex Buckley, The Java Language Specification, Java SE 8 Edition (PDF). URL consultato il 18 marzo 2014.
• (EN) James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Alex Buckley, The Java Language Specification, Java SE 7 Edition (PDF). URL consultato il 28 agosto 2012.

Testi di approfondimento

• (EN) Ken Arnold, James Gosling, David Holmes, The Java Programming Language, Fourth Edition, Addison-Wesley Professional, 2005, ISBN 0-321-34980-6.

Fonte: Wikipedia

Categorie:Z01- Linguaggi di programmazione