JAVA
Java appena è uscito è stato accolto con molto entusiasmo dalla comunità mondiale dei progettisti di software e dei provider di servizi Internet, questo perché Java permetteva agli utenti di Internet di utilizzare applicazioni sicure e indipendenti dalla piattaforma, che si possono trovare in qualsiasi punto della rete.
Java è quindi nato come linguaggio per la rete, per affiancare l' Hyper Text Markup Language (HTML), il quale non è un linguaggio di programmazione vero e proprio, e per dargli quella sicurezza che l'HTML non ha. Da quando è nato Java sulla rete si è iniziato a poter parlare di numeri di carte di credito e di informazioni sicure, notizia che ha molto affascinato le grosse società mondiali, le quali hanno trasformato la vecchia Internet, rete ad appannaggio delle sole università e centri di ricerca, nell'attuale mezzo di comunicazione aperto a tutti.
Il linguaggio di programmazione Java è stato creato verso la metà degli anni novanta, è il più recente tra i suoi cugini, e per questo è ancora in fase evolutiva, tanto che ogni anno circa ne viene rilasciata una nuova relase. Da linguaggio nato solo per la rete è divenuto un vero e proprio linguaggio di programmazione, paragonabile, dal punto di vista delle funzionalità, al più blasonato C++.
Java e la maggior parte degli altri linguaggi possono essere paragonati solo dal punto di vista delle funzionalità, perché sono fondamentalmente molto diversi, infatti Java compila i sorgenti dei suoi programmi in un codice detto Bytecode, diverso dal linguaggio della macchina su cui è compilato, mentre linguaggi come il C++ compilano i sorgenti dei programmi in un codice che è il codice della macchina ( per macchina intendo computer + sistema operativo ) su cui è eseguito. Quindi per eseguire un programma Java occorre avere uno strumento che è chiamato Java Virtual Machine, la quale interpreta il bytecode generato dal compilatore Java e lo esegue sulla macchina su cui è installato. Grazie alla Java Virtual Machine Java è indipendente dalla piattaforma, infatti il programma compilato Java è legato alla JVM e non al sistema operativo, sarà quindi possibile eseguire lo stesso programma Java, compilato una sola volta su una qualche macchina con un compilatore Java versione X, su una piattaforma Windows e su una piattaforma Linux, per fare questo però c'è bisogno che sia Windows che Linux abbiano installato una Java Virtual Machine che supporti la versione X di Java. Le due JVM installate sulle due piattaforme diverse sono lo stesso programma compilato una volta per Windows ed una volta per Linux, come avveniva con i programmi scritti in linguaggi come il C/C++.
Una Java Virtual Machine è implementata anche nei vari Browser (Come Netscape e Explorer) per poter eseguire i programmi Java incontrati nella rete, i cosidetti Applet.
Questo però, unito al fatto che Java ancora si evolve, causa degli ovvi problemi di incompatibilità, infatti capita sempre che il più moderno Browser supporti una versione precedente di Java rispetto all' ultima versione rilasciata dalla Sun Microsystem, inoltre bisogna tener presente che non tutti gli utenti di Internet navigano usando l'ultima versione di Netscape o di Explorer. Quindi volendo creare un' applet ed inserirlo in un nostro documento HTML, dobbiamo tenere presente questi problemi, e cercare di fare un programma che sia compatibile con la maggior parte delle JVM inplementate nei vari browser.
Un altro problema da affrontare è quello della scelta del compilatore Java da utilizzare, infatti esistono vari ambienti integrati per editare, compilare, debuggare ed eseguire programmi Java, come quelli della Broland, della Microsoft, della Symantec. Tutti questi ambienti offrono dei tool di sviluppo eccellenti, come editori grafici di finestre, debugger molto interessanti, però hanno due problemi, il primo è che si pagano, anche molto, il secondo è sempre lo stesso della compatibilità, infatti essi spesso si trovano indietro alla relase della sun, ed inoltre aggiungono delle classi che poi le JVM implementate nei browser non hanno.
Il mio consiglio è quallo di usare le JDK ( Java Development Kit ) della Sun, le quali comprendono sia il compilatore che la Java Virtual Machine per eseguire i programmi da noi compilati, inoltre sono freeware (non costano niente) e sono scaricabili dalla rete ed i browser si adeguano pian piano a questa versione di Java.
Se volete scrivere applet per i vecchi browser dovete scaricarvi la versione 1.1 di Java, però questa versione è niente alla versione attualmente più gettonata, ovvero alla 1.2.2 ( Chiamata per qualche motivo a me oscuro Java 2 , la si può scaricare all'indirizzo
http://java.sun.com/products/jdk/1.2/index.html ), alla quale farò riferimento anche io in questo corso e per la quale Netscape versione 4.0x ed Explorer 5 hanno implementato la Java Virtual Machine (quasi tutta, io ho avuto qualche problema con le Swing, che sono una libreria standard di Java 2).
Se avete intenzione di scaricarvi Java 2 vi consiglio di farlo la mattina verso tra le nove e le undici, perché il sito è affollato e lento, inoltre il file da scaricare è una ventina di mega, se volete potete scaricarvi anche la documentazione la quale è molto utile, però anch' essa è di circa venti mega.
Io ho appena scaricato e installato la prossima versione, ovvero la Relase Candidate del Java 2 Software Development Kit versione 1.3 Relase Candidate 1, e vi assicuro che se la 1.2.2 era eccezionale questa è incredibile, ho anche appena scoperto che è uscita la Relase Candidate 2 del JDK 1.3 e che a fine aprile uscirà finalmente la relase (Io la aspetto, non ho voglia di passare un'altra nottata in bianco per scaricarmi una cosa che verrà rimpiazzata dalla relase tra meno di un mese).
Per scaricarvi il prodotto dovrete iscrivervi, fatelo, l'iscrizione è gratuita.
Un ultimo problema che ha Java è la lentezza, infatti, come già detto, esso è interpretato, quindi le istruzioni Java prima di essere eseguite dalla macchina vengono interpretate dalla JVM, ovvero per eseguire ogni istruzione il computer eseguirà un numero di istruzioni macchina che è più del doppio delle istruzioni che eseguirebbe se la stessa istruzione fosse stata scritta in C, quindi avrete bisogno di computer veloci per eseguire bene programmi Java, e di questo vi sarete sicuramente accorti anche navigando sulla rete. Anche la memoria è importante, si compila e si esegue anche con soli 32Mb di RAM, ma per fare le cose velocemente ne occorrono almeno 64, pensate che l' ultimo ambiente integrato della Borland, il Jbuilder 3, ha come requisito minimo di RAM 96 Megabyte.
Per finire ritorno al Java Development Kit della Sun Microsystem, con questo è possibile produrre tutto il software che si vuole senza dover pagare diritti di uso del prodotto come avviene con il Borland Jbuilder, il Symantec Cafe, e il Microsoft Visual Java, vi consiglio di leggervi la licenza d'uso che troverete quando andrete a scaricare il JDK prima di cominciare a produrre software. A questo punto possiamo cominciare.
La principale differenza tra Java e gli altri linguaggi di programmazione ad oggetti è che mentre con questi ultimi è possibile anche programmare ad oggetti, con Java si deve assolutamente programmare ad oggetti. Quindi punto fondamentale è spiegare cosa significa "programmare ad oggetti".
Sostanzialmente il modo di programmare è simile ai linguaggi "normali" (ci sono variabili, cicli, etc.), solo che sia i dati, sia le funzioni che li manipolano sono racchiusi in strutture dette classi.
Le classi sono dei "prototipi di oggetti", ovvero sono delle strutture astratte (non troppo vedremo) che possono essere instanziate e quindi creare un oggetto (ma anche più di uno).
La classe definisce tutte le proprietà degli oggetti appartenenti a quella classe, detti attributi, e le funzioni che verranno usate per agire su di essi, detti metodi. Ad esempio è possibile definire una classe delle persone, come segue:
Inizio classe persone
Attributo annodinascita
Metodo calcolaetà(annoattuale)
Fine classe persone
La classe delle persone così definita ha un attributo che è annodinascita che sarà sicuramente un numero intero ed un metodo che in base all'anno attuale passatogli calcola l'età della persona. Usando il formalismo di Java, per definire la classe persone scriveremo:
class persone
{
public int annodinascita;
public int calcolaeta(int annoattuale)
{
return ( annoattuale - annodinascita );
}
}
Come si vede abbiamo dichiarato sia il metodo che l'attributo come public, vedremo tra poco cosa significa, vediamo anche che il corpo della classe è racchiuso tra parentesi graffe ({,}) così anche i metodi. Questo come altri elementi sono molto simili alla sintassi del linguaccio C, per questo motivo la sintassi di java è tra quelle chiamate "c-like". Per chi non ha familiarità con il C, le parentesi graffe servono a rappresentare blocchi di codice, come il costrutto begin end del Pascal.
La classe avrà un cosiddetto costruttore (o più di uno), che è un metodo particolare che di solito viene utilizzato per inizializzare gli attributi quando viene instanziata la classe in un oggetto, esso è una funzione che non ha nessun tipo di ritorno ed il nome uguale al nome della classe. Ho detto che i costruttori possono essere più di uno, che però il nome del costruttore deve essere lo stesso di quello della classe, chi è abituato a programmare con linguaggi non orientati agli oggetti troverà tutto questo strano, però è possibile perché Java fa il cosidetto overloading di funzioni, ovvero funzioni con lo stesso nome che hanno parametri diversi (detti in informatica parametri formali) sono diverse, e al momento dell'invocazione viene scelta la funzione in base al parametro (detto parametro attuale). Questo vale per ogni metodo, non solo per i costruttori.
class persone
{
// Proprietà
public int annodinascita;
public String Cognome=new String();
// Costruttori
public persone(int annonascita)
{
this("Non Conosco");
this.annodinascita=annonascita;
}
public persone(String Cognome)
{
this(0);
this.Cognome=Cognome;
}
public persone(int annonascita , String Cognome)
{
annodinascita=annonascita;
this.Cognome=Cognome;
}
// Metodo che calcola l'età del soggetto
public int calcolaeta ( int annoattuale )
{
return ( annoattuale - annodinascita );
}
}
Le linee che cominciano con il doppio slash (//) sono dei commenti e vengono ignorate dal compilatore. Ci sono altri due tipi di commenti, quelli racchiusi tra /* e */ che permettono di definire commenti su più linee e quelli racchiusi tra /** e */, che permettono sempre di definire commenti su più linee, sono detti commenti di documentazione, essi si devono trovare subito prima la dichiarazione di classi, di membri di classi (attributi o metodi) o costruttori, e vengono inclusi nella eventuale documentazione del codice generata automaticamente.
Nell'esempio vediamo che ci sono tre costruttori, diversi per i parametri formali, che hanno lo stesso nome, vediamo inoltre un nuovo attributo che è Cognome, esso è una stringa, definita come:
public String Cognome = new String();
la parte prima dell'uguale è chiara, lo è meno quella a destra, quel new String() crea un nuovo oggetto della classe String, e ne invoca il costruttore che non ha parametri, questo è il modo standard usato da Java per instanziare gli oggetti di una classe. Non deve sorprendere che il tipo di dato stringa sia una classe, in Java è possibile usare oggetti che rappresentano tutti i tipi di dato del linguaggio, inseriti per completezza del linguaggio, detti involucri che a volte sono molto utili, è però possibile anche usare i valori.
Quindi ad esempio ci troveremo a lavorare sia con interi che con oggetti che rappresentano interi.
Un ultima cosa che salta all'occhio dall'esempio è che i costruttori hanno volutamente dei parametri che hanno lo stesso nome degli attributi, anche questo è possibile in Java, il quale stabilisce che quando c'è un assegnamento alla sinistra dell'uguale ci deve essere l'attributo, e alla destra il parametro, comunque se non vogliamo confonderci possiamo usare il riferimento this, scrivendo ad esempio this.annodinascita intendiamo l'attributo. this è un riferimento all'oggetto, e nell'esempio lo troviamo anche come invocazione di funzione this(0), in questo caso esso è un riferimento ad un costruttore dell'oggetto, in questo caso chiama il costruttore persone (int annodinascita), con il valore 0. è quindi possibile in un costruttore chiamare un costruttore diverso della classe stessa, a patto che l'invocazione sia la prima istruzione del costruttore e che il costruttore sia diverso da quello attuale.
A questo punto siamo pronti a creare oggetti appartenenti alla classe da noi appena definita, abbiamo tre modi per farlo, perché abbiamo creato tre costruttori.
persone Pietro=new persone(1974);
persone Pietro=new persone("Castellucci");
persone Pietro=new persone(1974,"Castellucci");
Possiamo voler creare un altro oggetto della classe persone:
persone Lina=new persone(1975);
Aquesto punto ho creato due oggetti della classe persone, essi sono in una relazione con la classe detta di inst_of (ovvero "istanza di"), gli oggetti si chiamano Pietro e Lina, è possibile anche copiare i riferimenti degli oggetti, ad esempio è possibile scrivere:
persone Pietro2=Pietro;
Costruiti gli oggetti ne possiamo invocare i metodi, questo si fa indicando Oggetto.Metodo, ad esempio è possibile invocare i metodi:
Pietro.calcolaeta(2000); Pietro2.calcolaeta(2000); Lina.calcolaeta(2000);
Introduciamo adesso degli attributi e dei metodi particolari, i cosidetti membri statici. Per come abbiamo definito i membri della classe non ci è possibile referenziare direttamente dalla classe attributi e metodi (persone.annodinascita è un errore), questo perché essi lavorano su una istanza della classe, ovvero su un oggetto, però a volte può essere utile scrivere metodi e attributi che possano essere invocati senza dover istanziare l'oggetto, ma direttamente dalla classe, per fare questo occorre dichiararli static, ad esempio:
class TitoliAziendaVattelapesca
{
public static int TassodiInteresse=3;
public String Proprietario=new String();
public static float InteressiMaturati (int Periodo)
{
return((Periodo * TassodiInteresse )/100)
}
TitoliAziendaVattelapesca(String nome)
{
Proprietario=nome;
}
}
Quindi potremo decidere ad esempio di instanziare un oggetto della classe TitoliAziendaVattelapesca solo se ci conviene, ad esempio facendo:
if (TitoliAziendaVattelapesca.InteressiMaturati(12)>1000)
CompraAzioni(10000);
Dove CompraAzioni(int X) è una funzione che instanzia un numero X di TitoliAziendaVattelapesca.
Introduciamo adesso la relazione is_a tra classi, data una classe è possibile creare una nuova classe da questa facendo come si dice in gergo una specializzazione della prima classe. La nuova classe creata è in relazione is_a con la prima. Creata una classe studente dalla classe (detta superclasse) persone, la nuova classe eredita dalla prima tutti i metodi e gli attributi, con la possibilità di definirne dei nuovo o di ridefinirne alcuni, in Java l'estensione di una classe si esplicita con la parola chiave extends.
class studente extends persone
{
int matricola;
// Costruttori
public studente(int annonascita)
{
super(annonascita,"Non Conosco");
}
public studente (String Cognome)
{
super(0,Cognome);
}
public studente(int annonascita , String Cognome)
{
super(annonascita,Cognome);
}
}
Come si vede dall'esempio la classe studente eredita tutti i metodi e gli attrubuti della classe persone, definisce un nuovo attributo matricola e nei suoi costruttori chiama i costruttori della classe persone, con super().
super() può essere, come this, una invocazione di un altro costruttore (tra parentesi vanno i parametri eventuali) o un riferimento alla classe (alla superclasse in questo caso), quindi super.annodinascita rappresenta l'attributo annodinascita della superclasse persone. Le relazioni is_a e inst_of sono le due relazioni più importanti dei modelli ad oggetti.
Concludiamo con un esempio ed alcune considerazioni per spiegare il significato della parola chiave public che abbiamo introdotto sopra, e di private e protected (attributi e metodi possono essere dichiarati come public, private e protected).
class A
{
public int a;
protected int b;
private int c;
// Suoi medodi, attributi e costruttori
}
class B extends A
{
public float a;
protected float b;
private float c;
// Suoi medodi, attributi e costruttori
}
class C
{
// Suoi medodi, attributi e costruttori
}
Abbiamo definito tre classi, A,B e C, B è definita da A ridefinendone i tre attributi, da interi a reali.
In A, nei suoi costruttori e nei suoi metodi ho libero accesso ai propri attributi di tipo intero, senza limitazioni, ovvero posso scriverli e leggerli a piacimento. In B e C accade lo stesso per i propri attributi, ma vediamo cosa succede per quelli delle altre classi.
Ad esempio in B (in un suo metodo) se scrivo espressioni con a,b e c, scriverò delle espressioni per dei float (in Java è importantissimo il tipo delle espressioni), per referenziare invece gli attributi omonimi di A da cui è ereditata, dobbiamo scrivere come sappiamo, super.a, super.b e super.c (e sono degli interi).
Il nostro compilatore Java non darà problemi per le prime due ma ci darà errore per la terza, questo perché il c di A è private, questo vuol dire che è possibile leggere e scrivere quell'attributo solo all'interno della classe a cui appartiene, ma non è possibile leggerlo e scriverlo da classi estranee o da sottoclassi.
A questo punto mettiamoci in un metodo di C, instanziamo qui dentro un oggetto della classe B (lo chiamo b) e scriviamo le espressioni b.a, b.b e b.c , il nostro compilatore a questo punto ci darà buona solo la prima, questo perché la terza è private ed è quindi visibile solo nella classe di appartenenza e la seconda è protected, questo significa che è visibile solo alla classe di appartenenza e alle sue sottoclassi, e C non è sottoclasse di B.
Sopra ho un po' barato, ovvero ho parlato di atributi di classi e di oggetti come se fossero la stessa cosa, ma in effetti lo sono, solo con la piccola differenza che se accedo all'attributo di una classe
Listato X. DESCRIZIONE
nomeClasse.nomeAttributo
questo sarà sicuramente static, e vi accederò solo in lettura, è in pratica una costante.
Quando instanzierò la classe in un oggetto
nomeClasse nomeOggetto = new nomeClasse(parametri);
accedendo allo stesso attributo dell'oggetto
nomeOggetto,nomeAttributo
accederò allo stesso valore di prima, e non potrò modificarlo (è static). Se cercherò invece di accedere ad un attributo non dichiarato static di una classe avrò ovviamente errore, infatti questo attributo verrà creato al momento della creazione dell'oggetto della classe, ed il più delle volte verrà inizializzato dal costruttore dell'oggetto.
Spero di essere stato abbastanza chiaro nella trattazione dell'argomento, però devo dirvi che i modelli ad oggetti sono piuttosto complicati, ed è impossibile spiegarli in dettaglio in un solo paragrafo, occorrerebbe un corso dedicato interamente a loro. Ovviamente quello che vi ho detto non è tutto sui modelli ad oggetti, ho solo introdotto alcuni concetti che ci basteranno per fare i nostri programmi in Java, se dovessi accorgermi durante il corso di avere tralasciato qualche punto importante per i nostri scopi aprirò volentieri una piccola parentesi.
Per il lettore che volesse approfondire l'argomento non mi sento di consigliare un testo, perché ve ne sono vari sull'argomento e tutti egregi, se invece vi accontentate di una introduzione all'argomento potreste vedere i capitoli iniziali di ogni buon manuale di programmazione per principianti di Linguaggi ad oggetti (C++ o Java), come ad esempio Java: Didattica e Programmazione di K.Arnold e J.Gosling (Ed. Addison-Wesley) Capitoli 2,3 e 4.
by antimo
