Programování v jazyce. Visual Basic Ján Hanák. Nakladatelství a vydavatelství R

Programování v jazyce

Visual Basic 2010 Ján Hanák

Nakladatelství a vydavatelství

w w w. co m p u t e r m e d i a . c z

R

Obsah

Visual Basic 2010 na první pohled

Obsah O autorovi ..............................................................................................................................................................................5 Úvod ........................................................................................................................................................................ 8 Struktura publikace............................................................................................................................................................9 Komu je tato publikace určena .........................................................................................................................................11 Co budete potřebovat........................................................................................................................................................12 Typografické konvence .....................................................................................................................................................13 Základy algoritmizace

Konvence týkající se použitých stylů písma ....................................................................................................................13 Soubory řešení na disku CD ............................................................................................................................................14 Sdělte nám, jak se vám tato kniha líbí .............................................................................................................................15 Poděkování .......................................................................................................................................................................15 1. Visual Basic 2010 na první pohled............................................................................................................................16 1.1. První pohled na programovací jazykVisual Basic 2010..........................................................................................16 1.2. Visual Basic 2010 a jeho role v počítačovém průmyslu ..........................................................................................19 1.3. Vsaďte na Visual Basic 2010 ...................................................................................................................................20 Základy programování v jazyce Visual Basic 2010

1.4. Dodávka a instalace produktu Visual Basic 2010 Express .....................................................................................23 1.5. První spuštění produktu Visual Basic 2010 Express .............................................................................................23 1.6. Vytváříme první projekt v jazyce Visual Basic 2010 ..............................................................................................25 2. Základy algoritmizace.................................................................................................................................................32 2.1. Konstrukce algoritmu pro vypočtení kořenů kvadratické rovnice ..........................................................................33 2.2. Konstrukce algoritmu pro zjištění hmotnostního indexu BMI osoby ....................................................................34 2.3. Konstrukce algoritmu grafické transformace pro invertování bitové mapy ...........................................................35 2.4. Konstrukce algoritmu pro šifrování otevřeného textu pomocí Cézarovy šifry ......................................................37

Základy OOP v jazyce Visual Basic 2010

2.5. Vlastnosti algoritmů................................................................................................................................................38 2.6. Výpočetní složitost algoritmů .................................................................................................................................42 2.7. Prostředky pro reprezentaci algoritmů ...................................................................................................................50 3. Základy programování v jazyce Visual Basic 2010 ...............................................................................................57 3.1. Proměnná, její definice, inicializace a použití .........................................................................................................57 3.2. Obor proměnné, lokální a globální proměnné .........................................................................................................62 3.3. Charakteristika a klasifikace datových typů............................................................................................................66 3.4. Hodnotové a odkazové datové typy .........................................................................................................................76

.NET Framework 4.0 a vývoj aplikací .NET

3.5. Uživatelsky deklarované hodnotové datové typy ....................................................................................................78 3.6. Konstantní proměnné ..............................................................................................................................................82 3.7. Výčtové typy ............................................................................................................................................................84 3.8. Typové konverze ......................................................................................................................................................86 3.9. Operátory.................................................................................................................................................................96 3.10. Rozhodovací příkazy a řízení toku programu .......................................................................................................111 3.11. Cykly ......................................................................................................................................................................120

3

Programování v jazyce Visual Basic 2010 3.12. Pole .........................................................................................................................................................................132 3.13. Funkce a procedury................................................................................................................................................137 4. Základy objektově orientovaného programování (OOP) v jazyce Visual Basic 2010 .................................148 4.1. Všeobecná teorie objektově orientovaného programování ....................................................................................148 4.2. Hybridní a objektově orientované programovací jazyky .......................................................................................152 4.3. Třída jako abstraktní objektový uživatelsky deklarovaný odkazový datový typ ..................................................152 4.4. Přístupové metody třídy........................................................................................................................................162 4.5. Vlastnosti třídy .....................................................................................................................................................162 4.6. Dědičnost ...............................................................................................................................................................172 5. NET Framework 4.0 jako prostředí pro vývoj aplikací .NET ...........................................................................182 5.1. Úvod do vývojové platformy .NET Framework4.0 ...............................................................................................182 5.2. Společný typový systém (CTS) a společná jazyková specifikace (CLS) ................................................................183 5.3. Řízená exekuce aplikací .NET, mezijazyk MSIL a Just-In-Time kompilace .........................................................185 5.4. Prostředí CLR a služby, které nabízí řízeným aplikacím......................................................................................190 5.5. Sestavení aplikace .NET a jeho architektura .........................................................................................................196 Závěr .................................................................................................................................................................... 198

4

Programování v jazyce Visual Basic 2010 1.


1.1.

První pohled na programovací jazyk Visual Basic 2010

Visual Basic 2010 je moderní, objektově orientovaný programovací jazyk, jenž byl navržen pro vytváření široké škály aplikací určených pro běh v prostředích na lokálních i vzdálených počítačových stanicích. Je přitom zcela nepodstatné, zdali se chystáte vydat na dráhu programátora aplikací pro operační systém Windows nebo web, je-li vaším společníkem jazyk Visual Basic 2010, můžete očekávat, že vaše pracovní produktivita začne záhy stoupat do závratných výšin. Ano, po několikaletých zkušenostech s tímto programovacím jazykem, a také s jeho předcházejícími verzemi, můžeme potvrdit, že na to, abyste vyřešili jakýkoliv z různorodých informatických úkolů, je ve Visual Basicu nutno vynaložit daleko menší kvantum programátorské práce než v příbuzných programovacích jazycích. Visual Basic nás poprvé skutečně okouzlil ve svém čtvrtém vydání (uvedeném v roce 1995), a přestože jsme programovali také v dalších programovacích jazycích (Pascal, C a C++), Visual Basic měl už tehdy v sobě cosi originálního a neopakovatelného. Snad to byl nový styl vývoje aplikací, rychlá práce se zdrojovým kódem, mocná automatizace aplikací nebo opravdové a komfortní vizuální programování. V dřívějších verzích byla role Visual Basicu mnohdy neprávem zamlžována, zejména ze strany programátorů používajících podle nich „skutečné“ programovací jazyky, zejména C a C++. Těmto výrokům jsme ovšem nikdy nepřikládali valnou důležitost, a to zejména proto, že se zmíněnými jazyky jsme také měli vlastní zkušenosti (nevíme ovšem, zdali tvůrci uvedených tvrzení někdy skutečně pracovali s jazykem Visual Basic, ale domníváme se, že spíše nikoliv). Ať tak či onak, příchod první „dotnetové“ verze jazyka Visual Basic v roce 2002 již nenechal nikoho na pochybách. Bylo jasné, že z Visual Basicu se stal univerzální programovací jazyk, jenž si spokojeně hověl na mohutných, objektově orientovaných základech. Visual Basic .NET však nebyl osamoceným jezdcem, společně s ním světlo světa uzřely také další programovací nástroje, a to Visual C# .NET a Visual C++ .NET. Všechny programovací jazyky byly podepřeny všeobjímající vývojovou platformou s názvem Microsoft .NET Framework verze 1.0. Právě nová platforma pro vývoj a běh aplikací .NET byla vskutku revolučním přínosem do poněkud stojatých vod programování aplikací. Přinesla totiž dlouho požadovaný standard a zcela novou architekturu programového ekosystému, čímž hluboce ovlivnila proces navrhování a programování aplikací (tedy něco, s čím dost dobře nepočítali ani ti nejprozřetelnější softwaroví kouzelníci). Vytvořené aplikace již nebyly překládány přímo do strojového kódu, jemuž bezprostředně rozumí instrukční sada mikroprocesoru. Místo toho byl všechen zdrojový kód programu převeden do formy speciálního mezikódu nízkoúrovňového programovacího jazyka s názvem Microsoft

