Programmazione in Java - CEDACRI

a.a. 00/01

Lezione 7

Argomenti trattati

Testing di metodi e classi

• dal Cap. 6 (ATTENZIONE: gli esempi ilustrati in questo capitolo hanno il pregio di essere molto semplici, essi usano il metodo paint per disegnare direttamente su un frame. Questo stile di programmazione e' SCONSIGLIATO.)
  1. Esempi di applicazioni con architettura Model-View-Controller
     1. "CASE STUDY": una applicazione per convertire le temperature.
        1. Per prima cosa scegliamo l'interfaccia che dovra' essere implementata dalla componente "Model":

           TempCalculator models conversion between Celsius and Fahrenheit

           Methods (responsibilities)
           celsiusIntoFahrenheit(double c): double	translate the Celsius temperature, c, into the corresponding Fahrenheit value and return it as a double
           fahrenheitIntoCelsius(double f): double	translate the Fahrenheit temperature, c, into the corresponding Celsius value and return it as a double

        2. Consideriamo poi la classe che realizza la componente "Model":
           TempCalculator.java
        3. Per realizzare la componente "Viewer" in due parti distinte: "Input Viewer" e "Output Viewer" possiamo utilizzare direttamente le classi DialogReader e TemperatureWriter che abbiamo visto nella lezione precedente.
        4. A questo punto possiamo procedere con la scrittura della classe che realizza la componente "Controller":
           TempConverter.java
     2. "CASE STUDY": Bank Account Managers
        In questo esempio considereremo un "Model" che necessita di uno stato interno che "modella" il problema da risolvere.
        1. Per prima cosa scegliamo l'interfaccia che dovra' essere implementata dalla componente "Model", nel fare facciamo anche alcune ipotesi sulle strutture dati che rappresenteranno lo stato interno del "Model"; si noti tuttavia che tali stutture e le variabili di istanza (o attributi) associate a tali strutture NON FANNO PARTE DELL'INTERFACCIA.

           BankAccount models a single bank account

           Attribute (internal state)
           private int balance	the account's balance; should always be a nonnegative value
           Methods (responsibilities)
           deposit(int amount)	add amount, a nonnegative integer, to the account's balance
           withdraw(int amount): boolean	attempt to withdraw amount, a nonnegative integer, from the balance. If successful, return true, if unsuccessful, leave balance alone and return false

        2. Consideriamo poi la classe che realizza la componente "Model":
           BankAccount.java
        3. Il "Class Diagram" che descrive l'architettura dell'applicazione e' il seguente (si noti che esso contiene anche la descrizione dell'interfaccia delle classi):

           bank-account manager
           
                               AccountManager
                                main(...)
                                   |
                                   v
                               AccountController 
                                processTransactions()
                            /              |            \
                           /               |             \
                          v                |              \
            BankReader                     |                \
             readCommand(): String         |                 \
             readAmount(): int             |                  \
                                           v                   |
                              BankWriter                       |
                               showTransaction(String message, |
                                               int amount)     |
                               showTransaction(String message) |
                                    |                          |
                                    |                          v
                                    +------------------->BankAccount 
                                                            private int balance
                                                          deposit(int amount)
                                                          withdraw(int amount): boolean
                                                          balanceOf(): int
           

        4. Consideriamo ora le classi che realizzano la componente "Viewer" in due parti distinte:
           "Input Viewer": BankReader.java, e
           "Output Viewer": BankWriter.java (notate la presenza di un metodo "overloaded").
        5. Adesso e' il turno del controller:
           AccountController.java.
        6. Infine possiamo scrivere il "codice di startup":
           AccountManager.java.
     3. Istanze multiple di una stessa classe.
        Modifichamo l'applocazione precedente in modo da permettere la gestione simultanea di due conti.
        1. L'architettura e' praticamente la stessa: occorre solo tener conto che il nuovo "Controller" dovra' aver a che fare con due distinti "Model", ciasuno dei quali avra' una sua "Output-View".

           Program architecture with two bank accounts
           
                           AccountManager2
                                   |
                                   v
                           AccountController2
                            /          1|      1\
                           /            |        \
                          |            2|         \
                          v             v          \
                    BankReader    BankWriter      2|
                                       |           v
                                       +---->BankAccount
           
           
           

        2. Quindi occorre solo scrivere un nuovo controller e una nuova componente di "startup".
           Ecco il codice per il nuovo controller: AccountController2.java
           e quello per la nuova componente di "startup": AccountManager2.java.
  2. Testing di metodi e classi
  3. "BEYOND THE BASICS"