výuka objektově orientovaného programování na středních

MASARYKOVA UNIVERZITA V BRNĚ

FAKULTA INFORMATIKY

Diplomová práce

Výuka objektově orientovaného programovánína středních školách

Brno, 2003 Tomáš Foltýnek

- 2 -

ProhlášeníProhlašuji, že tato práce je mým původním autorským dílem, které jsem vypracoval

samostatně. Všechny zdroje, prameny a literaturu, které jsem při vypracování používal neboz nichčerpal, v práciřádně cituji s uvedením úplného odkazu na příslušný zdroj.

PoděkováníDěkuji RNDr. Jaroslavu Pelikánovi, Ph.D. za vedení této práce. Dále děkuji Mgr.

Marku Blahovi za to, že mi věnoval svůj čas a zejména v počátcích mé práce mi poskytl cennéinformace pramenící z jeho pedagogické praxe.

- 3 -

ShrnutíTato práce obsahuje zhodnocenívývojových prostředí podporujících objektově

orientované programování z hlediska jejich vhodnosti pro výuku na středních školách. Dáleobsahuje praktickou realizaci sady programů v jazyce Object Pascal a prostředí Borland Delphi,na kterých si studenti středních škol osvojí zásady a metody objektově orientovaných návrhůaplikací. Jednotlivé programy jsou doplněny i metodickými pokyny pro učitele.

Klíčová slovaOOP, Objektově orientované programování, Object Pascal, Delphi, Výuka

programování, Příklady pro výuku programování,

Obsah

- 4 -

Obsah1 ÚVOD.......................................................................................................................................................6

2 CÍLE VÝUKY INFORMATIKY NA ST ŘEDNÍ ŠKOLE...................................................................8

3 CÍLE VÝUKY OOP..............................................................................................................................103.1 PROČ UČIT OOP................................................................................................................................103.2 KONKRÉTNÍ CÍLE VÝUKY ..................................................................................................................10

4 PROSTŘEDÍ PRO VÝUKU OOP.......................................................................................................124.1 OBJECTPASCAL................................................................................................................................124.2 DELPHI..............................................................................................................................................124.3 C++ ..................................................................................................................................................124.4 EIFFEL ..............................................................................................................................................134.5 SMALL TALK .....................................................................................................................................134.6 JAVA .................................................................................................................................................14

5 POROVNÁNÍ OBJEKTOVÝCH JAZYK Ů .......................................................................................155.1 PROČ UČIT OBJECTPASCAL ..............................................................................................................155.2 PROČ NEUČIT OBJECTPASCAL..........................................................................................................155.3 PROČ UČIT C++.................................................................................................................................155.4 PROČ NEUČIT C++ ............................................................................................................................165.5 PROČ UČIT DELPHI............................................................................................................................165.6 PROČ NEUČIT DELPHI........................................................................................................................165.7 PROČ UČIT JAVU ...............................................................................................................................165.8 PROČ NEUČIT JAVU ...........................................................................................................................175.9 PROČ UČIT SMALL TALK ....................................................................................................................175.10 PROČ NEUČIT SMALL TALK .............................................................................................................175.11 PROČ UČIT EIFFEL...........................................................................................................................175.12 PROČ NEUČIT EIFFEL.......................................................................................................................175.13 CO TEDY UČIT .................................................................................................................................18

6 VÝUKA OBJECT PASCALU..............................................................................................................196.1 VSTUPNÍ ZNALOSTI...........................................................................................................................196.2 ZAPOUZDŘENÍ...................................................................................................................................196.3 DĚDIČNOST.......................................................................................................................................206.4 POLYMORFISMUS..............................................................................................................................21

7 VÝUKA BORLAND DELPHI .............................................................................................................227.1 VSTUPNÍ ZNALOSTI...........................................................................................................................227.2 SEZNÁMENÍ S PROSTŘEDÍM A VYTVO ŘENÍ PRVNÍ APLIKACE..............................................................227.3 PSANÍ KÓDU......................................................................................................................................237.4 REAKCE NA UDÁLOST.......................................................................................................................237.5 UDÁLOSTI VYVOLANÉ MYŠÍ ..............................................................................................................247.6 KOMPONENTATEDIT .......................................................................................................................267.7 KOMPONENTYTCHECKBOX A TRADIOBUTTON ...................................................................................277.8 VÝJIMKY ...........................................................................................................................................287.9 PRÁCE SČASEM A KOMPONENTATMAINMENU...................................................................................297.10 KOMPONENTATSCROLLBAR ...........................................................................................................307.11 MODÁLNÍ A NEMODÁLNÍ FORMULÁ ŘE ............................................................................................317.12 VLASTNOSTI FORMULÁŘE A OBJEKTSCREEN ..................................................................................327.13 RTTIOPERÁTORY A PARAMETRSENDER.........................................................................................347.14 KOMPONENTYTLISTBOX A TCOMBOBOX.........................................................................................347.15 GRAFICKÝ VÝSTUP: TŘÍDA TCANVAS ..............................................................................................367.16 KOMPONENTATIMAGE ...................................................................................................................387.17 VYTVÁŘENÍ KOMPONENT ZA BĚHU PROGRAMU..............................................................................397.18 DIALOGY ........................................................................................................................................407.19 MŘÍŽKY ..........................................................................................................................................417.20 DYNAMICKÁ POLE ..........................................................................................................................437.21 KOMPONENTATMEMO .....................................................................................................................43

Obsah

- 5 -

7.22 NÁSTROJOVÁ LIŠTA A STAVOVÝŘÁDEK .........................................................................................457.23 DALŠÍ VÝUKA .................................................................................................................................467.24 FUNKCE VÝVOJOVÉHO PROSTŘEDÍ..................................................................................................477.25 FORMA VS. OBSAH..........................................................................................................................487.26 PŘEDDEFINOVANÉ APLIKACE A EXPERTI.........................................................................................49

8 DLOUHODOBÉ PROJEKTY .............................................................................................................508.1 VÝHODY DLOUHODOBÝCH PROJEKTŮ...............................................................................................508.2 NEVÝHODY DLOUHODOBÝCH PROJEKTŮ...........................................................................................508.3 DLOUHODOBÉ PROJEKTY: ANOČI NE................................................................................................508.4 ZÁSADY DLOUHODOBÝCH PROJEKTŮ................................................................................................518.5 TÉMATA DLOUHODOBÝCH PROJEKTŮ ...............................................................................................52

9 ZÁVĚR...................................................................................................................................................54

LITERATURA .........................................................................................................................................55

INTERNETOVÉ ZDROJE .....................................................................................................................56

PŘÍLOHA: DALŠÍ P ŘÍKLADY.............................................................................................................57

Úvod

- 6 -

1 ÚvodInformatika patří mezi nejmladší učební předměty, které se na našich školách vyučují.

Pokud se zabýváme informatikou jako vědou, respektive společenským fenoménem, nenípochyb o tom, že se jedná o obor velmi dynamický, jehož priority a základy se mění takřkaz roku na rok. Není proto divu, že také informatika jako učební předmět, který má studentypřipravovat k tomu, aby se ve světě výpočetní techniky dokázali orientovat, je předmět, jehožnáplň prochází poměrně dramatickým vývojem. Informatika jako předmět totiž musí studentynaučit nejen orientaci v současném světě výpočetní techniky, ale i znalostem, které uplatnív každém vývojovém stadiu tohoto oboru.

Mezi témata, které učitelé do výuky informatikyči výpočetní techniky zařazují, sepoměrně nedlouhořadí také objektově orientované programování (dále jen OOP). Důvodů protuto skutečnost je hned několik. Tím prvním je bezesporu to, že znalost alespoň základníchpravidel objektového programování je v praxi poměrně hodně ceněná. Aplikace s grafickýmuživatelským rozhraním, které jsou zpravidlařízené událostmi, bychom si bez objektovéhopřístupu představovali jen velmi těžko. Dalším důvodem je to, že výuka OOP přirozeněnavazuje na výuku programování jako takového. Posledním důvodem je pak skutečnost, žeOOP je odvětví poměrně moderní. Studenti, kteří se o výpočetní techniku zajímají také mimoškolu, často slýchávají o věcech jako Delphi, C++či Java, a rádi by se dozvěděli, co se zatěmito názvy skrývá. Proto je to nezřídka právě iniciativa studentů, co učitele přivede k tomu,aby objektově orientované programování do výuky zařadil.

Ne každý učitel má dostačující vědomostní základy na to, aby mohl objektově

orientované programování učit. I ten, který má dostatečné vědomosti, se může potýkats nedostatkem programátorské praxe v tomto oboru. Ani dobrá úroveň teoretických znalostí, aniprogramátorská praxe však nejsou uspokojivou zárukou pedagogického úspěchu. Učitel musímetodiku své výuky důkladně promyslet. Musí zvážit, jaké prostředky k výuce použije, jakýmzpůsobem bude studenty motivovat, na co bude klást důraz, co naopak může uvést jen okrajově.To jsou však jen ty nejzákladnější okruhy učitelových úvah. Za každým okruhem se skrývámnoho otázek, na které učitel, uvažující o výuce objektově orientovaného programování, budemuset odpovědět. Mnohdy budou odpovědi v kontextu konkrétní školy a konkrétní skupinystudentů zřejmé, mnohdy bude hledání odpovědi náročnější.

Je třeba zdůraznit, že tato práce není učebnicí OOP. Znalost OOP, načerpaná např.z [28], je již u čtenáře této práce předpokládána. Úkolem této práce je především pomociučitelům, kteří chtějí OOP učit. Přestože na spoustu otázek neodpoví přímo, uvádí možnévýhody a nevýhody téči oné odpovědi. V žádném případě není cílem této práce jednoznačnýzávěr, jaký způsob je při vedení výuky OOP nejlepší. Ani být nemůže. Vše záleží totiž nejen nakonkrétní škole, konkrétním učiteli, ale i očekávaném uplatnění studentů a aktuálním vývojivýpočetní techniky. Tato práce by měla být metodickou pomůckou do té doby, dokud budeOOP učebním tématem informatiky, ať se tento předmět jmenuje jakkoli.

I zkušený učitel, který má v metodice výuky dávno jasno, zde však najde množstvípříkladů, které jsou při výuce použitelné buďto přímo, nebo mohou posloužit jako inspirace přivymýšlení příkladů nových. Přestože jsou všechny příklady napsány v prostředí Borland Delphi,velká většina z nich nevyužívá specifik tohoto prostředí a jsou tak s drobnými úpravamipřenositelné na výuku OOP v jiném vývojovém prostředí nebo dokonce v jiném programovacímjazyce. Příklady tvoří těžiště této práce. Správnou metodiku lze totiž zvolit zejména na základě

vrozených vloh, nabytého pedagogického vzdělání či konzultacemi se zkušenějšími kolegy. Alepříklady jsou věcí, bez nichž se při výuce neobejde nikdo. I sebezkušenějšímu učiteli tato prácemůže pomoci tím, že mu ušetří čas potřebný na jejich vymýšlení.

Většina příkladů je včleněna přímo do textu práce, ostatní pak tvoří její přílohu.V nadpisu příkladu je vždy uvedeno slovo „Příklad“. Pro názornost je text příkladu doplněnobrázkem. Kromě toho je většina uvedených příkladů dostupná na doprovodném CD, a tovčetně svých zdrojových kódů. Text ke každému příkladu je rozdělen do několika částí, přičemžněkteré z nich mohou být vynechány, pokud nejsou relevantní:

Úvod

- 7 -

� Procvičované znalosti: Tento odstavec obsahuje heslovitý výčet dovedností, které sestudenti na příkladu naučí. Je uveden především pro usnadnění orientace učitele.

� Legenda: Je-li příklad převzat z praxe nebo se k příkladu váže nějaká legenda, je uvedenaprávě v tomto odstavci. Text v tétočásti může být použit pro motivaci studentů.

� Zadání: Zde je uvedeno stručné a pokud možno jednoznačné zadání toho, co mají studentinaprogramovat. V zadání se mohou vyskytnout odkazy na legendu. Zadání je formulovánove vztahu ke studentům a je uváděno v imperativu.

� Poznámky: Zde jsou uvedeny instrukce a rady, které studentům pomohou zadaný problémřešit.

� Použitý algoritmus: Je-li úlohařešitelná různými algoritmy a algoritmus představujestěžejníčást příkladu, je uveden popis algoritmu použitého ve vzorovémřešení příkladu nadoprovodném CD.

� Možná rozšíření: Každý program lze vylepšit. Platí to zejména o jednoduchých programech,které slouží jako příklady v této práci. Nadaní studenti, kteří zadání splní dříve než ostatní,mohou pracovat na vylepšení svého programu. Důležité upozornění: Možná rozšíření uněkterých příkladů vyžadují nadstandardní znalosti, které se mnohdy na středních školáchnevyučují. Je proto třeba zvážit, zda je vhodné tato rozšíření studentům doporučovat,případně jim zajistit relevantní studijní materiály.

� Možné alternativy: Lze-li konkrétní programátorskou dovednost demonstrovat na vícealternativách téhož příkladu, jsou možné alternativy u příkladu uvedeny.

Cíle výuky informatiky na střední škole

- 8 -

2 Cíle výuky informatiky na st řední školeNa základním cíli informatiky jako učebního předmětu se asi všichni shodnou: Naučit

studenty zacházet s počítačem. To je ovšem cíl natolik široký, že si jeho realizaci praktickynelze konkrétně představit. Cílem výuky informatiky nazákladních školácha na nižšíchstupních víceletých gymnázií je naučit studenty zacházet s počítačem jako uživatelé. Musí setedy naučit rozeznávat jednotlivéčásti počítače, pochopit základní principy jejich fungování anaučit se s počítačem komunikovat pomocí textového a grafického rozhraní. Další fází je pakvýuka nejběžnějších uživatelských dovedností, jakými jsou psaní textů, práce s grafikou, tvorbatabulek a práce s různými aplikacemi. Na některých školách je již v tomto věku zařazovánavýuka programování jako prostředku k učení algoritmizace, logického a analytického myšlení ařešení problémů. Přestože dovednosti nabyté výukou programování studenti v drtivé většiněpřípadů v praxi nevyužijí, je jejich výuka důležitá zejména kvůli rozvoji zmíněných foremmyšlení.

V této fázi znalostí studentů většinou výuka informatiky končí. Pouze naspecializovaných středních školách, například se zaměřením na matematiku nebo přímo naprogramování, výuka informatiky a programování pokračuje. Cílem těchto škol totiž není jennaučit studenty pracovat s počítačem jako uživatelé. U studentů specializovaných tříd sepředpokládá studium vysoké školy příslušného zaměření a nezřídka i pozdější výzkumná práce.Cíl základní školy, která vychovává pouze konzumenty informačních technologií, je natakovýchto školách překonáván. Studenti roli konzumenta zpravidla dokonale zvládají a mají-lise v oblasti informačních technologií dále rozvíjet, je třeba si vytyčit cíl nový, vyšší. Máme zdena výběr několik možností:

� Vychovat dobré programátory� Vychovat schopné administrátory a správce sítě

� Vychovat teoreticky dobře připravené výzkumné a vývojové pracovníky

Nedá se jednoznačně říci, který z cílů bychom měli preferovat. Pro studenty je v tomtookamžiku také příliš brzo, aby si svůj cíl zvolili sami. Proto bychom jim na střední škole měliposkytnout dostatečný základ pro všechny zmíněné cíle. Při výběru vysoké školy se pakstudenti rozhodnou, kterému z nich dají přednost.

Rozhodně tedy výuku informatiky směřující k dalším cílům zahájíme tématem, které jenezbytné pro dosažení všech těchto cílů. Tímto tématem je bezesporu tvorba algoritmů achápání počítačů „zevnitř“. Prvním úkolem tedy je, naučit studenty programovat, a tov kterémkoli vhodném programovacím jazyce. K výuce programování jako takového senejčastěji používá jazyk Pascal, který byl pro výukové účely vytvořen. Otázkou k diskusizůstává, jak moc je tento jazyk z výukového hlediska vhodný, nicméně to není tématem tétopráce.

Naučit studenty programovat je však jen první krok, který musíme udělat. Jehorealizace nám zpravidla zaberečasový úsek v délce okolo dvou let. Po něm máme na výběrněkolik možností. Jejich zvolením se ve větší či menší míře přiblížíme k některému zezmíněných cílů, stále se však jedná o dovednosti, které uplatní pravděpodobně všichni.

� Výuka jiného programovacího jazyka, nejčastěji jazyka C. Tento posun je pro studentypřínosem zejména v tom, že při řešení zadaných úkolů používají stejné principy v myšlení,pouze při komunikaci s počítačem používají jiný prostředek, zvláště pak jinou syntaxi.Abstrakce od konkrétní syntaxe je velice důležitá, pokud chceme, aby si studenti vštípilipředevším obecné principy a konkrétní formě zápisu nepřikládali takovou důležitost.Důkladně si tak ujasní rozdíl meziobsahemsdělení a jeho formou a v pozdější praxinebudou tyto složky zaměňovat.

� Výuka teoretické informatiky. Do této kapitoly školy většinou zařazují výuku teorieformálních jazyků, gramatik, automatů a operačních systémů. Tyto znalosti pak studentivyužijí na vysoké škole se zaměřením na informatiku, kde tak budou mít oproti studentům,

Cíle výuky informatiky na střední škole

- 9 -

kteří touto výukou na střední škole neprošli, značný náskok. Pokud škola přistoupí k výucetěchto znalostí, je dobré hodiny informatiky rozdělit na teoretické, ve kterých se probírajízmíněné věci, a praktické, ve kterých se studenti učí praktické věci, které se zmíněnou teoriívůbec nesouvisejí nebo souvisejí jen velmi okrajově. Důvod je zřejmý: Teorie formálníchjazyků a operačních systémů se takřka nedá procvičovat na počítači.

� Poslední oblastí, o které se zmíníme, je výuka objektově orientovaného programování. Tapatrně tvoří nejpřirozenější pokračování výuky, neboť přímo navazuje na nabyté znalostiprogramování a tvoří další stupeň programátorských znalostí a dovedností. Tato výukau studentů prohlubuje analytické myšlení, učí správné dekompozici problémů a za jistýchokolností může podporovat učení týmové spolupráce.

Velice záleží na konkrétní škole a na tom, kolikčasu výuce informatiky věnuje. Je takve většině případů prakticky nemožné stihnout studenty pořádně naučit všechny popsanéoblasti. Podařit se to samozřejmě může, ale jen ve třídách, které mají dostatečný počet hodininformatiky už od prvních ročníků nižších tříd víceletého gymnázia, a i v takových třídách se totýká jen té nejlepší skupiny.

Ve skupinách, ve kterých se nestihnou probrat všechny zmíněné oblasti, je třebaněkterým z nich přiřadit větší prioritu a ty pak učit, zatímco jiné probrat jen okrajově, popřípaděvypustit úplně. Těžko se hledají objektivní kritéria pro srovnání. Už jenom proto, že studentydělí od nástupu do praxe téměř deset let, což je v informatice doba natolik dlouhá, že nikdonemůže vědět, co budou studenti opravdu potřebovat.

V následujícím textu se budeme věnovat především poslednímu tématu, a to výuceobjektově orientovaného programování.

Cíle výuky OOP

- 10 -

3 Cíle výuky OOP

3.1 Proč učit OOPNyní si uvedeme několik důvodů, proč učit studenty právě objektově orientovanému

programování. Samozřejmě si lze představit minimálně stejně pádné argumenty, proč učit něcojiného. Tyto argumenty nám jistě poskytnou obdobné práce na jiná témata.

� Objektově orientované programování učí dalšímu stupnianalytického myšlení. Díky tomu,že je to k dokonalosti dovedené strukturované programování, studenti se s objektově

orientovaným programováním naučí řádnédekompozici problémů. Tato schopnost se jimpak bude hodit nejen při řešení programátorských problémů, ale i při řešení praktickýchproblémů běžného života.

� Studenti budou během výuky nuceni pochopit další stupeň abstrakce. Je jím rozdíl meziobjektovým typem(třídou) a konkrétníinstancí objektu(objektem). To je něco zcela nového,s čím se doposud nesetkali. Rozšíří se tak obzory jejich chápání, což je opět věc, kterouvyužijí nejen při programování.

� Objektově orientované programování je velmi užitečné v praxi, a to zejména díky tomu, žepřímo souvisí sudálostmi řízeným programováním,bez nějž bychom si nedokázalipředstavit jakékoliv grafické rozhraní. Okna, ikony, tlačítka – to vše jsou objekty, kterénějakým způsobem reagují na události. Protože grafické rozhraní je věc, se kterou sestudenti každodenně setkávají, máme tak při výuce jednak příklad, na kterém lze principyřízení událostmi předvádět, a jednak mají studenti pocit, že jim to později k něčemu bude,což je pocit velmi důležitý při výucečehokoliv.

� Objektově orientované programování podporuje týmovou spolupráci. Je tak rozšířené mimojiné proto, že je velmi jednoduché postupovat při řešení problému společně ve skupiněvývojářů. Stačí se společně dohodnout na dekompozici problému a komunikačníchrozhraních, poté už každý sám pokračuje tvorbou konkrétních objektů. Mají-li se studenti(alespoň někteří) v budoucnu živit jako programátoři, je velmi důležité naučit je pracovatv týmu. A to se nejlépe učí právě s využitím OOP. Opět je na místě dodat, že týmováspolupráce je věc, kterou studenti později využijí nejen při programování.

� Studenty bude výuka bavit. Jestliže máme skupinu studentů, kteří se naučili dobřeprogramovat, lze předpokládat, že je programování jako takové baví, a že se mu věnují imimo školu. V tom případě se nám bude OOP učit poměrně snadno, protože nebude potřebastudenty náročně motivovat (jako by tomu bylo například v případě výuky různých teorií).

3.2 Konkrétní cíle výukyJak již vyplývá z výše zmíněného, výuka objektově orientovaného programování je

prostředkem k dosažení určitých cílů. Toto bychom měli mít při výuce neustále na paměti.Nikdy se pro nás nesmí stát prostředek cílem. Nesmí tedy být cílem naučit studenty objektověprogramovat. Je to jen pomůcka, jejímž prostřednictvím si studenti osvojí daleko obecnějšía užitečnější znalosti a dovednosti. Přestože už byly na různých místech zmíněny, uvedeme jeještě jednou, tentokrát stručně a na jednom místě.

� Rozvoj analytického myšlení� Rozvoj abstraktního myšlení� Správná dekompozice problémů� Týmová spolupráce� Rozdíl mezi obsahem a formou

Až budeme s výukou objektově orientovaného programování hotovi, nemělo by námjako učitelům k uspokojení stačit pouhé konstatování, že jsme studenty naučili objektověprogramovat. Měli bychom se zamyslet nad tím, zda jim naše výuka kromě nabytých

Cíle výuky OOP

- 11 -

dovedností dala něco víc, zda splnila vytčené cíle. Teprve pokud si na tuto otázku dokážemeodpovědět kladně, můžeme považovat výuku objektově orientovaného programování zaúspěšnou.

Prostředí pro výuku OOP

- 12 -

4 Prost ředí pro výuku OOPJednou z prvních otázek, na kterou si učitel uvažující o výuce objektově orientovaného

programování musí odpovědět, je bezesporu to, v jakém jazyce a v jakém vývojovém prostředíbude toto téma učit. Zde jsou základní charakteristiky dostupnýchvývojových prostředí, kterápro výuku OOP přicházejí v úvahu.

4.1 Object PascalZákladem jazyka Object Pascal byl programovací jazyk Pascal, který vyvinul profesor

Niclaus Wirth na konci šedesátých a začátku sedmdesátých let dvacátého století. Prvnípublikace o Pascalu je datována do roku 1971. Jméno Pascal bylo vybráno jako vzpomínka nafrancouzského matematika a filosofa Blaise Pascala. V roce 1983 byl dokumentem ISO 7185definován standard tohoto jazyka. Objektovým se Pascal stal v polovině sedmdesátých let, kdybyla do jazyka zvaného Pascal Plus zavedena konstrukceENVELOPE. První jazyk, nazývanýskutečně Object Pascal, byl v polovině osmdesátých let vyvinut Larrym Teslerem a NiclausemWirthem za podpory firmy Apple Macintosh. Tento jazyk byl určen výhradně pro počítačeApple. Přibližně v roce 1990 byl do Quick Pascalu (Microsoft) a Turbo Pascalu (Borland)zaveden datový typOBJECT. Podpora objektů je v obou systémech podobná, není však úplně

shodná. Dnes se pod názvem Object Pascal většinou rozumí programovací jazyk používanýfirmou Borland v jejím produktu Delphi.

4.2 DelphiDelphi, striktně vzato, není programovací jazyk. Delphi je vývojové prostředí pro

programátory v Object Pascalu. Na druhou stranu, Delphi přináší do Object Pascalu některározšíření a úpravy přímo v definici jazyka, proto bychom se o něm zmínit měli. Navíc taképroto, že je to významný kandidát na výukové prostředí, ve kterém se nakonec rozhodnemeOOP učit.

Delphi, produkt firmy Borland, je profesionálnívývojové prostředí sloužící k tvorběaplikací pod Microsoft Windows. Jeho základním rysem je tedy značná systémová závislost. Zazmínku stojí také Kylix, což je linuxová verze Delphi sloužící k psaní programů pro tentosystém.

4.3 C++C++ je objektové rozšíření jazyka C. Oproti jazyku C však zavádí i další novinky, které

s objektovým přístupem souvisejí jen okrajově. Nalezneme zde mnohonásobnou dědičnost,virtuální třídy, možnost dynamického spravování paměti, využití šablon a již definovanýchvzorů (kontejnery, seznamy...), plně podporovaný polymorfismus, přetěžování operátorů, funkcía třídních metod. Jazyk C++ umožňuje také zajištění obsluhy a manipulaci s výjimkami,poskytuje silnou typovou kontrolu, velmi elegantní práci s vstupními/výstupními proudy a taképoužití ukazatelů. Struktura programů je přehledná a umožňuje snadné intuitivní pochopeníproblému.

Jazyk C vytvořil v Bellových laboratořích AT&T Denis Ritchie v roce 1972. Záměrembylo napsat jazyk pro snadnou a přenositelnou implementaci Unixu. Na tomto díle se dálepodíleli Brian Kernighan a Ken Thompson, a tak v roce 1973 vznikl Unix napsaný v C.

Jazyk C vznikl jako systémový jazyk pro systémové programátory. Pořadu let bylafaktickou normou jazyka knihaProgramovací jazyk Cautorů Kerninghana a Ritchieho, kterábyla vydána v roce 1978. Jazyk umožňoval programátorům nejrůznější metody zhutňovánízdrojového textu, které jej všakčinily značně nečitelným. Nicméně s postupemčasu se s Ca Unixem seznamovali studenti na vysokých školách, odcházeli do praxe a začali používat Ci v jiných než systémových oblastech. Uživatelé přirozeně požadovali, aby C bylo nejenmocným prostředkem (tím bylo od svého vzniku), ale i bezpečným a přehledným jazykem.Rovněž vznikl trend vedoucí k normalizaci jazyka. S postupem doby se nezastavila ani teorie


- 13 -

programování. Jestliže C umožňuje psát programy modulárně, dnešní trend vyžaduje i podporuobjektového přístupu.

Již v roce 1978 se začal Bjarne Stroustrup zabývat otázkou objektových přístupův jazyce C a kolem roku 1981 se na světě objevil první jazyk C s třídami (prapředek C++).Vlastní C++ byl vyvinut v letech1983 – 1985. V roce 1986 publikoval Stroustrup knihuTheC++ Programming Language. Počátkem 90. let pak byl i tento jazyk normalizován.

Stejně jako na Object Pascal navazují Delphi jako jeho grafické vývojové prostředí,navazují na C++ vývojová prostředí Borland C++ Builder, Microsoft Visual C++, IBM VisualAge C++ a další.

4.4 EiffelJazyk Eiffel, jak už jeho jméno napovídá, byl pojmenován podle francouzského

stavitele Gustava Eiffela, konstruktéra známé Eiffelovy věže v Paříži. Jeho autorem je Dr.Bertrand Meyer spolu se svojí firmou Interactive Software Engineering. Vývoj začal v roce1985 a už o rok později byl na trhu první překladač tohoto jazyka. Cílem tehdy bylo vytvořitnový jazyk kombinující spolehlivost a schopnost konstruovat komplexní architektury.

Základními rysy jazyka Eiffel jsou polymorfismus, zapouzdření a vícenásobnádědičnost. Ačkoli vícenásobná dědičnost má mnoho odpůrců, její implementace v Eiffeludokáže jejich výtkám úspěšně čelit.

Jazyk Eiffel nachází uplatnění v telekomunikačních systémech, finančních aplikacícha je také vhodný pro účely výuky.

4.5 SmallTalkSmallTalk ječistě objektový programovací jazyk. Vznikl na počátku sedmdesátých let

ve výzkumném středisku PARC (Palo Alto Research Center) firmy Xerox. Jeho autory jsouAlan Kay, Adele Goldberg a Dan Ingalls. Jeho syntaxe je do značné míry ovlivněná LISPem ana rozdíl od jiných programovacích jazyků se velmi podobá přirozenému jazyku. Právě díkykořenům v LISPu je jazyk jako takový velmi jednoduchý, s jasnými funkcionálními rysy.

Jak bychom odčistě objektového jazyka očekávali, vše je objekt. Přestože toto tvrzeníslýcháváme i o Javě, ve srovnání se Smalltalkem nemůže být o Javě jako o čistě objektovémprogramovacím jazykuřeč. Ve SmallTalku je totiž objektem nejen instance třídy, ale i třídasamotná. SmallTalk navíc nezná nic jako primitivní datové typy, které objekty nejsou.SmallTalk se tak vyhýbá jakékoliv typové kontrole a typovým konverzím, což vede k tomu, žesmalltalkový kód je velmi hutný, bez zbytečného zdvojování.

K datům objektů nelze přistupovat přímo, ale jen prostřednictvím zasílání zpráv. VeSmallTalku v podstatě nelze dělat nic jiného, než zasílat zprávy objektům. Dokonce i základníprogramátorské struktury, jako jsou větvení a cykly, jsou ve SmallTalku realizovány pomocízasílání zpráv objektům.

Programování ve SmallTalku se neobjede bez vývojového prostředí, kterých jev současné době k dispozici několik. Jejich společným rysem je jazyk jako takový, velmi sevšak liší tím, jaké knihovny programátorům nabízejí. Dalším společným rysem je také to, že ažna nezbytné záležitosti nejnižší úrovně jsou vývojová prostředí napsána v samotnémSmallTalku. Programování ve SmallTalku je nezávislé na platformě. Program je přeložen dotzv. byte-kódu, který je pro všechny platformy stejný. Ke spuštění programu na konkrétníplatformě pak samozřejmě potřebujeme interpret SmallTalku pro danou platformu (zpravidlabývá součástí vývojového prostředí). Díky tzv. Just in Time (JIT) kompilaci pak není prováděníinterpretovaného kódu o mnoho pomalejší (ve srovnání s C++ se udává dvacetiprocentnízpomalení).

Velkým propagátorem tohoto jazyka je firma IBM, která takévyvinula vlastní vývojovéprostředí VisualAge obsahující knihovny, které programátorům zpřístupňují specifika počítačůIBM. Pro programování pod Windows je určeno vývojové prostředí Dolphin SmallTalk, kterévýborně implementuje klasický rys Windows – zasílání zpráv. Konečně, na zasílání zpráv jepostaven samotný SmallTalk, tudíž implementace tohoto rysu byla samozřejmostí.


- 14 -

Všechna ostatní vývojová prostředí (VisualWorks, Squeak, GNU SmallTalk, atd.) jsouurčena pro programování pod unixovými operačními systémy, popřípadě jsou na platforměnezávislá.

Přestože se v praxi se SmallTalkem příliš nesetkáme, na některých vysokých školácha výzkumných ústavech je poměrně hojně využíván. Například na Fakultě informačníchtechnologií VUT v Brně je SmallTalk uznávanou platformou pro studentské projekty,výzkumné projekty a různé simulace.

4.6 JavaProgramovací jazyk Java začala vyvíjet firma Sun Microsystems v roce1991. Poprvé

byla světu Java představena v květnu roku 1995. O okamžitý nárůst popularity se nezasloužiljazyk samotný, ale spíše podpora pro tvorbu aplikací určených pro WWW.

Všeobecně se tvrdí, že Java stojí na principech C a C++. Do značné míry je to pravda,nicméně nemaloučást svých vlastností a schopností si vypůjčila i od jazyka SmallTalk. Mezityto vlastnosti patří to, že programy v Javě jsou nezávislé na platformě. Překladače Javy totižnetvoří spustitelné soubory, ale byte-kód uložený do souborů s příponou class. Teprve tentobyte-kód je možné za pomoci interpretu spustit. Protože interpretované jazyky jsou znatelně

pomalejší než nativní kód konkrétní platformy, javové interprety provádějí, stejně jakointerprety SmallTalku, JIT kompilaci, při níž jsou důležité a často prováděné části kódupřeloženy do nativního kódu konkrétní platformy, v němž jsou poté vykonávány. Tím serychlost programů oproti klasickému interpretování výrazně zvýší.

Díky tomu, že byte-kód v souborech .class je pro všechny platformy stejný, se Javastala hitem právě pro programování webových aplikací, k nimž lidé přistupují z různýchplatforem. Na serveru tak může být jen jediný class soubor, jeho spuštění pak už záleží nakonkrétním interpretu vestavěném do konkrétního prohlížeče běžícího na dané platformě.

Java ječistě objektový jazyk. Jedinými výjimkami jsou tzv. primitivní datové typy,které samy o sobě objekty nejsou. Ke Každému primitivnímu datovému typu však existuje třídaimplementující metody pro práci s daným datovým typem. Datové typy vůbec představujív Javě velice podstatnou záležitost. Java totiž patří mezi silně typované jazyky. Vše má svůj typa prakticky veškeré typové konverze musí být programátorem potvrzeny, což může býtv některých situacích nevýhodné, avšak je to dobrá prevence proti programátorským chybám.

Java nepodporuje vícenásobnou dědičnost. Důvodem jsou poměrně špatné zkušenostis tímto rysem, které vedly kčetným chybám. Tento mechanismus je nahrazen pomocíabstraktnější záležitosti, a sicerozhraní.

V současné době se Java stává stále populárnějším programovacím jazykem, který sepoužívá nejen v komerční sféře, ale včím dál tím větší míře se začíná uplatňovat i jako výukovýjazyk. Opět se tedy jedná o žhavého kandidáta na výuku OOP.

V Javě je možné programovat buďto v libovolném textovém editoru a zdrojové souborypřekládat pomocí překladače spuštěného z příkazové řádky, nebo je možné využít některéz grafických vývojových prostředí. Profesionální grafická vývojová prostředí jsou dostupnáprakticky na všech platformách:

� Java SDK – základní vývojové prostředí od firmy Sun pro operační systémy Solaris, Linuxa Windows 9x/NT/2000. Další firmy vytvářejí vývojová prostředí pro další operačnísystémy (např. IBM). Nad těmito základními vývojovými prostředími vznikají grafickávývojová prostředí dalších firem, která umožňují pohodlnější vývoj aplikací (např. BlueJ).

� NetBeans – vývojové prostředí vytvořené českou firmou NetBeans, nyní rozvíjené jakoOpenSource.

� Forte – vývojové prostředí založené na NetBeans vyvíjené a distribuované pod hlavičkoufirmy Sun. Základní verze je distribuována zdarma.

Z dalších vývojových prostředí jmenujme alespoň IBM VisualJava, Jikes, Jlint, Jopt,Realjči JCreator.

Porovnání objektových jazyků

- 15 -

5 Porovnání objektových jazyk ůNyní, když jsme si něco řekli o základních rysech dostupných objektových jazyků,

budeme se zabývat jejich výhodami a nevýhodami z hlediska výuky OOP. Je důležité uvědomitsi, že tatáž vlastnost může být z jednoho úhlu pohledu výhodou a z jiného nevýhodou, což můževytvářet dojem, že si argumenty protiřečí. Záleží pak na konkrétních podmínkách pro výuku,který úhel pohledu je důležitější.

5.1 Proč učit Object PascalVýuka Object Pascalu je velmi výhodná, pokud je Pascal jazykem, na kterém se

studenti učili programovat. Tomu tak ve většině případů skutečně bývá.Začneme-li učit objektové programování právě na Object Pascalu, studenti nebudou mít

vůbec pocit, že by se učili něco úplně nového. V podstatě je budeme učit jen další oblastprogramování v Pascalu, tedy něco, co už učíme hodně dlouho. Teprve po nějaké době lzeu studentů začít pěstovat skutečně objektové myšlení. Základní výhoda je tedy v tom, že sestudenti budou s novou látkou seznamovat postupně a budou stavět na věcech, které už dobřezvládají, což je obecně pro výukučehokoliv nesmírně výhodné.

Díky tomu se Object Pascal stává odrazovým můstkem pro výuku dalších jazyků,zejména pak Delphi nebo Javy.

5.2 Proč neučit Object PascalObject Pascal neníčistě objektový programovací jazyk. Je to jen pouhá nadstavba nad

neobjektovým imperativním jazykem. Myšlenky OOP zde nejsou tím základním, načem jazykstojí, ale tvoří jen rozšíření neobjektového jazyka. Studenty tak nebude nic nutit ke skutečnéobjektové analýzeřešeného problému. Je zde nebezpečí, že při nevhodné volbě příkladů nebopři přílišné vynalézavosti studentů se studenti budou objektovému programování stále vyhýbata budou se snažit maximum problémů řešit tak jak jsou zvyklí, tedy neobjektově.

Další podstatnou nevýhodou Object Pascalu je jistý nesoulad v pojmenovávání oprotijiným jazykům. Klíčové slovoOBJECT zde totiž na rozdíl od běžné terminologie ostatníchjazyků neoznačuje objekt, ale třídu. Obvyklý pojem objekt, tedy instance třídy, v terminologiiObject Pascalu neexistuje, místo něj se používá termín „instance objektu“. Pokud si studentizvyknou na toto nestandardní pojmenování, mohou mít problémy přecházet k libovolnémujinému objektovému jazyku, a to včetně Delphi, která, byť vystavěná na Object Pascalu, jižtřídy a objekty pojmenovávají tak, jak je v OOP zvykem.

5.3 Proč učit C++Nezbytnou podmínkou k výuce jazyka C++ je důkladná znalost programování v jazyce

C. O výuce C++ tedy v žádném případě nemá smysl uvažovat dříve, než studenti zvládnoujazyk C skutečně dobře. Pokud byl jazyk C jazykem, na kterém se studenti učili programovat,výuka C++ se zde přímo nabízí. Výhody takového postupu jsou zde přesně tytéž, jako v případěnávaznosti Object Pascalu na obyčejný Pascal, tedy to, že nové učivo staví na dobřezvládnutých základech a není jej příliš velké množství najednou.

Dokonce zde odpadá i jedna z nevýhod Object Pascalu navazujícího na Pascal, a sicezmatek v pojmenování. C++ používá standardní terminologii pro třídu a objekt coby instancitřídy. V případě, že studenti umí jak Pascal tak C a váháme, na kterém z nich učit jehoobjektovou nadstavbu, jeví se z tohoto hlediska C++ jako výhodnější.

Díky tomu, že jazyk C je esenciálním programovacím jazykem na unixovýchsystémech, C++ i přes svou v současné době klesající popularitu zůstane jazykem poměrněhojně používaným. Opět tu tedy máme dobrý základ v tom, že studenti mají pocit užitečnostitoho, co je učíme.


- 16 -

5.4 Proč neučit C++Hlavní důvod je stejný jako u Object Pascalu. C++ neníčistě objektový programovací

jazyk, ale jen rozšířením jazyka neobjektového. Důsledky již byly popsány dříve.Další nevýhodou je, že tento jazyk má v komerční sféře klesající podporu. Značnáčást

programátorů C++ již přešla nebo přechází na jazyk Java, který je C++ syntakticky velmipodobný. Proto se jako učitelé můžeme dostat do problému, když nebudeme schopni uspokojivě

obhájit účelnost znalosti C++.Posledním, z pedagogického hlediska však velmi významným důvodem je složitost

vývojových prostředí. Tento argument bude podrobně rozveden v podkapitole „Proč neučitDelphi“, nicméně vývojová prostředí C++ jsou zpravidla ještě složitější než Delphi.

5.5 Proč učit DelphiDelphi je profesionální vývojové prostředí sloužící k tvorbě aplikací pod Microsoft

Windows. Mezivývojovými prostředími pracující s objektovými jazyky je nejrozšířenější, cožjistě souvisí s tím, že Microsoft Windows je nejrozšířenější operační systém. Studenti se taksvými výsledky mohou prakticky kdekoliv „pochlubit“, což zvyšuje jejich motivaci. Navíc,výuka toho, co je rozšířené, automaticky vyvolává ve studentech pocit, že se učí něco, coopravdu použijí, což opět zvyšuje jejich motivaci.

Navíc, kromě Delphi pod Windows je dostupný i Kylix pod Linux, což do určité míryeliminuje případný protiargument o systémové závislosti programů v Delphi.

5.6 Proč neučit DelphiProblémem Delphi je značná složitost vlastního vývojového prostředí. Velké množství

času a úsilí zabere pouhé vysvětlení toho, jak vytvořit projekt, kčemu jsou dobré jaké souborya seznámení s ovládáním vývojového prostředí. Kdybychom studentům měli zároveň s tímvysvětlovat ještě nové programovací principy, bylo by nových věcí příliš mnoho najednoua studenti by v tom měli zmatek.

Před používánímvývojových prostředí na počátku výuky varuje i [13] (str. 29-30):

Pokud jste úplným začátečníkem, nepoužívejte žádné vývojové prostředí. Jejich složitosta nutnost mnoha administrativních úkonů, např. vytvoření projektu (jistěže pro pokročiléhosamé užitečné věci) vás bude stát spoustučasu. Kromě toho se ztratíte v záplavěpředgenerovaného kódu.

Vývojová prostředí svádí k tomu, že lze snadno vytvořit „zadarmo“ okénka. Tosamozřejmě velice oceníme, ale v začátcích je nutné rozumět jazyku.

Tuto nevýhodu se nám však podaří eliminovat tím, že před započetím výuky Delphivěnujeme nějaký čas výuce Object Pascalu. Tím se množství nových věcí rozloží a studenti jelépe zvládnou. Musíme však mít na paměti, že Object Pascal používá odlišnou terminologii nežDelphi, na což je nutné studenty včas upozornit.

Další nevýhodou výuky Delphi je, byť ne zcela pravdivé, ale značné rozšířené tvrzení,že hlavní přístup spočívá pouze ve výběru voleb a vizuálních elementů. Psaní kódu je jen jakésinutné zlo, které je potřeba mimochodem podstoupit proto, aby byly programy lepší ([4], str. 17,937). Existuje zde tedy nebezpečí, že studenti začnou objektové programování chápat jen jako„vyklikávání okýnek a tlačítek“ a původní cíl výuky se zcela vytratí.

5.7 Proč učit JavuJava ječistě objektový programovací jazyk. Díky tomu zde máme vynikající příležitost

naučit studenty objektově myslet, což je z hlediska uplatnění v praxi daleko důležitější nežsyntaktické zásady konkrétního jazyka. Díky nemožnosti používat jakékoliv globální objektyJava nutí programátora k důkladné objektové analýzeřešeného problému. Naučit studentyobjektově myslet je základní cíl naší výuky, proto bychom tento argument neměli podceňovat.


- 17 -

Java je velmi populární programovací jazyk, jehož popularita má navíc stále vzrůstajícítendenci. Při výuce nám tedy nedá mnoho práce studentům vysvětlit, že to, co se učí,v budoucnu uplatní. Za rostoucí popularitu vděčí Java také tomu, že její implementace senachází v mobilních telefonech. Někteří ze studentů takové telefony mají, což jejich motivaciještě zvýší.

5.8 Proč neučit JavuJe pravda, že Java je populární. Otázkou však zůstává, zda je to dostatečný důvod.

Nemůžeme si být jisti, zda se nejedná jen o módní vlnu, kteráčasem opadne. V tom případěbychom studenty naučili něco, co v praxi neuplatní a velkáčást naší výuky by tak přišla vniveč.

Výuka Javy s sebou přináší příliš mnoho nových věcí. Pokud studenti zvládají jenneobjektové imperativní programování, bude pro ně přechod na Javu tvořit obrovský problém,který se možná některým ani nepodaří překonat. V poměrně krátkémčasovém úseku budoumuset studenti pochopit principy objektového programování, objektové myšlení jako takové,a ještě syntaxi úplně nového jazyka. Toto riziko je menší, pokud studenti ovládají jazyk C,nicméně i tak se stále jedná o velký problém.

5.9 Proč učit SmallTalkSmallTalk ječistě objektový jazyk, na kterém se studenti mohou dobře naučit objektově

myslet. Jehočistota je navíc ve srovnání s Javou na daleko vyšší úrovni, takže máme dobrýpředpoklad ve studentech vybudovat schopnost objektového myšlení na vysoké úrovni.

Přestože se studenti budou muset naučit novou syntaxi, v případě SmallTalku to nebudetakový problém, neboť jeho syntaxe je poměrně jednoduchá a je velmi podobná přirozenémujazyku. Pokud se navíc v minulosti setkali s nějakým funkcionálním jazykem (napříklads jazykem Logo, který se pro výuku základních algoritmů často používá na ZŠ), nebudepředstavovat zvládnutí syntaxe SmallTalku vážný problém. Jako motivaci lze využít skutečnost,že se SmallTalk užívá na některých vysokých školách.

5.10 Proč neučit SmallTalkSmallTalk, jakkoli dobře navržený programovací jazyk, se bohužel nedočkal příliš

velkého rozšíření v programátorské komunitě. Většina lidí o jeho existenci buďto vůbec nevía nebo o něm jen slyšeli, málokdo v něm však skutečně programoval. Těžko tak budemestudenty, kteří mají ve svém mobilním telefonu Javu, přesvědčovat o tom, že se učí užitečnouvěc, kterou v praxi uplatní. Argument o objektovém myšlení u studentů také příliš neobstojí,neboť to je věc, po jejíž výuce přímo buďto vůbec netouží, anebo se tato výuka dá realizovatv rámci jiného objektového jazyka (např. Javy).

5.11 Proč učit EiffelZatímco Pascal je programovací jazyk navržený pro výuku imperativního

programování, Eiffel je jazyk, při jehož návrhu bylo pamatováno i na to, aby se stal nástrojempro výuku objektového programování. Z didaktického hlediska se tedy jedná o jazyk poměrněvhodný.

Eiffel je čistě objektový jazyk, což se nám při formování objektového myšlení vestudentech bude hodit.

5.12 Proč neučit EiffelZatímco u SmallTalku jeho praktické využití najdeme, u Eiffelu již příliš ne.

S nástupem Javy byl Eiffel definitivně zatlačen do pozadí a lze předpokládat, že se na nějv brzké době zapomene úplně. V praxi se jedná o jazyk prakticky nepoužívaný. Proto bychomučili něco, co studenti v praxi opravdu neuplatní, což nemá smysl.


- 18 -

5.13 Co tedy u čitJak je vidět, každý programovací jazyk, respektive každé vývojové prostředí, má svá

pro a proti. Při rozhodování o tom, který jazyk použijeme, musíme zvážit nejen tato pro a proti,ale také minulou výuku programování, úroveň znalostí studentů, jejich zájmy, zájmy školya spoustu dalších hledisek, která se mnohdy ani nedají popsat, neboť jsou ryze subjektivní.

Při rozhodování budou jistě hrát roli znalosti učitele. Pokud někdo neumí Javu, nemůžeji učit, i kdyby byl o jejích výhodách sebevíce přesvědčen. Tento problém je samozřejmě možnéřešit, pokud si jej učitel uvědomí s předstihem, pro výuku je však nezbytná jistá zběhlostv daném programátorském prostředí.

Významnou – z racionálních složek rozhodování možná nejvýznamnější – roli hrajívstupní znalosti studentů. Pokud studenti umí programovat pouze v Pascalu, je holý nesmyslpouštět se do výuky C++ a také výuka jazyka Java je v tomto případě velmi diskutabilní. Pokudstudenti umí programovat v jazyce C, je naopak poměrně nevýhodné učit Object PascalčiDelphi a je lépe začít s C++ nebo rovnou s Javou. Pokud mají studenti dobré zkušenostis funkcionálním programováním, může být vhodné učit je programovat ve SmallTalku.

Dalším aspektem je zájem studentů. Z hlediska výuky objektového myšlení je poměrnělhostejné, jaký programovací jazyk použijeme. Důležité je naučit principy OOP a správnouanalýzu problémů. Pokud tedy studenti mají eminentní zájem o výuku jednoho konkrétníhojazyka, je dobré jim vyhovět. O motivaci tak máme postaráno a cíl výuky rozhodně nemusí býtohrožen.

