Vývoj objektových aplikací 2

Ostrava, 2003 Mgr. Rostislav Fojtík

2

Obsah: Úvodní lekce ............................................................................................................6

Cíl lekce................................................................................................................6 Samostatné práce..................................................................................................6 Podmínky pro přihlášení ke zkoušce....................................................................7 Obsah kurzu..........................................................................................................7 Literatura ..............................................................................................................7 Shrnutí lekce.........................................................................................................7

Opakování ................................................................................................................8 Cíl lekce................................................................................................................8 Základy objektově orientovaného programování.................................................8 Vizuální vývojové nástroje...................................................................................8 Řešený příklad......................................................................................................9 Shrnutí učiva ......................................................................................................15

Projekty I – práce s časovými údaji .......................................................................16 Cíl lekce..............................................................................................................16 Program č.1 – Jednoduché hodiny .....................................................................16

Komponenta Timer ........................................................................................16 Komponenta PopupMenu...............................................................................17

Program č.2 – Čas a datum v komponentě StatusBar ........................................20 Komponenta StatusBar...................................................................................20

Program č.3 – Jednoduchý záznamník úkolu.....................................................23 Samostatná práce................................................................................................27 Shrnutí ................................................................................................................28

Implementace OOP v jazyku Object Pascal...........................................................29 Cíl lekce..............................................................................................................29 Konstruktor.........................................................................................................31 Destruktor...........................................................................................................33 Dědičnost............................................................................................................33 Polymorfismus ...................................................................................................33 Shrnutí učiva ......................................................................................................37

Vývoj programů .....................................................................................................38 Cíle lekce............................................................................................................38

Studie..............................................................................................................38 Objektově orientovaná analýza (OOA)..........................................................38 Návrh..............................................................................................................39 Doporučení pro analýzu a návrh: ...................................................................40 Implementace .................................................................................................40 Testování ........................................................................................................40 Používání ........................................................................................................40

Časté chyby ........................................................................................................40 Shrnutí učiva ......................................................................................................41

Samostatná práce....................................................................................................42 Cíl lekce..............................................................................................................42 Zadání samostatné práce ....................................................................................42

Projekty II – grafika ...............................................................................................44 Cíle lekce............................................................................................................44 Program č.1 – Jednoduchý kreslicí program......................................................44

Komponenta Image ........................................................................................44 Třída TCanvas ................................................................................................45

3

Program č.2 – Jednoduchý kreslicí program...................................................... 47 Shrnutí učiva ...................................................................................................... 50

Projekty III – více formulářů v aplikaci................................................................. 51 Cíle lekce............................................................................................................ 51 Program č.1 – Otevírání modálních a nemodálních oken.................................. 51 Shrnutí učiva ...................................................................................................... 58

Test znalostí ........................................................................................................... 59 Cíle lekce............................................................................................................ 59 Shrnutí................................................................................................................ 60

4

Orientační symboly v textu:

Cíle, ke kterým chceme dospět. Úkoly, projekty, testy a písemné zprávy.

Otazník - průběžné otázky a úkoly.

Vykřičník - důležité pojmy a postupy.

Suma - shrnutí učební látky.

počítačů

Samostatná práce – korespondenční úkol, který je potřeba v určeném termínu zaslat tutorovi kurzu.

Zpracoval: Mgr. Rostislav Fojtík Katedra informatiky a Přírodovědecká fakulta Ostravská univerzita rostislav.fojtik@osu.cz

5

Úvodní lekce Cíl lekce Cílem této lekce je vás seznámit s organizací výukového kurzy a požadavky

pro absolvování zkoušky. Po absolvování lekce budete: • vědět, jaké lekce kurz obsahuje a kdy by jste je měli absolvovat • vědět, kdy odevzdat samostatné práce • vědět, jaké jsou požadavky pro absolvování zkoušky z předmětu "Vývoj objektových aplikací 2" Časová náročnost lekce: 30 minut

Pro zdárné absolvování kurzu "Vývoj objektových aplikací 2" jsou vhodnými

základními předpoklady znalosti z předmětů Algoritmy a datové struktury 1 a 2. Dále je nutné absolvovat výukový kurz "Vývoj objektových aplikací 1".

Cílem kurzu "Vývoj objektových aplikací 2" je rozšířit si znalosti v oblasti objektově orientovaného způsobu programování a to pomocí konkrétního, komerčně velmi rozšířeného a využívaného programovacího nástroje Delphi. Po absolvování kurzu budete umět vytvářet programy a jednoduché aplikace v jazyku Object Pascal.

Komunikace mezi všemi účastníky kurzu je velmi důležitá. Pro její zajištění slouží následující způsoby:

• e-mail - elektronická pošta. Adresa vyučujícího (lektora kurzu) je rostislav.fojtik@osu.cz. Je důležité, aby studenti během semestru neměnili své e-mailové adresy! • elektronická konference • telefonicky - telefonní spojení na vyučujícího Mgr. Rostislav Fojtík - 59 6160 229 • konzultace prezenční formou - konzultace probíhají po předcházející domluvě. Kancelář č.24, v budově na adrese 30.dubna 22, Ostrava.

Další možnosti komunikace:

• ICQ - číslo vyučujícího je 66965477 • internetová video konference - je potřeba domluvit s vyučujícím

Veškeré dotazy týkající se učiva, neposílejte na e-mail vyučujícího, ale do elektronické konference! Důvodem je možnost zapojení ostatních účastníků kurzu na řešení problémů.

Samostatné práce Během úvodního tutoriálu – setkání budou určeny termíny, podmínky a formy pro

odevzdání samostatných prací. V určeném termínu zašlete rovněž řešení testu z poslední lekce.

6

Podmínky pro přihlášení ke zkoušce Pro přihlášení ke zkoušce je potřeba zpracovat samostatný projekt, jehož zadání

najdete v poslední lekci. Zkouška z předmětu „Vývoj objektových aplikací 2“ se bude skládat ze dvou částí. První je obhajoba a rozbor vytvořeného projektu a druhou části zkoušky je předvedení znalosti z oblasti teoretických poznatků objektově orientovaného programování a práce s vizuálním vývojovým nástrojem Borland Delphi.

Obsah kurzu Výukový kurz obsahuje níže uvedené výkladové lekce. U každé lekce je uvedena

přibližná časová náročnost a datum, ke kterému by jste měli lekci absolvovat - zvládnout její učivo. Nenechávejte si studium na poslední chvíle, nestihnete absolvovat kurz! Úvodní lekce - 30 minut 5. března Opakování - 2 hodiny 12. března Projekty I - 3 hodiny 22. března Implementace OOP v jazyku Object Pascal - 3 hodiny 2.dubna Vývoj aplikací - 2 hodiny 12. dubna Samostatná práce - 1 hodina 22. dubna Projekty II - 3 hodiny 30. dubna Projekty III - 3 hodiny 6. května Test - 1 hodina 10. května

Literatura Pro dobré zvládnutí učiva je potřeba studovat i z dalších zdrojů. Velmi doporučuji

on-line kurz na stránkách Zive.cz: KADLEC V. Umíme to s Delphi, http://www.zive.cz, on-line Tištěné literatury o programování v Delphi je velké množství. Od jednoduchých a rozsahem malých příruček až po do detailů vyvedené a samozřejmě patřičně drahé učebnice. Uvádím alespoň několik vhodných publikací: LISCHNER R. Delphi v kostce, Computer Press, Praha 2000, ISBN 8072263617 CANTU M. Myslíme v jazyku Delphi 6 – 1.díl knihovna programátora, Grada 2002, ISBN 8024703343 ELLER F. Delphi 6 příručka programátora, Grada, ISBN 8024703033 SVOBODA L., VONEŠ P., KONŠAL T., MAREŠ M. 1001 tipů a triků pro Delphi, ComputerPress, 2001, ISBN 8072265296 PÍSEK S. Delphi začínáme programovat, Grada, ISBN 8024705478 TEIXERA S., PACHECO X. Mistrovství v Delphi 6, ComputerPress, 2002, ISBN 8072266276

Shrnutí lekce

• Kurz "Vývoj objektových aplikací 2" je ukončen ústní zkouškou. Ke zkoušce je potřeba přinést řešení samostatné práce. Během zkoušky je potřeba dané řešení umět vysvětlit a případně obhájit.

7

Opakování

Cíl lekce Cílem této lekce je zopakovat si znalosti z minulého kurzu „Vývoj

objektových aplikací 1“. Po absolvování lekce budete: • zopakujete si základní poznatky objektově orientovaného programování • vědět, jak správně zpracovat úkol č.3 z lekce Samostatné práce výukového kurzu „Vývoj objektových aplikací 1“. Časová náročnost lekce: 2 hodiny

Základy objektově orientovaného programování Základní tezí objektově orientovaného programování (OOP) je používání objektů,

které nejsou určeny jen množinou dat, ale rovněž množinou přesně stanovených a definovaných operací, které objekt může provádět. Během analýzy programu se snažíme vytvořit a popsat objekty, které v rámci programu mají vzniknout. Objekty mezi sebou komunikují a posílají si zprávy, reagují na události.

Základní vlastnosti OOP: 1. Zapouzdření (Encapsulation) - základním pojmem OOP je třída (class), která v

sobě zahrnuje data a operace. Konkrétní výskyt třídy je instance třídy (objekt). 2. Dědičnost (Inheritance) - Možnost odvozovat nové třídy, které dědí data a

metody z jedné nebo více tříd. V odvozených třídách je možno přidávat nebo předefinovávat nová data a metody.

3. Polymorfismus - Česky možno vyjádřit přibližně pojmem "vícetvarost". Umožňuje jediným příkazem zpracovávat "podobné" objekty.

Základní pojmy: Třída - je typ definován uživatelem, který se nachází v nějakém stavu, má

reprezentaci a chování. Třída je podobná datovému typu. Objekt (instance třídy) - je již proměnná určitého datového typu, který je

definován třídou. Objekt je konkrétní místo v paměti. Vizuální vývojové nástroje Grafické operační systémy kladou stále větší nároky na programátory, kteří kromě

naprogramování samotného problému řešeného v programu, musí zajistit interface aplikace podle grafického prostředí. Neustálým zvyšování nároků na rychlost vývoje aplikací a zároveň zvyšováním nároků na délku a složitost kódu se postupně dospělo k vizuálním programovacím nástrojům, které se také nazývají RAD. Mezi nejznámější produkty pro prostředí MS Windows patří Visual Basic, Power++, Delphi, C++Builder a další. Pro operační systém Linux existuje linuxová verze Delphi s názvem Kylix.

Všechny tyto nástroje využívají předem naprogramované knihovny grafických komponent. Jedná se o objekty, které kromě základních vlastností (např. jméno, rozměry, barva, font textu, ...) umí rovněž reagovat na určité události vyvolané v operačním systému (např. kliknutí tlačítkem myši, zmáčknutí určité klávesy, přesun myši...) a zároveň mají předdefinované metody - schopnosti provádět určitou činnost (např. zrušit objekt, smazat svůj obsah, ...).

8

V našem kurzu budeme nadále využívat vývojový nástroj firmy Borland s názvem Delphi, který využívá k psaní kódu objektově orientovaný programovací jazyk Object Pascal.

Řešený příklad Podívejme se na možné řešení úkolu č.3 z lekce Samostatné práce (Vývoj

objektových aplikací 1). Zadání znělo: Vytvořte program, u kterého bude měnit font nápisu v okně programu. Program

bude obsahovat minimálně tyto objekty: • Label - v něm bude umístěn text, který se bude měnit • GroupBox č.1 a vněm tři objekty typu RadioButton, pomocí kterých budeme měnit barvu textu (černá, modrá, zelená) • GroupBox č.2 a v něm tři objekty typu CheckBox, pomocí kterých budeme měnit styl textu (tučné, kurzíva, podtržené) • ComboBox - pomocí kterého budeme nastavovat velikost písma v hodnotách 8, 10, 12, 14, 20, 24

Ukázka zdrojových textů:

Soubor Unit1.pas // Mgr. Rostislav Fojtík // Úkol č.3 – Samostatná práce VOA1 // Odladěno v Delphi 7 unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) LblNapis: TLabel; ChBoxBold: TCheckBox;

9

ChBoxItalic: TCheckBox; ChBoxUnderline: TCheckBox; RBtnArial: TRadioButton; RBtnCourierNew: TRadioButton; RBtnTimesNewRoman: TRadioButton; ComboBoxSize: TComboBox; procedure ChBoxBoldClick(Sender: TObject); procedure ChBoxItalicClick(Sender: TObject); procedure ChBoxUnderlineClick(Sender: TObject); procedure RBtnArialClick(Sender: TObject); procedure RBtnCourierNewClick(Sender: TObject); procedure RBtnTimesNewRomanClick(Sender: TObject); procedure ComboBoxSizeChange(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.ChBoxBoldClick(Sender: TObject); begin {přidá nebo ubere style Bold – tučné písmo} if ChBoxBold.checked= true then LblNapis.Font.Style:=LblNapis.Font.Style + [fsBold] else LblNapis.Font.Style:=LblNapis.Font.Style - [fsBold]; end; procedure TForm1.ChBoxItalicClick(Sender: TObject); begin {přidá nebo ubere style Italic – kurzíva} if ChBoxItalic.checked= true then LblNapis.Font.Style:=LblNapis.Font.Style + [fsItalic] else LblNapis.Font.Style:=LblNapis.Font.Style - [fsItalic]; end; procedure TForm1.ChBoxUnderlineClick(Sender: TObject); begin {přidá nebo ubere style Underline – podtržené písmo} if ChBoxUnderline.checked= true then LblNapis.Font.Style:=LblNapis.Font.Style + [fsUnderline] else LblNapis.Font.Style:=LblNapis.Font.Style - [fsUnderline]; end; procedure TForm1.RBtnArialClick(Sender: TObject); begin LblNapis.Font.Name:='Arial';{změní font na Arial} end;

10

procedure TForm1.RBtnCourierNewClick(Sender: TObject); begin LblNapis.Font.Name:='Courier New'; {změní font na Courier New} end; procedure TForm1.RBtnTimesNewRomanClick(Sender: TObject); begin LblNapis.Font.Name:='Times New Roman'; {změní font na Times New Roman} end; procedure TForm1.ComboBoxSizeChange(Sender: TObject); begin LblNapis.Font.Size:= StrToInt(ComboBoxSize.Items[ComboBoxSize.ItemIndex]); {změní velikost fontu písma podle vybraného čísla v ComboBoxu} end; end. //*** konec unity Unit1 ***

Soubor Project1.dpr program Project1; uses Forms, Unit1 in 'Unit1.pas' {Form1}; {$R *.res} begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end. //*** konec souboru Project1.dpr ***

Soubor Unit1.dfm object Form1: TForm1 Left = 192 Top = 107 Width = 603 Height = 238 Caption = 'CheckBox a RadioButton' Color = clBtnFace Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'MS Sans Serif' Font.Style = [] OldCreateOrder = False PixelsPerInch = 96 TextHeight = 13

11

object LblNapis: TLabel Left = 56 Top = 14 Width = 71 Height = 14 Caption = 'Rostislav Fojt'#237'k' Font.Charset = EASTEUROPE_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'Arial' Font.Style = [] ParentFont = False end object ChBoxBold: TCheckBox Left = 32 Top = 64 Width = 97 Height = 17 Caption = 'Bold' Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'MS Sans Serif' Font.Style = [fsBold] ParentFont = False TabOrder = 0 OnClick = ChBoxBoldClick end object ChBoxItalic: TCheckBox Left = 32 Top = 104 Width = 97 Height = 17 Caption = 'Italic' Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'MS Sans Serif' Font.Style = [fsItalic] ParentFont = False TabOrder = 1 OnClick = ChBoxItalicClick end object ChBoxUnderline: TCheckBox Left = 32 Top = 145 Width = 97 Height = 17 Caption = 'Underline' Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'MS Sans Serif' Font.Style = [fsUnderline] ParentFont = False TabOrder = 2

12

OnClick = ChBoxUnderlineClick end object RBtnArial: TRadioButton Left = 208 Top = 64 Width = 113 Height = 17 Caption = 'Arial' Checked = True Font.Charset = EASTEUROPE_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'Arial' Font.Style = [] ParentFont = False TabOrder = 3 TabStop = True OnClick = RBtnArialClick end object RBtnCourierNew: TRadioButton Left = 208 Top = 105 Width = 113 Height = 17 Caption = 'Courier New' Font.Charset = EASTEUROPE_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'Courier New' Font.Style = [] ParentFont = False TabOrder = 4 OnClick = RBtnCourierNewClick end object RBtnTimesNewRoman: TRadioButton Left = 208 Top = 146 Width = 113 Height = 17 Caption = 'Times New Roman' Font.Charset = EASTEUROPE_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'Times New Roman' Font.Style = [] ParentFont = False TabOrder = 5 OnClick = RBtnTimesNewRomanClick end object ComboBoxSize: TComboBox Left = 416 Top = 64 Width = 145 Height = 19 Style = csOwnerDrawFixed ItemHeight = 13

13

TabOrder = 6 OnChange = ComboBoxSizeChange Items.Strings = ( '8' '10' '12' '14' '20' '24') end end //*** konec souboru Unit1.dfm ***

14

Shrnutí učiva • Základními pojmy objektově orientovaného programování jsou třída (class) a objekt – instance třídy. • Základními vlastnostmi objektově orientovaného programování jsou zapouzdření, dědičnost a polymorfismus. • K usnadnění vývoje aplikací v operačních systémech s grafickým rozhraním se stále více využívají vizuální programovací nástroje, které disponují rozsáhlou zásobou předdefinovaných grafických a jiných komponent, které programátor umisťuje do svých aplikací.

Rejstřík class dědičnost Delphi instance třídy komponenty objekt polymorfismus třída vizuální programovací nástroj zapouzdření

15

Projekty I – práce s časovými údaji

Cíl lekce Cílem této lekce je vás seznámit se základními postupy při práci

s komponentou Timer. Po absolvování lekce budete: • vědět, jak pracovat s komponentou Timer • vědět, jak pracovat s komponentou StatusBar • vytvoříte si jednoduchou aplikaci, která bude ukazovat aktuální čas • vytvoříte si jednoduchou aplikaci, která bude sloužit jako záznamník úkolu

Časová náročnost lekce: 3 hodiny

Program č.1 – Jednoduché hodiny Zadání: Vytvořte aplikaci, která bude ukazovat aktuální čas. Okno, ve kterém budou

časové údaje, nebude mít rámeček a bude stále vidět. Kliknutím pravého tlačítka myši na plochu formuláře se vyvolá plovoucí nabídka, která bude obsahovat volbu pro ukončení aplikace.

Na následujícím obrázku vidíte možné grafické řešení programu.

Řešení

Komponenta Timer Pro práci s časovými údaji využijeme komponentu Timer, která se nachází

v záložce Standard.

Komponenta Timer má následující vlastnosti:

Enabled – určuje, zda je komponenta aktivní nebo ne Interval – určuje interval práce Timeru. Hodnota se udává v milisekundách. Necháme-li hodnotu 1000, bude komponenta pracovat jedenkrát za sekundu. Name Tag

16

Komponenta PopupMenu Další komponentou, kterou budeme potřebovat je PopupMenu ze záložky

Standard. Komponenta slouží k vyvolání plovoucí nabídky.

Kontrolní úkol Prohlédněte si v nápovědě další vlastností a metody komponenty PopupMenu. Obě komponenty můžeme umístit kdekoliv do formuláře, neboť po spuštění

programu nejsou vidět.

Na dalším obrázku vidíte seznam všech použ

lCifernik: TLabel;

pMenu;

Soubor Unit1.pas // Jed

ík, 2002

es ows, Messages, SysUtils, Variants, Classes, Graphics, Controls,

itých komponent. LbTimer1: TTimer; PopupMenu1: TPopu mpKonec: TMenuItem;

noduché hodiny // Mgr. Rostislav Fojt// Odladěno v Borland Delphi 7.0 nit Unit1; u nterface i us Wind Forms, Dialogs, ExtCtrls, StdCtrls, Menus;

17

type TFrmHodiny = class(TForm)

lCifernik: TLabel;

; m;

der: TObject); Sender: TObject);

ject);

utton:

FrmHodiny: TFrmHodiny;

rmHodiny.Timer1Timer(Sender: TObject); gin

brazování času. Je potřeba časový údaj převést na řetězec.

ure TFrmHodiny.FormCreate(Sender: TObject); gin

ři vytvoření okna a ne až po 1 sekundě.

ure TFrmHodiny.LblCifernikDblClick(Sender: TObject); gin

jklikem dojde k uzavření aplikace.

ure TFrmHodiny.mpKonecClick(Sender: TObject); gin

ure TFrmHodiny.LblCifernikMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

upMenu1.Popup(FrmHodiny.Left+X,FrmHodiny.Top+Y); ápovědy, klikneme-li pravým tlačítkem na

Lb Timer1: TTimer; PopupMenu1: TPopupMenu mpKonec: TMenuIte procedure Timer1Timer(Sen procedure FormCreate( procedure LblCifernikDblClick(Sender: TOb procedure mpKonecClick(Sender: TObject); procedure LblCifernikMouseDown(Sender: TObject; BTMouseButton; Shift: TShiftState; X, Y: Integer); private { Private declarations } public { Public declarations } end; var implementation {$R *.dfm} procedure TFbe LbLCifernik.Caption:=TimeToStr(Time); // Zoend; procedbe LbLCifernik.Caption:=TimeToStr(Time); // Čas se zobrazí již pend; procedbe Application.Terminate; // Dvoend; procedbe Application.Terminate; end; proced begin if (Button=mbRight) then Pop{zajistí vyvolání plovoucí nformulář} end; end.

18

Soubor Unit1.pas object FrmHodiny: TFrmHodiny

= bsNone

ULT_CHARSET

TLabel

5

row 0'

_CHARSET

rif'

nikDblClick

Menu1: TPopupMenu

nec: TMenuItem

ezapomeňte správně nastavit vlastnosti formuláře podle zadání. Pro vytvoření formul

astavit vlastnost FormStyle:

Left = 177 Top = 154

e BorderStyl Caption = 'Hodiny' ClientHeight = 36 ClientWidth = 136 Color = clBlue

DEFA Font.Charset = Font.Color = clWindowText Font.Height = -11

ns Serif' Font.Name = 'MS Sa Font.Style = []

ayOnTop FormStyle = fsSt OldCreateOrder = False OnCreate = FormCreate PixelsPerInch = 96 TextHeight = 13

ik: object LblCifern Left = 2 Top = 0

14 Width = Height = 37 Cursor = crAr Caption = '00:00:0 Color = clBlue

DEFAULT Font.Charset = Font.Color = clYellow Font.Height = -31

ns Se Font.Name = 'MS Sa Font.Style = [fsBold] ParentColor = False ParentFont = False

er OnDblClick = LblCif OnMouseDown = LblCifernikMouseDown end

ct Timer1: TTimer obje OnTimer = Timer1Timer Left = 120 Top = 16 end

ct Popup obje Left = 96 Top = 16

Ko object mp Caption = 'Konec'

lick OnClick = mpKonecC end end end

Náře bez okraje nastavte vlastnost BorderStyle:

BorderStyle = bsNone stále v popředí je potřeba nChceme-li, aby okno bylo

FormStyle = fsStayOnTop

19

Program č.2 – Čas a datum v komponentě StatusBar

plikaci, která bude ukazovat aktuální čas a datum v komponentě StatusB

Zadání: Vytvořte aar.

Komponenta StatusBar vat s komponentou StatusBar. Komponentu můžeme

nalézt vNejprve si ukažme, jak praco záložce Win32.

Pokud chceme StatusBar rozdělit na více části, musíme nastavit vlastnost Panels.

U každého panelu pak určíme jeho šířku pomoci vlastnosti Width. Dále nás bude zajímat vlastnost Text, která určí, jaký nápis se objeví na příslušném panelu.

20

Kontrolní úkol Prohlédněte si v nápovědě další vlastností a metody komponenty StatusBar. Prostudujte si v nápovědě následující metody

TimeToStr(Time) {Změní čas na řetězec} DateToStr(Date) {Změní datum na řetězec}

Soubor Unit1.pas unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, ComCtrls; type TForm1 = class(TForm) StatusBar1: TStatusBar; Timer1: TTimer; procedure Timer1Timer(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm}

21

procedure TForm1.Timer1Timer(Sender: TObject); begin StatusBar1.Panels[0].Text:=TimeToStr(Time); StatusBar1.Panels[1].Text:=DateToStr(Date); {zobrazení času a data v panelech StatusBaru} end; end.

Soubor Unit1.dfm object Form1: TForm1 Left = 192 Top = 107 Width = 275 Height = 132 Caption = #268'as a datum' Color = clBtnFace Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'MS Sans Serif' Font.Style = [] OldCreateOrder = False OnCreate = Timer1Timer PixelsPerInch = 96 TextHeight = 13 object StatusBar1: TStatusBar Left = 0 Top = 86 Width = 267 Height = 19 Panels = < item Width = 70 end item Width = 50 end> end object Timer1: TTimer OnTimer = Timer1Timer Left = 176 Top = 32 end end

22

Program č.3 – Jednoduchý záznamník úkolu Zadání: Vytvořte program, který bude sloužit jako jednoduchý záznamník pro jeden úkol.

Do připraveného formuláře zapíše uživatel text, čas a datum úkolu (schůzky). Formulář se následně minimalizuje.

Po uplynutí času se objeví druhé okno se zněním úkolu.

Soubor Unit1.pas unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls; type TUkol=record Text:string[200]; hod,min,den,mes,rok:word; aktivni:boolean;{určuje, zda upozornění bylo provedeno} end; TFrmPlanovac = class(TForm) EditUkol: TEdit; EditHodiny: TEdit; LblHodiny: TLabel; EditMinuty: TEdit; Label1: TLabel; EditDen: TEdit; Label2: TLabel;

23

EditMesic: TEdit; Label3: TLabel; EditRok: TEdit; Label4: TLabel; BtnOK: TButton; BtnKonec: TButton; Timer1: TTimer; procedure BtnKonecClick(Sender: TObject); procedure BtnOKClick(Sender: TObject); procedure Timer1Timer(Sender: TObject); procedure JenProCteni(h:boolean); procedure SmazatEdity; private { Private declarations } public { Public declarations } end; var FrmPlanovac: TFrmPlanovac; ukol:TUkol; implementation uses Unit2; {$R *.dfm} procedure TFrmPlanovac.JenProCteni(h:boolean); begin {nastavíme edity podle parametru ‘h’} EditUkol.ReadOnly:=h; EditHodiny.ReadOnly:=h; EditMinuty.ReadOnly:=h; EditDen.ReadOnly:=h; EditMesic.ReadOnly:=h; EditRok.ReadOnly:=h; end; procedure TFrmPlanovac.SmazatEdity; begin //smazani editu EditUkol.Clear; EditHodiny.Clear; EditMinuty.Clear; EditDen.Clear; EditMesic.Clear; EditRok.Clear; EditUkol.SetFocus; end; procedure TFrmPlanovac.BtnKonecClick(Sender: TObject); begin Application.Terminate; end;

24

procedure TFrmPlanovac.BtnOKClick(Sender: TObject); begin ukol.Text:=EditUkol.Text; ukol.hod:=StrToInt(EditHodiny.Text); ukol.min:=StrToInt(EditMinuty.Text); ukol.den:=StrToInt(EditDen.Text); ukol.mes:=StrToInt(EditMesic.Text); ukol.rok:=StrToInt(EditRok.Text); ukol.aktivni:=false; FrmPlanovac.WindowState:=wsMinimized; JenProCteni(true); end; procedure TFrmPlanovac.Timer1Timer(Sender: TObject); var cas:TDateTime; h,mn,s,ss,d,ms,r:word; begin Cas:=Now; DecodeDate(cas,r,ms,d); DecodeTime(cas,h,mn,s,ss); if (ukol.aktivni=false) then if (ukol.min=mn) then if (ukol.hod=h) then if (ukol.den=d) then if (ukol.mes=ms) then if (ukol.rok=r) then begin ukol.aktivni:=true; JenProCteni(false); SmazatEdity; FrmUkol.EditUkol.Text:=ukol.Text; FrmUkol.ShowModal; {otevře okno s upozorněním} end; end; end.

Soubor Unit2.pas unit Unit2; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TFrmUkol = class(TForm) EditUkol: TEdit; BtnOK: TButton; procedure BtnOKClick(Sender: TObject); private { Private declarations } public { Public declarations } end;

25

var FrmUkol: TFrmUkol; implementation {$R *.dfm} procedure TFrmUkol.BtnOKClick(Sender: TObject); begin close; end; end.

Soubor Project1.dpr program Project1; uses Forms, Unit1 in 'Unit1.pas' {FrmPlanovac}, Unit2 in 'Unit2.pas' {FrmUkol}; {$R *.res} begin Application.Initialize; Application.CreateForm(TFrmPlanovac, FrmPlanovac); Application.CreateForm(TFrmUkol, FrmUkol); Application.Run; end.

26

Úkol Upravte předcházející program podle níže uvedeného obrázku. Přidejte tlačítko

„Nový“, kterým zajistíte záznam nového úkolu. Ve StatusBaru nechejte zobrazovat aktuální čas.

Samostatná práce Upravte předcházejí program tak, aby se do něj dalo zapisovat více úkolů

(maximálně 100). U jednotlivých úkolů půjde nastavit datum a čas, prioritu a text. Jednotlivé úkoly se budou zapisovat do souboru a zároveň pro přehlednost do ListBoxu. Pro výběr priority úkolu můžete použít komponentu SpinEdit, kterou můžete nalézt v záložce Samples. Vybraný úkol bude možné ze seznamu zrušit.

Prohlédněte si obrázek možného grafického řešení aplikace.

Své řešení zašlete v určeném termínu na adresu tutora kurzu. Termín odevzdání bude určen na úvodním tutoriálu. Zašlete všechny zdrojové soubory, které jsou potřebné pro překompilování do spustitelného tvaru. Soubory pošlete zkomprimovány například ve formátu ZIP.

27

Shrnutí

• Pro práci s časovými údaji slouží komponenta Timer. • Komponenta StatusBar slouží k zobrazování pomocných informací. Nejčastěji se umísťuje ve spodní části formuláře. • Komponenta PopupMenu slouží k zobrazení plovoucí nabídky, která se vyvolává stiskem pravého tlačítka. • Nezapomeňte v určeném termínu zaslat na adresu tutora kurzu zdrojové soubory vaší samostatné práce.

Rejstřík PopupMenu SpinEdit StatusBar Timer

28

Implementace OOP v jazyku Object Pascal Cíl lekce Cílem této lekce je vás seznámit se základními postupy při vytváření tříd a

jejich instancí. Po absolvování lekce budete: • vědět, jak definovat třídu • umět vytvářet konstruktory a destruktory třídy • umět volat konstruktory a destruktory jednotlivých objektů Časová náročnost lekce: 3 hodiny

Programovací jazyk Object Pascal firmy Borland vychází ze standardního jazyka

Pascal, který v sedmdesátých letech minulého století navrhl Niclaus Wirth. Navazuje na možnostmi programovacích nástrojů Turbo Pascal 7.0 a Borland Pascal 7.0. Již od verze 5.5 firma Borland zavedla, i když s jistými omezeními, možnosti objektově orientovaného programování. Jazyk Object Pascal je s uvedenými produkty zpětně kompatibilní (lze využívat některé programové konstrukce a kódy).

Třídu lze v jazyku Object Pascal tvořit dvěma způsoby. Z důvodu zpětné kompatibility, lze používat pro vytvoření třídy klíčové slovo object (přebráno z předchozích verzí jazyka Borland Pascal). Tento způsob nedoporučuji, neboť vede k záměně pojmů třída a objekt. Nověji je přidáno klíčové slovo class.

Příklad: type TCas = class private hod, min, sek : integer; public construktor Init(h,m,s:integer); procedure ZmenHod(h:integer); procedure ZmenMin(h:integer); procedure ZmenSek(h:integer); function DejHod:integer;

function DejMin:integer; function DejSek:integer;

end; Uvedená třída může sloužit k vytváření objektů, které mohou zpracovávat časové

údaje. Dané objekty však s časem mohou provádět jen operace definované v dané třídě, čímž nemůže dojít k nepatřičným operacím. Atributy hod, min, sek obsahují údaje o hodině, minutě a sekundě. Tím, že jejich přístupová práva jsou nastavena na private, není možné k nim z vnějšku objektu přistupovat přímo, ale jen pomocí veřejných (public) přístupových metod. Data takto chráníme před neoprávněnými operacemi.

Object Pascal využívá následujících specifikátorů přístupu: • private – takto označené vlastnosti a metody nejsou přímo přístupné z vnějšku třídy (objektu) • public – veřejné vlastnosti a metody jsou přímo přístupné mimo třídu (objekt) • protected – k chráněným položkám se může přímo přistupovat jen uvnitř samotné třídy nebo v dědicích

29

• published – zvláštní přístupová práva Object Pascalu. Vlastnosti nebo metody jsou přístupné nejen za běhu, ale i při tvorbě aplikace. Pro aplikaci se chovají podobně jako public.

Metoda construktor Init(h,m,s:integer); je speciální procedura, která se nazývá konstruktor a slouží k vytvoření (přidělení

paměti) a inicializaci (nastavení hodnot) daného objektu. Jednotlivé metody, které jsme ve třídě deklarovali, je potřeba také definovat.

construktor TCas.Init(h,m,s:integer); begin hod:=h; min:=m; sek:=s; {přiřazení hodnoty lze ošetřit proti chybným údajům} end; procedure TCas.ZmenHod(h:integer); begin hod:=h; end; procedure TCas.ZmenMin(h:integer); begin min:=m; end; procedure TCas.ZmenSek(h:integer); begin sek:=h; end; function TCas.DejHod:integer; begin DejHod:=hod; end; function TCas.DejMin:integer; begin DejMin:=min; end; function TCas.DejSek:integer; begin DejSek:=sek; end;

Všimněte si, že každá metoda má v hlavičce přidáno ještě jméno třídy. Bez tohoto jména by se jednalo o samostatnou řadovou funkci nebo proceduru, která nesouvisí s žádnou třídou. V okamžiku, kdy nadefinujeme všechny metody, můžeme vytvořit jednotlivé instance: var ted:TCas; begin

ted:=TCas.Init(12,10,30); {volání konstruktoru} ted.ZmenSek(40); {změní hodnotu sekund} Vypis(ted.DejHod, ted.DejMin, ted.DejSek); {vypíše čas; předpokládáme, že máme definovanou proceduru Vypis} ted.hod:=13; {CHYBA! Nelze! Neboť atribut hod je private} end.

30

Příklad: Upravte předcházející kód tak, aby zadávané hodnoty byly správně. Zadáme-li

například sekund více než 59, pak se rovněž upraví počet minut. V rámci vývojového nástroje Delphi je aplikace tvořena několika základními typy

souborů se zdrojovými kódy. Prvním typem je soubor s příponou DPR (delphi project), který uchovává informace o projektu. Soubory s příponou PAS obsahují jednotlivé jednotky (unit). Jejich překladem vznikají soubory s příponou DCU. Přípona DFM charakterizuje soubory, které obsahují informace o daných formulářích (oknech) aplikace. Soubory s příponou RES jsou tzv. resource soubory, které jsou binární soubory spojené s projektem, obsahující jeho ikonu.

Jednotlivé jednotky (unit) mají následující strukturu:

unit Nazev; interface uses {následuje výčet unit potřebných pro činnost}; type {následují definice tříd a dalších datových typů} var {následuje výčet instancí a dalších proměnných} implementation {$R *.DFM} {zde jsou uvedeny definice všech metod a řadových funkcí} end.

Jazyk Object Pascal umožňuje pouze jednoduchou dědičnost. Rodič se při

vytváření potomka zapisuje za klíčové slovo class do závorek. Příklad:

type TridaPotomek = class (TridaRodic) {seznam položek třídy} end;

Kromě tří výše uvedených přístupových práv zavádí Delphi specifikaci

published. Tato volba je implicitní a klíčové slovo nemusí být uváděno. Položky v této sekci jsou přístupné v Object Inspectoru. Součásti třídy, které definujeme jako published jsou přístupny nejen za běhu, ale i při tvorbě aplikace. Položky jsou viditelné podobně jako položky public.

Konstruktor Konstruktory jsou velmi důležitými metodami třídy. Pokud programovací jazyk

neumí vytvářet implicitní konstruktor, je potřeba, aby jej definoval sám programátor. Metoda konstruktor je uvozena klíčovým slovem constructor a účelem konstruktoru je vytvoření objektu – instance třídy. To znamená, že musí zajistit pro objekt příslušný kus paměti, případně inicializovat určené položky (viz. příklad s třídou TCas).

Pokud nedefinujeme svůj vlastní konstruktor, například, abychom inicializovali vnitřní data – vlastnosti objetu, můžeme využít tzv. implicitního konstruktoru. Ten nemusíme ve třídě zavádět a definovat, ale musíme jej zavolat (viz. příklad).

31

Příklad: TZaznam = class

obje

e

private index : integer; public procedure ZmenIndex(i:integer); function DejIndex:integer; end; var zaznam : Tzaznam; begin {definování objektu pomocí implicitního konstruktoru} zaznam:=TZaznam.Create; . . . {další příkazy} end;

Je možné však definovat vlastní konstruktor, který kromě vymezení paměti pro

kt může rovněž nastavit hodnoty požadovaných položek objektů.

Příklad: Type TZaznam = class private index : integer; public constructor Create(i:integer); procedure ZmenIndex(i:integer); function DejIndex:integer; end; constructor TZaznam.Create(i:integer); begin if (i>=1) AND (i<100) then index := i else index := 0; end; procedure TZaznam.ZmenIndex(i:integer); begin if (i>=1) AND (i<100) then index := i else index := 0; end; var zaznam : Tzaznam; begin {definování objektu pomocí vlastního konstruktoru} zaznam:=TZaznam.Create(10); . . . {další příkazy} end;

Pokud se pozorně podíváte na konstruktor Create a metodu ZmenIndex, zjistíte, žmají stejný vnitřní kód. To by mohlo vést k mylnému závěru, že jedna z metod je zbytečná. Toto je však chybná úvaha, neboť konstruktor se pro daný objekt volá právě jednou! Konstruktor pro jeden objekt nelze volat vícekrát. To by znamenalo snahu o mnohanásobné vytvoření jediného objektu. Naproti tomu metoda ZmenIndex nenahradí

32

volání konstruktoru, neboť nevytvoří v paměti potřebný prostor pro objekt. Bez zavolání konstruktoru objekt vlastně nevznikne, neboť mu není přiděleno místo v paměti!

Destruktor Úkolem metody zvané destruktor je zrušit objekt – instanci třídy a uvolnit paměť.

Tedy přesně opačná činnost než provádí konstruktor. Implicitní název konstruktoru je Free.

V našem předcházejícím příkladu by se objekt rušil následujícím způsobem: zaznam.Free; {volání destruktoru}

Dědičnost Dědičnost patří k velmi silným nástrojům objektově orientovaných jazyků. Object

Pascal patří mezi programovací nástroje, které podporují pouze jednoduchou dědičnost. Následující ukázka zavádí třídu TZamestnanec, která je dědicem třídy TOsoba. type TZamestnanec = vlase (TOsoba) //zde jsou umístěny vlastnosti a metody třídy TZamestnanec end;

Polymorfismus Polymorfismus souvisí s tzv. včasnou (někdy nazývanou statickou) a pozdní

(dynamickou) vazbou. Představme si například třídy TOsoba a jejího dědice třídu TStudent. V obou třídách si vytvoříme metodu se stejným názvem i parametry, ale v každé třídě bude tato metoda provádět jinou činnost. Jako příklad si můžeme ukázat metodu Vypis, která vypíše údaje o osobě nebo studentovi. type TOsoba = class //vlastnosti a metody procedure Vypis; virtual; end; TStudent = class(TOsoba) //vlastnosti a metody procedure Vypis; override; end; var p:^Tosoba;

V případě, že se pokusíme vytvořit dynamický seznam a do něj ukládat objekty třídy TOsoba i TStudent, je nutné metodu Vypis definovat jako virtuální metodu. Pokud bychom tak neučinili, pak by se uplatnila vždy včasná vazba. To znamená, že by se nezávisle na vytvořené instanci vždy použila metoda Vypis ze třídy TOsoba. Při pozdní vazbě se pro danou třídu vytváří tabulka virtuálních metod (Virtual Method Table). Každý objekt obsahuje vnitřní ukazatel do této tabulky a příslušná metoda se vybere až po alokaci paměti.

Kromě klíčových slov virtual a override se využívá ještě slovo abstrakt, které deklaruje metody, jenž budou definovány až v potomcích současné třídy.

33

Příklad: Vytvořte program, ve kterém si vyzkoušíte přidávání (vytváření) objektů a jejich

následné rušení. Pro objekty vytvořte speciální třídu, která bude obsahovat index (číslo) vytvořeného objektu. Indexy objektů vypisujte v ListBoxu.

Soubor Hlavni.pas // První unita

// Příklady v Delphi // Mgr. Rostislav Fojtík, 2002 // odladěno v Borland Delphi 6 unit hlavni; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, trida; {připjení unity trida} type TFrmClass = class(TForm) ListBoxObjekty: TListBox; BtnKonec: TButton; BtnNovy: TButton; BtnZrusit: TButton; procedure BtnKonecClick(Sender: TObject); procedure FormCreate(Sender: TObject); procedure BtnNovyClick(Sender: TObject); procedure BtnZrusitClick(Sender: TObject); private { Private declarations } public { Public declarations } end;

34

var FrmClass: TFrmClass; index:integer; zaznamy: array[1..100] of TZaznam; zaznam : TZaznam; implementation {$R *.dfm} procedure TFrmClass.BtnKonecClick(Sender: TObject); begin Application.Terminate; end; procedure TFrmClass.FormCreate(Sender: TObject); begin index:=0; end; procedure TFrmClass.BtnNovyClick(Sender: TObject); begin index:=index + 1; zaznamy[index]:=TZaznam.Create(index); {volání explicitního konstruktoru} ListBoxObjekty.Items.Add('Objekt s vnitřní hodnotou indexu = ' + IntToStr(zaznamy[index].DejIndex)); if index > 0 then BtnZrusit.Enabled:=true; if index > 99 then BtnNovy.Enabled:=false; end; procedure TFrmClass.BtnZrusitClick(Sender: TObject); begin zaznamy[index].Free; {volání destruktoru} index := index -1; ListBoxObjekty.Items.Delete(index); if index = 0 then BtnZrusit.Enabled:=false; if (index >= 0) and (index< 100) then BtnNovy.Enabled:=true; end; end. //*** konec unity Hlavni ***

Soubor Trida.pas // Druhá unita // Příklady v Delphi // Mgr. Rostislav Fojtík, 2002 // odladěno v Borland Delphi 6 unit trida; interface type TZaznam = class private index : integer; public constructor Create(i:integer); procedure ZmenIndex(i:integer); function DejIndex:integer; end;

35

implementation constructor TZaznam.Create(i:integer); begin if (i>=1) AND (i<100) then index := i else index := 0; end; procedure TZaznam.ZmenIndex(i:integer); begin if (i>=1) AND (i<100) then index := i else index := 0; end; function TZaznam.DejIndex:integer; begin DejIndex:=index; end; end. //*** konec unity Trida ***

36

Shrnutí učiva • Třída je uvozena klíčovým slovem class. Jednotlivé vlastnosti a metody třídy mají pomocí klíčových slov private, public, published a protected určeny přístupová práva. • Pro vytvoření objektu – instance třídy je potřeba zavolat implicitní nebo explicitní konstruktor. Konstruktor je speciální metoda, která se stará o vytvoření objektu (vyhrazení potřebného paměťového prostoru, případně inicializace určených vlastností). • Při rušení objektu se volá metoda s názvem destruktor.

Rejstřík class destruktor konstruktor ListBox metoda private protected public publisher tabulka virtuálních metod třída virtual

37

Vývoj programů

Cíle lekce Cílem lekce je seznámit se s mechanizmem tvorby aplikací, jednotlivými

fázemi analýzy a vývoje.

Po absolvování lekce budete: • vědět v jakých fázích se vyvíjí aplikace • umět provádět objektovou analýzu a návrh aplikace • umět lépe navrhovat a vytvářet své programy

Časová náročnost lekce: 2 hodiny

Vývoj každého programu se děje v několika základních fázích:

1. Studie 2. Analýza 3. Návrh 4. Implementace 5. Testování 6. Používání

Během všech kroků je potřeba pamatovat na tvorbu důkladné a dostatečně obsáhlé dokumentace, bez které nelze udržet přehled o vytvářeném programu a bude téměř nemožné jej po času upravovat a doplňovat.

Studie Studie představuje analýzu požadavků (requirement analysis) na aplikaci. Jedná se

o společnou činnost zákazníka a softwarové firmy, která aplikaci vytváří. V této fázi je potřeba důkladně a zcela přesně definovat požadavky zákazníka na vytvářenou aplikaci. Nejasné zadání může vést k tomu, že výsledný produkt nebude odpovídat původním představám zadavatele!

Objektově orientovaná analýza (OOA) Mechanismus abstrakce a hierarchie. Je potřeba nalézt objekty a skupiny

příbuzných objektů z reálného světa požadované aplikace. Dále je nutné popsat vazby mezi objekty. Jedná se o implementačně nezávislou fázi vývoje aplikace, která dává možnost přenositelnosti. Výsledkem této fáze je objektový model aplikace. Model objektu je zobecněný konečný automat (state machine), jehož stav je dán konkrétními hodnotami atributů. Vstupy – odpovídají metodám, které mohou změnit stav. Výstupy – jsou reprezentovanými hodnotami, které vracejí jednotlivé operace (přístupové metody). V této fázi vývoje nemusíme uvažovat o vývojových nástrojích, ani o cílové platformě.

Objekt = je modelem objektu z reálného světa aplikace Objekty:

• abstraktní • instanční

38

Objekty nesmí být ani příliš velké ani naopak malé. Objekty mohou mít následující povahu: - informační – mají schopnost nést a spravovat informace - řídící – mají schopnost spravovat a ovládat jiné objekty - prezentační – mají schopnost prezentovat své vlastnosti a komunikovat s okolím

Není příliš vhodné vytvářet objekty, které v sobě slučují všechny tři povahy. Program je pak následně špatně přenositelný na jinou platformu, jiné grafické rozhraní a podobně.

Podle převažujících rysů můžeme objekty rozdělit na:

- entitní – nést informace a metody pro jejich automatickou správu - řídící – vedou dialog s okolím programu a reagují na události z okolí - rozhraní – modelují vstupně-výstupní zařízení a typicky spolupracují s jedním řídícím objektem

Vazby mezi objekty:

Instanční vazba – (používá) – logická vazba (souvislost) mezi jednotlivými objekty, ke které se přidává kardinalita vazby. Vztah závislosti je jednosměrný. Vazba celek-část – (kompozice) Vazba obecný-speciální – (dědičnost)

Návrh Nejprve je potřeba zvolit i v návaznosti na vytvořený objektový model aplikace

implementační prostředí. Výsledkem této fáze je objektově orientovaný návrh (Object-Oriented Design - OOD), který je upřesněním a doplněním objektového modelu. Tvůrci návrhu by se měli snažit co nejméně narušit objektový model vzniklý při OOA a zachovat tak přenositelnost na jiné systémy. Návrh si můžeme rozdělit na čtyři základní oblasti:

Problémová oblast (Problem Domain Component – PD) - model vzniklý jako důsledek analýzy.

Uživatelské rozhraní (Human Interaction Component – HI) – komunikace s uživatelem

Správa dat (Data Management Component – DM) – zajišťuje ukládání dat do vnější paměti, bezpečnost a konzistenci dat, obnovu dat apod.

Řízení spolupráce (System Interaction – SI) rozhraní na hardware, operační systém a počítačovou síť.

Je potřeba si stanovit: 1) Cíle návrhu 2) Kroky návrhu:

1) Nalezení tříd 2) Specifikovat operace 3) Specifikovat závislost tříd na jiných třídách 4) Specifikovat rozhraní tříd 5) Reorganizovat hierarchii tříd

39

Doporučení pro analýzu a návrh: • provést smysluplné zobecnění – při začátku návrhu je možné si pomoci pomůckou, která říká, že podstatné jméno = objekt (třída) a sloveso = operace (metoda). • minimalizovat vazby mezi třídami – třída je spojena s jinou v případě, že mezi nimi existuje vztah (dědičnosti, používání, kompozice). Osamocené třídy, které nejsou ve vztahu s žádnými jinými třídami, se mohou zrušit. Naopak třída, která je spojena s velkým množstvím tříd, přináší problémy. • rozdělit třídy, které mají příliš mnoho odpovědností – mnoho operací • spojit třídy s malými odpovědnostmi • vyloučit počet jedna – vytvoření mnoha objektů musí být stejně snadné jako vytvoření jediného objektu. Měli bychom dobře zvážit všechna zda jsou smysluplná zahrnutí s počtem jedna. • opakovanou funkčnost vyjádřit děděním – má-li více tříd stejnou odpovědnost (operaci), pak je vhodné navrhnout lépe dědičnost mezi třídami. To znamená najít základní obecnou třídu a ostatní z ní odvodit. • úroveň abstrakce – na každé úrovní abstrakce by měla mít třída určitou odpovědnost

Implementace Jedná se o realizaci programových textů, tedy o vlastní fázi objektově

orientovaného programování v konkrétním vývojovém nástroji.

Testování Testování se provádí až v okamžiku alespoň částečného dokončení projektů. Na

rozdíl od ladění, které probíhá již ve fázi implementace a kterou provádí programátoři, provádí testování obvykle speciální tým, který se nemusí podílet na implementaci (psaní zdrojových kódů). Dokonce je výhodnější, jsou-li týmy testerů a programátorů odlišné. - testování podle scénářů - testování podle subsystémů

Používání Pro každý softwarový projekt je důležitá zpětná vazba, kterou poskytují uživatelé

aplikace. Získané poznatky jsou důležité pro úpravu nových verzí.

Kontrolní úkol: Proveďte kompletní vývoj pro úkol v samostatné práci. Zaměřte se hlavně

na fázi analýzy a návrhu. Zpracujte textovou a případně i grafickou dokumentaci k jednotlivým fázím vývoje programu.

Časté chyby

• Vlastnosti třídy vytváříte s přístupovými právy public, čímž nezajistíte dostatečnou ochranu dat. • Nejprve píšete program a teprve následně začínáte přemýšlet o třídách a jejich schopnostech. Pamatujte, že je potřeba nejprve udělat kvalitní rozbor programu a návrh řešení.

40

Shrnutí učiva • Správně vytvořit program není jen psaní programového kódu v konkrétním vývojovém nástroji v určitém programovacím jazyku. Jedná se o komplexní činnost, kterou si můžeme rozdělit do několika fází:

