Implementare le classi

Transcript

1 Implementare le classi C. Horstmann Fondamenti di programmazione e Java 2 3^ edizione Apogeo trad. Nicola Fanizzi corso di Programmazione, CdS: Informatica TPS Dip. di Informatica, Università degli studi di Bari

2 Obiettivi 2 Familiarizzare col processo di implementazione delle classi Essere in grado di implementare semplici metodi Capire lo scopo e l'uso dei costruttori Capire come accedere campi d'istanza e variabili locali Sperimentare l'importanza dei commenti per la documentazione

3 Scatole Nere 3 Una scatola nera fa il suo lavoro come per magia Nasconde il lavoro all'interno Incapsulamento: nascondere i dettagli meno importanti Qual è il giusto concetto per ogni particolare scatola nera?

4 Scatole Nere 4 I concetti si scoprono attraverso un meccanismo di astrazione astrazione: togliere caratteristiche inessenziali finché rimane solo l'essenza del concetto Nella programmazione orientata agli oggetti le scatole nere con cui si costruiscono i programmi sono dette oggetti

5 Livelli di Astrazione: 5 Esempio dal Mondo Reale Scatole nere in un'auto: trasmissione centralina elettronica ecc...

6 Livelli di Astrazione: 6 Esempio dal Mondo Reale Gli utenti di un'auto non han bisogno di capire come funzionano nei dettagli queste scatole nere L'interazione di una scatola nera con il mondo esterno è ben definita: I guidatori interagiscono con l'auto usando pedaliera, bottoni, ecc. Un meccanico sa controllare che la centraline mandi i giusti segnali di accensione alle candele Per i produttori di centraline i transistor e condensatori sono scatole nere prodotte da un'azienda di componenti elettronici

7 Livelli di Astrazione: 7 Esempio dal Mondo Reale L'incapsulamento porta all'efficienza: I meccanico si preoccupa solo dei componenti dell'automobile (es. centralina), non dei sensori o dei transistor Il guidatore si preoccupa solo dell'interazione con la macchina (es. fare benzina), non del motore o delle parti elettroniche

8 Livelli di Astrazione: 8 Progettazione di Software

9 Livelli di Astrazione: 9 Progettazione di Software Passato: programmi che manipolavano tipi primitivi come numeri e caratteri Manipolare troppe di tali quantità primitive diventa difficile per i programmatori e porta ad errori Soluzione: Incapsulare i calcoli di routine in scatole nere di tipo software

10 Livelli di Astrazione: 10 Progettazione di Software L'astrazione serve ad inventare tipi di dato di alto livello Nella programmazione object-oriented, gli oggetti sono le scatole nere Incapsulamento: Il programmatore che usa un oggetto deve conoscere il suo comportamento esterno, non necessariamente la sua struttura interna

11 Livelli di Astrazione: 11 Progettazione di Software Nella progettazione di software design, si possono progettare buone o cattive astrazioni con la stessa facilità Comprendere la buona progettazione è una parte importante nella formazione di un ingegnere del software Occorre prima: definire il comportamento di una classe dopo: implementarlo

12 Progettazione dell'interfaccia 12 Pubblica Comportamento di un conto bancario (astrazione): Depositare denaro Ritirare denaro Chiedere il saldo

13 Progettazione dell'interfaccia 13 Pubblica: Metodi Metodi della classe BankAccount: deposit withdraw getbalance Vogliamo supportare le chiamate al metodo simili alla seguente: harryschecking.deposit(2000); harryschecking.withdraw(500); System.out.println(harrysChecking.getBalance());

14 Progettazione dell'interfaccia 14 Pubblica: Definizione dei Metodi Specificatore di accesso (come public) Tipo di ritorno (come String oppure void) Nome di metodo (come deposit) Lista dei parametri (double( amount per deposit) Corpo del metodo tra { }

15 Progettazione dell'interfaccia 15 Pubblica: Definizione dei Metodi Esempi public void deposit(double amount) {... } public void withdraw(double amount) {... } public double getbalance() {... }

16 Sintassi 3.1: Definizione dei 16 Metodi specificatoreaccesso tiporitorno nomemetodo (tipoparametro nomeparametro,...). { corpometodo } Esempio: public void deposit(double amount) {... } Scopo: definire il comportamento di un metodo

17 Definizione del Costruttore 17 Un costruttore inizializza le variabili d'istanza (o d'esemplare) Nome del costruttore = nome della classe public BankAccount() { // corpo riempito più tardi }

18 Definizione del Costruttore 18 Il corpo del costruttore viene eseguito quando si crea un nuovo oggetto Le istruzioni nel corpo di un costruttore impostano i dati interni (stato) dell'oggetto che si costruisce Tutti i costruttori di una classe hanno lo stesso nome Il compilatore sa distinguere tra i vari costruttori poiché essi accettano parametri differenti

19 Sintassi 3.2: 19 Definizione di Costruttore accessspecifier ClassName(parameterType parametername,,...). { constructor body } Esempio public BankAccount(double initialbalance) {... } Scopo: : Definire il comportamento di un costruttore

20 BankAccount 20 Interfaccia Pubblica I costruttori pubblici e tutti i metodi di una classe formano l'interfaccia pubblica della classe public class BankAccount { // Costruttori public BankAccount() { // corpo da riempire in seguito } public BankAccount(double initialbalance) { // corpo da riempire in seguito } // Metodi public void deposit(double amount)

21 BankAccount 21 Interfaccia Pubblica } { // corpo da riempire in seguito } public void withdraw(double amount) { // corpo da riempire in seguito } public double getbalance() { // corpo da riempire in seguito } // campi privati da riempire in seguito

22 Sintassi 3.3: 22 accessspecifier class ClassName { constructors methods fields } Esempio Definizione di Classe public class BankAccount { public BankAccount(double initialbalance) {... } public void deposit(double amount) {... }... } Scopo: : definire una classe, la sua interfaccia pubblica ed i dettagli implementativi

23 Commentare l'interfaccia 23 Pubblica /** Ritira denaro dal conto amount l'ammontare da ritirare */ public void withdraw(double amount) { // implementato in seguito } /** Ottiene il saldo del conto il saldo corrente */ public double getbalance() { // implementato in seguito }

24 Commenti di Documentazione 24 Fornire commenti per la documentazione di Ogni classe Ogni metodo Ogni parametro Ogni valore di ritorno /** Un conto corrente ha un saldo che può essere cambiato da depositi e prelievi. */ public class BankAccount {... }

25 Riassunto Javadoc dei Metodi 25

26 Javadoc: 26 Dettagli di un Metodo

27 Campi di Istanza 27 Un oggetto memorizza i suoi dati (stato) in campi d'istanza Campo: termine tecnico per l'allocazione in un'area di memoria Istanza di una classe: un oggetto della classe La dichiarazione della classe specifica i campi delle istanze: public class BankAccount { }... private double balance;

28 Campi di Istanza 28 La dichiarazione di un campo consiste nelle parti seguenti: Specificatore d'accesso (come private) Tipo della variabile (come double) Nome della variabile (come balance) Ogni oggetto di una classe ha il suo insieme di campi d'istanza Si dovrebbero dichiarare tutte le istanze come private

29 Campi di Istanza 29

30 Sintassi 3.4: 30 Dichiarazione dei campi accessspecifier class ClassName { }... accessspecifier fieldtype fieldname;... Esempio: public class BankAccount {... private double balance;... } Scopo: : definire un campo che sia presente in ogni oggetto della classe

31 Accedere ai Campi d'istanza 31 Il metodo deposit della classe BankAccount può accedere ai campi d'istanza privati: public void deposit(double amount) { double newbalance = balance + amount; balance = newbalance; }

32 Accedere ai Campi d'istanza 32 Gli altri metodi non possono: public class BankRobber { public static void main(string[] args) { BankAccount momssavings = new BankAccount(1000);... momssavings.balance = -1000; // ERROR } } Incapsulamento = nascondere i dati e fornire accesso attraverso i metodi

33 Implementare i Costruttori 33 I costruttori contengono istruzioni per inizializzare i campi di un oggetto public BankAccount() { balance = 0; } public BankAccount(double initialbalance) { } balance = initialbalance;

34 Esempio 34 BankAccount harryschecking = new BankAccount(1000); Crea un nuovo oggetto di tipo BankAccount Chiama il secondo costruttore (dato che si fornisce un parametro di costruzione) Imposta il parametro initialbalance a 1000 Imposta il campo balance dell'oggetto apnea creato ad initialbalance Restituisce un riferimento, cioè l'indirizzo in memoria dell'oggetto come valore dell'espressione new Immagazzina il riferimento nella variabile harryschecking

35 Implementare i Metodi 35 Alcuni metodi non ritornano alcun valore public void withdraw(double amount) { double newbalance = balance - amount; balance = newbalance; } Alcuni metodi non restituiscono un valore in output public double getbalance() { return balance; }

36 Esempio: Chiamata di Metodo 36 harryschecking.deposit(500); Imposta il parametro amount a 500 Preleva il campo balance dell'oggetto la cui locazione è immagazzinata in harryschecking Aggiunge il valore di amount a balance e immagazzinare il risultato nella variabile newbalance Immagazzina il valore di newbalance nel campo balance sovrascrivendo il vecchio valore

37 Sintassi 3.5: 37 return expression; oppure return; Esempio: return balance; Esempio: Istruzione return Scopo: : Specificare il valore restituito da un metodo ed uscirvi immediatamente. Esso diventa il valore dell'espressione relativa alla chiamata del metodo

38 File BankAccount.java 38 01: /** 02: Un conto ha un saldo che può essere modificato 03: con depositi e prelievi. 04: */ 05: public class BankAccount 06: { 07: /** 08: costruisce un conto con saldo pari a 0. 09: */ 10: public BankAccount() 11: { 12: balance = 0; 13: } 14: 15: /** 16: Costruisce un conto con il dato saldo. initialbalance saldo iniziale 18: */

39 File BankAccount.java 39 19: public BankAccount(double initialbalance) 20: { 21: balance = initialbalance; 22: } 23: 24: /** 25: Deposita denaro sul conto. amount l'ammontare del deposito 27: */ 28: public void deposit(double amount) 29: { 30: double newbalance = balance + amount; 31: balance = newbalance; 32: } 33: 34: /** 35: Preleva denaro dal conto. amount ammontare del prelievo

40 File BankAccount.java 40 37: */ 38: public void withdraw(double amount) 39: { 40: double newbalance = balance - amount; 41: balance = newbalance; 42: } 43: 44: /** 45: Legge il saldo corrente del conto. il saldo corrente 47: */ 48: public double getbalance() 49: { 50: return balance; 51: } 52: 53: private double balance; 54: }

41 Collaudare una Classe 41 Classe di collaudo: classe con un metodo main contenente istruzioni per testare un'altra classe Tipicamente svolge i seguenti passi: 1) Costruire uno o più oggetti della classe da collaudare 2) Invocare uno o più metodi 3) Stampare uno o più risultati

42 Collaudare una Classe 42 I dettagli sulla costruzione di un programma variano. Nella maggior parte degli ambienti, si devono svolgere questi passi: 1) Creare una nuova cartella per il proprio programma 2) Creare due file, uno per classe 3) Compilare entrambi i file 4) Far girare il programma di collaudo

