Efektywne Programowanie W Języku Java.pdf

(251 KB) Pobierz
C:\Andrzej\PDF\ABC nagrywania p³yt CD\1 strona.cdr
IDZ DO
PRZYK£ADOW Y ROZDZIA£
Efektywne programowanie
w jêzyku Java
Autor: Joshua Bloch
T³umaczenie: Pawe³ Gonera
ISBN: 83-7197-989-4
Format: B5, stron: 214
Przyk³ady na ftp: 48 kB
SPIS TRECI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Java to wspania³e narzêdzie w rêkach programisty. Ale nawet najlepsze narzêdzie mo¿e
zostaæ le u¿yte. Istnieje wiele ksi¹¿ek, które opisuj¹ ten jêzyk programowania
skupiaj¹c siê na przedstawieniu jego sk³adni. Ta ksi¹¿ka jest zupe³nie inna. Adresowana
jest do osób znaj¹cych ju¿ Javê i przedstawia praktyczne zasady pisania efektywnego,
poprawnego kodu.
Ka¿da wskazówka omówiona jest w osobnym podrozdziale opisuj¹cym dany problem,
przyk³ady poprawnego (i b³êdnego!) kodu, a tak¿e historie zaczerpniête z bogatego
dowiadczenia autora. Ta ksi¹¿ka zapozna Ciê z idiomami w³aciwymi jêzykowi Java
oraz z istotnymi z praktycznego punktu widzenia wzorcami projektowymi.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
1122851.001.png 1122851.002.png 1122851.003.png 1122851.004.png
Spis treci
Słowo wstpne..................................................................................7
Przedmowa........................................................................................9
Wprowadzenie.................................................................................11
Rozdział 1. Tworzenie i usuwanie obiektów........................................................15
Temat 1. Tworzenie statycznych metod factory zamiast konstruktorów..........................15
Temat 2. Wymuszanie właciwoci singleton za pomoc prywatnego konstruktora .......18
Temat 3. Wykorzystanie konstruktora prywatnego
w celu uniemo#liwienia utworzenia obiektu ..................................................................20
Temat 4. Unikanie powielania obiektów...........................................................................21
Temat 5. Usuwanie niepotrzebnych referencji do obiektów.............................................24
Temat 6. Unikanie finalizatorów.......................................................................................27
Rozdział 2. Metody wspólne dla wszystkich obiektów.........................................31
Temat 7. Zachowanie zało#e, w trakcie przedefiniowywania metody equals .................31
Temat 8. Przedefiniowywanie metody hashCode wraz z equals ......................................39
Temat 9. Przedefiniowywanie metody toString................................................................44
Temat 10. Rozs dne przedefiniowywanie metody clone..................................................46
Temat 11. Implementacja interfejsu Comparable .............................................................53
Rozdział 3. Klasy i interfejsy..............................................................................59
Temat 12. Ograniczanie dost5pnoci klas i ich składników..............................................59
Temat 13. Zapewnianie niezmiennoci obiektu................................................................62
Temat 14. Zast5powanie dziedziczenia kompozycj ........................................................69
Temat 15. Projektowanie i dokumentowanie klas przeznaczonych do dziedziczenia......74
Temat 16. Stosowanie interfejsów zamiast klas abstrakcyjnych ......................................78
Temat 17. Wykorzystanie interfejsów jedynie do definiowania typów............................83
Temat 18. Zalety stosowania statycznych klas składowych .............................................84
Rozdział 4. Odpowiedniki konstrukcji jzyka C...................................................89
Temat 19. Zast5powanie struktur klasami.........................................................................89
Temat 20. Zamiana unii na hierarchi5 klas .......................................................................91
Temat 21. Zast5powanie konstrukcji enum za pomoc klas.............................................94
Temat 22. Zast5powanie wska6ników do funkcji za pomoc klas i interfejsów...................103
Rozdział 5. Metody..........................................................................................107
Temat 23. Sprawdzanie poprawnoci parametrów .........................................................107
Temat 24. Defensywne kopiowanie................................................................................109
Temat 25. Projektowanie sygnatur metod.......................................................................112
Temat 26. Rozs dne korzystanie z przeci #ania.............................................................114
Temat 27. Zwracanie pustych tablic zamiast wartoci null ............................................118
Temat 28. Tworzenie komentarzy dokumentuj cych
dla wszystkich udost5pnianych elementów API...........................................................120
6
Efektywne programowanie w jzyku Java
Rozdział 6. Programowanie..............................................................................125
Temat 29. Ograniczanie zasi5gu zmiennych lokalnych..................................................125
Temat 30. Poznanie i wykorzystywanie bibliotek ..........................................................128
Temat 31. Unikanie typów float i double, gdy potrzebne s dokładne wyniki...............131
Temat 32. Unikanie typu String, gdy istniej bardziej odpowiednie typy......................133
Temat 33. Problemy z wydajnoci przy ł czeniu ci gów znaków................................135
Temat 34. Odwoływanie si5 do obiektów poprzez interfejsy.........................................136
Temat 35. Stosowanie interfejsów zamiast refleksyjnoci..............................................137
Temat 36. Rozwa#ne wykorzystywanie metod natywnych ............................................140
Temat 37. Unikanie optymalizacji ..................................................................................141
Temat 38. Wykorzystanie ogólnie przyj5tych konwencji nazewnictwa.........................144
Rozdział 7. Wyj0tki .........................................................................................147
Temat 39. Wykorzystanie wyj tków w sytuacjach nadzwyczajnych .............................147
Temat 40. Stosowanie wyj tków przechwytywalnych i wyj tków czasu wykonania.......149
Temat 41. Unikanie niepotrzebnych wyj tków przechwytywalnych .............................151
Temat 42. Wykorzystanie wyj tków standardowych .....................................................153
Temat 43. Zgłaszanie wyj tków właciwych dla abstrakcji ...........................................155
Temat 44. Dokumentowanie wyj tków zgłaszanych przez metod5 ...............................157
Temat 45. Udost5pnianie danych o bł5dzie ....................................................................158
Temat 46. Zachowanie atomowoci w przypadku bł5du ................................................159
Temat 47. Nie ignoruj wyj tków.....................................................................................161
Rozdział 8. W0tki............................................................................................163
Temat 48. Synchronizacja dost5pu do wspólnych modyfikowalnych danych................163
Temat 49. Unikanie nadmiarowej synchronizacji...........................................................168
Temat 50. Nigdy nie wywołuj wait poza p5tl ................................................................172
Temat 51. Unikanie korzystania z systemowego szeregowania w tków........................174
Temat 52. Dokumentowanie bezpiecze,stwa dla w tków..............................................177
Temat 53. Unikanie grup w tków...................................................................................180
Rozdział 9. Serializacja....................................................................................181
Temat 54. Implementowanie interfejsu Serializable.......................................................181
Temat 55. Wykorzystanie własnej postaci serializowanej..............................................185
Temat 56. Defensywne tworzenie metody readObject ...................................................191
Temat 57. Tworzenie metody readResolve.....................................................................196
Dodatek A Zasoby..........................................................................................199
Skorowidz......................................................................................203
Rozdział 4.
Odpowiedniki konstrukcji
jzyka C
Jzyk programowania Java posiada wiele podobiestw do jzyka C, ale kilka jego kon-
strukcji zostało pominitych. W wikszo"ci przypadków oczywiste jest, dlaczego dana
konstrukcja została pominita i w jaki sposób mo$na sobie bez niej radzi%. W rozdziale
tym zaproponujemy zamienniki dla kilku pominitych konstrukcji jzyka C, których
zast&pienie nie jest tak oczywiste.
Najczstszym w&tkiem, który przewija si przez cały ten rozdział, jest twierdzenie, $e
wszystkie pominite konstrukcje były zorientowane na dane, a nie zorientowane obiek-
towo. Jzyk programowania Java zawiera bardzo wydajny system typów i propono-
wane zamienniki w pełni korzystaj& z tego systemu w celu zapewnienia wy$szego
stopnia abstrakcji ni$ konstrukcje jzyka C, które s& przez nie zastpowane.
Nawet je$eli zdecydujesz si na pominicie tego rozdziału, warto zapozna% si z tema-
tem 21., po"wiconym typowi wyliczeniowemu , który zastpuje konstrukcj , dostp-
n& w jzyku C. Wzorzec ten nie był powszechnie znany w czasie pisania tej ksi&$ki,
a posiada znaczn& przewag nad obecnie stosowanymi rozwi&zaniami tego problemu.
Temat 19. Zastpowanie struktur klasami
Konstrukcja jzyka C została usunita z jzyka Java, poniewa$ za pomoc& klasy
mo$na zrealizowa% wszystko to, co potrafi struktura, a nawet wicej. Struktura jedy-
nie grupuje kilka pól danych w jeden obiekt — klasa zawiera operacje wykonywane na
wynikowym obiekcie i pozwala na ukrycie pól danych przed u$ytkownikiem obiektu.
Inaczej mówi&c, klasa hermetyzuje dane w obiekcie i umo$liwia dostp do nich jedy-
nie za pomoc& metod, co pozwala twórcy klasy na swobodn& zmian reprezentacji
danych w pó/niejszym czasie (temat 12.).
W czasie pierwszych pokazów jzyka Java niektórzy programi"ci korzystaj&cy z jzyka
C uwa$ali, $e klasy s& zbyt obszerne, aby w pewnych sytuacjach zast&pi% struktury.
90
Efektywne programowanie w jzyku Java
Nie bdziemy si zajmowali tym problemem. Zdegenerowane klasy składaj&ce si jedynie
z pól danych s& pewnym przybli$eniem struktur z jzyka C:
Poniewa$ takie klasy pozwalaj& na dostp do swoich pól, nie pozwalaj& na skorzysta-
nie z zalet hermetyzacji. Nie mo$na zmieni% reprezentacji danych w takiej klasie bez
zmiany API, nie mo$na wymusza% $adnych ogranicze oraz nie mo$na podejmowa%
dodatkowych zada podczas modyfikacji pola. Ortodoksyjni programi"ci obiektowi
uwa$aj&, $e takie klasy s& zakazane i powinny zawsze by% zastpowane klasami z polami
prywatnymi oraz publicznymi metodami je udostpniaj&cymi:
Oczywi"cie twierdzenie to jest prawdziwe w odniesieniu do klas publicznych — je$eli
klasa jest dostpna spoza swojego pakietu, rozwa$ny programista powinien zabezpie-
czy% sobie mo$liwo"% zmiany wewntrznej reprezentacji danych. Je$eli klasa publiczna
udostpnia swoje pola, nie ma mo$liwo"ci zmiany reprezentacji danych, poniewa$ kod
klientów, korzystaj&cy z klasy publicznej, mo$e by% ju$ rozesłany po całym "wiecie.
Je$eli jednak klasa jest prywatna w ramach pakietu lub jest to prywatna klasa zagnie$-
d$ona, nie ma nic złego w bezpo"rednim udostpnieniu pól danych — zakładaj&c, $e
naprawd opisuj& abstrakcj definiowan& przez klas. Podej"cie to generuje mniej kodu
ni$ wykorzystanie metod dostpowych, zarówno w definicji klasy, jak i w kodzie klientów
j& wykorzystuj&cych. Poniewa$ kod klientów jest "ci"le zwi&zany z wewntrzn& repre-
zentacj& klasy, jest on ograniczony do pakietu, w którym klasa ta jest zdefiniowana.
W przypadku, gdy konieczna jest zmiana reprezentacji danych, mo$liwe jest wpro-
wadzenie zmian bez konieczno"ci zmiany kodu poza pakietem. W przypadku prywat-
nej klasy zagnie$d$onej zasig zmian jest ograniczony do klasy nadrzdnej.
Kilka klas w bibliotekach jzyka Java nie dotrzymuje zalecenia, aby klasy publiczne nie
udostpniały bezpo"rednio swoich pól. Przykładami takich klas s& klasy i
z pakietu . Przykłady te nie powinny by% na"ladowane — nale$ałoby raczej

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin