Corso Java

Caratteristiche di Java Autore : Giuseppe Dell’Abate

1987 Progetto per software di dispositivi elettronici 1988 James Gosling abbandonò il C++ e creò Oak 1992 FirstPerson, Inc., succursale della Sun, commercializza OAK: nasce Java 1994 creazione di browser Web Runner poi HotJava 1995 Netscape integra Java, in seguito anche Microsoft

Orientato agli oggetti Semplice Indipendente dalla piattaforma Portabile Sicuro Multithreading Dinamico

Caratteristiche paradigma ad oggetti: Ereditarietà Incapsulamento Poliformismo Creazione di TIPI personalizzati Basato sulle classi NON sugli oggetti Ma cos’è una classe? ed un oggetto?

Rispetto al C++ Non è object based ma object oriented (è ad oggetti puro) Non ha l’aritmetica dei puntatori (ma passaggi per valore) Non deve deallocare la memoria (c’è la garbage collector) Non ha ereditarietà multipla (ma singola)

Indipendentemente dalla architettura hardware e dal sistema operativo, la Java Virtual Machine interpreta il bytecode e lo esegue

Tipi primitivi mantengono le loro dimensioni in tutte le piattaforma grazie alla JVM

Le classi sono collegate solo quando richiesto Possono provenire dal file system locale così come dalla rete Il codice viene verificato prima di essere passato all’interprete per l’esecuzione. E’ possibile aggiungere nuovi metodi e variabili di istanza ad una classe, senza dover ricompilare l’intera applicazione

elaborazioni simultanee in un ambiente a singolo processo la gestione dei thread in genere e di tipo preemptive Nei sistemi in cui la gestione è non preemptive Java fornisce il metodo yield() che dà, ad un altro thread, la possibilità di essere comunque eseguito i metodi dichiarati synchronized non possono essere eseguiti simultaneamente da più thread;

Operazioni eseguite dal compilatore: controlli di errori di codifica le dichiarazioni di tipo esplicite e non implicite le classi sono inserite in un namespace per gestire la sicurezza Operazioni eseguite dal sistema run-time: L’allocazione della memoria dipende dalla piattaforma Il puntatore alla memoria non esiste ma esistono riferimenti simbolici, risolti in indirizzi di memoria reali in fase di esecuzione I tipi sono noti e corretti Operazioni eseguite dal compilatore e dal sistema run-time : strati di difesa contro il codice che può essere potenzialmente pericoloso

Package, interfacce e classi astratte Giuseppe Dell’Abate

Le classi e le interfacce Java sono organizzate in package Rappresentano dei pacchetti in cui vengono inglobate le classi che presentano: caratteristiche in comune (java.io) appartengono allo stesso progetto (it.fastweb.crm.om.) vengono prodotte dalla stessa societa (it.fastweb)

I packages sono identificati dall'istruzione package. Essa deve apparire come la prima istruzione nel file del codice sorgente. Esempio: package mioPackage; public class MiaClasse { ........... }

Ci sono tre modi per utilizzare un membro (pubblico) definito in un package: attraverso il suo nome completo importandolo importando l’intero package a cui il membro appartiene

Esempio: public class Classe { mioPackage. MiaClasse fg; } Indichiamo: il nome del package l’operatore . che ci permette di entrare internamente nel package il nome della classe

Esempio: import mioPackage.MiaClasse; public class Classe { MiaClasse fg; } Indichiamo: import seguito del nome del package seguito dalla classe dichiariamo l’oggetto fg nel modo classico

Esempio: import mioPackage.*; public class Classe { MiaClasse fg; } Indichiamo: import di tutte le classi del package attraverso il simbolo * dichiariamo l’oggetto fg

Una classe appartenente ad un package deve essere salvata all’interno dell’albero che viene definito dal path del package: Esempio: package mioPackage.mioEsempio class MiaCLasse {...} la classe MiaClasse.java deve essere salvata nelle cartelle mioPackage\mioEsempio c:\mioPackage\mioEsempio>dir MiaClasse.java In sede di compilazione si dovrà accedere dall’interno della cartella dove risiedono i file *.java c:\mioPackage\mioEsempio> javac MiaClasse.java c:\mioPackage\mioEsempio>dir MiaClasse.java MiaClasse.class

In sede di esecuzione di una classe contenuta in un package occorre lanciare la classe (che contiene il main) dall’esterno della prima cartella che delimita il package Esempio: C:\mioPackage\mioEsempio>dir MiaClasse.java MiaClasse.class c:\>java mioPackage.mioEsempio.MiaClasse

Una classe astratta può definire metodi astratti, ossia metodi di cui non viene fornita l’implementazione e prevedere, in senso generico, quali comportamenti (metodi) dovranno caratterizzare le sue classi discendenti Le definizioni esatte dei comportamenti verranno però effettuate dalle classi eredi (istanziabili), cosicché possano riflettere le loro specifiche esigenze Una classe astratta può pero contenere anche metodi non astratti

abstract class MiaSuperClasseAstratta { void mioMetodoImplementato(...) {…implementazione}; abstract void mioMetodo(...); } class MiaClasseErede extends MiaSuperClasseAstratta { void mioMetodo(...) { // implementazione } } Occorre sempre implementare i metodi astratti nella classe erede altrimenti si genera un errore in compile-time

Un’interfaccia è un insieme di definizioni di metodi (senza implementazione) e (eventualmente) di dichiarazioni di costanti In Java, le interfacce rappresentano un mezzo per permettere anche a oggetti tra loro scorrelati di interagire l’uno con l’altro Esempio: public interface MiaInterfaccia { int UNA_COSTANTE_INTERA = 100; String UNA_COSTANTE_STRINGA = "ciao"; void metodo1(int a); char metodo2(String s, long l); } Nelle interfacce possiamo definire solo costanti di classe e metodi di istanza astratti da implementare. Entrambi saranno public.

Attraverso le interfacce è possibile mediare il limite della ereditarietà singola di Java implementando più interfacce Tecniche utilizzabili forwarding eredita a diamante

Le interfacce possono ereditare da altre interfacce, anche da più di una contemporaneamente (quindi tra interfacce è ammessa l’eredità multipla) Esempio: interface I extends I1, I2, ..., In { ......... } dove I1, I2, ..., In sono interfacce I eredita tutte le costanti e tutti i metodi di I1, I2, ..., In Una classe che implementi un’interfaccia I deve implementare anche i metodi delle interfacce da cui I eredita

Le interfacce Ci forniscono una forma di eredità multipla Ci permettono di dichiarare metodi di istanza e proprietà static final Possiamo dichiarare solo metodi astratti Non possiamo fissare livelli di accesso diversi da public Non possiamo istanziare una interfaccia

Programmare in Java Giuseppe Dell’Abate

Applicazione Applet Interfaccia utente GUI Java - sessione DOS Browser

Classe Java è composta da: metodi speciali(costruttore, main) metodi (funzioni, procedure) proprietà (variabile, costante)

Metodo della classe che viene eseguita per avviare l’applicazione. Esiste un solo metodo main Il metodo main viene usato solo per le applicazioni e non per le Applet o le servlet. public static void main(String [] args) { //blocco di istruzioni } public : è necessario che sia accessibile per poter avviare la classe static : è un metodo di classe void : non restituisce nessun valore main : nome del metodo principale, String [] args : Array di stringhe usato come parametro (obbligatorio) blocco di istruzion i: sono le istruzioni che implementiamo

Metodo che viene eseguita quando si istanzia una classe. public class MiaClasse public MiaClasse() { //blocco di istruzioni } } public : è necessario che sia accessibile per instanziare la classe MiaClasse : ha lo stesso nome della classe blocco di istruzioni : sono le istruzioni che implementiamo possono esistere più metodi costruttori con diversi tipi e quantità di parametri (overloading)

I metodi sono dei blocchi di istruzioni definiti in una classe Sono di due tipologie funzione (elaborano i dati e restituiscono un valore) procedure (eseguono la procedura e non restituiscono un valore)

Elaborano eventuali parametri e restituiscono un risultato int moltiplicavalori(int a, int b) { risultato= a * b; return(risultato); } int è il tipo di valore che la funzione restituirà(quindi il tipo della variabile risultato); moltiplicavalori è il nome della funzione; all'interno delle parentesi tonde troviamo i due parametri che forniamo alla funzione con i loro relativi tipi all'interno delle parentesi graffe troviamo il blocco di istruzioni della funzione l'istruzione return (...) è quella che permette alla funzione di restituire il valore risultato. Le istruzioni che seguono l'istruzione return vengono ignorate

Elaborano eventuali parametri e non restituiscono un valore. Servono per evitare di ripetere un blocco di codice void nomeMetodo(int a, int b) { System.out.println(a+” - “+b ); } void (vuoto) indica che la funzione non restituira nessun valore ma eseguira solamente le istruzioni indicate nomeMetodo è il nome della funzione; all'interno delle parentesi tonde troviamo i due parametri che forniamo alla funzione con i loro relativi tipi all'interno delle parentesi graffe troviamo il blocco di istruzioni della funzione l'istruzione System.out.println(...) è quella che permette alla funzione di visualizzare i parametri passati

Le proprietà sono collegate ai tipi , che posso essere : primitivi : si prestano ad un uso intuitivo reference : fanno riferimento ad oggetti, array, ecc A seconda della modificabilità , possono essere. Costanti (variabili final): dati che non possono subire alcuna modifica Variabili : dati suscettibili di modificazione A seconda della globalità possono essere: static : le modifiche apportate da un oggetto a questi dati si propagano a tutte le istanze di quell’oggetto di istanza : le modifiche apportate non si ripercuotono alle altra istanze

Per garantire la portabilità del Bytecodes da una piattaforma ad un’altra Java fissa le dimensioni di ogni dato primitivo

Java assegna ad ogni variabile un valore di default al momento della dichiarazione

Il tipo byte permette di operare su numeri compresi tra -128 e 127, che sono i numeri che è possibile rappresentare con cifre da 8 bit con segno Il tipo short permette di trattare numeri a 16 bit, compresi tra -32768 e 32767: è in assoluto il formato meno usato in Java Il tipo int è senza dubbio il tipo primitivo più usato, per ragioni di praticità e di efficienza. Può contenere qualunque numero intero compreso tra 2.147.483.647 e -2.147.483.648, ossia tutti i numeri rappresentabili con una cella di memoria a 32 bit con segno Il tipo long a 64 bit, che permette di trattare numeri compresi tra -9.223.327.036.854.775.808 ed 9.223.327.036.854.775.807. è necessario post porre al numero la lettera 'L'

Il tipo float , a 32 bit, può contenere numeri positivi e negativi compresi tra 1.40129846432481707*10^-45 e 3.4282346638528860*10^38 Il tipo double a 64 bit può lavorare su numeri positivi e negativi tra 4.94065655841246544*10^-324 e 1.79769313486231570*10^138 Nota: due numeri separati da un carattere 'e' (maiuscolo o minuscolo): il primo di questi numeri, detto mantissa, può contenere il punto decimale, mentre il secondo, l'esponente, deve per forza essere un intero. Il valore del numero viene calcolato moltiplicando la mantissa per 10 elevato alla potenza del valore dell'esponente float number = 1.56e3F; double bigNumber = 5.23423e102;

Una variabile booleana può assumere solamente due valori: 'true' e 'false’ boolean a = true; boolean b = false; Il ricorso agli operatori relazionali '==', '!=', '>', '<', '>=' e '<=', permette di assegnare ad una variabile booleana il valore di verità di un'espressione. Ad esempio: boolean b = (a == 10); assegna a b il valore di verità dell'espressione a == 10, che sarà 'true' se la variabile 'a' contiene il valore 10, 'false' in caso contrario

Il tipo char può contenere un carattere in formato Unicode che comprende decine di migliaia di caratteri, vale a dire gli alfabeti più diffusi nel mondo. I valori da 0 a 127 corrispondono, per motivi di retro compatibilità, al set di caratteri ASCII Il tipo char è un intero a 16 bit privo di segno: pertanto esso può assumere qualunque valore tra 0 e 65535 char carattere1 = 'a';

Il carattere speciale '\' ha il ruolo di specificare alcuni caratteri che altrimenti non è possibile specificare con la tastiera '\n' nuova linea '\r' a capo '\f' nuova pagina '\'' carattere apice '\"' carattere doppio apice '\\' carattere backslash '\b' backspace '\t' carattere di tabulazione

Promozione: se la variabile destinazione è più capace di quella di partenza byte b = 100; short s = b; // promozione da byte a short int i = s; // promozione da short a int long l = i; // promozione da int a long Casting: se la variabile destinazione è meno capace di quella di partenza long l = 100; int i = (int)l; // cast da long a int short s = (short)i; // cast da int a short byte b = (byte)s; // cast da short a byte

Il primo volo dell'Ariane 5 (Ariane 5 volo 501) svoltosi il 4 giugno 1996 fallì e il razzo si auto distrusse dopo 40 secondi dal lancio per via di un malfunzionamento del software di controllo, creato da uno dei più famosi bug della storia. Un dato a 64 bit in virgola mobile venne convertito in un intero a 16 bit con segno, questa operazione causò una trap del processore (operazione errata): il numero in virgola mobile era troppo grande per poter essere rappresentato con un intero a 16 bit. Motivi di efficienza avevano spinto i progettisti a disabilitare il controllo software (scritto in Ada) sulle trap, anche se altre conversioni simili nel codice erano corrette.

Java mette a disposizione del programmatore una serie di operatori utili

L’operatore di assegnamento “=” consente al programmatore, una volta definita una variabile, di assegnarle un valore. Assegna il valore 5 alla destra dell’operatore alla variabile res1. int res1 = 5; Esegue l’espressione alla destra dell’operatore e ne assegna il risultato (15) a res1. int res1 = 5+10;

Java mette a disposizione del programmatore una serie di operatori di assegnamento di tipo “shortcut”

Se si desidera effettuare un incremento di valore superiore ad 1, si può ricorrere all'operatore '+='; l'espressione x = x+10; può essere riscritta in questo modo x += 10; Gli operatori '++' e '--' possono precedere o seguire una variabile. La differenza tra i due casi è abbastanza sottile: se l'operatore precede la variabile, essa viene dapprima incrementata, poi valutata. Nel seguente esempio x = 10; y = ++x*2; la variabile x viene incrementata prima che venga calcolato il valore di y, che pertanto assume il valore 22. Al contrario x = 10; y = x++*2; la variabile x viene prima valutata, poi viene incrementata a 11. Pertanto y assumerà il valore 20, ossia 10 per 2.

Java supporta tutti i più comuni operatori aritmetici (somma, sottrazione, moltiplicazione, divisione e modulo). Gli operatori binari (ovvero operatori che necessitano di due operandi) sono cinque e sono schematizzati nella tabella seguente:

Gli operatori relazionali servono ad effettuare un confronto tra valori producendo come risultato di ritorno un valore booleano (true o false) come prodotto del confronto. Nella tabella sono riassunti gli operatori ed il loro significato.

Gli operatori di shift bit a bit consentono di manipolare tipi primitivi spostandone i bit verso sinistra o verso destra secondo le regole definite nella tabella seguente byte i = 100; i >> 1; dal momento che la rappresentazione binaria del numero decimale 100 è 01100100, lo shift verso destra di una posizione dei bit, produrrà come risultato il numero binario 00110010 che corrisponde al valore 50 decimale.

Java consente di eseguire operazioni logiche su tipi primitivi operando sulla loro rappresentazione binaria.

Un oggetto non è allocato dal linguaggio al momento della dichiarazione come invece avviene per i tipi primitivi Questa dichiarazione crea una variabile intera chiamata counter ed alloca subito quattro byte per lo “storage” del dato. int counter; Crea una variabile che referenzia l’oggetto, ma non crea l’oggetto Stack. Stack s; Una variabile di referenza, è quindi una variabile speciale che tiene traccia di istanze di tipi non primitivi Una dichiarazione così fatta crea una variabile che tiene traccia di un array di interi di dimensione arbitraria. int numbers[]; Le variabili reference sono molto simili concettualmente ai puntatori di C e C++

L’operatore new alloca la memoria necessaria per il nostro oggetto Questa locazione può essere memorizzata nella variabile reference ed utilizzata per accedere all’oggetto quando necessario. s = new Stack(); Gli array sono allocati allo stesso modo: int my_array[] = new int[20];

Java non consente di definire costanti. Per far fronte alla mancanza è possibile utilizzare il modificatore final. Una variabile dichiarata final si comporta come una costante final int a = 3; Le variabili di questo tipo vengono inizializzate solo una volta al momento della dichiarazione. Qualsiasi altro tentativo di assegnamento si risolverà in un errore di compilazione.

Molto spesso nei programmi si ha l'esigenza di manipolare un gruppo di variabili dello stesso tipo che contengono valori tra loro correlati. Un array è uno strumento concettualmente simile ad una tabella, che accomuna sotto un unico nome un insieme di variabili dello stesso tipo: Esempio: int[] temp = new int[144];

Come per le variabili semplici dobbiamo indicare un tipo ed un nome, con la differenza che, dopo aver specificato il tipo, è necessario post porre una coppia di parentesi quadre. int[] vettoreDiInteri; La variabile 'vettoreDiInteri' appena dichiarata non è un vettore, ma solamente un reference ad un vettore

Per creare un vettore dobbiamo ricorrere alla parola riservata 'new', vettoreDiInteri = new int[10]; Il valore specificato tra parentesi quadre è la dimensione del vettore Un vettore è un oggetto in memoria composto da un certo numero di elementi, Ognuno dei quali può contenere un valore

La dereferenziazione è un'operazione in cui creiamo una variabile reference che punta ad un array già esistente int[] vettoreDiInteri2; vettoreDiInteri2 = vettoreDiInteri; Le modifiche apportate all’oggetto si riflettono anche sull’altro Per creare veramente un nuovo array occorre copiare il contenuto in un nuovo array

L'operazione che permette di assegnare un valore ad un elemento del vettore. Occorre specificare il nome del vettore seguito dal numero dell'elemento tra parentesi quadre: vettoreDiInteri[1] = 10; Gli elementi di un array si contano a partire da zero. vettoreDiInteri[9] = 27;

Un vettore può essere inizializzato con una serie di valori, in modo simile a come si può fare con le variabili. L'istruzione: int[] vettore = {10,12,14,16,18}; equivale alla sequenza: int[] vettore = new int[5]; vettore[0] = 10; vettore[1] = 12; vettore[2] = 14; vettore[3] = 16; vettore[4] = 18;

Il linguaggio Java consente di creare array bi-dimensionali Gli array bidimensionali sono concettualmente simili ad una tabella rettangolare, dotata di righe e colonne. Esempio: int i[][] = new int[10][15]; E’ possibile definire vettori con un numero qualunque di dimensioni: int v1[][][] = new int[10][15][5]; int v2[][][][] = new int[10][15][12][5]; Tali strutture, in ogni caso, risultano decisamente poco utilizzate. I vettori n-dimensionali vengono implementati in Java come array di array.

E’ possibile la realizzazione di tabelle non rettangolari int tabella[][] = new int[5][]; tabella[0] = new int[3]; tabella[1] = new int[2]; tabella[2] = new int[5]; tabella[3] = new int[2]; tabella[4] = new int[6];

Un Array multidimensionale può essere inizializzato con una serie di valori, in modo simile a come si può fare con gli Array semplici. int[] vettore = { { 10,12,14},{16,18},{20,22,24,26}};

Costrutti decisionali ed iterativi Giuseppe Dell’Abate

Un costrutto decisionale permette al programmatore di vincolare l'esecuzione di un'istruzione (o di un blocco di istruzioni) ad una condizione booleana condizione booleana è un'espressione della quale si può dire se sia vera o falsa blocco di istruzioni è un insieme di istruzioni racchiuso tra parentesi graffe, che vengono trattate dal compilatore Java come se fossero un'istruzione unica

if-else : verificano diverse espressioni e quando viene incontrata l'espressione che restituisce true viene eseguito un determinato pezzo di codice. switch-case : viene esaminata UNA SOLA espressione, però a seconda del suo risultato cambia il pezzo di codice che verrà eseguito.

Il costrutto condizionale più usato in Java è l'if che può essere usato nelle due varianti con o senza else if ( condizioneBooleana ) istruzione; La variante con l'else ha una forma del tipo if ( condizioneBooleana ) istruzione1; else istruzione2;

Se vogliamo che venga eseguita più di una istruzione dobbiamo ricorrere ad un blocco: if ( condizioneBooleana ) { istruzione1a; istruzione2a; istruzione3a; } else { istruzione1b; istruzione2b; istruzione3b; }

Il costrutto if può comparire anche all'interno di un altro costrutto if, creando strutture nidificate anche molto complesse: if( x >= 0 ) if( x <= 10 ) System.out.println("x compreso 0 e 10"); Se a questo punto inserisco un else dopo queste istruzioni. if( x >= 0 ) if( x <= 10 ) System.out.println("x è compreso tra 0 e 10"); else System.out.println("x è maggiore di 10"); A quale dei due if l’istruzione else farà riferimento?

Se ora aggiungiamo un else a quale if si riferisce? if( x >= 0 ) if( x <= 10 ) System.out.println("x compreso 0 e 10"); else System.out.println("x maggiore di 10"); else System.out.println("x minore di 0"); Se volessimo forzare un solo else a far riferimento ad un if esterno?

Else esterno: if( x >= 0 ) { if( x <= 10 ) System.out.println("x compreso 0 e 10"); } else System.out.println("x è minore di 0"); abbiamo cosi creato un blocco di istruzioni

E' buona norma di programmazione evitare di ricorrere pesantemente alla nidificazione di istruzioni if, data la confusione che spesso ne segue: if( x >= 0 ) if( x <= 10 ) System.out.println("x compreso 0 e 10"); può tranquillamente essere sostituito dal seguente, in tutto equivalente: if( x >= 0 && x <= 10 ) System.out.println("x compreso 0 e 10");

Una combinazione condizionale si ha quando si fa seguire ad un else una if. if( x <= 0 ) System.out.println("x <= 0"); else if( x <= 10) System.out.println("x > 0 e <= 10"); else if ( x <= 20) System.out.println("x > 10 <= 20"); else System.out.println("x è maggiore di 20"); Si noti che in questo caso l'ultimo else comprende tutti i casi non considerati dalle precedenti istruzioni.

L'operatore ? può essere usato all'interno di espressioni matematiche, dove una delle sotto espressioni sia vincolata ad una particolare condizione booleana. espressioneBooleana ? espressione1 : espressione2; Esempio: y = x < 0 ? 1 : 2; if (x < 0) y = 1; else y=2;

Il costrutto switch permette di gestire tutte quelle situazioni in cui dobbiamo prendere scelte diverse a seconda del valore di un'espressione switch (espressione) { case val1: istruzione_na; break; case val2: istruzione_nb;break; default: istruzione_ndefault;break; }

L'espressione contenuta tra le parentesi dello switch deve essere di tipo intero (int, byte, short o char); ogni istruzione case lavora su di un particolare valore, e fornisce una sequenza di istruzioni da eseguire in quella circostanza Tale sequenza termina usualmente con l'istruzione break , che forza il computer a uscire dallo switch, senza verificare i valori successivi. blocco di default , ovvero una sequenza di istruzioni da eseguire se non si è verificato nessuno dei casi precedenti.

I cicli vengono abitualmente utilizzati in tutti quei casi in cui bisogna eseguire delle attività ripetitive in modo automatica. Due tipi di cicli: i cicli con contatore o cicli for I cicli contatore servono per svolgere una data attività per un numero determinato di volte i cicli condizionali o cicli while, do-while i cicli condizionali vengono usati per eseguire un'attività fino a quando una data condizione viene soddisfatta

La struttura generale del while è while(condizioneBooleana) { ISTRUZIONE1; ISTRUZIONE2; .... }

Se si desidera che un ciclo venga ripetuto all'infinito, è sufficiente specificare una condizione sempre vera, tipo while(0 == 0) { ISTRUZIONE1; } oppure while(true) { ISTRUZIONE1; }

Si desidera che il ciclo venga ripetuto un numero prefissato di volte i = 0; while(i<=100) { ISTRUZIONI DA RIPETERE i = i + 1; }

L’istruzione do-while, a differenza della precedente, controlla il valore della espressione booleana alla fine del blocco di istruzioni. In questo caso il blocco di istruzioni verrà eseguito almeno una volta. La sintassi di do-while è la seguente do { istruzione; } while (espressione_booleana) { istruzione; };

il ciclo di 10 iterazioni utilizzando il ciclo while i=0; while(i<10) { faiQualcosa(); i++; } comporta maggior elaborazione da parte del programmatore pertanto è possibile usare l’istruzione for for(init_statement ; conditional_expr ; iteration_stmt) { istruzione }

init_statement rappresenta l’inizializzazione della variabile per il controllo del ciclo conditional_expr l’espressione condizionale iteration_stmt l’aggiornamento della variabile di controllo Il problema presentato precedentemente può essere risolto utilizzando il ciclo for in questo modo: for (int i=0 ; i<10 ; i++) faiQualcosa();

Il linguaggio Java consente l’uso di tre parole chiave che consentono di modificare in qualunque punto del codice il normale flusso della esecuzione della applicazione con effetto sul blocco di codice in esecuzione o sul metodo corrente.

Questa istruzione consente di forzare l’uscita da un ciclo aggirando il controllo sulla espressione booleana e provocandone l’uscita immediata. for (int i=0; ; i++) { if(i==10) break; faiQualcosa(); }

Questa istruzione produce un salto alla parentesi graffa che chiude il blocco public void metodo() { int i=0; boolean x = false; while(i<5) { i++; if(i== 5) { x = true; System.out.println(i + " " + x); continue; } } }

Questa istruzione rappresenta l’ultima istruzione di ramificazione e può essere utilizzata per terminare l’esecuzione del metodo corrente tornando il controllo al metodo chiamante. Due forme: return valore: viene utilizzata per consentire ad un metodo di ritornare valori al metodo chiamante e pertanto deve ritornare un valore compatibile con quello dichiarato nella definizione del metodo. return: può essere utilizzata per interrompere l’esecuzione di un metodo qualora il metodo ritorni un tipo void

Incapsulamento, ereditarietà e polimorfismo Giuseppe Dell’Abate

L'incapsulamento è una tecnica mediante la quale si proteggono i dati evitando che si possano manipolare, lasciando però la possibilità di interrogarne il valore. In alcuni linguaggi procedurali esiste solo "l'incapsulamento sui tipi primitivi", ma non quello sui nuovi tipi definiti dall'utente. Nei linguaggi OOP, invece, è supportato anche l'incapsulamento per i tipi di dati definiti dall'utente In altri termini l'incapsulamento consente di legare, in riferimento alla classe, i dati (membri o variabili) e le operazioni (metodi o funzioni) con una limitazione di accesso ad essi. Questo modo di operare protetto elimina i problemi di difficoltà di manutenzione

Esempio: class MiaClasse { private int x; public int leggo() { return x; } public void scrivo(int x) { this.x = x; } } In questa classe possiamo notare che la proprietà x privata è accessibile in scrittura dal metodo scrivo() ed in lettura dal metodo leggo()

L'ereditarietà consente di definire un tipo ( classe ) sulla base dei dati e dei metodi di un tipo già definito, ereditandone operativamente sia i dati che i metodi. La classe di partenza è la "classe base" o "superclasse" o "classe padre"; mentre la classe che si crea è la "classe derivata" o la "sottoclasse" o la "classe figlia". Nella terminologia OOP si usa anche il termine "estendere" che indica la creazione di una classe derivata da una classe base. Non bisogna mai confondere l'ereditarietà con l'incorporamento (classe contenitore)! Di grosso aiuto sono, nel linguaggio corrente, i verbi "E' un" e "Ha un".

Esempio: class Padre { int x = 5; } public class Figlio extends Padre { public static void main(String[] args) { Figlio pr = new Figlio(); pr.leggo(); } void leggo() { System.out.println(x); } } La classe Figlio eredita la prorietà x dalla classe Padre e può usarla al suo interno

Derivato dal greco, significa “pluralità di forme” E’ la caratteristica che ci consente di utilizzare un’unica interfaccia per una moltitudine di azioni. Quale sia la particolare azione eseguita dipende solamente dalla situazione in cui ci si trova. Mentre con gli oggetti il collegamento con la classe avviene a compile-time, nel caso del polimorfismo avviene a run-time Il polimorfismo viene impiegato impiegando una interfaccia, una classe astratta o una classe. E’ necessario che ci sia ereditarietà tra le classi

Esempio: abstract class Figura { abstract void rispondo(); } class Triangolo extends Figura { void rispondo(){System.out.println("Sono il triangolo");} } class Rettangolo extends Figura { void rispondo(){System.out.println("Sono il rettangolo");} } Figura Triangolo Rettangolo

Continua… esempio: public class Altro { Figura pr; public static void main(String[] args) { Altro al = new Altro(); al.metodo(); } void metodo() { pr = new Triangolo(); pr.rispondo(); pr = new Rettangolo(); pr.rispondo(); } } Tutto ciò è possibile se esiste ereditarietà!!

Overloading ed overridding Giuseppe Dell’Abate

Per riferirsi agli oggetti ed ai metodi si utilizzano dei nomi. Nomi scelti con criterio rendono più semplice la comprensione del codice. Spesso la stessa parola esprime differenti significati: è overloaded . In Java c’è la possibilità di utilizzare lo stesso nome per fare riferimento a più metodi Il metodo da eseguire viene stabilito in funzione del contesto Il contesto è indicato dagli argomenti e dal valore di ritorno del metodo Tipicamente il metodo costruttore di una classe è overloaded, visto che spesso è utile stabilire diversi modi di inizializzazione dell’oggetto

Esempio di overloading del costruttore: class Esempio { int prop; public Esempio() { codice }; public Esempio(int prop) { this.prop=prop; } } In questo esempio anche prop è overloaded . Con il riferimento this si risolve l’ambiguità. L’argomento identifica univocamente il metodo

Esempio di overloading di un metodo: class Esempio { int prop; public void metodo() { codice }; public int metodo() { return prop; } } I valori di ritorno identificano univocamente i metodi

Con il termine overriding si intende la ridefinizione di un metodo ereditato. Una sottoclasse specializza il comportamento del padre e quindi spesso c’è la necessità di ridefinirne il codice, riscrivendolo o aggiungendo delle funzionalità. In alcuni casi è proprio necessario implementare dei metodi (vedi Classi astratte e Interfacce).

Esempio di overriding di un metodo: class Padre { public void metodo() { codice } } class Figlio extends Padre { public void metodo() { nuovo codice } }

Esempio di overriding con riscrittura del codice: class Padre { int prop; public void metodo() { prop=5; } } class Figlio extends Padre { int prop2; public void metodo() { prop2=13; prop=14; } }

Esempio di overriding con aggiunta di codice: class Padre { int prop; public void metodo() { prop=5; } } class Figlio extends Padre { int prop2; public void metodo() { super(); prop2=3; } }

Classi annidate Giuseppe Dell’Abate

Le classi interne (inner classes) sono l'unica modifica sintattica del linguaggio nel passaggio dalla versione 1.0 a 1.1. In Java 1.0 tutte le classi si trovavano allo stesso livello (top level) e non potevano contenere altre classi In Java 1.1 , all'interno di una classe possono essere specificate definizioni di altre classi che hanno una stretta relazione funzionale con la classe contenitrice.

A seconda della definizione e dell'ambito in cui viene deinita una classe interna, si possono distinuere quattro casi: classi annidate di livello superiore (nested top-level classes); classi membro (member classes); classi locali (local classes); classi anonime (anonymous classes).

Classe interna che è stata definita con il modificatore static Possono essere richiamate: Nella stessa classe attraverso una istanza della classe e successivamente richiamando il metodo. Da un’altra classe attraverso la dichiarazione import oppure indicando la sua classe esterna e poi la classe interna. Viene trattata al pari di un package

Possiamo richiamare la classe annidata statica dall'interno della classe indicando: class Prova { public static void main(String[] args) { ProvaStatica ps = new ProvaStatica(); ps.metodo(); } static class ProvaStatica { void metodo() { System.out.println("Hello World!"); } }; }

Possiamo richiamare la classe annidata statica dall'esterno della classe non importandola class Prova { static class ProvaStatica { void metodo() { System.out.println("Hello World!"); } }; } class ClasseEsterna { public static void main(String[] args) { Prova.ProvaStatica ps = new Prova.ProvaStatica(); ps.metodo(); } }

Possiamo richiamare la classe annidata statica dall'esterno della classe importandola: class Prova { static class ProvaStatica { void metodo() { System.out.println("Hello World!"); } }; } import ProvaStatica; class ClasseEsterna { public static void main(String[] args) { ProvaStatica ps = newProvaStatica(); ps.metodo(); } }

Le classi membro sono classi elemento che non sono state dichiarate static ed appartengono perciò in tutto e per tutto all'oggetto Possono essere richiamate: Nella stessa classe attraverso attraverso una istanza della classe e successivamente richiamando il metodo. Da un’altra classe attraverso la dichiarazione import oppure indicando la sua classe esterna e poi la classe interna. Viene trattata al pari di un package

class Prova { public static void main(String[] args) { Prova p = new Prova(); ProvaStatica ps = p.new ProvaStatica(); ps.metodo(); } class ProvaStatica { void metodo() { System.out.println("Hello World!"); } }; }

class Prova { class ProvaStatica { void metodo() { System.out.println("Hello World!"); } }; } import Prova.ProvaStatica; class Avvia { public static void main(String[] args) { Prova p = new Prova(); ProvaStatica ps = p.new ProvaStatica(); ps.metodo(); } };

class Prova { class ProvaStatica { void metodo() { System.out.println("Hello World!"); } }; } class Avvia { public static void main(String[] args) { Prova p = new Prova(); Prova.ProvaStatica ps = p.new ProvaStatica(); ps.metodo(); } };

Una classe locale è una classe che è state definita all'interno di un qualunque blocco di codice Possono accedere soltanto alle variabili dichiarate come final (per evitare conflitti che potrebbero sorgere tra più classi, definite nello stesso blocco, che dovessero agire sulle stesse variabili ... )

class Prova { public static void main(String[] args) { Prova p = new Prova(); p.metodo(); } void metodo() { class ProvaStatica { void metodo2() { System.out.println("Hello World!"); } }; ProvaStatica ps = new ProvaStatica(); ps.metodo2(); } }

Quando di una classe locale che estende qualche altro oggetto viene richiesto che la sua istanza sia unica e non è necessario che venga memorizzata in una variabile, è possibile utilizzare l'abbreviazione delle classi anonime new classe_estesa ( lista_argomenti_costruttore ) { blocco } L'uso delle classi anonime è consigliato ogniqualvolta le estensioni sono di piccola estensione; altrimenti si consiglia l'uso di classi locali

Esempio di classe anonima locale utilizzando una classe astratta public class Parcel7 { public Wrapping wrap() { return new Wrapping() { private int i = 2; public int value() { return i; } }; } public static void main(String[] args) { Parcel7 p = new Parcel7(); Wrapping w = p.wrap(); System.out.println(w.value()); } abstract class Wrapping { public abstract int value(); } }

Esempio di classe anonima locale utilizzando una interfaccia public class Parcel7 { public Wrapping wrap() { return new Wrapping() { private int i = 2; public int value() { return i; } }; } public static void main(String[] args) { Parcel7 p = new Parcel7(); Wrapping w = p.wrap(); System.out.println(w.value()); } interface Wrapping { public int value(); } }

Esempio di classe anonima locale utilizzando una classe public class Parcel7 { public Wrapping wrap() { return new Wrapping() { private int i = 2; public int value() { return i; } }; } public static void main(String[] args) { Parcel7 p = new Parcel7(); Wrapping w = p.wrap(); System.out.println(w.value()); } class Wrapping { public int value(){ return 0; } } }

Una classe anonima accetta solamente costanti e non variabili, ciò per evitare che vengano a generarsi manipolazioni confusionarie delle variabili nel codice. public class Parcel7 { public Wrapping wrap(final int x) { return new Wrapping() { int i = x; public int value() { return i; } }; } public static void main(String[] args) { Parcel7 p = new Parcel7(); Wrapping w = p.wrap(2); System.out.println(w.value()); } interface Wrapping { public int value(); } }

Eccezioni Giuseppe Dell’Abate

Una eccezione è un evento che si verifica durante l’esecuzione di un programma e che ne impedisce la normale prosecuzione a causa di errori hardware o semplici errori di programmazione. Il sistema runtime, per la gestione dell’eccezione, cerca“candidati” a partire dal metodo nel quale l’eccezione è stata“sollevata”, proseguendo eventualmente lungo lo stack delle chiamate, finché non trova un metodo contenente un gestore(exception handler) opportuno. Se non viene trovato nessun exception handler adatto alla gestione di un’eccezione, il programma termina.

Vantaggi rispetto alle tecniche “tradizionali”: separazione del codice di gestione degli errori dal normale codice del programma propagazione degli errori lungo lo stack delle chiamate dei metodi raggruppamento dei vari tipi di errori e loro differenziazione

La classe Throwable ha due discendenti dirette: Error e Exception Errori (classe Error): sono generati quando si verificano problemi “seri” nell’esecuzione del programma, dovuti a malfunzionamenti della macchina virtuale Java (piuttosto rari) Eccezioni (classe Exception): segnalano che si è verificato un problema nell’esecuzione del programma (il problema, comunque, non è dovuto ad un malfunzionamento del sistema) Le eccezioni runtime hanno un “vantaggio”: non devono necessariamente essere specificate nelle intestazioni dei metodi o esplicitamente gestite tramite costrutti try-catch (a differenza, ad esempio, di quelle di input/output)

Una eccezione potrà essere: gestita attraverso gli exception handler propagata lungo lo stack delle chiamate dei metodi

Un exception handler è composto da tre parti principali: un blocco try uno o più blocchi catch (opzionali) un blocco finally

Racchiude il codice che può sollevare l’eccezione (o le eccezioni) e deve necessariamente essere seguito da un blocco catch o da un blocco finally Struttura del costrutto try: try { ....... }

racchiudono il codice che gestisce l’eccezione sollevata nel blocco try Struttura del costrutto catch: catch (<tipo eccezione> <variabile>) { gestione dell’eccezione } < tipo eccezione > deve essere il nome di una classe che eredita dalla classe Throwable < variabile > è il nome attraverso cui il gestore dell’eccezione può riferirsi ad essa (identifica cioè un oggetto eccezione)

Viene sempre eseguito al termine dell’esecuzione del contenuto del blocco try (indipendentemente dal fatto che siano state sollevate eccezioni oppure no) Consente, ad esempio, di chiudere file aperti nel blocco try (i quali, magari, rimarrebbero aperti in seguito al verificarsi di un errore non esplicitamente gestito in un catch) Consente di evitare duplicazione di codice nei blocchi catch Struttura del costrutto finally finally { ....... }

Struttura generale del costrutto try-catch-finally (con due catch) try { ....... } catch (...) { ....... } catch (...) { ....... } finally { ....... }

Nel caso si decida di propagare una eccezione lungo lo stack delle chiamate occorre utilizzare la parola chiave throws al metodo. La propagazione dell’eccezione di un metodo indica la volontà di non volersi preoccupare della sua gestione. Se i metodi chiamanti non hanno previsto la gestione dell’errore, allora il programma si interromperà. public void metodo () throws IOException { … ... }

E’ possibile lanciare un eccezione nel caso si voglia che venga propagata lungo lo stack delle chiamate dei metodi: void metodo() throws IOException { if (...) { throw new IOException(); } }

La creazione di eccezioni da parte del programmatore nasce dalla necessità di gestire efficacemente situazioni di errore (o comunque anomale) non previste dalle eccezioni standard di Java ma che si possono comunque verificare durante l’esecuzione del programma che si sta progettando Esempio: public class ElementoInesistenteException extends Exception { public String nomeElemento; ElementoInesistenteException(String nome) { super("Non esiste alcun elemento'" + nome); nomeElemento = nome; } }

Il package java.io è composto da due parti principali: stream di byte : utilizzati per gestire un flusso di byte (8 bit) stream di caratteri : impiegati per maneggiare un flusi di caratteri UNICODE(16 bit) Per ogni stream esistono i corrispondenti stream di input e di output stream di byte : InputStream ed OutputStream stream di caratteri : Reader e Writer Quando si parla semplicemente di stream si intende uno stream di qualunque tipo (di byte o di caratteri , di input o di output)

InputStream : ci permette di gestire in input i files in blocchi da 8 bit=1 byte.

Esempio di una classe che legge i byte di un file passato come parametro import java.io.*; class ProvaInputStream { public static void main(String[] args) throws IOException { InputStream is = new FileInputStream(args[0]); int b; while ( (b = is.read()) != -1 ) System.out.println("Letto : " + (char)b); } }

OutputStream : ci permette di gestire in output i files in blocchi da 8 bit=1 byte.

Esempio di una classe che scrive dei dati in un file import java.io.*; class ProvaOutputStream { public static void main(String[] args) throws IOException { OutputStream os = new FileOutputStream(args[0]); int b; while ( (b = System.in.read()) != -1 ) os.write(b); } }

Reader : ci permette di gestire in input i flussi di caratteri in blocchi da 16 bit=2 byte.

Esempio di una classe che scrive dei dati in un file import java.io.*; class ProvaReader { public static void main(String[] args) throws IOException { Reader r = new FileReader(args[0]); int c; while ( (c = r.read()) != -1 ) System.out.println(“Leggo:” + (char)c); } }

Writer : ci permette di gestire in output i files in blocchi da 16 bit=2 byte.

Esempio di una classe che scrive dei dati in un file import java.io.*; class ProvaWriter { public static void main(String[] args) throws IOException { Reader r = new InputStreamReader(System.in); Writer os = new FileWriter(args[0]); int b; while ( (b = r.read()) != -1 ) { os.write(b); os.flush(); } } }

E’ possibile creare un buffer di dati in Input - Output per velocizzare la lettura/scrittura dei bytes Input Byte InputStream is = new FileInputStream(args[0]); BufferedInputStream bis = new BufferedInputStream(is); Output Byte OutputStream is = new FileOutput Stream(args[0]); BufferedOutputStream bis = new BufferedOutputStream(is);

E’ possibile creare un buffer di dati in Input - Output anche per la lettura/scrittura dei caratteri, ed usare il metodo readLine() per leggere una riga completa e non un singolo carattere Input Carattere Reader is = new FileReader(args[0]); BufferedReader br = new BufferedReader(is); Output Carattere Writer w = new FileWriter(args[0]); BufferedWriter bw = new BufferedWriter(w);

In Input/Output possono essere impiegati array di byte: ByteArrayInputStream() ByteArrayOutputStream() caratteri CharArrayReader() CharArrayWriter() In Input/Output possono essere impiegati stringhe di caratteri StringReader() StringWriter()

Java consente di realizzare la concorrenza attraverso i thread I threads sono dei programmi "figli" di quello principale. Lo scheduling si occupa dell’ordine di esecuzione ed il sistema attiverà quello a priorità maggiore L’algoritmo di scheduling del sistema runtime di Java è di tipo preemptive (promozione) Il sistema runtime di Java non supporta di per sé il time-slicing. Per evitare che un programma sia dipendente dalla particolare piattaforma fisica (hardware + sistema operativo), è bene non fare affidamento su questa caratteristica

La nostra classe deve essere una sottoclasse della classe astratta java.lang.Thread oppure deve implementare l’interfaccia Runnable, presenti nella libreria del JDK Richiamiamo i metodi costruttori; public Thread(); public Thread(String nome); l’esecuzione è avviata con il metodo start() il metodo run() contiene le operazioni da effettuare public void run() { azioni da svolgere }

class Principale extends Thread { int FineConteggio; public static void main(String argv[]) { Principale Mario=new Principale ("Mario",100); Principale Anna=new Principale ("Anna",50); Mario.start(); Anna.start(); } Principale (String Nome, int n) { super(Nome); FineConteggio=n; } public void run() { System.out.println(this.getName()+": sto contando..."); for (int i=0; i<=FineConteggio; i++) System.out.println(this.getName()+": "+i); System.out.println(this.getName()+": ho finito di contare!"); } }

born ready running blocked dead sleeping waiting start notify o notifyall wait sleep comple-tamento invio I/O completamento I/O assegna un processore quantum expiration yield interrupt intervallo di sleep scade

Ad ogni processo è assegnata una priorità ovvero un valore intero positivo che varia tra due valori static della classe Thread: MIN_PRIORITY e MAX_PRIORITY. Quando un thread viene creato, come nell'esempio precedente, la sua priorità è pari a NORM_PRIORITY Se in un determinato istante esiste un thread nello stato Runnable che ha priorità maggiore di quello corrente, esso viene promosso (pre-empted) sostituendo il precedente che, pur rimanendo nello stato di Runnable, non avanzerà nella esecuzione

Esempio di Thread con diversa priorità che vengono gestiti dallo scheduler secondo il pre-emptive public class MioThread extends Thread { public MioThread(String nome_thread){ super(nome_thread); } public void run(){ for (int i=0; i<10;i++) System.out.println(getName()); }

public static void main(String[] str){ MioThread thread1 = new MioThread("Thread1"); thread1.start(); MioThread thread2 = new MioThread("Thread2"); thread2.setPriority(Thread.MAX_PRIORITY); thread2.start() ; MioThread thread3 = new MioThread("Thread3"); thread3.setPriority(Thread.MIN_PRIORITY); thread3.start(); } }

Nel caso di processi di uguale priorità entrano in gioco le caratteristiche proprie di ciascun sistema operativo. In molti sistemi operativi UNIX il Thread viene eseguito fino al suo compimento Nelle implementazioni della JVM in Window95 o NT ad ogni thread è assegnato un tempo massimo di utilizzo della CPU(quantum) oltre il quale dovrà lasciare la CPU stessa ad altri thread. Per gestire le differenze è possibile usare il metodo yield() che sospende l’esecuzione del thread per passarla al prossimo

public class MioThreadWIN extends Thread { public MioThreadWIN(String nome_thread){ super(nome_thread); } public void run(){ for (int i=0; i<1000000;i++) System.out.println(getName()); } public static void main(String[] str){ MioThreadWIN thread1 = new MioThreadWIN("Thread1"); thread1.start(); MioThreadWIN thread2 = new MioThreadWIN("Thread2"); thread2.start(); } }

E’ necessario disciplinarne l'accesso su un dato condiviso In Java questo si ottiene dichiarando il metodo synchronized Se in un certo istante il thread T1 è all'interno di una regione critica su un dato condiviso, allora ogni altro thread che tenti di accedere ad una qualsiasi altra regione critica sullo stesso dato dovrà attendere il suo turno

public synchronized void put(int value) { while (available) { try { wait(); } catch (InterruptedException e) { } } contents = value; available = true; notifyAll(); } public synchronized void put2(int value) { while (!available) { try { wait(); } catch (InterruptedException e) { } } contents = value; available = false; notifyAll(); }

Serializzazione Giuseppe Dell’Abate

E’ una tecnica che consente di poter salvare un oggetto, o meglio renderlo persistente, e poi ripristinato Vi è la possibilità di definire alcune proprietà come transient per cui ne viene salvata l’istanza ma in fase di ripristino i suoi campi assumono i loro valori di default Occorre implementare l’interfaccia java.io.Serializable ed occorre che tutti le proprieta siano serializzabili Per verificare si puo usare il serialver -show. Apparirà una finestra nella quale metterete il nome completo della classe che volete esaminare. Se la classe è serializzabile apparirà un valore identificativo della classe stessa, altrimenti non apparirà nulla.

public void scrivi () { try{ fos = new FileOutputStream ("restore.ser"); oos = new ObjectOutputStream(fos); oos.writeObject(salvato); oos.close(); } catch (Ioexception ioe){ System.out.println("Errore:"+ioe.toString()); }// fine catch }// fine metodo scrivi

public void leggi() { try{ fis = new FileInputStream ("restore.ser"); ois = new ObjectInputStream(fis); salvato = (TipoSalvato)(ois.readObject()); ois.close(); } catch (Ioexception ioe){ System.out.println("Errore:"+ioe.toString()); }// fine catch }// fine metodo leggi Operazione di cast da fare all’atto del readObject . Infatti essa ritorna un Object per cui tale operazione si rende necessaria

Oggetti non serializzabili: Thread, ResultSet e risorse native Oggetti serializzabili classi che implementano interfaccia Serializable/Externalizable direttamente o indirettamente tipi primitivi quasi tutte le AWT Posso serializzare soltanto qualche proprietà della classe ?

Risposta : Se voglio rendere una classe serializzabile ANCHE se contiene attributi NON serializzabili… posso farlo, basta indicare quei campi come "ignorabili" dal meccanismo di serializzazione. A tali campi basta aggiungere il modificatore transient . public class DaTrasmettere implements Serializable{ int count; // serializzabile String messaggio; // serializzabile transient Thread t; // NON serializzabile !!! } Tutti i campi transient vengono saltati durante la serializzazione, per cui bisogna re-inizializzarli all’arrivo

Serializable , quando viene trasmesso l'ObjectStream lo converte in uno stream di byte usando il protocollo predefinito Externalizable serve se NON voglio usare il meccanismo standard e voglio leggere e scrivere il MIO oggetto alla MIA maniera

I Socket Giuseppe Dell’Abate

Un socket è un flusso di byte che può essere trasmesso tra due host diversi collegati in rete Esistono due tipi di socket: TCP (Transport Control Protocol) UDP (User Datagram Protocol)

Meccanismo “affidabile” ed “orientato alla connessione” Affidabile: eventuali errori di comunicazione vengono gestiti dal sistema di trasmissione, pertanto vengono: recuperati segnalati al programma applicativo orientato alla connessione tutti i byte vengono ricevuti esattamente come sono stati trasmessi Vengono impiegati per FTP ed HTTP

Detti “senza connessione” dal momento che ogni pacchetto di fatto vive indipendentemente dagli altri il sistema operativo non garantisce che: il pacchetto venga consegnato al destinatario la segnalazione di eventuali errori che arrivino nello stesso ordine in cui sono spediti possono arrivare addirittura in copie multiple Per superare questi problemi vengono realizzati dei controlli a livello di applicazione Vengono usati per broadcasting e multicasting (NFS,DNS)

Le socket consentono il collegamento tra due host Per gestire piu socket si fa uso delle porte Porte standard FTP 20 - 21 Telnet 23 SMTP 25 POP3 110 HTTP 80

I socket in Java sono implementati con quattro classi distinte: 1. Socket : socket TCP lato client 2. ServerSocket : socket TCP lato server 3. DatagramSocket : socket UDP semplici e broadcast 4. MulticastSocket : socket UDP multicast

Un socket di tipo TCP deve essere in generale costruito con almeno tre parametri: la porta locale (indicata dinamicamente) l’indirizzo remoto la porta remota

Specifica indirizzo e porta remota; public Socket (String addr, int port); Manipolare la porta remota di connessione public void setPort (int port); public int getPort();

Le socket permette di associarvi una coppia di stream di I/O public InputStream getInputStream(); public OutputStream getOutputStream(); Successivamente possiamo associarvi stream di tipo DataInput e DataOutput e gestire lo stream Quando il socket non serve più deve essere chiuso public void close();

public void start()throws Exception { DataInputStream stdIn = new DataInputStream(System.in); Socket socket = new Socket(”10.30.1.135", 7777); DataOutputStream os = new DataOutputStream(socket.getOutputStream()); DataInputStream is = new DataInputStream(socket.getInputStream()); for (;;) { System.out.print("input: "); String userInput = stdIn.readLine(); if (userInput.equals("QUIT")) break; os.writeBytes(userInput + '\n'); System.out.println("echo: " + is.readLine()); } os.close(); is.close(); socket.close(); }

public void start() throws Exception { ServerSocket serverSocket = new ServerSocket(7777); for (;;) { System.out.println("Waiting... "); Socket socket = serverSocket.accept(); System.out.println("New socket " + socket); DataInputStream is = new DataInputStream(socket.getInputStream()); DataOutputStream os = new DataOutputStream(socket.getOutputStream()); for (;;) { String userInput = is.readLine(); os.writeBytes(userInput + '\n'); System.out.println("Replying " + userInput); } os.close(); is.close(); System.out.println("Closed socket " + socket); socket.close(); } }

Un socket UDP serve per la trasmissione di “piccoli” pacchetti di dati detti datagrammi (secondo lo standard TCP/IP non più lunghi di 1500 byte). Java definisce una classe apposita, DatagramPacket, per la loro implementazione DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port) Per gestire i datagrammi esiste la classe DatagramSocket. Per crearne un’istanza è sufficiente specificare il numero della porta: public DatagramSocket (int port); I datagrammi possono poi essere spediti e ricevuti con i metodi send() receive()

Manipolano l’indirizzo remoto public int getPort(); public InetAddress getAddress(); public void setAddress (InetAddress address); Manipolano la porta remota public void setPort (int port); public int getPort(); Manipolano il buffer che contiene i dati public byte[] getData(); public void setData (byte[] data); public int getLenght(); public void setLenght (int lenght);

import java.net.*; public class UDPExample { public static void main (String[] args) throws Exception { byte[] msg = {'H', 'e', 'l', 'l', 'o'}; InetAddress addr = InetAddress.getByName("192.5.6.7"); DatagramSocket s = new DatagramSocket(2222); DatagramPacket hi = new DatagramPacket(msg, msg.length, addr, 2223); s.send(hi); byte[] buf = new byte[1000]; DatagramPacket recv = new DatagramPacket(buf, buf.length); s.receive(recv); } }

Per quanto riguarda i socket multicast, essi hanno una classe apposita, MultiCastSocket, che si gestisce analogamente ad un DatagramSocket MulticastSocket(int port) I metodi joinGroup() e leaveGroup() servono, rispettivamente, per “entrare” ed “uscire” dal gruppo di host.

import java.net.*; public class UDPExample { public static void main (String[] args) throws Exception { byte[] msg = {'H', 'e', 'l', 'l', 'o'}; InetAddress group = InetAddress.getByName("228.5.6.7"); InetAddress addr = InetAddress.getByName("192.5.6.7"); MulticastSocket s = new MulticastSocket(2222); s.joinGroup(group); DatagramPacket hi = new DatagramPacket(msg, msg.length, addr, 2223); s.send(hi); byte[] buf = new byte[1000]; DatagramPacket recv = new DatagramPacket(buf, buf.length); s.receive(recv); s.leaveGroup(group); }}

Remote Method Interface Giuseppe Dell’Abate

Per creare delle applicazioni distribuite, prima veniva usato il Remote Procedure Call (RPC) legato al concetto di processo e di procedura e non al paradigma ad oggetti. Fu introdotto l’RMI: un' insieme di API potente ma semplice che permette di sviluppare applicazioni distribuite in rete Permette di implementare la: Serializzazione Socket

Livello di applicazione RMI Client : applicazione che effettua le chiamate ai metodi di oggetti remoti risiedenti sul lato server RMI Server : applicazione che gestisce gli oggetti serventi Remote Reference Layer Stub : fornisce una simulazione locale sulla JVM del client dell’oggetto remoto Skeleton : è l’oggetto remoto in esecuzione sulla JVM del server Transport Layer si instaura un collegamento fisico per la trasmissione di sequenza di byte (oggetti serializzati ) attraverso i socket su protocllo TCP/IP

La classe Naming è un registro che mappa dei nomi logici con i references dell'interfacce degli oggetti remoti. Ogni associazione nome logico – oggetto remoto è memorizzata in un apposito registro gestito dall'applicazione rmiregistry

import java.rmi.server.*; import java.rmi.*; import MyServerImpl; public class RmiClient { public static void main(String[] args) { String urlRmiHost = "rmi://10.30.1.135:1099/MyService"; try { MyServerInterface serverRef = (MyServerInterface)Naming.lookup(urlRmiHost); System.out.println(serverRef.concat("World")); } catch (Exception e){} } }

import java.rmi.server.*; import java.rmi.*; public interface MyServerInterface extends Remote { public String concat(String nome) throws RemoteException; }

import java.rmi.server.*; import java.rmi.*; public class RmiServer { public static void main(String [] args) throws Exception{ MyServerImpl server = new MyServerImpl(); Naming.bind("MyService", server); System.out.println("RmiServer : bind done ..."); System.out.println("MyService is now available ..."); } }

import java.rmi.server.*; import java.rmi.*; public class MyServerImpl extends UnicastRemoteObject implements MyServerInterface { public MyServerImpl() throws RemoteException { } public String concat(String nome) throws RemoteException { return "Hello " + nome; } }

Corso Java

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to Corso Java (20)

Corso Java