Efektywne Programowanie W Języku Java.pdf

IDZ DO

PRZYK£ADOW Y ROZDZIA£

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

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

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

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.

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: