Moderné vzdelávanie pre vedomostnú spoločnosť / Projekt je spolufinancovaný zo zdrojov EÚ

Ing. Ján Kontuľ

Programovanie v jazyku Object Pascal v programovacom prostredí Lazarus

Osvedčená pedagogická skúsenosť edukačnej praxe

Prešov 2013

Vydavateľ: Metodicko-pedagogické centrum, Ševčenkova 11, 850 01 Bratislava

Autor OPS: Ing. Ján Kontuľ

Kontakt na autora:

Gymnázium sv. Jána Zlatoústeho, Lesná 28, 066 01 Humenné, jan.kontul@gmail.com

Názov OPS: Programovanie v jazyku Object Pascal v programovacom prostredí Lazarus

Rok vytvorenia OPS:

2013

VI. kolo výzvy

Odborné stanovisko vypracoval:

Ing. Zuzana Tkáčová

Za obsah a pôvodnosť rukopisu zodpovedá autor. Text neprešiel jazykovou úpravou.

Táto osvedčená pedagogická skúsenosť edukačnej praxe bola vytvorená z prostriedkov národného projektu Profesijný a kariérový rast pedagogických zamestnancov. Projekt je financovaný zo zdrojov Európskej únie.

Kľúčové slová Object Pascal, Lazarus, grafická plocha, časovač, vetvenie, cyklus, podprogram, jednorozmerné pole, grafický robot, textová plocha, textový súbor, listbox

Anotácia

Práca vychádza z pedagogickej praxe a zaoberá sa programovaním v jazyku Object Pascal. Učiteľom má poskytnúť podporný materiál pre vyučovanie programovania v danom jazyku. Stanovuje učebné ciele, popisuje použité vyučovacie metódy, učebné pomôcky, didaktickú techniku. Je obohatená o dobré rady, skúsenosti a návrhy riešenia problémov, ktoré sa pri programovaní môžu vyskytnúť. Súčasťou práce sú aj dva priebežné testy s návrhom výsledného hodnotenia a dotazník pre absolventov našej školy, ktorý má slúžiť na potvrdenie alebo vyvrátenie významu výučby programovania v spomínanom jazyku.

OBSAH

ÚVOD ............................................................................................................................................................ 5

1 POKYNY PRE PRÁCU S TÝMTO MATERIÁLOM ...................................................................... 7

1.1 Špecifikácia cieľovej skupiny a prehľad cieľov ................................................................... 7

1.2 Štruktúra práce ................................................................................................................................. 8

2 ÚVOD DO JAZYKA OBJECT PASCAL ............................................................................................. 11

2.1 Integrované vývojové prostredie Lazarus ............................................................................ 11

3 GRAFICKÁ PLOCHA ............................................................................................................................ 15

4 PRÁCA S ČASOVAČOM A PSEUDONÁHODNÉ ČÍSLA ............................................................ 19

5 PRÍKAZY VETVENIA ........................................................................................................................... 23

6 PROGRAMOVÉ CYKLY ....................................................................................................................... 25

7 PODPROGRAMY ................................................................................................................................... 29

8 JEDNOROZMERNÉ POLE A TEXTOVÁ PLOCHA ...................................................................... 31

9 ZNAKY A REŤAZCE ZNAKOV .......................................................................................................... 33

10 PRÁCA S MYŠOU ....................................................................................................................... ......... 35

11 GRAFICKÝ ROBOT ............................................................................................................................ 37

12 TEXTOVÉ SÚBORY ............................................................................................................................ 41

13 LISTBOX .................................................................................................................. .............................. 43

14 OVERENIE NAVRHNUTEJ METODIKY...................................................................................... 47

14.1 Odporúčania pre pedagogickú prax....................................................................................... 48

ZÁVER ....................................................................................................................... ................................... 51

Zoznam príloh .......................................................................................................................................... 55

5

ÚVOD

Táto práca bola napísaná na základe pedagogickej skúsenosti z vyučovania Seminára z informatiky na strednej škole (ISCED 3). Je určená na výučbu žiakov, ktorí sa pripravujú na štúdium na vysokej škole technického zamerania. Zaoberá sa výučbou základných štruktúr programovacieho jazyka Object Pascal. Obsahuje teoretický základ pri jednotlivých preberaných pojmoch, podrobne popísané vzorové príklady, na konci každej kapitoly úlohy na riešenie a precvičenie pre žiakov a v prílohách sú uvedené doplnkové materiály a dva priebežné testy, s návrhom ich vyhodnotenia, ktorými učiteľ zistí hĺbku osvojenia daného učiva žiakmi. Motiváciou na napísanie tejto práce je poskytnúť učiteľovi ucelený materiál, ktorý mu pomôže pri výuke objektovo orientovaného programovania v programovacom jazyku Object Pascal. Znamená to preň pomoc a aj veľkú časovú úsporu, pretože jednotlivé materiály nemusí pracne zháňať po knižniciach, resp. na Internete. Obsah a aj postupnosť jednotlivých tém vychádza z praktických skúseností na jednotlivých hodinách, kde sa dá najlepšie zistiť, čo žiaci dokážu pochopiť rýchlo, a naopak čo žiakom robí menšie alebo väčšie problémy a podľa toho je volená aj časová dotácia pre jednotlivé kapitoly. Hlavným cieľom práce je pomôcť učiteľom informatiky na stredných školách s prípravou na hodiny informatiky, kde sa vyučuje programovanie v jazyku Object Pascal. Ďalším cieľom je aj budovanie medzipredmetových vzťahov informatiky a matematiky, pretože výstupné programy práce môžu slúžiť na kontrolu výsledkov riešení rôznych matematických úloh, ako je napríklad výpočtet koreňov kvadratickej rovnice, pomoc pri hľadaní prvočísel, výpočet faktoriálu, kombinačného čísla a podobne. Jedným z dôležitých cieľov mojej práce je takisto overiť metodiku vyučovania programovacieho jazyka Object Pascal v programovacom prostredí Lazarus na strednej škole. Ďalší dôvod, prečo som sa rozhodol napísať túto prácu, je veľmi pozitívna odozva na výučbu Object Pascalu podľa tejto práce od žiakov, ktorí tento predmet absolvovali a teraz študujú na vysokých školách. Pri vyučovaní jazyka Object Pascal podľa tejto práce je potrebné, aby žiaci ovládali základné programátorské vedomosti a zručnosti z akéhokoľvek iného programovacieho jazyka. Práca je rozdelená do trinástich kapitol a obsahuje pokyny pre prácu s týmto materiálom a popis základných štruktúr programovacieho jazyka Object Pascal, ktoré by mali poskytnúť základ do ďalšieho štúdia daného jazyka.

6

7

1 POKYNY PRE PRÁCU S TÝMTO MATERIÁLOM

Výučbový materiál „Programovanie v jazyku Object Pascal v programovacom prostredí Lazarus“ sa zaoberá základmi jazyka, ktorý umožňuje v programovacom prostredí Lazarus vyvíjať nielen aplikácie pre grafické rozhranie (napr. Wndows), ale aj aplikácie pre web. Prínosom daného programovacieho prostredia je charakteristika označovaná ako RAD (Rapid Application Development – rýchly vývoj aplikácií), ktorá umožňuje aplikáciu poskladať z hotových častí – komponentov. Programátor potom veľmi často už len doprogramuje správanie týchto komponentov v rôznych situáciách. Tento materiál je určený ako pomôcka pre učiteľa pri výučbe programovacieho jazyka Object Pascal v programovacom prostredí Lazarus. Sú v ňom popísané pokyny, ako s týmto materiálom pracovať, základná teória, riešené cvičenia, úlohy pre žiakov a samozrejme aj dva priebežné testy na overenie vedomostí a znalostí žiakov z prebraného učiva. Materiál je plánovaný na 28 vyučovacích hodín. Časová dotácia jednotlivých blokov je informačná a vychádza zo skúseností a pozorovania autora. Je ju možné podľa potreby modifikovať. Ďalej je nutné, aby žiaci:

ovládali prácu s počítačom (príslušným hardvérom a softvérom), ovládali základy akéhokoľvek iného programovacieho jazyka.

1.1 Špecifikácia cieľovej skupiny a prehľad cieľov

Kategória: učiteľ – mal by mať aprobáciu pre výučbu predmetu Informatika a aspoň základné skúsenosti s programovaním v jazyku Object Pascal. Podkategória: učiteľ pre úplné stredné všeobecné vzdelávanie a učiteľ pre úplné stredné odborné vzdelávanie (učiteľ strednej školy). Žiak: žiak strednej školy (ISCED 3). Vzdelávacia oblasť: matematika a práca s informáciami. Škola, ročník: stredná škola, 2., resp. 3. ročník. Vyučovacie predmety: informatika, seminár z informatiky. Tematický okruh: Postupy, riešenie problémov, algoritmické myslenie. Vymedzenie kompetencií:

komunikatívne a sociálne interakčné spôsobilosti – sprostredkovať informácie vhodným spôsobom; vyjadriť alebo jednoznačne formulovať vlastný názor a záver; aktívne používať odborný jazyk,

interpersonálne a intrapersonálne spôsobilosti – rozvíjať prácu v kolektíve (kooperáciu a komunikáciu); hodnotiť a rešpektovať svoju vlastnú prácu ako aj prácu ďalších členov kolektívu,

schopnosti riešiť problémy – rozpoznať a jednoznačne formulovať problém; hľadať, navrhovať alebo používať ďalšie metódy, informácie alebo nástroje, ktoré by mohli prispieť k riešeniu problému; posudzovať riešenie daného problému

8

z hľadiska jeho správnosti, jednoznačnosti alebo efektívnosti; korigovať nesprávne riešenia problému,

spôsobilosti využívať informačné technológie – získavať informácie v priebehu vzdelávania využívaním všetkých metód a prostriedkov, ktoré majú žiaci v danom okamihu k dispozícii; zhromažďovať, triediť, posudzovať a využívať informácie, ktoré by mohli prispieť k riešeniu daného problému alebo osvojiť si nové poznatky; rozvíjať metakognitívnu kompetenciu - t. j. učiť sa tým, že objavujem; rozvíjať si svoju osobnosť a tvorivosť.

Žiaci by mali po absolvovaní hodín programovania:

orientovať sa v objektovom programovacom prostredí Lazarus, pracovať so základnými súčiastkami z palety komponentov, skompilovať program a analyzovať chyby, ktoré sa môžu v programe vyskytnúť, navrhnúť a spustiť jednoduchý program podľa zadania a okomentovať ho, poznať základné príkazy na prácu s grafickou plochou, demonštrovať prácu s pseudonáhodnými číslami a časovačom, použiť v programe jednoduché príkazy, ako aj príkazy binárneho

a viacnásobného vetvenia, v programe správne použiť programové cykly, ako je nepodmienený cyklus for,

tak aj podmienené cykly while a repeat-until, vysvetliť význam podprogramov a predviesť použitie podprogramu v konkrétnej

aplikácii, demonštrovať prácu s jednorozmerným poľom, vysvetliť rozdiel medzi číselnou hodnotou a znakom a vedieť zadeklarovať

premennú, do ktorej sa môžu ukladať znaky, ako aj pracovať s reťazcami znakov, popísať základné príkazy pri práci s myšou a použiť ich v aplikácii, ilustrovať využitie grafického robota v rôznych aplikáciách, vysvetliť princíp práce s textovou plochou a textovým súborom, popísať základné príkazy pri práci s listboxom a aplikovať ich v konkrétnom

programe. Žiaci môžu zadané úlohy riešiť individuálne, ale odporúča sa vytvoriť menšie skupiny, kde je veľké pozitívum to, že žiaci medzi sebou spolupracujú, spoločne problém analyzujú a snažia sa spoločne dôjsť k správnemu riešeniu. Je to pre nich veľmi dôležitá skúsenosť pre prax, kde veľmi často na takúto spoluprácu budú odkázaní.

1.2 Štruktúra práce

Každý učiteľ si môže mnou navrhnuté časové dotácie pre každú tému podľa potreby upraviť. Odporúča sa 15 až 20 minút (záleží na obšírnosti a zložitosti preberanej kapitoly) venovať teoretickým poznatkom (napr. definovaniu jednotlivých pojmov, porovnaniu syntaxe príkazov jazyka Object Pascal s jazykom, ktorý žiaci mali už predtým, atď.) a spoločne preriešiť vzorové cvičenie. Ostatné hodiny sú venované samostatnej práci žiakov, kde riešia úlohy, ktoré sa nachádzajú na konci každej kapitoly. Učiteľ pritom kontroluje samostatnú prácu žiakov, koordinuje ich činnosť, poprípade sa ich snaží naviesť na správne riešenie.

9

Celý výučbový systém je plánovaný na už vyššie uvedených 28 vyučovacích hodín, pričom sú plánované aj dva priebežné testy. Podrobnosti sú uvedené v Tabuľke 1. Tabuľka 1 Prehľad aktivít

Zdroj: súkromný archív

Kapitola Počet

vyučovacích hodín

Pomôcky

Úvod do jazyka Object Pascal

2 počítač s príslušným softvérovým

vybavením, projektor, premietacie plátno

Grafická plocha 2 Práca s časovačom a pseudonáhodné čísla

2

Príkazy vetvenia 3 Programové cykly 3 Podprogramy 2 Prvý priebežný test 1 Príloha 2

Jednorozmerné pole a textová plocha

2 počítač s príslušným softvérovým

vybavením, projektor, premietacie plátno

Znaky a reťazce znakov

2

Práca s myšou 2 Grafický robot 2 Textové súbory 2 Listbox 2 Druhý priebežný test 1 Príloha 3

10

11

2 ÚVOD DO JAZYKA OBJECT PASCAL

Ciele:

rozoznať a popísať jednotlivé časti IDE Lazarus, uložiť projekt, zapamätať si dôležité klávesy pre prácu s IDE Lazarus, rozoznať základné komonenty zo štandardnej palety (Button, Label, Edit)

a umiestniť ich do formulára, predviesť prácu so základnými komponentmi – meniť ich veľkosť, farbu, písmo,

polohu vo formulári a pozná základné príkazy pre prácu s nimi. Object Pascal je objektovo orientovaný programovací jazyk založený na jazyku Pascal. Na vytvorenie programu je potrebné integrované vývojové prostredie (IDE), do ktorého nami navrhnutý zdrojový kód budeme písať, kompilovať a následne spúšťať, testovať a ladiť. Medzi vývojové prostredia, ktoré môžeme použiť pre vývoj našich aplikácií patrí napr. Delphi alebo Lazarus.

2.1 Integrované vývojové prostredie Lazarus

Lazarus je open source multiplatformový vizuálny vývojový nástroj. IDE Lazarus je stabilné a vzhľadovo bohaté programovacie prostredie, podobné Borland Delphi, pre vytváranie samostatne bežiacich grafických a konzolových aplikácií. V súčasnosti beží na systémoch Linux, FreeBSD, Mac OS X a Windows. Poskytuje prispôsobiteľný editor zdrojového kódu a vizuálnu tvorbu formulárov s manažérom balíčkov, ladiacim nástrojom a úplnou integráciou prekladača FreePascal do GUI. 32, resp. 64 bitovú verziu si môžeme voľne stiahnuť z internetu. Dobrá rada: Pre každý nový projekt je potrebné si vytvoriť nový adresár a pred začatím práce si projekt do adresára najprv uložiť. Novú aplikáciu s prázdnym formulárom môžeme otvoriť napr. takto: File – New – Application. Pre zjednodušenie a zrýchlenie práce s IDE Lazarus uvádzam aj pár často využívaných klávesov: F1 – help (pomocník), F12 – zobrazenie, resp. skrytie formulára, F9 – spustenie programu (run), Ctrl+F9 – skompilovanie programu (build), Shift+F2 – zastavenie (reset) programu, napr. ktorý sa nám zacyklí, neskončí, F7 – krokovanie (aj do vnútra procedúry), F8 – krokovanie (s vynechaním tela procedúry), Del – odstránenie (zmazanie) komponentu z formulára.

12

Obrázok 1 Integrované vývojové prostredie Lazarus Prameň: vlastný návrh

Cvičenie 2.1: Vytvorte program, ktorý bude pozostávať z troch súčiastok: Button1, Label1 a Edit1. Zmeňte meno tlačidla z Button1 na Zapíš. Po stlačení tlačidla nech sa text užívateľom napísaný do Editu1 zaznamená do Labelu1. Riešenie: Najprv je potrebné žiakom názorne predviesť, ako má aplikácia vyzerať, k čomu vlastne chceme dospieť. Samotná aplikácia sa uloží do súboru typu *.exe a vyzerá priamo po spustení takto (názov Buttonu1 na Zapíš zmeníme v inšpektore objektov v položke Caption, parametre Labelu1 nastavíme v položke Font v inšpektore objektov):

riadiaci panel paleta komponentov formulár aplikácie

inšpektor objektov okno pre zdrojový kód správy kompilátora

13

Obrázok 2 Okno aplikácie pred stlačením tlačidla Prameň: vlastný návrh

Najprv do Editu1 napíšeme slovo „Ahoj“ a po stlačení tlačidla sa daný text zaznamená do Labelu, čím sa text v Labele prepíše.

Obrázok 3 Okno aplikácie po stlačení tlačidla Prameň: vlastný návrh

Ako vidíme z predchádzajúcich obrázkov, pri programovaní aplikácie si najprv do okna formulára musíme zadané objekty (Button, Edit aj Label) umiestniť a až potom dochádza k samotnému programovaniu vybraného objektu. V tomto prípade sa programuje tlačidlo (Button1). Urobíme to tak, že dvojklikom na tlačidlo sa prenesieme do zdrojového kódu priamo do tela procedúry. V tomto prvom cvičení zobrazím celý zdrojový kód, v ďalších cvičeniach už len komponenty, ktoré budeme programovať. Zdrojový kód teda bude vyzerať takto (komponent, ktorý sa programuje – Button1, je vyznačený tučným písmom): unit Unit1; {$mode objfpc}{$H+} interface uses Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls; type { TForm1 } TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; Label1: TLabel; procedure Button1Click(Sender: TObject);

14

private { private declarations } public { public declarations } end; var Form1: TForm1; implementation { TForm1 } procedure TForm1.Button1Click(Sender: TObject); begin Label1.Caption:=Edit1.Text;; end; initialization {$I Unit1.lrs} end. Úloha 2.1: Vytvorte program, ktorý bude pozostávať z dvoch tlačidiel. Na začiatku im ponechajte ich názvy, teda Button1 a Button2. Tlačidlo Button1 naprogramujte tak, aby po jeho stlačení sa prepísal jeho názov na „Tlačidlo1“ a názov druhého tlačidla z Button2 na Tlačidlo2. Úloha 2.2: Upravte predchádzajúci program tak, že po stlačení druhého tlačidla sa aplikácia dostane do pôvodného stavu (teda Tlačidlo1 na Button1 a Tlačidlo2 na Button2) a zároveň nech sa do pripraveného Labelu napíše správa: „Aplikácia je v pôvodnom stave“.

15

3 GRAFICKÁ PLOCHA

Ciele:

pamätať si základné príkazy pri práci s grafickou plochou, dané príkazy použiť v konkrétnej aplikácii.

Pod pojmom grafická plocha (vnútorné meno Image) rozumieme obdĺžnikovú oblasť, do ktorej môžeme rôznymi nástrojmi kresliť, písať, nastaviť farbu oblasti, atď. Ak chceme použiť grafickú plochu, z palety komponentov Additional vyberieme komponent Image, položíme ho do formulára a ťahaním za čierne štvorčeky nastavíme veľkosť grafickej plochy. Každá grafická plocha má svoje plátno a kreslíme práve do tohto plátna, ktoré sa nazýva Canvas. Na plátno kreslíme pomocou pera – Pen, alebo vyfarbujeme nejaké plochy pomocou štetca – Brush. Pero aj štetec majú svoje farby – Color, pero má svoju hrúbku – Width. Grafický príkaz Rectangle nakreslí obdĺžnik, resp. štvorec a grafický príkaz Ellipse nakreslí elipsu, resp. kružnicu. Ďalšími dôležitými príkazmi na kreslenie v grafickej ploche sú MoveTo a LineTo. Oba presúvajú grafické pero na nové pozície. MoveTo nekreslí čiary a LineTo kreslí čiary nastavenou farbou a hrúbkou. Príkazy, ktoré pohybujú a kreslia perom, väčšinou vyžadujú zadávanie súradníc. Súradnicová sústava vo Windows je ale trochu inak natočená, ako ju poznáme z matematiky. Ľavý horný roh má súradnice [0,0], a to je počiatok súradnicovej sústavy. Súradnica x smeruje zľava dopravana na hornom okraji plochy a y-ová súradnica smeruje zhora nadol pri ľavom okraji plochy. Cvičenie 3.1: Vytvorte program, ktorý bude obsahovať 2 tlačidlá. Prvé tlačidlo vyfarbí grafickú plochu žltou farbou a druhé tlačidlo do grafickej plochy na ľubovoľnú pozíciu nakreslí obdĺžnik ľubovoľných rozmerov. Obdĺžnik bude mať hrubší červený obvod a vnútro obdĺžnika bude vyfarbené modrou farbou. Riešenie: Formulár programu môže vyzerať napr. takto: Obrázok 4 Grafická plocha – návrh formulára

Prameň: vlastný návrh

grafická plocha

16

Následne si naprogramujeme tlačidlá Button1 a Button2:

procedure TForm1.Button1Click(Sender: TObject); begin Image1.Canvas.Brush.Color:=clYellow; Image1.Canvas.FillRect(Image1.ClientRect); end;

procedure TForm1.Button2Click(Sender: TObject); begin Image1.Canvas.Pen.Width:=5; Image1.Canvas.Pen.Color:=clRed; Image1.Canvas.Brush.Color:=clBlue; Image1.Canvas.Rectangle(20,30,200,100); end; Výsledný program po stlačení oboch tlačidiel bude vyzerať takto: Obrázok 5 Grafická plocha – výsledný program

Prameň: vlastný návrh Úloha 3.1: Napíšte program, ktorý po stlačení tlačidla nakreslí elipsu na základe daného obrázka.

Obrázok 6 Úloha 3.1 - obrázok Prameň: vlastný návrh

17

Úloha 3.2: S využitím príkazov MoveTo a LineTo napíšte program, ktorý po stlačení tlačidla nakreslí daný objekt podľa daného obrázka.

Obrázok 7 Úloha 3.2 - obrázok Prameň: vlastný návrh

Úloha 3.3: Nakreslite semafor.

18

19

4 PRÁCA S ČASOVAČOM A PSEUDONÁHODNÉ ČÍSLA

Ciele:

popísať, ako funguje časovač, definovať pojem pseudonáhodné číslo, použiť časovač a pseudonáhodné čísla v programe.

IDE Lazarus poskytuje mechanizmus, pomocou ktorého môžeme v programe nejakú akciu nechať stále vykonávať v nejakých časových intervaloch. Môžeme si to predstaviť tak, že v počítači sú špeciálne hodiny, ktorým môžeme nastaviť rýchlosť tikania (napr. každú sekundu alebo každú stotinu sekundy a pod.). Zároveň môžeme týmto hodinám povedať, čo majú robiť pri každom tiknutí. Sem teraz môžeme prekopírovať akciu, ktorú sme predtým mali pre stlačenie tlačidla a odteraz táto akcia bude fungovať bez nášho zásahu. Takýto časovač, nájdeme v záložke komponentov System a je to komponent s vnútorným menom Timer. Časovač môžeme položiť na ľubovoľné miesto do formulára (po spustení programu ho nebude vidno). Na vygenerovanie pseudonáhodného čísla slúži funkcia Random. Túto funkciu môžeme podľa potreby použiť v dvoch tvaroch:

1. Random(n) vráti celé číslo z intervalu <0, n-1). Napríklad Random(5) vyberie jednu z hodnôt z 5-prvkovej množiny {0, 1, 2, 3, 4},

2. Random bez parametra generuje pseudonáhodné číslo z intervalu <0, 1). Ak chceme generovať čísla z iného intervalu, musíme výraz na generovanie pseudonáhodného čísla mierne upraviť. Ak chceme napríklad generovať číslo z intervalu 5 až 11, pseudonáhodne vyberáme jednu zo 7 hodnôt {5, 6, 7, 8, 9, 10, 11}. Operáciou Random(7) dostaneme číslo z intervalu 0 až 6 a pričítaním čísla 5 určite dostaneme číslo najmenej 5 a najviac 11. Pseudonáhodné celé číslo z intervalu 5 až 11 teda vyjadruje výraz 5+Random(7). Pri generovaní pseudonáhodného reálneho čísla použijeme funkciu Random bez parametra, ktorá pseudonáhodne vyberá číslo z intervalu <0, 1). Ak chceme napr. generovať reálne číslo z intervalu <5, 11), interval musí mať šírku 7. Preto najprv vynásobíme vygenerované pseudonáhodné číslo siedmimi, takže jeho hodnota bude najmenej 0 a zároveň nepresiahne 7. Pričítaním čísla 5 sa jeho hodnota zväčší najmenej na 5 a nepresiahne 11. Pseudonáhodné reálne číslo z intervalu <5, 11) teda vyjadruje výraz 5+7*Random. Dobrá rada: Pri dlhšej práci s generátorom si môžeme po čase všimnúť, že po každom spustení aplikácie sa generujú vždy tie isté hodnoty. Dôvodom je spôsob generovania, ktorý používa na získavanie čísel algoritmus, v ktorom je nasledujúca hodnota závislá od predchádzajúcej a tá je po spustení aplikácie vždy rovnaká. Riešením je použitie príkazu Randomize, ktorý nastaví generátor na pseudonáhodnú východiskovú hodnotu. Stačí ho použiť v aplikácii raz (napr. pri jej štarte). Cvičenie 4.1: Napíšte program, ktorý bude pozostávať z troch tlačidiel, grafickej plochy a časovača. Stlačením prvého tlačidla sa grafická plocha vyfarbí bielou farbou. Stlačením druhého tlačidla sa spustí činnosť časovača, ktorý v jednosekundových intervaloch bude

20

do grafickej plochy vykresľovať čiary pseudonáhodne generovanej dĺžky a farby. Hrúbka čiary bude stale rovnaká. Stlačenie tretieho tlačidla činnosť časovača pozastaví. Riešenie: Formulár môže vyzerať napríklad takto:

Obrázok 8 Cvičenie 4.1 – návrh formulára

Prameň: vlastný návrh Predtým, ako si naprogramujeme jednotlivé tlačidlá, pozrieme sa najprv na nastavenie časovača v inšpektore objektov. Klikneme na súčiastku Timer1 a v inšpektore objektov v lište s názvom Vlastnosti nastavíme položku Enabled na False (to nám zabezpečí, že sa nám časovač nespustí hneď po spustení aplikácie, ale čaká na príslušné tlačidlo) a položku Interval nastavíme na 1000 (1000 milisekúnd = 1 sekunda). Samotný časovač bude obsahovať tento kód: procedure TForm1.Timer1Timer(Sender: TObject); begin Randomize; Image1.Canvas.Pen.Color := Random(256*256*256); Image1.Canvas.LineTo(Random(Image1.Width), Random(Image1.Height)); end; Tlačidlo s názvom Pozadie naprogramujeme takto: procedure TForm1.Button1Click(Sender: TObject); begin Image1.Canvas.Brush.Color := clWhite; Image1.Canvas.FillRect(Image1.ClientRect); end; Tlačidlo Štart: procedure TForm1.Button2Click(Sender: TObject); begin Timer1.Enabled:=True; end;

časovač (Timer)

21

Tlačidlo Stop: procedure TForm1.Button2Click(Sender: TObject); begin Timer1.Enabled:=False; end; Úloha 4.1: Doplňte predchádzajúce cvičenie 4.1 tak, aby sa okrem dĺžky a farby čiary v zadanom intervale pseudonáhodne generovala aj hrúbka čiary. Nastavte nech sa generuje stále jedna z 5-tich rôznych hrúbok čiar. Zároveň dbajte aj na to, aby nebola vygenerovaná nulová hrúbka čiary. Úloha 4.2: Vytvorte aplikáciu, v ktorej sa hneď po spustení nastaví pozadie grafickej plochy na žlté a v časovom intervale 5 sekúnd sa budú generovať obdĺžniky pseudonáhodnej veľkosti, farby a hrúbky pera. Pozor na nulovú hrúbku obrysovej čiary obdĺžnikov.

22

23

5 PRÍKAZY VETVENIA

Ciele:

popísať príkaz binárneho vetvenia if-then-else, popísať príkaz viacnásobného vetvenia case-of-else, správne použiť príkazy vetvenia v konkrétnej aplikácii, zdôvodniť, prečo použiť určitý príkaz vetvenia pri riešení daného problému.

Príkaz if slúži k rozvetveniu programu na dve vetvy (tzv. binárne vetvenie), pričom program využije len jednu z vetví a druhú preskočí. Môže sa vyskytovať v dvoch podobách (dvoch tvaroch):

a) neúplný príkaz if – tento príkaz neobsahuje nepovinnú vetvu, začínajúcu slovom else. Syntax príkazu: if podmienka then prikaz;

b) úplný príkaz if – tento príkaz obsahuje aj nepovinnú vetvu, začínajúcu slovom else. Syntax príkazu: if podmienka then prikaz_A else prikaz_B;

Príkaz case slúži k rozvetveniu programu na dve alebo viac vetiev, pričom program využije nanajvýš jednu z vetiev. Program je vetvený podľa hodnoty riadiacej premennej N. Táto premenná musí byť ordinálneho dátového typu, teda zo skupiny typu integer (integer, shortint, longint, byte, word) alebo typu char. Syntax príkazu:

case N of Konst1 : Príkaz_A; Konst2 : Príkaz_B; Konst3 : Príkaz_C; else Príkaz_X; end; Cvičenie 5.1: Napíšte program, ktorý bude simulovať kalkulačku. Naša kalkulačka bude vykonávať operácie sčítania, odčítania, násobenia a delenia. Pri delení nezabudnite zohľadniť aj možnosť, že užívateľ zadá do menovateľa nulu. Riešenie: Najprv si do formulára vložíme komponenty, s ktorými budeme pracovať. Návrh formulára pre túto aplikáciu je zobrazený na obrázku 9.

24

Obrázok 9 Cvičenie 5.1 – návrh formulára Prameň: vlastný návrh

Programujeme tlačidlo s názvom Počítaj (Button1): procedure TForm1.Button1Click(Sender: TObject); var a, b:Real; n:Char; begin a:=StrToFloat(Edit1.Text); b:=StrToFloat(Edit3.Text); n:=Edit2.Text[1]; case n of '+': Label5.Caption:=FloatToStr(a+b); '-': Label5.Caption:=FloatToStr(a-b); '*': Label5.Caption:=FloatToStr(a*b); '/': begin

if (b<>0) then Label5.Caption:=FloatToStr(a/b) else Label5.Caption:='Nedovolené delenie nulou';

end; else Label5.Caption:='Zadal si zlý operátor'; end; end; Úloha 5.1: Vytvorte program, ktorý porovná dve čísla. Zohľadnite aj možnosť, že užívateľ zadá rovnaké hodnoty. Úloha 5.2: Vytvorte program, ktorý si od uživateľa vypýta koeficienty a následne vypočíta korene kvadratickej rovnice ax2+bx+c=0. Úloha 5.3: Vytvorte program, ktorý si od užívateľa vypýta poradové číslo mesiaca v kalendárnom roku a následne vypíše, koľko má daný mesiac dní.

Edit2

Edit3 Edit1

Button1

Label5

Label1

Label2

Label3

Label4

25

6 PROGRAMOVÉ CYKLY

Ciele:

popísať nepodmienený cyklus for-to (downto)-do, popísať podmienené cykly while-do a repeat-until, príkazy cyklu správne použiť v konkrétnej aplikácii, zdôvodniť, prečo použiť určitý príkaz cyklu pri riešení daného problému.

Poznáme tri druhy programových cyklov:

a) nepodmienený cyklus for-to (downto)-do Existujú dva spôsoby vykonávania tohto cyklu. Ak sa riadiaca premenná cyklu bude zväčšovať, syntax je: for R:=PocHodnota to KonHodnota do Prikaz; Musí platiť, že počiatočná hodnota musí byť menšia nanajvýš rovná ako koncová hodnota. Ak sa riadiaca premenná cyklu bude zmenšovať, syntax je: for R:=PocHodnota downto KonHodnota do Prikaz; Musí platiť, že počiatočná hodnota musí byť väčšia nanajvýš rovná ako koncová hodnota. Cyklus sa používa vtedy, keď je dopredu známe, koľkokrát sa má daný príkaz, resp. skupina príkazov vykonať,

b) podmienený cyklus while-do Syntax cyklu je: while Podmienka do Prikaz; Príkaz v cykle je vykonávaný dovtedy, pokiaľ je podmienka pravdivá. Vzhľadom na to, že podmienka sa testuje na začiatku cyklu, nemusí sa tento cyklus v programe vykonať ani raz,

c) podmienený cyklus repeat-until Syntax cyklu je: repeat Prikaz until Podmienka; Príkaz v cykle je vykonávaný dovtedy, pokiaľ je podmienka nepravdivá. Vzhľadom na to, že podmienka sa testuje na konci cyklu, musí sa tento cyklus v programe vykonať minimálne raz.

Cvičenie 6.1: Vytvorte program, ktorý vypočíta faktoriál zadaného prirodzeného čísla. Počítajte aj s možnosťou, že užívateľ zadá záporné číslo. Riešenie: Najprv do formulára vložíme komponenty, ktoré v programe budeme používať. Návrh formulára je na obrázku 10.

Obrázok 10 Cvičenie 6.1 – návrh formulára Prameň: vlastný návrh

Edit1

Button1

Label3 Label2

Label1

26

Do Editu1 užívateľ zadá číselnú hodnotu a po stlačení tlačidla Button1 sa do Labelu3 vypíše výsledok. Pri programovaní musíme dať pozor aj na možnosť, že užívateľ zadá do Editu1 zápornú hodnotu. Ak sa tak stane, aplikácia by mala užívateľa upozorniť, že spravil chybu. Možností, ako to spraviť môže byť viac, my na to teraz použijeme objekt, ktorý sa volá MessageBox (príkaz ShowMessage). Pre výpočet samotného faktoriálu použijeme algoritmus, pri ktorom využijeme nepodmienený cyklus for. Procedúra tlačidla Button1 môže vyzerať takto: procedure TForm1.Button1Click(Sender: TObject); var i, cislo, faktorial:Integer; begin cislo:=StrToInt(Edit1.Text); if (cislo<0) then ShowMessage('Faktoriál záporného čísla neexistuje!') else begin faktorial:=1; for i:=cislo downto 2 do faktorial:=faktorial*i; Label3.Caption:=IntToStr(faktorial); end; end; Cvičenie 6.2: Vytvorte program, ktorý nám nájde najväčší spoločný deliteľ (NSD) dvoch prirodzených čísel. Zohľadnite aj možnosť, ak užívateľ zadá záporné čísla, resp. nulu, aby bol upozornený, že je to chybné zadanie. Riešenie: Pripravený formulár s komponentmi je na obrázku 11.

Obrázok 11 Cvičenie 6.2 – návrh formulára Prameň: vlastný návrh

Užívateľ do Editu1 a Editu2 zadá číselnú hodnotu a po stlačení tlačidla Button1 sa do Editu3 vypíše výsledok. Pri programovaní musíme dať pozor aj na možnosť, že užívateľ zadá do Editu1, resp. Editu2 zápornú hodnotu alebo nulu. Ak sa tak stane, aplikácia by mala užívateľa upozorniť, že spravil chybu. Pre výpočet NSD použijeme algoritmus, pri ktorom využijeme podmienený cyklus while-do. Zadanie korektných čísel do editov testujeme s využitím cyklu repeat-until a chybová správa sa vypíše do MessageBoxu. Môžeme si ešte všimnúť, že v tejto aplikácii je nastavené zelené pozadie formulára a názov aplikácie v záhlaví už nie je Form1 ale Podmienené cykly. Tieto parametre nastavíme v inšpektore objektov v položke Vlastnosti. Samozrejme, predtým musíme

Label4

Label1

Label2

Label3 Edit3

Edit2

Button1

Edit1

27

kliknúť myšou na samotný formulár (Form1). Procedúra tlačidla Button1 môže vyzerať napríklad takto: procedure TForm1.Button1Click(Sender: TObject); var a, b:Integer; begin a:=StrToInt(Edit1.Text); b:=StrToInt(Edit2.Text); if ((a<=0) or (b<=0)) then repeat ShowMessage('Čísla musia byť kladné!'+chr(13)+'Nesmieš zadať ani nulu!'); break; until ((a>0) and (b>0)) else begin while (a<>b) do if (a>b) then a:=a-b else b:=b-a; Edit3.Caption:=IntToStr(a); end; end; Úloha 6.1: Vytvorte program, ktorý nám vypočíta n – tú mocninu zadaného čísla. Úloha 6.2: Vytvorte program, ktorý vypočíta najmenší spoločný násobok (nsn) dvoch prirodzených čísel.

28

29

7 PODPROGRAMY

Ciele:

definovať pojem podprogram, popísať mechanizmus, ktorý prebehne pri volaní každého podprogramu, vysvetliť význam a využitie podprogramov pri tvorbe konkrétnych aplikácií.

V Object Pascale poznáme dva typy podprogramov:

a) procedúra – postupnosť príkazov, ktoré riešia nejakú podúlohu, b) funkcia – postupnosť príkazov, ktoré majú za úlohu vypočítať nejaký vysledok,

resp. hodnotu. Syntax definovania vlastnej procedúry: Procedure meno_procedury; // deklarácia premenných pre danú procedúru Begin // telo procedúry End; Mechanizmus, ktorý prebehne pri volaní každého podprogramu:

1. zapamätá sa návratová adresa, 2. vytvoria sa lokálne premenné procedúry, 3. prenesie sa riadenie programu do tela podprogramu (za príslušný begin), 4. vykonajú sa všetky príkazy podprogramu (až po koncový end), 5. zrušia („zabudnú“) sa lokálne premenné, 6. riadenie sa vráti za miesto v programe, odkiaľ bol podprogram volaný, t. j. na

návratovú adresu.

Cvičenie 7.1: Vytvorte program, ktorý bude simulovať pohyb vozíka. Vozík sa po každom stlačení tlačidla pohne doprava vo vodorovnom smere o nejakú dopredu definovanú hodnotu. Úlohu riešte pomocou podprogramov. Riešenie: Do formulára si v tomto prípade vložíme dva komponenty, tlačidlo a grafickú plochu. Formulár je znázornený na obrázku 12.

Obrázok 12 Cvičenie 7.1 – návrh formulára Prameň: vlastný návrh

Button1

Image1

30

Podstata spočíva v tom, že po každom stlačení tlačidla sa vozík má posunúť o nejakú súradnicu vo vodorovnom smere smerom doprava. Vyriešime to tak, že si naprogramujeme dve procedúry. Prvá (procedúra zmaz) vymaže vozík na predchádzajúcej pozícii a druhá (procedúra vozik) bude slúžiť na nakreslenie samotného vozíka. Hlavný program potom využije obe procedúry, nastaví súradnice posunu vozíka a takisto nadefinuje, čo sa má stať, keď vozík príde na kraj grafickej plochy. Programovať sa bude tlačidlo Button1 a zdrojový kód môže vyzerať napríklad takto: var x : Integer = 10; y : Integer = 100; // premenné x, y musíme definovať ako globálne premenné procedure TForm1.Button1Click(Sender: TObject); procedure zmaz; begin Image1.Canvas.Brush.Color := clWhite; Image1.Canvas.FillRect(Image1.ClientRect); end; procedure vozik; begin Image1.Canvas.Brush.Color := clRed; Image1.Canvas.Rectangle(x, y, x+100, y-30); Image1.Canvas.Brush.Color := clBlue; Image1.Canvas.Ellipse(x+25-15, y-15, x+25+15, y+15); Image1.Canvas.Ellipse(x+75-15, y-15, x+75+15, y+15); end; begin // príkazová časť procedúry TForm1.Button1Click zmaz; vozik; x := x+10; if x > Image1.Width then x := -100; end; Úloha 7.1: Skúste prerobiť predchádzajúce cvičenie 7.1 tak, aby sa vozík nepohyboval o zadanú súradnicu len pri každom stlačení tlačidla, ale aby tlačidlo pohyb vozíka len rozbehlo a vozík by sa pohyboval už automaticky. Následne doprogramujte aj tlačidlo, ktoré samostatný pohyb vozíka dokáže pozastaviť.

31

8 JEDNOROZMERNÉ POLE A TEXTOVÁ PLOCHA

Ciele:

definovať pojem jednorozmerné pole, vymenovať a popísať tri vlastnosti poľa, vysvetliť význam a využitie poľa pri tvorbe konkrétnych aplikácií.

Základným štruktúrovaným dátovým typom je pole (ang. array). Možno si ho predstaviť ako zoznam, ktorý obsahuje hodnoty rovnakého typu. Dátový typ poľa má tieto vlastnosti:

1. pevne daný počet prvkov poľa, 2. všetky prvky poľa sú rovnakého dátového typu (integer, real, atď.), 3. jednotlivé prvky poľa majú svoje jednoznačné označenie, tzv. index. Index

chápeme ako označenie prvku poľa. Ordinálna hodnota indexu nasledujúceho prvku je vždy o jedničku vyššia, než ordinálna hodnota predchádzajúceho prvku.

Všeobecne syntax jednorozmerného poľa môže vyzerať takto: Meno_pola : Array[I1..I2] of Typ_premennej; Pričom I1 je počiatočná hodnota indexu poľa, I2 je koncová hodnota indexu poľa. Index poľa musí byť ordinálneho dátového typu (integer, char), nesmie byť napr. real alebo string. Typ_premennej môže byť ordinálneho aj reálneho dátového typu. Pri práci so súvislejším textom nám v Lazaruse slúži komponent textová plocha (Memo), ktorý slúži nielen na vypisovanie textov do plochy, ale aj pri práci s textovými súbormi (tomu sa budeme venovať neskôr). Niektoré základné príkazy pre prácu s textovou plochou:

Memo1.Lines.Clear; - vyčistí všetky riadky, Memo1.Lines.Append('nejaký text'); - pridá ďalší riadok s daným textom na

koniec, Memo1.Lines.LoadFromFile(súbor); - do textovej plochy zapíše obsah súboru

z disku, Memo1.Lines.SaveToFile(súbor); - obsah textovej plochy zapíše do súboru.

Cvičenie 8.1: Vytvorte program, ktorý náhodne vygeneruje 10 celých čísel z intervalu 1 až 100, uloží si ich do jednorozmerného poľa a vypíše do textovej plochy. Riešenie: Najprv do formulára vložíme potrebné komponenty, ako je to znázornené na obrázku 13.

32

Obrázok 13 Cvičenie 8.1 – návrh formulára Prameň: vlastný návrh

Programovať sa bude tlačidlo Button1 a zdrojový kód môže vyzerať takto: procedure TForm1.Button1Click(Sender: TObject); var Pole:Array[1..10] of Integer; i:Integer; begin Randomize; Memo1.Lines.Clear; for i:=1 to 10 do begin Pole[i]:=Random(100)+1; Memo1.Lines.Append(IntToStr(Pole[i])); end; end; Úloha 8.1: Doplňte formulár v predchádzajúcom cvičení 8.1 o ďalšiu textovú plochu (Memo2), v ktorej budú vygenerované čísla vypísané v opačnom poradí, ako sú vypísané v Memo1.

Button1

Label1

Memo1

33

9 ZNAKY A REŤAZCE ZNAKOV

Ciele:

vysvetliť, akým spôsobom sú v počítači znaky kódované, definovať pojem reťazec znakov, vymenovať štandardné typy premenných pre prácu so znakmi a reťazcami

znakov, použiť znaky a reťazce znakov pri tvorbe návrhu konkrétneho algoritmu.

Pre prácu so znakmi sa v Object Pascale používa dátový typ char. Na rozdiel od celočíselného, reálneho alebo logického typu, nemôžeme s týmto typom robiť žiadne operácie. Môžeme akurát nejakú znakovú hodnotu priradiť do premennej, môžeme ju porovnať s inou hodnotou a znakovú hodnotu môžeme ešte vypísať, napr. do grafickej plochy. V pamäti počítača je pre každú takúto premennú vyhradený jeden bajt (8 bitov) a preto sa do tejto premennej zmestí jedna z 256 rôznych hodnôt. Tieto hodnoty sú navzájom usporiadané a tak ich môžeme navzájom porovnávať nielen na rovnosť, ale aj reláciami menší a väčší. Vnútorne v počítači sú znaky kódované ASCII kódovaním. Každému znaku prislúcha kód, čo je číslo od 0 do 255. Object Pascal potom pri porovnávaní dvoch znakov porovná ich ASCII kódy a ten znak, ktorý má menší tento kód je považovaný za menší (napr. znak 'A' má hodnotu #65, znak 'a' hodnotu #97). Pre prácu s reťazcami znakov v Object Pascale používame dátový typ string. Pod pojmom reťazec znakov rozumieme postupnosť tvorenú znakmi, ktorú chápeme ako celok. Najjednoduchšia predstava raťazca znakov môže byť vyjadrená napríklad dátovým typom Znaky: Type velkost_retazca = 0..255; Znaky = Array[velkost_retazca] of Char; Var z : Znaky; Premenná typu string zároveň umožňuje prístup k textu nielen ako k celku, ale aj k jeho jednotlivým znakom, prostredníctvom poradového čísla znaku – indexu, ktorý je uvedený v hranatých zátvorkách. Medzi štandardné podprogramy na prácu so znakovými reťazcami patrí:

TextOut(x, y, text); // vypíše text do grafickej plochy IntToStr(číslo); // konvertuje číslo na reťazec StrToInt(text); // konvertuje reťazec na číslo Length(text); // vráti dĺžku reťazca SetLength(premenná, číslo); // reťazcovej premennej nastaví dĺžku

Cvičenie 9.1: Vytvorte program, ktorý si do Editu1 od užívateľa vypýta jeho meno a do Editu2 jeho priezvisko. Následne nech po stlačení tlačidla do Labelu1 vypíše spolu zadané meno a priezvisko a do Labelu2 nech vypíše iniciály veľkými písmenami. Program nech zároveň aj spočíta počet znakov mena užívateľa.

34

Riešenie: Najprv si do formulára vložíme potrebné komponenty, ako je to znázornené na obrázku 14.

Obrázok 14 Cvičenie 9.1 – návrh formulára Prameň: vlastný návrh

Programovať budeme tlačidlo Button1 a zdrojový kód môže vyzerať takto: procedure TForm1.Button1Click(Sender: TObject); var R1, R2:String;

a:Integer; begin R1:=Edit1.Text; R2:=Edit2.Text; Label4.Caption:=R1+' '+R2; Label6.Caption:=Upcase(R1[1])+Upcase(R2[1]); a:=Length(R1); Label8.Caption:=IntToStr(a); end; Úloha 9.1: Napíšte program, ktorý po stlačení tlačidla vypíše do grafickej plochy na náhodnú pozíciu náhodné písmeno veľkej abecedy. Úloha 9.2: Napíšte program, ktorý otočí slovo. Napr. ak užívateľ napíše slovo 'auto', program po stlačení tlačidla vypíše 'otua'.

Label1

Buttonl

1

Edit1

Label2

Edit2

Label5

Label3 Label4

Label8

Label6

Label7

35

10 PRÁCA S MYŠOU

Ciele:

určiť, kedy vzniká udalosť OnMouseMove a kedy udalosť OnMouseDown, použiť parameter Shift pri tvorbe aplikácie, použiť udalosti OnMouseMove a OnMouseDown pri tvorbe aplikácie.

Keď je pod systémom Windows spustená ľubovoľná aplikácia, systém môže tejto aplikácii oznamovať každý pohyb myši nad jej oknom a tiež rôzne typy klikania a ťahania myši. Aplikácie, ktoré sú napísané v Object Pascale v IDE Lazarus, dostávajú tieto informácie formou udalostí. Ak pre nejakú z týchto udalostí napíšeme zodpovedajúcu procedúru, táto sa zavolá pri každom výskyte príslušnej udalosti. Aby sme mohli pridávať nové udalosti, musíme prejsť do Inšpektora objektov, pričom treba mať nastavený príslušný komponent, pre ktorý chceme definovať nejakú udalosť, teda Image1. V Inšpektore objektov prejdeme do záložky Events (Udalosti) a nájdeme riadok s požadovanou udalosťou. Teraz keď dvojklikneme do voľného políčka pri tejto udalosti, v editovacom okne sa predpripraví už známy tvar procedúry, napr. Image1MouseMove. Medzi najčastejšie používané udalosti patrí:

OnMouseMove – táto udalosť vzniká vždy, keď pohybujeme myšou nad grafickou plochou. Dvojklikneme do voľného políčka vpravo od OnMouseMove a vytvorí sa prázdna procedúra na spracovávanie tejto udalosti: procedure TForm1.Image1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);

begin

end;

OnMouseDown – táto udalosť vzniká, keď stlačíme tlačidlo myši nad grafickou plochou. Väčšinou to znamená začiatok kreslenia nejakých čiar alebo útvarov. V inšpektore objektov dvojklikneme na udalosť OnMouseDown. Na zistenie, či bolo alebo nebolo stlačené tlačidlo myši nad grafickou plochou slúži parameter Shift. V ňom systém odovzdáva informáciu o stláčaných tlačidlách. Tento parameter môže nadobúdať rôzne hodnoty, ale pre nás sú najzaujímavejšie tieto:

Shift = [ ] // nestlačili sme žiadne tlačidlo

Shift = [ssLeft] // stlačili sme len ľavé tlačidlo

Shift = [ssRight] // stlačili sme len pravé tlačidlo

Shift = [ssLeft, ssRight] // stlačili sme naraz obe tlačidlá

Cvičenie 10.1: Vytvorte program, kde pri stlačení a následnom ťahaní pravého tlačidla myši sa grafická plocha vyfarbí na bielo a pri stlačení a následnom ťahaní ľavého tlačidla myši sa do grafickej plochy budú vykresľovať krúžky. Veľkosť krúžkov nech je ľubovoľná. Riešenie: Najprv si do formulára vložíme komoponent grafická plocha. Potom si vyberieme v inšpektore objektov kartu Udalosti, dvojklikneme na udalosť OnMouseMove a nadefinujeme jej tento kód:

36

procedure TForm1.Image1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin if Shift = [ssLeft] then Image1.Canvas.Ellipse(X-5, Y-5, X+5, Y+5) else if Shift = [ssRight] then begin Image1.Canvas.Brush.Color:=clWhite; Image1.Canvas.FillRect(Image1.ClientRect); end; end; Úloha 10.1: Napíšte program, v ktorom kliknutie do plochy pravým tlačidlom myši vykreslí na danú pozíciu buď elipsu alebo obdĺžnik.

37

11 GRAFICKÝ ROBOT

Ciele:

popísať, načo sa používa grafický robot, vysvetliť, na akom princípe pracuje grafický robot, vymenovať a popísať základné príkazy pre prácu s grafickým robotom, použiť grafického robota pri tvorbe aplikácie.

Už vieme pracovať s grafickým perom v grafickej ploche. Teraz si ukážeme iný spôsob kreslenia: využijeme na to špeciálne "vycvičených" robotov, ktorí sa vedia v grafickej ploche pohybovať a pritom môžu za sebou zanechávať čiaru. Nakoľko tieto roboty nie sú štandardnou súčasťou IDE Lazarus, bude treba do nášho programu špeciálne niečo kvôli tomu pridávať:

1. predpokladáme, že máme novú aplikáciu s grafickou plochou a s aspoň jedným tlačidlom,

2. za riadok implementation pridáme: uses

RobotUnit; Tento zápis predpokladá, že na disku už máme súbor s definíciou správania robotov. Súbor sa volá RobotUnit.pas1. Je veľmi dôležité, aby sa nachádzal presne v tom istom priečinku, ako aj náš program (ak budeme mať viac programov, ktoré pracujú s týmito robotmi, vo viacerých priečinkoch, do všetkých treba tento súbor nakopírovať). Teraz už môžeme zadefinovať nových robotov a teda aj s nimi pracovať. Robot vo všeobecnosti pracuje na takomto princípe:

nachádza sa niekde v grafickej ploche a je natočený nejakým smerom - nie je ho ale vidieť - nezobrazuje sa (ak nie je nastavené inak, tak sa robot „narodí“ v strede grafickej plochy a je natočený smerom „na sever“),

ak sa mu povie, aby prešiel nejakú vzdialenosť, tak v momentálnom smere natočenia sa presunie dopredu,

ak sa mu povie, aby sa o nejaký uhol otočil, tak nemení svoju pozíciu, len sa na svojom mieste otočí o zadaný uhol,

robot má k dispozícii pero, ktorým vie počas svojho chodenia zanechávať za sebou čiaru - toto pero môže byť spustené (vtedy kreslí), alebo zdvihnuté (vtedy sa len presúva),

tomuto peru môžeme zmeniť farbu aj hrúbku. Základné príkazy pre prácu s grafickým robotom sú:

Create; robot vznikne v strede plochy, Create(x, y); robot vznikne na súradniciach (x, y), Create(x, y, uhol); robot vznikne na súradniciach (x, y) s počiatočným

