Introduzione a JAVA Dott. Ing. Leonardo Rigutini Dipartimento Ingegneria dell'Informazione Università di Siena Via Roma 56 53100 - SIENA Uff ...

Introduzione a JAVA

Dott. Ing. Leonardo Rigutini
Dipartimento Ingegneria dell’Informazione
Università di Siena
Via Roma 56 – 53100 – SIENA
Uff. 0577233606
rigutini@dii.unisi.it
http://www.dii.unisi.it/~rigutini/

JAVA

Il linguaggio di programmazione JAVA
¾   Nel 1991 un gruppo di Sun MicroSystems, guidato da James
    Gosling e Patrick Naughton, progettò un linguaggio chiamato in
    codice “Green”, per l’utilizzo in apparecchi di consumo:
    ¾   Elettrodomestici intelligenti, telefoni mobili, ecc….

¾   Il linguaggio era stato progettato per essere SEMPLICE e
    NEUTRALE rispetto all’architetture, in modo da operare su
    hardware diversi:
    ¾   Non si trovò mai un cliente per questa tecnologia

¾   Nel 1994, la squadra si rese conto che un’altra area poteva sfruttare
    le proprietà di “Green”: il filone client/server
    ¾   Indipendenza dall’architettura
    ¾   Esecuzione in tempo reale
    ¾   Affidabilità e sicurezza

Nasce JAVA
¾   Nel 1995 fu presentato dalla Sun il browser HotJava che aveva una
    caratteristica unica:
    ¾   Poteva scaricare piccoli programmi, chiamati applet , dal web ed
        eseguirli sulla macchina client con un elevato grado di sicurezza

¾   Gli applet scritti nel linguaggio che adesso si chiama Java,
    permettevano agli sviluppatori Web di predisporre una serie di
    animazioni e integrazioni che potevano migliorare molto le
    potenzialità della pagina

¾   Dal 1996, sia Netscape (allora molto diffuso) che Explorer
    supportano Java

La crescita di Java
¾   Da allora Java è cresciuto a ritmo fenomenale:
    ¾   I programmatori lo hanno adottato per la sua elevata semplicità rispetto
        al rivale/progenitore (il C++)

¾   Inoltre la Sun rilasciava con Java, una libreria enormemente ricca
    (JDK – Java Development Kit) che forniva agli sviluppatori una
    innumerevole quantità di classi per i problemi più diversi

¾   Nel 1998 la Sun rilasciò la nuova versione del linguaggio, chiamata
    Java2, e la sua libreria ampliata con nuove classi:
    ¾   La nuova release aveva due versioni, la micro-edition(J2ME), pensata
        per lo sviluppo su piccoli dispositivi integrati (gli anni del boom del
        cellulare) e la enterprise edition (J2EE), pensata per le workstation

JAVA ed internet
¾   Poiché Java era stato pensato per Internet, ha due qualità che lo
    rendono molto adatto per i principianti:
    ¾   Sicurezza – le applet si avviano automaticamente una volta scaricate dal
        browser, quindi è importante che esse siano intrinsecamente sicuri
    ¾   Trasferibilità – lo stesso programma Java è eseguibile su qualsiasi
        piattaforma (Windows, Unix-like o Machintosh)

¾   Quando si visita un sito, il server web non ha idea di quale computer
    state utilizzando, ma restituisce semplicemente il codice trasferibile
    che è stato generato dal compilatore Java
    ¾   la macchina virtuale Java sul computer client si occuperà di eseguire
        questo codice trasferibile

Tipi di programmi Java
¾   Applets
    ¾   Piccoli programmi Java utilizzati all'interno di pagine HTML
    ¾   Vengono scaricate insieme alla pagina HTML ed eseguite lato client (dal
        browser o da un applet viewer)
    ¾   Normalmente i browser incorporano una JVM con cui eseguono l'applet
¾   Servlets e JSP
    ¾   Sono programmi Java che risiedono sul server Web e vengono invocati
        dalle pagine HTML
    ¾   Vengono eseguiti lato server solitamente per la generazione di pagine
        Web dinamiche (accesso a Database, risposta a dati inviati o operazioni
        effettuate dall’utente)
¾   Applicazioni
    ¾   Sono normali programmi eseguiti su una JVM (lanciata esplicitamente
        da riga di comando)

Scrivere un programma in Java
¾   Una caratteristica che ha reso popolare il Java è quella di essere
    indipendente dal S.O. in cui un programma è compilato. Ma come è
    resa possibile questa cosa?

¾   Il compilatore Java produce un codice che non è il codice binario
    finale, ma un codice binario intermedio chiamato bytecode
    (indipendente dall’architettura)

¾   Questo codice intermedio è interpretato da una “macchina virtuale”
    che lo traduce in istruzioni macchina
    ¾   la Java Virtual Machine (JVM)

¾   La JVM ha bisogno di conoscere il SO su cui sta girando. La Sun
    mette a disposizione JVM per tutti i sistemi operativi:
    ¾   Windows, Linux, Unix, Mac ecc…

Scrivere un programma in Java
¾   In definitiva, scrivere un programma Java vuole dire creare un file di
    testo contenente del codice Java:
    ¾   un file per ogni classe (ossia astrazione dell’oggetto)

¾   Il file così creato ha estensione .java e deve essere passato al
    compilatore Java:
            javac xxx.java Î xxx.class

¾   Questo software crea un file .class con lo stesso nome
    dell’originario, che contiene il bytecode per la JVM
          java xxx Î esecuzione del main della classe xxx.class

Es
                          HelloWorld.java
         class HelloWorld {
                 public static void main(String[] args) {
                          System.out.println(“Hello World!”);
                 }
         }

                                                      bytecode
                                                      01010101
                                                      11010101
                               Java                   11101001 HelloWorld.class
                             Compiler                 10101011
                                                      11100101
                               javac

    javac e java sono forniti con la
¾
                                               java    JVM
    distribuzione Java (JDK)

javac.exe e java.exe
¾   Forniti con la distribuzione Java della SUN:
    ¾   JDK

¾   Dipendono dall’architettura su cui si va ad operare:
    ¾   È necessario utilizzare il JDK per Windows se si usa Windows,
        ugualmente per Linux, Mac ecc…

¾   Sono applicazioni lanciate dall’utente dalla shell dei comandi oppure
    dall’ambiente di sviluppo grafico utilizzato

¾   Devono essere nel path di ricerca del S.O. :
    Es. in windows:
       path %path%;C:\Programmi\Java\jdk1.5.0_02;C:\Programmi\Java\
       jdk1.5.0_02\bin;
       set JAVAHOME=C:\Programmi\Java\jdk1.5.0_02

javac.exe

java.exe

CLASSPATH
¾   Quando creiamo una classe Java (nell’esempio precedente ‘prova’),
    affinché sia utilizzabile è necessario che il nome del file sia lo stesso
    del nome della classe:
    ¾   La classe prova va quindi salvata in un file prova.java e compilata nel
        file prova.class
    ¾   Il compilatore javac si occupa di generare il file .class con il nome del
        file .java che gli viene fornito come parametro di ingresso

¾   Il file .class deve poi essere nel classpath della macchina virtuale,
    altrimenti non sarà trovato. E’ possibile specificare il classpath come
    opzione diretta alla JVM:
        java.exe –classpath [PATH1;PATH2;…;PATHn] file.class

¾   In alternativa si può definire una variabile di sistema CLASSPATH
    da cui il compilatore e la JVM leggono automaticamente il
    classpath

Classpath in javac

Classpath in JVM

Regole di base di JAVA

Regole di base – 1
¾   Java, come quasi tutti i linguaggi di programmazione di alto livello è
    case-sensitive, distingue cioè le lettere minuscole da quelle
    maiuscole:
    ¾   La variabile nome è quindi diversa da Nome

¾   È consigliato inserire delle linee di commento per rendere il codice
    più leggibile e comprensibile (commentare il codice):
    ¾   La sequenza // permette di commentare la parte di riga rimanente
    ¾   I delimitatori /* e */ permettono di commentare tutto ciò compreso tra
        queste due sequenze di caratteri
¾   Es:
        int a=3; // questa parte finale della riga è commentata
        /* commento su
        più
        righe */

Regole di base – 2
¾   Istruzione
    ¾   Ogni istruzione deve essere terminata da un ‘;’
¾   Blocchi di codice
    ¾   Ogni blocco di codice (sequenza di una o più istruzioni da eseguire in
        blocco) è racchiuso tra parentesi graffe: ‘{ }’
¾   Formattazione
    ¾   Una singola istruzione per riga
    ¾   L’apertura di un blocco viene indentata per rendere più chiara la struttura
        del blocco

                   class HelloWorld {
                        public static main(String[] args) {
                                  // visualizza un messaggio di saluto
                                  System.out.println(“Hello World !!”);
                        }
                   }

Facciamo un esempio

  ¾   Scrivere un applicazione di benvenuto:
      ¾    il cosiddetto HelloWorld

  ¾   Iniziamo col creare un file HelloWorld.java con il notepad (o
      qualsiasi altro editor di testo)
  ¾   Scriviamo il codice per la nostra applicazione:
          class HelloWorld {
                  public static void main(String[] args) {
                           System.out.println(“Hello World!”);
                  }
          }
  ¾   Utilizziamo lo script JavaEnvStart disponibile in rete su Sunto
      (\\sunto\Laboratorio Java\esempi):
      ¾    Questo script setta le variabili di ambiente JAVAHOME e PATH
           in modo cha sia possibile utilizzare javac.exe e java.exe

Facciamo un esempio
¾   Copiamo lo script nella directory dove abbiamo salvato il file
    HelloWorld.java ed avviamo la shell

¾   Digitiamo:
       javac HelloWorld.java
    E vediamo che viene creato il file HelloWorld.class

¾   Se proviamo ad aprire il file HelloWorld.class con un editor di testo
    (notepad), vediamo una sequenza di caratteri incomprensibile:
    ¾   bytecode della nostra prima applicazione Java

¾   Adesso chiamiamo la JVM per eseguire la nostra classe:
        java HelloWorld

Facciamo un esempio
¾   Otteniamo però un errore:
       Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld
    Cosa vuol dire? La JVM non trova la classe HelloWorld di cui deve lanciare
    la funzione main()

¾   Forse vuole il nome del file:
       java HelloWorld.class

¾   Otteniamo ancora un errore simile:
       Exception in thread "main" java.lang.NoClassDefFoundError:
       HelloWorld/class
    La JVM ancora non trova la classe HelloWorld/class (spiegheremo in
    seguito la differenza tra questi due errori)

¾   Dove è il problema?

Facciamo un esempio
¾   Il problema sta nel fatto che la JVM cerca la classe HelloWorld
    (ossia il file HelloWorld.class) nei percorsi specificati dalla variabile
    di sistema CLASSPATH:
    ¾   Questa variabile non contiene però il percorso dove realmente si trova
        HelloWorld.class

¾   E’ necessario quindi specificare alla JVM che cerchi il file (o meglio
    la classe) anche nella directory corrente:
        java –cp . HelloWorld

¾   Adesso funziona tutto !!

Facciamo un esempio
¾   Proviamo adesso a rinominare la funzione main(String[] args) con
    run(String[] args) e compiliamo di nuovo:
    ¾   Per adesso nessun problema, javac genera il file HelloWorld.class

¾   Proviamo a lanciare HelloWorld.class :
        java –cp . HelloWorld

¾   Ovviamente otteniamo un errore:
    ¾   Exception in thread "main" java.lang.NoSuchMethodError: main

¾   Perché OVVIAMENTE ? Che errore si verifica ?

Facciamo un esempio
¾   Leggendo attentamente il messaggio di errore si vede che la JVM ci
    sta dicendo che non trova il metodo main
    ¾   Il metodo main di un oggetto, come detto, contiene il corpo principale
        dell’applicazione rappresentata dall’oggetto stesso

¾   Quando si invia un oggetto alla JVM, quest’ultima prova a lanciare il
    metodo main, ad eseguire quindi l’oggetto come se fosse un
    applicazione:
    ¾   Se tale metodo non esiste, la JVM ritorna un errore del tipo visto prima

Esempio
¾   Esempio:
    01.HelloWorld\01.HelloWorld

IDE e JBuilder

Integrated Development Environment (IDE)

¾   Un IDE è una applicazione grafica che fornisce al programmatore un
    ambiente di sviluppo completo ma al tempo stesso semplice e
    chiaro

¾   Tramite una interfaccia grafica (GUI) è possibile costruire il progetto,
    tenere sotto controllo le varie parti, effettuare il debugging e molto
    altro ancora

