Sviluppo Applicazioni Mobile Lezione 8. Dr. Paolo Casoto, Ph.D

Transcript

1 + Sviluppo Applicazioni Mobile Lezione 8 Dr. Paolo Casoto, Ph.D

2 + Credits I lucidi di questa lezione sono stati preparati da: Professor Stefano Mizzaro Professor Paolo Coppola e sono stati modificati e completati dal Dr. Paolo Casoto nel Sono rilasciati con licenza Creative Commons Attribuzione, non commerciale e non opere derivate. Dr. Paolo Casoto, Ph.D

3 + Programmazione strutturata Mattoni Strutture di controllo Sequenza, Selezione, Iterazione Cicli annidati Array (unidimensionali, multidimensionali) Sottoprogrammi (metodi) Parametri formali e attuali Pila dei record di attivazione Ricorsione Dr. Paolo Casoto, Ph.D

4 + Altro Pila dei record di attivazione, heap Attività del programmatore Sviluppo incrementale Ciclo editing-compilazione-esecuzione Testing Bast-Che-Funz chi se ne frega di come è scritto un programma, basta che funzioni NO! DOVETE imparare a scrivere programmi di buona qualità Anche chi pensa di saper già programmare Dr. Paolo Casoto, Ph.D

5 + Oggi Tipi di Dato Astratto (TDA) Primi concetti Definizione di un TDA Uso di un TDA Principio dell Occultamento delle informazioni Introduzione, ne parleremo anche nella prossima lezione Dr. Paolo Casoto, Ph.D

6 + TDA Tipo di Dato Astratto (TDA) Abstract Data Type (ADT) I metodi (procedure e funzioni) possono essere visti come un modo per estendere il linguaggio di programmazione appena definito un nuovo metodo, è come se il linguaggio avesse una nuova istruzione È un meccanismo di astrazione: astraggo dai dettagli pensando al livello delle nuove istruzioni Ne esiste un altro... Migliore (vedremo perché) Dr. Paolo Casoto, Ph.D

7 + Struttura programma Java? lass... { static <tipo> <id> (<parametri>) {... static <tipo> <id> (<parametri>) {... public static void main (String[] args) {... static <tipo> <id> (<parametri>) {... static <tipo> <id> (<parametri>) {... Stefano Mizzaro - TDA Dr. Paolo Casoto, Ph.D

8 + Un altro meccanismo di astrazione: i TDA Possiamo estendere il linguaggio definendo nuovi tipi di dato Per farlo bisogna: definire come sono fatti decidere quali operazioni sono lecite su di essi (Tipo = valori + operazioni) Per definire un nuovo tipo di dato si deve specificare una classe il nome della classe rappresenterà il nuovo tipo una classe definisce le sue variabili e i suoi metodi Dr. Paolo Casoto, Ph.D

9 + Definire TDA: la sintassi class <NomeDelTDA> { <tipo1> <var1>; <tipo2> <var2>; static <tipometodo1> <nomemetodo1>(<parametri1>) {... static <tipometodo2> <nomemetodo2>(<parametri2>) { Dr. Paolo Casoto, Ph.D

10 + Convenzione sugli identificatori Gli identificatori Java vanno scritti con l iniziale maiuscola se sono nomi di classi con l iniziale minuscola se sono nomi di variabili o di metodi se l identificatore è formato da più parole, queste vanno scritte attaccate e ogni parola deve iniziare con la maiuscola Esempi: Classe1, variabile1, metodo1, AltroNomeDiClasse, altronomedivariabile, altronomedimetodo, nome_sbagliato Dr. Paolo Casoto, Ph.D

11 + Esempio 1: classe coordinate Definire un nuovo tipo che rappresenta le coordinate di un punto del piano cartesiano Decidiamo il nome della classe: Coordinate Decidiamo quali informazioni/ dati saranno presenti nella classe: x, y class Coordinate { int x; int y; oppure class Coordinate { double x; double y; Dr. Paolo Casoto, Ph.D

12 + Esempio 2: classe ora Definire un nuovo tipo che rappresenta un ora del giorno Decidiamo il nome della classe: Ora Decidiamo quali informazioni/dati saranno presenti nella classe: ore, minuti, secondi oppure secondi trascorsi dalla mezzanotte class Ora { int ore; int minuti; int secondi; oppure class Ora { int secondi; Dr. Paolo Casoto, Ph.D

13 + Esempio 3: classe freccia orizzontale Definire un nuovo tipo che rappresenta una freccia orizzontale Decidiamo il nome della classe: FrecciaOrizzontale Decidiamo quali informazioni/dati saranno presenti nella classe: lunghezza, verso class FrecciaOrizzontale { int lunghezza; char verso; oppure class FrecciaOrizzontale { int lunghezza; boolean versodestra; Dr. Paolo Casoto, Ph.D

14 + Usare TDA Una volta definita una classe abbiamo un nuovo tipo (non abbiamo scritto un programma; non c è un main) e possiamo usarlo! Ora si possono: dichiarare variabili di quella classe (di quel tipo) creare nuovi valori (istanze) usare le variabili (in un altra classe/file ad es. nel main vedremo) Dr. Paolo Casoto, Ph.D

15 + Dichiarazione Analogamente a come si dichiarano le variabili con tipo primitivo: int x, k, count; Coordinate punto, coppia, pluto; Ora oradelgiorno, pippo; Dichiarare una variabile non basta. Per usare un TDA bisogna creare esplicitamente un valore Bisogna allocare dello spazio in memoria Lo spazio per i tipi primitivi invece viene allocato in modo automatico Dr. Paolo Casoto, Ph.D

16 + L istruzione new Dichiarazione e istanziazione/allocazione: Coordinate punto; punto = new Coordinate(); oppure, in una sola riga: Coordinate punto = new Coordinate(); new Alloca lo spazio nello heap per una nuova istanza Viene creato un nuovo oggetto (che verrà riferito dalla variabile) Vi ricorda qualcosa? Dr. Paolo Casoto, Ph.D

17 + Istanziazione/allocazione Dichiarazione: Coordinate punto; Istanziazione: punto = new Coordinate(); punto... x y Pila dei record di attivazione Heap Dr. Paolo Casoto, Ph.D

18 + La notazione puntata Una volta dichiarata una variabile e istanziato un TDA, si può accedere ai suoi attributi, ovvero alle variabili, usando questa sintassi: variabiletda.variabilecomponente I metodi dei TDA invece si invocano premettendo il nome della classe: TDA.metodo(parametri) Esempi punto.x = 2; punto.y = 3 + punto.x; System.out.println(punto.y); Dr. Paolo Casoto, Ph.D

19 + Esempio 1 Scrivere un programma che crea due punti le cui coordinate sono lette da tastiera usando la classe Leggi e stampa la distanza tra i due punti Per calcolare la radice quadrata usate la funzione Math.sqrt Dr. Paolo Casoto, Ph.D

20 + Stefano Mizzaro - TDA Dr. Paolo Casoto, Ph.D

21 + Dr. Paolo Casoto, Ph.D

22 + Esempio 2 Scrivere un programma che legge da tastiera un ora del giorno e la stampa... Ora x = new Ora(); //Legge un ora del giorno x.ore = Leggi.unInt(); x.minuti = Leggi.unInt(); x.secondi = Leggi.unInt(); System.out.println( Sono le +x.ore+ : +x.minuti+. +x.secondi);... Dr. Paolo Casoto, Ph.D

23 + Esempio 2 Con l altra definizione della classe Ora... Ora x = new Ora(); //Legge un ora del giorno int ore = Leggi.unInt(); int minuti = Leggi.unInt(); int secondi = Leggi.unInt(); x.secondi = ore*3600+minuti*60+secondi; System.out.println( Ora sono le +(x.secondi/3600)+ : +((x.secondi%3600)/60)+. +(x.secondi%60));... Dr. Paolo Casoto, Ph.D

24 + Esempio 3 Scrivere un programma che legge da tastiera la lunghezza e il verso di una freccia e poi la stampa... FrecciaOrizzontale x = new FrecciaOrizzontale(); //Legge lunghezza e verso x.lunghezza = Leggi.unInt(); x.verso = Leggi.unChar(); if (x.verso == s ) System.out.print( < ); for (int i=0; i<x.lunghezza; i++) System.out.print( - ); if (x.verso == d ) System.out.println( > ); else System.out.println();... Dr. Paolo Casoto, Ph.D

25 + Esempio 3 Oppure, con l altra definizione della classe FrecciaOrizzontale... FrecciaOrizzontale x = new FrecciaOrizzontale(); //Legge lunghezza e verso x.lunghezza = Leggi.unInt(); char verso = Leggi.unChar(); x.versodestra = (verso == d ); if (!x.versodestra) System.out.print( < ); for (int i=0; i<x.lunghezza; i++) System.out.print( - ); if (x.versodestra) System.out.print( > ); System.out.println();... Dr. Paolo Casoto, Ph.D

26 + L occultamento delle informazioni (1/2) Negli esempi precedenti non è evidente il vantaggio di usare i TDA L astrazione è ancora limitata Per usare un TDA si fa riferimento direttamente a come è fatto (alla sua implementazione) Mancano le operazioni del tipo Negli esempi: cambio definizione della classe => cambiare anche il codice che usa quei TDA Dr. Paolo Casoto, Ph.D

27 + L occultamento delle informazioni (2/2) Due aspetti: Bisogna nascondere l implementazione dei TDA L accesso e la modifica delle variabili interne avviene solo tramite metodi (le operazioni del tipo) In questo modo si realizza un astrazione maggiore: chi userà la classe dovrà conoscere solo l insieme dei metodi (la sua interfaccia) non come è fatto dentro (l implementazione) Tipo di dato astratto: si astrae dall implementazione (quando si usa) Dr. Paolo Casoto, Ph.D

28 + I modificatori In Java si possono nascondere le variabili di una classe usando il modificatore private Esempio: class Coordinate { private int x; private int y; Dr. Paolo Casoto, Ph.D

29 + Variabili private Se una variabile è dichiarata privata, può essere riferita solo nei metodi della sua classe Non è visibile al di fuori della classe Se un metodo di un altra classe prova ad accedere ad una variabile privata, il compilatore segnala un errore Se si nascondono le variabili di una classe, si devono aggiungere dei metodi per modificarle Le operazioni del tipo Dr. Paolo Casoto, Ph.D

30 + Esempio 1 Stefano Mizzaro - TDA Dr. Paolo Casoto, Ph.D

31 + Esempio 2 Dr. Paolo Casoto, Ph.D

32 + Esempio 2: altra implementazione Dr. Paolo Casoto, Ph.D

33 + Esempio 2: vantaggi dell occultamento/astrazione Dr. Paolo Casoto, Ph.D

34 + TDA: l idea Tipo di Dato Astratto (TDA) Abstract Data Type (ADT) L idea è: Programma che gestisce numeri complessi => aggiungo il tipo di dato astratto NumeroComplesso Programma dell anagrafe => aggiungo i TDA Persona, Indirizzo, Data, Non aggiungo al Java i metodi che non ha ma aggiungo al Java i tipi che non ha E poi li uso astraendo dall implementazione È un meccanismo di astrazione

35 + TDA: i concetti (1/2) Astrazione: nuovo tipo (non nuova istruzione) Definire Come sono fatti (attributi): implementazione Operazioni (metodi, per ora static): interfaccia class Usare Dichiarazione E allocazione, sullo heap new (ricorda qualcosa?) Notazione puntata (ricorda qcosa?) Non solo per accedere alle componenti Anche per invocare i metodi

36 + TDA: i concetti (2/2) Occultamento delle informazioni (dell implementazione) Information (implementation) hiding Cambio implementazione cambio uso? NO!! private Operazioni di accesso con metodi Astratto = si astrae dall implementazione quando si usa Limitazione alla libertà del programmatore? Sì, ma positiva! Divide et impera (anche con i metodi) Riuso (i TDA creati per un programma spesso funzionano anche per altri programmi; i metodi no)

37 + Esempio: definizione e uso class Ora { private int secondi; static void impostaora(ora x, int o, int m, int s) { x.secondi = o*3600+m*60+s; static int getore(ora x) {return x.secondi/3600; static int getminuti(ora x) { return (x.secondi%3600)/60; static int getsecondi(ora x) {return x.secondi%60; class UsaOra { public static void main(string[] args) {... Ora h = new Ora(); Ora.impostaOra(h,12,22,31); System.out.println("Sono le ore +Ora.getOre(h));... Stefano Mizzaro - TDA 2

38 + Terminologia Tipi TDA Classi Variabili (Valori, Istanze, Oggetti) Attributi Incapsulamento = unitarietà + inaccessibilità Unitarietà: raggruppamento definizione in un unico punto Inaccessibilità: dell implementazione

39 + Il costruttore Le classi hanno un metodo particolare, il costruttore, che viene invocato quando si istanzia un TDA Essendo il primo metodo della classe che viene eseguito, di solito viene usato per inizializzare la variabile creata Il costruttore è un metodo strano : ha (deve avere) lo stesso nome della classe e non ha un tipo restituito (nemmeno void) viene invocato in modo strano (con la new)

40 + Esempio

41 + Costruttori

42 + Esempio: il TDA Ora lass Ora { private int ore, minuti, secondi; Ora(int o, int m, int s) { ore = o; minuti = m; secondi = s; static void setora(ora x, int o, int m, int s){ x.ore = o; x.minuti = m; x.secondi = s; static void setora(ora x, int o, int m) { setora(x,o,m,0); static int getore(ora x) {return x.ore; static int getminuti(ora x) {return x.minuti; static int getsecondi(ora x){return x.secondi; Stefano Mizzaro - TDA 2

43 + Esempio: uso del TDA Ora Qs. è un caso banale, immaginarsi in generale.. lass UsaOra { public static void main(string[] args) { Ora x = new Ora(12,32,05); Ora y = new Ora(Ora.getOre(x), 20, 3); System.out.println(Ora.getMinuti(y)); Ora.setOra(y, 20, 4); System.out.println(Ora.getOre(y) + : + Ora.getMinuti(y) + : + Ora.getSecondi(y));

44 + Esercizi Che cosa fa il seguente costruttore? Ora(int o) { ore = o; minuti = 0; secondi = 0; E questo? Ora(Ora o) { ore = o.ore; minuti = o.minuti; secondi = o.secondi;

45 + Costruttori Un costruttore può avere parametri di ogni tipo, anche della sua stessa classe Può invocare altri metodi Anche della stessa classe, ma attenzione! Quando si deve creare un istanza di una certa classe, si deve invocare uno dei suoi costruttori Se non è stato specificato nessun costruttore allora si può usare quello senza parametri (che c è automaticamente ), altrimenti si deve usare uno di quelli definiti

46 + Esempi Se la classe è: class Coordinate { private int x, y; si deve scrivere Coordinate p = new Coordinate(); Se invece è: class Coordinate { private int x, y; Coordinate(int a, int b) { x = a; y = b; si deve scrivere Coordinate p = new Coordinate(2,3); Il costruttore automatico c è solo se non c è nessun altro costruttore

47 + Ancora esempi Se, infine, la classe ha entrambi i costruttori: class Coordinate { private int x, y; Coordinate() {x = 0; y = 0; Coordinate(int a, int b) {x = a; y = b; si possono scrivere entrambe le istruzioni: Coordinate p = new Coordinate(); Coordinate q = new Coordinate(0,0);

48 + Esempio Freccia

49 + Visibilità Nei costruttori precedenti ho dovuto inventare nomi di parametri che fossero diversi da quelli delle variabili della classe Cosa succede se usiamo gli stessi nomi? class Coordinate { private int x, y; Coordinate(int x, int y) { x = x; y = y;

50 + Il this Regola di visibilità Se nomi dei parametri = nomi degli attributi Gli attributi vengono nascosti (del costruttore, o di qualsiasi altro metodo) Per accedervi occorre specificare che sono le variabili di questo oggetto, con la parola riservata this: Coordinate(int x, int y){ this.x=x; this.y=y; «assegno alla variabile x di questo oggetto il valore del parametro x, assegno alla variabile y di questo oggetto il valore del parametro y» Coordinate(int x, int y) {x = x; y = y; «assegno al parametro x il valore del parametro x»... e quindi non modifico la variabile x della classe!

51 + Riassunto visibilità Variabili locali a un blocco for (int i = ) Variabili locali a un metodo static void m(int x){ int y... Variabili locali a una classe class C { int x... public (o niente): visibili anche all esterno della classe private: solo all interno della classe Stefano Mizzaro - TDA 2

52 + Il this this può essere usato anche per riferirsi ad un altro costruttore (sovraccarico). Esempio: class Coordinate { private int x, y; Coordinate(int x, int y) { this.x = x; this.y = y; /** costruttore che crea un oggetto con * coordinate uguali */ Coordinate(int a) {this(a,a); Stefano Mizzaro - TDA 2 questo costruttore

53 + Costruttori e metodi sovraccarichi A cosa servono? Semplificano uso e allocazione delle variabili del TDA Evitare duplicazione del codice Con il this, o invocando altri metodi Può essere comodo, ma non esagerare oordinate c = new Coordinate(); oordinate c = new Coordinate(0); oordinate c = new Coordinate(0,0); Stefano Mizzaro - TDA 2

54 + Scaletta Costruttore this Metodi/costruttori sovraccarichi (overloaded) tostring Procedurale vs. funzionale Esempi Stefano Mizzaro - TDA 2

55 + Il metodo tostring Chi deve avere la conoscenza/responsabilità di sapere come visualizzare il valore di un TDA? La classe! (cfr. Ora e UsaOra: scomodo!) Si potrebbe definire un metodo nel TDA static void print(...)... ma si preferisce definire (vedremo perché) static String tostring(...) che restituisce una rappresentazione visualizzabile dell istanza (Vedremo l invocazione automatica di tostring) tostring verrà invocato nell istruzione System.out.print o println In questo modo è possibile specificare come verranno visualizzati gli oggetti di una certa classe Stefano Mizzaro - TDA 2

56 + tostring tostring restituisce la rappresentazione dell oggetto in forma di stringa. Ad es. : class Coordinate { private int x, y;... static String tostring(coordinate c){ return ( + c.x +, + c.y + ) ; class UsoCoordinate { Coordinate a = new...;... System.out.println(Coordinate.toString(a)); Stefano Mizzaro - TDA 2

57 + Ora.java lass Ora { private int ore, minuti, secondi; Ora(int ore, int minuti, int secondi) { this.ore=ore; this.minuti=minuti; this.secondi=secondi; static void impostaora(ora x, int ore, int minuti, int secondi) { x.ore = ore; x.minuti = minuti; x.secondi = secondi; static int getore(ora x) {return x.ore; static int getminuti(ora x) {return x.minuti; static int getsecondi(ora x) {return x.secondi; static String tostring(ora x) { return x.ore+":"+x.minuti+"."+x.secondi;

58 + UsaOra.java lass UsaOra { public static void main(string[] args) { Ora x = new Ora(10,2,3); System.out.println(Ora.toString(x)); Ora.impostaOra(x,12,2,0); System.out.println(Ora.getMinuti(x)); 2 10:2.3 (basterà scrivere System.out.println(x); vedremo come)

59 + Pila (di interi limitata) Pila (stack): struttura dati a gestione LIFO (Last In First Out, il primo che entra è l ultimo che esce) Operazioni: push: aggiungi un elemento in cima top: restituisce l elemento in cima pop: rimuove un elemento dalla cima piena: dice se c è ancora posto vuota: dice se è vuota Vediamo una versione semplice: la pila limitata di interi C è un numero massimo di elementi Quindi potremo implementarla con un array

60 + Segnatura del TDA Pila

61 + Pila.java (1/2) Stefano Mizzaro - TDA 2

62 + Pila.java (2/2)

63 + ProvaPila.java /** Programma per la prova della classe Pila. */ class ProvaPila { public static void main (String[] args) { Pila p1 = new Pila(); p1 = Pila.push(p1,1); p1 = Pila.push(p1,2); p1 = Pila.push(p1,3); p1 = Pila.push(p1,4); System.out.println(Pila.top(p1)); p1 = Pila.pop(p1); p1 = Pila.pop(p1); System.out.println(Pila.top(p1)); p1 = Pila.push(p1,5); System.out.println(Pila.top(p1)); Stefano Mizzaro - TDA 2

64 + public o non public Per ora non fa differenza Se non c è il private attributi e metodi sono visibili dal resto del programma al di fuori della classe (la differenza la vedremo più avanti: con il public sono più visibili ) L unico che è necessario è quello del main Esercizio: dato un programma funzionante a vostra scelta, provate a togliere il public del main, a compilare e ad eseguire Il private è importante

65 + Funzionale e procedurale Nella versione precedente i metodi sono funzioni Alcuni potrebbero essere procedure push, pop Lavorano per effetto collaterale (side effect) sui parametri (Parametri che non sono tipi primitivi: viene passato il riferimento per valore => modifiche al parametro attuale si ripercuotono sul parametro formale) Esercizio: rivedere la versione funzionale ed eliminare i side effect

66 + PilaP.java (procedurale) lass PilaP {... //... come prima... /** push dell'elemento e sulla pila p */ static void push (PilaP p, int e) { if (!piena(p)) p.elementi[p.numelementi++] = e; /** Elimina un elemento dalla cima della pila * p */ static void pop(pilap p) { if(!vuota(p)) p.numelementi--;

67 + ProvaPilaP.java (procedurale) /** Programma per la prova della classe PilaP. */ class ProvaPilaP { public static void main (String[] args) { PilaP p1 = new PilaP(); PilaP.push(p1,1); PilaP.push(p1,2); PilaP.push(p1,3); PilaP.push(p1,4); System.out.println(PilaP.top(p1)); PilaP.pop(p1); PilaP.pop(p1); System.out.println(PilaP.top(p1)); PilaP.push(p1,5); System.out.println(PilaP.top(p1));

68 + Funzionale procedurale (1/2) Definizione metodo ublic static Pila push (Pila p, int e) { if (!piena(p)) p.elementi[p.numelementi++] = e; return p; ublic static void push (PilaP p, int e) { if (!piena(p)) p.elementi[p.numelementi++] = e;

69 + Funzionale procedurale (2/2) class ProvaPila { public Invocazione static metodo void main (String[] args) { Pila p1 = new Pila(); p1 = Pila.push(p1,1);... p1 = Pila.push(Pila.push(p1,1),2); p1 = Pila.pop(p1); class ProvaPilaP { public static void main (String[] args) { PilaP p1 = new PilaP(); PilaP.push(p1,1);... PilaP.pop(p1);

70 + Domande??? Grazie a tutti per l attenzione Dr. Paolo Casoto, Ph.D