1. Studie 2. Objektově orientovaná analýza 3. Objektově orientovaný návrh 4. Implementace 5. Testování 6. Používání

Během všech kroků je potřeba pamatovat na tvorbu důkladné a dostatečně obsáhlé dokumentace. Výsledkem analýzy je objektový model aplikace, který by měl být přenositelný a tedy nezávislý na konkrétní hardwarové a softwarové implementaci.

• Objektově orientovaný návrh si můžeme rozdělit na čtyři základní části - problémová oblast - uživatelské rozhraní - správa dat - řízení spolupráce

• Doporučení pro analýzu a návrh: - provést smysluplné zobecnění - minimalizovat vazby mezi třídami - rozdělit třídy, které mají příliš mnoho odpovědností spojit třídy s malými odpovědnostmi - vyloučit počet jedna - opakovanou funkčnost vyjádřit děděním

Rejstřík implementace konečný automat ladění objektový model aplikace objektově orientovaná analýza objektově orientovaný návrh testování

41

Samostatná práce

Cíl lekce

Cílem této lekce je seznámit se se zadáním samostatné práce. Ke zkoušce z předmětu Vývoj objektových aplikací 2 se budete moci přihlásit

jen v případě, že zpracujete zadaný úkol. Vytvořené programy doneste vyučujícímu zároveň se všemi zdrojovými soubory, ve kterých budete muset umět vysvětlit uplatněné postupy.

Po absolvování lekce budete: • umět samostatně vytvořit program • mít základní podklady pro vykonání ústní zkoušky

Časová náročnost lekce: 1 hodina (pro nastudování zadání)

Zadání samostatné práce

Vytvořte aplikace, které budou sloužit k vytváření didaktických testů a jejich následnému zkoušení.

Program musí splňovat následující podmínky: • Bude obsahovat část pro tvorbu testových otázek a odpovědí. • Otázky (testy) budou ukládány do binárních souborů. Názvy souborů si určí tvůrci testů. • Práce bude obsahovat část pro zkoušení žáka. Modul pro tvorbu a modul pro zkoušení testu mohou být dva samostatné programy. • Po provedení testu, program vyhodnotí úspěšnost žáka. • Testové otázky budou načítány z libovolného z připravených souborů. • Testové otázky budou zkoušenému nabízeny v náhodném pořadí. Rovněž možné odpovědi na danou otázku budou zobrazovány v náhodném pořadí. • Při zahájení testu bude možné vybrat počet testových otázek. • Aplikace musí obsahovat přehledné a uživatelský přístupné grafické rozhraní. • K aplikaci přiložíte dokument s rozborem vývoje programu. Hlavně se zaměřte na fázi analýzy a návrhu (viz. lekce Vývoj programů). • K testovým otázkám budou nabízeny odpovědi. U každé z odpovědí doporučuji přidat parametr počet bodů, podle kterého lze určit zda je odpověď zcela správně, zcela špatně nebo správně jen částečně. Budete moci pak vytvářet testové otázky nejen z jednou správnou odpovědí, ale i s více správnými nebo s odpověďmi s odstupňovanou kvalitou správnosti. • Vytvořte alespoň jeden zkušební soubor s testem pro předmět, který vyučujete. Odzkoušejte test na svých žácích.

42

Rady a poznámky k řešení:

• Pro práci s testovými otázkami si zaveďte samostatnou třídu (případně alespoň záznam). Tento typ bude obsahovat například následující položky: TOdpoved = rekord text: string;{text odpovědi} body: byte;{počet bodů za odpověď} end; TOtazka = class private otazka: string; odpoved1: TOdpoved; odpoved2: TOdpoved; odpoved3: TOdpoved; odpoved4: TOdpoved; public //zde vytvoříte potřebné metody end; • Pro náhodný výběr otázek a pro náhodné pořadí odpovědí si vytvořte společnou proceduru, která pomoci generace náhodných čísel zajistí požadovanou operaci. • Neodkládejte řešení samostatné práce. Naopak začněte s do řešením programu, co nejdříve, dokud máte v hlavě řešení minulých úkolů. Nechejte si na vývoj aplikace dostatek času. Tento úkol se nedá kvalitně zvládnout za jedno či dvě odpoledne. Počítejte raději s časem několika týdnu (podle vašich znalostí a zkušeností s programováním v Delphi). • Budete-li mít vážné problémy s řešením některých části aplikace, neváhejte a zašlete dotaz na můj e-mail: rostislav.fojtik@osu.cz.

43

Projekty II – grafika

Cíle lekce Cílem lekce je seznámit se s možnostmi práce s grafickými objekty.

Po absolvování lekce budete: • vědět, jak využívat grafické možnosti Delphi • umět pracovat se třídu TCanvas • umět lépe navrhovat a vytvářet své programy

Časová náročnost lekce: 3 hodiny

Program č.1 – Jednoduchý kreslicí program Zadání: Vytvořte aplikaci, která bude umožňovat nakreslit jednoduchý obrázek pomocí

myši. Naprogramujte tlačítko na ukončení aplikace a smazání nakresleného obrázku. Na následujícím obrázku vidíte možné grafické řešení programu.

Řešení

Abychom aplikaci mohli vytvořit, je nejprve potřeba seznámit se s komponentou Image a třídou TCanvas.

Komponenta Image Pro práci s grafikou můžeme využít například komponentu Image, kterou můžeme

nalézt v záložce Additional. Komponenta může zobrazovat obrázek uložený v souboru a rovněž lze na ni kreslit.

44

Mezi důležité vlastnosti komponenty patří:

Picture, do které můžeme načíst obrázek ze souboru. Například: Image.Picture.LoadFromFile(‘obrazek.bmp`);

Kontrolní úkol Prohlédněte si v nápovědě další vlastností a metody komponenty Image. Podívejte

se rovněž na komponentu PaintBox ze záložky System.

Třída TCanvas Pro kreslení je důležitá třída TCanvas - plátno. Mnoho z grafických komponent

v Delphi má objekt Canvas, který je objektem třídy TCanvas a který umožňuje grafické operace v dané komponentě. Podívejme se na několik základních vlastnosti a schopností objektu Canvas: • Brush (štětec) – umožňuje změnu barvy a vzoru grafických objektů. nejakaKomponenta.Canvas.Brush.Color:=clRed; //nastaví barvu štětce na červenou nejakaKomponenta.Canvas.Brush.Style:=bsSolid; //nastaví styl na úplné vyplnění

• Font – nastavení písma nejakaKomponenta.Canvas.Font.Color:=clBlue; //nastaví barvu písma nejakaKomponenta.Canvas.TextOut(100,20,’Text do určeného místa’);

• Pen (péro) – nastavuje vlastnosti kreslícího péra nejakaKomponenta.Canvas.Pen.Color:=clBlue; //nastaví barvu kreslcího péra

Mezi metody třídy TCanvas patří například: • Arc – kreslí část elipsy • Ellipse – vykreslí elipsu nebo kružnici, která je definována jako vepsána obdélníku • LineTo – nakreslí úsečku z aktuální pozice grafického kurzoru do pozice zadané v parametru metody • MoveTo – přesune grafický kurzor z aktuální pozice do pozice zadané v parametru metody • Rectangle – vykreslí obdélník nebo čtverec

Kontrolní úkol

Prohlédněte si v nápovědě další vlastností a metody třídy TCanvas.

Rozbor programu: 1. Vytvořte si složku (adresář), do kterého budeme ukládat všechny soubory projektu. 2. Spusťte Delphi.

45

3. Pojmenujte formulář FrmHlavni. Upravte jeho velikost. Nastavte vlastnost Caption na text "Kreslení". 4. Umístěte na plochu formuláře komponentu Button a pojmenujte ji BtnKonec a nastavte vlastnost Caption na text "&Konec". 5. Umístěte na plochu formuláře komponentu Button a pojmenujte ji BtnSmazat. Vlastnost Caption nastavte na text "&Smazat". 6. U komponenty BtnKonec vyberte událost OnClick a dopište kód ukončení aplikace. Application.Terminate; 7. Umístěte do formuláře komponentu Image a pojmenujte ji ImgKresleni. 8. Napište kód jako reakci na událost ImgKresleniMouseMove. if ssLeft in Shift then ImgKresleni.Canvas.LineTo(X,Y) else ImgKresleni.Canvas.MoveTo(X,Y); Je-li stisknuto levé tlačítko myši, kreslí se z původního bodu úsečka do bodu o nových souřadnicích. V opačném případě se grafický kurzor pouze přesouvá, ale nezanechává po svém pohybu viditelnou stopu. 9. Napište kód jako reakci na událost BtnSmazatClick. 10. Napište kód jako reakci na událost FormCreate.

Soubor u_kres.pas unit u_kres; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls; type TFrmHlavni = class(TForm) ImgKresleni: TImage; BtnKonec: TButton; BtnSmazat: TButton; procedure ImgKresleniMouseMove(Sender: TObject; Shift: TShiftState;

X, Y: Integer); procedure FormCreate(Sender: TObject); procedure BtnKonecClick(Sender: TObject); procedure BtnSmazatClick(Sender: TObject); private { Private declarations } public { Public declarations } end; var FrmHlavni: TFrmHlavni; implementation {$R *.dfm} procedure TFrmHlavni.ImgKresleniMouseMove(Sender: TObject;

Shift: TShiftState; X,Y: Integer); begin //procedura zajišťuje kreslení levým tlačítkem myši if ssLeft in Shift then ImgKresleni.Canvas.LineTo(X,Y) else ImgKresleni.Canvas.MoveTo(X,Y); end;

46

procedure TFrmHlavni.FormCreate(Sender: TObject); begin ImgKresleni.Canvas.Brush.Color := clWhite; ImgKresleni.Canvas.Fillrect(Rect(0, 0, imgKresleni.Picture.Width,

imgKresleni.Picture.Height)); //Zajistíme přebarvení komponenty Image bílou barvu end; procedure TFrmHlavni.BtnKonecClick(Sender: TObject); begin Application.Terminate; end; procedure TFrmHlavni.BtnSmazatClick(Sender: TObject); begin ImgKresleni.Canvas.Brush.Color := clWhite; ImgKresleni.Canvas.Fillrect(Rect(0, 0, imgKresleni.Picture.Width,

imgKresleni.Picture.Height)); //Zajistíme přebarvení komponenty Image bílou barvu end; end.

Program č.2 – Jednoduchý kreslicí program Zadání: Rozšiřte program o možnost vytvářet další grafické objekty, například: elipsa a

obdélník.

Rozbor programu: Vytvořte si nový datový typ, který bude určovat typ grafického objektu:

Tgraf_objekt=(o_nic,o_ellipse,o_rectangle);

47

Při stisku levého tlačítka myši si poznamenejte počáteční souřadnice“ procedure TFrmHlavni.ImgKresleniMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin x_pocatecni:=X; y_pocatecni:=Y; end;

Při puštění tlačítka nakreslete příslušný objekt:

procedure TFrmHlavni.ImgKresleniMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if (graf_objekt=o_ellipse) then begin ImgKresleni.Canvas.Ellipse(x_pocatecni, y_pocatecni, X,Y); end; if (graf_objekt=o_rectangle) then begin ImgKresleni.Canvas.Rectangle(x_pocatecni, y_pocatecni, X,Y); end; graf_objekt:=o_nic; end;

Upravte metodu, která reaguje na pohyb myší:

procedure TFrmHlavni.ImgKresleniMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin //procedura zajišťuje kreslení levým tlačítkem myši if graf_objekt=o_nic then begin if ssLeft in Shift then ImgKresleni.Canvas.LineTo(X,Y) else ImgKresleni.Canvas.MoveTo(X,Y); end; end;

Při stisku tlačítka pro výběr grafického objektu si poznamenejte typ objektu: procedure TFrmHlavni.BtnEllipseClick(Sender: TObject); begin graf_objekt:=o_ellipse; end; procedure TFrmHlavni.BtnRectangleClick(Sender: TObject); begin graf_objekt:=o_rectangle; end;

Kontrolní úkol

Upravte grafický editor tak, aby bylo možné nastavovat různé barvy štětce. Pro výběr barevné palety použijte například komponentu ColorGrid ze záložky Samples.

48

Dodělejte pro grafický editor možnost načítaní obrázků ze souborů. K řešení úkolu využijte komponentu OpenPictureDialog ze záložky Dialogs.

procedure TFrmHlavni.BtnOtevriClick(Sender: TObject); begin if (openPictureDialog1.Execute)then ImgKresleni.Picture.LoadFromFile(OpenPictureDialog1.FileName); end;

49

Shrnutí učiva

• Pro kreslení na komponenty slouží v Delphi třída TCanvas. • Komponenta Image složí k zobrazení obrázku uloženého v souboru i ke kreslení grafických objektů. • Pro vytvoření dialogového okna pro otevření nebo uložení souboru s obrázky se používají komponenty OpenPictureDialog, případně SavePicturDialog.

Rejstřík Canvas ColorGrid Image OpenPictureDialog TCanvas

50

Projekty III – více formulářů v aplikaci Cíle lekce Cílem lekce je seznámit se s možnostmi práce s více okny v jedné aplikaci.

Po absolvování lekce budete: • vědět, jak využívat vytvářet více oken v jedné aplikaci • vědět, jaký je rozdíl mezi modálním a nemodálním oknem • vědět, jak vytvářet dialogová okna

Časová náročnost lekce: 3 hodiny

Program č.1 – Otevírání modálních a nemodálních oken Zadání:

Vytvořte aplikaci, která bude umožňovat otevřít další okno (formulář).

Řešení Nově otevřené okno může být modální případně nemodální. Rozdíl mezi oběma typy oken je v možnosti vrátit se do původního formuláře. Zatímco u modálního okna je nutné druhé okno nejprve zavřít, abychom se mohli přepnout do prvního okna, tak u nemodálního okna je možné se mezi oběma okny přepínat bez omezení.

51

Rozbor programu: 1. Vytvořte úvodní formulář a umístěte do něj tři tlačítka: pro otevření druhého –

modální okna, pro otevření nemodálního okna a pro ukončení aplikace. 2. Přidejte do projektu nový formulář a přidejte do něj tlačítko OK, které formulář

zavře. Do titulkového pruhu nápis „Druhé okno – modální“. 3. Přidejte do projektu nový formulář a přidejte do něj tlačítko OK, které formulář

zavře. Do titulkového pruhu nápis „Druhé okno – nemodální“. 4. Nezapomeňte do unity č.1 přidat odkaz na další dvě unity. Projekt se bude skládat z následujících částí:

Otázka k zamyšlení: Zvažte, zda by nebylo výhodnější vytvořit pro druhé - modální i nemodální okno jen jeden formulář a měnit pouze jeho titulek (Oba formuláře vlastně dělají stejnou činnost!). Podívejte na to, jak by se dalo využít vlastnost ModalResult.

52

Soubor Unit1.pas unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TFrmUvodni = class(TForm) BtnDruheModal: TButton; BtnOtevriNonModal: TButton; BtnKonec: TButton; procedure BtnKonecClick(Sender: TObject); procedure BtnDruheModalClick(Sender: TObject); procedure BtnOtevriNonModalClick(Sender: TObject); private { Private declarations } public { Public declarations } end; var FrmUvodni: TFrmUvodni; implementation uses Unit2, Unit3; {$R *.dfm} procedure TFrmUvodni.BtnKonecClick(Sender: TObject); begin Application.Terminate;{ukončí aplikaci} end; procedure TFrmUvodni.BtnDruheModalClick(Sender: TObject); begin FrmModal.ShowModal; {Zobrazí nové – modální okno} end; procedure TFrmUvodni.BtnOtevriNonModalClick(Sender: TObject); begin FrmNonModal.Show; {Zobrazí nové – nemodální okno} end; end.

Soubor Unit2.pas unit Unit2; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

53

type TFrmModal = class(TForm) BtnOK: TButton; procedure BtnOKClick(Sender: TObject); private { Private declarations } public { Public declarations } end; var FrmModal: TFrmModal; implementation {$R *.dfm} procedure TFrmModal.BtnOKClick(Sender: TObject); begin Close; {uzavře druhé okno, ale neukončí aplikaci} end; end.

Soubor Unit3.pas unit Unit3; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TFrmNonModal = class(TForm) BtnOK: TButton; procedure BtnOKClick(Sender: TObject); private { Private declarations } public { Public declarations } end; var FrmNonModal: TFrmNonModal; implementation {$R *.dfm} procedure TFrmNonModal.BtnOKClick(Sender: TObject); begin Close; {uzavře druhé okno, ale neukončí aplikaci} end; end.

54

Chceme-li pracovat s formuláři v našich aplikacích, je nutné se dostatečně seznámit alespoň se základními událostmi formuláře (záložka Events v Object Inspektoru): • onActivate – určuje, zda se stane formulář aktivním • onDeactivate – určuje, zda přestane formulář být aktivním • onClose – uzavření formuláře (např. klávesovou zkratkou Alt+F4) • onCloseQuery – před uzavřením je možno vyvolat dialog z dotazem • onCreate - při vytvoření formuláře. Zamyslete se nad rozdílem mezi aktivací a vytvořením formuláře. • onDestroy – rušení formuláře • onShow – ukázání formuláře. Nemusí se vždy jednat o nové vytvoření! • onHide – skrytí formuláře. Pozor! Formulář je stále v paměti, není zrušen!

Rozšiřme náš program o vyvolání dalšího okna, tzv. MessageDialogu.

procedure TFrmUvodni.BtnMessageClick(Sender: TObject); begin MessageDlg('Okno s upozorněním', mtInformation, [mbOK], 0); end;

Varianty upozorňovacího dialogu: mtWarning mtError mtInformation mtConfirmation mtCustom

55

Kontrolní úkol

Vyzkoušejte si jednotlivé typy komponenty MessageDlg změnou parametru při vyvolání dialogu. MessageDlg('Okno s upozorněním', mtInformation, [mbOK], 0);

Dalším typem upozorňovacího dialogu může být MessageBox. Jeho vyvolání provedeme například: procedure TFrmUvodni.BtnMessBoxClick(Sender: TObject); begin Application.MessageBox('Další typ upozornění', 'Pozor!'); end;

Podobné dialogy lze v aplikaci použít například při upozornění na špatná vstupní data, chyby v průběhu programu nebo jako upozornění o stavu řešení aplikace.

Při vkládání dalších oken je možné využít již připravených dialogů a formulářů.

Stačí si jen vybrat v nabídce File – New – Other.

56

57

Shrnutí učiva

• Při vytváření nového okna v aplikaci je potřeba nejprve určit, zda se bude jednat o modální či nemodální okno. • Dialogová okna mohou sloužit k upozornění uživatele na chyby v programu.

Rejstřík MessageBox MessageDlg modální okno nemodální okno událost

58

Test znalostí Cíle lekce Cílem lekce je ověřit si stupeň vašich teoretických znalostí. Časová náročnost lekce: 1 hodina Vyberte správnou odpověď:

1) Která vlastnost objektově orientovaného programování vyjadřuje specializaci – konkretizaci nových tříd?

a) kompozice b) dědičnost c) zapouzdření d) pozdní vazba

2) Která z následujících aplikací nepatří mezi vizuální vývojové nástroje? a) Visual Basic b) Borland Delphi c) Borland Pascal 7.0 d) Borland C++ Builder

3) Která z následujících vlastností vysvětluje sestavení nové třídy pomocí skládání z objektů jiných tříd

a) kompozice b) zapouzdření c) dědičnost d) polymorfismus

4) Které z následujících přístupových specifikací umožňuje přímý přístup k prvkům třídy jen v rámci dané třídy?

a) public b) published c) private d) protected

5) Která z následujících přístupových specifikací umožňuje přímý přístup k prvkům jen v rámci dané třídy nebo v potomcích?

a) public b) published c) private d) protected

6) Která z následujících přístupových specifikací je pouze součásti programovacího jazyka Object Pascal a v jiných objektových jazycích se standardně nevyužívá?

a) public b) published c) private d) protected

7) Který z následujících programovacích jazyků nevyužívá objektově orientovaného modelu programování

a) SmallTalk b) C++ c) Objekt Pascal d) C

59

8) Jak se nazývá linuxová verze vývojového nástroje Borland Delphi? a) Delphi Linux b) Kylix c) uxDelphi d) verze Delphi pro Linux není

9) Jak se jmenuje programovací jazyk využívaný ve vývojovém nástroji Borland Delphi?

a) Borland Pascal b) C++ c) Object Pascal d) Visual Basic

10) Jaké klíčové slovo slouží vytvoření třídy? a) type b) var c) class d) trida

11) Který z následujících zápisů volá konstruktor třídy TZaznam? a) zaznam:=TZaznam.Create(10); b) zaznam.Create(10); c) zaznam.free; d) zaznam.constructor;

12) Který z následujících zápisů volá destruktor objektu zaznam třídy TZaznam? a) zaznam:=TZaznam.free; b) zaznam.Create(10); c) zaznam.free; d) zaznam.destructor;

13) Která z následujících vlastnosti vysvětluje a umožňuje tzv. pozdní vazbu? a) zapouzdření b) dědičnost c) polymorfismus d) kompozice

14) Kterým klíčovým slovem se označuje metoda, pro kterou chceme mít v rámci dědičných tříd stejnou hlavičkou, ale různý kód?

a) polymorf b) virtual c) const d) takové metody nelze vytvořit

15) Ve které fázi programu vytváříme objektový model aplikace? a) studie b) analýza c) návrh d) implementace

Shrnutí

• Řešení testu zašlete v určeném termínu na dresu tutora kurzu.

60