|
|
Java Best Practice - I migliori consigli per scrivere codice di qualita'
|
| Editore | Tecniche Nuove |
| Autore | Vetti Tagliati Luca |
| Pagine | 350 |
| Volumi | 1 |
| Livello | Intermedio-Avanzato |
| Lingua | Italiano |
| Data pubblicazione | 05 - 2008 |
| ISBN | 9788848121934 |
|
|
| Prezzo di copertina | Sconto | Prezzo Librinformatica |
| Euro 33,90 | 20% | Euro 27,12 |
|
Sommario
Introduzione ........................................................................................ vii
Capitolo 1. Elementi base
Introduzione ............................................................................................................................ 1
Obiettivi .................................................................................................................................. 2
Direttive .................................................................................................................................. 2
1.1 Selezionare nomi significativi per le classi ................................................................................................. 2
1.2 Selezionare nomi significativi per attributi/variabili e parametri ................................................................ 6
1.3 Selezionare nomi significativi per i metodi .............................................................................................. 10
1.4 Implementare classi orientate agli oggetti .............................................................................................. 11
1.5 Porre attenzione alla scrittura dei metodi ................................................................................................ 14
1.6 Utilizzare correttamente l’ereditarietà .................................................................................................... 19
Capitolo 2. Programmazione Java
Introduzione .......................................................................................................................... 21
Obiettivi ................................................................................................................................ 21
Direttive ................................................................................................................................ 22
2.1 Investire nello stile ................................................................................................................................ 22
2.2 Utilizzare accuratamente le “costanti” ..................................................................................................... 22
2.3 Concludere correttamente i programmi Java ........................................................................................... 24
2.4 Scrivere correttamente i metodi .............................................................................................................. 26
2.5 Implementare attentamente i metodi “accessori” e “modificatori” (get/set) ............................................. 32
2.6 Utilizzare con oculatezza la classe java.lang.Runtime ............................................................................... 36
2.7 Implementare i metodi Object ................................................................................................................ 36
2.8 Porre attenzione alla chiusura degli stream ............................................................................................. 40
2.9 Tipi numerici ......................................................................................................................................... 43
2.10 Selezionare attentamente le collezioni ................................................................................................... 49
2.11 Lavorare con le date ............................................................................................................................... 50
2.12 Problemi con il riutilizzo dei nomi ........................................................................................................... 55
Capitolo 3. Approfondimenti
Introduzione .......................................................................................................................... 59
Obiettivi ................................................................................................................................ 59
Direttive ................................................................................................................................ 60
3.1 I Generics ............................................................................................................................................... 60
3.2 Static import ......................................................................................................................................... 71
3.3 Auto-Boxing / Unboxing .......................................................................................................................... 73
3.4 Varargs: argomenti variabili .................................................................................................................... 76
3.5 Applicazioni multi-threaded tradizionali ................................................................................................. 78
3.6 Applicazioni multi-threaded Java 5 ......................................................................................................... 89
3.7 Gestire correttamente possibili accessi concorrenti .................................................................................. 94
Capitolo 4. I commenti
Introduzione ........................................................................................................................ 101
Obiettivi ............................................................................................................................... 102
Direttive ............................................................................................................................... 102
4.1 Investire nella documentazione ............................................................................................................ 102
4.2 Scrivere i commenti JavaDoc ................................................................................................................. 105
4.3 Valutare la possibilità di inserire la documentazione al livello di package ............................................... 109
4.4 Commentare correttamente le classi ..................................................................................................... 113
4.5 Commentare attentamente l’implementazione ..................................................................................... 118
Capitolo 5. Strategia di gestione delle eccezioni
Introduzione ........................................................................................................................ 123
Obiettivi ............................................................................................................................... 124
Un po’ di teoria ..................................................................................................................... 124
La gerarchia delle eccezioni in Java ....................................................................................... 125
Gerarchia .................................................................................................................................................... 125
Eccezioni runtime e checked ......................................................................................................................... 126
La controversia relativa all’uso ..................................................................................................................... 128
Direttive ............................................................................................................................... 129
5.1 Utilizzare le eccezioni ............................................................................................................................ 129
5.2 Utilizzare correttamente il blocco finally ................................................................................................ 132
5.3 Non utilizzare i tipi base delle eccezioni ................................................................................................. 135
5.4 Fare attenzione alla modalità di notifica delle eccezioni ......................................................................... 138
5.5 Valutare attentamente il ciclo di vita delle eccezioni .............................................................................. 140
5.6 Considerare la natura delle eccezioni ..................................................................................................... 140
5.7 Considerare i classici problemi relativi all’impiego di sistemi di messaggistica ........................................ 143
Capitolo 6. Il logging
Introduzione ........................................................................................................................ 145
Obiettivi ............................................................................................................................... 146
Un po’ di storia ...................................................................................................................... 147
Log4J .................................................................................................................................. 148
Struttura e funzionamento .......................................................................................................................... 148
java.util.logging ................................................................................................................... 156
Apache Java Logging (JCL) .................................................................................................... 158
Quale tool di logging utilizzare? ............................................................................................ 160
Direttive ............................................................................................................................... 160
6.1 Investire nel logging ............................................................................................................................. 160
Java Best Practice: i migliori consigli per scrivere codice di qualità v
6.2 Porre attenzione al contenuto del log .................................................................................................... 162
6.3 Utilizzare correttamente i livelli di log ................................................................................................... 163
6.4 Valutare l’impatto sulle prestazioni ....................................................................................................... 164
6.5 Implementare un corretto logging delle eccezioni ................................................................................. 166
Capitolo 7. Test di unità
Introduzione ........................................................................................................................ 169
Obiettivi ............................................................................................................................... 170
Un po’ di teoria ..................................................................................................................... 170
I vantaggi dei test di unità ........................................................................................................................... 171
Processi iterativi e incrementali .................................................................................................................... 172
La copertura dei test di unità ........................................................................................................................ 173
JUnit ................................................................................................................................... 178
JUnit prima della versione 4 ......................................................................................................................... 178
JUnit versione 4 .......................................................................................................................................... 181
Direttive ............................................................................................................................... 182
7.1 Investire nei test di unità ...................................................................................................................... 182
7.2 Utilizzare JUnit .................................................................................................................................... 185
7.3 Test di unità e mock objects ................................................................................................................... 187
7.4 Utilizzare tool di analisi della copertura ................................................................................................. 190
7.5 Scrivere test chiari ed efficaci ................................................................................................................ 192
Capitolo 8. Test di integrazione
Introduzione ........................................................................................................................ 197
Obiettivi ............................................................................................................................... 198
Catalogazione dei test di integrazione .................................................................................. 199
Sanity Check e Smoke Test .................................................................................................... 200
Alcuni tool ............................................................................................................................ 200
Direttive ............................................................................................................................... 201
8.1 Investire negli use case e test case ......................................................................................................... 201
8.2 Gestire correttamente i vari progetti di test ........................................................................................... 202
8.3 Gestire correttamente i vari ambienti .................................................................................................... 204
8.4 Pianificare correttamente i test di integrazione ..................................................................................... 204
8.5 Verificare gli elementi principali ............................................................................................................ 206
8.6 Test di applicazioni Java EE .................................................................................................................... 207
8.7 Investire sui test della GUI ..................................................................................................................... 208
8.8 Test di integrazione delle performance .................................................................................................. 210
Capitolo 9. Organizzazione di un progetto, build e deploy
Introduzione ........................................................................................................................ 213
Obiettivi ............................................................................................................................... 214
I tool: filosofia e uso di Ant e Maven ...................................................................................... 216
Ant ............................................................................................................................................................. 216
Struttura ............................................................................................................................................................................................ 217
Maven ........................................................................................................................................................ 221
Breve storia di Maven ......................................................................................................................................................................... 222
Obiettivi di Maven .............................................................................................................................................................................. 223
Caratteristiche principali di Maven ...................................................................................................................................................... 224
Vantaggi di Maven .............................................................................................................................................................................. 224
Componenti principali di Maven .......................................................................................................................................................... 225
Archetipo ........................................................................................................................................................................................... 226
POM ................................................................................................................................................................................................... 227
I repository di Maven .......................................................................................................................................................................... 232
I comandi di Maven ............................................................................................................................................................................. 236
Confronto tra Ant e Maven .................................................................................................... 237
Struttura di progetti medio-grandi ....................................................................................... 239
Direttive ............................................................................................................................... 240
9.1 Utilizzare strumenti moderni per il build ............................................................................................... 241
9.2 Organizzare correttamente il proprio progetto ...................................................................................... 242
9.3 Automatizzare il processo di build ......................................................................................................... 243
9.5 Utilizzare i repository Maven ................................................................................................................. 245
9.6 Distinguere i processi build e di personalizzazione ................................................................................. 245
Appendice A. JavaDoc
Introduzione ........................................................................................................................ 247
L’utility JavaDoc .................................................................................................................... 247
Appendice B. Tag HTML ....................................................................... 255
Appendice C. Hashing
Introduzione ........................................................................................................................ 261
Collisioni .............................................................................................................................. 264
Gestione interna alla tabella ................................................................................................. 265
Gestione esterna alla tabella ................................................................................................ 267
Funzioni hash e numeri primi ............................................................................................... 271
Alcuni esempi di algoritmi di hash ........................................................................................ 271
Un test informale ................................................................................................................. 277
Appendice D. Multi-threading
Introduzione ........................................................................................................................ 283
Obiettivi ............................................................................................................................... 284
Nozioni di base ..................................................................................................................... 284
Programmazione MT Java originaria ..................................................................................... 295
Problemi di programmazione MT in Java .............................................................................. 321
Innovazioni del JDK 5 per il MT .............................................................................................. 324
Appendice E. Riferimenti bibliografici ................................................. 349
|
|
|
|
