java.-efektywne-programowanie.-wydanie-ii helion.pdf

Java. Efektywne

programowanie. Wydanie II

Autor: Joshua Bloch

T³umaczenie: Pawe³ Gonera

ISBN: 978-83-246-2084-5

Tytu³ orygina³u: Effective Java (2nd Edition)

Format: 158x235 , stron: 352

Poznaj specyfikê jêzyka Java i zostañ mistrzem programowania

• Jak korzystaæ z bibliotek jêzyka Java?

• Jak pisaæ funkcjonalny i klarowny kod?

• Jak stworzyæ profesjonalny i efektowny program?

Jêzyk Java jest jêzykiem obiektowym z dziedziczeniem jednobazowym. Wewn¹trz

ka¿dej metody korzysta on ze zorientowanego na instrukcje stylu kodowania.

Aby dobrze poznaæ jakikolwiek jêzyk, nale¿y nauczyæ siê pos³ugiwaæ jego regu³ami,

zasadami i sk³adni¹ — podobnie jest z jêzykiem programowania. Jeœli chcesz zyskaæ

mo¿liwoœæ efektywnego programowania w jêzyku Java, powinieneœ poznaæ struktury

danych, operacje i udogodnienia, oferowane przez biblioteki standardowe, a tak¿e

czêsto stosowane i efektywne sposoby tworzenia kodu. Ca³¹ potrzebn¹ Ci wiedzê

znajdziesz w³aœnie w tym podrêczniku.

W ksi¹¿ce „Java. Efektywne programowanie” w sposób zrozumia³y i klarowny

przedstawiono zasady opisuj¹ce mechanizmy u¿ywane w najlepszych technikach

programowania. Ten podrêcznik podpowie Ci, jak najbardziej racjonalnie korzystaæ

z jêzyka Java oraz jego podstawowych bibliotek. Dowiesz siê, jak stosowaæ wyj¹tki

przechwytywalne i wyj¹tki czasu wykonania, poznasz tak¿e zalety stosowania

statycznych klas sk³adowych. Opanujesz metody sprawdzania poprawnoœci

parametrów i projektowania sygnatur oraz wszelkie instrukcje, które pozwol¹ Ci

na wydajne i profesjonalne programowanie.

• Tworzenie i usuwanie obiektów

• Klasy i interfejsy

• Zapewnianie niezmiennoœci obiektu

• Projektowanie i dokumentowanie klas przeznaczonych do dziedziczenia

• Zalety stosowania statycznych klas sk³adowych

• Typy ogólne

• Typy wyliczeniowe i adnotacje

• Metody

• Programowanie

• Wykorzystanie ogólnie przyjêtych konwencji nazewnictwa

• Wyj¹tki

• Wspó³bie¿noœæ i serializacja

• Dokumentowanie bezpieczeñstwa dla w¹tków

Nie wystarczy samo poznanie jêzyka Java.

Trzeba wiedzieæ, jak z niego efektywnie korzystaæ!

Spis treści

Słowo wstępne .................................................................................. 11

Przedmowa ...................................................................................... 13

Podziękowania .................................................................................. 17

Rozdział 1. Wprowadzenie ............................................................... 21

Rozdział 2. Tworzenie i usuwanie obiektów ...................................... 25

Temat 1. Tworzenie statycznych metod factory

zamiast konstruktorów ............................................................... 25

Temat 2. Zastosowanie budowniczego

do obsługi wielu parametrów konstruktora ........................ 31

Temat 3. Wymuszanie właściwości singleton

za pomocą prywatnego konstruktora .............................. 37

Temat 4. Wykorzystanie konstruktora prywatnego

w celu uniemożliwienia utworzenia obiektu ....................... 39

Temat 5. Unikanie powielania obiektów .......................................... 40

Temat 6. Usuwanie niepotrzebnych referencji do obiektów ........... 44

Temat 7. Unikanie finalizatorów ...................................................... 47

Rozdział 3. Metody wspólne dla wszystkich obiektów ....................... 53

Temat 8. Zachowanie założeń w trakcie przedefiniowywania

metody equals ..................................................................... 53

Temat 9. Przedefiniowywanie metody hashCode wraz z equals ..... 65

Temat 10. Przedefiniowywanie metody toString ............................... 70

Temat 11. Rozsądne przedefiniowywanie metody clone ................... 73

Temat 12. Implementacja interfejsu Comparable ............................. 81

S PIS TREŚCI

Rozdział 4. Klasy i interfejsy ............................................................ 87

Temat 13. Ograniczanie dostępności klas i ich składników .............. 87

Temat 14. Stosowanie metod akcesorów zamiast pól publicznych

w klasach publicznych ........................................................ 91

Temat 15. Zapewnianie niezmienności obiektu ................................. 93

Temat 16. Zastępowanie dziedziczenia kompozycją ........................ 101

Temat 17. Projektowanie i dokumentowanie klas przeznaczonych

do dziedziczenia ............................................................... 107

Temat 18. Stosowanie interfejsów zamiast klas abstrakcyjnych ..... 112

Temat 19. Wykorzystanie interfejsów jedynie

do definiowania typów ...........................................................117

Temat 20. Zastępowanie oznaczania klas hierarchią ....................... 119

Temat 21. Zastosowanie obiektów funkcyjnych

do reprezentowania strategii ........................................... 122

Temat 22. Zalety stosowania statycznych klas składowych ............. 125

Rozdział 5. Typy ogólne ................................................................ 129

Temat 23. Nie korzystaj z typów surowych w nowym kodzie ......... 129

Temat 24. Eliminowanie ostrzeżeń o braku kontroli ....................... 135

Temat 25. Korzystanie z list zamiast tablic ......................................... 137

Temat 26. Stosowanie typów ogólnych ............................................. 142

Temat 27. Stosowanie metod ogólnych ............................................ 146

Temat 28. Zastosowanie związanych szablonów

do zwiększania elastyczności API .................................... 151

Temat 29. Wykorzystanie heterogenicznych kontenerów

bezpiecznych dla typów .................................................... 158

Rozdział 6. Typy wyliczeniowe i adnotacje ..................................... 165

Temat 30. Użycie typów wyliczeniowych zamiast stałych int .......... 165

Temat 31. Użycie pól instancyjnych zamiast kolejności .................. 176

Temat 32. Użycie EnumSet zamiast pól bitowych ........................... 177

Temat 33. Użycie EnumMap zamiast indeksowania kolejnością .... 178

Temat 34. Emulowanie rozszerzalnych typów wyliczeniowych

za pomocą interfejsów ...................................................... 182

Temat 35. Korzystanie z adnotacji zamiast wzorców nazw ............. 186

Temat 36. Spójne użycie adnotacji Override .................................... 192

Temat 37. Użycie interfejsów znacznikowych

do definiowania typów ...........................................................195

Rozdział 7. Metody ....................................................................... 197

Temat 38. Sprawdzanie poprawności parametrów .......................... 197

Temat 39. Defensywne kopiowanie .................................................. 200

Temat 40. Projektowanie sygnatur metod ........................................ 204

Temat 41. Rozsądne korzystanie z przeciążania .............................. 206

S PIS TREŚCI

Temat 42. Rozsądne korzystanie z metod varargs ........................... 212

Temat 43. Zwracanie pustych tablic lub kolekcji

zamiast wartości null ..............................................................215

Temat 44. Tworzenie komentarzy dokumentujących

dla wszystkich udostępnianych elementów API ............. 217

Rozdział 8. Programowanie ........................................................... 225

Temat 45. Ograniczanie zasięgu zmiennych lokalnych ................... 225

Temat 46. Stosowanie pętli for-each

zamiast tradycyjnych pętli for ......................................... 228

Temat 47. Poznanie i wykorzystywanie bibliotek ............................ 231

Temat 48. Unikanie typów float i double,

gdy potrzebne są dokładne wyniki .................................. 234

Temat 49. Stosowanie typów prostych

zamiast opakowanych typów prostych ............................ 236

Temat 50. Unikanie typu String,

gdy istnieją bardziej odpowiednie typy ........................... 239

Temat 51. Problemy z wydajnością

przy łączeniu ciągów znaków ........................................... 242

Temat 52. Odwoływanie się do obiektów poprzez interfejsy .......... 243

Temat 53. Stosowanie interfejsów zamiast refleksyjności ............... 245

Temat 54. Rozważne wykorzystywanie metod natywnych .............. 248

Temat 55. Unikanie optymalizacji .................................................... 249

Temat 56. Wykorzystanie ogólnie przyjętych

konwencji nazewnictwa .................................................... 252

Rozdział 9. Wyjątki ........................................................................ 257

Temat 57. Wykorzystanie wyjątków

w sytuacjach nadzwyczajnych .......................................... 257

Temat 58. Stosowanie wyjątków przechwytywanych

i wyjątków czasu wykonania ............................................ 260

Temat 59. Unikanie niepotrzebnych

wyjątków przechwytywanych ........................................... 262

Temat 60. Wykorzystanie wyjątków standardowych ....................... 264

Temat 61. Zgłaszanie wyjątków właściwych dla abstrakcji .............. 266

Temat 62. Dokumentowanie wyjątków zgłaszanych

przez metodę ..................................................................... 268

Temat 63. Udostępnianie danych o błędzie ....................................... 270

Temat 64. Zachowanie atomowości w przypadku błędu ................. 272

Temat 65. Nie ignoruj wyjątków ....................................................... 274

S PIS TREŚCI

Rozdział 10. Współbieżność ............................................................ 275

Temat 66. Synchronizacja dostępu

do wspólnych modyfikowalnych danych ........................ 275

Temat 67. Unikanie nadmiarowej synchronizacji ........................... 280

Temat 68. Stosowanie wykonawców i zadań zamiast wątków ......... 286

Temat 69. Stosowanie narzędzi współbieżności

zamiast wait i notify ......................................................... 288

Temat 70. Dokumentowanie bezpieczeństwa dla wątków ............... 293

Temat 71. Rozsądne korzystanie z późnej inicjalizacji .................... 296

Temat 72. Nie polegaj na harmonogramie wątków ......................... 300

Temat 73. Unikanie grup wątków ..................................................... 302

Rozdział 11. Serializacja .................................................................. 305

Temat 74. Rozsądne implementowanie interfejsu Serializable ....... 305

Temat 75. Wykorzystanie własnej postaci serializowanej ............... 310

Temat 76. Defensywne tworzenie metody readObject .................... 317

Temat 77. Stosowanie typów wyliczeniowych

zamiast readResolve do kontroli obiektów ..................... 323

Temat 78. Użycie pośrednika serializacji

zamiast serializowanych obiektów .................................. 327

Dodatek A Tematy odpowiadające pierwszemu wydaniu ............... 331

Dodatek B Zasoby ........................................................................ 335

Skorowidz ....................................................................................... 339

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: