E-kniha: Návrhové vzory - Rudolf Pecinovský

Rudolf Pecinovský

Návrhové vzory

Computer Press

Brno

2013

Návrhové vzory

Rudolf Pecinovský

Odborná korektura: Jaroslava Pavlíčková

Obálka: Martin Sodomka

Odpovědný redaktor: Václav Kadlec

Technický redaktor: Jiří Matoušek

Objednávky knih:

http://knihy.cpress.cz

www.albatrosmedia.cz

eshop@albatrosmedia.cz

bezplatná linka 800 555 513

ISBN 978-80-251-1582-4

Vydalo nakladatelství Computer Press v Brně roku 2013 ve společnosti Albatros Media a. s. se sídlem

Na Pankráci 30, Praha 4. Číslo publikace 16 694.

© Albatros Media a. s. Všechna práva vyhrazena. Žádná část této publikace nesmí být kopírována

a rozmnožována za účelem rozšiřování v jakékoli formě či jakýmkoli způsobem bez písemného souhlasu

vydavatele.

Dotisk 1. vydání

Mé ženě Jarušce a dětem Štěpánce, Pavlínce, Ivance a Michalovi

Rudolf Pecinovský, 2007

Stručný obsah

Část 1: Zahřívací kolo Kapitola 1 Co je a k čemu je návrhový vzor 33 Kapitola 2 Zásady objektově orientovaného programování 39 Kapitola 3 Co konstruktor neumí (Jednoduchá tovární metoda

– Simple Factory Method) 57 Kapitola 4 Nehemži se mi pod rukama (Neměnné objekty

– Immutable objects) 65 Kapitola 5 Nenos mi to po jednom (Přepravka – Crate) 83 Kapitola 6 Udělám to za tebe (Služebník – Servant) 91 Kapitola 7 I nic může být objekt (Prázdný objekt – Null Object) 97 Část 2: Ovlivňujeme počet instancí Kapitola 8 Žádná instance (Knihovní třída – Library Class) 103 Kapitola 9 Jediná instance (Jedináček – Singleton) 107 Kapitola 10 Předem známé instance (Výčtový typ – Enumerated Type) 123 Kapitola 11 Dvojníky nepotřebujeme (Originál – Original) 135 Kapitola 12 Konečný počet instancí (Fond – Pool) 151 Kapitola 13 Příliš mnoho instancí (Muší váha – Flyweight) 171 Část 3: Nekoukej mi do kuchyně Kapitola 14 Pod ruce mi neuvidíš (Zástupce – Proxy) 189 Kapitola 15 Řekni, až to budeš chtít (Příkaz – Command) 195 Kapitola 16 Moc se mi v tom nehrab (Iterátor – Iterator) 203 Kapitola 17 Příliš mnoho rozhodování (Stav – State) 221 Kapitola 18 Já to umím, upřesni jen detaily (Šablonová metoda

– Template Method) 239 Část 4: Optimalizujeme rozhraní Kapitola 19 Je to zbytečně složité (Fasáda – Facade) 255 Kapitola 20 Je to trochu jinak (Adaptér – Adapter) 261 Kapitola 21 Bloudění strukturou (Strom – Composite) 271 Část 5: Vytvořte to univerzální Kapitola 22 Střihni mi to na míru (Tovární metoda – Factory Method) 279 Kapitola 23 Baťovy cvičky (Prototyp – Prototype) 285 Kapitola 24 Dosazujeme do vzorečku (Stavitel – Builder) 309 Kapitola 25 Bude toho víc (Abstraktní továrna – Abstract Factory) 329

Část 6: Zjednodušujeme program Kapitola 26 Příliš mnoho druhů tříd (Dekorátor – Decorator) 343 Kapitola 27 Horký brambor (Řetěz odpovědnosti

– Chain of Responsibility) 361 Kapitola 28 Až se to stane, dám ti vědět (Pozorovatel – Observer) 375 Kapitola 29 Telefonní ústředna (Prostředník – Mediator) 387 Část 7: Já se přizpůsobím Kapitola 30 Příště to může být jinak (Most – Bridge) 399 Kapitola 31 Vyberte si, jak to chcete (Strategie – Strategy) 415 Kapitola 32 Každý chvilku tahá pilku (Model-Pohled-Ovládání

– Model-View-Controller) 425 Kapitola 33 Tohle ještě neumíš (Návštěvník – Visitor) 453 Kapitola 34 Zpátky na stromy (Pamětník – Memento) 467 Kapitola 35 Tak si to naprogramuj sám (Interpret – Interpreter) 475 Část 8: Přílohy Příloha A Základy jazyka UML 511 Příloha B Seznam doporučené literatury 517

Stručný obsah6

Obsah Poděkování 17 Úvod 18

ČÁST 1

Zahřívací kolo

KAPITOLA 1 Co je a k čemu je návrhový vzor 33

Návrhové vzory a jejich katalogy 34

Které vzory budeme probírat 36

Shrnutí – co jsme se naučili 37 KAPITOLA 2 Zásady objektově orientovaného programování 39

Programovat proti rozhraní 40

Signatura 41

Kontrakt 42

Jak zásadu dodržovat 43

Návrh vlastního rozhraní 44

Důsledné skrytí implementace 44

Interní × publikované rozhraní 45

Podzásady 46

Zapouzdření a odpoutání částí kódu, které by se mohly měnit 47

Přednost skládání před dědičností 48

Soudržnost (cohesion): jedna entita → jeden úkol 50

Návrh řízený odpovědnostmi 52

Minimální vzájemná provázanost (coupling) 52

Vyhýbání se duplicitám v kódu 53

Nepodřizovat návrh snahám o maximální efektivitu 53

Shrnutí – co jsme se naučili 55

KAPITOLA 3 Co konstruktor neumí (Jednoduchá tovární metoda – Simple Factory Method) 57

Účel 58

Implementace 59

Příklad 61

Shrnutí – co jsme se naučili 63 KAPITOLA 4 Nehemži se mi pod rukama (Neměnné objekty – Immutable objects) 65

Účel 66

Hodnotové a referenční datové typy 66

Hodnotové objektové typy 67

Referenční datové typy 69

Neměnnost instancí v praxi 69

Implementace 73

Příklad 75

Příklad špatně definovaného potomka 81

Shrnutí – co jsme se naučili 81 KAPITOLA 5 Nenos mi to po jednom (Přepravka – Crate) 83

Účel 84

Implementace 85

Příklady ze standardní knihovny 86

Interní přepravka 87

Další příklady v doprovodných programech 90

Shrnutí – co jsme se naučili 90 KAPITOLA 6 Udělám to za tebe (Služebník – Servant) 91

Účel 92

Implementace 92

Příklad: Přesouvač 94

Shrnutí – co jsme se naučili 95

Obsah8

KAPITOLA 7 I nic může být objekt (Prázdný objekt – Null Object) 97

Účel 98

Implementace 98

Příklad 99

Shrnutí – co jsme se naučili 99

ČÁST 2

Ovlivňujeme počet instancí

KAPITOLA 8 Žádná instance (Knihovní třída – Library Class) 103

Účel 104

Implementace 104

Příklad 105

Shrnutí – co jsme se naučili 105 KAPITOLA 9 Jediná instance (Jedináček – Singleton) 107

Účel 108

Základní implementace 109

Časná inicializace = inicializace v deklaraci 109

Námitky proti veřejné konstantě 111

Odložená inicializace 112

Vícevláknové aplikace 114

Serializovatelnost 116

Speciální případy 117

Vlastní zavaděče tříd 117

Chyba v prvních verzích Javy 117

Jedináček s dědici 117

Shrnutí – co jsme se naučili 120 KAPITOLA 10 Předem známé instance (Výčtový typ – Enumerated Type) 123

Účel 124

Implementace 125

9Obsah

Starší verze Javy 125

Java 5.0 128

Funkční výčtové typy 131

Výčtové podtypy 132

Shrnutí – co jsme se naučili 133 KAPITOLA 11 Dvojníky nepotřebujeme (Originál – Original) 135

Účel 136

Implementace 137

Příklad 140

Shrnutí – co jsme se naučili 149 KAPITOLA 12 Konečný počet instancí (Fond – Pool) 151

Účel 152

Implementace 153

Univerzální fond 153

Příklad: Molekuly 163

Shrnutí – co jsme se naučili 169 KAPITOLA 13 Příliš mnoho instancí (Muší váha – Flyweight) 171

Účel 172

Implementace 172

Příklad – hra Diamanty 173

Shrnutí – co jsme se naučili 186

ČÁST 3

Nekoukej mi do kuchyně

KAPITOLA 14 Pod ruce mi neuvidíš (Zástupce – Proxy) 189

Účel 190

Implementace 191

Vzdálený zástupce 191

Virtuální zástupce 191

Ochranný zástupce 192

Obsah10

Chytrý odkaz 193

Příklad 193

Shrnutí – co jsme se naučili 194 KAPITOLA 15 Řekni, až to budeš chtít (Příkaz – Command) 195

Účel 196

Implementace 196

Příklad 197

Shrnutí – co jsme se naučili 202 KAPITOLA 16 Moc se mi v tom nehrab (Iterátor – Iterator) 203

Účel 204

Implementace 204

Příklad 209

Prázdný iterátor a iterovatelný objekt 218

Shrnutí – co jsme se naučili 220 KAPITOLA 17 Příliš mnoho rozhodování (Stav – State) 221

Účel 222

Implementace 223

Příklad 225

Shrnutí – co jsme se naučili 237 KAPITOLA 18 Já to umím, upřesni jen detaily (Šablonová metoda – Template Method) 239

Účel 240

Proč nemůže být šablonovou metodou konstruktor 244

Implementace 245

Příklad 250

Shrnutí – co jsme se naučili 251

11Obsah

ČÁST 4

Optimalizujeme rozhraní

KAPITOLA 19 Je to zbytečně složité (Fasáda – Facade) 255

Účel 256

Implementace 258

Příklad 259

Shrnutí – co jsme se naučili 259 KAPITOLA 20 Je to trochu jinak (Adaptér – Adapter) 261

Účel 262

Implementace 262

Univerzální adaptér 263

Adaptér obsahující adaptovaný objekt 266

Adaptér jako potomek adaptované třídy 267

Příklad 269

Shrnutí – co jsme se naučili 269 KAPITOLA 21 Bloudění strukturou (Strom – Composite) 271

Účel 272

Implementace 273

Příklad 275

Shrnutí – co jsme se naučili 276

ČÁST 5

Vytvořte to univerzální

KAPITOLA 22 Střihni mi to na míru (Tovární metoda – Factory Method) 279

Účel 280

Implementace 283

Příklad 284

Shrnutí – co jsme se naučili 284

Obsah12

KAPITOLA 23 Baťovy cvičky (Prototyp – Prototype) 285

Klonování a jeho vlastnosti 286

Účel vzoru Prototyp 290

Implementace 293

Příklad: Mnohotvar 294

Shrnutí – co jsme se naučili 306 KAPITOLA 24 Dosazujeme do vzorečku (Stavitel – Builder) 309

Účel 310

Implementace 312

Příklad 314

Způsoby zadávání textu 315

Sázecí stroje 317

Definice sazeče 322

Testovací autor 325

Možná rozšíření 327

Shrnutí – co jsme se naučili 327 KAPITOLA 25 Bude toho víc (Abstraktní továrna – Abstract Factory) 329

Účel 330

Implementace 333

Příklad 334

Shrnutí – co jsme se naučili 339

ČÁST 6

Zjednodušujeme program

KAPITOLA 26 Příliš mnoho druhů tříd (Dekorátor – Decorator) 343

Účel 344

Implementace 346

Příklad 348

Shrnutí – co jsme se naučili 360

13Obsah

KAPITOLA 27 Horký brambor (Řetěz odpovědnosti – Chain of Responsibility) 361

Účel 362

Implementace 363

Příklad 364

Shrnutí – co jsme se naučili 373 KAPITOLA 28 Až se to stane, dám ti vědět (Pozorovatel – Observer) 375

Účel 376

Implementace 377

Příklad 379

Shrnutí – co jsme se naučili 385 KAPITOLA 29 Telefonní ústředna (Prostředník – Mediator) 387

Účel 388

Implementace 389

Příklad 389

Shrnutí – co jsme se naučili 396

ČÁST 7

Já se přizpůsobím

KAPITOLA 30 Příště to může být jinak (Most – Bridge) 399

Účel 400

Implementace 402

Příklad 403

Shrnutí – co jsme se naučili 413 KAPITOLA 31 Vyberte si, jak to chcete (Strategie – Strategy) 415

Účel 416

Implementace 416

Obsah14

Příklad 419

Shrnutí – co jsme se naučili 424 KAPITOLA 32 Každý chvilku tahá pilku (Model-Pohled-Ovládání – Model-View-Controller) 425

Účel 426

Implementace 428

Příklad: Reversi (Othello) 429

Shrnutí – co jsme se naučili 452 KAPITOLA 33 Tohle ještě neumíš (Návštěvník – Visitor) 453

Účel 454

Implementace 454

Příklad 460

Shrnutí – co jsme se naučili 466 KAPITOLA 34 Zpátky na stromy (Pamětník – Memento) 467

Účel 468

Implementace 468

Příklad: Reversi s návraty 469

Shrnutí – co jsme se naučili 474 KAPITOLA 35 Tak si to naprogramuj sám (Interpret – Interpreter) 475

Účel 476

Implementace 477

Definice jednotlivých částí interpretu 480

Příklad: Aritmetické výrazy 488

Rozhraní IAritmVýraz 489

Třída Kontext 490

Konstanty a proměnné 494

Binární operátory 497

Třída Překladač 501

Použití interpretu v programu 505

Shrnutí – co jsme se naučili 507

15Obsah

ČÁST 8

Přílohy

PŘÍLOHA A Základy jazyka UML 511

Jazyk UML 512

Diagramy tříd 512

Datové typy 513

Vztahy mezi datovými typy 514

Diagramy tříd v prostředí BlueJ 515 PŘÍLOHA B Seznam doporučené literatury 517

Co číst 518

Jazyk UML 518

Návrhové vzory 518

Objektově orientované programování 519

Java 520

Jednotlivé články 520 Rejstřík 521

Obsah16

Poděkování

Vím, že se v českých knížkách většinou neděkuje, ale tahle silná kniha je spojena

s tolika pomocníky a tolika oběmi lidí z mého okolí, že bych měl velkou újmu na

duši, kdybych tak neučinil.

Chtěl bych především nesmírně poděkovat své ženě Jarušce, která byla po celou

dobu mojí největší oporou a která si za dobu mého psaní vysloužila již nejednu sva

tozář. Nemenší poděkování patří i dětem, které se mi také snažily v rámci svých mož

ností pomáhat: testovaly programy nebo za mne zařizovaly nejrůznější záležitosti,

abych měl rozumný klid na psaní.

Na vylepšování textu knihy se ale podílela řada dalších lidí. Mezi nimi musím podě

kovat především manželům Pavlíčkovým, kteří knihu velmi podrobně přečetli, upo

zornili mne na nejrůznější nesrovnalosti v textu a odchylky mezi popisovanou a sku

tečnou podobou doprovodných programů a kteří se ji na závěr uvolili ještě jednou

podrobně pročíst a zlektorovat. Naše debaty o správné interpretaci některých zásad

moderního programování a o některých vlastnostech popisovaných návrhových

vzorů byly občas poměrně vášnivé.

Knihu četla a připomínkami doplňovala i řada dalších lidí, mezi nimiž bych jmenoval

Frantu Hunku a Milana Šedého, jejichž soubory s přípomínkami byly také velmi

podrobné.

Rád bych touto cestou poděkoval i Michaelu Köllingovi a jeho spolupracovníkům,

jejichž myšlenky mne přivedly k nové metodice výuky a jejichž vývojový nástroj BlueJ

realizaci takto koncipované výuky vůbec umožnil.

Musím vyjádřit svůj velký dík také veškerému osazenstvu firmy Amaio Technologies.

Tito lidé mne k Javě přivedli a po celou dobu přípravy knihy mne všestranně pod

porovali. Upozorňovali mne na zajímavé články a oponovali některé programy. Bez

jejich podpory by kniha nevznikla.

Na závěr nesmím zapomenout ani na Václava Kadlece z nakladatelství Computer

Press, který dostal moji knihu na starost a který si se mnou užil, když se termín ode

vzdání neustále vzdaloval. Díky jeho trpělivosti a vstřícnosti se kniha po několika

odkladech konečně dostala do stavu, ve kterém ji otevíráte.

Úvod Znalost základních návrhových vzorů a schopnost je efektivně využívat ve svých programech patří ve světě k povinné výbavě zkušeného programátora. Knihy, které tuto oblast vysvětlují, patří k trvalým bestsellerům. V našich školách a programátorských kurzech se však tato problematika příliš neučí a řada programátorů (a to i těch, kteří se považují za zkušené) o existenci návrhových vzorů dokonce ani netuší. Před časem u nás vyšel překlad [10] knihy [16], která je dlouhodobým světovým bestsellerem a základní biblí návrhových vzorů, na niž se téměř všechny ostatní učebnice návrhových vzorů odvolávají (přesněji nepotkal jsem takovou, která by tak nečinila). Přeložená publikace se však u nás setkala s podivuhodným nezájmem. Nevím, zda to bylo ne zcela vydařeným překladem

1

nebo zda byl na vině styl příručky, který

pro průměrného programátora není příliš čtivý, anebo zda se na nezájmu podepsala i ignorace tohoto tématu ze strany vyučujících. Vypadá to zkrátka tak, že návrhové vzory u nás netáhnou.

Čísla v hranatých závorkách označují pořadí dané knihy v seznamu lite

ratury uvedeném v příloze Seznam doporučené a nedoporučené literatu

ry na straně 517.

Kniha [16] se v originále jmenuje Design Patterns s podtitulem Elements

of Reusable Object-Oriented Software. Poprvé vyšla v roce 1995 a napsa

la ji čtveřice autorů, která zanedlouho na to dostala přezdívku Gang of

four (banda čtyř) – ve zkratce GoF. Pod touto zkratkou se na jejich pub

likaci řada ostatních příruček odvolává, aby bylo zřejmé, že se odvoláva

jí právě na ni, a ne na nějakou z mnoha dalších knih, které mají termín

design patterns v titulu. Nebudu se proto odlišovat, a budu-li se někde

odvolávat na tuto publikaci, také ji označím zkratkou GoF. Vím, že je proto ode mne troufalé pokoušet se napsat další knihu, která by se věnovala této nesmírně důležité, avšak u nás stále opomíjené problematice, ale jako nenapravitelný optimista stále doufám, že návrhové vzory přece jenom získají v povědomí našich programátorů místo, které jim náleží. Přispěje-li k tomu i tato kniha, budu nesmírně potěšen.

Úvod18

1

Problémem českého překladu této publikace je bohužel to, že překladatel nebyl programá

tor, a na překladu je to často vidět. Přiznávám, že já jsem se po prvních kapitolách dopro

vázených nepublikovatelnými výkřiky zbaběle uchýlil k anglickému originálu. Pokusím se

proto na rozdíl od běžných zvyklostí prezentovat látku tak, abyste uvedenou příručku-bibli

nepotřebovali.

"

"

Koncepce knihy

Většina příruček zabývajících se problematikou návrhových vzorů probírané návrho

vé vzory pouze vyjmenuje (nejlépe podle abecedy) a u každého uvede jeho základ

ní princip a jeden či dva příklady jeho použití. V některých jejich autoři ještě učeně

pohovoří o možných důsledcích nebo o možné zastupitelnosti či spolupráci s jinými

vzory.

Zkušenost ukazuje, že takovýto přístup řadě programátorů nestačí. Takovýto výklad

pro ně často bývá příliš abstraktní. Potřebovali by vysvětlit řadu konkrétních otázek

a rozšířit množinu příkladů, na nichž se látka demonstruje a na nichž si ji pak mohou

sami vyzkoušet.

Mnozí programátoři přiznávají, že výše zmiňovanou „bibli“ GoF sice ve své knihov

ně mají, ale její vysvětlení příliš nechápou. Připadá jim jako kniha, kterou psali teo

retici pro teoretiky. Svoji snahu o pochopení návrhových vzorů z této příručky při

rovnávají k pokusu naučit se matematiku studiem sbírky vzorců.

Koncipoval jsem proto tuto příručku jako rozhovor mezi zkušeným a začínajícím pro

gramátorem. Jeho inspirací byly rozhovory, které jsem nad daným tématem vedl se

svými dětmi, s žáky a studenty, kteří navštěvují mé lekce programování, i s profesio

nálními programátory navštěvujícími mé kurzy, v nichž se přeškolují z klasického pro

gramování na programování objektově orientované.

Celý výklad jsem se snažil ilustrovat na takových příkladech, které jsou na jednu stra

nu dostatečně jednoduché, takže probíraná problematika se neztrácí v šumu ostatních

příkazů, ale které na druhou stranu nebudou jen nějaké AHA-příklady, jež pouze

demonstrují princip vzoru a chod programu simulují prostřednictvím tisků na stan

dardní výstup (i když se k nim, pravda, občas z nedostatku fantazie také uchýlím).

Pokusím se, aby většina programů v příkladech byla maximálně praktická, abyste

z nich mohli načerpat nějakou inspiraci pro své vlastní programy.

Tato kniha nechce být pouze výčtem základních návrhových vzorů, ale chce být

komplexní učebnicí současných zásad objektově orientovaného programování (to

jsem se ostatně pokusil naznačit i v jejím názvu). Zásad, o kterých se běžné učebni

ce většinou nezmiňují (přiznejme si, že se také většinou nejedná o učebnice progra

mování [by se to jejich titul snaží naznačit], ale pouze o učebnice syntaxe některého

jazyka).

V řadě případů autoři učebnic v demonstračních příkladech tyto zásady dokonce

porušují. Knih s různými, často do nebe volajícími prohřešky autorů bychom na trhu

našli více. (Doufám, že se mezi ně časem nezařadí kniha, kterou právě čtete.)

Na druhou stranu se v knize nesnažím o podrobný rozbor všech probíraných návrho

vých vzorů se všemi jejich vzájemnými vazbami a různými důsledky – to by musela být

daleko tlustší. Chci pouze čtenáře seznámit se základními návrhovými vzory tak, aby

pochopil jejich podstatu a princip a dokázal je později využít ve svých programech.

Detailní rozbory ponechávám akademičtěji orientovaným učebnicím – např. GoF.

19Úvod

Neučím jen

návrhové

vzory, učím

moderní

programování

Nebudu

zabíhat do

detailů

Co se mi na

většině

příruček

návrhových

vzorů nelíbí

Kniha je

záznam

rozhovoru

Příklady, na

nichž výklad

stojí

Na počátku každé kapitoly je stručná charakteristika vzoru, kterému se daná kapitola věnuje. Protože jsem se již několikrát setkal s tím, že studenti ode mne chtěli vedle mých volných popisů i přesné definice uváděné v GoF, doplnil jsem u vzorů uváděných v GoF do poznámky pod čarou i jejich originální definici a její překlad (nepřebíral jsem jej z [10], ale pokusil jsem se vytvořit vlastní). Tyto citace by vám mohly pomoci v orientaci při pročítání některých článků týkajících se návrhových vzorů uvedených v GoF. Otázky Kniha představuje záznam fiktivního rozhovoru se 625 otázkami. Oproti jiným příručkám s otázkami a odpově mi však v této knize nenajdete klasické dotazy, které nastolí problém, jenž je pak v odpovědi vyřešen. Obsah této knihy má opravdu simulovat zaznamenaný rozhovor, takže mezi otázkami najdete i výplňové otázky a na druhou stranu otázky, které již samy obsahují řešení problému a tazatel se pouze ubezpečuje, že toto řešení je správné. Koncepce knihy psané jako záznam rozhovoru má pro čtenáře několik výhod:

■ Udržuje jej daleko lépe „v obraze“ a umožňuje mu tak lépe sledovat výklad.

Čtenáři mých minulých rozhovorových knih mi dokonce psali, že je potěšilo,

když tazatel pokládal otázku, která je v průběhu čtení předchozího odstavce

napadla také.

■ Když někdy potřebuji vysvětlit něco, co přímo nesouvisí s probíraným téma

tem, mohu vás daleko snadněji navigovat, takže neztratíte nit hlavního výkla

du, což bývá u klasicky koncipovaného výkladu problém.

■ Otázky přesně oddělují části, které je třeba přečíst jako jeden celek. Soukromě

označuji způsob „konzumace“ takovéhoto textu termínem nádech – výdech.

Při čtení odpovědi na otázku čtenář vstřebává informace (nádech), aby se před

další otázkou v klidu zastavil a ujasnil si, že vše z předchozí pasáže pochopil

(výdech). Čeština Jedním z častých námětů bouřlivých diskusí mezi programátory, resp. mezi učiteli programování, je používání původních a přeložených termínů. Za dlouhou dobu své učitelské praxe jsem si vyzkoušel, že používání původních termínů v začátečnických kurzech není dobré řešení. Začátečníci mívají problémy s pochopením vlastní látky a přidání termínů, kterým nerozumějí (znalost angličtiny u nás stále není na takové úrovni, jakou bychom rádi viděli), jim situaci pouze ztěžuje. Když na začátečníka vybafnu např. název singleton, málokterý bude vědět, co to slovo znamená, a nezbude mu, než si je zapamatovat jako nějaký nový, cizí termín. Když se pak po pár týdnech výuky zeptám, jaké vlastnosti má návrhový vzor singleton, začnou žáci nejprve tápat, který z probraných vzorů to je, a v řadě případů jej zamění s nějakým jiným.

Úvod20

Citace

definicí

z GoF

Charakter

otázek

v knize

Výhody:

– výklad se

lépe sleduje

– nutné

odbočky méně

ruší

– čtení stylem

nádech – výdech

Proč

používám

české

termíny

Když naproti tomu použiji pro daný návrhový vzor termín jedináček, všichni si jej ihned pevně spojí se svojí představou jedináčka a nejenom že jej i po týdnech správně vyloží, ale navíc i lépe pochopí jeho podstatu. Prosím proto čtenáře, kteří jsou hrdí na svoji znalost angličtiny, aby se smířili s tím, že budu vycházet vstříc většině, která konstrukce označené českými termíny lépe pochopí a daleko lépe si je zapamatuje. Ti, kteří můj počeštěný výklad nepotřebují, se jistě již dávno poučili z některé z anglicky psaných učebnic (seznam některých z těch, které se staly zdrojem inspirace pro mne, najdete v příloze Seznam doporučené a nedoporučené literatury na straně 517). Protože je však programátorský svět veskrz anglický

1

, uvedu u každého termínu při

jeho zavedení i příslušný anglický ekvivalent. Všem vám pak doporučuji si tento ekvivalent zapamatovat, protože řada českých i slovenských autorů z nejrůznějších důvodů trvá na používání anglických termínů doplněných českými, resp. slovenskými koncovkami. Použité programovací jazyky Knihu jsem se snažil napsat maximálně nezávislou na konkrétním programovacím jazyku. Při jejím koncipování jsem přemýšlel nad tím, v jakých jazycích uvádět demonstrační příklady. Volil jsem mezi možností, uvádět všechny příklady v jediném jazyku anebo ukazovat řešení v několika jazycích současně. Protože jsem se bál, že by při příkladech ve více jazycích kniha neúměrně narostla, rozhodl jsem se zůstat u jediného jazyka a naprogramovat všechny příklady v Javě, která je v současné době nejpoužívanějším programovacím jazykem. Protože jsem tuto knihu psal především pro ty, kteří s objektovým programováním začínají, přihrála této volbě i skutečnosti, že Java je ve světě naprosto dominantním jazykem vstupních kurzů programování na univerzitách i středních školách

2

.

Připočteme-li syntaktickou blízkost jazyka C#, který byl vlastně odvozen z Javy, je zřejmé, že se čtením demonstračních programů nebudou mít problémy ani uživatelé tohoto jazyka. Těch pár drobných syntaktických odlišností by jim nemělo ztěžovat porozumění programům. Zásadní problém v porozumění by neměli mít ani uživatelé ostatních jazyků určených pro programování na platformě .NET, konkrétně jazyků Delphi a Visual Basic .NET. Vzhledem k blízkosti koncepce této platformy s koncepcí platformy Java by jim měla být většina termínů zřejmá. Pouze čtení programů pro ně bude trochu obtížnější, ale snažil jsem se používat pouze jednoduché dostatečně okomentované programy, takže by měly být i pro ně pochopitelné.

21Úvod

1

Když jsem po škole nastupoval v akademii, položil mi můj školitel otázku: „Umíte anglicky?“

Než jsem si zformuloval odpově , která by charakterizovala úroveň mých znalostí, odpově

děl si sám: „No ono je to jedno – bu to budete umět anglicky, nebo změníte zaměstnání.“

A totéž platí pro všechny, kteří se chtějí vážně zabývat programováním. 2

V naší republice sice na středních školách v současné době dominuje Delphi, ale učitelé

tohoto jazyka většinou objektové programování neučí. Navíc pozice tohoto jazyka neustále

slábne.

O anglické

termíny

nepřijdete

Rozhodování

o použitém

jazyku

Proč jsem

zvolil Javu

Text by měl

být čitelný

i pro

programátory

v jiných

jazycích

Byl bych rád, kdyby se z této učebnice mohli poučit i programátoři v C++. Je sice známou pravdou, že základem syntaxe Javy je syntaxe C++, ale způsob přemýšlení v Javě se od způsobu přemýšlení obvyklého u programátorů v C++ přece jenom liší a liší se i řada prvků jazyka. Obávám se proto, že programátoři v C++ budou mít se vstřebáním informací z této knihy větší problémy než programátoři jiných uvedených jazyků. Komu je kniha určena Kniha je určena programátorům, kteří mají základní znalosti objektově orientovaného programování v některém z moderních programovacích jazyků. Nejvýhodnější je pro její studium znalost jazyka Java, ale jak jsem již řekl, stejně dobře ji mohou číst i ti, kteří programují v některém z jazyků určených pro platformu .NET. Jinými slovy: je určena „absolventům“ začátečnických příruček programování, resp. absolventům začátečnických kurzů. Předpokládám pouze to, že čtenář zná základní strukturované konstrukce a ví, co jsou to třídy a jejich instance a jaký je rozdíl mezi třídou a rozhraním, a umí je ve svých programech rozhraní využívat. Ví, co jsou to atributy a metody, jaký je rozdíl mezi konstruktorem a běžnou metodou a jaký je rozdíl mezi atributy a metodami třídy (používá se pro ně označení statické) a instancí. Nepředpokládám však žádné hluboké znalosti. Ze zkušenosti vím, že řada kurzů objektově orientovaných jazyků toho o OOP stejně více nenaučí a řada programátorů používajících objektově orientované jazyky píše v těchto jazycích i nadále staré dobré strukturované programy. Proto se v této učebnici nehodlám omezit na pouhý výklad principů jednotlivých vzorů, ale chtěl bych vás seznámit i s některými obecnějšími zásadami moderního objektově orientovaného programování. Doprovodné příklady Všechny příklady, které budeme v této knize probírat, a to jak ty, u nichž budu uvádět jejich kompletní výpis, tak ty, u nichž vám tu ukážu jenom jejich klíčové části nebo se o nich dokonce pouze zmíním, najdete na adrese http://knihy.pecinovsky.cz/vzory. Všechny doprovodné materiály si můžete stáhnout také z adresy http://knihy.cpress.cz/k1348. Na této adrese vás očekávají dva soubory: první bude obsahovat programy, v jejichž definicích je použita diakritika obdobně, jako ji budu používat v programech, které najdete v textu knihy