43 BankAccountTester 43 01: /** 02: A class to test the BankAccount class. 03: */ 04: public class BankAccountTester 05: { 06: /** 07: Tests the methods of the BankAccount class. args not used 09: */ 10: public static void main(string[] args) 11: { 12: BankAccount harryschecking = new BankAccount(); 13: harryschecking.deposit(2000); 14: harryschecking.withdraw(500); 15: System.out.println(harrysChecking.getBalance()); 16: } 17: }

44 Collaudo con BlueJ 44

45 Categorie di Variabili 45 Categorie di variabili Campi d'istanza (balance( in BankAccount) Variabili locali (newbalance( nel metodo deposit) Parametri (amount( nel metodo deposit) Un campo d'istanza appartiene ad un oggetto I campi si mantengono in vita fino a quando nessun oggetto utilizza l'oggetto

46 Categorie di Variabili 46 In Java, il garbage collector periodicamente reclama (la memoria allocata per) oggetti che non sono più usati Variabili locali e parametri appartengono ad un metodo I campi d'istanza sono inizializzati ad un valore di default, ma occorre inizializzare le variabili locali

47 Vita delle Variabili 47 harryschecking.deposit(500); double newbalance = balance + amount; balance = newbalance;

48 Vita delle Variabili 48

49 Vita delle Variabili 49

50 Parametri Impliciti ed Espliciti 50 Il parametro implicito di un metodo è l'oggetto del quale si invoca il metodo Il riferimento this denota tale parametro implicito

51 Parametri Impliciti ed Espliciti 51 L'uso del nome di un campo d'istanza in un metodo denota il campo del parametro implicito public void withdraw(double amount) { double newbalance = balance - amount; balance = newbalance; }

52 Parametri Impliciti ed Espliciti 52 balance è il saldo dell'oggetto a sinistra del punto: momssavings.withdraw(500) significa double newbalance = momssavings.balance - amount; momssavings.balance = newbalance;

53 Parametri Impliciti e this 53 Ogni metodo ha un solo parametro implicito Esso è sempre indicato con this Eccezione: : i metodi statici (static( static) ) non hanno parametri impliciti (vedi cap. 9) double newbalance = balance + amount; // actually means double newbalance = this.balance + amount;

54 Parametri Impliciti e this 54 Quando ci si riferisce ad un campo in un metodo il compilatore automaticamente lo applica a this momssavings.deposit(500);

55 Parametri Impliciti e this 55