• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Object Oriented with Java Programmazione Base
 

Object Oriented with Java Programmazione Base

on

  • 733 views

Corso base per la programmazione java

Corso base per la programmazione java

Statistics

Views

Total Views
733
Views on SlideShare
733
Embed Views
0

Actions

Likes
0
Downloads
23
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Object Oriented with Java Programmazione Base Object Oriented with Java Programmazione Base Presentation Transcript

    • Object Oriented with JavaProgrammazione Base ing. Felice Pescatore www.storiainformatica.it -www.felicepescatore.it felice.pecatore@gmail.com
    • 1.Object Oriented Language
    • Funzionale, Procedurale e ad Oggetti•Funzionale (detta anche orientata alle espressioni): si focalizzasulle espressione e considera le funzioni come oggetti. • Es: Python•Procedurali (o imperativi): il focus è sulla sequenza di operazionida eseguire • Es: C, VB Classic, Pascal, Fortran, Algol, C++•Programmazione ad Oggetti (OO): il dominio viene astratta inelementi aventi un proprio stato ed una serie di metodi in grado dilavorare su di esso. • Es: Java, C#, C++
    • Sintassi vs Semantica•La sintassi definisce la forma: come e’ fatto unprogramma del linguaggio (correttezza sintattica)• La semantica definisce il significato associato aciascuna forma: cosa calcola ciascun programma(correttezza semantica)
    • Il nostro focusAl centro di questo corso introduttivo vedremo iconcetti di base della programmazione ad oggetti.Ragioneremo in modo “agnostico” rispetto allospecifico linguaggio, ma utilizzeremo JAVA per gliesempi
    • Perché Object Oriented• La programmazione ad oggetti rappresenta una metodologia disviluppo software che si contrappone alla programmazione procedurale,spesso troppo poco gestibile e confusionaria.•Tramite lapproccio orientato ad oggetti è possibile definire delle classiche rappresentano un tipo di dato gestito dallapplicazione che puòessere utilizzato solo tramite particolari interfacce esposte dalla classestessa verso le altre classi dellapplicazione. Allinterno di una classeesistono infatti alcune funzionalità "interne" che non vengono mostrateallesterno.•Tramite questa tipologia di programmazione si migliora notevolmente ilcodice limitando le interferenze tra diversi componenti e incapsulandofunzionalità specifiche allinterno di una sorta di contenitore chepermette una organizzazione più funzionale ed elegante.
    • Classi,Interfacce e Classi Astratte (1)•I linguaggio OO trovano nella “classe” il loroelemento principale •una classe definisce tipicamente un tipo •Istanziando una classe (in sintesi allocando memoria per essa) otteniamo un oggetto di quello specifico tipo
    • Classi,Interfacce e Classi Astratte (2)• Le interfacce rappresentano un “contratto”, ovvero unaserie di funzionalità che la classe deve implementare sevuole essere conforme a quanto definito • per ogni interfaccia possono esistere più classi che la implementano • e quindi, transitivamente, posso riferirmi a oggetti di classi diverse che implementano la stessa interfaccia tramite quest’ultima Tramite le interfacce (ed una serie di pattern) posso ottenere una vera “dinamicità” del codice!
    • Classi,Interfacce e Classi Astratte (3)•Le interfacce permettono di astrarre quello che èrichiesto ad una classe da come esso vieneimplementato.• Ciò consente di disaccoppiare i due elementi,consentendo di utilizzare l’opportuno implementazionesenza modificare (o quasi) il flusso primario diesecuzione del codice. design for change
    • Classi,Interfacce e Classi Astratte (4)• Le classi astratte sono un po’ una via di mezzo tra Classied Interfacce. Infatti consentono di implementare in modocompleto una serie di operazioni (metodi) e definire ilcontratto di altre che dovranno essere implementate dalleclassi figlie.Le classi astratte non sono istanziabili!
    • Caratteristiche fondamentali diun linguaggio Object Oriented•incapsulamento: la classe è un “mondo a se”, auto contenuto eportatore di una (o più) informazione (i) ben precisa (e).•ereditarietà: la possibilità di estendere classi con altre classi che neereditano appunto proprietà e metodi;•polimorfismo: la possibilità di avere funzionalità particolari che sicomportano in maniera diversa in base alloggetto invocante o aiparametri ad esso passati.
    • Struttura di una ClasseUna classe realizza limplementazione di un tipo di dato astratto. class Animal { string family; int legs; string GetFamily() { return family } void SetFamily(string fam) { this.family = fam; } … }
    • Object Oriented: Ereditarietà (1)•Lereditarietà consente di definire un tipo (ovvero una nuovaclasse) estendendone uno già esistente ed ereditando le sueproprietà (dati e metodi)•La classe di partenza è la “classe base” (“superclasse“, “classepadre”), la nuova classe è detta “classe derivata” (“sottoclasse”,“classe figlia”).
    • Object Oriented: Ereditarietà (2)class Padre { int x = 5;}public class Figlio extends Padre { PADRE public static void main(String[] args) { Figlio pr = new Figlio(); pr.leggo(); } void leggo() { FIGLIO System.out.println(x); }}La classe Figlio eredita la proprietà x dalla classe Padre e può usarla al suo interno
    • Object Oriented: Polimorfismo (1)•Il polimorfismo consente di utilizzare un’unica interfaccia perrichiamare funzionalità varianti in base ad una specificasituazione (implementazione)•Mentre con gli oggetti il collegamento con la classe avviene acompile-time, nel caso del polimorfismo avviene a run-time•Il polimorfismo viene impiegato impiegando una interfaccia, unaclasse astratta o una classe e richiede che le stesse siano collegatetra loro tramite ereditarietà Il termine “polimorfismo” deriva dal greco e significa “pluralità di forme”
    • Object Oriented: Polimorfismo (2)abstract class Figura{ abstract void rispondo(); Figura} class Triangolo extends Figura Triangolo Rettangolo{ void rispondo(){System.out.println("Sono iltriangolo");}} class Rettangolo extends Figura{ void rispondo(){System.out.println("Sono il rettangolo");}}
    • Object Oriented: Polimorfismo (3)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(); }} Assegno alla stessa classe astratta oggetti di tipo diverso. La cosa è possibile grazie all’ereditarietà
    • Domande… prima, esempi… dopo
    • 2. Object Oriented Programming
    • Classi e oggetti La classe modella un insieme di oggetti omogenei (le istanze della classe) ai quali sono associate proprietà statiche e dinamiche Ogni classe è descritta da: • Nome della classe (l’identificatore) • Attributi (lo stato) • Operazioni (il comportamento) Importanza dellidentificativo •Due oggetti con identificativi distinti sono comunque distinti, anche se hanno i valori di tutti gli attributi uguali •Due oggetti diversi devono avere identificativi diversi, anche se possono avere gli stessi valori per tutti gli attributi
    • Attributi e metodi (1) Le classi sono tipicamente caratterizzate da: • attributi •modellano una o più proprietà della classe •tipicamente rappresentano nel loro insieme lo stato dell’oggetto • metodi •permettono operazioni sugli attributi •permettono di variare lo stato dell’oggetto
    • Attributi e metodi (2) In una classe, un metodo si definisce specificando i parametri e il tipo del risultato (se c‟è). Non è necessario che un metodo restituisca un valore o un oggetto. Un metodo può anche effettuare solamente azioni senza calcolare un risultato.
    • Attributi e metodi (3)I metodi possono essere raggruppati in due macro-categorie: • Funzione: elaborano i dati e restituiscono un valore int moltiplicavalori(int a, int b) { risultato= a * b; return(risultato); } • Procedure: eseguono la procedura e non restituiscono un valore void nomeMetodo(int a, int b) { System.out.println(a+” - “+b ); }
    • Attributi e metodi, funzioni (4)• int è il tipo di valore che la funzione restituirà(quindi il tipo dellavariabile risultato);• moltiplicavalori è il nome della funzione;• argomenti: allinterno delle parentesi tonde troviamo i dueargomenti che forniamo alla funzione con i loro relativi tipi• blocco di istruzioni : allinterno delle parentesi graffe troviamoil blocco di istruzioni della funzione• return: listruzione return(...) è quella che permette alla funzionedi restituire il valore risultato. Le istruzioni che seguonolistruzione return vengono ignorate
    • Attributi e metodi, procedure (5)• nomeMetodo: è il nome della funzione;• argomenti: allinterno delle parentesi tonde troviamo i due argomentiche forniamo alla funzione con i loro relativi tipi• blocco di istruzioni: allinterno delle parentesi graffe troviamo ilblocco di istruzioni della funzione• void (vuoto): indica che la funzione non restituirà nessun valore maeseguirà solamente le istruzioni indicate• listruzione: System.out.println(...) è quella che permette alla funzionedi visualizzare a console i parametri passati
    • Attributi e metodi(6)Le proprietà sono collegate ai tipi, che posso essere :  primitivi: si prestano ad un uso intuitivo  reference: fanno riferimento ad oggetti, array, eccA seconda della modificabilità, possono essere.  Costanti (variabili final): dati che non possono subire alcuna modifica  Variabili : dati suscettibili di modificazioneA 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
    • CostruttoriIl costruttore è un metodo che viene eseguito 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)
    • Modificatori e costanti
    • Incapsulamento dei datiLincapsulamento permette di gestire (e nascondere) in modo miratovariabili (dati) interni alla classe, legando il loro acceso e la loro modificaall’utilizzo di una funzione (metodo) che effettui quanto richiesto inaccordo con le regolo proprie dell’oggetto e del dominio relativoIn questa classe possiamo notare che la proprietà x privata è accessibile in scrittura dal metodoscrivo() ed in lettura dal class MiaClasse { private int x; metodo leggo() public int leggo() { return x; } public void scrivo(int x) { this.x = x; } }
    • Overloading e Overriding (1)•L‘Overloading consente di definire in una stessa classe più metodiaventi lo stesso nome, ma che differiscano nella firma, cioè nellasequenza dei tipi dei parametri formali. È il compilatore che determinaquale dei metodi verrà invocato, in base al numero e al tipo dei parametriattuali.•L‘Overriding, invece, consente di ridefinire un metodo in unasottoclasse: il metodo originale e quello che lo ridefinisce hannonecessariamente la stessa firma, e solo a tempo di esecuzione si determinaquale dei due deve essere eseguito.
    • Overloading e Overriding (2)Esempio di overloading: class Esempio { int prop; public void metodo() { codice }; public int metodo() { return prop; } } Esempio di overriding: class Esempio2 exends Esempio { public void metodo() { codice2 }; }
    • Boxing e UnboxingViene utilizzato per assegnare ad un oggetto un tipo primitivo senza ricorrere a metodi di utility.Consente di velocizzare lo sviluppo di codice e di ottimizzare le prestazioni: //senza boxing Integer i1 = new Integer(100); int y1 = 20; int z1 = y1 + i1.intValue(); //con boxing Integer i2 = 100; int y2 = 20; int z2 = y2 + i2;
    • 3. JAVA, introduzione
    • Il linguaggio JAVA (1)Java si caratterizza per una miriade di specificità. Tra le piùevidenti troviamo: • orientato agli oggetti • eseguito in un ambiente protetto, ovvero dalla Java Virtual Machine (JVM) • indipendente dalla piattaforma, portabile • sicuro dal punto di vista della gestione del codice • multithreading • dinamico Java è stato creato da James Gosling ed il proprio team di ingegneri presso la Sun Microsystems, oggi acquisita da Oracle.
    • Il linguaggio JAVA (2)• Java è ad “oggetti puro”, quindi non object based come adesempio il C++• Non contempla l’aritmetica dei puntatori• Non è necessario deallocare la memoria in modo esplicito(esiste il meccanismo del “garbage collection”)• Non prevede ereditarietà multipla (solo singola) In realtà in alcuni casi è comunque utile deallocare la memoria,o meglio le risorse utilizzate, in modo esplicito.
    • Il linguaggio JAVA (3)•Con i linguaggi compilati in modo nativo, per effettuare ilporting su piattaforme diverse, è necessario utilizzare lospecifico compilatore e ricompilare il codice… sperando dinon dover apportare modifiche!
    • Il linguaggio JAVA (4), JVM Write Once, Run Anywhere•Il codice Java viene compilato in un linguaggiointermedio chiamato bytecode indipendente dallamacchina (calcolatore) su cui viene eseguito.•javac (comando) compila il codice sorgente .java ibytecode .class.•Il Bytecode, successivamente viene interpretato dauna specifica Java Virtual Machine (JVM).•Il Bytecode non è altro che una serie di istruzioni daeseguire passo-passo.
    • Il linguaggio JAVA (5), JVM• La JVM è, semplificando, un computersimulato/virtualizzato in un computer host;• La JVM trasforma il bytecode nello specificolinguaggio macchina della piattaforma di destinazione•Esistono differenti JVM per differenti piattaforme: •Windows, Mac OS X, Linux, cellulari.•Per la stessa piattaforma esistono JVM realizzati dadiversi produttori •Sun/Oracle, Microsoft, ecc.
    • Il linguaggio JAVA (6), JVM
    • Il linguaggio JAVA (6), Dinamico• Il linking (collegamento) delle classi avviene soloquando richiesto• Le classi sono normalmente “depositate” su discolocale o sulla rete•Il codice viene sempre verificato prima di esserepassato all’interprete per l’esecuzione.•E’ possibile aggiungere nuovi metodi e variabili diistanza ad una classe, senza dover ricompilarel’intera applicazione
    • Il linguaggio JAVA (7), MultiThreading•Elaborazioni simultanee in un ambiente a singoloprocesso•La gestione dei thread in genere e di tipo preemptive•Nei sistemi in cui la gestione è non preemptive Javafornisce il metodo yield() che dà, ad un altro thread,la possibilità di essere comunque eseguito•I metodi dichiarati synchronized non possono essereeseguiti simultaneamente da più thread;
    • Il linguaggio JAVA (8), Sicuro•Il compilatore esegue una serie di verifiche durante lagenerazione del bytecode: 1. controlli di errori di codifica 2. verifica dichiarazioni di tipo esplicite e non implicite 3. le classi sono inserite in un name-space per gestire la sicurezza•Inoltre (cosa ripetuta a tempo di esecuzione), viene inibito ilcodice potenzialmente pericoloso
    • Compilazione ed esecuzione (1)Primo programma in JAVA • Un programma Java è costituito da una o più classi • Ogni classe risiede in un file che ha lo stesso nome della classe ed estensione .java • Deve esistere almeno una classe che ha il nome del programma ed un metodo speciale chiamato main.
    • Compilazione ed esecuzione (2)public class HelloWorld{ public static void main (String args[]) { System.out.println(“Hello”); }}
    • Compilazione ed esecuzione (2b)Per compilare ed eseguire la classe HelloWord C:SorgentiHelloWorldjavac HelloWorld.java C:SorgentiHelloWorldjava HelloWorld Hello C:SorgentiHelloWorld
    • Compilazione ed esecuzione (3)•Il metodo main deve essere sempre presente,unico e serve per avviare l’applicazione.•Non viene utilizzato per le Applet o le servlet. public static void main(String [] args) { //blocco di istruzioni }
    • Compilazione ed esecuzione (4)• 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 istruzioni: sono le istruzioni che implementiamo
    • 3.1 JAVA, Tipi
    • Tipi Primitivi (1)Il JDK viene fornito con una serie comune di Tipi Primitivi Tipo Primitivo Dimensione boolean valori che possono essere true e false i caratteri, sono di 16 bit, e sono char codificati Unicode 1.1.5, negli altri linguaggi sono ASCII, di soli 8 bit interi di 8 bit con segno, ovvero numeri byte compresi tra meno (due alla settima) e due alla ottava short interi di 16 bit con segno int interi di 32 bit con segno long interi di 64 bit con segno reali di 32 bit in virgola mobile (IEEE 754- float 1985) reali di 64 bit in virgola mobile (IEEE 754- double 1985)
    • Tipi Primitivi (2)•Per garantire la portabilità del Bytecode da una piattaforma ad un‟altraJava fissa le dimensioni di ogni dato primitivo•I tipi primitivi mantengono le loro dimensioni in tutte le piattaformagrazie al fatto che le JVM devono essere implementate secondo specificheben definite Tipo Primitivo Dimensione Boolean 1bit Char 16bit Byte 8bit Short 16bit Int 32bit Long 64bit Float 32bit Double 64bit
    • Tipi Primitivi, Numeri interi•Il tipo int è senza dubbio il tipo primitivo più usato, per ragioni dipraticità e di efficienza. Può contenere qualunque numero intero compresotra 2.147.483.647 e -2.147.483.648, ossia tutti i numeri rappresentabili conuna cella di memoria a 32 bit•Il tipo byte permette di operare su numeri compresi tra -128 e 127, chesono i numeri che è possibile rappresentare con cifre da 8 bit•Il tipo short permette di trattare numeri a 16 bit, compresi tra -32768 e32767: è in assoluto il formato meno usato in Java•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. è necessarioposporre al numero la lettera L
    • Tipi Primitivi, Numeri floating point•Il tipo float, a 32 bit, può contenere numeri positivi e negativicompresi tra 1.40129846432481707*10^-45 e3.4282346638528860*10^38•Il tipo double a 64 bit può lavorare su numeri positivi e negativi tra4.94065655841246544*10^-324 e 1.79769313486231570*10^138•float number = 1.56e3F;•double bigNumber = 5.23423e102;
    • Tipi Primitivi, boolean•Una variabile booleana può assumere solamente due valori: “true” o“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 unespressione.Ad esempio:•boolean b = (a == 10); • assegna a b il valore di verità dellespressione a == • 10, che sarà true se la variabile a contiene il valore • 10, false in caso contrario
    • Tipi Primitivi, char (1)•Il tipo “char”può contenere un carattere in formatoUnicode che comprende decine di migliaia di caratteri, valea dire gli alfabeti più diffusi nel mondo.•I valori da 0 a 127 corrispondono, per motivi di retrocompatibilità, al set di caratteri ASCII•Il tipo char è un intero a 16 bit privo di segno, pertanto essopuò assumere qualunque valore tra 0 e 65535
    • Tipi Primitivi, char (2)Il carattere speciale “” ha il ruolo di specificare alcunicaratteri che altrimenti non sarebbe possibile specificare conla tastiera • nnuova linea • ra capo • fnuova pagina • carattere apice • "carattere doppio apice • carattere backslash • bbackspace • tcarattere di tabulazione
    • Tipi Primitivi, Casting: up and downup-casting: 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 down-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
    • Le stringhe alfanumeriche (1)In Java è possono utilizzare e gestire stringhe tramite le due classi: • String: un oggetto di tipo String è una stringa costante • StringBuffer: un oggetto di tipo StringBuffer è una stringa variabile nel contenuto e nella dimensione.La creazione di una oggetto String può essere esplicita: String S= new String(“parola”);oppure implicita (caso più comune) String S = “parola”; Se proviamo a modificare una stringa, Java consente di farlo ma, dietro le quinte, crea una nuova stringa con le modifiche richieste e aggiorna il reference di quella originale
    • La classe ObjectLa classe Object è la classe padre di tutte le classi, assegnata implicitamente dal compilatore.Ciò fa si che tutte le proprietà e i metodi di Objectsiano sempre disponibili in qualsiasi classe Es: hashCode(), equal(), lenght
    • Le stringhe alfanumeriche (2)Come tutti i Tipi, anche String ha una propria serie dimetodi: (prendiamo come riferimento “parola”) length(): ritorna la lunghezza della stringa Es: int len= s.length(); // len== 6 charAt(int i): ritorna il carattere in posizione i-esima Es:char c=s.charAt(0) // c ==“p” indexOf(char c): ritorna l‟indice della prima occorrenza del carattere indicato Es: inti=s.indexOf(„o‟) // i == 3 substring(int da,inta): ritorna una sottostringa Es: String sub = s.substring(2,4) // sub==“ro”
    • Le stringhe alfanumeriche (3)E’ possibile concatenare stringhe tramite l‟operatore String s = “Prova” + “di” + “ concatenazione”; System.out.println(s); produrrà come output: “prova di concatenazione”
    • Array (1) Molto spesso nei programmi si ha lesigenza 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: int[] temp = new int[144]; Nel prosieguo utilizzeremo come sinonimi il termine “array” e “vettore”
    • Array, dichiarazione (2) Esattamente come per le variabili semplici dobbiamo indicare un tipo ed un nome, con la differenza che, dopo aver specificato il tipo, è necessario postporre una coppiadi parentesi quadre. int[] vettoreDiInteri; La variabile “vettoreDiInteri” appena dichiarata non è un vettore, ma solamente un reference ad un vettore
    • Array, assegnamento(3) Per creare un vettore dobbiamo ricorrere alla parola riservata “new”, vettoreDiInteri = new int[10]; Il valore specificato tra parentesi quadre è la dimensione del vettore. E’ fondamentale evidenziare che un vettore è un oggetto di memoria composto da un certo numero di elementi, ognuno dei quali può contenere un valore
    • Array, dereferenziazione (4) La dereferenziazione è unoperazione 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, quindi per creare veramente un nuovo array occorre copiare il contenuto in un nuovo array
    • Array, popolamento ed inizializzazione(5) Per assegnare un valore al vettore occorrerà specificare la posizione del nuovo valore: vettoreDiInteri[1] = 10; Teniamo presente che l’indice parte da 0 e non da 1!Un vettore può essere inizializzato con una serie di valori, in modo simile a come si può fare con le variabili. Listruzione: 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;
    • Array, array bi e multi dimensionali(6) Il linguaggio Java consente di creare array bi-dimensionali, raticamente una matrice. int i[][] = new int[10][15]; 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}}; Il lignaggio permette inoltre di definire vettori con un numero qualunque di dimensioni: int v1[][][] = new int[10][15][5]; int v2[][][][] = new int[10][15][12][5]; ma di difficile lettura ed utilizzo. E’ consigliabili limitarsi agli array lineari o alle matrici.
    • Array, array non rettangolari (6) Java, infine, permette di definire array 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];
    • EnumeratoriA partire da Java 5 è possibile definire una variabile con un numeropredefinito di valori, sia come variabile nella classe e sia come classeesterna. enum Size { SMALL, BIG;}Caratteristiche:•Hanno modificatori: public static final•Ereditano metodi: • public static MyEnum valueOf(String name) • public static MyEnum[] values()
    • 3.2 JAVA, Costrutti Decisionalie Cicli Iterativi
    • Costrutti decisionali•if-else : verificano diverse espressioni e quando vieneincontrata lespressione che restituisce true viene eseguito undeterminato pezzo di codice.•switch-case: viene esaminata UNA SOLA espressione, peròa seconda del suo risultato cambia il pezzo di codice che verràeseguito.
    • Costrutti decisionali ed iterativiUn costrutto decisionale permette di vincolare lesecuzionedi unistruzione (o di un blocco di istruzioni) ad unacondizione booleana: •condizione booleana è unespressione 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 unistruzione unica
    • Costrutti decisionali, if – else (1)Il costrutto condizionale più usato in Java è lif, che può essereusato nelle due varianti con o senza else if ( condizioneBooleana ) istruzione;La variante con lelse ha una forma del tipo if ( condizioneBooleana ) istruzione1; else istruzione2;
    • Costrutti decisionali, if – else (2)Se vogliamo che venga eseguita più di una istruzione dobbiamo ricorrere ad un blocco: if ( condizioneBooleana ) { istruzione1a; istruzione2a; istruzione3a; } else { istruzione1b; istruzione2b; istruzione3b; }
    • Costrutti decisionali, if – else (3)Il costrutto if può comparire anche allinterno 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?
    • Costrutti decisionali, if – else (4)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?
    • Costrutti decisionali, if – else (5)Per creare un blocco di istruzioni if( x >= 0 ) { if( x <= 10 ) System.out.println("x compreso 0 e 10"); } else System.out.println("x è minore di 0");
    • Costrutti decisionali, if – else annidatiE 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");
    • Costrutti decisionali, if – else nidificatiE’ 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");
    • Costrutti decisionali, if – else concatenatiUna 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 lultimo else comprende tutti i casi non considerati dalle precedenti istruzioni.
    • Costrutti decisionali, Espressioni condizionaliLoperatore “?”può essere usato allinterno 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;
    • Costrutti decisionali, switch – case (1)Il costrutto switch permette di gestire tutte quelle situazioni in cui dobbiamo prendere scelte diverse a seconda del valore di unespressione switch (espressione) { case val1: istruzione_na; break; case val2: istruzione_nb;break; default: istruzione_ndefault;break; }
    • Costrutti decisionali, switch – case (2)•Lespressione contenuta tra le parentesi dello switchdeve essere di tipo intero (int, byte, short o char);•ogni istruzione case lavora su di un particolare valore, efornisce una sequenza di istruzioni da eseguire in quellacircostanza•Tale sequenza termina usualmente con listruzionebreak, che forza il computer a uscire dallo switch, senzaverificare i valori successivi.•blocco di default, ovvero una sequenza di istruzioni daeseguire se non si è verificato nessuno dei casi precedenti.
    • I Cicli iterativi•I cicli vengono abitualmente utilizzati in tutti queicasi in cui bisogna eseguire delle attività ripetitive inmodo automatica.•Abbiamo due tipi di cicli: • cicli con contatore o Cicli For, utilizzati per svolgere una data attività per un numero determinato di volte • i cicli condizionali o Cicli While, Do-While, utilizzati per eseguire unattività fino a quando una data condizione viene soddisfatta
    • I Cicli iterativi, istruzioni while La struttura generale del while è while(condizioneBooleana) { ISTRUZIONE1; ISTRUZIONE2; .... }Se si desidera che un ciclo venga ripetuto allinfinito, èsufficiente specificare una condizione sempre vera, tipo while(0 == 0) { while(true) { ISTRUZIONE1; ISTRUZIONE1; } } Se si desidera che il i = 0; ciclo venga ripetuto un while(i<=100) { ISTRUZIONI DA RIPETERE numero prefissato di i = i + 1; volte }
    • I Cicli iterativi, do-while•Dall’istruzione do-while a differenza della precedente,controlla il valore della espressione booleana alla finedel blocco di istruzioni. In questo caso quindi il blocco diistruzioni verrà eseguito sicuramente almeno una volta.La sintassi di do-while è la seguente do { istruzione; } while (espressione_booleana) { istruzione; };
    • I Cicli iterativi, for (1)per effettuare un ciclo di 10 iterazioni utilizzando il ciclo while,dovremmo scrivere qualcosa del tipo: i=0; while(i<10) { faiQualcosa(); i++; }tramite il costrutto for è possibile ottenere lo stesso risultato inmaniera decisamente più for(init_statement ; conditional_expr ; iteration_stmt) { istruzione }
    • I Cicli iterativi, for (2)•init_statement, rappresenta l‟inizializzazione dellavariabile per il controllo del ciclo•conditional_expr, l’espressione condizionale•iteration_stmt l’aggiornamento della variabile di controlloLa situazione presentata precedentemente può essere risolto utilizzando il ciclo for in questo modo: for (int i=0 ; i<10 ; i++) faiQualcosa();
    • I Cicli iterativi, foreach (1)Per semplificare il ciclo for, in java 6 è stato introdotto un ciclo specializzato che consente di ciclare su array e collection. for(declaration : expression)•declaration: variabile compatibile con il tipo di elementi della collezione•expression: collezione di elementi che può essere un array o un metodoche ritorna un array
    • I Cicli iterativi, foreach (2)Differenze tra for e foreach: int[] a = {1, 2, 3, 4}; for (int x = 0; x < a.length; x++) { System.out.print(a[x]); } for (int n : a) { System.out.print(n); }Utilizzo del for enhanced per array annidati: int[][] twoDee = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; for (int[] x : twoDee) { for (int y : x) { System.out.println(y); }}
    • 3.3 JAVA,Collection eGenerics
    • Collezioni Spesso si rende necessario raggruppare un insieme di oggetti e accedere ad essi secondo regole particolari (per esempio uno Stack o una Coda). In tali strutture dati gli Array possono non essere adeguati. 1. Soluzione 1: Realizzare una propria classe che, utilizzando internamente gli array, fornisce i metodi di accesso opportuni 2. Soluzione 2: Utilizzare classi già pronte fornite da Java, scegliendo quella più opportuna ai propri bisogni Java fornisce un insieme molto ampio di classi (concrete) in grado di collezionare oggetti fornendo un interfacce (estese dalle proprie classi) relative a Pile, Code, Insiemi, Liste, Mappe, Insiemi ordinati ecc …  (JCF) Java Collections Framework91
    • JCF (1) • Collection: • List • ArrayList • LinkedList • Vector • Set • SortedSet • TreeSet • HashSet • LinkedHashSet • Altre interfacce disponibili • Queue,Dequeue,Stack, Map, SortedMap …
    • JCF (2)• Collection • E’ in sostanza la classe base da cui derivano le specifiche tipologie di collezioni. Tra i suoi metodi primari troviamo: • boolean add(Object e) • void clear() • boolean contains(Object o) • Iterator iterator() • boolean remove(Object o) int size()• List • Una collezione ordinata di elemente (anche nota come sequeza) in cui l’utente ha una precisa conoscenza di dove l’elemento (E) viene inserito: • E get(int index) • E set(int index, E element)• Set • Collezione che non ammette valori duplicati• SortedSet • Collezione che contiene elementi ordinati
    • Collezioni… di quali oggetti? Tutti gli oggetti in java estendono da Object  E’ corretto scrivere: Object o=new Integer(10); Le collection di java gestiscono elementi di tipo Object  Esse possono contenere elementi di tipo object  quindi un qualunque oggetto java può essere aggiunto in una collezione  NB: Gli oggetti vengono ritornati come Object e non del loro tipo specifico ArrayList a=new ArrayList(); a.add(new Integer(10));//aggiungo un intero Object elem=a.get(0); //oggetto di tipo Object  Per ottenere il tipo originario è necessario il cast esplicito Integer i=(Integer) a.get(0);//cast esplicito
    • La Collection ArrayListpublic class ArrayList extends …boolean add(Object e) Aggiunge l’oggetto alla fine della listavoid add(int index, Object element) Inserisce l’oggetto nella posizione specificataObject get(int index) Ritorna l’oggetto presente nella posizione specificataObject set(int index, Object element) Sositutisce l’oggetto nella posizione specificata con quello indicatovoid clear() Svuota la listaIterator iterator() Ritorna un iteratore per ciclare sulla listaint size() Ritorna il numero di elementi presenti nella lista
    • IteratoriSi tratta di un operatore «agnostico» che permette di scorrere gli elementi di una collezioneindipendentemente dalla loro disposizione • Il metodo iterator() è disponibile in tutte classi che estendono da CollectionIterator  boolean hasNext()  Ritorna true se esiste un altro elemento  Object next()  Ritorna l’elemento successivo  void remove()  Rimuove dalla collezione l’ultimo elemento iterato
    • Esempi public static int somma(ArrayList a){ int somma=0; for (int i=0;i<a.size();i++){ Integer elem=(Integer)a.get(i) somma=somma+elem.intValue(); } return somma; } public static int somma(ArrayList a){ int somma=0; Iterator i=a.iterator(); while (i.hasNext()){ Integer val=(Integer)i.next(); somma=somma+val.intValue(); } return somma; }
    • JCF (3)public interface Collectionboolean add(Object e)  Appends the specified element to the end of this list. void add(int index, Object element)  Inserts the specified element at the specified position in this list. void clear()  Removes all of the elements from this list. Iterator iterator()  Returns an iterator over the elements in this list in proper sequence. int size()  Returns the number of elements in this list. boolean isEmpty()  Returns true if this collection contains no elements. … altri metodi
    • JCF (4) public interface List extends Collection Ereditate da Collection  boolean add(Object e)  void add(int index, Object element)  void clear()  Iterator iterator()  int size()  boolean isEmpty() E get(int index)  Returns the element at the specified position in this list. E remove(int index)  Removes the element at the specified position in this list (optional operation). E set(int index, E element)  Replaces the element at the specified position in this list with the specified element (optional operation). … altri metodi
    • JCF (5)• public class ArrayList …implements List  public class Vector …implements List• Ereditate da List  Ereditate da List • boolean add(Object e)  boolean add(Object e) • void add(int index, Object element)  void add(int index, Object element) • void clear()  void clear() • Iterator iterator()  Iterator iterator() • int size()  int size() • boolean isEmpty()  boolean isEmpty() • E get(int index)  E get(int index) • E remove(int index)  E remove(int index) • E set(int index, E element)  E set(int index, E element)• … altri metodi  … altri metodi  Analogo ad ArrayList ma l’implementazione è thread-safe ed è in genere più lenta
    • JCF (6)public class LinkedList …implements List Ereditate da List  boolean add(Object e)  void add(int index, Object element)  void clear()  Iterator iterator()  int size()  boolean isEmpty()  E get(int index)  E remove(int index)  E set(int index, E element) E getFirst()  Returns the first element in this list. E getLast()  Returns the last element in this list. … altri metodi NB: L’implementazione di get e set hanno costo O(n)
    • Il problema della mancata tipizzazioneIl problema della mancata tipizzazione (alias utilizzo di Object) 1. Necessità di ricorrere al cast degli elementi anche quando il tipo di elementi è noto ArrayList a=new ArrayList(); a.add(new Integer(10)); ... Integer i=(Integer)a.get(0); 2. Possibili cast degli elementi a tipi non corretti ArrayList a=new ArrayList(); a.add(new Integer(10)); ... String i=(String)a.get(0);//eccezione!!! 3. Nessun controllo sui tipi di dati inseriti all’interno di un vettore ArrayList a=new ArrayList(); a.add(new Integer(10)); ... a.add(new String(“paperino”));//? Integer i=(Integer)a.get(0);//OK Integer j=(Integer)a.get(1);//cast exception 4. Poca chiarezza sul tipo di dati trattati public static ArrayList calcolaQualcosa() //che tipi contiene? In tutti i casi, il codice risulta sintatticamente corretto e non viene segnalato alcun errore dal compilatore. L’errore viene scoperto solo a Runtime!
    • I GenericsProgrammazione generica: creazione di costrutti di programmazione che possano essere utilizzati con tipi di dati diversi.In Java si può raggiungere l’obiettivo della programmazione generica usando l’ereditarietà oppure le variabili di tipo. Esempio: ArrayList di Java  ArrayList<String>Classe generica: è stata dichiarata usando una variabile di tipo E.La variabile di tipo rappresenta il tipo degli elementi: public class ArrayList<E> // si può usare "ElementType" invece di E { public ArrayList() { . . . } public void add(E element) { . . . } ... }Le variabili di tipo possono essere sostituite, all’atto della creazione di esemplari, con nomi di classe o di interfacce ArrayList<String> ArrayList<MyClass> Non si può usare come sostituto uno degli otto tipi di dati primitivi ArrayList<double> // Sbagliato! Usate un esemplare di ArrayList<Double>
    • I Generics: la gerarchia
    • I Generics (2)• Il tipo di dato indicato va a sostituire la variabile di tipo utilizzata nella definizione dell’interfaccia o della classe generica Esempio: nel metodo add di un oggetto di tipo ArrayList<String> la variabile di tipo E viene sostituita dal tipo String • public void add(String element)• Le variabili tipizzate rendono più sicuro e di più facile comprensione il codice generico.  E’ impossibile aggiungere un oggetto di tipo Integer ad un esemplare di ArrayList<String>  È invece possibile aggiungere un oggetto di tipo Integer ad un esemplare di ArrayList (senza generics) che sia stato creato con l’intenzione di usarlo per contenere stringhe
    • I Generics (3) ArrayList<String> a1 = new ArrayList<String>(); Integer numero=new Integer(30); // Dovrebbe contenere oggetti di tipo String ArrayList a2 = new LinkedList(); // errore di compilazione a1.add(numero); // errore non individuato dal compilatore a2.add(numero); //errore di esecuzione String account = (String) a2.get(0);
    • I Generics (4) ArrayList<E>  boolean add(E e)  void add(int index, E element)  E get(int index) public static int somma(ArrayList<Integer> a)  E set(int index, E element) {  void clear() int somma=0; for (int i=0;i<a.size();i++){  Iterator<E> iterator() Integer elem=a.get(i)  int size() somma=somma+elem.intValue(); } return somma; Iterator<E> }  boolean hasNext()  E next()  void remove()
    • I Generics (5)• Collection<E>: • List<E> • ArrayList<E> • LinkedList<E> • Vector<E> • Set<E> • SortedSet<E> • TreeSet<E> • HashSet<E> • LinkedHashSet<E>• Altre interfacce disponibili • Queue<E>,Dequeue<E>,Stack<E>, Map<K,V>, SortedMap<K,V> …
    • 3.4 JAVA,Packaging edocumentazione
    • I membri dei PackageI Package permettono sostanzialmente di organizzare ilcodice in una sorta di contenitori in cui vengono inglobateclassi omogenee: • caratteristiche in comune (java.io) • appartengono allo stesso progetto (it.fastweb.crm.om.) • vengono prodotte dalla stessa societa (com.cedati)
    • I membri dei PackageI packages sono identificati dallistruzione package,che deve apparire come la prima istruzione nel file del codice sorgente. package mioPackage; public class MiaClasse { ........... }
    • Uso delle classi del Package (1)Un membro pubblico (classe, interfaccia, ecc) di un package può essereutilizzato in tre modi diversi: 1. attraverso il suo nome completo 2. importandolo 3. importando l‟intero package a cui il membro appartiene
    • Uso delle classi del Package, nomecompleto (2)Indichiamo: •nome del package •l’operatore: che ci permette di entrare internamente nel package •il nome della classe public class Classe { mioPackage. MiaClasse fg; }
    • Uso delle classi del Package,nome della singola classe (3)Indichiamo: •import seguito del nome del package seguito dalla classe •dichiariamo l‟oggetto fg nel modo classico import mioPackage.MiaClasse; public class Classe { MiaClasse fg; }
    • Uso delle classi del Package, import dell’interopackage (3)Indichiamo: •import di tutte le classi del package attraverso il simbolo “*” •dichiariamo l‟oggetto fg import mioPackage.*; public class Classe { MiaClasse fg; }
    • Salvare e compilare una classe di un package• 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 mioPackagemioEsempio c:mioPackagemioEsempio>dir MiaClasse.java c:mioPackagemioEsempio> javac MiaClasse.java c:mioPackagemioEsempio>dir MiaClasse.java MiaClasse.class
    • Eseguire una classe del package• Per eseguire 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:mioPackagemioEsempio>dir MiaClasse.java MiaClasse.class c:>java mioPackage.mioEsempio.MiaClasse
    • Import e Import statici• Mentre l‟istruzione import consente di importare le classi o interfacce, l‟import statico consente di importare proprietà static di una classe: import static java.lang.System.out; public class ProvaImportStatic { public static void main(String[] args) { out.println("Hello"); } }
    • Documentazione e javadoc• E‟ possibile generare direttamente dai sorgenti java la documentazione dello sviluppo.• I commenti al codice vengono inseriti nella documentazione per essere leggibili dal browser.• Per fare questo si utilizza l‟utility presente nel JDK dal nome “javadoc”
    • Documentazione e javadoc• Partiamo da una classe appositamente commentata:/** Classe di Prova **/public class Prova { /** Proprietà privata x **/ private int x = 0; /** Descrione del metodo **/ public String metodo(int t) throws Exception { return ""; }}
    • Documentazione e javadoc
    • Annotazioni (1)•Le annotazioni possono essere create per “annotare” degli aspettiimportanti del programma in modo da rendere il codice più leggibile.•Vengono usate spesso per passare delle note al compilatore in modotale che questi possa svolgere il proprio compito in un modo piùefficiente.“annotazione” nel codice:public class MiaProva { @Deprecated public void metodoConNotazione(){}}public class Avvio{ public static void main(String [] args ){ new MiaProva().metodoConNotazione(); }}
    • Annotazioni (2)• Abbiamo questo output:
    • Annotazioni (3)Creiamo una nostra “annotazione” ed usiamola nel codice: public @interface ProvaAnnotazione { String nome(); } public class MiaProva { @ProvaAnnotazione(nome="primaAnnotazione") public void metodoConNotazione(){} }
    • 3.5 JAVA,Gestione deglierrori
    • Meccanismo vincolante delle eccezioni• 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.
    • Meccanismo vincolante delle eccezioniUna eccezione potrà essere:• gestita attraverso gli exception handler• propagata lungo lo stack delle chiamate dei metodiUn exception handler è composto da tre parti principali:• un blocco try• uno o più blocchi catch (opzionali)• un blocco finallyNel caso si decida di propagare una eccezione lungo lo stack delle chiamate occorre utilizzare la parola chiave throws al metodo.• La propagazione dell‟eccezione consente ad un metodo di non doversi preoccupare di gestirlo.• Se i metodi chiamanti non hanno previsto la gestione dell‟errore, allora il programma si interromperà
    • Le eccezioni di RunTime• Alcune eccezioni possono verificarsi a causa di errori di coloro che utilizzano il programma e non ad opera di coloro che l‟hanno realizzato.• Possono sempre presentarsi ed il programmatore può semplicemente provare a gestirle ma non può impedirle.
    • Eccezioni personalizzate• 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; public ElementoInesistenteException(String nome) { super("Non esiste alcun elemento" + nome); nomeElemento = nome; } }
    • 3.6 JAVA,librerie di base J2SE
    • Il package java.lang• Il package java.lang è importato di default in quanto contiene la struttura di base per la creazione di una classe java.• E‟ composto da: interfacce: Cloneable, Comparable, Runnable classi: Wrapper( Byte, Short, Integer, Long, Float, Double, Boolean, Character, Void ) String, System, Thread, Object, Runtime, SecurityManager, eccezioni: Throwable
    • Il package java.util• Il package java.util contiene delle classi di utility che servono al programmatore per implementare i propri algoritmi.• Per esempio: liste ordinate/casuali con valori unici/duplicati, tabelle di elementi, calendari, comparatori di elementi, gestori della localizzazione geografica• interfacce/classi: List, Set, Map, Collection, Iterator, Enumeration, Calendar, Comparator, Local
    • Il package java.text• Il package java.text permette di convertire oggetti in testo e viceversa.• Per esempio: DateFormat, DecimalFormat, MessageFormat, NumberFormat,