Při rozhodování hrají roli také ryze subjektivní argumenty. Jejich role je bohužel velicepodstatná, ač si to v mnoha případech učitel ani neuvědomuje. Pokud se nám nějaký jazyk„líbí“, například proto, že v něm programujeme celý život, jsme niterně přesvědčeni o jehoužitečnosti. Ta sice může být po aplikaci racionálních argumentů zpochybněna, nicméněpravdou stále zůstává, že pokud jsme o něčem niterně přesvědčeni, ze své pozice jsme schopnipřesvědčit i studenty o tom, jak je námi podporovaný jazyk jedinečný. Často se proto stává, žebez ohledu na racionální výhody a nevýhody učitelé učí právě to, co se jim nejvíce líbí.

Vzhledem k tomu, že na většině českých středních škol se učí nejprve jazyk Pascal,který byl jako učební jazyk navržen, je přirozené navázat na znalosti studentů a pokračovatvýukou Object Pascalu. Během výuky Object Pascalu se studenti seznámí s principy objektově

orientovaného programování a se zásadami správného objektového návrhu aplikací. Poté jevhodné pokračovat výukou Delphi, neboť studenti již mají pro tuto výuku všechny potřebnéznalosti.

Pokud vynecháme výuku Object Pascalu a přejdeme rovnou na Delphi, studenti mohoumít problémy s příliš velkým množstvím nového učiva. Musí se vedle zásad objektovéhoprogramování učit pracovat se zcela novým vývojovým prostředím. Vložení výuky ObjectPascalu umožňuje nové učivo rozložit do delšíhočasového období, což je pro studentypřijatelnější. Dostaneme se tím sice do problémů plynoucích z terminologických odlišnostíObject Pascalu a Delphi, ale ty lze odstranit snáze než problémy plynoucí z příliš velkéhomnožství učiva.

Uvedeného modelu výuky se budeme držet i v následujících kapitolách.

Výuka Object Pascalu

- 19 -

6 Výuka Object Pascalu

6.1 Vstupní znalostiK výuce Object Pascalu lze přistoupit až poté, kdy studenti zvládnou znalosti pro tuto

výuku nezbytné. Jsou to zejména:

� Programátorská zběhlost v Pascalu. Studenti by již měli umět programovat v Pascalunatolik dobře, aby dokázali bez problémů vymýšlet a implementovat dílčí algoritmy,provádět rozklad problémů na dílčí podproblémy, chápat chybová hlášení překladače a umětopravovat logické chyby ve svých programech.

� Programátorem definované datové typy a datový typ záznam. Ačkoliv to na první pohlednení zřejmé, programátorem definované datové typy zavádí určitý nový stupeň abstrakce,který je ke zvládnutí zásad OOP nezbytný. Datový typ záznam je z logického hlediskapřímým předchůdcem třídy. Na první pohled je to v podstatě totéž, s výjimkou procedura funkcí.

� Dynamické proměnné a datový typ ukazatel. Protože objekty je zpravidla výhodnějšívytvářet dynamicky, je velice žádoucí, aby studenti před výukou OOP uměli s dynamickýmiproměnnými a ukazateli na ně pracovat.

� Programové jednotky (units). Přestože se bez znalosti programových jednotek při výuceObject Pascalu obejdeme a tatočást je nezbytná až pro výuku Delphi, je vhodné ji zařaditdo výuky dříve, než přistoupíme k výuce objektově orientovaného programování.

Během výuky OOP je nutné studenty naučit zejménaobjektově myslet. Je proto třebadbát i na zdánlivé maličkosti a nutit studenty k důkladnému rozmyšlení objektového návrhua důslednému dodržování zásad a rysů OOP. Na výuku jednotlivých rysů se nyní podívejmeblíže. Znovu připomeňme, že Object Pascal je pouze „odrazovým můstkem“ pro Delphi,čemužje třeba přizpůsobit rozsah výuky. Je zbytečné strávit výukou Object Pascalu mnohočasu,studenti však musí pochopit princip OOP a mít jej důkladně zažitý.

Protože Object Pascal používá jinou terminologii než je obecně zvykem, je namístěupozornit, že v dalším textu se přidržíme terminologie standardní, tedy třída – objekt, nikolivobjekt – instance objektu.

6.2 Zapouzd řeníNejjednodušším rysem OOP je z hlediska výuky bezpochyby zapouzdření

(enkapsulace), proto je vhodné tímto rysem začít hned, když studentům vysvětlujeme objekty.Velmi na místě je v tomto případě srovnání se záznamem, neboť studenti získají konkrétnípředstavu, očem je řeč. Jediné, co se jim zpočátku může jevit jako nepřirozené, je snahao přistupování k datovým položkám výhradně přes metody, nikoliv přímo. První příklady, nakterých OOP učíme, obsahují jen jednoduché třídy s několika málo datovými položkamia metodami pro přístup k nim.

Zároveň je vhodné od začátku vést studenty k tomu, aby měli jednotlivé třídy umístěnév programových jednotkách, což výrazně zvyšuje přehlednost programu a přenositelnost jižnaprogramovaných tříd.

U následujících příkladů bude kromě zadané jednotky nutné vytvořit ještě ukázkovýprogram demonstrující funkčnost vytvořené jednotky.

Příklad Člov ěk1Procvičované znalosti:Základy OOP, zapouzdření.Zadání: Napište jednotkuClovek obsahující definici třídy TClovek, umožňující uchováníjména, příjmení a pohlaví. Třídu doplňte o metody manipulující s těmito položkami.


- 20 -

Příklad VektorProcvičované znalosti:Základy OOP, zapouzdření. Práce s vektory.Zadání: Napište jednotkuVektor, obsahující definici třídy TVektor, která bude uchovávatsouřadnice trojrozměrného reálného vektoru a implementovat metody pro základní prácis vektorem (konstruktor pro vytvoření vektoru, metodu pro výpočet délky a metodu pro vypsánísouřadnic vektoru).Možná rozšíření: Jednotku rozšiřte tak, aby umožňovala provádět základní operace s vektory(násobení reálnýmčíslem, sčítání vektorů, skalární a vektorový součin).

Příklad BankaProcvičované znalosti:Základy OOP, zapouzdření. Parametrself.Zadání: Napište jednotkuBanka, která bude obsahovat definici tří tříd: TClovek, TBankaaTUcet. Třída TClovek je totožná z třídou zadanou v příkladu Člověk1 (lze tedy tutojednotku využít). Třída TUcet bude sloužit k uchování zůstatkovéčástky a manipulací s ní(vklad, výběr, převod na jiný účet). Kromě toho bude obsahovat informaci o majiteli účtu(ukazatel na příslušný objekt typuTClovek) a bance, u které je účet veden (opět ukazatel naobjekt typuTBanka). Třída TBanka bude obsahovat název banky a metoduVytvorUcet,která vytvoří účet utétobanky.Poznámky: Nejproblematičtější je metodaVytvorUcet, která musí při vytváření objektutypu TUcet vědět, která banka tuto metodu volá. K tomu slouží implicitní parametrself,v němž je předáván právě ukazatel na instanci, jež metodu volá.

Příklad DatumProcvičované znalosti:Základy OOP, zapouzdření.Zadání: Napište jednotkuDatum, obsahující definici třídy TDatum. Tato třída bude sloužitk zadání, uchování a vypsání data. Jednotku doplňte o funkci umožňující vypočítat počet dnůuplynuvších mezi dvěma zadanými daty.Poznámky: Pro počítání s datem je vhodné neuchovávat datum jako tři čísla (den, měsíc a rok),ale jako počet dnů, které uplynuly např. od 1.1.1900 do zadaného data. Tomu je třebapřizpůsobit metody, sloužící pro vstup a výstup data.Možná rozšíření: Do třídy doplňte metodu pro výpočet dne v týdnu.

6.3 DědičnostDruhým klíčovým rysem OOP je dědičnost. Abychom co nejlépe demonstrovali její

využití, v maximální míře využijeme již naprogramovaných jednotek, které budeme vhodně

rozšiřovat. Např. v příkladu Vektor lze využít prvků popsaných v odstavci „Možná rozšíření“k vytvoření třídy TVektor2, dědící své základní vlastnosti po třídě původní a rozšiřující seprávě o popsané prvky. Podobně lze postupovat i v příkladuDatum.

Podrobně si tento postup ukážeme na příkladuČlověk.

Příklad Člov ěk2Procvičované znalosti:Základy OOP, dědičnost.Zadání: Napište jednotkuClovek2, obsahující definici třídy TClovek2, která budepotomkem třídy TClovek. Navíc bude tato třída obsahovat novou položku pro uchování datanarození (viz příklad Datum) a metody pro její obsluhu.

Příklad Člov ěk3Procvičované znalosti:Základy OOP, dědičnost.Zadání: Napište jednotkuPracujici, obsahující definici třídy TPracujici, která budepotomkem třídy TClovek2 z příkladuČlověk2. Navíc bude obsahovat položky pro uchovánípovolání a výše platu.


- 21 -

Možná rozšíření: Za použití tříd z příkladu Banka lze příklad rozšířit o metody simulujícíreálné situace (např. výplatu). Fantazii pro implementaci dalších rysů (národnost, výška,hmotnost, délka vlasů, …) se meze nekladou.

6.4 PolymorfismusPosledním rysem OOP je polymorfismus (mnohotvárnost). Komplexní příklady

ilustrující polymorfismus na manipulaci s grafickými objekty je možné nalézt v různýchzdrojích (např. [28]). Jejich realizace je však velmi náročná a práce s grafikou nemusí být v tétodobě probrána. Proto se zaměříme na textové aplikace, které však pro ilustraci polymorfismumohou posloužit stejně dobře.

Příklad ZOOProcvičované znalosti:Základy OOP, dědičnost, polymorfismus. Přetypování.Zadání: Navrhněte jednotkuZivocich, implementující zjednodušenou hierarchii živočišnýchdruhů. Základní třídaTZivocich bude obsahovat datové položky společné všem živočichům(hmotnost, ohrožený druh,…) a metody pro práci s nimi. Dále bude obsahovat metoduGetInfo, vypisující informaci o objektu (ve třídě TZivocich tato metoda vypíše„Živočich“). Dále definujte potomky této třídy: TPtak, TSavec a TRyba s vhodnýmivlastnostmi (rozpětí křídel, kopyta, druh vody,…). Potomky těchto tříd pak budou již konkrétníživočišné druhy (vrabec, holub, pes, tuleň, štika, kapr,…). MetodaGetInfo musí pro každýobjekt vypisovat informace právě o daném objektu (např. TTulen.GetInfo bude podávatinformaci typu „Hnědý tuleň vážící 230kg.“).Dále napište programZOO, který bude obsahovat pole prvků typu TZivocich. Jednotlivéprvky tohoto pole budeme chápat jako klece s živočichy. Program bude umět umísťovatživočichy do klecí a vypisovat o nich informace pomocí metodGetInfo.Poznámky: Všem definovaným třídám je společná metodaGetInfo, která jepolymorfní.Jmenuje se ve všech třídách stejně, v každé se však chová jinak. To nám umožní definovatzmíněné pole jakoarray of TZivocich. Jednotlivými prvky pole mohou být i potomkytohoto typu, tedy buď některý z typů TPtak, TSavec, TRyba, nebo konkrétní živočišný druh.Chceme-li se pomocí prvků pole, které jsou typuTZivocich, odkazovat na metodydefinované až v potomcích, je třeba využít přetypování. Např. PTulen(zahrada[1])^.UlovRybu(PRyba(zahrada[9])).Možné varianty: Namísto ZOO použijeme botanickou zahradu nebo arboretum. Podobnáobjektová hierarchie bude použita pro rostliny.

Příklad GeometrieProcvičované znalosti:Základy OOP, dědičnost, polymorfismus, geometrické útvary.Zadání: Navrhněte jednotku implementující hierarchii základních geometrických útvarů.Základní třída, TUtvar, bude popisovat pouze virtuální metoduGetInfo pro vypsáníinformací o objektu. Potomky této třídy budou třídy TBod, TUsecka, TTrojuhelnikaTKoule. Kromě předefinování metodyGetInfo budou tyto třídy obsahovat relevantnídatové položky (délka, poloměr, …) a metody pro základní výpočty (obsah, objem).Poznámky: Práci s jednotkou demonstrujte vhodným ukázkovým programem. Využijtepolymorfismu. Objektové proměnné ukázkového programu mohou být typuTUtvar,přiřazovat jim však lze instance potomků.

Výuka Borland Delphi

- 22 -

7 Výuka Borland Delphi

7.1 Vstupní znalostiK tomu, abychom mohli studenty začít učit programovat v Delphi, potřebujeme určitou

míru vstupních znalostí. Rozhodně není v žádném případě možné začít učit Delphi bezpředchozí znalosti Pascalu. Zde tedy jsou nutné vstupní znalosti pro výuku Delphi:

� Programové jednotky (units). Bez této znalosti se v Delphi neobejdeme. Každé okno, kteréstudenti vytvoří, bude mít svoji vlastní jednotku. Studenti tak musí zvládat jednak obecnoustrukturu jednotky a jednak propojování jednotek pomocí klausuleuses. Měli by mít zasebou také vytvoření několika jednoduchých jednotek.

� Základy objektově orientovaného programování. Kdybychom začali učit Delphi studenty,kteří o OOP nic neslyšeli, bylo by toho na ně příliš mnoho najednou. Studenti by tak poddojmem nezvládnutelnosti velkého množství nové látky ztratili motivaci.

� Vyjasnění terminologických rozdílů mezi Object Pascalem a Delphi.

7.2 Seznámení s prost ředím a vytvo ření první aplikacePřestože se jedná o věci, které spolu zdánlivě příliš nesouvisejí, musejí být probrány

v jedné hodině. Protože výuka programování ve vyšších ročnících, kdy Delphi pravděpodobněbudeme učit, probíhá zpravidla ve dvouhodinových blocích, neměl by to být velký problém. Alei tam, kde máme k výuce pouze jednu vyučovací hodinu, by studenti měli být schopni vytvořitprvní program v první hodině, a to i za cenu toho, že se svývojovým prostředím nenaučí přílišzacházet.

Důvod k tomu je velmi jednoduchý. Studenti musí při výuce vidět své výsledky. A jistěnení lepší výsledek programátora, než funkční program, spustitelný soubor. Pokud studentinebudou mít hmatatelný výsledek co nejdříve, získají pocit, že to, co se právě učí, je přílišsložité a že to nezvládnou. Přestože tomu tak ve skutečnosti být nemusí, tento jejich pocitpovede k naprosté ztrátě motivace a následné rezignaci. A to je jedna z nejhorších věcí, kteránás při výuce může potkat. Proto je třeba dbát na to, aby studenti motivaci neztratili. Nejen abyměli pocit, že to, co se učí, je dobré a užitečné, ale také, že to není těžké, a že to zvládnou. Prvníspustitelný program v první hodině je k tomu nutnou podmínkou.

Lze si všimnout, že drtivá většina knih, kteréčtenáře učí programovat, se snažíposkytnout hned v první kapitole návod, jak vytvořit první program. Zpravidla to bývájednoduché Hello world! nebo něco podobného. Ale svědčí to o tom, že autoři těchto publikacísi moc dobře uvědomují to, co bylořečeno v předcházejícím odstavci. Kdyby totiž napsali prvníprogram dále než do první kapitoly, nikdo by si jejich knihu nekoupil, protože by měl pocit, žeje to na něj příliš složité.

Nyní tedy již k vlastnímu vývojovému prostředí. Po spuštění Delphi se studentůmobjeví prázdný formulář a kolem něj spousta věcí. Zpočátku si vystačíme s paletou komponenta Object Inspectorem. Studenti by si měli vyzkoušet umístit nějaké komponenty na formulářa nastavit jejich základní vlastnosti pomocí Object Inspectoru. Zde je dobré nezabíhat dopřílišných detailů, protože většinu komponent budeme probírat v následujících hodinách. Nynínám jde jen o obecné záležitosti, ne o konkrétní vlastnosti konkrétních komponent.

V rámci seznamování s paletou komponent a Object inspectorem studenti mohouvytvořit okno příkladu Ahoj (nebo případně jakéhokoliv jiného příkladu, kterým jsme serozhodli začít, ale příklad Ahoj je asi nejpřirozenější).

Příklad AhojProcvičované znalosti: Seznámení s vývojovým prostředím. Tvorbaaplikací. KomponentaTLabel.Zadání: Napište program, který vytvoří okno, v němž bude nápis„Ahoj!!!“.


- 23 -

Poznámky: Na plochu formuláře umístěte komponentuTLabel (štítek). Do vlastnostiCaption této komponenty napište požadovaný text, v našem případě „Ahoj!!!“.

Nyní přichází nařadu uložení programu. Zde je nutné studentům vysvětlit, co je toprojekt a kčemu je dobrý. Také je dobré upozornit na to, že formulář, název souborus formulářem a název projektu musí být různé. Je dobré zmínit některé konvence propojmenovávání souborů, na některé z nich se se studenty shodnout a tu posléze prosazovati v dalších příkladech.

Po vytvoření a uložení programu přichází nařadu jeho kompilace a spuštění. Protože sejedná očinnosti studentům důvěrně známé z programování v Pascalu, lze předpokládat, že jezvládnou rychle a bez problémů. První program je tak na světě, což neopomeneme zdůraznit.

Dále je dobré se studenty probrat soubory, které v jejich adresářích vznikly. Je-ličas, jevhodné se na to zaměřit ještě v téže hodině. Pokud alečas není, bez problémů lze tuto pasážpřesunout do hodiny následující. Studenti by měli vidět kód, který za ně Delphi vytvořily, kdyžumísťovali komponenty do formuláře. Je důležité srovnat zdrojový kód formuláře s hlavnímprogramem (.DPR), který neumí nic jiného než inicializovat a spustit aplikaci. Dále studentůmukážeme, že všechny vlastnosti, které nastavili pomocí Object Inspectoru, jsou dostupnév souboru .DFM. Samozřejmě upozorníme, že soubory *.~* lze mazat, neboť to jsou jen záložníkopie.

7.3 Psaní kóduStudenti by v žádném případě neměli nabýt dojmu, že Delphi jsou jen grafickou

záležitostí, a že není potřeba psát žádný kód. Co nejdříve po základním seznámení s vývojovýmprostředím je dobré studentům ukázat, jak napsat do programu kód, který něco vykoná.

Jako první věc, kterou musíme studenty naučit, je nastavování vlastností komponent zaběhu programu. Zpočátku můžeme vyzkoušet za běhu nastavovat i vlastnosti dostupné v ObjectInspectoru, ale je dobré ukázat, že ne vše lze v Object inspectoru nastavit. Aby mělonastavování vlastnosti za běhu smysl, je třeba použít hodnotu, která není v době kompilaceprogramu známá, například parametr, se kterým je program spuštěn, jak ukazuje následujícípříklad.

Příklad Ahoj2

Procvičované znalosti:Seznámení s vývojovým prostředím.Čtení parametrů příkazovéřádky.KomponentaTLabel.Zadání: Napište program, který po spuštění zjistí, zda byl spuštěn s parametrem. Pokud ne,vypíše do okna chybové hlášení. Pokud ano, předpokládá, že parametr je jméno v 5. pádě a dookna vypíše pozdrav (např. „Ahoj Pepíku!“, dostal-li slovo „Pepíku“ jako parametr).Poznámky: Využijte celočíselné proměnné ParamCount uchovávající počet parametrůpříkazovéřádky a řetězcové funkceParamStr vracející jednotlivé parametry. V Delphi lzeparametry předávané spouštěnému programu zadat pomocí menu Run –> Parameters.V případě, že chcete, aby parametr obsahoval mezeru, je potřeba jej celý uzavřít do uvozovek.Možná rozšíření: V tuto chvíli program využívá jen prvního parametru. Upravte jej tak, abyvyužil všech parametrů předpokládaje, že to jsou jména v pátém pádě. Tak např. spuštěnípříkazu „Ahoj Pepíku Honzíku Aničko“ způsobí, že program vypíše „Ahoj Pepíku, Honzíku aAničko!“.

7.4 Reakce na událostPoté, co studenti alespoň okrajově umí nastavovat vlastnosti komponent a vkládat do

programu kód, přichází nejvhodnější doba pro výuku reakcí na události. Této pasáži musíme


- 24 -

věnovat patřičnou pozornost, protože je to jedna z klíčových oblastí programování v Delphi.Následují jednoduché příklady, které lze pro výuku reakcí na události využít.

Příklad Ahoj3Procvičované znalosti: Tvorba aplikací. KomponentyTLabel,TButton. Reakce na stisk tlačítka.Zadání: Napište program, který vytvoří okno s tlačítkem „Pozdrav“.Po stisknutí tlačítka se v okně objeví nápis „Ahoj!!!“.Poznámky: Tlačítko (komponenta TButton) má událostOnClick. Metoda napojená na tuto událost může za běhu změnitvlastnostCaption komponentyTLabel.

Příklad Text

Procvičované znalosti:KomponentyTLabel, TButton. Vlastnosti komponentyTLabel.Zadání: Napište program, jehož okno bude obsahovat štítek a 6 tlačítek. Tři tlačítka budoumanipulovat s velikostí textu ve štítku (zvětšení, zmenšení a uvedení na původní velikost) a třise budou starat o zarovnávání textu (vlevo, na střed, vpravo).Poznámky: Stisk tlačítka generuje událostOnClick komponentyTButton. Na tuto událostje potřeba napojit metodu, která bude manipulovat s příslušnou vlastností komponentyTLabel. Velikost textu je přístupná přes položkuFont.Size, zarovnávání je pak v položceAlignment.

7.5 Události vyvolané myšíPoté, co studenty naučíme základní principy obsluhy událostí na událostiOnClick,

přichází nařadu další události. Nejpřirozenější je zpočátku se věnovat událostem generovanýmmyší, tedyOnClick, OnDblClick, OnMouseDown, OnMouseUp aOnMouseMove.

Je vhodné studenty upozornit na to, že metody obsluhující různé jmenované událostidostávají různé informace prostřednictvím svých parametrů. Např. metoda obsluhující událostOnClick neví, na kterém místě uživatel tlačítko myši stiskl, zatímco metoda obsluhujícíudálostOnMouseDown tuto informaci má.

Další příklady vztahující se k tomuto tématu jsou uvedené v příloze pod názvyCloseMea CloseMe2.


- 25 -

Příklad BarvyProcvičované znalosti: KomponentyTButton, TLabel. Reakce na stisktlačítka a kliknutí myší na plochuformuláře. Vlastnosti komponentyTForm.Zadání: Napište program, který vytvoříokno se třemi tlačítky: „Červená“, „Zelená“a „Modrá“. Po stisknutí některého z tlačítekse hlavní formulář přebarví odpovídajícíbarvou. Navíc, v případě kliknutí na plochu

formuláře (mimo tlačítka) se přebarví na bílo, v případě dvojitého kliknutí načerno.Poznámky: Stejně jako komponentaTButton, má i komponentaTForm událostiOnClickaOnDblClick. V metodách obsluhujících patřičné události nastavujte vlastnostColorkomponenty TForm. Využijte předdefinovaných konstantclRed, clGreen, clBlue,clWhite aclBlack.

Příklad Barvy2Procvičované znalosti: Reakce na stisktlačítka a události OnMouseDown,OnMouseUp. Komponenty TForm,TButton.Zadání: Upravte program z příkladuBarvytak, aby v případě kliknutí na plochuformuláře nastavil jeho barvu načernounebo bílou toho, kterým tlačítkem uživatelkliknul.Poznámky: Metoda obsluhující událostiOnMouseDown a OnMouseUp dostává množstvíparametrů, mezi nimiž je i parametrButton nabývající hodnotymbLeft nebombRight přistisku levého, resp. pravého tlačítka.Možná rozšíření: Alternativně lze program zpracovat tak, žečerná nebo bílá plocha formulářese po uvolnění tlačítka změní opět v původní barvu (např. žlutou).

Příklad PohybProcvičované znalosti: KomponentaTEdit nebo TLabel. UdálostOnMouseMove. FunkceIntToStr.Zadání: Napište program, v jehož okněbudou jen dva editační řádky nebo štítek(štítky) sloužící pro zobrazení souřadnickurzoru myši nad oknem.Poznámky: Při pohybu myší jegenerována událostOnMouseMove.Metoda napojená na tuto událostdostane jako parametr souřadnicekurzoru myši vzhledem k levémuhornímu rohu okna. Souřadnicepřevedené nařetězec pomocí funkce

IntToStr zobrazíte zkopírováním do vlastnostiText příslušného editačníhořádku.


- 26 -

7.6 Komponenta TEditSpolečně s touto komponentou, která představuje nejpoužívanější způsob, jak získat

vstup od uživatele, uvedeme i příbuznou komponentuTSpinEdit a naučíme studentyzákladní práci sřetězci. Uvedení komponentyTSpinEdit má zejména ten význam, žestudenti budou schopni získávat do svých programů číselné hodnoty, aniž by bylo nutné jeextrahovat zřetězců za nutnosti ošetřování výjimek.

