Efektywne programowanie w jezyku Java.pdf

(242 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
Efektywne programowanie
w jêzyku Java
Autor: Joshua Bloch
T³umaczenie: Pawe³ Gonera
ISBN: 83-7197-989-4
Tytu³ orygina³u:
Effective Java Programming Language
Format: B5, stron: 214
Przyk³ady na ftp: 48 kB
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
do wiadczenia autora. Ta ksi¹¿ka zapozna Ciê z idiomami w³a ciwymi jêzykowi Java
oraz z istotnymi z praktycznego punktu widzenia wzorcami projektowymi.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
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
Spis treści
Słowo wstępne .................................................................................. 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łaściwości 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 dostępności klas i ich składników..............................................59
Temat 13. Zapewnianie niezmienności obiektu................................................................62
Temat 14. Zastępowanie 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 języka C ................................................... 89
Temat 19. Zastępowanie struktur klasami.........................................................................89
Temat 20. Zamiana unii na hierarchię klas .......................................................................91
Temat 21. Zastępowanie konstrukcji enum za pomocą klas.............................................94
Temat 22. Zastępowanie wskaźników do funkcji za pomocą klas i interfejsów...................103
Rozdział 5. Metody.......................................................................................... 107
Temat 23. Sprawdzanie poprawności 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 wartości null ............................................118
Temat 28. Tworzenie komentarzy dokumentujących
dla wszystkich udostępnianych elementów API...........................................................120
6
Efektywne programowanie w języku Java
Rozdział 6. Programowanie.............................................................................. 125
Temat 29. Ograniczanie zasięgu 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 wydajnością przy łączeniu ciągów znaków................................135
Temat 34. Odwoływanie się do obiektów poprzez interfejsy .........................................136
Temat 35. Stosowanie interfejsów zamiast refleksyjności..............................................137
Temat 36. Rozwa ne wykorzystywanie metod natywnych ............................................140
Temat 37. Unikanie optymalizacji ..................................................................................141
Temat 38. Wykorzystanie ogólnie przyjętych konwencji nazewnictwa .........................144
Rozdział 7. Wyjątki ......................................................................................... 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łaściwych dla abstrakcji ...........................................155
Temat 44. Dokumentowanie wyjątków zgłaszanych przez metodę ...............................157
Temat 45. Udostępnianie danych o błędzie ....................................................................158
Temat 46. Zachowanie atomowości w przypadku błędu ................................................159
Temat 47. Nie ignoruj wyjątków.....................................................................................161
Rozdział 8. Wątki ............................................................................................ 163
Temat 48. Synchronizacja dostępu do wspólnych modyfikowalnych danych................163
Temat 49. Unikanie nadmiarowej synchronizacji...........................................................168
Temat 50. Nigdy nie wywołuj wait poza pętlą................................................................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
języka C
Język programowania Java posiada wiele podobieństw do języka C, ale kilka jego kon-
strukcji zostało pominiętych. W większości przypadków oczywiste jest, dlaczego dana
konstrukcja została pominięta i w jaki sposób mo na sobie bez niej radzić. W rozdziale
tym zaproponujemy zamienniki dla kilku pominiętych konstrukcji języka C, których
zastąpienie nie jest tak oczywiste.
Najczęstszym wątkiem, który przewija się przez cały ten rozdział, jest twierdzenie, e
wszystkie pominięte konstrukcje były zorientowane na dane, a nie zorientowane obiek-
towo. Język 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 języka C, które są przez nie zastępowane.
Nawet je eli zdecydujesz się na pominięcie tego rozdziału, warto zapoznać się z tema-
tem 21., poświęconym
typowi wyliczeniowemu,
który zastępuje konstrukcję
GPWO
, dostęp-
ną w języku 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. Zastępowanie struktur klasami
Konstrukcja
UVTWEV
języka C została usunięta z języka Java, poniewa za pomocą klasy
mo na zrealizować wszystko to, co potrafi struktura, a nawet więcej. 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 dostęp 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 języka Java niektórzy programiści korzystający z języka
C uwa ali, e klasy są zbyt obszerne, aby w pewnych sytuacjach zastąpić struktury.
90
Efektywne programowanie w języku Java
Nie będziemy się zajmowali tym problemem. Zdegenerowane klasy składające się jedynie
z pól danych są pewnym przybli eniem struktur z języka C:
6CMKG \FGIGPGTQYCPG MNCU[ PKG RQYKPP[ D[è RWDNKE\PG
ENCUU 2QKPV ]
RWDNKE HNQCV Z
RWDNKE HNQCV [
_
Poniewa takie klasy pozwalają na dostęp 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ć zastępowane klasami z polami
prywatnymi oraz publicznymi metodami je udostępniającymi:
*GTOGV[\QYCPC MNCUC Q HWPMELCEJ UVTWMVWT[
ENCUU 2QKPV ]
RTKXCVG HNQCV Z
RTKXCVG HNQCV [
RWDNKE 2QKPV HNQCV Z HNQCV [ ]
VJKUZ Z
VJKU[ [
_
RWDNKE HNQCV IGV: ]TGVWTP Z _
RWDNKE HNQCV IGV; ]TGVWTP [ _
RWDNKE HNQCV UGV: ]VJKUZ Z _
RWDNKE HNQCV UGV; ]VJKU[ [ _
_
Oczywiście twierdzenie to jest prawdziwe w odniesieniu do klas publicznych — je eli
klasa jest dostępna spoza swojego pakietu, rozwa ny programista powinien zabezpie-
czyć sobie mo liwość zmiany wewnętrznej reprezentacji danych. Je eli klasa publiczna
udostępnia 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 udostępnieniu pól danych — zakładając, e
naprawdę opisują abstrakcję definiowaną przez klasę. Podejście to generuje mniej kodu
ni wykorzystanie metod dostępowych, zarówno w definicji klasy, jak i w kodzie klientów
ją wykorzystujących. Poniewa kod klientów jest ściśle związany z wewnętrzną 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 zasięg zmian jest ograniczony do klasy nadrzędnej.
Kilka klas w bibliotekach języka Java nie dotrzymuje zalecenia, aby klasy publiczne nie
udostępniały bezpośrednio swoich pól. Przykładami takich klas są klasy
2QKPV
i
&KOGPUKQP
z pakietu
LCXCCYV
. 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