¾   I più comuni ambienti di sviluppo Java sono:
    ¾   JBuilder – della Borland, a pagamento, ma è disponibile una versione
        free (chiamata Foundation)
    ¾   NetBeans – della SunMicrosystem, free scaricabile dal sito www.java.
    ¾   Eclipse – della Eclipse Foundation

Integrated Development Environment (IDE)

¾   L’uso dei programmi da linea di comando javac e java viene
    nascosto dalla IDE:
    ¾   Compilando il progetto, il software passa al compilatore tutti i files
        necessari e genera i file .class
    ¾   Anche l’esecuzione del programma è gestita dall’interfaccia e richiede
        solamente di specificare quale funzione main() mandare in esecuzione

¾   Anche la gestione del path e del classpath è automatizzata e resa
    “friendly” dall’interfaccia grafica:
    ¾   Il path corrente è automaticamente inserito nel classpath
    ¾   Aggiungendo librerie automaticamente viene aggiunto il percorso al
        classpath
    ¾   Ecc…

JBuilder
¾   L’ambiente che utilizzeremo in questo laboratorio è il JBuilder, ma
    tutto ciò che viene fatto è facilmente trasportabile su NetBeans o su
    Eclipse

¾   Oltre alla libreria standard del Java, ogni IDE può mettere a
    disposizione librerie proprietarie da utilizzare nel progetto:
    ¾   Non sempre consigliato dato che una caratteristica molto importante del
        Java è quella della trasferibilità del codice e molte volte l’uso di librerie
        proprietarie può limitare questa possibilità

¾   Il JBuilder mette a disposizione una gran quantità di tipologie di
    progetto:
    ¾   tramite un wizard è possibile scegliere il tipo di progetto, specificarne i
        parametri ed iniziare a programmare

Esempio

  ¾   Proviamo adesso a creare una applicazione HelloWorld
      utilizzando il JBuilder

  ¾   Prima di tutto avviamo il JBuilder

  ¾   Andiamo su File e selezioniamo new
      ¾   Possiamo creare direttamente una classe o un progetto. Nel primo
          caso, viene richiesto comunque di creare un progetto per la classe.
      ¾   Una volta scelto il nome del progetto e dove salvarlo passiamo alla
          creazione guidata della classe

  ¾   Ci viene chiesto il nome della classe (HelloWorld) ed il package:
      ¾   Per adesso ignoriamo il package (lasciamo bianco il campo del
          package)
      ¾   Notiamo l’opzione “generate main method” che permette di
          generare uno “scheletro” per la funzione main all’interno della classe

Esempio
¾   Inseriamo il codice Java nel file HelloWorld.java

          class HelloWorld {
                  public static void main(String[] args) {
                           System.out.println(“Hello World!”);
                  }
          }
¾   Adesso possiamo compilare ed eseguire l’applicazione:
    ¾   Tramite il menù run lanciamo l’applicazione
    ¾   Notiamo la possibilità di lanciare l’applicazione anche sotto debug

Esempio
¾   Nella finestra in basso vedremo visualizzato l’output
    dell’applicazione

¾   E’ possibile verificare che anche in questo caso, rinominando la
    funzione main() in qualsiasi altro modo (anche Main()) il JBuilder
    ritorna errore

Esempio
¾   Esempio:
    01.HelloWorld\02.HelloWorld-JBuilder

Debug

Debug in JBuilder
¾   Un IDE permette di effettuare un’operazione molto utile al
    programmatore:
    ¾   Il debugging

¾   Trovare i punti in cui il programma si comporta in maniera differente
    da quello che il creatore si aspettava è un lavoro molto difficile e
    costoso:
    ¾   Il debug a run-time permette di fissare dei break-point

¾   Break-point: punto del programma in cui si desidera fermare il
    flusso delle istruzioni per verificare ed ispezionare lo stato
    dell’applicazione

Breakpoint
¾   Viene selezionata la riga di codice in cui si desidera interrompere il
    programma

¾   Quando l’esecuzione del programma raggiunge tale riga di codice,
    l’IDE interrompe l’esecuzione e permette all’utente di interagire con
    il programma:
    ¾   per esempio la lettura di alcuni valori attuali dell’applicazione

¾   Una volta terminata la verifica è possibile “continuare” fino al
    break-point successivo o fino alla terminazione dell’applicazione

¾   Inoltre esiste la modalità passo-passo in cui l’ambiente si ferma ad
    ogni istruzione

Esempio
¾   Riprendiamo l’applicazione HelloWorld
    ¾   Inseriamo una istruzione per aumentare il numero di istruzioni:
    ¾   ES : una istruzione di assegnamento ad una variabile
          int a = 4;
    ¾   Mettiamo un break-point nella istruzione successiva a questa

¾   Lanciamo l’applicazione in modalità debug

Esempio
¾   Vediamo che l’esecuzione si
    interrompe alla linea di codice
     con il break-point

¾   A questo punto è possibile:
    ¾   ispezionare i contenuti dell’oggetto

Esempio
 ¾   mettere dei watch sulle variabili

Esempio
¾    Infine è possibile “continuare” l’applicazione (F9) fino ad un successivo
     break-point o alla fine, andare avanti passo-passo (F8), entrare
     all’interno della funzione corrente(F7), ecc…

Modo 1

    Modo 2

Esempio
¾   Esempio:
    01.HelloWorld\02.HelloWorld-JBuilder

Il JavaDoc

Il JavaDoc
¾   L’ambiente di sviluppo grafico permette di creare la documentazione
    in automatico:
    ¾   la Sun aveva previsto la possibilità di descrivere, mediante apposita
        sintassi, le varie funzioni disponibili in ogni oggetto

¾   Per creare una descrizione di una funzione è sufficiente inserire
    prima del metodo e fuori da ogni altra funzione la descrizione della
    funzione delimitata dalle sequenze /** e */

¾   Aggiungendo il tool JavaDoc al progetto, è possibile creare la
    documentazione della classi e delle funzioni del progetto:

JavaDoc
¾   Descrizione di una classe:
    ¾   Quando inseriamo la sequenza /** il JBuilder automaticamente inserisce
        i campi descrittivi della classe in cui l’autore può inserire la descrizione:
        ¾   titolo, descrizione, autore, versione, ecc…

¾   Descrizione di una funzione
    ¾   Quando inseriamo la sequenza /** il JBuilder crea automaticamente le
        righe per la descrizione dei parametri di ingresso e di ritorno della
        funzione:
        ¾   Es:
            @param args String[] Î indica che la funzione ha un parametro di
            ingresso args di tipo String[]
    ¾   L’autore della funzione può inserire la descrizione della funzione nella
        prima riga del blocco generato automaticamente da JBuilder

JavaDoc – Esempio
¾   Creare una classe HelloWorld de-selezionando tutti i check-box
    durante il wizard di JBuilder:
    ¾   Verrà creata una classe semplice prova senza alcuna funzione o
        variabile
         class HelloWorld {
          }

¾   Creiamo il JavaDoc per la classe:
         /**
          * Title: 
          * Description: 
          * Copyright: Copyright (c) 2005
          * Company: 
          * @author not attributable
          * @version 1.0
          */
         class HelloWorld {
          }

JavaDoc – Esempio
¾   Creare una funzione nella classe HelloWorld (creiamo la funzione
    main() che per ora è l’unica cha abbiamo visto come si scrive):

        class HelloWorld {
                 public static void main(String[] args) {
                 }
         }

¾   Creiamo il JavaDoc per questa funzione:

        class HelloWorld {
                  /**
                  *
                  * @param args String[]
                  */
                 public static void main(String[] args) {
                 }
         }

JavaDoc – Esempio

 ¾   Inseriamo il titolo e la descrizione della classe e la descrizione della
     funzione
      /**
       * Title: Hello World
       * Description: Classe di prova per il JavaDoc
       * Copyright: Copyright (c) 2005
       * Company: 
       * @author not attributable
       * @version 1.0
       */
      class HelloWorld {
                /**
                 * Funzione principale per il test
                 * @param args String[]
                 */
                public static void main(String[] args) {
                }

       }

JavaDoc – Esempio
¾   Compiliamo, solo il JavaDoc o tutto quanto ed apriamo il file
    index.html del JavaDoc:

JavaDoc – Esempio
¾   La funzione è visualizzata in due punti:
    ¾   nel sommario delle funzioni in cui viene mostrata una lista di tutte le
        funzioni con un breve descrizione (la prima riga del commento inserito)

    ¾   nella sezione dettagli, in cui viene visualizzata tutta la descrizione

Esempio
¾   Esempio:
    01.HelloWorld\02.HelloWorld-JBuilder