1

. Druhý soubor bude označen zkratkou bhc (= bez hacku

a carek) a bude obsahovat tytéž programy, ale zbavené veškeré diakritiky.

Úvod22

1

Doufám, že mi to zapřisáhlí „nepoužívači diakritiky“ odpustí, ale při psaní té záplavy různých

textů mám používání diakritiky tak hluboko pod kůží, že mi činí problémy se při programo

vání hlídat, abych ji nepoužil. Je to obdobný problém, s jakým se potýkají programátoři, kteří

jsou z programů a e-mailů zvyklí diakritiku nepoužívat a pro změnu jim činí obtíže psaní běž

ného textu.

„Absol

ventům“

začátečnických

programátor

ských příruček

a kurzů

Předpoklá

dané

znalosti

Neomezuje se

pouze na

vzory, ale

vysvětluje

i obecné

zásady

moderního

programování

Kde je najdete

Diakritika

Struktura programů

Všechny programy mají jednotnou strukturu, jejíž jednotlivé části jsou odděleny řád

kovými komentáři, podle nichž se lze v programu rychleji orientovat. V doprovod

ných programech najdete vždy všechny oddělující řádkové komentáře. Nechávám si

je v programech pro případ, že bych se později k programu vrátil a chtěl něco dopl

nit. Kromě toho se podle těchto komentářů v programu mnohem lépe orientuji

a rychle poznám, které sekce daný program neobsahuje – např. že nemá definován

konstruktor.

Z výpisů určených pro publikaci v této knize jsem však nepotřebné řádkové oddělo

vače odstranil, abyste mi nevyčítali, že musíte platit za zbytečně potištěný papír.

Nelekněte se proto, že programy stažené z webu budou vypadat maličko jinak než

ty, které najdete v textu knihy.

Dokumentační komentáře tříd a metod začínají řádkem hvězdiček. Vyzkoušel jsem,

že začátečníkům takovéto výrazné oddělení jednotlivých metod napomáhá k lepší

orientaci v programu. Bude-li tato moje konvence ty zkušenější z vás obtěžovat, urči

tě je ve svém editoru dokážou pomocí jednoduchého regulárního výrazu hromadně

odstranit.

Konvence názvů

V doprovodných programech začínají názvy všech rozhraní písmenem I (např. IPosuv

ný) a názvy všech abstraktních tříd písmenem A (např. APosuvný). Vím, že v Javě se tato

konvence standardně nepoužívá (vynechám-li programy firmy Microsoft), ale ze své

praxe mám vyzkoušeno, že tato konvence usnadňuje začátečníkům orientaci v projek

tech.

Většinou používám v názvech tříd celá slova, ale někdy mi takto utvořené názvy při

padají příliš dlouhé, takže zvítězí má lenora a použiji v názvech zkratky. Doufám, že

i tak zůstávají programy přehledné.

Terminologie

Terminologie autorů programátorských příruček a lektorů kurzů programování není

jednotná. Řada autorů zcela ignoruje českou terminologii a používá jakousi czenglish

terminologii, u níž se nemusejí namáhat s vyhledáváním vhodného ekvivalentu, který

by začátečníkům pomohl termín pochopit.

Nicméně ani ti, kteří se snaží hovořit na své studenty česky, se v používaných termí

nech neshodují. Následující pasáž je proto věnována některým termínům, které byste

nemuseli znát nebo které jste zvyklí používat poněkud jinak.

Rozhraní × interface

Termín rozhraní se v objektově orientovaném programování používá ve dvou význa

mech:

23Úvod

Úvodní řádky

dokumentač

ních

komentářů

Není

jednotná

Dva významy

termínu

rozhraní

a) Druh datového typu označovaného v hlavičce klíčovým slovem interface.