16

1. Visual Basic 2010 na první pohled


Intermediate Language (zkráceně MSIL, také CIL nebo jen IL). Pokud došlo ke spuštění aplikace .NET, byl nejprve zaveden do paměti počítače její startovní kód a poté byl automaticky aktivován Just-In-Time (JIT) překladač, jenž provedl překlad fragmentů instrukcí MSIL kódu do nativního (strojového) kódu. Výstupem JIT překladače byl tedy finální strojový kód, který se v dalším stádiu stal soustem pro mikroprocesor a jeho instrukční sadu.

Základy algoritmizace

Jedna z magických věcí „dotnetu“ spočívala v unifikaci mezikódu jazyka MSIL, jejž generovaly všechny překladače .NET-kompatibilních programovacích jazyků. Řečeno jinak, výstupem překladačů všech zúčastněných programovacích jazyků (Visual Basic .NET, C# a v té době ještě i C++ s Managed Extensions) byl právě MSIL kód. Tak se rázem setřely rozdíly mezi startovní rychlostí aplikací napsaných pomocí různých programovacích jazyků, neboť finální kód vytvořené aplikace .NET byl stejně složen z programových instrukcí jazyka MSIL, ať jste již používali kterýkoliv z nich.

Základy programování v jazyce Visual Basic 2010

Platforma .NET Framework 1.0 uvedla nepřeberné množství novinek a inovativních koncepcí, jejichž cíl byl jediný – připravit takové prostředí, které by na jedné straně maximalizovalo pracovní produktivitu a rychlost práce programátorů, zatímco na straně druhé by jim nabízelo příležitost sestavit a odladit i velice sofistikované počítačové programy.


V první polovině roku 2003 se na trh dostala nová verze platformy .NET Framework, označována jako 1.1. Dalšího vylepšení se dočkal také jazyk Visual Basic, jehož plný název tehdy zněl Visual Basic .NET 2003. Podíváme-li se na následující evoluční pouť Visual Basicu, tak prožijeme pozoruhodný příběh. V roce 2005 byl uveden Visual Basic 2005 a ještě nyní máme v paměti „boom“, jenž „dvatisícpětka“ udělala. Inovací vůči verzi 2003 bylo mnoho, ze všech jmenujme alespoň přímou podporu pro práci s generickými datovými typy a generickými datovými strukturami. Visual Basic 2005 se připravoval na příchod operačního systému Microsoft Windows Vista, a proto si již v té době více než dobře rozuměl se směsicí aplikačních programových rozhraní, která byla do Visty interně zabudována. Ano, šlo o grafický modul Windows Presentation Foundation (WPF), synchronně-asynchronní komunikační modul Windows Communication Foundation (WCF) a deklarativní modul pro reprezentaci toků procesů Windows Workflow Foundation (WF). Koncem roku 2007 přišel Visual Basic 2008 a jeho fanouškové opět uznaně tleskali. Pokud se ptáte čemu, tak důvodů pro radost bylo víc:


• Visual Basic 2008 dovedl implicitně inferovat datové typy lokálních entit. • Visual Basic 2008 umožňoval instanciovat pojmenované a anonymní třídy pomocí syntakticky komfortních inicializátorů. • Visual Basic 2008 byl schopen prostřednictvím rozšiřujících metod obohatit stávající funkcionalitu existujících tříd.

17


1.4.


Patříte-li do segmentu programátorů, jejichž vědomostní úroveň nejlépe vystihuje poslední možnost, zkuste popřemýšlet, zda by se vám nevyplatil přechod na nejnovější verzi jazyka Visual Basic 2010 i platformy .NET Framework. Visual Basic 2010 přináší několik nových změn, jimiž jeho předchůdce nedisponuje.

Dodávka a instalace produktu Visual Basic 2010 Express


1.5.


Jak již bylo řečeno, díky diverzifikované produktové politice firmy Microsoft je expresní vydání jazyka Visual Basic 2010 zdarma k dispozici pro kteréhokoliv zájemce. Když jste si zakoupili tuto knihu, získali jste bezplatně rovněž CD disk s instalačními soubory produktu Visual Basic 2010 Express. Samotnou instalaci zahájíte aktivací instalátoru (soubor setup.exe), který se již postará o všechno ostatní. Po úspěšné instalaci bude do palety programů v nabídce Start operačního systému Windows 7 přidána složka Microsoft Visual Studio 2010 Express s položkou Microsoft Visual Basic 2010 Express. Jelikož budeme s vývojovým prostředím udržovat pravidlný kontakt, doporučujeme vám umístit zástupce Visual Basicu 2010 Express na hlavní panel operačního systému.

První spuštění produktu Visual Basic 2010 Express



Po klepnutí na položku Microsoft Visual Basic 2010 Express se spustí vývojové prostředí pro jazyk Visual Basic 2010. Skutečnost, že probíhá inicializační proces, je signalizována prostřednictvím úvodního okna (obr. 1.1).

Obr. 1.1: Úvodní obrazovka, kterou spatříme při prvním spuštění produktu Visual Basic 2010 Express.

23

Programování v jazyce Visual Basic 2010 Jakmile dojde k načtení a zavedení všech součástí vývojového prostředí jazyka Visual Basic 2010, uvidíte před sebou hlavní okno aplikace (obr. 1.2).

Obr. 1.2: Hlavní okno vývojového prostředí produktu Visual Basic 2010 Express.

Na první pohled spatříme úvodní stránku Start Page, na níž jsou situovány následující součásti: • Tlačítko pro založení nového projektu jazyka Visual Basic 2010 (New Project). • Tlačítko pro otevření existujícího projektu jazyka Visual Basic 2010 (Open Project). • Seznam naposledy otevřených projektů jazyka Visual Basic 2010 (Recent Projects). Seznam je prozatím prázdný, poněvadž jsme ještě neotevřeli ani nevytvořili žádný projekt. • Záložky Get Started (Začínáme) a Latest News (Nejnovější zprávy) s různým informačním obsahem. • Implicitně aktivní zatrhávací pole s názvem Close page after project load (Zavřít úvodní stránku po načtení projektu). Je-li aktivní, způsobí tahle volba automatické uzavření úvodní stránky Start Page okamžitě poté, co byly úspěšně načteny všechny součásti příslušného projektu jazyka Visual Basic 2010. (Budete-li chtít mít stránku Start Page pořád na dohled, doporučujeme vám možnost Close page after project load vypnout.)

24



• Implicitně aktivní zatrhávací pole Show page on startup (Zobrazit úvodní stránku po startu vývojového prostředí). Tato volba rozhoduje o tom, zda se bude po startu produktu Visual Basic 2010 Express objevovat i úvodní stránka, či nikoliv.

1.6.


Přestože úvodní stránka Start Page zabírá největší porci hlavního okna vývojového prostředí jazyka Visual Basic 2010, jsou zde i další součásti, které bychom neměli minout. Tak třeba záhlaví hlavního okna s názvem aplikace, dále pruh nabídek s položkami a příkazy a rovněž tak i panel nástrojů s tlačítkami a jejich ikonami. S jednotlivými nabídkami, příkazy a tlačítky se budeme seznamovat postupně, jak budou narůstat naše programátorské dovednosti jazyka Visual Basic 2010.

Vytváříme první projekt v jazyce Visual Basic 2010

Těšíte-li se již na vytvoření prvního projektu v jazyce Visual Basic 2010, tak vězte, že právě nastal ten správný čas. Ačkoliv je založení projektu docela snadnou záležitostí, vývojové prostředí nám umožňuje dosáhnout tohoto cíle pomocí několika odlišných postupů. Nový projekt můžeme založit prostřednictvím jedné z následujících metod:


1. Stiskneme tlačítko pro založení nového projektu (New Project), které se nachází na úvodní stránce Start Page. 2. Vybereme nabídku File a klepneme na položku New Project. 3. Použijeme klávesovou zkratku CTRL+N.



Každá z uvedených cest iniciuje zobrazení dialogového okna New Project (obr. 1.3).

Obr. 1.3: Dialogové okno New Project pro vytvoření nového projektu jazyka Visual Basic 2010.

25

Programování v jazyce Visual Basic 2010 Volání metody ReadLine třídy Console pozastaví běh programu, takže jeho uživatelé mohou zkontrolovat výstup. Po stisknutí klávesy Enter se okno s konzolovou aplikací automaticky uzavře.

2.


Program, aplikace nebo software jsou shodná pojmenování pro soustavu počítačových instrukcí, které plní požadovanou funkci. Prozatím jsme program blíže nespecifikovali – naši první konzolovou aplikaci naprogramovanou v jazyce Visual Basic 2010 jsme chápali jako samostatnou jednotku, která dovede po svém startu odesílat do okna konzole informační zprávy. Z hlediska informatiky a počítačových věd je možné program jako celek dekomponovat na dvě základní entity, jimiž jsou algoritmy a data. Každý program operuje s jistými daty. Charakter dat určuje kolekce datových typů. I když o datových typech budeme podrobněji mluvit později, už nyní si můžeme povědět, že datový typ zavádí abstrakci předem vymezeného oboru dat, s nimiž lze v programu pracovat. V roli programátorů budeme manipulovat s daty různé povahy: setkáme se třeba s celými čísly, desetinnými čísly s jednoduchou a dvojitou přesností, textovými znaky, textovými řetězci a mnoha dalšími typy dat. Ačkoliv programovací jazyky obecně zavádějí abstrakci datových typů, na zcela nejnižší, strojové úrovni, musejí být všechna data převedena do formy strojového kódu. Je to proto, že instrukční sada procesoru počítače rozumí výhradně nativním instrukcím vyjádřeným ve strojovém kódu. Ovšem program nejsou pouze prostá data. Pokud by totiž program sloužil jenom pro reprezentaci / úschovu dat a nic jiného, jeho praktická využitelnost by se blížila nule. Smysluplnost program nabývá až tehdy, když implementuje určitý způsob, předpis nebo postup, jenž říká, jak s uvedenými daty naložit. Nároky kladené na program jsou však vyšší, neboť se od něj očekává, že bude vhodným a efektivním způsobem přetvářet vstupní data na adekvátní výstupní data. Budeme-li uvažovat o primární funkci kteréhokoliv programu, pak zákonitě dojdeme k závěru, že je jí právě ona „transformační“ funkce. V našich prozatímních myšlenkových pochodech jsme tedy dospěli do bodu, v němž nenadále zjišťujeme, že program musí být kromě schopnosti uschovat data vybaven rovněž jistým mechanismem, který bude tato data kýženým způsobem zpracovávat. Akademičtější definice algoritmu by mohla vypadat následovně: Algoritmus je exaktní postup řešící určitou třídu úloh (neboli problémovou oblast), který je formován konečnou posloupností příkazů. Algoritmus garantuje, že po provedení konečného počtu kroků na množině přípustných vstupních dat bude generován požadovaný výsledek. Algoritmus lze chápat jako implementaci transformační funkce f, která provádí zobrazení z množiny vstupních dat (A) do množiny výstupních dat (B). Zapsáno matematicky: f:AB.

32

2. Základy algoritmizace



S termínem „algoritmus“ se lidstvo setkává již velice dlouhou dobu, neboť první zmínky o algoritmu a algoritmickém řešení algebraických úloh se datují do doby kolem roku 810 n. l., kdy se objevily v pracích uzbeckého matematika Al-Chórezmího. Vynalezení termínu „algoritmus“ ovšem neznamená, že s algoritmy se lidé nepotýkali již mnohem dříve. Pokud situaci zjednodušíme a budeme abstrahovat od využití algoritmů v informatice, pak můžeme prohlásit, že jakýkoliv postup o n krocích, který vede k řešení jistého problému, je algoritmem. Je přitom zcela nepodstatné, zda mluvíme o výpočtu kořenů kvadratické rovnice, nalezení nejkratší možné cesty mezi deseti městy nebo třeba o něčem tak samozřejmém, jako je upečení vašeho oblíbeného dortu. Jestliže víte, jak na to, není pro vás problémem úspěšně provést libovolnou z nastíněných činností. V dalším výkladovém textu se seznámíme s procesem konstrukce následujících algoritmů: 1. Algoritmus pro vypočtení kořenů kvadratické rovnice. 2. Algoritmus pro zjištění hmotnostního indexu BMI osoby. 3. Algoritmus grafické transformace, která invertuje bitovou mapu.

2.1.


4. Algoritmus pro šifrování otevřeného textu pomocí Cézarovy šifry.

Konstrukce algoritmu pro vypočtení kořenů kvadratické rovnice

1. Rovnici ve tvaru ax2 + bx + c = 0 (přičemž a ≠ 0) začneme v oboru reálných čísel řešit vypočtením diskriminantu (D), na jehož základě posléze stanovíme množinu kořenů.


2. Ze středoškolské matematiky si pamatujeme vzorec, jenž nám pomůže s určením diskriminantu: D = b2 - 4ac. 3. Jestliže je D < 0, množina kořenů (K) je v oboru reálných čísel (R) prázdná. Algoritmus výpočtu nás tedy dovádí k výsledku K = Ø. 4. V případě, že je diskriminant roven nule, existuje jeden (dvojnásobný) kořen, který najdeme následovně: b x= 2a


Za těchto okolností je množina kořenů tvořena jedním prvkem, K = {x}. 5. Při kladné hodnotě diskriminantu existují právě dva kořeny, které vyhovují řešení kvadratické rovnice. Jejich nalezení je otázkou rozluštění níže popsaných rovnic: x1 =

- b + √D 2a

x1 =

- b - √D 2a

Pro množinu kořenů pak platí K = {x1, x2}.

33

Programování v jazyce Visual Basic 2010 Ačkoliv to může působit zprvu poněkud zvláštně, pravdou je, že každá proměnná jazyka Visual Basic 2010 je již od své definice implicitně inicializována jistou hodnotou. Této hodnotě říkáme implicitní inicializační hodnota proměnné. Implicitní inicializační hodnoty proměnných vymezuje jazyková specifikace pro Visual Basic 2010. Ta říká, že všechny proměnné datového typu Integer jsou od své definice implicitně inicializovány nulou. Z uvedeného plyne, že každá celočíselná proměnná, do které nebyla přímo přiřazena určitá hodnota, obsahuje nulu. Programátoři však mohou tuto implicitní inicializaci proměnných obejít tak, že proměnnou explicitně inicializují ihned v rámci její definice: Sub Main() 'Defi niční inicializace proměnné. Dim promenna As Integer = 20 + (100 * 2) - 10 End Sub Explicitní přiřazení hodnoty do právě definované proměnné je technika, které říkáme definiční inicializace proměnné. Uskutečňuje se pomocí přiřazovacího operátoru, který je vkládán za název datového typu vytvářené proměnné. Explicitní inicializace proměnné při její definici je výhodná především v situacích, kdy již v době vytváření proměnné víme, jakou hodnotu má proměnná obsahovat. Pokud je nám ovšem tato skutečnost neznámá, můžeme postupovat standardně, tedy nejprve proměnnou definujeme a poté do ní v příhodné chvíli uložíme požadovanou hodnotu. Právě popsaná technika je známá jako odložená inicializace proměnné.

3.2.

Obor proměnné, lokální a globální proměnné

Proměnné mohou působit na rozdílných úrovních programu, od lokální až po globální úroveň. Charakter „dosahu“ působnosti proměnné definuje obor proměnné. Pod pojmem obor proměnné rozumíme blok zdrojového kódu, v němž je proměnná viditelná pro jiné programové entity, například pro jiné proměnné nebo funkce. Ze základního hlediska lze za obor proměnné považovat: • hlavní funkci Main, • jakoukoliv jinou funkci (ať už s návratovou hodnotou, nebo bez ní), • třídu • a programový modul. Pokud je proměnná definována v těle hlavní funkce Main (čili definiční příkaz proměnné se objevuje mezi příkazy Sub a End Sub hlavní funkce), mluvíme o tzv. lokální proměnné. Obor lokální proměnné je pouze místní, jelikož je ohraničen zdrojovým kódem, jenž je

62

3. Základy programování v jazyce Visual Basic 2010


umístěn v těle hlavní funkce. Proměnná operující ve funkci je vytvořena pomocí definičního příkazu tak, jak jsme si jej předvedli před chvilkou. Tento příkaz se může nacházet na jakémkoliv řádku zdrojového kódu těla hlavní funkce, ovšem musí předcházet tomu řádku, jenž se snaží nějak manipulovat s danou proměnnou (nelze kupříkladu přiřadit hodnotu do proměnné, která ještě nebyla definována).


V průběhu zpracování zdrojového kódu hlavní funkce může být hodnota proměnné libovolněkrát modifikována podle pokynů aplikační logiky programu. Pokud ovšem procesor přijde na řádek s příkazem End Sub, dochází k ukončení provádění kódu hlavní funkce. Tento okamžik je obzvlášť důležitý z aspektu života proměnné, protože dochází k automatické likvidaci proměnné, a tudíž i její hodnoty. Ano, uvedené chování je pro lokální proměnné typické: Ve chvíli provedení příkazu End Sub hlavní funkce jsou všechny její lokální proměnné samočinně odstraněny z paměti počítače. Jinými slovy, prostor, jejž proměnné alokovaly, bude vyčištěn a zpřístupněn pro budoucí použití.


Proměnná může být definována také v kterékoliv jiné platně vytvořené funkci. Ve všeobecnosti platí následující pravidlo: Jakákoliv proměnná, která byla vytvořena ve zdrojovém kódu funkce, je lokální proměnnou vzhledem k dané funkci. Oborem proměnné je vždy tělo funkce, v níž je proměnná definována. Následující program, jenž manipuluje s lokálními proměnnými, dovede vypočítat hmotnostní index BMI. Prostudujeme nejprve zdrojový kód programu a poté jej opatříme doprovodným komentářem. Module Module1 Sub Main()


'Defi nice lokálních proměnných. Dim hmotnost As Integer Dim vyska As Single Dim indexBMI As Single 'Získání uživatelovi hmotnosti. Console.Write("Zadejte svoji hmotnost (v kg): ")


hmotnost = Convert.ToInt32(Console.ReadLine()) 'Získání uživatelovi výšky. Console.Write("Zadejte svoji výšku (v m): ") vyska = Convert.ToSingle(Console.ReadLine()) 'Vypočtení indexu BMI uživatele. indexBMI = hmotnost / (vyska * vyska)

63

Programování v jazyce Visual Basic 2010 'Zobrazení vypočteného indexu BMI. Console.WriteLine("Váš index BMI je " & indexBMI & ".") End Sub End Module Komentář k zdrojovému kódu programu jazyka Visual Basic 2010: Vzhledem k tomu, že pro zjištění hmotnostního indexu BMI potřebujeme od uživatele informace o jeho hmotnosti a výšce, definujeme v těle hlavní funkci adekvátní lokální proměnné. Jak si můžeme povšimnout, proměnná hmotnost má celočíselný typ Integer, zatímco proměnná vyska disponuje reálným typem Single. Datový typ Integer již známe, takže prozatím postačí sdělení, že typ Single je reálným typem s jednoduchou přesností. Poznámka: Jazyk Visual Basic 2010 obsahuje tři reálné datové typy: Single, Double a Decimal. Pro základní použití nám postačuje typ Single, jenž nabízí jednoduchou přesnost při interpretaci reálných hodnot. Jestliže požadujeme při práci s reálnými hodnotami vyšší přesnost, můžeme zvolit typ Double. Ten skýtá dvojnásobnou přesnost vůči typu Single. Přesnost je přitom kvantifikována počtem signifikantních cifer za desetinným oddělovačem (jak záhy zjistíme, tím je v jazyce Visual Basic 2010 tečka, nikoliv čárka, jak jsme zvyklí v našich zeměpisných šířkách). Poněvadž vypočtený index BMI bude také reálná hodnota, vytváříme stejnojmennou proměnnou s datovým typem Single. Ve chvíli, kdy máme vytvořeny všechny potřebné lokální proměnné, můžeme pokračovat dál. Následujícím krokem je sběr informací od uživatele, přičemž očekáváme konkrétní metriky. Jak víme, výstupní datovou operaci provede metoda Write třídy Console. S načtením vstupu nám zase pomůže metoda ReadLine identické třídy. Nyní ovšem musíme být opatrní, neboť metoda ReadLine je naprogramována tak, aby nám vracela načtená data výhradně ve formě textových řetězců. To je malinko problém, neboť my potřebujeme buď celočíselnou hodnotu (reprezentující hmotnost uživatele), nebo reálnou hodnotu (udávající výšku uživatele). Proto je zapotřebí, abychom příslušné hodnoty vyjádřené v textové podobě podrobili explicitní typové konverzi. Jinými slovy, z dodaných textových řetězců budeme extrahovat numerické textové znaky, které poté převedeme do podoby celočíselné, respektive reálné. Za tímto účelem voláme dvě konverzní metody: 1. Metoda ToInt32 třídy Console přetransformuje vstupní textovou hodnotu na výslednou celočíselnou hodnotu datového typu Integer. 2. Metoda ToSingle třídy Console převede vstupní textovou hodnotu na výslednou reálnou hodnotu datového typyu Single.

64




Když jsou lokální proměnné hmotnost a vyska náležitě naplněny inicializačními hodnotami, můžeme zahájit rovněž proces inicializace lokální proměnné indexBMI. To uskutečníme docela snadno, neboť do zdrojového kódu jazyka Visual Basic 2010 přepíšeme matematický vzoreček, jenž nám říká, jak tenhle hmotnostní index vypočítat (jak víme, k indexu BMI se dopracujeme tehdy, když hmotnost uživatele dělíme druhou mocninou jeho výšky). Inicializačním výrazem proměnné indexBMI je tudíž aritmetický výraz. V tomto výrazu jsme schopni rozpoznat dva aritmetické operátory (operátor / pro dělení a operátor * pro násobení). Rovněž tak vidíme tři operandy, jejichž roli zastávají proměnné hmotnost a vyska. Abychom dospěli ke správnému výsledku, zvyšujeme pomocí závorek prioritu zpracování podvýrazu vyska * vyska.


Poznámka: Operátor / realizuje reálné dělení, což znamená, že výsledný podíl bude desetinná hodnota. V nabídce aritmetických operátorů jazyka Visual Basic 2010 se ovšem nachází také operátor \ (zpětné lomítko), jenž provádí celočíselné dělení. Vývojáři tak mohou volit různé aritmetické operátory podle toho, jaký typ dělení právě potřebují. V jiných programovacích jazycích, jako jsou třeba C, C++ nebo C#, existuje pouze jeden operátor podílu: /. Skutečnost, zda v prostředích těchto jazyků dochází k reálnému, nebo celočíselnému dělení, je dána datovými typy operandů (je-li alespoň jeden z operandů reálný, pak je vykonáno reálné dělení). Konečně, je-li index BMI stanoven, zobrazujeme jej na obrazovce počítače. Přestože výstupní datovou operaci opět uskutečňuje metoda WriteLine třídy Console, je tu jedno specifikum – tím je automaticky převod hmotnostního indexu do formy textového řetězce a jeho přidání (neboli zřetězení) k dalším textovým řetězcům. Za vším stojí operátor &, což je v jazyce Visual Basic 2010 operátor, jenž spojuje textové řetězce dohromady.



Pokud spustíme program a naplníme jej požadovanými daty, získáme na výstupu hodnotu indexu BMI (obr. 3.1).

Obr. 3.1: Program na výpočet hmotnostního indexu BMI.

65

Programování v jazyce Visual Basic 2010 3.7.

Výčtové typy

Výčtové typy zařazujeme k uživatelsky deklarovaným hodnotovým datovým typům. Výčtový (nebo také enumerační) typ je jednotné pojmenování pro množinu symbolických konstant. Není-li určeno jinak, každá symbolická konstanta uvnitř výčtového typu má svůj identifikátor a implicitní inicializační hodnotu. V jazyce Visual Basic 2010 se výčtové typy deklarují pomocí klíčového slova Enum. Všeobecný zápis deklaračního příkazu pro nový výčtový typ má následující podobu: [PristupovyModifikator] Enum JmenoVyctovehoTypu SymbolickaKonstanta1 [= Hodnota1] SymbolickaKonstanta2 [= Hodnota2] .... SymbolickaKonstantaN [= HodnotaN] End Enum Každá symbolická konstanta má svůj identifikátor. Pokud sami neurčíme explicitní inicializační hodnotu pro danou symbolickou konstantu, překladač přisoudí všem symbolickým konstantám implicitní inicializační hodnoty. Tato implicitní inicializace se děje podle tohoto modelu: do první symbolické konstanty je přiřazena nula, do druhé symbolické konstanty je přiřazena jednotka, do třetí symbolické konstanty je přiřazena dvojka atd., dokud nejsou automaticky inicializovány všechny přítomné symbolické konstanty. Samozřejmě dáváme v praxi většinou přednost explicitní inicializaci všech symbolických konstant. To znamená, že za název každé symbolické konstanty zapíšeme přiřazovací operátor a kýženou explicitní inicializační hodnotu. Kupříkladu takto vytvoříme výčtový typ pro reprezentaci barev v modelu RGB: Public Enum Barvy Cervena = 1 Zelena = 2 Modra = 3 End Enum Kompozice deklaračního příkazu výčtového typu se vzdáleně podobá deklaračnímu příkazu, jenž jsme upotřebili při vytváření nové struktury. Enumerace jsou ovšem podstatně jednodušší, protože jejich členy nejsou standardními, nýbrž konstantními proměnnými. V elementární podobě dokonce ani není zapotřebí určovat datový typ jednotlivých symbolických konstant výčtového typu – Visual Basic 2010 jim totiž implicitně přiřadí datový typ Integer. Předložený výčtový typ se jmenuje Barvy a obsahuje tři symbolické konstanty (Cervena, Zelena a Modra), které jsou explicitně inicializovány celočíselnými hodnotami.

84



Implicitním datovým typem enumeračních konstant je typ Integer. Při deklaraci nových výčtových typů ovšem můžeme zužitkovat také další celočíselné datové typy, jakými jsou Byte, Short a Long. Nadcházející ukázka předvádí, jak provést, aby byl bázovým typem výčtového typu typ Byte: Enum Tyden As Byte Pondeli = 1 Utery = 2


Streda = 3 Ctvrtek = 4 Patek = 5 Sobota = 6 Nedele = 7 End Enum


Jak jsme již konstatovali, někdy můžeme ponechat inicializaci symbolických konstant na překladači. Tehdy říkáme, že byl proveden implicitní inicializační proces, v rámci něhož překladač přiřadil do všech symbolických konstant výchozí inicializační hodnoty. Enum Produkty OperacniSystemy 'Hodnota symbolické konstanty je 0. KancelarskySoftware 'Hodnota symbolické konstanty je 1.


VyvojarskeNastroje 'Hodnota symbolické konstanty je 2. End Enum Pokud je výčtový typ náležitě deklarován, můžeme založit proměnnou tohoto typu. Tuto eventualitu demonstruje následující program jazyka Visual Basic 2010: Module Module1 Enum SkolskePredmety Matematika .NET Framework 4.0 a vývoj aplikací .NET

Fyzika Informatika Biologie Anglictina End Enum

85

Programování v jazyce Visual Basic 2010 Sub Main() Dim oblibenyPredmet As SkolskePredmety = _ SkolskePredmety.Informatika Console.WriteLine("Můj oblíbený předmet je {0}.", oblibenyPredmet) End Sub End Module Když v definičním příkazu přisoudíme proměnné za klauzilí As výčtový typ, uděláme z ní proměnnou zadaného výčtového typu. Počínaje tímto okamžikem dovede proměnná uchovat hodnotu jakékoliv symbolické konstanty použitého výčtového typu. Tip: Jakmile zapíšeme za názvem proměnné výčtového typu tečkový operátor, technologie IntelliSense nám zobrazí seznam všech symbolických konstant, jimiž výčtový typ oplývá.

3.8.

Typové konverze

Programování spočívá v operacích s daty různého charakteru. Data nejprve odněkud získáme, poté je zpracujeme a podrobíme analytickým či syntetickým operacím, které nám poskytnou nová data, jež získáme transformací dat původních. Spektrum datových operací je poměrně široké a velice často při nich dochází ke změně datových typů hodnot. Někdy je proces konverze dat pouhým vedlejším efektem prováděného výpočtu, jindy je pečlivé uskutečnění přetypování jediným cílem realizovaných syntakticko-sémantických analýz zdrojového kódu. Již jsme se obeznámili s hlavními zástupci datových typů, s nimiž lze v jazyce Visual Basic 2010 pracovat a používat je pro systematické uchovávání požadovaných kvant dat. Dále se naučíme, jak se dají změnit datové typy hodnot proměnných v procesu typové konverze, a také se dozvíme, jaké druhy přetypování můžeme v prostředí jazyka Visual Basic 2010 upotřebit. Nakonec si představíme konverzní funkce, které jsou s to nám při proměně typů hodnot proměnných poskytnout pomocnou ruku. Termínem typová konverze hodnoty rozumíme změnu aktuálního (zdrojového) datového typu hodnoty na jiný (cílový) datový typ. Kupříkladu můžeme vzít celočíselnou hodnotu a v procesu typové konverze ji přeměnit na textový řetězec, jehož znaky budou tvořeny číslicemi původní hodnoty. V tomto případě tedy do konverzního procesu vstupuje numerická hodnota a vystupuje z něj textový řetězec. Současně s konverzí hodnoty se mění i datový typ hodnoty z typu Integer na typ String. Výsledkem je tedy textový řetězec, který můžeme zobrazit na výstupu konzolového programu.

86



Operátor pro umocňování převede před výpočtem mocniny číselné hodnoty konverzi obou operandů do hodnot datového typu Double a na takto upravených operandech následně provede operaci umocnění. Aplikaci operátoru ^ v praxi přibližuje následující fragment zdrojového kódu jazyka Visual Basic 2010: Sub Main() Dim ciselnaHodnota As Short = 2


Dim exponent As Byte = 8 Dim vysledek As Double = ciselnaHodnota ^ exponent Console.WriteLine("{0} na {1} se rovná {2}.", ciselnaHodnota, _ exponent, vysledek) End Sub

3.9.2.


Do proměnné vysledek typu Double je uložena hodnota 256 (protože 28=256). Mějme prosím na paměti skutečnost, že výsledem práce operátoru ^ je reálná hodnota datového typu Double. Pokud budeme umocněnou hodnotu ukládat do proměnné celočíselného datového typu, musíme uskutečnit explicitní typovou konverzi této hodnoty (za předpokladu, že používáme volbu Option Strict On, což je, jak víme, doporučeníhodné standardní nastavení).

Relační operátory


Relační operátory zkoumají existenci relace mezi svými operandy. Jazyk Visual Basic 2010 zná následující typy relačních operátorů: • Operátor rovnosti (=). • Operátor nerovnosti (< >). • Operátor menší než (<). • Operátor větší než (>). • Operátor menší než nebo roven (<=).


• Operátor větší než nebo roven (>=). Upozornění: Všechny relační operátory (kromě prvního) jsou složeny ze dvou symbolů. Aby překladač jazyka Visual Basic 2010 správně rozeznal tyto relační operátory, musíme jejich dva symboly psát za sebou a bez mezery. Kupříkladu korektní zápis operátoru nerovností je <>, a nikoliv <[mezera]>. Kdybychom se spletli a omylem zapsali mezi symboly < a > mezeru, překladač by viděl dva samostatné operátory (menší než a větší než), nikoliv jeden samostatný operátor nerovnosti.

99

Programování v jazyce Visual Basic 2010 Pozoruhodné je, že operátor rovnosti (=) je syntakticky představován stejným symbolem jako operátor pro přiřazení (=). Přestože oba operátory sdílejí totožnou vizuální interpretaci, provádějí zcela odlišné programové operace. Zatímco operátor pro přiřazení naplňuje entitu, která se nachází po jeho levé straně, inicializační hodnotou, operátor rovnosti zkoumá, zdali jsou datové obsahy dvou entit shodné, či nikoliv. Výsledkem práce operátoru pro přiřazení je přiřazení jisté hodnoty do cílové entity. Výsledkem činnosti operátoru rovnosti je logická hodnota (True nebo False), která pojednává o rovnosti, respektive nerovnosti testovaných hodnot. Přestože v jazyce Visual Basic 2010 mají oba operátory stejnou symboliku, překladač ví, kdy má uskutečnit porovnání hodnot a kdy jejich přiřazení. Tato znalost překladače vychází z programového kontextu, v němž se symbol = objevuje. Jestliže se na levé straně operátoru nachází proměnná a na pravé hodnota, překladač jazyka Visual Basic 2010 správně usoudí, že se pokoušíme přiřadit tuto hodnotu do proměnné, a proto provede operaci přiřazení hodnoty. Poznámka: Operátor, který se v různých programových kontextech chová jinak, je v terminologii programování označován jako přetížený operátor (angl. overloaded operator). Přetížený operátor je specifický v tom, že ve skutečnosti zastupuje množinu operátorů, pro které platí tato pravidla: 1. Všechny operátory sdílejí stejný symbol. 2. Každý z operátorů se chová jinak. 3. Odlišné chování jednotlivých verzí přetíženého operátoru může být determinováno různými faktory, z nichž hlavní postavení má počet operandů, na něž je daná verze přetíženého operátoru aplikována. Vzhledem k tomu, že překladač je deterministický stroj, musí být z užití přetíženého operátoru v příslušném programovém kontextu vždy zcela jednoznačné, která z dostupných variant přetíženého operátoru má být použita. Jestliže překladač nedovede toto kvalifikované rozhodnutí jednoznačně určit, zastaví překlad zdrojového kódu programu a vygeneruje chybové hlášení. Pak je už na vývojáři, aby existující nejednoznačnost odstranil.

100



Všechny ostatní relační operátory porovnávají hodnoty svých operandů a na základě uskutečněného porovnání vracejí logické hodnoty True nebo False. Práci relačních operátorů na dvou operandech přibližuje tab. 3.6. Tab. 3.6: Přehled relačních operátorů Výsledkem operace je hodnota True

Výsledkem operace je hodnota False

Operátor rovnosti

Operand1 = Operand2

Operand1 <> Operand2

Operátor nerovnosti

Operand1 <> Operand2

Operand1 = Operand2

Operátor menší než

Operand1 < Operand2

Operand1 >= Operand2

Operátor větší než

Operand1 > Operand2

Operand1 <= Operand2

Operátor menší než nebo roven

Operand1 <= Operand2

Operand1 > Operand2

Operátor větší než nebo roven

Operand1 >= Operand2

Operand1 < Operand2


Operátor


Pokračujeme programem, jenž používá relační výraz coby inicializační výraz pro lokální proměnnou: Sub Main() Dim cislo1, cislo2 As Integer cislo1 = 6 cislo2 = 2 'Inicializačním výrazem této proměnné je relační výraz.


Dim vysledek As Boolean = cislo1 <= cislo2 Console.WriteLine("Hodnota proměnné vysledek: {0}.", vysledek) End Sub Lokální proměnná vysledek bude uchovávat logickou pravdu (True) nebo logickou nepravdu (False), a to v závislosti na hodnotách zbylých lokálních proměnných cislo1 a cislo2.

3.9.3.

Složené přiřazovací operátory .NET Framework 4.0 a vývoj aplikací .NET

Složené přiřazovací operátory nacházejí své místo v přiřazovacích příkazech, přičemž kombinují dovednosti standardního přiřazovacího operátoru (=) a dalších (zejména aritmetických) operátorů. Právě použití těchto operátorů v rámci přiřazovacích příkazů naznačuje rozsah jejich působnosti. Všechny složené přiřazovací operátory přiřazují jisté hodnoty do cílových entit, ovšem až poté, co byly na tyto hodnoty aplikovány předepsané operace. Jazykovou specifikaci pro Visual Basic 2010 tvoří následující složené přiřazovací operátory:

101

3. Základy programování v jazyce Visual Basic 2010 Pro příznivce praktických ukázek je připraveno další sousto: Visual Basic 2010 na první pohled

Sub Main() 'Defi nice proměnné typu Integer. Dim pocetBodu As Integer 'Inkrementace hodnoty proměnné o 10 jednotek. pocetBodu = pocetBodu + 10


'Opětovná inkrementace hodnoty proměnné pomocí složeného 'operátoru pro sčítání a přiřazení. 'Složený přiřazovací operátor je sémanticky totožný s předcházejícím 'řádkem kódu. pocetBodu += 10 Console.WriteLine("Počet bodů je " & pocetBodu & ".")


End Sub Víte, jaká hodnota bude zobrazena na výstupu programu? Říkáte-li 20, máte samozřejmě pravdu. Jak jsme dospěli k tomuto výsledku? Při své definici je lokální proměnná pocetBodu typu Integer implicitně inicializována nulovou hodnotou. Následně je hodnota proměnné zvýšena o 10 jednotek a záhy pomocí operátoru += ještě o dalších 10 jednotek, dohromady tedy o 20 jednotek.

3.9.4.

Logické operátory Základy OOP v jazyce Visual Basic 2010

Logické operátory se používají při konstrukci logických výrazů. Hodnotou jakéhokoliv správně zapsaného logického výrazu je buď logická pravda (reprezentovaná klíčovým slovem True), nebo logická nepravda (vyjádřena klíčovým slovem False). Logické operátory jsou s to realizovat čtyři základní logické operace, jimiž jsou: logická konjunkce, logická disjunkce, logická nonekvivalence a logická negace. Syntakticky jsou logické operátory jazyka Visual Basic 2010 ztělesňovány těmito symboly: • Logický operátor And pro realizaci logické konjunkce.


• Logický operátor Or pro uskutečnění logické disjunkce. • Logický operátor Xor pro provedení logické nonekvivalence. • Logický operátor Not pro zpracování logické negace.

103

Programování v jazyce Visual Basic 2010 Kromě čtyř základních logických operátorů se v jazyce Visual Basic 2010 setkáváme rovněž se dvěma komplementárními logickými operátory, které umí provádět zkrácené vyhodnocování logických výrazu. Jedná se o následující operátory: • Logický operátor AndAlso realizuje zkrácené vyhodnocení logického výrazu. • Logický operátor OrElse uskutečňuje zkrácené vyhodnocení logického výrazu. Přehled a praktické použití základních logických operátorů And, Or, Xor a Not přibližuje tab. 3.7. Tab. 3.7: Přehled a použití základních logických operátorů Operátor

And

Or

Xor

Not

Operand1

Operand2

X = True

Y = True

X = True

Y = False

X = False

Y = True

X = False

Y = False

False

X = True

Y = True

True

X = True

Y = False

X = False

Y = True

X = False

Y = False

False

X = True

Y = True

False

X = True

Y = False

X = False

Y = True

X = False

Y = False

X = True Y = False

Syntaktická aplikace operátoru

Výsledná logická hodnota True

X And Y

X Or Y

X Xor Y

False False

True True

True True False

Not X

False

Not Y

True

Operátor And provádí logickou konjunkci svých operandů. Tento operátor vrací logickou pravdu (True) právě tehdy, obsahují-li oba operandy současně logickou pravdu (True). V jakémkoliv jiném případě je logickým operátorem And poskytnuta logická nepravda (False). Prostřednictvím logického operátoru Or můžeme realizovat logickou disjunkci operandů. Pokud alespoň jeden z operandů obsahuje logickou pravdu (True), je operátorem Or vrácena rovněž logická pravda (True). Není-li tomu tak, operátor vrací logickou nepravdu (False). Operátor Xor zjišťuje nonekvivalenci hodnot svých logických operandů. Přitom platí zásada, že operátor Xor vrací logickou pravdu (True) jedině ve chvíli, kdy se logické

104

Programování v jazyce Visual Basic 2010 je hledaná hodnota v poli nalezena, funkce ihned končí svůj běh a vrací hodnotu, která představuje index prvku, jenž hledanou hodnotu obsahuje. Pokud se hledanou hodnotu nepodaří najít v žádném prvku pole, funkce NajitPrvek vrací zápornou hodnotu -1. Poznámka: Fibonacciho posloupnost je tvořena sekvencí členů, pro niž platí toto pravidlo: Každý následující člen je součtem dvou předcházejících členů. Pokračujeme stanovením hledané hodnoty – v našem případě jde o dvojku. Dále voláme funkci NajitPrvek, které předáváme odkaz na pole a hodnotu, o níž máme zjistit, zdali se v poli nachází. Výstup programu můžeme vidět na obr. 3.7.

Obr. 3.7: Výstup programu, jenž provádí sekvenční prohledávání jednorozměrného pole.

4.

Základy objektově orientovaného programování (OOP) v jazyce Visual Basic 2010

4.1.

Všeobecná teorie objektově orientovaného programování

Přestože základy paradigmatu objektově orientovaného vývoje počítačového softwaru byly teoreticky položeny již v 60. letech 20. století, praktický rozmach zaznamenal tento model vytváření počítačových aplikací a systémů přibližně o třicet let později. Objektově orientované programování se snaží efektivně řešit jeden ze základních problémů strukturovaného (procedurálního) programování, jímž byla separace datových objektů a funkcí (neboli podprogramů), které s těmito datovými objekty manipulovaly. Všeobecná teorie objektově orientovaného programování vychází z následujících axiomů: 1. Objekt je základní logická entita, která je charakterizována svým identifikátorem, vlastnostmi a činnostmi. Identifikátor objektu je jednoznačné určení objektu v systému, respektive v objektově orientovaném prostředí. Vlastnosti objektu jsou

148

4. Základy OOP v jazyce Visual Basic 2010 Program nejprve vytvoří nový 3D vektor a poté uživatele informuje o jeho datovém složení. Visual Basic 2010 na první pohled

Složky 3D vektoru můžeme kdykoliv pozměnit pomocí přístupových metod: Sub Main() Dim vektor As New Vektor3D(9, 3, 5) Console.WriteLine("Vektor má tyto složky: {0}, {1}, {2}.", _ vektor.NacistX(), vektor.NacistY(), vektor.NacistZ())


'Úprava složek vektoru pomocí přístupových metod. vektor.ZapsatDoX(1) vektor.ZapsatDoY(0) vektor.ZapsatDoZ(1) Console.WriteLine("Nyní má vektor tyto složky: {0}, {1}, {2}.", _ vektor.NacistX(), vektor.NacistY(), vektor.NacistZ())

4.5.


End Sub

Vlastnosti třídy


Ačkoliv přístupové metody plní svou funkci dobře, v jazykové specifikaci pro Visual Basic 2010 se nachází ještě lepší programová konstrukce, pomocí které lze získávat a upravovat hodnoty soukromých datových atributů instancí tříd. Tato konstrukce se volá vlastnost. Vlastnost je nová entita třídy, která zavádí vrstvu abstrakce mezi soukromý datový atribut a klientský zdrojový kód. Mezi soukromými datovými atributy a spřízněnými vlastnostmi existuje relace typu 1:1 (na každý datový atribut připadá právě jedna vlastnost). V těle vlastnosti jsou umístěny dvě přístupové metody, které provádějí čtení a zápis hodnot do příslušného datového atributu. Generický model pro definici vlastnosti je následující: Public Class JmenoTridy Private datovyAtribut As Typ


'Defi nice vlastnosti. Public Property JmenoVlastnosti As Typ 'Defi nice speciální přístupové metody Get. Get 'Kód pro získání hodnoty datového atributu. Return datovyAtribut

165

Programování v jazyce Visual Basic 2010 End Get 'Defi nice speciální přístupové metody Set. Set(ByVal value As Typ) 'Kód pro změnu hodnoty datového atributu. datovyAtribut = value End Set End Property End Class V těle vlastnosti rozeznáme dvě speciální přístupové metody s identifikátory Get a Set. Metodu Get naprogramujeme tak, aby nám na požádání poskytla hodnotu soukromého datového atributu. Metodu Set naprojektujeme tak, aby si poradila s úpravou hodnoty soukromého datového atributu. Jazyk Visual Basic 2010 ví, že metoda Get je bezparametrickou metodou s návratovou hodnotou. Datový typ návratové hodnoty metody Get je stejný jako typ vlastnosti, v jejíž definici je metoda Get uložena. Možná se ptáte, proč je metoda Get bezparametrickou metodou s návratovou hodnotou. Nuže, smyslem existence této metody je bezpečným způsobem poskytnout klientskému kódu hodnotu spřízněného soukromého datového atributu instance třídy. Klientský kód nebude této metodě předávat žádná data, právě naopak, bude od ní data očekávat. To je ovšem v pořádku, protože metoda Get přečte kýžená data a vrátí je zpět klientskému kódu v podobě své návratové hodnoty. Zkusme nyní prozkoumat metodu Set. Metoda Set je parametrickou metodou bez návratové hodnoty. Metoda Set definuje jeden formální parametr s identifikátorem value. Proč právě takováto kompozice? Hlavním cílem metody Set je bezpečným způsobem pozměnit hodnotu asociovaného soukromého datového atributu. V zájmu provedení této reinicializační operace musí mít metoda Set k dispozici nová data, která uskladní do cílového datového atributu. Je nasnadě, že tato nová data metodě Set nabídne klientský kód v podobě argumentu. Tento argument bude vzápětí uložen do implicitně skrytého formálního parametru value metody Set a posléze použit k modifikaci hodnoty soukromého datového atributu. Pokud programujeme v jazyce Visual Basic 2010, je obecně doporučováno upřednostňovat vlastnosti před ryzími přístupovými metodami. Vlastnosti jsou totiž flexibilnější, přičemž z pohledu klientů se ponášejí spíše na inteligentní datové atributy než na metody. V souvislosti s vlastnostmi ovšem musíme mít vždy na paměti tuto skutečnost: Vlastnost je pouze syntaktická konstrukce, která působí jako prostředník mezi datovou sekcií objektu a klientským programovým kódem.

166

4. Základy OOP v jazyce Visual Basic 2010


Dále uvádíme syntaktický obraz třídy Vektor3D, do které jsme zapracovali množinu vlastností: Public Class Vektor3D Private x, y, z As Integer Public Sub New() New x = 1


y = 1 z = 1 End Sub Public Sub New(ByVal New ByVal x As Integer Integer, ByVal y As Integer Integer, _ ByVal z As Integer Integer) Me.x Me = x


Me.y Me = y Me.z Me = z End Sub Public Function ZjistitVelikost() As Double Dim velikostVektoru As Double velikostVektoru = Math.Sqrt(x * x + y * y + z * z)


Return velikostVektoru End Function 'Defi nice vlastnosti pro x-ovou složku vektoru. Public Property SlozkaX As Integer Get Return x End Get .NET Framework 4.0 a vývoj aplikací .NET

Set(ByVal Set ByVal value As Integer Integer) x = value End Set End Property

167

Programování v jazyce Visual Basic 2010 'Defi nice vlastnosti pro y-ovou složku vektoru. Public Property SlozkaY As Integer Get Return y End Get Set(ByVal Set ByVal value As Integer Integer) y = value End Set End Property 'Defi nice vlastnosti pro z-ovou složku vektoru. Public Property SlozkaZ As Integer Get Return z End Get Set(ByVal Set ByVal value As Integer Integer) z = value End Set End Property End Class Podívejme se, jak bude vypadat zdrojový kód našeho předcházejícího programu tehdy, když přístupové metody nahradíme vlastnostmi: Sub Main() Dim vektor As New Vektor3D(9, 3, 5) Console.WriteLine("Vektor má tyto složky: {0}, {1}, {2}.", _ vektor.SlozkaX, vektor.SlozkaY, vektor.SlozkaZ) 'Úprava složek vektoru pomocí přístupových metod. vektor.SlozkaX = 1 vektor.SlozkaY = 0 vektor.SlozkaZ = 1

168

4. Základy OOP v jazyce Visual Basic 2010 Console.WriteLine("Nyní má vektor tyto složky: {0}, {1}, {2}.", _ Visual Basic 2010 na první pohled

vektor.SlozkaX, vektor.SlozkaY, vektor.SlozkaZ) End Sub Patrně s námi budete souhlasit, když prohlásíme, že s vlastnostmi je zdrojový kód nejenom působivější, ale také lépe srozumitelný. Vlastnosti upotřebíme rovněž při tvorbě třídy, jejímiž instancemi budou MP3 přehrávače:


Public Class MP3Prehravac 'Soukromé datové atributy třídy. Private m _ model As String Private m _ pocetPisni As Integer Private m _ pametvGB As Integer 'Bezparametrický konstruktor.


Public Sub New() New m _ model = "Creative ZEN" m _ pocetPisni = 2000 m _ pametvGB = 4 End Sub 'Parametrický konstruktor. Public Sub New New(ByVal ByVal model As String, String ByVal pocetPisni As Integer Integer, _ Základy OOP v jazyce Visual Basic 2010

ByVal pametVGB As Integer Integer) m _ model = model m _ pocetPisni = pocetPisni m _ pametvGB = pametVGB End Sub 'Vlastnost Model.


Public Property Model As String Get Return m _ model End Get Set(ByVal Set ByVal value As String) String

169

Programování v jazyce Visual Basic 2010 m _ model = value End Set End Property 'Vlastnost PocetPisni. Public Property PocetPisni As Integer Get Return m _ pocetPisni End Get Set(ByVal Set ByVal value As Integer Integer) m _ pocetPisni = value End Set End Property 'Vlastnost PametVGB. Public Property PametVGB As Integer Get Return m _ pametvGB End Get Set(ByVal Set ByVal value As Integer Integer) m _ pametvGB = value End Set End Property End Class Komentář k zdrojovému kódu třídy jazyka Visual Basic 2010: Třída MP3Prehravac nám umožní generovat objekty, které budou působit coby konkrétní MP3 přehrávače. V deklaraci třídy se nachází soukromá a veřejná sekce. V soukromé sekci definujeme tři datové atributy s identifikátory m_model, m_pocetPisni a m_pametVGB. První datový atribut je odkazovou proměnnou, do které bude moci být uložen odkaz na instanci třídy System.String. Instance třídy String (ze jmenného prostoru System) jsou objekty, jež zapouzdřují textové řetězce. Datové atributy m_pocetPisni a m_pametVGB jsou hodnotovými proměnnými datového typu Integer. Ve veřejné sekci třídy jsou uloženy definice přetíženého konstruktoru a definice tří vlastností. Konstruktor třídy je přetížený, poněvadž v těle třídy se setkáváme s jeho

170

4. Základy OOP v jazyce Visual Basic 2010


bezparametrickou i parametrickou verzí. Jak si můžeme všimnout, bezparametrický konstruktor provede vytvoření implicitního MP3 přehrávače, kterým je Creative ZEN se 4 GB vestavěné paměti a se schopností uchovat 2000 hudebních skladeb. Na druhou stranu vytvoří parametrický konstruktor MP3 přehrávač přesně podle přání uživatele.


S každým datovým atributem třídy je asociována jedna vlastnost, která slouží k získání a také k přímé modifikaci hodnoty předmětného soukromého datového atributu instance třídy.


Obr. 4.1: Instance třídy MP3Prehravac byla inicializována bezparametrickým konstruktorem.

Třídu MP3Prehravac můžeme použít třeba takto: Sub Main() Dim prehravac As New MP3Prehravac() Console.WriteLine("Máme následující MP3 přehrávač:" & vbCrLf & _ "Model: " & prehravac.Model & vbCrLf & _


"Počet písní: " & prehravac.PocetPisni & vbCrLf & _ "Paměť (v GB): " & prehravac.PametVGB) End Sub


V těle hlavní funkce Main nejprve definujeme lokální odkazovou proměnnou prehravac. V dalším příkazu pomocí operátoru New zakládáme instanci třídy MP3Prehravac, kterou inicializujeme bezparametrickým konstruktorem. Jakmile je instance alokována a inicializována, dochází rovněž k inicializaci odkazové proměnné prehravac. V této proměnné se počínaje tímto okamžikem nachází odkaz na žijící instanci třídy MP3Prehravac, která je situována v řízené haldě. Program pokračuje vypsáním základních konfiguračních nastavení vygenerovaného MP3 přehrávače. Vzhledem k tomu, že třída MP3Prehravac obsahuje parametrický konstruktor, můžeme ji použít také následujícím způsobem: Sub Main() Dim prehravac As New MP3Prehravac("iPod nano", 4000, 8)

171

Programování v jazyce. Visual Basic Ján Hanák. Nakladatelství a vydavatelství R

Recommend Documents