uhlom uhol, Fd(dĺžka); „forward“ – robot prejde vzdialenosť dĺžka, SetXY(x, y); robot sa premiestni na súradnicu (x, y),

1 http://pascal.input.sk/images/7/79/RobotUnit.pas, 18.10.2013

38

MoveXY(x, y); robot sa premiestni na súradnicu (x, y) so zdvihnutým perom,

Point; robot nakreslí bodku veľkosti hrúbky pera, Point(veľkosť); robot nakreslí bodku veľkosti veľkosť, Rt(uhol); „right“ – robot sa na mieste otočí o uhol stupňov

vpravo, Lt(uhol); „left“ – robot sa na mieste otočí o uhol stupňov vľavo, SetH(uhol); „set heading“ – robot sa na mieste otočí do

absolútneho uhla uhol stupňov, PC := farba; „pen color“ – robotovi nastavíme farbu pera farba, PW := hrúbka; „pen width“ – robotovi nastavíme hrúbku pera

hrúbka, PU; „pen up“ – robotovi zdvihneme pero, PD; „pen down“ – robotovi spustíme pero, CS; „clear screen“ – zmažeme grafickú plochu bielou

farbou, CS(farba); zmažeme grafickú plochu farbou farba, Wait(ms); program sa pozdrží na ms milisekúnd.

Cvičenie 11.1: Vytvorte program, ktorý s využitím grafického robota, po stlačení tlačidla, do grafickej plochy vykreslí obdĺžnik ľubovoľných rozmerov. Obdĺžnik bude nakreslený modrou farbou a hrúbku čiary bude mať nastavenú na hodnotu 5 (pozri obrázok 15).

Obrázok 15 Cvičenie 11.1 – návrh formulára Prameň: vlastný návrh

Riešenie: Programovať budeme tlačidlo Robot (Button1) a zdrojový kód môže vyzerať napríklad takto: implementation uses RobotUnit; { TForm1 } procedure TForm1.Button1Click(Sender: TObject); var Robot: TRobot; I: Integer; begin

39

CS(clYellow); Robot := TRobot.Create; Robot.PC:=clBlue; Robot.PW:=5; Robot.Fd(50); Robot.Lt(90); Robot.Fd(100); Robot.Lt(90); Robot.Fd(50); Robot.Lt(90); Robot.Fd(100); end; Popíšme si predchádzajúci zdrojový kód: Najprv si zadeklarujeme premennú Robot, pomocou ktorej budeme ovládať robota – je to premenná typu TRobot. Príkazom CS(clYellow) vyfarbíme grafickú plochu na žlto. Príkazom Robot:=TRobot.Create vytvoríme nového robota. TRobot.Create označuje, že chceme, aby sa vytvoril („narodil“) nový robot a tento sa priradí do premennej Robot. Ak nie je nastavené inak, robot sa vytvorí v strede grafickej plochy otočený smerom „na sever“. Príkazom Robot.PC:=clBlue nastavíme farbu pera robota na modrú a príkazom Robot.PW:=5 nastavíme hrúbku pera robota na 5. Príkazom Robot.Lt natočíme robota o príslušný uhol a príkazom Robot.Fd sa robot posunie o príslušnú vzdialenosť. Úloha 11.1: S využitím grafického robota vytvorte program podľa obrázka 16. Hrúbku čiary robota nastavte na 4.

Obrázok 16 Úloha 11.1 – obrázok Prameň: vlastný návrh

40

41

12 TEXTOVÉ SÚBORY

Ciele:

definovať textový súbor, vymenovať a popísať základné príkazy pre prácu s textovým súborom, použiť dané príkazy pre prácu s textovým súborom pri tvorbe aplikácie.

Vo všeobecnosti je súbor postupnosť (sekvencia) prvkov (väčšinou) rovnakého typu. Najčastejšie sa nachádza na nejakom vonkajšom zariadení, napr. na disku. Textový súbor je postupnosť riadkov (aj prázdna), pričom riadok textového súboru je postupnosť znakov (aj prázdna) ukončená špeciálnou značkou Eoln (z anglického end of line). Všetky údaje sú v textovom súbore zapísané ako ASCII znaky. Ako pracujeme s textovým súborom:

1. najprv zadeklarujeme premennú typu TextFile, pomocou ktorej budeme k tomuto súboru ďalej v programe pristupovať (podobne ako premenná typu TRobot slúži na prístup k robotovi):

var Subor: TextFile; 2. ďalej treba tejto „súborovej“ premennej priradiť nejaký konkrétny súbor

(najčastejšie na disku): AssignFile(Subor, meno_súboru);

3. potom treba súbor „otvoriť“ - pri otváraní určíme, či z neho budeme len čítať (Reset) alebo budeme do neho len zapisovať (Rewrite):

Reset(Subor); // otvorenie súboru na čítanie - súbor už musí existovať, Rewrite(Subor); // otvorenie súboru na zápis - ak už existuje, tak sa najprv

obsah vymaže, 4. potom môžeme pracovať s jeho obsahom:

Read(Subor, premenná); // čítanie zo súboru - z pozície ukazovateľa, Readln(Subor, ...); Write(Subor, hodnota); // zápis do súboru - na jeho koniec, Writeln(Subor, ...);

5. na záver ho treba "zatvoriť", t.j. ukončíme s ním ďalšiu prácu: CloseFile(Subor);

Na testovanie konca súboru slúži štandardná logická funkcia Eof(Subor) - skratka z end of file:

vráti True, ak je ukazovateľ nastavený za posledným znakom súboru, najčastejšie sa bude používať v teste while not Eof(Subor) do ..., t.j. rob, kým nie je

koniec súboru, čítanie za koncom súboru najčastejšie spôsobí chybovú správu, ak je súbor otvorený na zápis (Rewrite), tak ukazovaťeľ je stále na konci a teda

Eof stále vracia True znak #26 má v Pascale (z historických dôvodov) niekedy špeciálny význam:

čítanie textového súboru si na ňom "myslí", že je na konci súboru (Eof(Subor)=True) a nedovolí čítať ďalšie znaky za ním.

42

Na testovanie konca riadka slúži štandardná logická funkcia Eoln(Subor) - skratka z ang. end of line:

vráti True, ak je ukazovateľ v súbore na značke Eoln, True vráti aj vtedy, keď je za posledným znakom súboru, t.j. ak platí

Eof(Subor)=True, tak platí aj Eoln(Subor)=True, značka Eoln sa vnútorne kóduje dvoma znakmi #13 a #10 (hovoríme im CR a LF), príkazom Readln(Subor) preskočíme od momentálnej pozície ukazovateľa všetky

znaky až za najbližšiu značku Eoln (na konci súboru nerobí nič), pozor, pomocou Read(Subor, Znak) je možné čítať aj značku Eoln, lenže táto sa

potom chápe ako 2 znaky #13 a #10 a nie ako nejaký jeden špeciálny znak, príkaz Readln(Subor, Znak) je skrátený tvar pre dvojicu príkazov Read(Subor,

Znak); Readln(Subor); príkaz Writeln(Subor) sa dá zapísať aj ako Write(Subor, #13#10).

Cvičenie 12.1: Vytvorte program, ktorý vypočíta súčet dvoch celých čísel a výsledok uloží do textového súboru „sucet.txt“ na disk počítača. Riešenie: Najprv si do formulára vložíme potrebné komponenty, ako je to znázornené na obrázku 17.

Obrázok 17 Cvičenie 12.1 – návrh formulára Prameň: vlastný návrh

Programovať budeme Button1. Súbor „sucet.txt“ sa nám po stlačení tlačidla vytvorí v adresári aplikácie. Do súboru bude zapísaný výsledok. Zdrojový kód môže vyzerať takto: procedure TForm1.Button1Click(Sender: TObject); var a, b, vysledok:Integer; Subor: TextFile; begin a:=StrToInt(Edit1.Text); b:=StrToInt(Edit2.Text); vysledok:=a+b; Label1.Caption:='Výsledok nájdeš v súbore "sucet.txt"'; AssignFile(Subor, 'sucet.txt'); Rewrite(Subor); Write(Subor, 'Súčet je: ',vysledok); CloseFile(Subor); end; Úloha 12.1: Navrhnite program, ktorý spočíta počet medzier v textovom súbore. Tento textový súbor si najprv musíte vytvoriť a uložiť na disk počítača. Následne je potrebné do daného súboru napísať ľubovoľný text, s ktorým bude program pracovať.

Edit1

Label1

Edit2

Button1

43

13 LISTBOX

Ciele:

vysvetliť význam Listboxu, vymenovať a popísať všetky nižšie uvedené základné príkazy pre prácu

s Listboxom, použiť dané príkazy pre prácu s Listboxom pri tvorbe aplikácie.

Na prácu so zoznamom je jedným z najvhodnejších komponentov komponent Listbox, ktorý predstavuje vizuálnu reprezentáciu poľa obsahujúceho hodnoty typu string. Do tohto zoznamu môžeme pridávať položky typu string buď priamov návrhovom prostredí Lazarus (uložiť pod seba položky cez vlastnosť Items), alebo prostredníctvom kódu. Pri Listboxe sa stretneme s vlastnosťou typickou aj pre ďalšie komponenty – index prvého prvku je 0, posledného Listbox1.Items.Count-1 – počítanie nezačína od 1, ale od 0. Pri mazaní položky z Listboxu by sme mali najprv zistiť, či je vôbec nejaká aktívna a ak áno, zistiť jej pozíciu a vymazať ju. V tabuľke 2 sú uvedené základné operácie na prístup k prvkom Listboxu.

Tabuľka 2 Operácie v Listboxe

Požiadavka Príkaz Poznámka pridať položku Listbox1.Items.Add(text); text je typu string počet položiek v Listboxe

pocet:= Listbox1.Items.Count; pocet je typu integer

získať text i-tej položky

polozka:=Listbox1.Items.Strings[i]; alebo jednoduchšie polozka:=Listbox1.Items[i];

polozka je typu string

odstrániť i-tu položku

Listbox1.Items.Delete(i);

vymazať všetky položky z Listboxu

Listbox1.Items.Clear; alebo Listbox1.Clear;

zistiť, na ktorej položke Listboxu je nastavený kurzor

cislo:=Listbox1.ItemIndex;

cislo je typu integer, pri výbere prvej položky je hodnota 0, druhej 1, atď. Pokiaľ nie je vybraná žiadna položka, je vrátená hodnota (-1)

vypísať text na vybranej položke

mytext:= Listbox1.Items[Listbox1.ItemIndex]; alebo jednoduchšie mytext:=Listbox1.SelectedText;

ide o kombináciu dvoch predchádzajúcich: ItemIndex vráti poradové číslo položky, ktorá je aktívna a Items[Listbox1.ItemIndex] vráti text, ktorý je v aktívnej položke uložený

zistiť, či sa daná porcislo:= porcislo obsahuje poradové

44

položka v Listboxe už nachádza a ak áno, vrátiť jej poradové číslo

Listbox1.Items.IndexOf(text); číslo položky, ktorá obsahuje zadaný text. V prípade, že sa takáto položka v Listboxe nenachádza, IndexOf vráti (-1)

Prameň: Skalka Ján, 2007, s. 308, 309

Cvičenie 13.1: Vytvorte program, ktorý dokáže prostredníctvom tlačidla pridávať do Listboxu text, ktorý zadáte do Editu a prostredníctvom druhého tlačidla mazať zo zoznamu položku, na ktorej ste v Listboxe nastavení. Riešenie: Najprv si do formulára vložíme potrebné komponenty, ako je to znázornené na obrázku 18.

Obrázok 18 Cvičenie 13.1 – návrh formulára Prameň: vlastný návrh

Programovať budeme tlačidlá Button1 a Button2 a zdrojový kód môže vyzerať napríklad takto: procedure TForm1.Button1Click(Sender: TObject); begin ListBox1.Items.Add(Edit1.Text); end; procedure TForm1.Button2Click(Sender: TObject); var index: Integer; begin if (ListBox1.ItemIndex > -1) then begin index:=Listbox1.ItemIndex; Listbox1.Items.Delete(index); end; end; procedure TForm1.Edit1Click(Sender: TObject); begin Edit1.Text:=''; // udalosť Editu1 – OnClick, pri kliknuti vymaže obsah Editu1 end;

ListBox1

Button2

Edit1

Button1

45

Úloha 13.1: Do predchádzajúceho cvičenia 13.1 doprogramujte ďalšie tlačidlo, ktoré nám vymaže všetky položky z Listboxu. Úloha 13.2: Vytvorte program, ktorý do poľa celých čísel prenesie číselné údaje z Listboxu a v opačnom poradí ich umiestni do druhého Listboxu.

46

47

14 OVERENIE NAVRHNUTEJ METODIKY

Jedným z dôležitých cieľov mojej práce bolo overiť metodiku vyučovania programovacieho jazyka Object Pascal v programovacom prostredí Lazarus na strednej škole. Metodiku som overoval na Gymnáziu sv. Jána Zlatoústeho v Humennom so žiakmi 3. ročníka na predmete Seminár z informatiky. Na začiatku každej problematiky som 15 až 20 minút venoval vysvetleniu teoretických pojmov. Každý učiteľ si túto časovú dotáciu môže predĺžiť alebo skrátiť v závislosti od školy, resp. triedy v ktorej učí. Následne som spolu so žiakmi preriešil vzorové cvičenia a tam som sa snažil aplikovať nadobudnuté teoretické vedomosti do praktického programu. A nakoniec, aby som overil, či žiaci danej problematike porozumeli, na konci každej kapitoly sú úlohy, ktoré by žiaci mali samostatne vyriešiť. Keďže cvičenie 2.1 bolo riešené na hodinách seminára ako prvé, odporúčam učiteľom aby na ňom žiakom predviedli aj tzv. „štábnu kultúru“ programovania v programovacom prostredí Lazarus. Zahŕňa to napr. ukázať žiakom ako spustiť a otvoriť novú prázdnu aplikáciu, popísať im základné časti IDE Lazarus, následne ich dôrazne upozorniť, že ešte pred vložením prvého komponentu do formulára je potrebné aplikáciu uložiť do vopred pripraveného adresára, naučiť ich vkladať základné komponenty do formulára (robiť s nimi aj úpravy), ukázať im kde a ako sa vkladá samotný zdrojový kód, vysvetliť im, že na rozdiel od „obyčajného“ programovania napr. v Pascale, tu sa programujú objekty, ako program skompilovať a následne aj spustiť a pod. Aj vzhľadom na podrobnosť vysvetlenia prvého cvičenia žiaci s algoritmom úlohy 2.1 a 2.2. nemali problém a dokázali pochopiť, čo majú robiť, ale všimol som si, že niektorí žiaci majú problém s kompilovaním aplikácie, pretože chybové hlásenia sú uvedené v anglickom jazyku (v tzv. technickej angličtine) a tieto problémy sa viac-menej objavovali aj v ostatných aplikáciách. Úlohu 3.1 bez pomoci učiteľa vyriešilo 60 % žiakov. Ostatným robilo problém pochopiť spôsob vykresľovania elipsy pomocou súradnice ľavého horného rohu a pravého dolného rohu. To im bolo nutné vysvetliť. Úlohu 3.2 sa podarilo samostatne vyriešiť 80 % žiakov. Ostatným bolo potrebné pripomenúť princíp fungovania príkazov MoveTo a LineTo. Úloha 3.3 nerobila žiakom žiadne problémy. S úlohou 4.1 nemali žiaci žiadne problémy. Úlohu 4.2 dokázalo bez pomoci učiteľa zvládnuť len 30 % žiakov. Problém bol v tom, že žiaci tu už neprogramovali tlačidlo, ale bolo potrebné programovať komponent Formulár. Po upozornení a vysvetlení daného problému sa všetkým žiakom úlohu podarilo vyriešiť. Úloha 5.1 nerobila žiakom žiadne problémy. Úlohu 5.2 bez pomoci učiteľa vyriešilo 70 % žiakov. Ostatní mali problém s matematikou a to konkrétne s matematickým riešením kvadratickej funkcie. Preto bolo potrebné túto problematiku zopakovať. Úlohu 5.3 bez pomoci učiteľa vyriešilo 80 % žiakov. Ostatní mali problém so skompilovaním programu, pretože zabudli na konci príkazu case napísať end. Mohlo to byť spôsobené jednak nepozornosťou, ale aj nedostatočným naštudovaním syntaxe daného príkazu. Preto odporúčam pri vysvetľovaní príkazov vetvenia klásť zvýšený dôraz na vysvetlenie ich syntaxe a hlavne žiakov upozorniť na zakončenie príkazu case end-om, lebo tento problém sa objavuje pravidelne. Úlohu 6.1 bez pomoci učiteľa vyriešilo 60 % žiakov. Ostatným robilo problém zostaviť algoritmus. Po vysvetlení postupu žiaci daný algoritmus nemali problém prepísať do programovacieho jazyka. Úlohu 6.2 bez pomoci učiteľa vyriešilo len 30 % žiakov. Najväčší problém žiakom robila matematika a to konkrétne vzorec na výpočet najmenšieho spoločného násobku. Problém bol následne aj s navrhnutím algoritmu.

48

Preto učiteľom pred riešením daných úloh navrhujem, aby žiakom dali naštudovať príslušný matematický aparát. Úlohu 7.1 bez pomoci učiteľa vyriešilo 70 % žiakov. Ostatným robilo problém zostaviť algoritmus naprogramovania Timera. Po vysvetlení postupu žiaci už daný algoritmus nemali problém prepísať do programovacieho jazyka. Navrhujem, aby učitelia pred riešením tejto kapitoly dali žiakom zopakovať problematiku práce s časovačom. Úlohu 8.1 bez pomoci učiteľa vyriešilo 70 % žiakov. Ostatným robilo problém zostaviť algoritmus výpisu čísel v opačnom poradí. Po vysvetlení postupu žiaci daný algoritmus nemali problém prepísať do programovacieho jazyka. Učiteľom pred riešením úlohy navrhujem, aby žiakom dali zopakovať cyklus for. Úloha 9.1 nerobila žiakom problémy a vyriešili ju všetci žiaci bez pomoci učiteľa. Úlohu 9.2 vyriešilo bez pomoci učiteľa 50 % žiakov. Ostatným robilo problém navrhnúť algoritmus otočenia slova a našli sa aj takí, ktorí nevedeli použiť príkaz na zistenie počtu znakov v textovom reťazci. Po vysvetlení postupu žiaci daný algoritmus nemali problém prepísať do programovacieho jazyka. Učiteľom preto navrhujem, aby dbali na dôkladné vysvetlenie problematiky znakov, reťazcov znakov a uistili sa, či žiaci vedia pracovať s podprogramami pre prácu so znakmi a reťazcami znakov. Navrhujem aj zopakovanie cyklu for. Úlohu 10.1 bez pomoci učiteľa vyriešili všetci žiaci. V tejto kapitole treba dbať na dôsledné vysvetlenie teoretických poznatkov, aby si žiaci osvojili príkazy pre prácu s myšou a navrhujem dať žiakom zopakovať kreslenie obdĺžnikov a elíps do grafickej plochy. Úloha 11.1 vzhľadom na dôkladné vysvetlenie a preriešenie predchádzajúceho cvičenia 90 percentám žiakov nerobila problémy. Ostatní mali menší problém s čiarkovanou čiarou. Učiteľom odporúčam, aby dôkladne so žiakmi prešli základné príkazy pre prácu s grafikou a uistili sa, či žiaci daným príkazom porozumeli. V tomto prípade som žiakom odporučil, aby si pozreli príkazy PU a PD a program úspešne vyriešili. Úlohu 12.1 bez pomoci učiteľa vyriešilo 30 % žiakov. Ostatní mali problém s vytvorením algoritmu a pár ich malo problém pochopiť, že aj medzera je znak a nevedeli ako medzeru v programe zadefinovať. Väčšinou si ju mýlili s prázdnym reťazcom. Úloha 13.1 nerobila žiakom žiadne problémy, keďže šlo len o doprogramovanie vzorového cvičenia s využitím príkazu na zmazanie položiek Listboxu, ktorý sme si vysvetlili v teoretickej časti. Úlohu 13.2 bez pomoci učiteľa vyriešilo 50 % žiakov. Ostatní mali problém s vytvorením algoritmu a pomerne veľké problémy im robila aj práca s jednorozmerným poľom. Preto je potrebné pred riešením tejto úlohy dať žiakom zopakovať problematiku jednorozmerných polí.

14.1 Odporúčania pre pedagogickú prax

Na základe pedagogických skúseností nadobudnutých na hodinách programovania v programovacom jazyku Object Pascal v IDE Lazarus odporúčam túto problematiku vyučovať na stredných školách v rámci tematického okruhu „Postupy, riešenie problémov, algoritmické myslenie“. Pri vyučovaní danej problematiky odporúčam klásť najväčší dôraz na riešenie praktických úloh, pretože algoritmizovať a programovať sa žiaci naučia len a len samotným riešením konkrétnych úloh. Teóriu by som obmedzil na minimálnu možnú mieru, ale učiteľom zároveň odporúčam, aby túto problematiku ani príliš nepodcenili. Zadania úloh som sa snažil popísať čo najobšírnejšie a preto žiaci väčšinou nemali problém pochopiť, čo majú robiť.

49

Najväčšie problémy žiakom nerobil ani tak prepis hotového algoritmu do programovacieho jazyka, ale návrh samotného algoritmu. Tento problém je pri vyučovaní programovania asi najvypuklejší a dá sa vyriešiť snáď len tým, že žiaci budú veľa programovať. Pri vytváraní algoritmu je samozrejme veľmi potrebné logické myslenie a nemenej dôležitá je aj snaha. Preto veľmi dôležitou úlohou učiteľa je žiakov vedieť aj správne namotivovať. Ako som už vyššie spomínal, veľké problémy žiakom spôsobovali aj chybové hlásenia počas ladenia programu, ktoré boli písané v anglickom jazyku a často zabúdali úlohu na začiatku uložiť. Bolo by preto vhodné, aby sa na hodinách anglického jazyka venovala zvýšená pozornosť aj technickej angličtine. Ďalej odporúčam klásť veľký dôraz aj na vysvetlenie vyhradených výrazov daného programovacieho jazyka a pripraviť pre nich preklad najčastejších chybových hlásení aj s ich zrozumiteľným výkladom. Pri programovaní sú často veľmi potrebné aj znalosti z matematiky a to často spôsobovalo žiakom veľké problémy. Preto učiteľom radím, aby žiakom pred tým, ako začnú riešiť konkrétny algoritmický problém, dali zopakovať aj príslušný matematický aparát.

50

51

ZÁVER

Táto práca má slúžiť hlavne ako pomôcka pre učiteľa. Učiteľ ju môže použiť ako celok, alebo si z nej môže vybrať len nejaké kapitoly. Podobne si môže zmeniť aj časovú dotáciu jednotlivých kapitol v závislosti na šikovnosti žiakov.

Cieľom tejto práce je podeliť sa so skúsenosťami autora pri vyučovaní základov programovacieho jazyka Object Pascal v prostredí Lazarus na hodinách informatiky na strednej škole. Je veľmi dôležité, aby sa s týmto jazykom oboznámili žiaci už na strednej škole, pretože im to pomôže v ich ďalšom štúdiu na vysokej škole, resp. programátorskej praxi. Jedným z dôležitých cieľov práce bolo taktiež overiť metodiku vyučovania programovacieho jazyka Object Pascal v programovacom prostredí Lazarus na strednej škole. Keďže som sa snažil minimalizovať teóriu a sústredil som sa hlavne na riešenie cvičení, resp. praktických úloh na počítači, u žiakov sa to stretlo s veľmi pozitívnym ohlasom. Vyskúšali si samostatnú prácu, ale aj prácu v tímoch, kde si mohli vyskúšať vzájomnú kooperáciu. Najväčšie problémy žiakom robilo navrhnúť algoritmus zadaného problému. Pre učiteľov preto navrhujem, aby sa sústredili na čo najlepší rozbor zadanej úlohy so žiakmi a uistili sa, že žiaci danej úlohe porozumeli. Pomerne veľké problémy žiakom robí aj matematika. Preto učiteľom radím, aby žiakom pred tým, ako začnú riešiť konkrétny algoritmický problém, dali zopakovať príslušný matematický aparát. Súčasťou práce sú aj štyri prílohy – základné typy premenných, prvý priebežný test, druhý priebežný test a dotazník pre absolventov našej školy. Testy majú slúžiť na overenie vedomostí žiakov. Pri každom teste uvádzam aj návrh výsledného hodnotenia testu. Učiteľ si bodové hodnotenie a návrh známky podľa získaného počtu bodov môže upraviť v závislosti od typu žiakov a triedy, v ktorej učí. Táto práca bola pre mňa veľmi užitočnou pomôckou pri výučbe základov objektového programovacieho jazyka Object Pascal, ktorý je v dnešnej dobe veľmi populárny a naďalej sa mení a rozvíja. Preto som sa rozhodol túto svoju pomôcku ponúknuť aj iným učiteľom informatiky, pre ktorých môže byť prínosom.

52

53

ZOZNAM BIBLIOGRAFICKÝCH ZDROJOV

1. BLAHO, A. 2006. Programovanie v Delphi. 1. vydanie. Slovenské pedagogické nakladateľstvo – Mladé letá, s. r. o. Bratislava. 2006 ISBN: 80-10-00421-9

2. PÍSEK, S. 2002. Delphi – začínáme programovat. 2. vydanie. Grada Publishing. Praha. 2002 ISBN: 80-247-0547-8

3. SKALKA, J. 2007. Informatika na maturity a prijímacie skúšky. ENIGMA. Nitra. 2007 ISBN: 978-80-89132-50-8

Internetové zdroje

4. Lazarus [online]. http://sk.wikipedia.org, [cit. 12.10.2013]. Dostupné na www: http://sk.wikipedia.org/wiki/Lazarus

5. Object Pascal [online]. http://sk.wikipedia.org, [cit. 12.10.2013]. Dostupné na www: http://sk.wikipedia.org/wiki/Object_Pascal

6. Free Pascal a Lazarus [online]. http://pascal.input.sk, [cit. 16.10.2013]. Dostupné na www: http://pascal.input.sk/index.php/11.Prednaska

54

55

ZOZNAM PRÍLOH

Príloha 1 Základné typy premenných

Príloha 2 Prvý priebežný test

Príloha 3 Druhý priebežný test

Príloha 4 Dotazník pre absolventov

56

Príloha 1 Základné typy premenných

Typ Veľkosť Hodnoty

Boolean 1 bajt True, resp. False

Integer 4 bajty -2 147 483 648 až 2 147 483 647

Cardinal 4 bajty 0 až 4 294 967 295

Shortint 1 bajt -128 až 127

Smallint 2 bajty -32 768 až 32 767

Longint 4 bajty -2 147 483 648 až 2 147 483 647

Int64 8 bajtov -2 x 1063 až 2 x 1063-1

Byte 1 bajty 0 až 255

Word 2 bajty 0 až 65 535

Longword 4 bajty 0 až 4 294 967 295

Single 4 bajty 1.5 x 10-45 až 3.4 x 1038

Double 8 bajtov 5.0 x 10-324 až 1.7 x 10308

Extended 10 bajtov 3.6 x 10-4951 až 1.1 x 104932

Real 8 bajtov 5.0 x 10-324 až 1.7 x 10308

Char 1 bajt 1 znak ASCII (#0..#255)

String max. 255 znakov ASCII

Prameň: Písek Slavoj, 2002, s. 47-50

57

Príloha 2 Prvý priebežný test

Prvý priebežný test

Meno a priezvisko žiaka: ..........................................................

Trieda: ...............

1. Vymenujte časti, z ktorých pozostáva integrované vývojové prostredie Lazarus. (2b)

2. Vypíšte všetky čísla, ktoré môžu byť vygenerované funkciou Random(4)+2. (2b)

3. Načo slúži príkaz vetvenia case-of-else? Napíšte syntax príkazu case-of-else. (2b)

4. Napíšte syntax cyklu while-do. (1b)

5. Vytvorte program, ktorý bude obsahovať 2 tlačidlá a grafickú plochu. Stlačenie

prvého tlačidla vyfarbí grafickú plochu modrou farbou a po stlačení druhého tlačidla sa do grafickej plochy v časovom intervale 7 sekúnd budú vykresľovať elipsy pseudonáhodnej veľkosti a farby pera. Hrúbku pera nastavte na 4. Program uložte do adresára s názvom „VasePriezvisko51“ na pracovnú plochu počítača. (5b)

6. Vytvorte program na zistenie súčtu prvých n prirodzených čísel, ktorých počet zadá

užívateľ na vstupe (do Editu). Výsledok nech bude vypísaný do Labelu a akcia nech sa realizuje po stlačení tlačidla (Button). Napr. ak užívateľ na vstupe zadá hodnotu 5, program vypočíta 1+2+3+4+5 a do Labelu vypíše hodnotu 15. Program uložte do adresára s názvom „VasePriezvisko61“ na pracovnú plochu počítača. (3b)

58

Návrh výsledného hodnotenia testu:

∑

15 – 13 výborný (1) 12 – 10 chválitebný (2) 9 – 7 dobrý (3) 6 – 5 dostatočný (4) 4 – 0 nedostatočný (5) Poznámka: Učiteľ si bodové hodnotenie a návrh známky podľa získaného počtu bodov môže upraviť v závislosti od typu žiakov a triedy, v ktorej učí.

59

Príloha 3 Druhý priebežný test

Druhý priebežný test

Meno a priezvisko žiaka: ..........................................................

Trieda: ...............

1. Definujte jednorozmerné pole. Vymenujte tri vlastnosti jednorozmerného poľa. (4b)

2. Koľko znakov môžeme priradiť do dátového typu char? (1b)

3. Popíšte udalosť OnMouseMove. (1b)

4. Napíšte príkaz, ktorým zmažeme všetky položky z Listboxu. (1b)

5. Vytvorte program, ktorý s využitím grafického robota, po stlačení tlačidla, do

grafickej plochy vykreslí pravouhlý trojuholník ľubovoľných rozmerov. Trojuholník bude nakreslený zelenou farbou a hrúbku čiary bude mať nastavenú na hodnotu 3. Program uložte do adresára s názvom „VasePriezvisko52“ na pracovnú plochu počítača. (3b)

6. Vytvorte program, ktorý vypočíta obvod obdlžníka, ak sú dané dĺžky jeho strán (zadané

do Editov). Výsledok dajte vypísať do textového súboru s názvom „obdlznik.txt“. Program uložte do adresára s názvom „VasePriezvisko62“ na pracovnú plochu počítača. (5b)

60

Návrh výsledného hodnotenia testu:

∑

15 – 13 výborný (1) 12 – 10 chválitebný (2) 9 – 7 dobrý (3) 6 – 5 dostatočný (4) 4 – 0 nedostatočný (5) Poznámka: Učiteľ si bodové hodnotenie a návrh známky podľa získaného počtu bodov môže upraviť v závislosti od typu žiakov a triedy, v ktorej učí.

61

Príloha 4 Dotazník pre absolventov

Na potvrdenie a overenie prínosu programovania v programovacom jazyku Object Pascal a teda aj prínosu tejto práce pre žiakov som vypracoval dotazník, ktorý som predložil (e-mailom) absolventom našej školy, ktorí v 3. ročníku navštevovali seminár objektového programovania v IDE Lazarus. Dotazník mi vrátilo 12 absolventov. Všetci sú študentmi vysokých škôl technického zamerania. Otázka č. 1: Páčilo sa Vám programovanie v integrovanom vývojovom prostredí Lazarus?

Otázka č. 2: Dostali ste dobré základy pre ďalšie štúdium programovacieho jazyka Object Pascal v IDE Lazarus?

0

2

4

6

8

10

12

Áno Nie

Po

čet

Odpovede

Odpoveď na otázku č. 1

0

1

2

3

4

5

6

7

8

Áno Skôr áno Skôr nie Nie

Po

čet

Odpovede

Odpoveď na otázku č. 2

62

Otázka č. 3: Využili ste daný programovací jazyk aj na Vašej terajšej vysokej škole?

0

1

2

3

4

5

6

7

Áno Čiastočne Nie

Po

čet

Odpovede

Odpoveď na otázku č. 3