b) Souhrn informací, které o sobě třída zveřejňuje. Při svém výkladu jsem dlouho narážel na problém, že jsem neuměl dostatečně jasně odlišit, kdy hovořím o rozhraní ve významu označeném jako a) a kdy o rozhraní ve významu b). S uvedeným problémem jsem dlouho zápasil a nakonec jsem se rozhodl, že budu standardně používat přeložený termín rozhraní (v řadě případů se beztak hovoří o rozhraní v obou významech současně), a v případě, když budu chtít zdůraznit, že hovořím o druhu datového typu, uchýlím se k nepřeloženému termínu interface, který budu navíc vysazovat „programovým“, tj. neproporcionálním písmem. Podrobněji se o dané problematice rozhovořím ještě jednou v podkapitole Programovat proti rozhraní na straně 40. Idiomy a návrhové vzory Někteří autoři rozlišují „pravé“ návrhové vzory (např. 23 vzorů publikovaných v GoF) a vzory, které podle nich nejsou plnohodnotnými návrhovými vzory, a nezaslouží si proto být mezi ně zařazovány. Označují je jako idiomy, případně používají jiné termíny. Přidávám se k těm, kteří tvrdí, že typického programátora nezajímá, je-li daný vzor „plnohodnotný“, ale zajímá jej, jak mu může daný vzor v jeho práci pomoci. Nebudu proto nijak rozlišovat mezi „plnohodnotnými“ a „ne-plnohodnotnými“ návrhovými vzory a budu pro všechny používat společný termín návrhový vzor. Méně známé termíny V dalším textu budu občas používat termíny, které nejsou v počítačové literatuře příliš běžné. Kdo četl moji učebnici Javy, tak je zná. Těm ostatním je nyní pro jistotu raději představím: Halda (anglicky heap) je název pro část paměti sloužící k alokaci (uložení) dynamicky vytvářených objektů. Kontejner je objekt sloužící k uchovávání jiných objektů. Mezi kontejnery patří nejenom klasické dynamické kontejnery, jako např. množina nebo seznam, ale i klasická pole, která jsou statickými kontejnery (statickými proto, že po jejich vytvoření již není možno změnit počet prvků, které se do nich vejdou). Literál je konstanta zapsaná v programu svojí hodnotou. Napíšete-li v programu 7 nebo “Ahoj”, použili jste literál. Obecně se používání literálů v programu považuje za nevhodné a doporučuje se dávat přednost používání pojmenovaných konstant. Překrytí metody (method overriding) je konstrukce, při níž potomek definuje metodu se stejnou charakteristikou (signaturou, tj. názvem metody a typy jednotlivých parametrů), jako má metoda předka. Při prácí s instancí potomka se pak vždy použije překrývající verze metody, a to i tehdy, vydává-li se instance potomka za instanci předka.

Úvod24

Nebudeme

návrhové vzory

kastovat

Halda

Kontejner

Literál

Překrytí

metody

Někteří autoři používají pro tuto konstrukci termín přepsání nebo předefinování metody. Tyto termíny odmítám používat, protože se tady nic nepřepisuje ani nepředefinovává. Toto není refaktorace. Rodičovská verze metody je pro všechny stále k dispozici. Prázdný odkaz je pouze jiný název pro odkaz s hodnotou null. Přetížení metody (method overloading) je konstrukce, při níž definujeme uvnitř jedné třídy několik metod se stejným názvem, ale různými sadami typů jejich parametrů. Správce paměti je modul virtuálního stroje, který spravuje haldu: alokuje na ní nové objekty a odstraňuje objekty nepoužívané. Řada autorů jej označuje anglickým termínem garbage collector (česky popelář nebo uklizeč). Vektor je alternativní termín pro jednorozměrné pole (odtud také získala svůj název kontejnerová třída java.util.Vector), tj. pro pole s jedním indexem (např. int[]). Vlastní instance třídy je instance, která je instancí dané třídy a není instancí žádného z jejích předků ani potomků. Vlastní třída instance je třída, pro niž je zmiňovaná instance její vlastní instancí. Zanořený typ (class – třída, enum – výčtový typ, interface – rozhraní) je typ, který je definován uvnitř jiného typu. V praxi se používají v drtivé většině případů pouze zanořené třídy. V některých situacích je však výhodné definovat i zanořená rozhraní a výčtové typy (se zanořeným rozhraním se setkáte i v doprovodných příkladech). Klíčovou vlastností všech zanořených tříd je to, že mohou pracovat i se soukromými členy své vnější třídy. Proto je také v programech zavádíme. V řadě případů představují dokonce jediný smysluplný způsob, jak celou situaci řešit (viz např. kapitolu Moc se mi v tom nehrab (Iterátor – Iterator) na straně 203). Existují tři druhy zanořených typů (jejich podobu ve zdrojovém kódu si můžete prohlédnout ve výpisu Ú.1):

■ Vnořená třída a rozhraní (embedded/nested class/interface) jsou typy, jejichž

definice jsou umístěné mezi definicemi metod a jsou doplněné modifikátorem

static. Platí pro ně totéž co pro obyčejné typy. Lze je používat nezávisle na

jejich vnější třídě. Jejich zanoření ovlivňuje pouze jejich „oslovování“, tj. název,

pod nímž jsou dostupné (a samozřejmě dosažitelnost soukromých členů své

vnější třídy).

Rozhraní (interface) a výčtové typy (enum) mohou být jenom zanořené. Defi

nujete-li rozhraní a/nebo výčtový typ uvnitř definice jiného typu bez modifi

kátoru static, překladač si jej „iniciativně“ doplní sám. Neuvedení modifikáto

ru static není tedy u těchto zanořených typů považováno za syntaktickou

chybu.

■ Vnitřní třídy (inner classes) je definována obdobně jako vnořená, pouze nemá

uveden modifikátor static. Její instance má skrytý atribut, kterým je odkaz na

přidruženou instanci její vnější třídy – bez ní nemůže existovat.

25Úvod

Prázdný

odkaz

Přetížení

metody

Správce

paměti

Vlastní

instance

třídy

Vlastní třída

instance

Zanořený typ

– Výhody

zanořených

typů

– Vnořené

třídy

a rozhraní

– Vnitřní třídy

Jak si možná někteří z vás domysleli, výčtový typ (enum) ani rozhraní (interfa

ce) se vám nepodaří definovat jako vnitřní, protože si případný chybějící modi

fikátor static překladač sám „iniciativně“ doplní.

■ Lokální třída (local class) je definována uvnitř bloku kódu. Jako lokální je

možné definovat pouze třídu. Výčtový typ (enum) ani rozhraní (interface) jako

lokální definovat nelze – je to syntaktická chyba.

■ Anonymní třída (anonymous class) je lokální třída pro jedno použití, tj. jejich instan

ce jsou vytvářeny pouze na jediném místě v programu. Vzhledem k jedinečnosti

použití dané třídy není třeba pro tuto třídu vymýšlet nějaký název, ale bývá pova

žováno za výhodnější umístit její definici jakou součást výrazu vytvářejícího její

instanci.

Výpis Ú.1: Stručný přehled druhů zanořených typů

package rup.česky.vzory._00_úvod;

public class ZanořenéTypy

{

/** Definice vnořené třídy je uvozena modifikátorem static. */

protected static class VnořenáTřída {}

/** Definice vnitřní třídy není uvozena modifikátorem static. */

public class VnitřníTřída {}

/** Metoda instance vnější třídy používající vlastní lokální třídu. */

void metodaLT ( final String par ) {

class LokálníTřída {}

}

/** Metoda instance vnější třídy používající vlastní anonymní třídu. */

void metodaAT ( final String par ) {

new Object() {

public String toString() { return null; }

};

}

}

Pro ty, kteří by si ještě chtěli připomenout některá základní pravidla práce s jednot

livými druhy zanořených tříd, jsem připravil třídu ZanořenéTypy2, obsahující trošku

podrobnější verzi, v níž jsou deklarované i metody a která obsahuje i jednoduchý tes

tovací program, jejž si můžete spustit. Definici třídy naleznete ve výpisu Ú.2. V této

definici jsou v některých třídách připraveny i zakomentované definice nepovolených

druhů atributů a metod, abyste si mohli vyzkoušet, že se při jejich odkomentování

překladač opravdu vzbouří.

Výpis Ú.2: Podrobnější přehled druhů zanořených typů

package rup.česky.vzory._00_úvod;

import rup.česky.společně.Dbg;

/*******************************************************************************

Úvod26

– Lokální třídy

* Třída ZanořenéTypy2 ukazuje definici zanořených tříd a ukázku jejich

* použití. Využívá metody <code>Dbg.kdoVolá(int,int), která vrací

* název volající metody, případně i její třídy.

*/

public class ZanořenéTypy2

{

//== NESOUKROMÉ METODY INSTANCÍ ================================================

/** Obyčejná metoda instance vnější třídy. */

void metoda () {

System.out.println(“Metoda instance vnější třídy: “ + Dbg.kdoVolá(2,0));

VnitřníTřída vnitřní = new VnitřníTřída();

vnitřní.instančníMetodaVnitřníTřídy();

}

/** Metoda instance vnější třídy používající vlastní lokální třídu. */

void metodaLT ( final String par ) {

/** Lokální třída je deklarována uvnitř bloku příkazů. Nesmí mít

* deklarovány modifikátory přístupu a nesmí mít statické členy.

* Nesmí používat lokální proměnné. Má-li používat lokální data,

* musí být deklarována jako konstanty.

*/

class LokálníTřída {

void metodaLokálníTřídy() {

System.out.println( par + “ Metoda: “ + Dbg.kdoVolá(2,0) );

}

}

LokálníTřída lt = new LokálníTřída();

lt.metodaLokálníTřídy();

System.out.println( “Metoda: “ + Dbg.kdoVolá(2,0) );

}

/** Metoda instance vnější třídy používající vlastní anonymní třídu. */

void metodaAT ( final String par ) {

/** Anonymní třída se od lokální liší pouze tím, že nemá jméno. */

new Thread() {

public void run() {

System.out.println( par + “V samostatném vlákně tisknu “ +

“ Metoda: “ + Dbg.kdoVolá(2,0) );

}

}.start();

}

//== VNOŘENÉ A VNITŘNÍ TŘÍDY ===================================================

/***************************************************************************

* Vnořená třída je uvozena modifikátorem static.

* Nejsou na ni kladena žádná omezení

*/

protected static class VnořenáTřída {

static String sa = “Statický atribut vnořené třídy”;

String ia = “Instanční atribut vnořené třídy”;

27Úvod

static void statickáMetodaVnořenéTřídy() {

System.out.println( “Metoda: “ + Dbg.kdoVolá(2,0) );

}

void instančníMetodaVnořenéTřídy() {

System.out.println( “Metoda: “ + Dbg.kdoVolá(2,0) );

}

}

/***************************************************************************

* Vnitřní třída není uvozena modifikátorem static, takže je navázána

* na konkrétní instanci. Nesmí obsahovat statické členy,

* s výjimkou konstant, jejichž hodnota je známa v době překladu.

*/

private class VnitřníTřída {

// static String sa = “Statický atribut vnitřní třídy”;

String ia = “Instanční atribut vnitřní třídy”;

// static void statickáMetodaVnitřníTřídy() {

// System.out.println( “Metoda: “ + Dbg.kdoVolá(2,0) );

// }

void instančníMetodaVnitřníTřídy() {

System.out.println( “Metoda: “ + Dbg.kdoVolá(2,0) );

}

}

//== TESTY A METODA MAIN =======================================================

/***************************************************************************

* Testovací metoda.

*/

public static void test()

{

ZanořenéTypy2 zt = new ZanořenéTypy2();

VnořenáTřída vnořená = new VnořenáTřída();

VnitřníTřída vnitřní = zt.new VnitřníTřída();

zt.metoda();

zt.metodaLT( “Lokální: “ );

zt.metodaAT( “Anonymní: “ );

VnořenáTřída.statickáMetodaVnořenéTřídy();

vnořená.instančníMetodaVnořenéTřídy();

vnitřní.instančníMetodaVnitřníTřídy();

}

/** @param ppr Parametry příkazového řádku - nepoužité */

public static void main(String[]ppr){ test(); }/*-*/

}

Úvod28

Použité konvence K tomu, abyste se v textu lépe vyznali a také abyste si vykládanou látku lépe zapamatovali, používám několik prostředků pro odlišení a zvýraznění textu. Důležité Texty, které chci zvýraznit, jsou vysazeny tučně. Názvy Názvy návrhových vzorů jsou stejně jako názvy firem a jejich

produktů vysazeny kurzivou. Citace Texty, které si můžete přečíst na displeji, např. názvy polí v dia

logových oknech či názvy příkazů v nabídkách, jsou vysazeny

tučným bezpatkovým písmem. Adresy Názvy souborů a internetové adresy jsou vysazeny obyčejným bez

patkovým písmem. Program Texty programů a jejich částí jsou vysazeny neproporcionálním

písmem. Kromě částí textu, které považuji je důležité zvýraznit nebo alespoň odlišit od okolního textu, najdete v textu ještě řadu doplňujících poznámek a vysvětlivek. Všechny budou v jednotném rámečku, který bude označen ikonou charakterizující druh informace, kterou vám chce poznámka předat.

Symbol jin-jang bude uvozovat poznámky, s nimiž se setkáte na počátku

každé kapitoly a ve kterých si povíme, co se v dané kapitole naučíme.

Obrázek knihy označuje poznámku týkající se používané terminologie.

Tato poznámka většinou upozorňuje na další používané termíny ozna

čující stejnou skutečnost.

Píšící ruka označuje obyčejnou poznám