Další příklady vhodné k procvičení práce s editačními řádky jsou uvedené v příloze podnázvyJméno2, Hádej a Zlomky.

Příklad EditDemoProcvičované znalosti: Komponenty TEdit,TButton, TLabel. Reakce na stisk tlačítka.Zadání: Napište program, jehož okno bude obsahovateditační řádek, tlačítko a štítek. Vždy při stiskutlačítka se text zadaný do editačního řádku zkopírujena štítek.

Poznámky: Celý program se bude odehrávat v metodě obsluhující událostOnClick tlačítka.KomponentaTEdit (editační řádek) má vlastnostText, kterou je třeba zkopírovat dovlastnostiCaption komponentyTLabel.

Příklad JménoProcvičované znalosti: Komponenty TLabel, TEdit,TButton. Reakce na stisk tlačítka. Manipulace sřetězci.Volitelně komponentaTRadioButton.Zadání: Napište program, který po zadání jména a příjmenído dvou editačníchřádků vypíše jméno i příjmení na štítek.Poznámky: Vypsání na štítek se provádí nastavenímvlastnostiCaption komponentyTLabel. Spojenířetězcůzařídí operátor „+“.Možná rozšíření: Přidejte editační řádek ještě na titul předjménem a titul za jménem.Dále přidejte možnost zadat přezdívku. Dejte uživateli možnost výběru umístění přezdívky kejménu (Jaroslav Foglar – Jestřáb, Jestřáb – Jaroslav Foglar, Jaroslav „Jestřáb“ Foglar).

Příklad FaktoriálProcvičované znalosti: Komponenty TSpinEdit, TButton,TEdit. Reakce na stisk tlačítka. FunkceIntToStr. Datový typInt64. Rekurze.Legenda: Faktoriál daného přirozenéhočísla n je definován jakosoučin všech přirozenýchčísel menších nebo rovnýchn. Alternativnělze faktoriál pro přirozenáčísla a nulu definovat rekurzivně:

0! = 1n! = n·(n-1)!A právě tuto rekurzivní definici využijeme v našem programu.Zadání: Napište program, který bude obsahovat pole pro zadání hodnoty (tzv. spin edit),tlačítko a editační řádek. V případě, že uživatel stiskne tlačítko, bude vypočten faktoriálhodnoty zadané ve spin editu a hodnota bude zobrazena v editačním řádku.Poznámky: Výpočet faktoriálu provádějte rekurzivně. Pro hodnotu výsledku použijte datovýtyp Int64, tedy 64bitové celéčíslo. Nastavte správně vlastnostiMaxValue a MinValuekomponentyTSpinEdit (aby výsledek nepřetekl, nelze počítat faktoriálčísel větších než 20).K převodučíselné hodnoty výsledku na textovýřetězec použijte funkciIntToStr.


- 27 -

7.7 Komponenty TCheckBox a TRadioButtonDalšími komponentami, se kterými studenty naučíme pracovat, jsou komponenty

důvěrně známé z různých dialogových oken, a siceTCheckBox, TRadioButton aTRadioGroup. Vzhledem k tomu, že prakticky každá větší aplikace tyto komponenty v hojnémíře používá, není třeba si příliš lámat hlavu s motivací studentů, neboť lze předpokládat, že sena tyto komponenty vysloveně těší.

Příklad CloseQueryProcvičované znalosti: Událost OnCloseQuery.KomponentaTCheckBox. Volitelně funkceMessageDlg.Zadání: Napište program, který vytvoří okno s jednímzaškrtávacím políčkem „Lze zavřít“ a jedním tlačítkem

„Zavřít“. Po stisknutí tlačítka „Zavřít“ nebo systémového zavíracího tlačítka se program ukončí,ale pouze v případě, že je zaškrtnuta volba „Lze zavřít“.Poznámky: Povolení zavření formuláře zajišťuje metoda obsluhující událostOnCloseQuerynastavením svého odkazem předávaného parametruCanClose na hodnotuTrue.Možné alternativy: Povolení zavření okna nezávisí na zaškrtávacím poli, ale na výsledkuinterakce s uživatelem pomocí funkceMessageDlg.

Příklad Jednotky

Procvičované znalosti:KomponentyTRadioGroup, TGroupBox, aTLabel.Legenda: Každý ví, jaké problémy přináší dětem na základní škole, když se mají učit různépředpony fyzikálních jednotek vyjadřující jejich násobky. Následující program by měl býtužitečnou pomůckou a může navíc sloužit jako výukový program, který využijí učitelé fyziky.Zadání: Napište program, který vypíše seznam všech předpon, které se používají k udánínásobku fyzikální jednotky. Při kliknutí na každou předponu pak vypíše, jaký násobek předponaznamená a jakou má značku. Pozor na značku mikro!Poznámky: Seznam předpon realizujeme pomocí komponentyTRadioGroup. V metoděobsluhující událostOnClick komponentyTRadioGroup budeme aktualizovat výstupníinformace o předponě. V případě zvolení předpony mikro je potřeba změnit font štítku seznačkou.


- 28 -

Příklad KeypressProcvičované znalosti: Události OnKeyDown, OnKeyUp,OnKeyPress. KomponentaTCheckBox.Zadání: Napište program, který bude reagovat na stiskklávesy tím, že vypíše, o jakou klávesu se jedná. V případě,že je klávesa stisknuta zároveň s některou z kláves Ctrl, Alt,Shift, zobrazí i tuto informaci.Poznámky: Stisk klávesy generuje událostOnKeyDown.Metoda obsluhující tuto událost dostane v parametrech jednakinformaci o tom, jaká klávesa byla stisknuta, a jednak

informaci o modifikátorových klávesách. Při uvolnění klávesy je generována událostOnKeyUp.Vzhledem k tomu, že událostiOnKeyDown/Up nelze poslat hlavnímu formuláři (protože nikdynemá zaměření), musíme přidat nějakou komponentu, která bude tyto události přijímat (např.TEdit).

7.8 VýjimkyMechanismus výjimek je jedním ze stěžejních prvků, které Delphi programátorovi

poskytují. Do této chvíle jsme studentům neustále vštěpovali, že musí důkladně testovatvšechny možné vlastnosti vstupu a důkladně ošetřovat potenciální chyby. Mechanismusvýjimek tuto vlastnost do značné míry popírá, neboť umožňuje bez předchozí kontroly vstupu„vyzkoušet“ provedení nějaké operace a teprve poté zjišťovat, zda došlo k chybě či nikoliv.

Protože se jedná o zcela novou záležitost, se kterou se studenti doposud nesetkali, jepotřeba jejímu probírání věnovat značnou péči a důkladně ji procvičit.

Příklad NSD & NSNProcvičované znalosti: KomponentyTEdit, TButton. FunkceStrToInt, IntToStr. Ošetření výjimek. Algoritmus provýpočet NSD.Legenda: Výpočet největšího společného dělitele a nejmenšíhospolečného násobku patří k důležitým tématům základoškolskématematiky. Následující program může sloužit například žákůmzákladních škol ke kontrolám výsledků při procvičování tohotoučiva.Zadání: Napište program, který vypočítá největšího společnéhodělitele a nejmenší společný násobek daných dvoučísel.Poznámky: K zadáváníčísel využijte komponentuTEdit. Při převádění textu načíslo funkcíStrToInt je třeba zachytávat výjimkuEConvertError. K zobrazeníčíselného výsledkupoužijte inverzní funkciIntToStr, která už pochopitelně žádné výjimky negeneruje.

Příklad SoustavyProcvičované znalosti:Algoritmus převodu mezičíselnýmisoustavami. OOP. KomponentyTEdit, TSpinEdit,TButton. Reakce na událostOnClick. Vyvolávánívýjimek.Legenda: Převody mezi číselnými soustavami jsouv informatice velmi důležité. Využití nacházejí zejménasoustavy o základu 2,8 a 16, zatímco v běžném životě senejčastěji setkáváme se soustavou desítkovou. Soustavy

o základu větším než 10 používají místočíslic písmena (např. šestnáctková soustava používácifry A–F).Zadání: Napište program, kterýčíslo v zadané soustavě (o základu 2-36) převede do jinézvolené soustavy (opět o základu 2-36). Naprogramujte třídu, která bude uchovávatčíslo


- 29 -

v desítkové soustavě a bude obsahovat metody pro převod ze zadané soustavy a pro převod dozadané soustavy. Tuto třídu pak v programu využijte. Záporná a neceláčísla neuvažujte.Poznámky: Nezapomeňte, že tyto metody budou jako vstup (resp. výstup) používatřetězec.Aby se třída chovala korektně, je třeba ošetřit chybové stavy, tedy výskyt nepovolených znaků

ve vstupnímřetězci. V tom případě metoda vyvolá výjimkuEConvertError, kterou je třebav hlavním programu zachytit.Možná rozšíření: Pomocí zpracování syntaxe (xx)(xx) rozšiřte program o možnost převod doa z libovolné soustavy. Dále je možné rozšířit program o zpracování záporných a necelýchčísel.

Příklad Kalkula čkaProcvičované znalosti:KomponentyTButton, TEdit. Reakce nastisk tlačítka. Ošetření výjimek.Zadání: Implementujte kalkulačku, která bude umět sčítat, odčítat,násobit, dělit a odmocňovat.Poznámky: Je třeba správně vyřešit to, že oba operandy jsouzadávány ve stejném editačním okně. Dále nezapomeňte na to, žeuživatel nemusí vždy zadatčíslo (funkce StrToInt v takovémpřípadě vyvolá výjimkuEConvertError).

Příklad TrojúhelníkProcvičované znalosti: Komponenty TEdit,TCheckBox. Ošetření výjimek. MetodaSetFocus.Zadání: Napište program, který pomocí editačníchřádkůnačte tři čísla, která mají určovat délky stran trojúhelníka.Program nejprve ošetří, zda uživatel skutečně zadalčísla,dále ověří, že délky splňují trojúhelníkovou nerovnost apokud ano, vypočte obvod a obsah trojúhelníka. Dáleprogram vypíše informace o tom, zda je trojúhelníkrovnoramenný, rovnostranný nebo pravoúhlý.Poznámky: Převodřetězce načíslo je realizován pomocífunkcíStrToInt aStrToFloat, které očekávají jakoparametrřetězec a vracejí hodnotu požadovaného typu.V případě, že řetězec nelze načíslo převést, vyvolají výjimkuEConvertError, kterou jepotřeba ošetřit. K chybovým výstupům využijte štítek nebo funkciMessageDlg. Dbejte na to,aby v případě zadání chybnéhočísla měl uživatel možnost hodnotu hned upravit (tj. použijteproceduruSetFocus komponentyTEdit). K výpočtu obsahu trojúhelníka ze známých délekstran využijte Heronova vzorce:s:=(a+b+c)/2;VypObsah:=Sqrt(s*(s-a)*(s-b)*(s-c));Pro zveřejnění informace o tom, zda je trojúhelník pravoúhlý, rovnostrannýči rovnoramennýpoužijte zaškrtávací pole (komponentaTCheckBox), která mají vlastnostChecked.Možná rozšíření: Do programu připište funkce počítající vnitřní úhly trojúhelníka. Dále lzeprogram rozšířit o výpočet délek výšek, těžnic, poloměr kružnice opsané a vepsané, atd.

7.9 Práce s časem a komponenta TMainMenuDelphi, na rozdíl od Pascalu, umožňují pracovat s datem ačasem poměrně pohodlným

způsobem, a to pomocí datových typů TDate a TDateTime. Komponentou, která sčasempřímo souvisí, je komponentaTTimer, která umožňuje vykonávat určitou operaci v přesněstanovenýchčasových intervalech.

Menu tvoří základní ovládací prvek složitějších aplikací. Přestože s datem ačasemvůbec nesouvisí, nic nám nebrání v tom, abychom oba prvky demonstrovali pomocí stejnýchpříkladů.


- 30 -

Dalšími příklady, které lze pro ilustraci práce s datem ačasem využít, jsou v příloze podnázvyBiorytmy a Videostop.

Příklad HodinyProcvičované znalosti: KomponentyTTimer, TMainMenu. Datový typTDateTime. Volitelně funkceInputBox.Zadání: Napište program, který budeve svém okně neustále zobrazovataktuálníčas.Poznámky: Ke zjištění aktuálníhočasu slouží funkceTime. K převodučasu na řetězec slouží funkceTimeToStr, které se jako parametrpředáčas (typTDateTime) a výsled-kem je řetězec obsahující zadanýčas

zapsaný ve formátu místního nastavení systému Windows.Možná rozšíření: Rozšiřte program o budík, tedy možnost, aby uživatel zadalčas, v němž se naobrazovce objeví budící zpráva. Při buzení dejte uživateli možnost aktivovat opětovné buzení za5 minut. Program rozšiřte o možnost volby fontu a barvy hodin.

Příklad Sv ětelné noviny

Procvičované znalosti:KomponentyTTimer, TLabel, TMainMenu. Vlastnosti formuláře.Práce s více formuláři.Zadání: Napište program, který bude provozovat světelné noviny, tj. text, který se budeposouvat přes celou šířku okna zprava doleva. Když zmizí za levým okrajem, začne se opětvpravo objevovat. Dejte uživateli možnost zadat zobrazovaný text. Program dále rozšiřteo možnost být stále navrchu a skrýt okraje okna.Poznámky: KomponentaTTimer generuje ve stanovených intervalech událostOnTimer. Natu budeme reagovat přesunutím textu. Je třeba ošetřit, že text vyjel levým okrajem. To, zda oknozůstane stále na povrchu je dáno vlastnostíFormStyle hlavního formuláře, okraje okna jsoudefinovány vlastnostíBorderStyle. Hlavní menu je zneviditelněno v případě, žezneviditelníme všechny jeho položky (vlastnostVisible).Možná rozšíření: Dejte uživateli možnost výběru typu písma a barvy pozadí. Dále nechejteuživatele zvolit rychlost pohybu textu.

7.10 Komponenta TScrollBarKomponentaTScrollBar (posuvník), je také studentům důvěrně známá, podobně

jako tomu bylo u zaškrtávacích polí. K procvičení této komponenty uvedeme dva příklady, kterépomocí funkceRGB nastavují barvu formuláře.

Příklad Barvy3Procvičované znalosti:KomponentaTScrollBar. FunkceRGB.Zadání: Napište program, který vytvoří hlavní okno se třemi posuvníky (scrollbars). Každýposuvník bude příslušet jedné z barevných složek (červená, zelená, modrá). Přetahovánímposuvníků se bude měnit barva hlavního formuláře tak, aby intenzita jednotlivých barevnýchsložek odpovídala pozici posuvníků.


- 31 -

Poznámky: KomponentaTScrollBar rozpozná událostOnChange, kteráříká, že uživatelzměnil pozici posuvníku. Aktuální pozice posuvníku je dostupná ve vlastnostiPositionkomponentyTScrollBar. K nastavení barvy formuláře využijte funkciRGB, která dostává třihodnoty typuByte odpovídající barevným složkám a vrací hodnotu typuTColor.Možná rozšíření: Ke každému posuvníku přidejte štítek, který bude zobrazovatčíselnouhodnotu pozice posuvníku.

Příklad Barvy4

Procvičované znalosti:KomponentyTEdit, TScrollBar. Ošetření výjimekZadání: Formulář příkladu Barvy3 rozšiřte o tři editační pole, která uživateli umožní zadatpřímo číselnou hodnotu dané barevné složky. Po zadáníčísla nastavte barvu formuláře i poziciposuvníku. Pozor na nečíselné nebo nepovolené hodnoty.Poznámky: K převodu řetězce (TEdit.Text) na číslo použijte funkciStrToInt, kteráv případě zadání jiného nežčíselnéhořetězce generuje výjimkuEConvertError, kterou jetřeba zachytit.

7.11 Modální a nemodální formulá řePřestože se studenti s modálními a nemodálními okny v praxi mnohokrát setkali, jsou

pro ně tyto pojmy nové. Je tedy třeba vše důkladně vysvětlit. Navíc, program využívající víceformulářů, musí obsahovat více programových jednotek, které musí být správně propojenypomocí klausuleuses. Následující příklad demonstruje rozdíly mezi modálními a nemodálnímiformuláři.

Příklad ModalProcvičované znalosti:Programy s více formuláři. FunkceShow aShowModal.Zadání: Napište program, který bude mít tři tlačítka: „Otevřít modální formulář“, „Otevřítnemodální formulář“ a „Zavřít“. První tlačítko otevře modální formulář s nápisem „Ahoj, jájsem modální formulář“, druhé tlačítko otevře nemodální formulář s nápisem „Ahoj, já jsemnemodální formulář“ a třetí tlačítko ukončí program.Poznámky: Modální okno je okno, které je aktivní, dokud jej uživatel nezavře (typickydialogové okno). Nemodální okno lze deaktivovat bez zavírání. Z toho plyne, že nemodálních


- 32 -

oken může být otevřeno více, zatímco modální může být v daný okamžik otevřeno jen jedno(samozřejmě za předpokladu, že se jedná o potomky téhož formuláře).K vytvoření tohoto programu budou potřeba tři formuláře (ve třech jednotkách). Dbejte nasprávné propojení klausulemiuses. Modální i nemodální okno jsou definovány stejně.Modalita je určena až za běhu programu tím, zda je okno vyvoláno metodou Show neboShowModal.Modální okno je program schopen kontrolovat, protože si může být jist, že dokud jej uživatelnezavře, nic dalšího se nestane. U nemodálního okna tomu tak není, proto jediný rozdílv definici spočívá v tom, že do metody obsluhující událostOnClose nemodálního okna jetřeba napsat příkazAction:=caFree;Tento příkaz způsobí korektní zrušení dynamicky alokované paměti. Přidáním tohoto příkazui do zavírací metody modálního formuláře sice nic nezkazíte, ale je to zbytečné.Možná rozšíření: Dejte do modálního okna možnost otevřít další modální okno. Oknaumísťujte na náhodnou pozici na obrazovce.

7.12 Vlastnosti formulá ře a objekt ScreenPomocí Delphi lze vytvářet kromě užitečných programů i programy, které mohou

uživatele trochu potrápit. Tyto programy zpravidla vyžadují nastavení určitých vlastností, kterév běžných programech nevyužijeme. Zařazení příkladu tohoto typu, prakticky kdykoliv, jevhodné pro posílení motivace studentů, neboť se rozhodně jedná o program, jehož vytváření jebude bavit. Navíc se u toho naučí věci, které by se u běžných příkladů nenaučili, nebo naučilijen „uměle“. Rozhodně je třeba dbát na to, aby byl příklad tohoto typu zařazen až poté, kdystudenti ovládají „standardní“ učivo.

Uvedeme zde příklad Shutdown, kde je potřeba kromě nastavení barvy a pozice štítkupoužít ještě objektScreen a funkciRGB.

ObjektScreen kromě informací o obrazovce uchovává také seznam písem dostupnýchv systému. Pro demonstraci práce s písmy poslouží příklad ScreenInfo.


- 33 -

Příklad ShutdownProcvičované znalosti: VlastnostikomponentyTForm. Volitelně objektScreen.Zadání: Napište program, který naobrazovce vytvoří dojem, že počítač jetěsně před vypnutím (tj. vytvoří černouobrazovku s nápisem „Nyní můžetepočítač bez obav vypnout“. Dbejte nato, aby efekt nerušil kurzor myši nebohlavní panel Windows.Poznámky: K vytvoření tohoto progra-mu není třeba psát téměř žádný kód.Vše se odehraje v okně ObjectInspectoru nastavením požadovanýchvlastností hlavního formuláře:

BorderStyle := bsNone;Color := clBlack;WindowState := wsMaximized;Dále je potřeba umístit na plochu formuláře komponentuTLabel a upravit její vlastnosti tak,aby výstup odpovídal zadání.Protože hodnotacrNone vlastnostiCursor komponentyTLabel není v Object Inspectorupřístupná, je potřeba tuto vlastnost nastavit až za běhu programu v metodě FormCreatesvázané s událostíOnCreate hlavního formuláře. V této metodě je potřeba též nastavit barvupísma komponentyTLabel na oranžovou (RGB 255, 127, 0), neboť tato barevná konstantarovněž není v Object Inspectoru přístupná.Možné rozšíření: Takto napsaný program bude správně fungovat jen na monitoru se stejnýmrozlišením. Na monitoru s jiným rozlišením nebude nápis přesně uprostřed. Požadovanépřenositelnosti lze dosáhnout nastavením vlastnostíLeft aTop komponentyTLabel za běhuprogramu v metodě FormCreate za využití globálního objektuScreen, který má vlastnostiWidth aHeight uchovávající horizontální a vertikální rozměr obrazovky. O objektuScreenvíce v příkladuScreenInfo.

Příklad ScreenInfo

Procvičované znalosti:ObjektScreen. KomponentyTLabel, TComboBox.Zadání: Napište program, který vypíše informaci o rozměrech obrazovky a umožní ukázkuvšech typů písma instalovaných v systému.Poznámky: Obě informace lze získat pomocí globálního objektuScreen. Rozměry obrazovkyjsou uloženy ve vlastnostechWidth a Height. Názvy fontů jsou uloženy v poliřetězcůFonts. Toto pole můžeme zkopírovat například do vlastnosti Items komponentyTComboBox.Možná rozšíření: Vytvořte vzorník fontů instalovaných v systému, tj. upravte program tak, abyumožnil zobrazení ukázek všech fontů najednou.


- 34 -

7.13 RTTI operátory a parametr SenderRTTI (Run-Time Type Information) operátory slouží k ověřování typu různých objektů

za běhu programu. Nejčastěji to bývá parametrSender, tedy ukazatel na komponentu, kterávyvolala nějakou událost. Na tomto místě uvedeme pouze příklad Dragging, k pozdějšímuprocvičení poslouží příkladyMatematico a RTTIDemo, uvedené v příloze.

Příklad Dragging

Procvičované znalosti:Přetahování pomocí myši. Operátory RTTI.Zadání: Napište program, jehož okno bude obsahovat velký štítek s nápisem a poté několikmalých štítků, z nichž každý bude mít jinou barvu. Při přetáhnutí malého štítku na velký dojdeke zkopírování barvy malého štítku na velký štítek.Poznámky: Přetahování obsluhují událostiOnDragOver a OnDragDrop. První událostkomponentě říká „Něco se nad tebou táhne“, druhá „Něco se nad tebe přetáhno“. Obsluhy obouudálostí dostanou jako parametrSource ukazatel na objekt, který byl na počátku přetahování.Metoda obsluhující událostOnDragOver dostane navíc odkazem parametrAccept, kterýmmůžeme přetahování povolit nebo zamítnout. V našem případě přetahování povolíme právětehdy, když zdrojem je štítek. Vlastní zkopírování barvy se provádí až v obsluze událostiOnDragDrop, tedy těsně poté, co uživatel přetahovaný objekt pustil.

7.14 Komponenty TListBox a TComboBoxTyto komponenty jsou si velmi podobné. KomponentaTListBox je nutná pro

formátovaný a víceřádkový výstup, obě komponenty se dají navíc použít pro vstup. Variantoukomponenty TListBox je komponenta TCheckListBox, použitá v příkladu Věty2v příloze. Variantou komponentyTComboBox je komponentaTColorBox, použitá v příkladuBarvy5, rovněž uvedeném v příloze.

Příklad Prvo číslaProcvičované znalosti: KomponentyTEdit, TButton,TListBox. Volitelně komponenta TRadioGroup.FunkceStrToInt aIntToStr. Ošetření výjimek.Zadání: Napište program, který zadanéčíslo rozloží nasoučin prvočinitelů.Poznámky: Číslo lze zřetězce získat pomocí funkceStrToInt. V případě, že uživatel zadářetězec, kterýneurčuje číslo, funkce generuje výjimkuEConvertError, kterou je třeba ošetřit. Číslo se nařetězec převádí pomocí funkceIntToStr. Zjištěnáprvočísla ukládejte do položkyItems komponenty


- 35 -

TListBox, čímž zajistíte jejich zobrazení.Možná rozšíření: Dejte uživateli možnost zvolit si, zda výstup bude seznam všech prvočísel(s povolením více výskytů) nebo jen seznam prvočísel (každé max. jednou) a jejich mocnin (tj.jestli 24 = 2⋅2⋅2⋅3 nebo 24 = 23⋅31).

Příklad FibonacciProcvičované znalosti: Fibonacciho posloupnost.KomponentyTListBox, TSpinEdit, TButton.Reakce na událostOnClick. FunkceIntToStr.Legenda: Fibonacciho posloupnost je slavnáposloupnost pojmenovaná po italském matematikoviLeonardu Pisánském (1170 – 1250), zvanémFibonacci. Je definována rekurentně takto:a1 = 1a2 = 1an = an-1+ an-2

Každý její člen je tedy součtem dvou členůpředcházejících.Zadání: Napište program, který vygeneruje zadaný počet členů Fibonacciho posloupnosti.Přitom členy budou v seznamu stále přibývat, tj. pokud uživatel stiskne tlačítko podruhé, doseznamupřibudezadaný počet členů.Poznámky: K zadání počtu členů využijte komponentuTSpinEdit. Její použití je v tomtopřípadě výhodnější oproti komponentě TEdit, neboť se nemusíte zabývat převodemřetězce načíselnou hodnotu. Aktuální hodnotu získáte z vlastnostiValue. Veškeré akce se budouodehrávat v metodě napojené na událostOnClick komponentyTButton, která je vyvolánapokaždé, když uživatel tlačítko stiskne. Pro zobrazování seznamučlenů posloupnosti použijtekomponentuTListBox. Její vlastnostItems (položky) je typuTStrings, což je třídareprezentující seznamřetězců a metody pro manipulaci s ním. Z nich využijeme zejménametoduAdd, která na konec seznamu přidá nový řetězec.Číslo lze nařetězec převést např.pomocí funkceIntToStr.Možná rozšíření: Upravte program tak, aby vygenerovaln-tý člen Fibonacciho posloupnosti.V tom případě jej nepočítejte podle rekurentního vzorce (nebo dokonce rekurzivně!), protožepro velkán by to mohlo trvat dlouho (v případě rekurze by to bylo záhy omezeno velikostízásobníku), ale rekurentní vzorec převeďte na vzorec pron-tý člen.

Příklad KurzoryProcvičované znalosti: KomponentaTComboBox. Datový typTCursor.Zadání: Napište program, jehož okno budeobsahovat pouze rozbalovací editační pole(combo box) s typy kurzorů. Při výběrutypu kurzoru se aktuální kurzor formulářezmění podle výběru.Poznámky: Datový typTCursor není nicjiného než celé číslo. Při vhodnémuspořádání konstant tak můžeme vlastnosti

Cursor hlavního formuláře přiřazovat drobně pozměněnou hodnotu ItemIndexrozbalovacího editačního pole.Možná rozšíření: Definujte vlastní kurzory a zahrňte je do programu.


- 36 -

Příklad V ěty

Procvičované znalosti:KomponentyTListBox, TRadioGroup. Manipulace sřetězcem.Zadání: Napište program, který bude sestavovat anglické věty podle vzoru subject ispreposition object. Ke zvolení podmětu a předmětu použijte komponentuTListBox. Použitítermínu „předmět“ je v tomto případě zavádějící, neboť se jedná o příslovečné určení místa,nicméně je to asi nejnázornější označení, jaké lze nalézt.Poznámky: To, že má program sestavovat anglické a nikolivčeské věty je zde z důvodunutnosti skloňovat česká slova, což není předmětem tohoto příkladu. Text zvolené položkykomponentyTListBox získáte pomocí konstrukceItems[ItemIndex]. Pole řetězcůItems obsahuje seznam položek a proměnnáItemIndex určuje právě vybranou položku.Možná rozšíření: Rozšiřte program o možnost přidávání dalších položek mezi podměty i mezipředměty.

7.15 Grafický výstup: T řída TCanvasPoužití třídy TCanvas je patrně nejjednodušší metodou, kterou lze pro grafický výstup

použít. Její nevýhodou je však to, že při minimalizaci a opětovném obnovení okna, případně připřekrytí okna jiným oknem, zmizí vše, co jsme na canvas vykreslili. Tento nedostatekodstraňuje až komponentaTImage.

Příklad GraphDemoProcvičované znalosti: KomponentyTTimer a TPaintBox. VlastnostEnabled. TřídaTCanvas. FunkceRandom aRGB.Zadání: Vytvořte alternativu známého programuBGIDemo dodávaného s Turbo Pascalem. Tj.napište program, který budevykreslovat geometrické objekty. Formulář bude obsahovat panels několika tlačítky: „Start“ spustí vykreslování, „Stop“ zastaví vykreslování, „Další“ způsobívykreslování dalšího objektu, „Předchozí“ způsobí vykreslování předchozího objektu a „Konec“ukončí program. Vykreslované objekty jsou obdélníky, elipsy, přímky a text. Vykresluje sevždy na náhodnou pozici objekt náhodné velikosti a náhodné barvy. Dbejte na to, aby tlačítka,jejichž stisknutí nemá v danou chvíli smysl, byla zakázána.Poznámky: Vykreslení jednoho objektu realizujte v obsluze událostiOnTimer komponentyTTimer. KomponentaTTimer má též vlastnostEnabled, která určuje, zda budou událostiOnTimer generovány. Tuto vlastnost nastavujte tlačítky „Start“ a „Stop“, která mají vlastnostEnabled také.


- 37 -

Možná rozšíření: Rozšiřte paletu vykreslovaných objektů o další objekty, které lze vykreslitjedinou metodou třídy TCanvas. Seznam metod vyhledejte v nápovědě Visual ComponentLibrary Reference.

Příklad Kuli čky

Procvičované znalosti:OOP. KomponentyTButton, TTimer, TLabel. Třída TCanvas.Dlouhodobý projekt.Zadání: Napište program, který bude simulovat kuličky v gravitačním poli v bezodporovémprostředí a s dokonale pružnými odrazy. Program bude obsahovat tlačítko pro vytvoření novékuličky, která bude vytvořena na náhodném místě, bude mít náhodnou rychlost a náhodnoubarvu. Interakce kuliček neuvažujte.Poznámky: Nejprve implementujte jednotku obsahující třídu TKulicka a poté napišteprogram, který bude vytvářet instance této třídy a manipulovat s nimi. Rychlost kuličkyuchovávejte rozloženu na horizontální a vertikální složku. Horizontální zůstává konstantní,vertikální se stále zvětšuje a při odrazu od stěny se mění znaménko příslušné složky.


- 38 -

Možná rozšíření: Rozšiřte program o možnost měnit parametry kuliček i po jejich vytvoření.Implementujte interakci kuliček mezi sebou (opět nechť se jedná o dokonale pružné odrazy).

Příklad Snell

Procvičované znalosti:Snellův zákon lomu. Třída TCanvas. JednotkaMath. Dlouhodobýprojekt.Legenda: Dopadá-li světelný paprsek na rozhraní dvou látek, mohou nastat dvě možnosti:buďto se od tohoto rozhraní odrazí, nebo dochází k lomu. To, která možnost nastane a jakvypadá případný lom, určují tzv. indexy lomupříslušných látek. Index lomun dané látky sevypočítá podle vztahun = c/v,kdec je rychlost světla ve vakuu av je rychlost světla v daném prostředí.Jestliže světlo prochází prostředím o indexu lomun1 a dopadá na rovinné rozhraní s prostředímo indexu lomun2 pod úhlemα1, určuje jeho chováníSnellův zákon(někdy též označovaný jakozákon lomu):sinα1 / sinα2 = n2 / n1

Úpravou tedy dostaneme, žesinα2 = n1 / n2 · sinα1

V případě, že je hodnota pravé strany větší než 1, není úhelα2 definován. Znamená to, ženedochází k lomu, ale k odrazu a v tom případě platí známýzákon odrazu, tedy že úhel odrazuse rovná úhlu dopadu. Dochází-li k lomu, porovnáním úhlů α1 a α2 rozlišujeme lomke kolmicialom od kolmice.Zadání: Napište program, který pro zadané indexy lomu a úhel dopadu rozhodne, zda dojdek lomu či odrazu a vypočítá úhelα2. Dále nechť program zadanou situaci nakreslí (viz obrázek).Poznámky: Ke zpřístupnění goniometrických a cyklometrických funkcí je třeba do klausuleuses přidat jednotkuMath.Možná rozšíření: Rozšiřte program tak, aby pro zadané hodnoty indexů lomu vypočítal tzv.mezní úhel, kdy se paprsek láme přímo na rozhraní.

7.16 Komponenta TImageJak již bylořečeno v předchozíčásti, komponentaTImage uchová svůj vzhled i poté,

co dojde k překreslení okna. Nevýhodou je určité zpomalení práce s grafikou, které však vevětšině případů není na škodu.

Příklad GraphDemo2Procvičované znalosti:KomponentaTImageZadání: Upravte programGraphDemo tak, aby namalované objekty nebyly zničenyminimalizací okna nebo překrytím jiným oknem.Poznámky: Do okna vložte komponentuTImage a kreslete pomocíTImage.Canvas.KomponentaTImage totiž svůj obsah ukládá do bitmapy, tudíž je schopna jej obnovit.Bohužel, ukládání informací je pomalé a program proto bude blikat.


- 39 -

Příklad Gonio

Procvičované znalosti: KomponentyTImage, TRadioGroup. Třída TCanvas. FunkceIsInfinite, IsNAN. Ošetření výjimek. Dlouhodobý projekt.Zadání: Napište program, který nakreslí graf uživatelem zvolené goniometrické funkce naintervalu <0,2π>. Pozor na dělení nulou a nedefinované hodnoty funkcítg a cotg. Velikostgrafu nechť je dána velikostí okna.Poznámky: Kreslení realizujte pomocí položkyCanvas komponentyTImage (obsahujepoložkuPen a metodyMoveTo a LineTo). Při kreslení grafu je výhodnější používat právěmetoduLineTo oproti přirozenějšímu (a definici grafu jako množiny bodů více vyhovujícímu)způsobu, kdy obarvujeme jednotlivé body. V případě obarvování jednotlivých bodů totiž nenívýsledná křivka spojitá.Výběr funkce je realizován komponentouTRadioGroup. Jednotlivé položky se nastavují vevlastnostiItems a právě zvolenou položku udává hodnota vlastnostiItemIndex (pozor,první položka máItemIndex roven0).Možná rozšíření: Upravte program tak, aby uživatel mohl zvolit interval, na němž bude funkcevykreslována (a to jak osyx, tak osyy).Dále je možné program rozšířit tak, aby kreslil graf libovolné elementární funkce. Poté můžemepomocí důkladné analýzy vstupu kreslit grafy libovolných funkcí.

7.17 Vytvá ření komponent za b ěhu programuVytváření komponent za běhu programu je velmi užitečné ve chvíli, kdy chceme

vytvořit velké množství komponent a jejich umísťování na formulář v době návrhu aplikace bybylo zdlouhavé. Přesný počet komponent navíc nemusí být v době návrhu aplikace znám.Příklad Matematico je příklad, v němž by bylo zdlouhavé nejen komponenty na plochuformuláře umísťovat, ale i vyhodnocování reakcí na události by bylo velice nepřehledné.

Příklad MatematicoProcvičované znalosti: KomponentaTButton a její vlastnosti. ParametrSender. RTTI.Tvorba komponent za běhu programu. Dlouhodobý projekt.Legenda: Hra Matematicoje v různých matematických třídách hrou dobře známou. Hraje sebuď s kartami (všech 4x13 karet) nebo s kartičkami očíslovanýmičísly 1-13 tak, že každéčísloje zastoupeno právě čtyřikrát. V případě, že se hraje s kartami, přiřadíme každé kartě patřičnouhodnotu: eso 1, kluk 11, dáma 12, král 13, ostatní karty mají své hodnoty.Hru je možno hrát jako solitér nebo s pomocí psacích potřeb ve skupině. Každý hráč si připravíčtvercovou síť 5x5 políček. Karty se zamíchají a poté jsou náhodně vytahovány. Úkolem hráčůje umísťovat taženáčísla do připravené sítě tak, aby měli na konci hry co největší bodové skóre.


- 40 -

Jednou umístěná čísla již nelze přesouvat. Hrakončí v okamžiku, kdy je umístěno 25.číslo a síť jetak zaplněna. Poté si každý hráč spočítá dosaženébody tak, že sečte body dosažené v každémřádku,sloupci a obou úhlopříčkách. Tyto body lze získatza to, že daný řádek, sloupecči úhlopříčkaobsahuje:Dvojici stejnýchčísel 10b.Trojici stejnýchčísel 50b.Dvě různé dvojice stejnýchčísel 30b.Trojici stejnýchčísel a dvojici stejnýchčísel 80b.Čtveřici stejnýchčísel 100b.Postupku (ne nutně setříděnou) 100b.Nejvyšší postupku (9..13) 110b.Jen jedničky a třináctky 110b.V případě, že něco z toho je v úhlopříčce, přičítá senavíc bonus 10b.Zadání: Implementujte hruMatematico.Poznámky: Všech 25 tlačítek lze vyrobit dyna-micky v metodě obsluhující událostOnCreatehlavního formuláře. Soustavou dvou vnořenýchcyklů for inicializujeme pole tlačítek a nastavíme

jejich pozice a další vlastnosti. Dalším zjednodušením je použití položkyTag. Tuto položkuobsahuje každá komponenta a jsou to 4B k uloženíčehokoliv, implicitně hodnoty typuInteger. Této položky můžeme použít pro uložení hodnoty, kterou tak při vyhodnocovánískóre nemusíme získávat z titulku tlačítka. Metodu obsluhující událostOnClick tlačítka stačínapsat jen jednou, napojit ji na každé tlačítko a pak se na to správné tlačítko odkazovat pomocíparametruSender, který ukazuje na komponentu, která událostvyvolala (tedy tlačítko, kterébylo stisknuto).Možná rozšíření: Napište proceduru, která taženáčísla uspořádá tak, aby bylo dosaženonejvyššího možného skóre. Dále je možné program upravit tak, aby ukazoval bodové hodnotyu každéhořádku, sloupce i úhlopříčky.

7.18 DialogyDialogová okna různého druhu jsou nezbytným prostředkem pro komunikaci programu

s uživatelem. Jako vedlejší efekt některých dříve uvedených příkladů se již studenti naučilipoužívat funkce ShowMessage a MessageDlg. Další možností komunikace jsoustandardizovaná okna pro výběr barev (TColorDialog), otvírání souborů (TOpenDialog,TOpenPictureDialog) a ukládání souborů (TSaveDialog).

Příklad ObrázkyProcvičované znalosti: Komponenty TMainMenu, TImage, TOpenDialog neboTOpenPictureDialog.Zadání: Napište program, který umožní zobrazit vybraný obrázek uložený v souboru na disku.Poznámky: K získání jména souboru s obrázkem použijte komponentuTOpenDialog neboalternativně komponentuTOpenPictureDialog. Obě komponenty mají metoduExecute,která vracíTrue v případě, že si uživatel vybral a stiskl tlačítko OK a False v případě, žeuživatel ukončil dialog stiskem tlačítka Cancel. Jméno vybraného souboru je dostupnév položceFileName. Zobrazení obrázku se provádí pomocí položkyPicture komponentyTImage, která má metoduLoadFromFile.Možná rozšíření: Rozšiřte program o možnost roztáhnout obrázek na celou plochu okna,volitelně se zachováním poměru šířky a výšky obrázku. Využijte k tomu vlastnostiStretchaProportional komponentyTImage.


- 41 -

Příklad Barvy5

Procvičované znalosti: Popupmenu. ProceduraClose. Kom-ponentaTColorDialog.Zadání: Napište program, kterývytvoří prázdné okno, které postisknutí pravého tlačítka myšivyvolá kontextové menus volbami „Barva…“ a „Konec“.V případě, že uživatel zvolípoložku Barva, otevře sestandardní dialog pro výběr barvya v případě, že uživatel vybralbarvu a výběr potvrdil stiskem klávesy OK, nastaví se barva hlavního formuláře na uživatelemvybranou. V případě, že uživatel vybere volbu Konec, program bude ukončen.Poznámky: Ke spuštění dialogového okna využijte metoduExecute komponentyTColorDialog, která vracíTrue v případě, že si uživatel vybral a stiskl OK aFalsev případě, že uživatel ukončil dialog stiskem tlačítka Cancel (Storno). Vybraná barva jedostupná ve vlastnostiColor. K ukončení programu využijte metoduClose hlavníhoformuláře.

7.19 MřížkyMřížky mají v aplikacích Delphi různou podobu a široké použití. Lze je využít jak pro

vstup, tak pro výstup. Nejjednodušší mřížkou je komponentaTColorGrid, použitá pro výběrbarvy v příkladu Kreslení. Příklady Miny a Patnáctka používají komponentuTDrawGrid,tedy mřížku, do které se kreslí a příklad Matice je založen na komponentě TStringGrid,tedy mřížky řetězců.


- 42 -

Příklad Miny je uveden v následující podkapitole, příklad Matice lze nalézt v příloze.Dalším relevantním příkladem je příklad Barvy7, uvedený rovněž v příloze.

Příklad Kreslení

Procvičované znalosti:KomponentyTColorGrid, TPaintBox. TřídaTCanvas. UdálostiOnMouseDown, OnMouseMove, OnMouseUp. Dlouhodobý projekt.Zadání: Napište jednoduchý kreslicí program. Okno bude mít na okraji mřížku pro výběr barvypopředí a barvy pozadí. Při tažení myší se stisknutým tlačítkem se bude na ploše okna kreslitčára barvy popředí (je-li stisknuto levé tlačítko) nebo pozadí (je-li stisknuto pravé tlačítko).Poznámky: Vzhledem k tomu, že událostOnMouseMove není generována nad každýmbodem, je vhodné kreslení realizovat ne pomocí obarvování bodů, ale pomocí metodyLineTo.Čára tak může být při rychlých pohybech myší kostrbatá, nicméně vždy bude spojitá.Možná rozšíření: Rozšiřte program o možnost kreslení úseček a následně také obdélníkůa elips, které budou mít obrys barvy popředí a výplň barvy pozadí.

Příklad PatnáctkaProcvičované znalosti: KomponentaTDrawGrid. UdálostOnMouseDown neboOnMouseUp.Legenda: Patnáctka patří mezi známé hlavolamy. Jejíimplementace ve výpočetní technice je navíc poměrnějednoduchá, proto tvoří běžnou součást repertoáru her namobilních telefonech a byla též nesčetněkrát implementovánajako počítačová hra. V reálném světě se jedná očtvercovoukrabičku, v níž jsou uloženyčtvercové hrací kameny. Každýkámen má délku strany rovnučtvrtině strany krabičky. Kamenůse do krabičky tedy vejde 16, ale je jich v ní jen 15, tudíž jednomísto zůstává stále volné a s kameny je tak možné posunovat.Každý kámen má na sobě jiné číslo od 1 do 15. Úkolem hráče je

náhodně rozmístěné kameny pomocí přesouvání poskládat podle velikostičísla. Pravé dolnípolíčko zůstane na konci hry prázdné.


- 43 -

Dá se dokázat, že ne vždy je možné kameny správně poskládat. Jestliže počáteční rozmístěníkamenů vzniklo přesouváním kamenů z uspořádané pozice, je to možné vždy. V případěnáhodného rozmístění kamenů se může stát, že daná permutace má špatnou paritu a tudížkameny poskládat nelze.Zadání: Implementujte hru Patnáctka. Pozor na to, aby šla dohrát!Poznámky: Pracovní plochu pokryjte komponentouTDrawGrid, v níž se bude vše odehrávat.Přesun realizujte v metodě obsluhující událostOnMouseDown/OnMouseUp komponentyTDrawGrid, neboť pak budete mít k dispozici souřadnice myši a tím i souřadnice políčka, nakteré uživatel kliknul (využijte funkciMouseToCell). Reakce na událostOnSelect, která jegenerována, když uživatel označí buňku, s sebou nese více problémů než užitku.Možná rozšíření: Umožněte hru hrát i v poli jiných rozměrů než 4x4.

7.20 Dynamická poleDynamická pole jsou velmi mocným nástrojem, zejména proto, že jejich rozměry je

možné použít např. jako parametry konstruktoru, který vytváří daný objekt. Dynamická polejsou použita v příkladu Miny a dále v příkladechBloudění, Matice a volitelně též Vlajky,uvedených v příloze.

Příklad MinyProcvičované znalosti: Komponenty TDrawGrid,TMainMenu, TStatusBar. Dynamická pole. Reakce nastisk myši v mřížce. Dlouhodobý projekt.Legenda: Uživatelům operačního systému Windows je hraHledání minjistě notoricky známa. Na začátku je neprobádanéminové pole. Uživatel klikáním myší může každé políčkobuďto prozkoumat (levým tlačítkem) nebo označit jakozaminované (pravým tlačítkem). Pokud se rozhodneprozkoumat zaminované políčko, hra pro něj končí výbuchem.Pokud prozkoumává nezaminované políčko, zobrazí se mupočet min na sousedních osmi políčkách. V případě, že je tentopočet nulový, sousedních osm políček se automatickyprozkoumá, atd. Úspěšný konec hry je ve chvíli, kdy jsouoznačena všechna zaminovaná políčka (a jen ta).

Zadání: Implementujte hruHledání min. Uživatel bude mít možnost zvolit si stupeň obtížnosti.Počet zbývajících min ukazujte ve stavovémřádku.Poznámky: K vykreslování minového polepoužijte komponentuTDrawGrid. Vykreslováníse provádí v metodě obsluhující událostOnDrawCell, která dostane jako parametr políčko,které se právě vykresluje. Nad formátem ukládání dat je potřeba trochu popřemýšlet, protože jetřeba ukládat více informací, než se na první pohled zdá. Stavovýřádek je realizovánkomponentouTStatusBar, jejíž vlastnostSimpleText uchovávářetězec zobrazený vestavovémřádku.Možná rozšíření: Dejte uživateli možnost, aby přímo zadal rozměry minového pole a početmin.

7.21 Komponenta TMemoKomponentaTMemo je nezbytná v místě, kde chceme pracovat s holým textem, který je

organizován pořádcích. Typická aplikace je pak textový editor, viz příklad Editor a jehorozšířeníEditor2 a Editor3 dostupná v následující podkapitole, respektive v příloze.

Příklad SouboryProcvičované znalosti: Komponenty TDriveComboBox, TDirectoryListBox,TFileListBox, TMemo.


- 44 -

Zadání: Napište prohlížeč souborů, tedy program, který umožní procházet adresářovoustrukturou a v případě zvolení konkrétního souboru zobrazí jeho obsah.Poznámky: K výběru diskových jednotek slouží komponentaTDriveComboBox, k výběruadresáře komponenta TDirectoryListBox a k výběru souboru komponentaTFileListBox. Tyto komponenty je ovšem třeba navzájem propojit. KomponentaTDriveComboBox má vlastnost DirList, jíž je třeba přiřadit komponentuTDirectoryListBox. KomponentaTDirectoryListBox má vlastnostFileList,které se přiřazuje komponenta typuTFileListBox. Zvolení konkrétního souboru generujeudálost OnChange komponenty TFileListBox. Obsah souboru zobrazí komponentaTMemo, jejíž položkaLines obsahuje metoduLoadFromFile.Možná rozšíření: Za použití komponentyTFilterComboBox upravte program tak, abyzobrazoval skutečně jen textové soubory.

Příklad EditorProcvičované znalosti: Komponenty TMainMenu, TMemo, TOpenDialog,TSaveDialog, TFontDialog, TColorDialog. Funkce MessageDlg. Práce s víceformuláři. Dlouhodobý projekt.Zadání: Implementujte textový editor, tedy okno, jež bude pokryto zejména editačním polema bude obsahovat roletové menu s příkazy pro otevření souboru, jeho uloženíči uložení podjiným jménem. Dále bude obsahovat možnost volby typu písma a barvy pozadí v editačním polia volbu zarovnávání textu. Samozřejmě nesmí chybět dialogové okno „O programu Editor“obsahující informace o verzi a autorovi programu.


- 45 -

Poznámky: Dejte pozor na to, aby uživatel nemohl zavřít program, jestliže jsou v souboruneuložené změny. K zobrazení obsahu souboru použijte komponentuTMemo, jejíž položkaLines obsahuje metodyLoadFromFile a SaveToFile, kterým se jako parametr předávátextový řetězec s názvem souboru. Nastavení fontu, barvy pozadí a zarovnávání se realizujezměnou příslušných vlastností na základě výsledku font-dialogu nebo color-dialogu.

7.22 Nástrojová lišta a stavový řádekU složitějších aplikací býváčasto užitečné zjednodušit uživatelům ovládání programu

pomocí nástrojové lišty s tlačítky, která odpovídají některým funkcím hlavní nabídky. K tomuslouží komponentyTToolBar a TSpeedButton. Vhodným doplňkem je komponentaTStatusBar, tedy stavovýřádek, pomocí níž můžeme snadno a rychle uživatele informovato činnostech prováděných programem a jejich stavu.

Příklad Editor2

Procvičované znalosti:KomponentyTToolBar, TSpeedButton, TStatusBar. UdálostOnHint.


- 46 -

Zadání: ProgramEditor rozšiřte o nástrojovou lištu (toolbar) s tlačítky pro vytvoření novéhosouboru, otevření a uložení souboru, zarovnávání v editačním poli a zobrazení informacío programu. Dále opatřete editační pole vodorovným a svislým posuvníkem, jejichž zobrazenínechejte na vůli uživatele v nabídce Možnosti. V případě zrušení posuvníků dejte uživatelimožnost volby, zda v editačním poli zalamovatřádkyči nikoli. Dále program rozšiřte o stavovýřádek, v němž se bude objevovat nápověda k položkám menu a informace o tom, zda bylaktuální soubor změněn.Poznámky: Nástrojovou lištu realizujte pomocí komponentyTToolBar a komponentTSpeedButton. Posuvníky jsou dány vlastnostíScrollBars komponenty TMemo(využijte hodnotyssNone a ssBoth). Zalamování textu realizujte vlastnostíWordWrapkomponentyTMemo. Stavový řádek pak komponentouTStatusBar, která obsahuje polePanels, v němž jsou informace o rozdělení stavovéhořádku a textovéřetězce zobrazenév jednotlivýchčástech.Nejnáročnější částí tohoto příkladu je zobrazování nápovědy k položkám menu ve stavovémřádku. U každé položky menu je potřeba naplnit vlastnostHint popisem. Pak je potřeba vědět,že při zaměření položky menu je generována událostOnHint objektuApplication aHintprávě zaměřené položky je dostupný v proměnné Application.Hint. Na událostApplication.OnHint je tedy potřeba napojit námi napsanou metodu, která obsahproměnnéApplication.Hint zkopíruje do stavovéhořádku.

7.23 Další výukaDelphi samozřejmě obsahují daleko více komponent, než bylo doposud v této kapitole

uvedeno. Navíc se jich dá spousta nalézt na Internetu, nebo si dokonce mohou studenti vytvářetsvé vlastní komponenty. Vše záleží na tom, kolikčasu chceme výuce Delphi věnovat. Je zřejmé,že na některých školách není možné probrat vše, co bylo v předcházejících bodech navrženo.Ale jsou i školy, kde se toho stihne daleko více. Vše záleží na celkové koncepci, zaměřeníškoly, zájmu studentů a schopnostech učitele.

Pro doplnění a důkladné procvičení uvedeného učiva lze využít příklady uvedenév příloze, případně se zabývat dlouhodobými projekty, o nichž se zmíníme později. Běhemrealizace dlouhodobých projektů může nastat (a pravděpodobně nastane) situace, kdy budevhodné probrat některé z dalších témat. V úvahu přitom mohou připadat:

� Schránka (jednotkaClipBrd), viz příklad Editor3 v příloze� Komplexníčísla (jednotkaVarCmplx), viz příklad Complex v příloze� Záložky (komponentaTTabControl), viz příklad Obrázky2 v příloze� MDI aplikace, viz příklad Obrázky3 v příloze� Tvorba vlastních komponent� Práce s databázemi� Práce se sítí� Práce s multimédii� Multithreadové aplikace (jednotkaTThread)� atd.

Kromě komponent, které je vhodné probrat, obsahují Delphiřadu komponent, bezkterých se naši studenti mohou bez problémů obejít. Typickým příkladem je komponentaTBitBtn. Umí toho stejně jako komponentaTButton, liší se jen bitmapou na svém povrchu.Každému je zřejmé, že tato komponenta se použije v případě, kdy chceme zlepšit grafickouúroveň našeho programu. Na jeho funkčnost vliv nemá, nepočítáme-li nepatrné zpomalenízpůsobené načítáním a vykreslováním bitmapy.

Je proto zcela zbytečné, abychom studenty učili používat tuto komponentu, protožejediné, co bychom je naučili nového, je přiřazení bitmapy vlastnostiBitmap této komponenty.Může se zdát, že to není problém, protože by nám to nezabralo příliš mnohočasu, opak je všakpravdou. Studenti by se začali velice intenzivně zabývat tím, aby na tlačítkách ve svých


- 47 -

aplikacích měli co nejoriginálnější bitmapy a zcela by se tak vytratil smysl naší výuky, totiž učitje programovat.

Další zbytečnou komponentou je komponentaTBevel, která nic neumí, jen na plošeformuláře vytváří čáry a 3D efekty. Někdy je samozřejmě užitečná pro zpřehlednění aplikačníhoprostředí, ale při naší výuce si jistě vystačíme s komponentouTPanel.

Neznamená to, že bychom studentům použití zmíněných komponent zakazovali, tov žádném případě. Jejich nastudování však můžeme nechat na nich. Ti, kteří se budouprogramováním v Delphi zabývat i mimo naši výuku, dříve či později alespoň vyzkouší téměřvšechny komponenty. Některé z nich se jim zalíbí více než jiné a pak je budou ve svýchprogramech používat. Je potom na místě je pochválit za to, že něco nastudovali sami, ale také jevhodné poukázat (jen tak meziřečí) na to, že přílišné používání těchto komponent zdržuje prácia odvádí nás od skutečného programování.

7.24 Funkce vývojového prost ředíJe zřejmé, že hned v první hodině, kdy Delphi probíráme, musíme studenty seznámit se

základními funkcemi, které integrované vývojové prostředí poskytuje. Bez toho by totižpochopitelně nebyli schopni napsat, přeložit a spustit jediný program. Jak již bylo zmíněno, jenesmírně důležité, aby studenti hned v první hodině napsali a spustili funkční program. Protoževývojové prostředí poskytuje velké množství různých funkcí, nevyhneme se tomu, že připrvním seznámení s prostředím některé funkce vynecháme a jejich probrání odložíme napozdější dobu. Navíc, mnohé funkce studenti zpočátku vůbec nevyužijí a těžko bychom je tedypřesvědčovali o jejich užitečnosti. Proto počkáme na vhodnou dobu, kdy studenty s těmitofunkcemi seznámíme.

Protože Delphi je vývojové prostředí pro profesionální programátory, je zřejmé, že aniv případě, že chceme výuce Delphi věnovat velmi mnohočasu, nebude třeba studentyseznamovat úplně se vším, co Delphi profesionálním programátorům nabízí. Je proto na zváženíučitele, které funkce je naučí a které ne. Velkou roli v tom samozřejmě musí sehrát vlastnípraxe, tedy to, které funkce učitel sám používá. Následující výčet uvádí příklady těch skutečněnejpoužívanějších funkcí:

� Seznam komponent. Seznam komponent je v nabídce dostupný přes View –> ComponentList. Poskytuje abecedně tříděný seznam všech komponent dostupných v Delphi.Programátor tak nemusí přemýšlet nad tím, kde se daná komponenta v paletě komponentnachází a ušetří spoustučasu jejím hledáním. Samozřejmě musí vědět jak se jmenuje, ale toje zpravidla menší problém. Vhodným okamžikem k seznámení studentů s touto funkcí jesituace, kdy vidíme, že studenti mají s vyhledáváním komponent v paletě problémy. Kdyžvidíme, jak někdo bezradně kliká a nemůže požadovanou komponentu nalézt, nebo se násněkterý ze studentů zeptá, kde danou komponentu najde, kromě správné odpovědi jevhodnýčas na to, abychom studenty upozornili na tuto funkci.

� Místa zastavení (breakpoints): Jestliže program v neznámém místě cyklí, nebo mámepodezření že nedělá to, co bychom od něj očekávali, a přitom nevíme, kde je chyba,můžeme na podezřelá místa umístit breakpointy. Breakpoint se umisťuje kliknutím na levýokraj okna vedleřádku, na kterém chceme program zastavit. Poté program spustíme. Tenpoběží až do chvíle, kdy narazí na breakpoint. V tu chvíli se zastaví a programátor vidí, vekterém místě byl zastaven. Následně může použít některou z funkcí, které s breakpointybezprostředně souvisejí. Vhodným okamžikem k probrání této funkce je situace, kdystudentiřeší složitější algoritmický problém, mají v programu chybu a nevědí jakou. Použitíbrakpointů, krokování a watch listu tak studentům velmi pravděpodobně pomůže, takžebudou přesvědčeni o užitečnosti probírané funkce.

� Systém nápovědy. V žádném případě nemůžeme po studentech vyžadovat, aby sipamatovali přesné parametry předávané funkcím, jejich pořadí a vůbec všechny detaily. Bezdetailů se však mnohdy neobejdeme, proto je vhodné, poté, co se studenti naučí základníúkony v integrovaném vývojovém prostředí, vysvětlit systém nápovědy a nadále pak véststudenty k jeho využívání.


- 48 -

� Krokování: Zastavený program lze krokovat, tedy provádět řádek pořádku. Pomůže nám toodhalit místo, kde se vyskytuje problém. Při volání funkce máme dvě možnosti, jakprogram krokovat. Buďto funkci vykonat v rámci jednoho kroku (Step over – F8) anebokrokovat i tělo funkce (Trace into – F7). Místo, kde je v programu logická chyba, se tak dápřesně lokalizovat.

� Zobrazení hodnot proměnných (Watch list): Tato funkce bezprostředně souvisís krokováním po zastavení programu v určitém místě. Chování programu mnohdy závisí nahodnotách proměnných a je proto dobré vědět, jak se hodnoty proměnných mění v závislostina vykonávaných příkazech.

7.25 Forma vs. obsahDelphi jako vizuální prostředí velice svádí k tomu, že programátor stráví daleko více

času vizuálním návrhem aplikace, než tvorbou skutečného kódu. V komerční sféře, kde je každáaplikace nutně týmovou prací, jsou tyto úkoly rozděleny mezi různé lidi. Zatímco vzhledaplikace, uspořádání komponent a podobné záležitosti jsou spíše záležitostí psychologiea marketingu, tvorbu kódu mají na starosti programátoři, kteří se vzhledem programu přílišnezabývají.

Po studentech budeme pochopitelně chtít obojí: Grafické uspořádání komponent a jejichvzhled, i tvorbu kódu. Při výuce však musíme dávat velký pozor na to, aby se uspořádáváníkomponent nestalo tím hlavním, co studenti v hodinách dělají. Výuka informatiky v tuto chvílinení o tom, naučit studenty skládat tlačítka a okénka, ale o tom, naučit je programovat.Zpočátku je proto nutné tuto skutečnost zdůrazňovat téměř každou hodinu a tomutoparadigmatu také přizpůsobit celkový styl výuky a volbu příkladů.

Jako flagrantní příklady nepochopení úlohy vizuálníhovývojového prostředí uveďmeněkolik citací z knihy [4]:

Kapitola 1, Formulář je okno, str. 17:„Mohli byste totiž nabýt dojmu, že programovánís Delphi je pouze otázkou výběru voleb a vizuálních elementů. To je jistě hlavní přístup, alepřijde čas, kdy budete muset napsat i nějaký kód.“

Pokud kniha, která o sobě tvrdí, že je nejlepší učebnicí Delphi, obsahuje hned v prvníkapitole tuto větu, je to skutečně tristní.Čtenář tak lehce nabude dojmu, že v Delphi se dá téměř

všechno „vyklikat“ a že psaní kódu je tam jen jaksi mimochodem a nebude příliš nutné.A přitom je to přesně naopak: důležitý je kód, nikoliv vizuální návrh. Důležitý je

funkční program, nikolivdobře vypadajícíprogram.Shrnutí kapitoly 11, Panel nástrojů a stavový pruh, str. 386:„Tuto kapitolu můžeme

považovat za první krok k profesionálním aplikacím. Další kroky probereme v následujícíchkapitolách, ale už nyní se naše programy podobají nejprodávanějším aplikacím Windows, cožmůže být pro naše klienty zásadní.“

To, že pro naše klienty může být zásadní, že se naše programy podobajínejprodávanějším aplikacím Windows, je mrzuté, ale bohužel je to pravda. Lidé velmi snadnopodléhají dojmu dobře vypadajících a snadno se ovládajících programů. Jsou to samozřejmě

vlastnosti důležité, ale v žádném případě nesmějí být považovány za důležitější než funkčnost.Bohužel, velmičasto jsou.

Studentům je vhodné podat problém přibližně následujícím způsobem: „Vzhledprogramu je jistě věc důležitá a na prodejnost programu má nezanedbatelný vliv. Ale to, co jeu dobrého programu daleko důležitější, je jeho funkčnost. To, že dělá to co má, že to dělá dobře,rychle, efektivně a bezchybně. Pokud sebelépe vypadající program nebude funkční, nemá šanci.Je sice pravda, že pokud sebefunkčnější program nebude dobře vypadat, jeho šance jsou téžomezené, ale forma (vzhled) se vždy mění snáze než obsah (funkčnost). My jsme tu proto,abychom se naučili programovat, nikoliv proto, abychom se naučili skládat tlačítka na plochuformuláře. Snažte se proto, aby vám grafický návrh aplikace nezabral déle než psaní kódu.“

Je nepříjemné, že se nevyhneme tomu, abychom hned u prvních programů tuto zásaduporušili. Studenti se totiž při psaní programů v Delphi nejprve seznámí se základnímikomponentami a teprve poté mohou psát kód, který tyto komponenty obsluhuje. Napříkladv příkladu Ahoj, který je určen k tomu, aby byl prvním programem v Delphi, není aniřádek


- 49 -

kódu, vše je jen o nastavování vlastností komponent. Proto je nutné co nejdříve (nejlépe vedruhé či třetí hodině výuky Delphi) zařadit příklad, kdy kód bude důležitější než vizuálnínastavení komponent (např. zjednodušená verze příkladu Světelné noviny, příklad Faktoriál,atp.).

Názor, prezentovaný výše, má své velké ALE. Pokud studenty povedeme k tomu, abyse příliš nezabývali vzhledem své aplikace, hrozí reálné nebezpečí, že studenti svůj programodbudou. Prostě na povrch formuláře nějak „nahážou“ komponenty nezajímajíce se o to, zdajsou aspoň pod sebouči vedle sebe, a hned se vrhnou na psaní kódu. To je sice v souladus naším přesvědčením, že psaní kódu je důležitější, ale program nebude udělán pořádně. Jepravda, že to, co na něm nebude pořádně, není pro nás příliš důležité, ale chybou je to, že vůbecněco nebude pořádně. A to bychom samozřejmě neměli dopustit. Studenti by si měli neustáleuvědomovat, že když už něco dělají, měli by to dělat kvalitně. Je zde totiž nebezpečí, že pokudstudenti odbudou grafický návrh, stejným způsobem odbudou i kód, což by bylaneospravedlnitelná pedagogická chyba.

Proto je třeba zvolit vhodný kompromis. Studenti by grafický návrh neměli odbýt, aletaké by se jím neměli zabývat přehnaně dlouhou dobu. Alespoň urovnání komponent pod sebe avedle sebe bychom tedy vyžadovat měli, přehnané vizuální záležitosti (bitmapy, bevely,…) užnikoli.

7.26 Předdefinované aplikace a expertiJedna z věcí, kterou si skuteční programátoři v Delphi velmi pochvalují, je to, že firma

Borland už za ně udělala to, co by jinak museli dělat pokaždé znovu, a sicekostru aplikace.Programátor tak má k dispozici funkční grafické prostředí, ve kterém stačí zpravidla provést jendrobné změny, a může se rovnou zabývat tím, co má program umět a začít psát příslušný kód.Přestože je to v souladu ze zásadou popsanou dříve (zabývat se více kódem než vzhledem), jetřeba před použitím těchto vymožeností v počátcích výuky varovat.

Podívejme se, jak vypadá použití předdefinovaných formulářů: Programátor se proklikánějakou strukturou až k aplikaci, kterou potřebuje, a Delphi ji vygenerují (resp. odněkudnakopírují). Výsledkem je množství souborů s množstvím kódu. Ten, kdo chce v taktopředdefinovaném kódu něco měnit nebo dopisovat nějaký kód vlastní, se musí v tom, coBorland vyrobil, vyznat, což není možné bez předchozí praxe s programováním v Delphi.Kromě toho to není možné, pokud si programátor alespoň jednou sám nevyzkoušel vyrobit to,co mu teď předkládají Delphi.

To, že takováto věc v Delphi existuje, je samozřejmě dobré studentům sdělit, ale ažv době, kdy jsou v programování v Delphi zběhlí a dokážou se v předdefinovaném kódu vyznat.Jinak totiž riskujeme, že studenti budou měnit něco, co měnit nemají a aplikace se začne chovatnepochopitelně. Nám se tam budou těžko hledat chyby a studenti získají dojem, že je to přílišsložité a že tomu nerozumí a ztratí motivaci k dalšímu učení.

Dlouhodobé projekty

- 50 -

8 Dlouhodobé projektyChceme-li výuce Delphi věnovat větší množstvíčasu, což je v této souvislosti alespoň

půl roku, budeme postaveni před problém, zda studentům zadat samostatný dlouhodobý úkolčinikoli. Zadání například pololetního projektu s sebou přináší spoustu výhod, ale bohužel takéčetná rizika, která je třeba zvážit. Tato kapitola poskytuje základní argumenty pro a proti, kteréučiteli pomohou při rozhodování, zda a jakým způsobem dlouhodobé projekty do výuky zařadit.Pro ty, kteří se rozhodnou pro dlouhodobé projekty, nabízí několik inspirativních příkladů.

8.1 Výhody dlouhodobých projekt ů

Zadáním samostatné práce studenty nepřímo donutíme, aby se programování v Delphivěnovali i mimočas stanovený k výuce. To pochopitelně povede k tomu, že se studenti v Delphinaučí programovat daleko lépe, než kdyby se mu věnovali pouze v době výuky.

Je-li navíc programování kromě školního předmětu také koníčkem velkého procentastudentů, což pravděpodobně nastane, je-li programování volitelným předmětem, který sizapisují jen studenti, kteří o něj mají zájem, studenti takový úkol s velkou pravděpodobnostídokonce uvítají.

Necháme-li studentům velkou míru autonomie při volbě projektu, nebo dokoncepovolíme týmovou spolupráci (viz dále), studenti se naučí „objektově myslet“ a možnái rozdělovat pracovní úkoly a spolupracovat v týmu, což jsou dovednosti, které v pozdějšímživotě rozhodně najdou uplatnění.

8.2 Nevýhody dlouhodobých projekt ů

Asi tím nejpodstatnějším rizikem dlouhodobých projektů je potenciální nedostupnostpotřebného vybavení pro studenty. Ne každý má doma počítač a rozhodně ne každý má domaDelphi, o jejich legálnosti nemluvě. Nemůžeme si proto v žádném případě dovolit deklarovatprojekt jako domácí práci. Poskytuje-li škola svým studentům přístup k počítačům i mimovýuku informatiky, a studenti se tak mají šanci dostat k Delphi ve svém volnémčase, jeproblémčástečně vyřešen, stále je tu však potenciální kapacitní problémči riziko, že čas, kdystudenti mohou počítače využít, se některému z nich z vážných důvodů nebude hodit. Kroměindividuálního přístupu (bez nějž bychom se pochopitelně stejně neobešli) a různých výjimek senabízí také možnost nechat v některých vyučovacích hodinách studenty na svých projektechpracovat. Ti nadanější tak získají šanci stihnout vše ve škole a nebudou muset trávit naddomácími úkoly svůj volný čas, navíc budeme mít přehled o tom, jak studenti s tvorbouprojektů postupují, budeme mociřešit vzniklé problémy, a donutíme studenty, aby svůj úkolřešili průběžně a ne až na poslední chvíli.

Druhé možné riziko nastane zejména tam, kde programování není zároveň koníčkema kde se Delphi učí v rámci povinného předmětu. Je jím nutnost věnovat větší množství volnéhočasu škole. To může u studentů, kteří nejsou programováním příliš nadšeni,vyvolat značnounevoli a v konečném důsledku může vést ke zprotivení programování jako učebního předmětu,což je samozřejmě velmi nežádoucí. Navíc, pokud bychom studentům zadali dlouhodobýprojekt zejména proto, aby se naučili programovat více, než by se naučili jen v době výuky, jeto svým způsobem naše selhání, neboť nedokážeme studenty naučit stanovené učivo vestanovenémčase. A takovéto selhání mohou negativně vnímat studenti, rodiče i vedení školy.

8.3 Dlouhodobé projekty: Ano či neV případě konkrétní školy, konkrétního učitele a konkrétních studentů se jistě mohou

objevit i další argumenty, které mohou uvažování nad tímto problémem značně posunout.V obecné rovině, bez uvážení dalších okolností, je závěr takový, že v případě výuky Delphiv rámci povinného předmětu je lepší dlouhodobý projekt do výuky nezařazovat, v případěvolitelného předmětu to možné je. Ale i v takovém případě je vhodné studenty již v době volbyvolitelných předmětů na tuto skutečnost upozornit, ať vědí, co mají od předmětu očekávat.


- 51 -

V následujícím textu předpokládejme, že učitel zvážil všechna pro a proti vypisovánídlouhodobých projektů a rozhodl se pro jejich vypsání. Budeme se tedy zabývat některýmiobecnými zásadami, kterými by se v takovém případě měl řídit.

8.4 Zásady dlouhodobých projekt ů

Nejdůležitější je, aby studenti měli možnost zvolitči vymyslet si svůj vlastní projekt.Jistě se totiž mezi nimi najdou takoví, kteří už na něčem pracují ze svého vlastního zájmu,a budou tak moci svůj „soukromý“ projekt prohlásit za školní projekt. Kdybychom studentůmněco vnucovali, ztratí motivaci. Protiargumentem ale může být, že se aspoň naučí tvořitprogramy na zakázku a přesně podle pokynů zadavatele, nicméně otázka motivace je v tutochvíli důležitější. Ať však studentům necháme jakoukoliv míru autonomie, je nesmírně důležitéponechat si právo veta. Projekty, které si studenti vymyslí, musíme schválit. Vyhneme se takpozdějším komplikacím.

I když necháme studentům možnost vytvořit vlastní projekty, musíme dát těm, kteří sisvůj projekt nevymyslí, možnost volby z námi předem připravených projektů. Nemělo by sestát, že budou dva lidé programovat to stejné a přitom by si každý měl vybrat projekt, který muvyhovuje. Příkladů je proto potřeba vymyslet poměrně značné množství. Zde se pochopitelně

uplatní schopnosti a kreativita učitele, jako dlouhodobé projekty mohou posloužit i některéz příkladů uvedených v této práci.

Tím jsme tedy vyčerpali možnost, že každý student pracuje zcela samostatně na svémvlastním projektu. To ovšem není jediná možnost. Další možností je spolupráce všech studentů

na témže projektu. Studenti se tak naučí sami rozložit komplexní úkol na dílčí problémy a tytoproblémy si rozdělit tak, aby to bylo spravedlivé. Zároveň se naučí spolupráci a komunikaciv týmu. Budou muset předem definovat, co mají které třídy a funkce umět a s jakými parametryse mají volat. To znamená, že ještě před vlastním plněním úkolu budou muset provést jehodůkladnou analýzu. Nebojme se této domluvě věnovat i několik vyučovacích hodin, neboť to jejedna z nejdůležitějších věcí, které si studenti ze školy mohou odnést. Dále je dobré citlivýmizásahy domluvu studentů usměrňovat, aby vše proběhlo „správně“. Největší kus práce by všakměli udělat studenti sami. I zde je však dobré, aby celý projekt včetně rozdělení práce mezijednotlivé studenty, prošel naším schválením.

Ani tato druhá extrémní možnost náš výčet neukončuje. Kompromisnímřešením jenechat studenty tvořit v libovolně početných (tedy i jednočlenných) skupinách. Hlediskoskupinové spolupráce zde zůstane zachováno a výuka se nám navíc bude lépe organizovat.

Obrovským rizikem je však to, že se mezi studenty najdou takoví, kteří budou mimojakoukoliv skupinu a zůstanou na svůj projekt sami. Může to být způsobeno tím, že jim to takvyhovuje a že to tak sami chtějí, což by bylo v pořádku, ale také tím, že je třídní kolektivzavrhuje a ostatní s nimi nechtějí spolupracovat. Této situaci musímeza každou cenuzabránit.Buďto tím, že násilně stanovíme počet členů projektové skupiny,čímž studenty donutíme, abysi své spolupracovníky vybrali i mezi těmito „outsidery“, nebo tím, že jakékoliv skupinyzakážeme úplně. I v případě, že tento jev odhalíme pozdě, máme ještě možnost takovýmtostudentům s tvorbou projektů pomoci a nepřímo je oproti týmovým projektům zvýhodnit,samozřejmě citlivě, abychom neudělali svým přístupem více škody než užitku. Mezi studentymohou být samozřejmě znalostí rozdíly. Budeme mít ve třídě studenty, kteří se dokáží prosaditvíce, i studenty, kteří se dokáží prosadit méně. Naší povinností je dát šanci všem. Ani sebelepšíznalosti, které předáme talentovaným studentům nemohou ospravedlnit pocity méněcennosti aztrátu motivace těch méně schopných.Čím více dáme studentům autonomie, tím větší rizikapodstupujeme. Studenti se sami nikdy nedomluví tak, aby to bylo zcela spravedlivé. Od tohojsme tam my, abychom je usměrnili. Pokud se na to necítíme, je lepší příliš autonomiestudentům nedávat a nechat je pracovat samostatně na přidělených projektech. Takovétoautoritářství bude lepší než špatně řízená demokracie. Dobrý učitel by však měl umět dobře říditdemokracii mezi studenty. A toto je k tomu skvělá příležitost, pokud se dobře využije.


- 52 -

8.5 Témata dlouhodobých projekt ů

Jak již bylo zmíněno, chce-li učitel vypisovat dlouhodobé projekty, musí mít sámpřipravenou zásobu témat, které bude přidělovat studentům, kteří nebudou schopni vymysletvlastní téma. Některé příklady uvedené v příloze mohou být použity jako témata dlouhodobýchprojektů. Tato skutečnost je v charakteristice příkladů uvedena. Kromě těchto příkladů uvedemeještě některá další možná témata, mezi nimiž budou i hry:

Příklad GrafProcvičované znalosti: Komponenta TImage. Třída TCanvas. Syntaktická analýzavstupníhořetězce. Elementární funkce. Dlouhodobý projekt.Zadání: Napište program, který ze vstupu načte funkční předpis jakékoliv funkce sestavenépomocí elementárních funkcí a nakreslí její graf.Rozšíření: Upravte program tak, aby kreslil graf v různém měřítku a zadaných výřezech.

Příklad Kuželose čkyProcvičované znalosti: KomponentaTImage. Třída TCanvas. Kuželosečky. Dlouhodobýprojekt.Zadání: Napište program, který bude kreslit reálné kuželosečky se zadanými parametry. Dejteuživateli možnost zadat kuželosečku pomocí matice i pomocí volby jejího typu a určujícíchparametrů.Rozšíření: Upravte program tak, aby kuželosečku nakreslil ve zvoleném měřítku. Dáleumožněte uživateli zadat výřez kuželosečky, který chce nakreslit.

Příklad TesterProcvičované znalosti:Dynamická pole. Manipulace sřetězci. Práce se soubory. Dlouhodobýprojekt.Zadání: Napište program, který bude sloužit jako univerzální testovací program. Programnejprve ze souboru načte seznam otázek a možných odpovědí k nim. Poté nechá uživatele zvolitu každé otázky odpověď, kterou považuje za správnou a nakonec uživatelův výkonohodnotí.Rozšíření: U každé otázky je obrázek, kterého se daná otázka týká. Program tak najde aplikacinapř. pro testování znalosti rostlin, živočichů, atd.

Příklad PiškvorkyProcvičované znalosti: KomponentaTDrawGrid. Dynamická pole. Algoritmus piškvorků.Dlouhodobý projekt.Zadání: Napište program, který umožní hrát dvěma hráčům hru piškvorky na omezenémdvourozměrném poli. Dejte uživatelům možnost zvolit si rozměry pole a délku piškvorky.Rozšíření: Rozšiřte program tak, aby uměl hrát proti jednomu hráči.Rozšíření: Implementujte trojrozměrné piškvorky. Opět nejprve pro dva hráče, poté můžetezpracovat algoritmus, podle kterého bude hrát počítač.

Příklad DámaProcvičované znalosti: KomponentaTDrawGrid. Události myši. Algoritmus hry Dáma.Dlouhodobý projekt.Zadání: Implementujte hru Dáma tak, aby mohli hrát dva hráči proti sobě.Rozšíření: Rozšiřte program tak, aby umožňoval hrát jednomu hráči proti počítači.

Příklad TetrisProcvičované znalosti: KomponentaTDrawGrid. Dynamická pole. OOP. Dlouhodobýprojekt.Zadání: Implementujte hru Tetris. Dejte uživateli možnost zvolit si rozměry herní plochy,počáteční rychlost a počáteční zaplněnost herní plochy.


- 53 -

Rozšíření: Napište editor hracích kostek a dejte možnost hráčům zvolit si vlastní tvary, sekterými budou hrát.

Příklad SnipesProcvičované znalosti:KomponentaTDrawGrid. Dynamická pole. OOP. Algoritmus tvorbybludiště. Dlouhodobý projekt.Legenda: Snipes je prastará hra pod operační systém MS-DOS. V dvourozměrném bludišti,které tvoří povrch koule, je rozmístěno několik krabic, produkujících „záškodníky“. Záškodnícise mohou pohybovat a střílet. Úkolem hráče, který se může pohybovat, střílet a pohybovatdvojnásobnou rychlostí, je zlikvidovat všechny záškodníky a jejich líhně. Jakékoliv střelymohou mít jeden z osmi základních směrů. Hráčovy střely se navíc mohou odrážet od stěn.Zadání: Implementujte hru Snipes. Dejte hráči možnost zvolit si obtížnost hry, tedy počet líhnía rychlost líhnutí.Rozšíření: Upravte hru tak, aby náraz do stěny znamenal ztrátu života.Rozšíření: Upravte hru tak, aby se po smrti záškodník proměnil v ducha, který bude odebírathráči životy tím, že do něj narazí. Ducha lze zlikvidovat opět střelbou.Rozšíření: Upravte hru tak, aby ji mohli hrát dva hráči. Ať už proti sobě, nebo spolupracující.

Příklad ČerviProcvičované znalosti: Komponenty TImage, TTimer. Třída TCanvas. Událostiklávesnice. Dlouhodobý projekt.Legenda: Hra Červi je určená teoreticky libovolnému počtu hráčů. Prakticky je jejich početomezen tak, aby se vešli k jedné klávesnici. Hraje se na omezené hrací ploše. Každý hráč másvéhočerva, který se jen prodlužuje. Pomocí dvou kláves (vpravo a vlevo) každý hráč svéhočerva řídí. Kdo narazí do hranice herního území nebo těla libovolnéhočerva (i vlastního), protoho hra končí. Zvítězí hráč, který vydrží nejdéle.Zadání: Implementujte hruČervi. Dejte možnost volby počtu hráčůRozšíření: Dejte hráčům možnost určit si klávesy, kterými budou svéčervy ovládat.

Příklad TankyProcvičované znalosti: KomponentaTImage. Třída TCanvas. Šikmý vrh. Dlouhodobýprojekt.Legenda: V krajině proti sobě stojí několik tanků, každý patří jednomu hráči. Hráči sepravidelně střídají. Ten, který je na tahu, zvolí zbraň, úhel a rychlost, a vypálí. Střela dopadnena místo určené rovnicí vrhu šikmého vzhůru, kde vybuchne a zničí vše do určité vzdálenosti,včetně případných tanků. Zvítězí hráč, jehož tank zůstane ve hře jako poslední. Zbraně se lišípředevším svoji sílou, počet různě silných střel je však omezen. Hráč může nevhodnou střelouzničit nebo poškodit i sám sebe. Hra neprobíhá na rovině, ale vřezu náhodně vygenerovanékrajiny. Není proto třeba se zabývat azimutem střely, ale jen úhlem, který hlaveň tanku svírá sezemí. Po střelách zůstávají v zemi krátery, do nichž mohou tanky sklouzávat.Zadání: Implementujte hru Tanky.Rozšíření: Implementujte algoritmus, podle kterého bude počítač hrát za některé tanky.Rozšíření: Fantazii programátora se meze nekladou. Lze vymýšlet nové a nové zbraně (laser) arůzně implementovat možnost volby zbraní, včetně nákupů zbraní mezi jednotlivými koly, kdyhráči ve zbraně proměňují svá skóre, která získali v předchozím kole.

Závěr

- 54 -

9 ZávěrZačátek této práce je věnován cílům výuky informatiky na různých stupních škol.

K naplnění těchto cílů může sloužit výuka OOP, proto jsme se jí v dalším textu zabývalipodrobně. Uvedli jsme, jaké jsou cíle výuky OOP a jaké prostředky k tomu můžeme využít.Rozebrali jsme si výhody a nevýhody nejpoužívanějších objektových jazyků a na základě jejichanalýzy jsme zvolili nejvhodnější postup při výuce OOP na střední škole. Konkrétně jsmedospěli k tomu, že k výuce základů OOP použijeme ve většině případů jazyk Object Pascal, nanějž co nejdříve navážeme výukou vývojového prostředí Borland Delphi.

Další kapitoly této práce pojednávají v souladu se závěry z prvních kapitol o výuceObject Pascalu a Borland Delphi. Těžiště této práce spočívá především v konkrétníchpříkladech, na nichž bude výuka OOP realizována. Příkladů je přímo v textu práce uvedenošedesát, dalších více než dvacet příkladů tvoří přílohu. Jsou zde uvedeny jak příkladyjednoduché, na kterých se studenti naučí pracovat s konkrétní komponentouči funkcí, takpříklady složitější, které ze strany studentů vyžadují komplexní analýzuřešeného problémua spojení dílčích poznatků v jeden celek. Mezi příklady najdeme i takové, které přesahují rámecinformatiky. Studenti v nich využijí znalosti z matematiky, fyziky, angličtiny či zeměpisu, cožpozitivně ovlivní jejich všeobecný rozhled a propojí informatiku s běžným životem.

Většina příkladů je pro názornost doplněna obrázkem. U každého příkladu sezamýšlíme nad tím, co studenty naučí. U každého příkladu jsou též uvedeny rady, které mohoustudentům pomoci při plnění zadání příkladu. Některé příklady je možné dále rozšiřovat; možnározšíření jsme rozebrali. Vzorovéřešení většiny z uvedených příkladů je dostupné nadoprovodném CD. Všechny příklady jsou formulovány tak, aby mohly být bez dalších úpravpřevzaty a předány studentům, a to jak ve formě mluveného slova, tak ve formě tištěnéči jakoWWW prezentace. Hotová vzorovářešení lze využít – např. za použití datového projektoru –pro názornou demonstraci zadání.

V poslední kapitole této práce jsme se zabývali dlouhodobými projekty jakoprostředkem ke zdokonalení výuky OOP. Uvedli jsme jejich výhody, nevýhody a podmínky, zanichž je možné je do výuky zařadit. Dále jsme uvedli zásady, které je při zařazení dlouhodobýchprojektů do výuky potřeba dodržovat, rizika, kterým musí učitel předcházet, a nastínili několikpříkladů, které mohou jako zadání dlouhodobých projektů sloužit.

Středoškolští učitelé informatiky, kteří uvažují o zařazení OOP do výuky, mohou v tétopráci nalézt argumenty, které jim jejich rozhodování usnadní. Příklady zde uvedené pak mohoubýt cennou inspirací pro ty, kteří se rozhodnou výuku OOP realizovat.

Literatura

- 55 -

Literatura[1] Bendl, S.:Školní kázeň. Praha, ISV, 2001[2] Blažek, B.:Tváří v tvář obrazovce. Praha, Sociologické nakladatelství, 1995[3] Cangelosi, J.S.:Strategieřízení třídy. Praha, Portál, 1994[4] Cantú, M.:Mistrovství v Delphi 2. Brno, Computer Press, 1996[5] Cimrman, J., Smojlak, L.:Vyšetřování ztráty třídní knihy. Praha, Paseka, 1992[6] Čáp, J.:Psychologie pro učitele. Praha, 1954[7] Černochová, M., Komrska, T., Novák, J.:Využití počítače při vyučování. Praha, Portál

1998[8] Dmitrijev, J.: Savci známí i neznámí, lovení i chránění. Praha, Lidové nakladatelství,

1987[9] Ezzel, B.:Object Oriented Programming in Turbo Pascal® 5.5. Addison-Wesley

Publishnig Company, 1988[10] Fanderlík, V.:Listy Jurovi. Brno, Blok, 1991[11] Gates, B.:Informační dálnice, Praha, Management Press, 1997[12] Hejný, M.; Kuřina, F.:Dítě, škola, matematika. Konstruktivistické přístupy ve

vyučování. Praha, Portál 2001[13] Herout, P., Rudolf, V., Šmrha, P.:ABC programátora v jazyce C: ANSI C, BORLAND

C, C++. České Budějovice, Nakladatelství KOPP, 1992[14] Herout, P.:Učebnice jazyka Java. Nakladatelství KOPP, 2001[15] Hohl, P.:Jak učit OOP (diplomová práce). Brno, Fakulta Informatiky MU, 1996[16] Horák, F. a kol.Didaktika základní a střední školy. Praha, SPN, 1990[17] Horák, F. a kol.:Aktivizační didaktické metody ve výchovně vzdělávacím procesu.

Olomouc, KPÚ, 1981[18] Hutchinson, T.:Project English 3. Oxford University Press, 1987[19] Chan, M.C., Griffith, S.W., Iasi, A.F.:1001 tipů Java. Brno, UNIS Publishing, 1997[20] Kalhous, Z., Obst, O. a kol.:Školní didaktika. Praha, Portál, 2002[21] Kohout, J.:Rétorika. Umění mluvit a jednat s lidmi. Praha, Management Press, 1996[22] Kol.: Rozum do kapsy, malá encyklopedie. Praha, Albatros, 1988[23] Kyriacou, Ch.:Klíčové dovednosti učitele (Cesty k lepšímu vyučování).Praha, Portál,

1996[24] Lewis, D.:Tajnářeč těla. Praha, Victoria Publishnig, 1995[25] Macek, P.:Adolescence. Praha, Portál, 1999[26] Mareš, J., Křivohlavý, J.:Komunikace ve škole, Brno, Masarykova univerzita, 1995[27] Mikulčák, J., Klimeš, B., Široký, J., Šůla V., Zemánek Fr.:Matematické, fyzikální a

chemické tabulky pro střední školy. Praha, SPN, 1989[28] Ochranová, R., Kozoubek, M.:Objektové programování v Turbo Pascalu, Brno,

Masarykova Univerzita, 1993[29] Pařízek, V.:Učitel a jeho povolání. Praha, SPN, 1988[30] Pelikán, J.:Mýty v pedagogice a empirický výzkum. Učitelské listyč. 1/1999-2000[31] Pitner, T.:Metodika OOP a událostmiřízeného programování (diplomová práce).Brno,

Fakulta Informatiky MU, 1995[32] Prokeš, J.:Člověk a počítač aneb svítání digitální kultury. Sursum, Tišnov, 2000[33] Průcha, J.:Moderní pedagogika, Praha, Portál, 1997[34] Rys, S.:Příprava učitele na vyučování. Praha, SPN, 1979[35] Slavík, J., Novák, J.:Počítač jako pomocník učitele. Praha, Portál, 1997[36] Svojsík, A.B.:Základy Junáctví, Praha, Merkur, 1991[37] Zapletal, M.:Rádce skautské družiny. Praha, Skauting, 1991

Internetové zdroje

- 56 -

Internetové zdroje[38] Janoušek, V.:Smalltalk. Fakulta Informačních technologií VUT, Brno, 1997,

http://www.fit.vutbr.cz/~janousek/smalltalk/smalltalk.html[39] Panici, J.D.:Have You Considered Smalltalk?. In: Why Smalltalk, 2002,

http://www.whysmalltalk.com/articles/considered.htm[40] Kol.: Wikipedia, The Free Encyclopedia, http://www.wikipedia.org/[41] Kol.: The Eiffel Programming Language,

http://www.engin.umd.umich.edu/CIS/course.des/cis400/eiffel/eiffel.html

Příloha: Další příklady

- 57 -

Příloha: Další p říklady

Příklad Barvy6

Procvičované znalosti:KomponentaTColorBox.Zadání: Napište program, který vytvoří okno s rozbalovacím okénkem pro výběr barvy.Pokaždé, když uživatel v rozbalovacím okně vybere barvu, změní se barva hlavního formuláře.Poznámky: UdálostOnChange komponentyTColorBox je generována při výběru novébarvy. Vybraná barva je dostupná ve vlastnostiSelected.Možná rozšíření: Pomocí Object Inspectoru upravte barevné konstanty, které si uživatel můževybrat.

Příklad Barvy7 (Vzorník barev)

Procvičované znalosti: Komponenty TColorGrid, TScrollBar, TRadioButton.Dlouhodobý projektZadání: Napište program, který vygeneruje vzorník barev. Protože prostor barev zobrazitelnýchv režimu true color je trojrozměrný a obrazovka počítače jen dvourozměrná, postupujte tak, žeuživatel bude mít možnost jednu zvolenou barevnou složku pevně zafixovat na zvolené


- 58 -

hodnotě. Poté program vygeneruje dvourozměrnou mřížku, kdy se v jednom směru budezvyšovat jedna barevná složka a ve druhém druhá. Protože možností je 256 x 256, což by bylopomalé, velké a nepřehledné, hodnota barevné složky v sousedním políčku bude vyšší vždyo vhodnou hodnotu (8,16,…).Poznámky: K vygenerování vzorníkupoužijte komponentuTDrawGrid. Vykreslování mřížkyse provádí v metodě obsluhující událostOnDrawCell, která dostane velmi užitečnéparametry: Souřadnice mřížky a výřez (TRect) obrazovky, ve kterém se kreslí. Nezapomeňte,že políčka, která mají některou souřadnici nulovou, tvoří záhlaví tabulky a místo barevnéhočtverce je potřeba do nich vypsat hodnotu příslušné barevné složky.Možná rozšíření: Když uživatel klikne na některé políčko, zobrazí se hlášení s konkrétnímihodnotami barevných složek daného políčka.Když uživatel klikne na některé políčko, zobrazí se nový vzorník, který bude upřesňovathodnoty daného políčka. Uživatel tak bude mít možnost prohlédnout si všech 256 x 256 x 256barev.

Příklad BiorytmyProcvičované znalosti:KomponentaTMonthCalendar.FunkceInputBox. TypTDate. Dlouhodobý projekt.Legenda: Někteří psychologové tvrdí, že to, v jaké ječlověk fyzické formě, jakou má náladu a jak dobře se mupřemýšlí, je dáno pravidelně se opakujícími cykly. Polovinakaždého cyklu je tvořena tzv. pozitivní fází, polovinanegativní fází,a dny, kdy se tyto fáze střídají, jsoukritickédny. Fyzický cyklus, který určuje, jak sečlověk cítí fyzicky,a zda je schopen podávat náročné výkony, trvá 23 dnů.Psychický cyklus určující duševní stav a náladu má 28 dnů

a intelektuální cyklus, určující schopnost používatinteligenci, trvá 33 dnů. Všechny cykly začínají v dennarození. Souhrnně se označují pojmembiorytmusa graf, donějž je pro každý den zanesen stav všech cyklů, se nazývákondiciogram.Díky různé délce cyklů pak během života většinou nastanouvšechny možné kombinace pozitivních, negativnícha kritických dnů. Kondiciogramy jsou hojně využíványvrcholovými sportovci. Některé výzkumy ukazují, žestatisticky významné procento dopravních nehod se stáváv kritické dny a některé aerolinky dokonce plánují lety

svých pilotů s ohledem na jejich biorytmus (viz [18], str. 104).Zadání: Napište program, který po zadání data narození vypočítá kondiciogram.Poznámky: K implementaci je možné využít buďto komponentuTMonthCalendar, nebonějakou jinou „kalendářovou“ komponentu, popř. vyřešit výstup úplně jinak, fantazii se mezenekladou. K výpočtu počtu dní, jež uplynuly od narození, využijte datový typTDate a funkciDate, která vrací dnešní datum právě v typu TDate. TDate není nic jiného než počet dnů,které uplynuly od 31.12.1899 (1.1.1900 má tedy hodnotu 1). Prostým odečtením hodnotTDatetak získáte počet dní uplynuvších mezi dvěma daty. Po zadání data narození uživatelem je totomožné převést na datum pomocí funkceStrToDate, která vrací hodnotu typuTDate nebovyvolá výjimkuEConvertError.Možná rozšíření: Zadaná data narození společně se jmény uživatelů ukládejte do souboru a pospuštění programu je načtěte. Uživatel, který bude váš program používatčastěji, tak nebudeobtěžován neustálým zadáváním svého data narození.


- 59 -

Příklad Bloud ění

Procvičované znalosti: OOP. Algoritmus tvorby bludiště. Komponenta TDrawGrid.Dynamická pole. Dlouhodobý projekt.Zadání: Vytvořte jednotkuBludiste, která bude implementovat metody pro vytvořenía procházení bludiště zadaných rozměrů. Bludištěm se v tomto případě rozumí obdélníkovépole, jehož jednotlivá políčka jsou nebo nejsou oddělena stěnou. V bludišti musí mezi každýmidvěma políčky existovat právě jedna cesta.Dále napište program, který bude tuto jednotku používat a umožní uživateli zadat rozměrybludiště, vytvoří bludiště a umožní bludiště projít.Poznámky: Bludiště je vhodné implementovat jako třídu TBludiste, jejíž stěžejní datovástruktura bude dynamické pole položek typuTPolicko obsahujících informaci o zdechohraničujících dané políčko. Bludiště vytvořte pomocí konstruktoruCreate, který dostanejako parametry právě rozměry bludiště. Rozměry dynamického pole se nastavují pomocífunkce SetLength (NázevPole, Rozměr1 [, Rozměr2, ...]). Pozor naokrajové části, bludiště musí být uzavřené!V implementaci doprovodného programu využijte komponentu TDrawGrid (kreslicí mřížka).Ta obsahuje událost OnDrawCell, která je vyvolána pokaždé, když se překresluje políčkomřížky. Parametry předávané metodě obsluhující tuto událost pak umožní velice přesněa efektivně bludiště nakreslit. Pomocí parametrů Col a Row udávajících souřadnice právěvybrané buňky a reakce na událost OnSelect, která nastane pokaždé, když uživatel označí(myší či klávesnicí) některou buňku, lze nastavením hodnoty CanSelect regulovatprocházení mřížky.Použitý algoritmus: Při implementaci tohoto příkladu bylo použito algoritmu postupnéhoprobourávání zcela zazděného bludiště. Zpočátku vybíráme náhodná sousední políčka, kterápropojujeme. Každé políčko uchovává „číslo oblasti“ , které je na začátku pro každé políčkojedinečné. Probouráním zdi mezi dvěma sousedními políčky dojde ke spojení oblastí a v jednéz oblastí je tak potřeba všechna políčka přečíslovat. Tímto mechanismem je zajištěno, žepolíčka se stejným číslem jsou propojená. Pokud navíc nebudeme probourávat stěny mezipolíčky se stejným číslem oblasti, máme jistotu, že tato políčka jsou propojená právě jednoucestou tak, jak požaduje zadání. Protože spojování náhodně vybraných políček je od určité dobyznačně neefektivní, přejde program na systematický průchod bludiště, v němž propojí to, codoposud propojeno nebylo. Třída TPolicko obsahuje převedším vlastnosti ZedNahorea ZedVlevo, které jsou typu Boolean a určují, zda je nahoře, resp. vlevo políčko zazděné. Je


- 60 -

zřejmé, že vlastnosti ZedVpravo a ZedDole by byly redundantní, neboť tyto vlastnostiplynou z hodnot patřičných vlastností sousedních políček (pravý a spodní okraj bludiště jeošetřen zvlášť).Možná rozšíření: Libovolná počítačová hra založená na bludišti. Fantazii se meze nekladou.

Příklad CloseMe

Procvičované znalosti: Vlastnost Visible. Událost OnMouseMove.Zadání: Napište program, jehož okno bude obsahovat tlačítko „Zavřít“ , při jehož stisku seprogram ukončí. Poté program upravte tak, aby kdykoliv se uživatel přiblíží kurzorem myšik zavíracímu tlačítko, toto tlačítko zmizelo.Poznámky: Komponenta TButton obsahuje vlastnost Visible, jejímž nastavením nahodnotu False se komponenta stane neviditelnou. Opětovným nastavením na True jekomponenta opět zviditelněna. Nastavování provádějte v metodě obsluhující událostOnMouseMove hlavního formuláře, která dostane jako parametry souřadnice kurzoru myši.Tyto souřadnice porovnávejte s hodnotami vlastností Left, Top, Width a Heightkomponenty TButton. Metodu, která skryje tlačítko, je vhodné napojit i na událostOnMouseMove tlačítka, neboť v případě, že uživatel pohne myší hodně rychle, systémnestihne generovat událost OnMouseMove nad každým bodem pohybu kurzoru a mohlo by sestát, že kurzor myši dorazí nad tlačítko dříve, než jej stihnete skrýt.Možná rozšíření: Formulář může zavíracích tlačítek obsahovat více. Dále lze program upravittak, aby nebylo možné jej ukončit stiskem systémového zavíracího tlačítka v titulku (využijteudálost OnCloseQuery).

Příklad CloseMe2

Procvičované znalosti: Událost OnMouseMove. Změna vlastností komponenty za běhuprogramu.Zadání: Napište program, jehož okno bude obsahovat tlačítko zavřít podobně jako v příkladuCloseMe. Rozdíl oproti příkladu CloseMe bude spočívat v tom, že pokaždé, když se uživatelkurzorem myši přiblíží k tlačítku, tlačítko se posune tak, aby se k němu uživatel nedostal.Poznámky: V metodě obsluhující událost OnMouseMove hlavního okna, která dostane jakoparametry aktuální pozici kurzoru myši, nastavujte vlastnosti Top a Left tlačítka. Pozor na to,aby uživatel nemohl vytlačit tlačítko z plochy formuláře.Možná rozšíření: Opět lze umístit na formulář více zavíracích tlačítek nebo zabránit zavíráníokna systémovým tlačítkem.


- 61 -

Příklad Complex

Procvičované znalosti: Jednotka VarCmplx. Počítání s komplexními čísly. Dlouhodobýprojekt.Zadání: Napište program, který pomocí editačního řádku načte komplexní číslo v algebraickémtvaru a vypíše jeho absolutní hodnotu a argument. Program poté rozšiřte o možnost zadánídruhého komplexního čísla a provedení uživatelem zvolené operace (sčítání, odčítání, násobení,dělení).Poznámky: K implementaci použijte funkce z jednotky VarCmplx, která umožňujeimplementovat komplexní čísla v rámci datového typu Variant. Základní konstruktorkomplexního čísla je funkce VarComplexCreate, která dostává jako parametr textovýřetězec tvaru a+bi a vrací hodnotu typu Variant. Na takto utvořená komplexní čísla lze pakaplikovat standardní operátory +,–,*,/ funkce VarComplexAbs a VarComplexAngle,které zjišťují absolutní hodnotu a argument.Možná rozšíření: Kalkulačka v komplexním oboru

Příklad Editor3

Procvičované znalosti: Jednotka ClipBrd. Práce se schránkou. Dlouhodobý projekt.Zadání: Rozšiřte program Editor2 o možnost použití schránky (Clipboardu), a to jak pomocíklávesových zkratek, tak pomocí menu a nástrojového pruhu.


- 62 -

Poznámky: Do klausule uses je třeba přidat jednotku ClipBrd. Tím se nám zpřístupníglobální objekt ClipBoard, který obsahuje metodu HasFormat, která jako parametr obdržíformát schránky (v našem případě to bude konstanta CF_TEXT) a vrací True nebo Falsepodle toho, zda jsou data ve schránce zadaného formátu. Komponenta TMemo obsahujevlastnost SelLength, která udává délku označeného textu (délka je nulová, jestliže neníoznačen žádný text).Kopírovat nebo vyříznout text do schránky je možné jen tehdy, je-li nějaký vybrán(SelLength <> 0). Vkládat ze schránky je možné jen tehdy, jsou-li v ní data správnéhoformátu. Proto je potřeba zakázat a povolit ty správné položky v menu Úpravy. Nejlepšímmístem, kde to lze udělat, je metoda napojená na událost OnClick položky menu Úpravy, tedyokamžik, kdy je rozvinuto menu Úpravy. V případě tlačítek na nástrojové liště je třeba reagovatna události TForm.OnActivate (jiná aplikace mohla umístit do schránky textová data)a TMemo.OnMouseUp a OnKeyUp (uživatel mohl označit text myší nebo klávesnicí).Možná rozšíření: Vyhledávání v dokumentu. Tisk dokumentu.

Příklad HádejProcvičované znalosti: Komponenty TSpinEdit,TButton, TLabel.Zadání: Napište program, který vygeneruje náhodnéčíslo od 1 do 100 a poté nechá uživatele hádat. Pokaždém pokusu vypíše, zda uživatelem zvolené číslo jevětší či menší než vygenerované, anebo že se uživateltrefil.

Poznámky: Uživatelovu sázku je možné implementovat pomocí komponenty TSpinEdit,která má vlastnost Value, z níž můžeme přímo přečíst požadovanou hodnotu bez nutnostipřevádění textu na číslo a ošetřování výjimek. K zobrazení informace o úspěšnosti uživatelovapokusu použijte komponentu TLabel, u níž budete nastavovat vlastnost Caption.Možná rozšíření: Upravte program tak, aby počítal uživatelovy pokusy a počet pokusůzobrazoval. Dále můžete program upravit tak, aby bylo možné zadat rozsah generovaných čísel.

Příklad Jednotky2 (Převody jednotek)


- 63 -

Procvičované znalosti: Komponenty TRadioGroup, TGroupBox, TLabel, TEdit.Datový typ Extended.Legenda: Každý si jistě vzpomíná na záludné otázky základoškolské fyziky typu: Kolikmilimetrů čtverečních je na ploše 3,256 dm2? Nebo: Kolik hektolitrů má 1 kilometr krychlový?A podobně. Částečné řešení pro ty, kteří již jednotky převádět umí, pouze je to obtěžujea nechtějí dělat zbytečné chyby, představuje následující příklad, který lze rozšířit tak, abyposkytl odpověď i na výše uvedené otázky.Zadání: Napište program, který spočítá, jakým číslem je potřeba násobit při převáděníjednotek. Dále hodnotu zadanou v jedněch jednotkách převede do druhých jednotek. Prozadávání jednotek použijte dva stejné seznamy předpon (podobné jako v příkladu Jednotky).Poznámky: Protože některá čísla jsou velmi malá a jiná velmi velká, je potřeba použít datovýtyp Extended, který svým rozsahem pokrývá všechny možné hodnoty.Možná rozšíření: Rozšiřte příklad o mocniny jednotek (tj. např. o plošné a objemovéjednotky).Dále je možné program rozšířit o převody mezi různými jednotkami, které se používajík vyjádření hodnoty téže veličiny. Například se jedná o převod stupňů na radiány či převodyteploty mezi °C, °F a K.Dále lze program rozšířit o propočty známých fyzikálních závislostí, např. mezi tlakema nadmořskou výškou.

Příklad Jednotky3 (Převody jednotek informací)

Procvičované znalosti: Komponenty TRadioGroup, TGroupBox, TLabel, TEdit.Datový typ Extended. Jednotky informací.Legenda: To, že 1 byte má 8 bitů, ví každý. Hůře jsme na to s odpovědí na otázky typu „Za jakdlouho si stáhnu obrázek, který má 1MB přes modem, který komunikuje rychlostí 56Kb/s?Zadání: Napište program, který bude převádět mezi bity a byty a jejich násobky.Poznámky: K určení násobku i k určení toho, zda se jedná o bit nebo byte použijte komponentuTRadioGroup. Do komponenty TLabel zapisujte převodní vztah a k vlastnímu převodujednotek použijte komponenty TEdit.Možná rozšíření: Rozšiřte program o možnostzadávat přenosovou rychlost a počítat čas přenosuzadaného objemu dat nebo přenesený objem datv zadaném čase. Program by tak měl umět dátodpověď na otázky nastolené v legendě.

Příklad Jméno2Procvičované znalosti: Komponenty TEdit,TButton. Reakce na stisk tlačítka. Manipulaces řetězci. Funkce ShowMessage. Volitelněkomponenta TRadioButton.


- 64 -

Zadání: Upravte program Jméno tak, aby jméno nevypisoval na štítek, ale zobrazil jej v novémdialogovém okně.Poznámky: Dialogové okno se vyvolává pomocí procedury ShowMessage, která jako jedinýparametr dostává textový řetězec, který se má v okně vypsat.Možná rozšíření: Opět lze, stejně jako v příkladě Jméno, přidat titul před jménem a zajménem, nebo přezdívku ve volitelném formátu.

Příklad Kalkulačka2Procvičované znalosti: Manipulace s řetězci. Dlouhodobý projekt.Zadání: Rozšiřte program Kalkulačka tak, aby obsahoval tlačítkas čísly 0 až 9 a desetinnou čárkou. Tato tlačítka budou plnitočekávatelnou funkci: Budou přidávat daný znak k řetězci nadispleji. Dále přidejte funkci odmocnina (sqrt) a rozšiřte kalkulačkuo paměť.Poznámky: Je nutné ošetřit levostranné nuly. Jedna levostrannánulaje naopak žádoucí u čísel tvaru 0,xxx.Možná rozšíření: Inspirujte se svoji kalkulačkou nebo vědeckoukalkulačkou systému Windows. Lze tedy přidat zejménagoniometrické a cyklometrické funkce, exponenciální a logaritmickéfunkce, konstanty e a πči závorky.

Příklad Matice

Procvičované znalosti: OOP. Operace s maticemi. Komponenty TStringGrid, TButton,TRadioGroup, TGroupBox, TEdit. Dynamická pole. Dlouhodobý projekt.Zadání: Implementujte jednotku pro operace nad maticemi. Třída TMatice bude obsahovatkonstruktor, který matici zadaných rozměrů vytvoří, dále bude obsahovat dynamické pole prouchování hodnot a metody pro transponování matice, převod na schodovitý tvar, výpočetdeterminantu a výpočet inverzní matice. Do jednotky dále přidejte funkce pro sčítání, odčítání anásobení matic. Dále předpokládejte, že data budete získávat z řetězcové mřížky


- 65 -

(TStringGrid), do níž je budete i ukládat. Proto napište metody pro převod obsahu mřížkyna matici a zpět. Pozor na ošetření výjimek!Dále napište program, který bude používat vytvořenou jednotku a demonstrovat její funkčnost.Jedná se tedy o jakousi maticovou kalkulačku. Uživatel bude moci zadat dvě matice a provésts nimi některou z operací, vypočítat determinant, inverzní matici, transponovat matici nebopřevést matici na schodovitý tvar. Zároveň je vhodné, aby program umožnil použít výslednoumatici k dalším operacím.Poznámky: Rozměry dynamického pole se nastavují pomocí funkce SetLength(NázevPole, Rozměr1[, Rozměr2, ...]). Rozměry řetězcové mřížky jsou uloženyve vlastnostech ColCount a RowCount. Samotné řetězce (data v mřížce) jsou uloženy v poliCells, indexovaném, jako každé dynamické pole, od nuly.Možná rozšíření: Protože počítání s desetinnými čísly je kvůli zaokrouhlování nepřesné,implementujte počítání s racionálními maticemi. Racionální číslo ukládejte jako uspořádanoudvojici čitatel, jmenovatel. Můžete k tomu využít jednotku z příkladu Zlomky.

Příklad Množiny

Procvičované znalosti: Komponenty TListBox, TSpinEdit. Datový typ Set. Dlouhodobýprojekt.Zadání: Implementujte množinovou kalkulačku. Bude se jednat o program umožňujícídefinovat dvě množiny (tj. přidávat do nich prvky a také je odebírat), porovnávat je a prováděts nimi standardní množinové operace (sjednocení, průnik, rozdíl). Pro jednoduchost pracujtes množinami čísel (Set of Byte).Poznámky: K uchovávání dat v množinách použijte datový typ množina (Set). Prvky množinymohou být jen data ordinálního typu a množina nesmí mít více než 256 prvků. Na množiny lzeaplikovat operátory + (sjednocení), * (průnik) a – (rozdíl). Přítomnost prvku v množině lzetestovat klíčovým slovem in.Možná rozšíření: Program rozšiřte o možnost testování, zda zadané číslo je prvkem množiny.Dále naprogramujte funkci na zjištění počtu prvků množiny.

Příklad MobilProcvičované znalosti: Komponenty TMemo, TTimer, TButton, TLabel. Reakce na různéudálosti. Parametr Sender. Vlastnost Tag. Vlastnosti komponenty TMemo. Dlouhodobýprojekt.Legenda: Téměř každý si už jistě vyzkoušet psát na mobilním telefonu krátké textové zprávy(tzv. SMSky). Každému tlačítku mobilního telefonu přísluší více písmen. Když je tlačítkostisknuto několikrát za sebou, vybere se patřičný znak. Pokud se chvíli nic neděje, je zvolenýznak vybrán definitivně a kurzor se posune na následující pozici. Totéžse stane v případě, že je


- 66 -

stisknuto jiné tlačítko. Protože se jedná o poměrně zajímavýalgoritmický problém, stojí zato vyzkoušet si naprogramovatsimulátor klávesnice mobilního telefonu.Zadání: Napište simulátor klávesnice mobilního telefonu při psaníkrátkých textových zpráv. Implementujte také možnost zadávat velkápísmena, malá písmena a čísla. Nezapomeňte na interpunkčníznaménka a další speciální znaky.Poznámky: To, zda bylo stisknuto stejné tlačítko jako minule, se dátestovat například pomocí vlastnosti Sender.Tag. Do vlastnostiTag se dá uložit jakákoliv čtyřbajtová informace (integer,ukazatel,…). V komponentě TMemo lze při vhodném nastavenívlastností použít místo standardního seznamu řetězců Linesvlastnost Text. Vhodné nastavení se týká zejména zalamování řádků.Kurzor se v komponentě TMemo zobrazuje jen tehdy, má-li zaměření.Po stisku tlačítka je tedy vždy třeba zavolat metoduTMemo.SetFocus. Při implementaci vlastnosti, že po chvíli odstisknutí tlačítka je kurzor přesunut na následující pozici, využijete(jak jinak) komponentu TTimer. V tomto případě se namísto

neustálého zakazování a povolování časovače (vlastnost Enabled) jeví jako vhodnější nechatčasovač stále povolený a při každé události OnTimer snížit virtuální odpočet o 1. Při stiskutlačítka pak lze tento virtuální odpočet nastavit na nějakou definovanou hodnotu. Přesunkurzoru a potvrzení stávajícího znaku se pak provede ve chvíli, kdy odpočet dosáhne nuly. Jenje třeba ošetřit jednu drobnost, a sice zamezit tomu, aby se kurzor nepřesouval stále dál, pokudse na klávesnici vůbec nesahá.Možná rozšíření: Přidejte tlačítko k vymazání znaku a tlačítka k přesunu kurzoru vlevoa vpravo.

Příklad Obrázky2


- 67 -

Procvičované znalosti: Komponenta TTabControl. Dlouhodobý projekt.Zadání: Upravte program Obrázky tak, aby bylo možno otevřít více obrázků zároveň. Otevřenéobrázky budou dostupné přes záložky v horní části pracovní plochy okna.Poznámky: Možnost otevřít více obrázků najednou má na starosti vlastnostAllowMultipleSelect komponenty TOpenDialog/TOpenPictureDialog. Záložkyjsou realizovány komponentou TTabControl, jejíž vlastnost Tabs uchovává pole řetězcůs názvy záložek. Při výběru záložky je generována událost OnChange. Metoda obsluhující tutoudálost pak musí zajistit překreslení obrázku.Možná rozšíření: Přidejte možnost zavřít obrázek. Nezapomeňte ošetřit krajní možnosti(zavírání posledního obrázku).

Příklad Obrázky3

Procvičované znalosti: MDI aplikace. Dlouhodobý projekt.Zadání: Program Obrázky upravte tak, aby bylo možno otevřít více obrázků a každý se otevřelve svém vlastním okně, které bude potomkem hlavního okna. Zároveň zajistěte, aby se položkamenu Možnosti (roztáhnout na celou plochu okna a zachovat poměr výšky a šířky) vztahovalavždy k právě aktivnímu oknu. Hlavní menu rozšiřte o standardní položky zajišťující uspořádáníoken (kaskáda, dlaždice, uspořádání ikon).Poznámky: Je třeba definovat dva formuláře: Jeden typu fsMDIForm a druhý fsMDIChild.Hlavní formulář (MDIForm) bude umět vyvolat otevírací dialog a vytvořit a zrušit oknopotomka (MDIChild). Formulář MDIChild bude obsahovat na celé své ploše komponentuTImage pro zobrazení obrázku. Seznam potomků je dostupný v poli MDIChildren. Naprávě aktivní okno ukazuje položka ActiveMDIChild.Položka menu Možnosti nebude položka menu hlavního okna, ale bude definována v okněpotomka. Menu hlavního okna a menu potomka pak budou automaticky spojeny v jediné menuviditelné v hlavním okně. Správnépořadí položek lze zajistit nastavením hodnot GroupIndex.Možná rozšíření: Přidejte možnost zavřít všechna okna.


- 68 -

Příklad RTTI Demo

Procvičované znalosti: RTTI operátory. Parametr Sender. Metoda ClassName.Zadání: Napište program, jehož hlavní okno bude obsahovat množství různých komponent.Když uživatel na některou z nich klikne, objeví se ve štítku její název. Program dále upravte tak,aby kliknutí na komponentu založenou na tlačítku vyvolalo zprávu o tom, že bylo kliknuto nakomponentu založenou na tlačítku. Dále zajistěte, aby kliknutí na komponentu založenou naeditačním poli zobrazilo v této komponentě nějaký text, např. aktuální datum nebo čas.Poznámky: Jméno komponenty, resp. jméno třídy lze zjistit pomocí metody ClassNameparametru Sender (ukazatel na komponentu, která vyvolala událost OnClick). Testování,zda je komponenta nějakého typu, se provádí pomocí operátoru is. Pokud chcemes komponentou pracovat a jsme si jisti, že je nějakého typu a máme k dispozici jen ukazatelobecnějšího typu (parametr Sender), lze jej přetypovat pomocí operátoru as.

Příklad RychlostProcvičované znalosti: Komponenty TRadioGroup,TLabeledEdit. Vlastnost Enabled. FunkceStrToFloat, FloatToStr. Ošetření výjimek.Legenda: Každý, kdo někam cestuje, chce znát, jakdlouho tam pojede, popřípadě, jak rychle musí jet, abyto stihl v určitém čase. Odpověď na tyto otázky dávánásledující program.Zadání: Napište program, který ze dvou hodnotz množiny {vzdálenost, čas, rychlost} dopočítáhodnotutřetí.

Poznámky: Volbu hodnoty, kterou chceme dopočítávat, realizujte pomocí komponentyTRadioGroup. Zvolená položka je dostupná pomocí vlastnosti ItemIndex. Dbejte na to,aby příslušný editační řádek (kvůli jednoduchému popisu jej realizujte komponentouTLabeledEdit) bylo zakázané (vlastnost Enabled nastavte na False). Pro převod řetězcena číslo použijte funkci StrToFloat. Nezapomeňte ošetřit možný výskyt výjimkyEConvertError.Možná rozšíření: Upravte program tak, aby dokázal počítat jak s kilometry za hodinu, taks metry za sekundu.


- 69 -

Možné alternativy: Ve fyzice se vyskytuje více veličin, které jsou spolu v jednoduchém vztahuX=Y/Z. Vzpomeňme například na hustotu coby podíl hmotnosti a objemu, Ohmův zákon nebostavové rovnice ideálního plynu. Místo rychlosti můžete použít některý ze zmíněných zákonů.Zůstaneme-li jen u pohybu a jeho rychlosti, lze program rozšířit tak, aby počítal rovnoměrnězrychlený pohyb, volný pád či šikmý vrh.

Příklad Věty2

Procvičované znalosti: Vlastnosti komponenty TListBox nebo komponentaTCheckListBox. Manipulace s řetězcem.Zadání: Rozšiřte program z příkladu Věty tak, aby umožňoval do věty zahrnout více podmětů.Nezapomeňte jednotlivé podměty oddělovat čárkou a před poslední vložit spojku and. Zároveňmyslete na to, že je-li použit jen jeden podmět, je třeba užít sloveso is, v opačném případě are.Poznámky: Jsou dvě možnosti implementace:1. Pomocí komponenty TCheckListBox, která umožňuje u každé položky zaškrtnout

políčko. Zvolené hodnoty jsou pak dostupné v poli Checked, jehož prvky jsou typuBoolean.

2. Nastavit vlastnost MultiSelect komponenty TListBox na hodnotu True. Tím budeuživateli umožněno vybrat v ListBoxu více položek. Jejich seznam pak získáme pomocípole Selected.

Možná rozšíření: Rozšiřte program o možnost přidat jak k podmětu, tak k předmětu přívlastky.

Příklad VideostopProcvičované znalosti: Komponenty TTimer, TLabel, TButton.Legenda: Videostop je prastará televizní hra, ve které bylo úkolem hráčů poznávat ukázkyz filmů. Ten, který byl nejlepší, mohl na konci vyhrát některou z věcných cen. To, kterou cenuvyhraje, určovala závěrečnáhra, při níž počítač jakoby házel jednou ze tří šestistěnných kostek ana monitoru zobrazoval hodnoty všech tří kostek. Bez hráčova zásahu počítač generoval stálenové a nové kombinace. Hráč mohl kdykoliv házení přerušit stiskem tlačítka. Stisknul-li tlačítkove chvíli, kdy byly na kostkách dvě stejné hodnoty, byl mu připsán určitý bodový zisk. Stiskl-litlačítko ve chvíli, kdy nesly všechny tři kostky stejnou hodnotu, byl jeho bodový ziskněkolikanásobně větší. Po určitém čase se hra zastavila a podle dosaženého skóre byla určenavýhra.Zadání: Implementujte hru Videostop. Pro jednoduchost nevykreslujte hrací kostky, alezobrazujte čísla 1 až 6. Hru neomezujte časem, ale určitým počtem hráčových pokusů.


- 70 -

Poznámky: Soustavné generování nových možnostízajistíme pomocí komponenty TTimer, kteráv určených intervalech generuje událost OnTimer.Metoda obsluhující tuto událost pak bude mít za úkolnáhodně vybrat kostku a její novou hodnotu. Tutohodnotu pak zobrazí. Komponenta TTimer mávlastnost Enabled, která určuje, zda časovačgeneruje události OnTimer či nikoliv. Nastavenímhodnoty False se tedy časovač zastaví. Toho lzevyužít k chvilkovému přerušení hry, kdy obarvenímštítků se stejným číslem oznamujeme hráči výsledekjeho pokusu.Možná rozšíření: Upravte program tak, aby místozobrazování čísel maloval příslušné stěnyšestistěnných kostek. Dále program upravte tak, aby se

kostky překreslovaly stále rychleji v závislosti na odehraných pokusech.

Příklad Vlajky

Procvičované znalosti: Komponenty TColorGrid, TPanel, TComboBox. Volitelně typovýsoubor a dynamická pole. Dlouhodobý projekt.Legenda: Na světě je mnoho států, jejichž vlajka je složená ze tří pruhů, ať už svislých(Francie, Itálie, Rumunsko) či vodorovných (Rusko, Německo, Nizozemsko).Zadání: Napište program, který bude vykreslovat třípruhové vlajky. Okno bude obsahovatkomponentu TRadioGroup, ve které bude mít uživatel možnost zvolit orientaci vlajky(vodorovně nebo svisle) a barevnou mřížku, kde si uživatel bude volit barvu. Největší část oknabude zabírat vlastní vlajka o zvolené orientaci. Při kliknutí na některý pruh se tento pruhpřebarví barvou zvolenou v mřížce. Dále přidejte Rozbalovací okénko, ve kterém budou názvyzemí s třípruhovými vlajkami. Při zvolení některé země se automaticky nastaví orientace pruhůa jejich barvy tak, aby vznikla vlajka dané země.


- 71 -

Poznámky: Barevnou mřížku realizujte pomocí komponenty TColorGrid. Vlajku je vhodné(nikoliv však nutné) implementovat jako tři komponenty TPanel. Při změně orientace se takpouze změní pozice a velikost panelů, zatímco s barvami, které jsou vlastností jednotlivýchpanelů, nebude třeba manipulovat. Jednotlivé země ukládejte do záznamu, jehož položky budounázev země, orientace vlajky a tři barvy. Komponenta TComboBox generuje při zvoleníněkteré z položek událost OnChange. Zvolená položka je zjistitelná pomocí vlastnostiItemIndex.Možná rozšíření: Umožněte uživateli přidávat do rozbalovacího okna další země. Informaceo vlajkách ukládejte do typového souboru, ze kterého je po spuštění programu (událostOnCreate hlavního okna) načítejte.

Příklad ZlomkyProcvičované znalosti: OOP. Komponenty TSpinEdit aTButton.Zadání: Napište jednotku, která implementuje třídu pro práci sezlomky. Tj. bude ukládat zlomek jako čitatele a jmenovatele, budeumět převést zlomek do základního tvaru, sčítat, odčítat, násobit adělit zlomky. Dále napište program, který tuto jednotku využije prozlomkovou kalkulačku. Program bude načítat zlomky pomocí spineditů a provádět s nimi požadované operace.Poznámky: K převádění zlomků do základního tvaru využijte Euklidův algoritmus pro hledánínejvětšího společného dělitele.Možná rozšíření: Napište metodu, která převede zlomek na desetinné číslo a naopak. Ošetřeteperiodické rozvoje.

výuka objektově orientovaného programování na středních

Documents