Vysoká škola ekonomická v Praze

Vysoká škola ekonomická v Praze Fakulta informatiky a statistiky Katedra informačních technologií Studijní program: Aplikovaná informatika Obor: Informační systémy a technologie

Diplomant: Bc. Marek Demčák Vedoucí diplomové práce: Ing. Rudolf Pecinovský, CSc. Oponent diplomové práce: Ing. Jarmila Pavlíčková

Programovací jazyk Objective-C a účelnost jeho zařazení do výuky

školní rok 2009/2010

Bc. Marek Demčák – Programovací jazyk Objective C a účelnost jeho zařazení do výuky

PROHLÁŠENÍ Prohlašuji, že jsem diplomovou práci zpracoval samostatně a že jsem uvedl všechny použité prameny a literaturu, ze kterých jsem čerpal.

V Praze dne

………………………………. Podpis

Stránka 2 z 80


ABSTRAKT Tato diplomová práce se zabývá popisem programovacího jazyka Objective-C, který je primárním programovacím jazykem pro operační systém Mac OS X, a posouzením účelnosti jeho zařazení do výuky. Cílem první části je poskytnout čtenáři základní výklad syntaxe jazyka tak, aby byl schopen porozumět napsanému programovému kódu a zjistit, zda by jej programování v tomto jazyku bavilo. Práce si neklade za cíl naučit čtenáře v jazyku Objective-C vytvářet vlastní aplikace, a to zejména kvůli velmi omezenému popisu knihoven tříd (Cocoa, Cocoa Touch), jejichž znalost je pro vytváření aplikací nezbytná. Všem zájemcům o programování v Objective-C však poskytne vhodný „odrazový můstek“ a odkáže je na další související zdroje. Ve druhé části je jazyk postupně posuzován na základě 10 zvolených kritérií, které mají vliv na účelnost zařazení jazyka do výuky. Cílem této části práce je poskytnou čtenáři dostatek argumentů pro rozhodnutí, zda má smysl pořádat výukový kurz Objective-C či nikoli. Součástí práce je např. základní srovnání jazyku Objective-C s ostatními jazyky (zejména Java a C#), posouzení souladu jazyka s principy objektově orientovaného programování, recenze vývojového prostředí Xcode, analýza poptávky po programátorech Objective-C v České republice a analýza zájmu studentů VŠE o kurz Objective-C. V závěru práce jsou shrnuty nejpodstatnější vlastnosti jazyka, jeho největší přínosy a nedostatky. Uveden je též profil „typického“ programátora v Objective-C, který je sestaven na základě vyhodnocení kritérií ve druhé části práce.

Klíčová slova: Objective-C, programovací jazyk, Cocoa, Xcode, Apple, Mac OS X

Stránka 3 z 80


ABSTRACT This thesis describes a programming language Objective-C, which is the primary programming language for Mac OS X, and assesses the suitability of language inclusion in education. The aim of the first part is to provide the reader with a basic explanation of the language syntax so as to be able to understand what is written for code. After reading this thesis, the reader should have enough information to decide whether he would enjoy programming in Objective-C or not. Thesis does not aim to teach the reader in Objective-C language to create custom applications, mainly due to very limited description of the class libraries (Cocoa, Cocoa Touch), whose knowledge is essential for building real applications. However, the thesis should be a good starting point for all people interested in Objective-C and should refer them to appropriate literature. In the second part, I assess the suitability of language inclusion in education from 10 points of view (criteria). The aim of this part is to provide enough arguments for a decision, whether it is the good idea to provide tuition of Objective-C language or not. Some of the points of view are: basic confrontation of Objective-C with other programming languages (mainly Java and C#), assessing compliance of Objective-C language with the principles of object-oriented programming, review of Xcode IDE, analysis of demand for Objective-C programmers in the Czech Republic and analysis of students’ interest in learning Objective-C by online (only students at University of Economics, Prague). The conclusion summarizes the most important properties of the language, its greatest benefits and drawbacks. I have also described the profile of a "typical" programmer in Objective-C, based on evaluated criteria.

Keywords: Objective-C, programming language, Cocoa, Xcode, Apple, Mac OS X Stránka 4 z 80


PODĚKOVÁNÍ Děkuji panu Ing. Rudolfu Pecinovskému, CSc. za odborné vedení této diplomové práce, poskytnutí cenných rad a upozornění na chyby, kterých jsem se v průběhu psaní dopouštěl.

Stránka 5 z 80


OBSAH Prohlášení .............................................................................................................................................................................2 Abstrakt..................................................................................................................................................................................3 Abstract ..................................................................................................................................................................................4 Poděkování ...........................................................................................................................................................................5 Obsah.......................................................................................................................................................................................6 1

2

Úvod ...............................................................................................................................................................................9 1.1

Důvody k napsání této práce......................................................................................................................9

1.2

Cíle práce a způsoby jejich dosažení .................................................................................................... 13

1.3

Přínosy a omezení práce ........................................................................................................................... 14

1.4

Použité konvence ......................................................................................................................................... 14

Jazyk Objective-C ................................................................................................................................................... 15 2.1

Letmý pohled do historie jazyka Objective-C................................................................................... 15

2.2

Kde se můžeme s jazykem Objective-C potkat a proč potřebujeme knihovny tříd? ........ 16

2.3

Stručný úvod do jazyka C – „Neobjektová část Objective-C“...................................................... 17

2.3.1

Obecně o jazyku C .............................................................................................................................. 17

2.3.2

Komentáře............................................................................................................................................. 18

2.3.3

Proměnné, základní datové typy, ukazatele, pole, struktury a konstanty .................. 18

2.3.4

Definice funkcí a funkce main ....................................................................................................... 21

2.3.5

Příkazy pro větvení a cykly ............................................................................................................ 22

2.3.6

Zdrojový kód ve více souborech – příkaz #include a hlavičkové soubory ................. 22

2.3.7

Využití funkcí ze standardní knihovny jazyka C.................................................................... 23

2.4

Pár slov o jazyku Smalltalk – „Objektová část Objective-C“ ....................................................... 24

2.4.1

Souvislost jazyku Smalltalk s jazykem Objective-C.............................................................. 24 Stránka 6 z 80


3

2.4.2

Historie a základní vlastnosti Smalltalku ................................................................................. 24

2.4.3

Zasílání zpráv ....................................................................................................................................... 25

2.5

Základní rysy Objective-C......................................................................................................................... 27

2.6

Typy a konstanty Objective-C pro práci s objekty, vybrané základní třídy ......................... 27

2.7

Definice Vlastních tříd, kategorií, rozšíření a protokolů ............................................................. 29

2.7.1

Definice vlastních tříd ...................................................................................................................... 29

2.7.2

Kategorie a rozšíření ........................................................................................................................ 32

2.7.3

Protokoly ............................................................................................................................................... 35

2.8

Vytváření instancí a zasílání zpráv, překrývání metody init ..................................................... 36

2.9

Standardní zprávy třídy NSObject ........................................................................................................ 37

2.10

Přeposílání zpráv – Forwarding ............................................................................................................ 38

2.11

Explicitní správa paměti ........................................................................................................................... 39

Účelnost zařazení jazyka Objective-C do výuky........................................................................................ 41 3.1

Kritéria účelnosti zařazení jazyka do výuky ..................................................................................... 41

3.2

Vstupní bariéry ............................................................................................................................................. 43

3.3

Perspektivnost jazyka ................................................................................................................................ 43

3.4

Podobnost jazyka s ostatními ................................................................................................................. 45

3.5

Náročnost syntaxe ....................................................................................................................................... 47

3.6

Dostupnost a použitelnost vývojového prostředí .......................................................................... 48

3.6.1

Stručné představení XCode ............................................................................................................ 48

3.6.2

Základní okno aplikace, Vytváření projektů a psaní kódu ................................................ 48

3.6.3

Editor ER diagramů ........................................................................................................................... 51

3.6.4

Tvorba grafického uživatelského rozhraní ............................................................................. 51 Stránka 7 z 80


4

3.7

Dostupnost literatury................................................................................................................................. 53

3.8

Soulad s myšlenkami OOP a možnosti implementace návrhových vzorů............................ 54

3.8.1

Aplikace zásad OOP na jazyk Objective-C ................................................................................ 54

3.8.2

Implementace vybraných návrhových vzorů ......................................................................... 56

3.9

Okamžitý užitek ze znalosti ..................................................................................................................... 58

3.10

Zájem o programátory na trhu práce .................................................................................................. 59

3.11

Průzkum zájmu studentů o Objective-C mezi studenty VŠ v ČR .............................................. 60

3.12

Vyhodnocení kritérií................................................................................................................................... 61

Závěr ........................................................................................................................................................................... 63 4.1

Shrnutí diplomové práce .......................................................................................................................... 63

4.2

Zhodnocení míry naplnění cílů a náměty na rozšíření práce .................................................... 66

5

Terminologický slovník ...................................................................................................................................... 68

6

Rejstřík....................................................................................................................................................................... 70

7

Bibliografie ............................................................................................................................................................... 72

Příloha 1: Výtah z výsledků internetového průzkumu .................................................................................... 77

Stránka 8 z 80


1 ÚVOD 1.1 DŮVODY K NAPSÁNÍ TÉTO PRÁCE Svět, ve kterém žijeme, se neustále mění. Každý rok jsou uváděny na trh nové výrobky, nové technologie, nové postupy. Přestože mnohé z těchto novinek končí v propadlišti dějin dříve, než někomu vydělají balík peněz (kdo si dnes třeba prohlíží v mobilním telefonu wapové stránky?), neexistuje podle mě dnes odvětví, které by během pěti až deseti let pravidelně nezasáhla nějaká radikálnější změna. Schopnost včasné reakce na tyto změny se stala nutnou podmínkou k úspěchu, a v mnoha případech i k získání nebo udržení (dobře placené) práce. Ty tam jsou doby, kdy se člověk vyučil jednomu řemeslu nebo vystudoval jednu vysokou školu, našel si zaměstnání, a v něm vydržel až do důchodu bez průběžného vzdělávání. Určitě bych se třeba dobrovolně neodvážil navštívit zubaře „ze staré školy“, který se obejde bez moderního zubařského křesla a možnosti využívat rentgen, anestezii, kameru a další vymoženosti. Preferuji zubaře, který je schopen odhalit kaz dříve, než si všimnu prvních příznaků. Podobná situace nastává prakticky u všech oborů a řemesel, a přestože jako student informatiky a programátor webových aplikací nemohu být nezaujatý, mám pocit, že v oblasti informatiky je tlak na průběžné sebevzdělávání jeden z nejsilnějších1. Zatímco před lety stačilo udělat web, na který mohl zadavatel (nejlépe s využitím nějakého administračního rozhraní) „pověsit nějaké informace“, dnes je nutné weby optimalizovat pro vyhledávače, vytvořit mapu stránek a ve většině případů přidat módní „sociální funkce“. Nutnost přizpůsobení se aktuálním trendům nejvíce pozoruji na některých starších kolezích programátorech, kteří již neměli sílu nebo chuť se dále vzdělávat, a byli postupně z firmy, ve které pracuji, propuštěni. I díky nim věnuji větší pozornost aktuálním trendům v informačních technologiích (IT). Za jeden z nejvýznamnějších trendů (mimo sociální sítě) lze v tomto momentě označit nástup chytrých telefonů (viz např. [1]), které v mnoha ohledech zvládnou zastoupit osobní počítač.

1

Hůře jsou na tom snad jen daňoví poradci…

Stránka 9 z 80


Dle [2] se očekává nárůst podílu chytrých telefonů až na 38%, což s sebou přinese jeden zajímavý vedlejší efekt – oslabení pozice jazyku Java (přesněji Java Micro Edition, Java ME)2. Ještě před dvěma až třemi lety zaplňovaly stránky novin a časopisů celostránkové inzeráty s java hrami do mobilu a nejrůznějších více či méně praktických aplikací. Dnes? Minimální reklamní prezentace. Sám jsem pár aplikací v Java ME naprogramoval, a mám pro ústup a faktický neúspěch této platformy 3 hlavní důvody: 1. Nekompatibilita: Z vlastní zkušenosti vím, že si každý telefon pod pojmem „podpora Java ME aplikací“ představoval něco jiného. Často se nebylo možné 100% spolehnout ani na základní standardy MIDP 1.0 / MIDP 2.0, nutnost ladit každou aplikaci pro velké množství různých telefonů činilo vývoj nesmírně nákladný. 2. Chybějící API: Mnoho aplikací se zajímavým tržním potenciálem bylo závislé na podpoře konkrétního API (JSR) – ať už se jednalo o využití polohového senzoru, GPS, fotoaparátu nebo multimédií, vždy se vytvářela aplikace pro velmi omezenou skupinu „vyvolených“ telefonů. I když telefon například obsahoval rozhraní Bluetooth nebo fotoaparát, neznamenalo to, že se k němu bude možné v Java ME „dostat“. 3. Pirátství: Aplikace v Java ME prakticky nebylo možné nikterak zabezpečit proti ilegálnímu stahování z internetu (snad s výjimkou aktivace přes internet, která se příliš neprosadila). V případě legálního prodeje docházelo a dochází ve většině případů k prodeji prostřednictvím drahé kombinace Premium SMS a WAP PUSH SMS3. Při pohledu na výše uvedené 3 důvody neúspěchu se nabízí otázka, v čem je to v případě chytrých telefonů jiné? Vyplatí se pro ně vůbec vytvářet aplikace?

2

Zatímco na poli telefonů bez operačního systému představuje Java ME často jedinou možnost, jak do

telefonu přidat nějakou funkcionalitu, telefony s operačním systémem obsahují podporu Java ME spíše ze zvyku a pouze v omezené míře (nejsou např. podporovány aplikace využívající funkci Bluetooth nebo GPS). Primárním způsobem rozšiřování funkcionality telefonů s operačním systémem je instalace aplikací, které byly vytvořeny přímo pro daný operační systém. 3

Klient zaplatil desítky korun za aplikaci, ze kterých kvůli provizi operátorů prodejce získal jen cca. 50%.

Dále ve většině případů zaplatil ještě několik (desítek) korun za samotné stažení aplikace přes GPRS.

Stránka 10 z 80


Je pravda, že i nyní existuje mnoho „druhů“ chytrých telefonů. Tyto telefony se však z hlediska programátorů liší zejména použitým operačním systémem – ten do velké míry předurčuje, jaké aplikace na daném telefonu půjde spustit. V rámci daného operačního systému však již k velkým problémům nedochází4, čehož důkazem jsou např. požadavky jednotlivých aplikací (uvádí se pouze kompatibilita s operačním systémem, nikoli konkrétními modely). Společným rysem všech chytrých telefonů současnosti5 je upozaděná podpora Java ME aplikací, zdůvodňovaná zejména vyšším výkonem a nižšími hardwarovými požadavky nativních (nebo alespoň nepřenositelných) aplikací. Tlak na vývoj aplikací „šitých na míru“ konkrétním operačním systémům se většinou projevuje distribucí omezeného virtuálního stroje Java ME (chybí např. JSR pro podporu specifického hardware pro konkrétní přístroje – toto se týká např. vývoje pro Symbian [3]), absencí virtuálního stroje Java ME v základní instalaci (např. do Windows Mobile 6.5 je nutné podporu Java ME doinstalovat, podpora JSR je u zdarma dostupného stroje Esmertec JBed velmi chudá), nebo dokonce zákazem instalace Java ME aplikací (iPhone OS [4]). Velmi nepravděpodobná je podpora Java ME v připravovaném systému Windows Phone 7 [5]. Při vývoji aplikací pro chytré telefony je díky ústupu technologie Java ME nutné začít psát nepřenositelné aplikace. V rámci českého (popř. evropského) trhu se má smysl rozhodovat mezi vývojem pro Symbian, Windows Mobile, iPhone OS (OS X iPhone) a Android (upravený Linux od Googlu). Detailní srovnání těchto operačních systémů by zabralo mnoho stránek. Bez ohledu na aktuální procentuální zastoupení mobilních operačních systémů však lze nepochybně za největší „štiky na trhu“ označit přístroje s iPhone OS od firmy Apple Inc. Žádný telefon neměl v médiích od uvedení prvního iPhone tolik prostoru jako iPhone, a přestože ve srovnání konkrétních parametrů mnohdy pokulhává, jeho podíl na trhu výrazně roste na úkor podílů přístrojů s operačními systémy Symbian nebo Windows Mobile [4]. 4

Samozřejmě nalezneme telefony s QWERTY klávesnicí i bez, telefony bez podpory polohového senzoru

apod., díky OS se však v nativních aplikacích vždy dostaneme na hardware, kterým telefon disponuje, nic není skryto. Chytrý telefon bez přítomnosti GPS, fotoaparátu, Bluetooth, WiFi, dotekového displeje je dnes neprodejný, takže v základu nabízí chytré telefony rozhodně více funkcionality než ty „hloupé“. 5

Jedinou „výjimkou potvrzující pravidlo“ jsou mobilní telefony značky BlackBerry.

Stránka 11 z 80


Lidé příliš nelpí na konkrétních hardwarových parametrech, podstatné pro ně je (bez ohledu na pořadí), jak telefon vypadá, jak snadno se ovládá a co všechno umí (k čemu všemu se dá použít). Firma Apple vytvořila zařízení s inovativním způsobem ovládání, zajímavou kombinací hardware (nic důležitého nechybí), a nechala z velké míry na samotných vývojářích a uživatelích, k jakému účelu jej bude možné používat. Díky bezplatnému vývojovému prostředí již vzniklo více než 100 000 aplikací pro iPhone [6]. Všechny tyto aplikace lze prodávat i nakupovat na jednom místě – App Store. Uživatelé za aplikace rádi zaplatí v jednotkách dolarů, protože to je pro ně jednodušší a možná i levnější, než složitá instalace aplikací stažených někde pokoutně z internetu. Vývojáři z každé prodané aplikace poté získávají 70%, což s ohledem na počet uživatelů iPhone činí vývoj zajímavým. Díky iPhone a zřejmě také potenciální možnosti rozšíření Mac OS X6 v posledním roce prudce vzrostla popularita jazyka Objective-C (viz obrázek 1 na další straně), který je pro programování v „Mac světě“ primární. Pro vývojáře, kteří se nyní rozmýšlí, jakým směrem se dále ubírat, nabízí myslím jazyk Objective-C poměrně dobrou perspektivu. Ale nejen pro ně – pro ty, kteří dosud neprogramovali, by se mohl stát jazyk Objective-C vhodným „startovacím jazykem“, přinejmenším z toho důvodu, že by si třeba rádi tu a tam ve volném čase napsali nějakou aplikaci pro svůj telefon. Z výše popsaných důvodů jsem se rozhodl tuto diplomovou práci zasvětit jazyku Objective-C a posouzení účelnosti jeho zařazení do výuky.

6

Veškeré produkty firmy Apple tvoří svůj (téměř uzavřený) ekosystém. Kdo si pořídí iPhone a zalíbí se mu

jeho používání, může mít větší tendenci si pořídit také počítač s operačním systémem Mac OS X.

Stránka 12 z 80


OBRÁZEK 1: POPULARITA RŮZNÝCH PROGRAMOVACÍCH JAZYKŮ – ZDROJ: [7]

1.2 CÍLE PRÁCE A ZPŮSOBY JEJICH DOSAŽENÍ Hlavním cílem této diplomové práce je v první části poskytnout čtenáři přehled o programování v jazyku Objective-C a ve druhé části zhodnotit účelnost jeho zařazení do výuky. První část se tedy bude týkat zejména popisu syntaxe jazyka Objective-C s některými krátkými ukázkami kódu, aby si čtenář mohl představit, jak kód v jazyce Objective-C vypadá a jaké jsou základní pilíře tohoto jazyka. Hlavním zdrojem informací pro první část je kniha Cocoa – úvod do programování počítačů Apple od Ondřeje Čady [8], která je v době psaní této práce jedinou českou knihou věnující se tomuto tématu. Dalším zdrojem informací je dokumentace jazyka na stránkách developer.apple.com a mnoho dalších internetových stránek. Druhá část diplomové práce, věnovaná účelnosti zařazení jazyka Objective-C do výuky, bude v úvodu definovat kritéria, podle kterých budu o účelnosti rozhodovat, a následně podle těchto kritérií budu jazyk také hodnotit. Kromě „didaktických“ kritérií, mezi které lze například zařadit soulad jazyka Objective-C s metodikou objektově orientovaného programování, jsem se rozhodl přihlédnout i ke kritériím, která se týkají praxe – zda je o programátory Objective-C zájem na trhu práce (toto bude zjištěno analýzou nabídek na pracovních serverech a na Stránka 13 z 80


stránkách firem, které se vývojem v Objective-C zabývají) a zda je pro studenty informatiky v současné době vůbec studium Objective-C dostatečně atraktivní (toto bude řešeno pomocí online průzkumu, při kterém budou osloveni studenti VŠE v Praze).

1.3 PŘÍNOSY A OMEZENÍ PRÁCE Hlavním přínosem této práce by měla být jakási „demystifikace“ programování v Objective-C. Čtenář by měl být po jejím přečtení schopen se sám rozhodnout, zda pro něj má smysl se tento jazyk naučit používat, zda by ho programování v tomto jazyce bavilo a zda by byl schopen (ochoten) v něm vůbec něco tvořit. Přestože bude v této práci popsána syntaxe jazyka Objective-C, nekladu si za cíl skutečně naučit čtenáře v tomto jazyku programovat. V práci však poskytnu všem zájemcům dobrý „odrazový můstek“ a odkážu je na další zdroje, s jejichž pomocí již budou schopni plnohodnotně tvořit první aplikace pro iPhone a celý operační systém Mac OS X. Část týkající se zhodnocení účelnosti zařazení jazyka Objective-C pro výuku by měla poskytnout dostatek argumentů k rozhodnutí, zda do studijních programů jazyk Objective-C zařadit či nikoli. Práce je určena především lidem, kteří již o objektovém programování něco vědí (např. programují v Javě), a rozhodují se, zda rozšířit své znalosti a dovednosti o další jazyk. Dále je tato práce určena všem, kteří mají nějakou rozhodovací moc nad tvorbou studijních plánů nebo kteří uvažují, jaké předměty by mohli nabízet k výuce (např. v rámci soukromého školicího střediska).

1.4 POUŽITÉ KONVENCE [1]

Čísla v hranatých závorkách označují pořadí pramene uvedeného na konci diplomové práce.

NSString

Tučným neproporcionálním písmem jsou vysázeny části programového kódu

v rámci odstavců běžného textu, názvy souborů a internetové adresy. Kód programu

Neproporcionálním písmem se zeleným podbarvením jsou vysázeny ukázky programového kódu.

Termín

Kurzívou jsou vysázeny termíny uvedené v terminologickém slovníku (termíny jsou takto označeny v místě prvního užití).

Stránka 14 z 80


2 JAZYK OBJECTIVE-C 2.1 LETMÝ POHLED DO HISTORIE JAZYKA OBJECTIVE-C

OBRÁZEK 2: POPULARITA OBJECTIVE-C – ZDROJ: [7]

Přestože popularita jazyka Objective-C začala strmě stoupat až v průběhu roku 2009 (viz obrázek 2), jedná se o poměrně starý a léty ověřený jazyk s kořeny v osmdesátých letech 20. století (viz [9], [10]). Tehdy se ve snaze o lepší znovupoužitelnost naprogramovaných kódů začal významněji uplatňovat objektově orientovaný přístup k programování. Brad Cox a Tom Love z firmy Stepstone si vzali znovupoužitelnost opravdu k srdci, a namísto toho, aby vytvořili zcela nový objektový jazyk, použili starý a osvědčený procedurální jazyk C, který doplnili o podporu objektů v duchu jazyka Smalltalk ze sedmdesátých let7 (rozšířili kompilátor jazyka C o podporu objektů se syntaxí podobnou jazyku Smalltalk).

7

V čistém slova smyslu tak není jazyk Objective-C skutečným „plnohodnotným“ jazykem, ale pouhou

objektovou nadstavbou jazyka C. Jelikož se však běžně používá spojení „jazyk Objective-C“, rozhodl jsem se pro lepší čitelnost práce pro zjednodušené označení „jazyk Objective-C“.

Stránka 15 z 80


V roce 1986 byl jazyk Objective-C publikován v knize „Object-Oriented Programming, An Evolutionary Approach“ a o dva roky později byl licencován společností NeXT, kterou založil Steve Jobs během několikaleté „přestávky“ v práci pro společnost Apple. V rámci firmy NeXT byl jazyk Objective-C využit pro tvorbu operačního systému NeXTstep a při té příležitosti dostal také nový překladač. Následně firma NeXT ve spolupráci s firmou Sun Microsystems vytvořila standardizovanou verzi NeXTstepu s názvem OPENstep, kterou opensourcová komunita pod hlavičkou Free Software Foundation adoptovala pod názvem GNUstep. Mezitím v devadesátých letech 20. století začala firma Apple postupně ztrácet podíl uživatelů svého operačního systému Mac OS. Namísto dalšího rozvoje Mac OS bylo rozhodnuto, že dojde k akvizici již některého zaběhnutého systému, a volba nakonec padla na „Jobsův“ systém NeXTstep, čímž se Steve Jobs postupně vrátil do (vedení) firmy Apple. Jazyk Objective-C se stal základem pro nový operační systém Mac OS X vycházející z NeXTstepu. I když je jazyk Objective-C již poměrně starý, jeho vývoj rozhodně neustrnul v devadesátých letech 20. století. Jazyk a jeho platformy se nadále vyvíjejí a reagují na současné trendy v programování. V roce 2007 byl například uveden nový kompilátor jazyka Objective-C 2.0, který oproti původní verzi jazyka přinesl mj. podporu atributů a automatickou správu paměti (garbage collector) pro platformy využívající framework Cocoa – více o novinkách v Objective-C 2.0 se lze dočíst v [11].

2.2 KDE SE MŮŽEME S JAZYKEM OBJECTIVE-C POTKAT A PROČ POTŘEBUJEME KNIHOVNY TŘÍD? Jazyk Objective-C je primárním programovacím jazykem v „jablečném světě“. Prostupuje prakticky všemi produkty firmy Apple – od počítačů Macintosh přes tablety iPad, telefony iPhone až po hudební přehrávače iPod. Ve všech těchto přístrojích lze spustit aplikace psané v tomto jazyce. Díky projektu GNUstep [12] existují překladače jazyka Objective-C také pro operační systémy Windows a Linux, nepodařilo se mi však nalézt žádné široce rozšířené aplikace, které by s jeho pomocí byly vytvořeny – jedná se spíše o projekt pro uzavřenější skupinu lidí.

Stránka 16 z 80


Jelikož je Objective-C pouze objektová nadstavba pro jazyk C (umožňuje objektové programování, ale sama o sobě nedefinuje žádné třídy8) a programování čistě s využitím jeho možností by bylo poněkud nepohodlné, využívá se Objective-C ve většině případů ve spojení s nějakou knihovnou tříd (chcete-li frameworkem). Právě s pomocí knihoven tříd (někdy též „knihovny objektů“) jsou vývojářům zpřístupněny objekty reprezentující základní datové typy, prvky uživatelského rozhraní atd. Nejpoužívanějšími a nejznámějšími knihovnami objektů jsou Cocoa (pro počítače s Mac OS X), Cocoa Touch (pro mobilní telefony iPhone, tablety iPad a hudební přehrávače iPod Touch), GNUstep a Cocotron.

2.3 STRUČNÝ ÚVOD DO JAZYKA C – „NEOBJEKTOVÁ ČÁST OBJECTIVE-C“ 2.3.1 OBECNĚ O JAZYKU C Jazyk Objective-C je pouze objektovou nadstavbou jazyka C – veškeré konstrukce, funkce a vlastnosti jazyka C jsou tudíž platné i v Objective-C. Z tohoto důvodu jsem se rozhodl do této práce zařadit i krátký úvod do jazyka C, bližší informace naleznou zájemci v dokumentaci [13]. Jazyk C [13] lze označit za nízkoúrovňový9, procedurální (základem programování je popis algoritmu pomocí posloupnosti příkazů) a kompilovaný (zdrojový kód se překládá kompilátorem do podoby spustitelného souboru). Využívají se v něm 3 základní způsoby ukládání dat [14] – statická alokace paměti (takto je uložen programový kód včetně hodnot konstant), automatická alokace paměti na zásobníku (tímto se předávají parametry funkcím, vracejí hodnoty funkcí a udržují návratové adresy po ukončení funkce) a dynamická alokace paměti na haldě (takto se ukládají proměnné). S pamětí se pracuje za pomoci speciálního

8

V samotném Objective-C nenajdeme dokonce ani objektové reprezentace základních datových typů

(řetězce, čísla). K dispozici máme jen „neobjektové“ datové typy převzaté z jazyka C. 9

Jazyk C je jen o řád „výše“, než jazyk symbolických adres (JSA), u kterého jednotlivé příkazy

reprezentují vždy volání jedné strojové instrukce určitého procesoru. Na této úrovni máme přístup přímo k paměti (a jiným registrům) daného přístroje a zároveň již nemusíme řešit kompatibilitu příkazů s instrukční sadou daného procesoru – o to se již stará překladač jazyka C. Pomocí direktivy __asm navíc můžeme v případě potřeby příkazy jazyka C kombinovat s příkazy JSA.

Stránka 17 z 80


datového typu ukazatel, který v sobě drží odkaz na paměťový prostor vyhrazený pro určitou proměnnou nebo i funkci (více o ukazatelích viz níže). V jazyku C neexistuje žádný mechanismus automatického uvolnění (dealokace) paměti – o přidělování i uvolňování se musí postarat programátor sám, nemůže se spoléhat na garbage collector známý například z jazyků Java nebo C#. Nižší pohodlí při programování je kompenzováno podstatně nižšími hardwarovými nároky vytvářených aplikací10. Syntaxe jazyka C se stala základem nejen jazyka Objective-C, ale ovlivnila také další současné jazyky – například C++, Perl, Java, C# nebo PHP11.

2.3.2 KOMENTÁŘE Komentáře můžeme v jazyku C vytvářet podobně jako například v Javě - jednořádkové komentáře uvedeme dvojicí znaků //, víceřádkové komentáře můžeme umístit mezi sekvenci znaků /* a */. // Jednořádkový komentář se vkládá takto. /* Víceřádkový komentář se vkládá takto. */

2.3.3 PROMĚNNÉ, ZÁKLADNÍ DATOVÉ TYPY, UKAZATELE, POLE, STRUKTURY A KONSTANTY Proměnné slouží pro ukládání různých typů dat, se kterými v námi napsaném programu pracujeme. Při vytváření (deklaraci) nějaké proměnné jí musíme vždy zvolit nějaký název, určit její typ a případně ovlivnit její dostupnost v rámci programu. Název proměnné může být tvořen malými a velkými písmeny anglické abecedy, číslicemi a podtržítkem, přičemž první znak názvu musí být vždy písmeno. Při psaní proměnných je zapotřebí dodržovat velikost písmen.

10

Přestože bylo o několik řádků výše uvedeno, že Objective-C 2.0 již disponuje pro některé platformy

mechanismem automatického uvolňování paměti, nelze jej alespoň prozatím z důvodu vysokých hardwarových nároků použít při kompilování aplikací pro jednodušší zařízení typu iPhone. 11

S trochou nadsázky tak můžeme jazyk C označit jako takovou „latinu mezi programovacími jazyky“.

Stránka 18 z 80


V jazyku C máme k dispozici následující nejpoužívanější základní datové typy (bližší detaily a některé méně používané datové typy viz [13]): -

void – žádná hodnota (využije se zejména pro definici funkcí bez návratové hodnoty)

-

unsigned char

– uchovávání jednoho 8-bitového znaku nebo číselné hodnoty v rozpětí 0

– 255 -

char

– uchovávání jednoho 8-bitového znaku nebo číselné hodnoty v rozpětí -128 – 128

-

unsigned int

-

int

-

unsigned long

-

long

-

float

-

double

– uchovávání 16-bitového čísla, rozpětí hodnot 0 – 65 535

– uchovávání 16-bitového čísla, rozpětí hodnot -32 768 – 32 767 – uchovávání 32-bitového čísla, rozpětí hodnot 0 – 4 294 967 295

– uchovávání 32-bitového čísla, rozpětí hodnot -2 147 483 648 – 2 147 483 647 – uchovávání 32-bitového čísla s plovoucí řádovou čárkou – uchovávání 64-bitového čísla s plovoucí řádovou čárkou

Pokud proměnnou deklarujeme v rámci nějakého bloku kódu uzavřeného do složených závorek (včetně těla funkcí – viz níže), je standardně platná vždy v rámci tohoto bloku kódu od místa deklarace do konce aktuálního bloku. Pakliže k deklaraci dochází mimo jakýkoli blok, je proměnná standardně platná v rámci celého souboru zdrojového kódu. Rozsah platnosti však můžeme ovlivnit, a to přidáním klíčového slova před deklaraci typu proměnné. Nejpoužívanějšími modifikátory platnosti jsou extern (dovoluje přistupovat k proměnné deklarované v jiném souboru) a static. Proměnná, která je deklarovaná uvnitř nějakého bloku kódu s pomocí modifikátoru static (nejčastěji uvnitř těla funkce), si ponechává svoji hodnotu i po dokončení zpracování tohoto bloku. V případě, že je blok kódu zavolán znovu, neprovádí se již nová deklarace proměnné a můžeme pracovat s původní hodnotou. Ukázka definice proměnných základních datových typů: int cislo = 45; char znak = "A"; extern int ciziCislo;

// // // // // static long pocitadlo; //

deklarace proměnné typu int s názvem cislo a hodnotou 45 deklarace proměnné typu char s názvem znak a hodnotou A deklarace externí proměnné typu int s názvem ciziCislo; externí proměnná je deklarována v jiném souboru (v místě „opravdové“ deklarace je proměnná deklarována bez „extern“) deklarace statické proměnné typu long s názvem pocitadlo

Stránka 19 z 80


Kromě základních datových typů existují v jazyku C ještě odvozené datové typy: -

ukazatele

-

pole

-

struktury

Ukazatele v sobě uchovávají odkaz na určité paměťové místo, na kterém je uložena hodnota proměnné určitého typu. Deklarace ukazatele je dána uvedením datového typu proměnné, na kterou chceme ukazovat, modifikátorem * a jeho názvem [15]. Chceme-li získat adresu paměti libovolné proměnné, zapíšeme před název proměnné znak &. Ukázka práce s ukazateli: int normalniPromenna = 45; int *ukazatelNaInt; ukazatelNaInt = &normalniPromenna; char *jinyUkazatel = 123;

// // // // //

deklarace proměnné typu int deklarace ukazatele na proměnnou typu int nastavení ukazatele na hodnotu normalniPromenna nastavení ukazatele na proměnnou typu int s hodnotou 123

Pole slouží k vytváření sady proměnných stejného typu o určité délce [15]. Deklarují se uvedením typu proměnné, názvu pole a počtem proměnných (počet se uvádí v hranatých závorkách za název pole). Proměnná typu pole v sobě obsahuje vždy ukazatel na hodnotu první proměnné v sadě, pro přístup k dalším hodnotám můžeme zapsat pořadí hodnoty v hranatých závorkách (index pole, číslovaný od nuly). Alternativně lze k hodnotám dalších proměnných dospět přičtením celého čísla k ukazateli na libovolnou proměnnou v sadě. Jelikož v jazyku C neexistuje datový typ odpovídající textovému řetězci, je nutné veškeré texty deklarovat jako pole znaků. Při práci s poli v jazyku C je zapotřebí mít na paměti, že indexy polí nejsou nikterak kontrolovány – pokusíme-li se získat hodnotu jedenácté proměnné z desetiprvkového pole, získáme pravděpodobně (část) hodnoty jiné proměnné, která je v paměti uložena hned za hodnotami pole (obdobný případ nastane v případě záporného indexu pole). Kromě jednoduchých polí je možné definovat rovněž vícerozměrná pole, a to jednoduše uvedením počtů proměnných pro každý rozměr. Ukázka práce s poli: char[10] zprava = "Ahoj svete"; char *prvniZnak = zprava; char *druhyZnak = zprava[1]; char *tretiZnak = zprava+2; zprava[0] = "a"; int[2][3] matice = {1,2,3},{4,5,6};

// // // // // //

definice pole s 10 znaky ukazatel prvniZnak ukazuje na znak „A“ ukazatel druhyZnak ukazuje na znak „h“ ukazatel tretiZnak ukazuje na znak „o“ změna prvního znaku na znak „a“ definice dvourozměrného pole 2x3

Stránka 20 z 80


Struktury slouží podobně jako pole k vytváření sad proměnných, rozdíl je pouze v tom, že tyto proměnné mohou být různého typu. Strukturu deklarujeme pomocí klíčového slova struct, za kterým ve složených závorkách uvedeme jednotlivé proměnné. Nakonec uvedeme název struktury. Pro přístup k jednotlivým proměnným v rámci struktury můžeme použít operátor ->. Ukázka práce se strukturami (více informací o strukturách lze nalézt např. v [16]): struct Osoba { char[10] pozdrav = "Ahoj svete"; int vek = 24; } karel;

// definice struktury

karel->vek = 25;

// nastavení proměnné vek uvnitř struktury

Jazyk C neobsahuje žádný datový typ odpovídající booleovským hodnotám true a false (ekvivalentem může být typ int, kde hodnota 0 odpovídá hodnotě false a jakákoli jiná hodnota odpovídá hodnotě true). Vedle proměnných je možné uchovávat data také v konstantách, které se definují pomocí klíčového slova const: const float PI = 3.14;

// definice konstanty PI typu float

2.3.4 DEFINICE FUNKCÍ A FUNKCE MAIN V rámci všech procedurálních programů se definují funkce, které sdružují vždy určitou skupinu příkazů. Funkce jsou základním prostředkem k získání znovupoužitelnosti napsaného kódu. Deklarace funkce obsahuje vždy typ návratové hodnoty, název funkce a volitelně také vstupní parametry. Pod deklarací funkce se definují jednotlivé příkazy do složených závorek (více viz např. [13]). Každý program musí obsahovat definici funkce s názvem main a nepovinnými parametry argc a argv – tato funkce se volá vždy po spuštění programu. Malá ukázka práce s funkcemi a statickou proměnnou: #include<stdio.h>

// zpřístupnění funkcí z knihovny stdio.h

int main(int argc, char *argv[]) { zvetsovac(); // v tomto momentě se inicializuje proměnná pocet a zvýší se o 1 int pct = zvetsovac(); // funkce vrátí hodnotu 2 a nastaví ji do pct sprintf("Hodnota pct je %i", pct); // vypíše „Hodnota pct je 2“ na konzoli return 0; } int zvetsovac() { static int pocet=0; return pocet++; }

Stránka 21 z 80


2.3.5 PŘÍKAZY PRO VĚTVENÍ A CYKLY V jazyku C jsou podobně jako ve většině jazyků k dispozici příkazy pro větvení programu if, ifelse, switch a cykly for, while a do-while. Kromě toho je k dispozici také příkaz goto, který

umožňuje z libovolného místa ve zdrojovém kódu přeskočit na definované návěstí (vzhledem k tomu, že použití goto ve většině případů silně zhoršuje čitelnost programových kódů, obyčejně se dnes již nepoužívá). Malá ukázka, že je použití příkazů pro větvení a cykly opravdu takové, jaké znáte z jiných jazyků: int a = 9; int b = 3; int c; if(a>3) { c=3; } else { c=0; } switch(c) { case 1: // udělej něco a ještě case 2: case 3: // udělej něco jiného a skonči část switch break; case 5: return; // ukonči funkci nebo celý program (dle kontextu) default: // udělej něco úplně jiného while(c>0) { c--; } }

2.3.6 ZDROJOVÝ KÓD VE VÍCE SOUBORECH – PŘÍKAZ #INCLUDE A HLAVIČKOVÉ SOUBORY Veškeré zdrojové kódy s implementací funkcí jazyka C mívají název souboru ve tvaru *.c – pokud se program skládá pouze z jednoho souboru, jmenuje se například main.c [17]. V praxi se však projekty z důvodu vyšší přehlednosti a snazšího sdílení funkcionality napříč různými projekty skládají z více zdrojových souborů. Jelikož kompilátor zpracovává jednotlivé zdrojové soubory postupně, je zapotřebí mu v případě použití nějaké funkce z jiného souboru říci, jak vypadá hlavička dané funkce. Rovněž v případě použití globální (extern) proměnné definované v jiném souboru je zapotřebí ve všech souborech, kde se s danou proměnnou pracuje, na začátku takto tuto globální proměnnou deklarovat, aby překladač věděl, že podobná Stránka 22 z 80


proměnná existuje. A do třetice je nutné takto deklarovat rovněž struktury používané napříč různými soubory zdrojových kódů. Existují dvě řešení tohoto problému – buď na začátku všech zdrojových souborů uvádět všechny hlavičky funkcí a deklarovat extern proměnné a struktury, nebo veškeré deklarace přesunout do zvláštního hlavičkového souboru s názvem ve tvaru *.h, a tento soubor na začátku všech ostatních souborů vkládat pomocí příkazu preprocesoru #include (další příkazy preprocesoru lze nalézt v [13]). Zde je malá ukázka převzatá z [17], jak může vypadat program s funkcí definovanou v jiném souboru. Žádné funkce z main.c nebudeme volat v jiných souborech, proto nepotřebujeme vytvářet hlavičkový soubor main.h. Obsah hlavičkového souboru funkce.h: void funkce(void);

Obsah souboru s implementací funkce.c: void funkce(void) { /* ... */ }

Obsah souboru s implementací main.c: #include "funkce.h" int main(void) { funkce(); return 0; }

2.3.7 VYUŽITÍ FUNKCÍ ZE STANDARDNÍ KNIHOVNY JAZYKA C Jazyk C má v porovnání s moderními jazyky poměrně omezenou knihovnu standardních funkcí. Zpřístupňování těchto funkcí v rámci programu se řeší rovněž s pomocí příkazu preprocesoru #include, cestu k hlavičkovým souborům však uvedeme do lomených závorek (tím preprocesoru

řekneme, že má hledat hlavičkové soubory funkcí ze standardní knihovny). Ukázka importu hlaviček pro skupinu funkcí stdio: #import <stdio.h>

Stránka 23 z 80


Kompletní popisy všech funkcí lze nalézt v [13], na tomto místě uvedu jen ty nejzajímavější skupiny: -

ctype.h – funkce pro validaci dat (test čísla, velkého písmene, malého písmene,…) a

konverzi na velká / malá písmena -

math.h – trigonometrické, exponenciální, logaritmické a mocninné funkce, zaokrouhlení

-

stdio.h – funkce pro práci se soubory a proudy dat

-

stdlib.h – funkce pro práci s pamětí a operačním systémem, generátor náhodných čísel

-

string.h – funkce pro práci s řetězci (poli znaků)

-

time.h – funkce pro práci s časem

2.4 PÁR SLOV O JAZYKU SMALLTALK – „OBJEKTOVÁ ČÁST OBJECTIVE-C“ 2.4.1 SOUVISLOST JAZYKU SMALLTALK S JAZYKEM OBJECTIVE-C Jazyk Objective-C přidává k jazyku C zejména podporu pro vytváření objektů a práci s nimi. Jelikož byla syntaxe pro práci s objekty inspirována jazykem Smalltalk, rozhodl jsem se na tomto místě o něm uvést pár slov. Nebudu zabíhat do přílišných detailů jako místy v případě jazyka C, budu se soustředit zejména na zasílání zpráv mezi objekty – to je totiž technika, kterou má jazyk Objective-C se Smalltalkem společnou a která z něj činí pro mnohé programátory zvyklé na Javu nebo PHP poněkud méně srozumitelný programovací jazyk. Nejprve však krátký historický kontext…

2.4.2 HISTORIE A ZÁKLADNÍ VLASTNOSTI SMALLTALKU Jak se můžeme dočíst v [18] (a v poněkud zhuštěné podobě také v [19]), jazyk Smalltalk vznikl v 70. letech 20. století ve výzkumném centru Xerox Palo Alto Research Center, jeho hlavními tvůrci byli Alan C. Kay a Dan Ingalls.

Stránka 24 z 80


Jazyk Smalltalk byl vytvořen jako jazyk: -

interpretovaný – nepřekládá se do spustitelné podoby, pro spouštění programů potřebujeme virtuální stroj

-

čistě objektový – striktně se využívá těchto 4 základních pravidel: o

vše je objekt - neexistují primitivní datové typy a dokonce i blok kódu je považován za objekt

o

objekty komunikují pouze zasíláním zpráv – na rozdíl od jazyků typu Java se na objektech nevyvolávají metody a neexistuje přímý přístup atributům objektu

o

každý objekt má svou třídu

o

každá třída má svého předka – veškeré vytvářené třídy mají předka ve třídě Object, třída Object má předka ve speciální třídě ProtoObject, jež má za předka samu sebe

-

dynamicky typovaný – kontrola typů se provádí až za běhu programu, nikoli během překladu

Smalltalk se ve své době mezi programátory příliš nerozšířil, a to zejména kvůli vysokým hardwarovým nárokům virtuálního stroje a vysoké ceně licence. Vytvořila jej však komunita lidí, která přinesla programátorům mnoho zajímavých myšlenek a postupů, které se dnes běžně využívají – jednotkové testování, extrémní programování nebo třeba návrhové vzory. Přestože se Smalltalk sám o sobě příliš neprosadil, některé jeho myšlenky přežívají dál – například v jazyku Objective-C.

2.4.3 ZASÍLÁNÍ ZPRÁV Objekty spolu navzájem komunikují prostřednictvím tzv. „zpráv“. Co je to zpráva? Dle [8] jde o jakousi „jednotku komunikace“, kterou si mezi sebou objekty posílají, a která může a nemusí mít nějaké argumenty a návratovou hodnotu. Rozdíl mezi zasíláním zpráv a voláním metody je zejména v tom, že je možné zprávy uchovávat (třeba pro pozdější zpracování – zprávy se třeba mohou ukládat do fronty) nebo předávat jiným objektům (objekt se může rozhodnout delegovat zpracování zprávy na jiný objekt – ve výsledku si teoreticky mohou objekty zprávy „přehazovat jako horký brambor“). Stránka 25 z 80


Podstatnou výhodou konceptu zasílání zpráv je také jeho snadná srozumitelnost pro člověka – díky zasílání zpráv připomínají kódy programů běžnou mluvu mezi lidmi. Však srovnejte sami: Maminka poslala svému nejstaršímu synovi Karlovi zprávu: Vynes odpadkový koš! Karel si zprávu přečetl, seznal, že se mu vynášet odpadkový koš dnes nechce, a obratem přeposlal zprávu svému mladšímu bratru Václavovi, který na jejím základě vstal od televize a koš skutečně vynesl. vs. Maminka zavolala na svém nejstarším synovi Karlovi metodu „Vynes odpadkový koš“. Tato metoda zjistila, že se Karlovi dnes vynášet odpadkový koš nechce, a tak zavolala na mladším bratru Václavovi metodu „Vynes odpadkový koš“. Václav vstal od televize a koš vynesl. Výše uvedené srovnání je samozřejmě účelově vymyšlené tak, aby konceptu zpráv plně vyhovovalo (chyběl snad jen odklad zpracování zprávy do konce sledovaného televizního pořadu). Ukažme si proto ještě jeden modelový příklad, který bude o něco blíže „technické realitě“. Začněme schématem (obrázek 3) části programu, který zachycuje napsaná slova na klávesnici, ukládá je k sobě do paměti (neřešíme, co s nimi dělá dále) a zobrazuje je na monitoru:

OBRÁZEK 3: ZASÍLÁNÍ ZPRÁV MEZI OBJEKTY

Vidíme, že se jedná o program, který využívá návrhového vzoru Model-View-Controller, přičemž uživatelské rozhraní agreguje objekty klávesnice a monitoru. Popisovaný proces začíná zasláním první zprávy Napsáno slovo „Ahoj“ z objektu klávesnice do objektu uživatelského rozhraní. Objekt uživatelského rozhraní posílá zprávu dále do řadiče, který ji zpracuje tak, že vytvoří druhou zprávu Ulož slovo „Ahoj“, kterou zašle objektu Model, a třetí zprávu Zobraz slovo „Ahoj“, kterou zašle objektu uživatelského rozhraní. Objekt uživatelského rozhraní následně zašle třetí zprávu objektu Monitor, který ji zobrazí. Stránka 26 z 80


2.5 ZÁKLADNÍ RYSY OBJECTIVE-C Základní rysy jazyku Objective-C vychází z velké míry z toho, co si tento jazyk vzal ze svých vzorů – C a Smalltalk. Vše, co bylo napsáno u jazyka C, je platné také u jazyka Objective-C – jazyk Objective-C je kompilovaný (program je v podobě spustitelného souboru) a umožňuje v případě potřeby vkládání příkazů jazyka symbolických adres (umožňuje nízkoúrovňové programování). V rámci programů můžeme používat primitivní datové typy, definovat vlastní funkce (všechny programy v Objective-C začínají metodou main stejně jako „céčkové“ programy) a používat klasické „céčkové“ konstrukce pro větvení kódu, cykly atd. Platformy jazyka nemusí podporovat automatický mechanismus pro uvolňování paměti (Objective-C 2.0 umožňuje využívat garbage collector, ale pouze pro platformy využívající framework Cocoa). Tvůrci jazyka Objective-C se při tvorbě syntaxe práce s objekty inspirovali v syntaxi jazyka Smalltalk – díky tomu je jazyk Objective-C v základu dynamicky typovaný (programátoři mohou využít rovněž statického typování) a mezi objekty jsou zasílány zprávy (jednou ze základních vlastností jazyka je tzv. „forwarding“, přeposílání zpráv mezi objekty). Na rozdíl od jazyka Smalltalk není Objective-C čistě objektový (např. díky primitivním datovým typům). Kromě podpory objektů přidává Objective-C k jazyku C také 2 neobjektová rozšíření [8] – primitivní (standardní) typ bool pro definování booleovských hodnot (využívají se konstanty YES a NO) a direktivu #import, která se stará o „chytré“ vkládání hlavičkových souborů (pokud je zavolán import jednoho hlavičkového souboru dvakrát, je podruhé tato direktiva již přeskočena – to je rozdíl oproti standardní direktivě #include používané v jazyku C, která při opakovaném vložení jednoho hlavičkového souboru zapříčinila chybu při kompilaci). Všechny hlavičkové soubory jazyka Objective-C mají koncovku *.h (například main.h), soubory s implementací mají na rozdíl od jazyka C koncovku *.m (například main.m).

2.6 TYPY A KONSTANTY OBJECTIVE-C PRO PRÁCI S OBJEKTY, VYBRANÉ ZÁKLADNÍ TŘÍDY V jazyku Objective-C se podobně jako v jiných jazycích pracuje s objekty prostřednictvím odkazů. V praxi to vypadá tak, že [8] v paměti existuje instance objektu, a v odkazu na objekt máme uvedenu adresu paměti, na které se objekt nachází. Stránka 27 z 80


Pro uchovávání odkazů na objekty se používá v Objective-C nový typ id, který je de-facto ukazatelem známým z jazyka C. Oproti ukazatelům z jazyka C však již implicitně obsahuje hvězdičku, takže ji nemusíme při jeho definici psát (viz ukázku níže). Kromě typu id, který je univerzálním odkazovým typem pro objekty všech tříd, lze používat také ukazatel typu Class, kde „Class“ odpovídá názvu třídy objektu, na který chceme odkazovat. Při definici těchto ukazatelů na konkrétní třídu však již hvězdičku použít musíme. Pro nastavení prázdného odkazu se používá konstanta nil, která odpovídá ukazateli na „nic“ (obdoba konstanty null v Javě). V rámci programování v jazyku Objective-C jsou využívány různé knihovny (frameworky), které programátorům zpřístupňují různé užitečné třídy a funkce (např. frameworky Cocoa, Cocoa Touch, Cocotron,…). Následující výběr zahrnuje vybrané nejběžnější třídy, které se vyskytují snad ve všech existujících knihovnách12: -

NSObject – kořenová třída, společný předek většiny tříd v Objective-C

-

NSString – třída pro uchovávání neměnných řetězců a práci s nimi

-

NSMutableString – třída pro uchovávání řetězců, které se mohou měnit (chceme-li např.

[20]

postupně skládat nějaký text z několika částí, zvolíme tuto třídu) -

NSConstantString

– třída pro uchovávání statických řetězců, dle [21] se jedná o literální

neměnnou instanci třídy NSString (její hodnota se přímo vkládá do kompilovaného zdrojového kódu); podstatnou výhodou této třídy je výrazně jednodušší vytváření její instance za pomoci znaku @ (viz ukázku níže) -

NSError

– třída pro reprezentaci chyb uživatele (špatně zadaná vstupní data,…) [8]

-

NSException

– třída pro reprezentaci chyb programátora (snaha otevřít neexistující

soubor,…) -

NSNumber

– třída pro reprezentaci libovolných čísel (odstiňuje od nutnosti volby

číselného datového typu) -

NSInteger

– třída pro reprezentaci celých čísel

-

NSArray

-

NSDictionary

– kontejner pro objekty uložené pod různými klíči

-

NSCountedSet

– kontejner pro uchovávání objektů, přičemž u každého objektu se eviduje

– kontejner pro uspořádaná pole objektů

počet výskytů 12

Jelikož jazyk Objective-C neobsahuje podporu jmenných prostorů (jako např. Java, C#,…), jsou veškeré

třídy z těchto knihoven označeny prefixem NS.

Stránka 28 z 80


Malá ukázka práce s objekty (ukázky práce s ostatními objekty budou uvedeny níže): id odkaz1 = nil; MojeTrida *odkaz2 = nil; id zprava = @"Ahoj světe!";

// prázdný odkaz na instanci libovolné třídy // prázdný odkaz na instanci třídy MyClass // jednoduché vytvoření instance třídy NSConstantString

2.7 DEFINICE VLASTNÍCH TŘÍD, KATEGORIÍ, ROZŠÍŘENÍ A PROTOKOLŮ 2.7.1 DEFINICE VLASTNÍCH TŘÍD Jak je uvedeno v [8], popis třídy se stává ze dvou částí: 1. Rozhraní – obsahuje informaci o samotné existenci třídy, jejím názvu, předku (rodičovská třída) a atributech (speciální instanční proměnné, které může kdokoli číst a případně také měnit). Dále je uveden seznam zpráv, na které umí daná třída nebo její instance reagovat, a seznam instančních proměnných. Deklarace rozhraní je umístěna v hlavičkovém souboru s koncovkou .h. 2. Implementace – zde se definuje, jakým způsobem bude třída reagovat na přijaté zprávy. Implementace je uložena v souboru s koncovkou .m, na jehož začátku je import hlavičkového souboru. Nejjednodušší rozhraní třídy Osoba, která je přímým potomkem třídy NSObject může vypadat například takto: @interface Osoba:NSObject @end

Chceme-li, aby měla Osoba nějaké instanční proměnné, deklarujeme je následovně: @interface Osoba:NSObject { NSInteger vek, rokNarozeni; // dvě celočíselné instanční proměnné @private NSString *jmeno; // odkaz na řetězec } @end

Každá instanční proměnná může mít uvedenu direktivu omezující přístup k její hodnotě (neuvedeme-li žádnou direktivu pro přístup k proměnným, použije se @protected): 

@private – instanční proměnná je přístupná pouze pro danou třídu



@protected – instanční proměnná je přístupná v rámci třídy a jejích potomků



@public – instanční proměnné jsou přístupné komukoli (pomocí operátoru ->)

Stránka 29 z 80


Deklarace atributů (jakýchsi veřejně přístupných instančních proměnných) je novinkou v jazyku Objective-C 2.013. Atribut deklarujeme uvedením direktivy @property, datového typu atributu a jeho názvu. Pro zajištění kompatibility s jinými než 64-bitovými procesory musíme navíc definovat také stejnojmenné soukromé instanční proměnné (podrobnosti viz [8]). Rozdíl mezi atributy a instančními proměnnými spočívá v možnosti automatického vytvoření přístupových metod pro každý atribut, a to pomocí direktivy @synthesize (direktiva se uvede v implementaci třídy, viz dále). Přístupové metody jsou označeny prefixem set nebo get a jménem atributu s velkým prvním písmenem (např. getVek, setVek). Pokud u některého z atributů nepoužijeme direktivu @synthesize, můžeme definovat přístupové metody sami (změnit např. jejich chování). Kromě přístupových metod můžeme s atributy pracovat také pomocí tzv. „tečkové notace“ – např. osoba.vek). Malá ukázka deklarace třídy s přístupnými atributy věk a jméno (instanční proměnná rokNarozeni je nepřístupná): @interface Osoba:NSObject { NSInteger vek, rokNarozeni; NSString *jmeno; } @property NSInteger vek; @property NSString *jmeno; @end

// dvě celočíselné instanční proměnné // odkaz na řetězec // celočíselný atribut věk // textový atribut jméno

U atributů můžeme dále deklarovat určité parametry, které např. ovlivní jeho přístupnost (podrobnosti viz [8]). A nakonec si ukážeme, jak deklarovat zprávy, na které umí třída nebo její instance reagovat prostřednictvím stejnojmenných metod (více o zprávách viz kapitolu 2.4.3). Při deklaraci je zapotřebí zvolit, zda se bude jednat o zprávu zaslanou třídě (jakýsi ekvivalent statickým metodám v Javě – označují se prefixem +) nebo o zprávu zaslanou instanci třídy (označené prefixem -), jaká bude její návratová hodnota a jméno. Za jméno zprávy je možné uvést parametr zprávy, a to pomocí dvojtečky (která se stane součástí jména zprávy), datového typu (uvedeného v kulatých závorkách) a identifikátoru proměnné.

13

S překladačem pro starší verze Objective-C nebude možné zdrojové kódy s atributy přeložit.

Stránka 30 z 80


Potřebujeme-li pro zprávu deklarovat více parametrů, musí se jméno zprávy skládat z více částí – každá z těchto částí poté může za dvojtečkou obsahovat definici datového typu a identifikátoru proměnné. Celé jméno zprávy poté tvoří jednotlivé části včetně dvojteček (např. nastavPromenne:rok:).

Vše bude snad jasné z následující ukázky: @interface Osoba:NSObject { … // zde může být uvedena deklarace instančních proměnných } +(NSString*) nazevTridy; // zpráva zasílaná třídě, návratový typ NSString -(void) omladniOrok; // zpráva zaslaná instanci třídy, návratový typ void -(void) nastavPromenne: (jmeno*)jmeno rok: (NSInteger)rok; // zpráva s více parametry @end

Podobně jako u definice rozhraní třídy si ukážeme nejprve základní definici implementace „prázdné“ třídy (připomeňme, že implementace třídy se ukládá do souboru s koncovkou *.m): #import "osoba.h" // import hlavičkového souboru @implementation Osoba @end

Pro zpracování zpráv se v Objective-C využívá metod, které se jmenují stejně jako dané zprávy a které mají i stejně definované vstupní parametry [8]. Uvnitř objektů můžeme používat speciální proměnnou self, s jejíž pomocí můžeme přistupovat k metodám a instančním proměnným v rámci aktuálního objektu, a proměnnou super, která nám zpřístupní metody rodičovské třídy (přístup k instančním proměnným rodičovské třídy je také možný, postrádá však smysl, jelikož veškeré přístupné instanční proměnné potomek podědí). Jednoduchá implementace metod deklarovaných výše pro třídu Osoba může vypadat například následovně: #import "osoba.h" // import hlavičkového souboru @implementation Osoba +(NSString*) nazevTridy { return @"Nazev tridy je Osoba"; // vrácení instance třídy NSConstantString, která je } // potomkem třídy NSString @synthesize jmeno, vek; // chceme automaticky definovat přístupové metody k atributům -(void) omladniOrok { vek--; rokNarozeni++; } -(void) nastavPromenne: (NSString*) jmeno rok: (NSInteger) rok { self.jmeno=jmeno; // použijeme self kvůli kolizi názvu parametru a instanční proměnné rokNarozeni=rok; // zde můžeme k instanční proměnné přistupovat i bez použití self } @end

Stránka 31 z 80


2.7.2 KATEGORIE A ROZŠÍŘENÍ Kategorie představují efektivní a mocný způsob, jak rozdělit kód jedné třídy do více souborů, nebo jak doplnit funkcionalitu k určité již existující třídě (vč. standardních tříd z knihovny Cocoa) [22]. Jejich funkci lze připodobnit k jazykovým rozšířením (language extensions) v jazyku C# [23]. Máme-li nějakou třídu, jejíž kód chceme rozdělit do více souborů (rozdělit do více souborů lze jak hlavičkové soubory, tak soubory s implementací), je zapotřebí nejprve vytvořit „normální“ hlavní třídu s definicí instančních proměnných (například v souborech Osoba.h a Osoba.m). K této „normální“ třídě následně můžeme přidávat další metody pomocí kategorií, které se definují podobně jako „normální“ třídy – s tím rozdílem, že se za název třídy do závorky uvede název kategorie (v celé aplikaci je možné jeden název kategorie použít pro rozšíření právě jedné třídy). Obvykle se hlavičky kategorií ukládají do souborů s názvem Trida+Kategorie.h a implementace do souborů s názvem Trida+Kategorie.m, nicméně komu by tento zvyk nevyhovoval, může použít i jiné názvy souborů. Je možné rovněž umístit definice rozhraní třídy a všech kategorií do jednoho souboru (Trida.h), a rozdělit pouze soubory s implementací. Malá ukázka, jak by mohl vypadat hlavičkový soubor třídy Osoba (soubor Osoba.h): @interface Osoba:NSObject { NSInteger vek, rokNarozeni; NSString *jmeno; } @property NSInteger vek; @property NSString *jmeno; +(NSString*) nazevTridy;

// dvě celočíselné instanční proměnné // odkaz na řetězec // atribut věk // atribut jméno // zpráva zasílaná třídě vracející řetězec

@end

Implementace jedné metody třídy Osoba (soubor Osoba.m): #import "Osoba.h" // import hlavičkového souboru @implementation Osoba +(NSString*) nazevTridy { return @"Nazev tridy je Osoba"; // vrácení instance třídy NSConstantString } @end

Stránka 32 z 80


Další dvě metody můžeme k třídě Osoba přidat14 pomocí kategorie NastaveniOsoby (pozor, pomocí kategorie nelze k třídě přidávat instanční proměnné). Hlavičkový soubor této kategorie (uložený v souboru Osoba+NastaveniOsoby.h) může vypadat takto: @interface Osoba (NastaveniOsoby) -(void) omladniOrok; // zpráva zasílaná instanci třídy -(void) nastavPromenne: (jmeno*)jmeno rok: (NSInteger)rok; // zpráva s parametry @end

Implementaci kategorie NastaveniOsoby bychom posléze umístili do souboru Osoba+NastaveniOsoby.m takto: #import "Osoba.h" // import hlavičkového souboru „normální“ třídy #import "Osoba+NastaveniOsoby.h" // import hlavičkového souboru kategorie @implementation Osoba (NastaveniOsoby) -(void) omladniOrok { vek--; rokNarozeni++; } -(void) nastavPromenne: (jmeno*) jmeno rok: (NSInteger) rok { self.jmeno=jmeno; rokNarozeni=rok; } @end

Pokud bychom chtěli ke standardní třídě NSString přidat metodu pro vrácení obráceného textu, nemusíme v Objective-C vytvářet potomka třídy NSString. Metodu jednoduše deklarujeme pomocí kategorie reverse v souboru NSString+reverse.h (ukázka převzata z [22]): // hlavičkový soubor NSString+reverse.h @interface NSString (reverse) -(NSString *) reverseString; @end

// reverse = název kategorie

Implementaci kategorie reverse poté definujeme v souboru NSString+reverse.m (kód uveden na další straně):

14

Metody je možné pomocí kategorií také překrývat, nicméně v praxi se kvůli přehlednosti kódu tento

postup příliš nedoporučuje.

Stránka 33 z 80


// soubor s implementací NSString+reverse.m @implementation NSString (reverse) -(NSString *) reverseString { NSMutableString *reversedStr; int len = [self length]; reversedStr = [NSMutableString stringWithCapacity:len]; while (len > 0) { [reversedStr appendString: [NSString stringWithFormat:@"%C", [self characterAtIndex:--len]]]; } return reversedStr; } @end

Upravenou třídu NSString poté můžeme použít například v následujícím kódu: #import #import "NSString+Reverse.h"

// zpřístupní Cocoa třídy a funkci NSLog

int main (int argc, const char * argv[]) { NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; NSString *str = [NSString stringWithString:@"Dobry den!"]; NSString *rev; NSLog(@"String: %@", str); // vypíše na konzoli „Dobry den!“ pomocí funkce NSLog rev = [str reverseString]; // načte převrácený řetězec NSLog(@"Reversed: %@",rev); // vypíše na konzoli „!ned yrboD“ pomocí funkce NSLog [pool drain]; return 0; }

Jazyk Objective-C neumožňuje definovat privátní metody tak, jak je známe například z jazyků Java, C# nebo PHP. Nejblíže mají k privátním metodám tzv. „rozšíření“, která v Objective-C 2.0 umožňují pro jednu třídu definovat několik různých rozhraní. Díky rozšíření můžeme v rámci třídy pracovat se všemi metodami, a ostatním třídám zpřístupnit pouze některé vybrané metody. Rozšíření se definují podobně jako kategorie, jediný rozdíl je v tom, že neuvádíme jejich jméno (jedná se o tzv. „nepojmenované kategorie“). Ukázka deklarace veřejného rozhraní pro třídu Osoba (v souboru Osoba.h): @interface Osoba:NSObject { NSInteger vek, rokNarozeni; // dvě celočíselné instanční proměnné NSString *jmeno; // odkaz na řetězec } @property NSInteger vek; // atribut věk @property NSString *jmeno; // atribut jméno +(NSString*) nazevTridy; // zpráva zasílaná třídě vracející řetězec -(void) nastavPromenne: (jmeno*)jmeno rok: (NSInteger)rok; // zpráva s parametry @end

Stránka 34 z 80


Ukázka deklarace privátního rozhraní pro třídu Osoba (v souboru OsobaPrivate.h): #import Osoba.h // import veřejného rozhraní @interface Osoba () // definice metod, které budou přístupné pouze přes privátní rozhraní -(void) omladniOrok; @end

2.7.3 PROTOKOLY Protokoly umožňují třídám deklarovat skupiny metod, které podporují. Jedná se o analogii k rozhraním (interface), která můžeme znát například z jazyků Java, C# nebo PHP. Protokoly se definují pomocí direktivy @protocol, a to uvedením jména protokolu a deklarací jeho metod. Pro jednoduchou demonstraci protokolů si nadefinujeme protokol UmimMladnout, který bude obsahovat jedinou metodu omladniOrok (kód umístíme do souboru UmimMladnout.h): @protocol UmimMladnout -(void) omladniOrok; @end

Jedna třída může zároveň odpovídat více protokolům (čárkami oddělené protokoly se uvádí v lomených závorkách za název třídy v hlavičce), a aby toho nebylo málo, tak také protokoly mohou odpovídat různým jiným protokolům. Následujícím způsobem v souboru Osoba.h uvedeme, že třída Osoba protokolu UmimMladnout odpovídá: // hlavička třídy Osoba v souboru Osoba.h @interface Osoba:NSObject { NSInteger vek, rokNarozeni; // dvě celočíselné instanční proměnné NSString *jmeno; // odkaz na řetězec } @property NSInteger vek; // atribut věk @property NSString *jmeno; // atribut jméno +(NSString*) nazevTridy; // zpráva zasílaná třídě vracející řetězec -(void) nastavPromenne: (jmeno*)jmeno rok: (NSInteger)rok; // zpráva s parametry @end

Stránka 35 z 80


2.8 VYTVÁŘENÍ INSTANCÍ A ZASÍLÁNÍ ZPRÁV, PŘEKRÝVÁNÍ METODY INIT Zprávy objektům zasíláme tak, že [24] napíšeme do hranatých závorek název třídy nebo proměnné, ve které máme uložen odkaz na objekt, a název zprávy, který může být doplněn parametry. Alternativně můžeme pro zaslání zprávy objektu použít funkci objc_msgSend, kde uvedeme odkaz na objekt, selektor zprávy a případně parametry zprávy15. Pod pojmem „selektor zprávy“ si lze představit ukazatel na určitou zprávu (získává se pomocí direktivy @selector a názvu zprávy v kulatých závorkách). Ukázky zaslání zpráv třídě Osoba: id osoba = [Osoba alloc]; [osoba zpravaSparametrem:23]; [osoba zpravaScislem:23 aTextem: @"Ahoj"]; objc_msgSend(osoba,@selector("zpravaScislem:aTextem"),24,@"Nazdar!");

Pro získání odkazu na novou instanci třídy (vytvoření nové instance třídy) stačí zaslat dané třídě zprávu alloc. Jelikož jazyk Objective-C nevolá při vytváření instance třídy žádný konstruktor, je nám v takovém případě vrácena instance třídy s nedefinovanými instančními proměnnými16. Abychom instanční proměnné definovali, je zapotřebí instanci zaslat další zprávu – obvykle se používá zpráva init, kterou lze připodobnit k bezparametrovému konstruktoru v Javě a jejíž metoda je implementována ve třídě NSObject (společném předkovi většiny tříd). Tuto zprávu můžeme zaslat rovnou výsledku zprávy alloc: MojeTrida *mojeTrida = [[MojeTrida alloc] init]; // uložení odkazu na instanci do // ukazatele na třídu MojeTrida id mojeTrida2 = [[MojeTrida alloc] init];

// uložení odkazu na instanci do // ukazatele na libovolnou třídu

Kromě zprávy init mohou objekty podporovat i jiné zprávy pro inicializaci instance třídy, zpravidla se tyto zprávy nazývají initWithNěco: // získání odkazu na instanci třídy NSInteger s hodnotou 123 NSInteger *mujInteger = [[NSInteger alloc] initWithInt: 123];

15

Takto volání zpráv překládá kompilátor – doporučený způsob volání zpráv je přes hranaté závorky.

16

Vzhledem k možnosti překrytí metod alloc a init je teoreticky možné vytvořit třídu, která bude místo

odkazu na novou instanci vracet konstantu nil, nebo případně instanci jiné třídy.

Stránka 36 z 80


Často bývá užitečné namísto dvou zpráv (alloc a init) zaslat pouze jednu tzv. „kombinovanou zprávu“, která zavolá metodu alloc a zároveň nastaví instanční proměnné. Dle konvencí se tato zpráva obvykle jmenuje podle názvu třídy (bez případného prefixu): // vytvoření prázdného pole NSArray *prazdnePole = [NSArray array]; // vytvoření instance výjimky NSException *e = [NSException exceptionWithName: @"Spojení přerušeno" reason: @"Neznámý důvod" userInfo: nil ]

Při vytváření vlastních tříd můžeme definici metody init překrýt, na začátku těla metody však vždy musíme zavolat nejprve metodu init na rodičovské třídě (super init). Každá metoda init musí vracet buď inicializovanou instanci (libovolné třídy!) nebo konstantu nil (pokud se inicializace nezdaří).

2.9 STANDARDNÍ ZPRÁVY TŘÍDY NSOBJECT Většina tříd v Objective-C (přesněji většina tříd ze všech knihoven tříd) je potomkem třídy NSObject, která sama o sobě umí reagovat na různé užitečné zprávy.

Základní zprávou, na kterou je schopna většina objektů reagovat, je description. Odpovědí na tuto zprávu je obvykle vypsání názvu třídy objektu; je-li zpráva zaslána instanci třídy, zobrazí se obvykle také obsah jejích instančních proměnných a místo v paměti. Dalšími zprávami jsou isEqual: a hash, které slouží k porovnávání dvou objektů. Odpovědí na zprávu hash je číslo, které jednoznačně identifikuje konkrétní objekt, odpovědí na isEqual je hodnota YES nebo NO v závislosti na tom, zda je objekt předaný parametrem shodný s objektem, kterému byla zpráva zaslána, či nikoli. V ideálním případě je odpověď na zprávu isEqual YES právě tehdy, když si vzájemně odpovídají také hashe jednotlivých objektů. V praxi je možné definovat metodu isEqual: také tak, aby vracela YES např. pro různé instance se stejnými hodnotami instančních proměnných. S pomocí zprávy class můžeme od libovolného objektu získat odkaz na třídu, jejíž instancí objekt je. Zašleme-li tuto zprávu objektu třídy (nikoli její instanci), vrátí objekt odkaz na sebe sama. Podobně funguje také zpráva superclass, která však vrací odkaz na rodičovskou třídu (nebo konstantu nil, pokud třída již žádného rodiče nemá).

Stránka 37 z 80


Zprávy isKindOfClass: a isSubclassOfClass: dovolují testovat, zda je instance určitého objektu instancí určité třídy, respektive zda je daná třída potomkem určité třídy. Poslední tři důležité zprávy umožňují otestovat, zda je určitý objekt schopen reagovat na určitou zprávu. Zpráva conformsToProtocol: (parametrem je odkaz na protokol) ověří, zda je daná instance instancí třídy odpovídající určitému protokolu, respondsToSelector: dovolí otestovat reakci instance na určitou zprávu a konečně instancesRespondToSelector: dovolí otestovat, zda instance určité třídy budou schopné reagovat na určitou zprávu. Parametrem posledních dvou uvedených zpráv je tzv. „selektor“, ukazatel na určitou zprávu. Ukázka zavolání zpráv conformsToProtocol:, respondsToSelector:, instancesRespondToSelector: // vytvoření instance třídy Osoba a „bezpečné“ zaslání zpráv Osoba osoba = [[[Osoba alloc] init] nastavPromenne:@"Karel":45]; if( [osoba conformsToProtocol: @protocol(UmimMladnout)] ) { [osoba omladniOrok]; } if( [osoba respondsToSelector: @selector(omladniOrok)] ) { [osoba omladniOrok]; } if( [Osoba instancesRespondToSelector: @selector(pozdrav)] ) { [osoba pozdrav]; }

2.10 PŘEPOSÍLÁNÍ ZPRÁV – FORWARDING V jazyku Objective-C platí, že [25] je možné libovolnému objektu zaslat libovolnou zprávu bez ohledu na seznam zpráv definovaných v jeho rozhraní. Zašleme-li například libovolné instanci třídy zprávu udelejNeco:, program se pokusí nejprve nalézt odpovídací metodu udelejNeco (s jedním parametrem) v rámci implementace dané třídy. Pokud tuto metodu nenalezne, pokusí se ji nalézt postupně ve všech rodičovských třídách. V případě, že v rámci třídy ani jejích rodičovských třídách implementaci příslušné metody program nenalezne, začne postupně hledat implementaci metody forwardInvocation: s parametrem typu NSInvocation (instance třídy NSInvocation reprezentují volání zprávy včetně parametrů). Metoda forwardInvocation je implementována ve všech kořenových třídách (např. NSObject) a pokud ji v žádné z definovaných tříd nepřekryjeme, zavolá standardně metodu doesNotRecognizeSelector:, která v případě třídy NSObject vyhodí výjimku NSInvalidArgumentsException.

Výhoda Objective-C však spočívá právě v možnosti překrytí metody forwardInvocation, s jejíž pomocí můžeme snadno delegovat zpracování neznámých zpráv na jiné objekty. Stačí poslat

Stránka 38 z 80


zprávu invokeWithTarget: instanci třídy NSInvocation a jako parametr uvést odkaz objektu, který „neznámou“ zprávu zpracuje. Ukázka překrytí metody forwardInvocation pro přeposílání neznámých zpráv instanci objektu, jehož odkaz máme v proměnné adresat (převzato z [25]): - (void)forwardInvocation:(NSInvocation *) zavolani { /* * Získáme selektor zprávy, kterou náš objekt neumí zpracovat, a dotážeme se adresáta, * zda daný selektor umí zpracovat. */ if ([adresat respondsToSelector:[zavolani selector]]) { [zavolani invokeWithTarget:adresat]; // adresát umí zpracovat zprávu, zašleme mu ji } else { [super forwardInvocation:anInvocation]; // adresát neumí zpracovat zprávu, necháme } // „vyřešit problém“ rodičovskou třídu }

2.11 EXPLICITNÍ SPRÁVA PAMĚTI Ve všech ukázkách kódů v Objective-C jsem (mlčky) předpokládal využití automatické správy paměti (Garbage collector), která je však dostupná až od verze Objective-C 2.0, a to ještě pouze pro některé platformy (z důvodu vysoké hardwarové náročnosti není možné automatickou správu paměti využít například při vývoji aplikací pro mobilní telefon iPhone). Pokud v programu nemůžeme využít automatickou správu paměti (která sama uvolňuje nepotřebné objekty z paměti), můžeme využít tzv. „explicitní správu paměti“. Velice dobře a přehledně je využití explicitní správy paměti popsáno v [26]. Nemáme-li zapnutou (dostupnou) automatickou správu paměti, existují všechny instance objektů v jednom ze dvou režimů – v režimu explicitní správy paměti, nebo mimo režim explicitní správy paměti. Objekty v režimu explicitní správy paměti jsou automaticky z paměti uvolněny na konci bloku kódu (např. funkce, metody, …), ostatní objekty jsou uvolněny v momentě, kdy jim je zaslána zpráva release. Mezi těmito režimy lze přepínat zasíláním zpráv autorelease (přepnutí do režimu explicitní správy paměti) a retain (vyřazení objektu z explicitní správy paměti)17.

17

Upozornění: Pokud zašleme objektu mimo režim explicitní správy paměti zprávu retain, musíme pro

uvolnění paměti zaslat zprávu release 2x. Zašleme-li objektu v režimu explicitní správy paměti zprávu release, program skončí chybou.

Stránka 39 z 80


Mimo režim explicitní správy paměti jsou ve výchozím stavu všechny objekty, které vznikly pomocí zpráv alloc / init, copy, mutableCopy nebo new. Chceme-li tyto objekty z paměti uvolnit, musíme jim vždy zaslat zprávu release nebo autorelease. // vytvoření instance třídy NSString, která nepodléhá explicitní správě paměti NSString* retezec = [[NSString alloc] init]; // vytvoření instance [retezec release]; // uvolnění paměti

Naopak v režimu explicitní správy paměti jsou ve výchozím stavu všechny ostatní objekty, tedy například instance vytvořené prostřednictvím kombinovaných zpráv. // vytvoření instance třídy NSString, která podléhá explicitní správě paměti NSString* retezec = [NSString string]; // vytvoření instance [retezec retain]; // vyřazení instance z explicitní správy paměti

Pokud vytváříme vlastní třídy s kombinovanými zprávami, je vhodné do metod těchto kombinovaných zpráv přidat volání autorelease. V případě, kdy nastavujeme v objektu nějaké instanční proměnné, musíme nejprve poslat původnímu objektu, na který instanční proměnná ukazuje, zprávu autorelease – jinak bude blokovat paměť až do skončení programu. Naopak objektu, na nějž bude nově instanční proměnná odkazovat, musíme zaslat zprávu retain, aby nebyl z paměti vymazán na konci metody18. @implementation Osoba -(void) initWithJmeno: (jmeno*) jmeno rok: (NSInteger) rok { [self.jmeno autorelease]; // starou instanci již nebudeme potřebovat self.jmeno=[jmeno retain]; // novou instanci budeme potřebovat v paměti déle [rokNarozeni autorelease]; rokNarozeni=[rok retain]; } +(Osoba*) osobaWithJmeno: (jmeno*) jmeno rok: (NSInteger) rok { return [[[self alloc] initWithJmeno:jmeno rok:rok] autorelease]; } @end

18

Všimněte si, že starému objektu zasíláme zprávu autorelease namísto release. Pokud by se totiž odkaz

na objekt náhodou nezměnil (pokusili bychom se nastavit ukazatel na stejný objekt), vymazali bychom nadobro objekt pomocí zprávy release, a zprávu retain bychom poté poslali již neexistujícímu objektu.

Stránka 40 z 80


3 ÚČELNOST ZAŘAZENÍ JAZYKA OBJECTIVE-C DO VÝUKY 3.1 KRITÉRIA ÚČELNOSTI ZAŘAZENÍ JAZYKA DO VÝUKY Zhodnotit (pokud možno objektivně) účelnost nebo dokonce míru účelnosti zařazení libovolného programovacího jazyka do výuky je ošemetné – každý jazyk má určité vlastnosti, které jednoho programátora nadchnou, zatímco druhý programátor nad nimi „ohrne nos“. Na základě svých několikaletých zkušeností s programováním (převážně v jazycích Java a PHP) jsem se pokusil dát dohromady 10 kritérií, podle kterých je podle mého názoru možné účelnost výuky programovacího jazyka zhodnotit. Prvním kritériem jsou vstupní bariéry – třebaže mohou bariéry přinášet také určité výhody (např. nízkou míru konkurence mezi programátory), obecně platí, že čím vyšší bariéry pro naučení daného jazyka jsou, tím více je potřeba zvažovat, zda neupřednostnit radši nějaký jiný jazyk. Typickou bariérou může být například příliš drahý software potřebný pro vývoj (jako je tomu například u Action Scriptu – ne každý si může dovolit zakoupit Flash Professional). Velice důležitá je perspektivnost jazyka – nemá smysl se učit jazyk, který by například měla „pod palcem“ firma, které hrozí bankrot nebo nepřátelské převzetí konkurencí, nebo jazyk, který je v porovnání s ostatními programovacími jazyky nekonkurenceschopný a neexistují pro něj oblasti využití. Je dobré, pokud programovacímu jazyku nechybí žádné významné vlastnosti jeho konkurentů, a ještě lepší je, pokud své konkurenty v něčem předčí. Čím více společných (dobrých) znaků určitý jazyk s ostatními jazyky má, tím větší smysl má jej zařadit do výuky – srovnání jazyku Objective-C s ostatními jazyky je proto dalším z kritérií. Vzhledem k omezené hodinové dotaci výukových kurzů je nutné, aby syntaxe jazyka nebyla příliš náročná. Rozhodl jsem se proto náročnost syntaxe krátce zhodnotit, a to jak z hlediska podobnosti s ostatními jazyky a objemu nových pravidel k naučení, tak z hlediska rychlosti (snadnosti) psaní zdrojových kódů (zejména v éře notebooků s omezenými klávesnicemi je velmi nepraktické, používá-li syntaxe jazyka „exotické“ znaky). S náročností syntaxe a rychlostí psaní kódů souvisí také použitelnost vývojového prostředí, které může díky automatickému doplňování kódu, kontextové nápovědě a dalším funkcím výrazně zefektivnit celý proces vývoje a testování programu. Stránka 41 z 80


Nejen během učení, ale také při práci je nutné se občas podívat do manuálu, nebo zadat konkrétní problém do vyhledávače Google. Dostupnost a kvalita literatury určitě velmi výrazně ovlivňuje produktivitu práce, a s tím spojenou atraktivitu konkrétního programovacího jazyka. Široká komunita programátorů, tutoriály, volně dostupné19 třídy pro realizaci opakujících se činností a diskusní fóra s řešením specifických problémů jsou „poklad“, který každý programovací jazyk rozhodně nemá. Má-li se určitý jazyk vyučovat ve škole, musí splňovat také určitá „didaktická kritéria“. Je důležité, aby vlastnosti jazyka byly v souladu s myšlenkami objektově orientovaného programování (OOP). Kromě základních vlastností (zapouzdření, programování oproti rozhraní,…) jsem se rozhodl soulad s myšlenkami OOP otestovat také na možnosti (snadnosti) implementace několika základních návrhových vzorů. Aby byla výuka jazyku úspěšná, musí být studenti správně (vnitřně) motivováni – osobně si myslím, že nejlepší motivací je vidět okamžitý užitek z čerstvě nabytých znalostí. Například v případě výuky Java EE na VŠE vidím trochu problém v tom, že získané znalosti momentálně nemám kde zužitkovat – programovat podnikové aplikace doma „na koleni“ nelze, a nechat se zaměstnat u nějaké větší firmy by obnášelo již spíše práci na plný úvazek. S předchozím kritériem souvisí také zájem o programátory na trhu práce – tento zájem je důležitý nejen pro studenty, ale také pro školy samotné (lákání studentů na propojení s praxí, sponzoring ze strany firem,…). Posledním kritériem je samotný zájem o studium Objective-C z řad současných studentů VŠE, který jsem zjišťoval prostřednictvím online dotazníku.

19

Zatímco v PHP je možné využívat bohatou zásobu různých hotových knihoven tříd, dostupných vesměs

pod velmi „volnými“ licencemi typu GNU/LGPL, při vývoji v prostředí C#.NET je většina komponent uveřejněných na internetu placená.

Stránka 42 z 80


3.2 VSTUPNÍ BARIÉRY Vstupní bariéry jsou v případě programování v jazyku Objective-C vysoké. Přestože díky projektu GNUstep [12] existuje vývojové prostředí (IDE) i kompilátor jazyka Objective-C pro všechny nejběžnější platformy (Windows, Linux, Mac OS X, Solaris,…), je tvorba aplikací v Objective-C pod majoritní platformou Windows značně nepohodlná (IDE ProjectCenter nelze srovnávat s pokročilými IDE typu MS Visual Studio, Netbeans nebo Eclipse) a nejsou k dispozici ani veškeré třídy frameworku Cocoa. V praxi má smysl vytvářet aplikace pouze prostřednictvím IDE Xcode, které je bohužel distribuováno pouze s počítači Macintosh. Zatímco celosvětově (díky USA) používá podle některých optimistických statistik počítače Macintosh až 10% uživatelů internetu (viz [27]) a podle střízlivých statistik kolem 5 % uživatelů internetu (viz [28]), v České republice se podíl uživatelů Mac OS X dle [29] pohybuje kolem 1-2 % (díky slabšímu marketingu, vysokým cenám a donedávna absenci české lokalizace). Pokud by se škola rozhodla zavést výuku jazyka Objective-C, muselo by se jednat o kurz určený velmi úzké skupině studentů (majitelů notebooků MacBook), nebo vybavit učebnu počítači Macintosh. V případě druhé varianty je nutné podotknout, že ovládání operačního systému (OS) Mac OS X není zcela kompatibilní s ovládáním OS Windows.

3.3 PERSPEKTIVNOST JAZYKA Objective-C je léty prověřený jazyk, vycházející z principů, které jsou (v základu) staré více než 30 let. Nejedná se jen o jakýsi „módní výstřelek“, u kterého se po době počátečního boomu zjistí, že se v něm zase tak dobře neprogramuje (např. Ruby [30], [31]). Na druhou stranu se jedná o jazyk, jehož úspěch je do značné míry spjat s úspěchem firmy Apple – dokud se budou prodávat a používat přehrávače iPod, tablety iPad a mobilní telefony iPhone, bude mít smysl se jazykem Objective-C zabývat. Dle hospodářských výsledků za rok 2009 [32] se zdá, že v tomto ohledu jazyk Objective-C nic neohrožuje, ba právě naopak.

Stránka 43 z 80


Domnívám se, že v souvislosti s prodejem výše uvedených přístrojů zároveň pozvolna stoupá podíl počítačů s operačním systémem Mac OS X (primárním jazykem v rámci Mac OS X je Objective-C, trend viz Obrázek 4)20.

OBRÁZEK 4: VÝVOJ ZASTOUPENÍ OPERAČNÍCH SYSTÉMŮ - ZDROJ [33]

Alternativním vysvětlením pro nárůst Mac OS X může být také fakt, že volba operačního systému přestává být (zejména pro domácí uživatele) volbou klíčovou – mnoho z „počítačových aktivit“ se již přesunulo na web, a těch pár aplikací, které mimo internetový prohlížeč běžný uživatel počítače využívá, má své alternativy ve všech současných operačních systémech. Za určitý (menší) problém lze z hlediska perspektivnosti jazyka označit probíhající soudní spor firem Nokia a Kodak s firmou Apple ohledně porušení patentů (viz [34], [35]), nicméně dá se očekávat, že nakonec dojde v obou případech k dohodě (pokud vůbec soud rozhodne ve prospěch žalujících stran). Celkově se domnívám, že je perspektiva jazyka Objective-C velmi dobrá – jedná se o objektově orientovaný jazyk s jasně definovaným okruhem použití. Závislost jazyka na úspěšnosti firmy Apple Inc. se v současné době jeví spíše jako výhoda – v posledních 5 letech zaznamenala tato

20

Zákazníci, kteří jsou spokojeni s telefony iPhone a hudebními přehrávači iPad, časem mohou tíhnout ke

koupi počítače s MAC OS X z důvodu zajištění co nejlepší spolupráce jednotlivých přístrojů.

Stránka 44 z 80


firma významné obchodní úspěchy, které jsou srovnatelné s výsledky společnosti Google (viz [36] a graf na obrázku 5).

OBRÁZEK 5: POROVNÁNÍ ZISKÚ SPOLEČNOSTÍ MICROSOFT, APPLE A GOOGLE - ZDROJ [36]

3.4 PODOBNOST JAZYKA S OSTATNÍMI Z přehledného srovnání [37] je patrné, že rozdíly mezi jazykem Objective-C a jeho konkurenty (Java, C++, Ruby, Python) nejsou příliš výrazné21. Objective-C dává programátorům oproti ostatním jazykům na výběr mezi dynamickým a statickým typováním – kdo je zvyklý (například z jazyků PHP, Ruby, Python) používat dynamické typování, může veškeré odkazy na objekty ukládat do proměnné typu id a pracovat s nimi bez omezení (zasílat jim libovolné zprávy). Komu naopak (např. z Javy, C# nebo C++) vyhovuje statické typování, může odkazy na objekty vkládat do proměnných typu Class (kde Class odpovídá názvu třídy), a využít tak kontrolu typů během kompilace (bonusem ke

statickému typování je funkce „code completion“22 ve vývojovém prostředí Xcode). 21

Ve srovnání chybí jazyk C#, který je však v mnoha ohledech velmi podobný jazyku Java.

22

Automatické doplňování kódu (např. nabízení automatického doplnění kódu zaslání zprávy k objektu

konkrétní třídy) je širokou veřejností nazýváno též jako tzv. „IntelliSense“ (podle funkce z vývojového prostředí MS Visual Studio).

Stránka 45 z 80


Podobně jako ostatní jazyky (s výjimkou C++) podporuje jazyk Objective-C tzv. „reflexi“, za běhu programu tedy jsou k dispozici funkce pro zjištění seznamu instančních proměnných, seznamu zpráv, na které je schopen objekt reagovat atd. Reflexe se hodí zejména pro ladění aplikací, určité funkce naleznou své uplatnění také při dynamicky typovaném programování. Kompletní možnosti reflexe v Objective-C jsou popsány v manuálu Objective-C Runtime Reference [38]. Objective-C umožňuje na rozdíl od jazyku Java tzv. „forwarding“, který spočívá v přesměrovávání určitých zpráv z jednoho objektu na jiný objekt (případně objekty). Objekt, který neumí (nebo nechce) reagovat na určitou zprávu, ji může jako celek vzít, zaslat ji na jiný objekt, na nějž drží odkaz, a případně vrátit výsledek, který od tohoto objektu obdrží. Tato technika se chodí například pro snadnou implementaci návrhových vzorů Observer (Pozorovatel) nebo Proxy (Zástupce). V Objective-C je stejně jako v Javě možné realizovat pouze jednonásobnou dědičnost tříd (na rozdíl od C++ nebo Pythonu). Ve většině případů toto omezení nikterak nevadí, a dá se případně „obejít“ pomocí protokolů (odpovídají cca rozhraním v Javě) nebo kategorií. Kategorie umožňují rozšiřovat funkcionalitu veškerých tříd – dovolují přidávat metody dokonce i ke standardním třídám z knihoven tříd, k jejichž zdrojovým kódům nemáme přístup. Kategorie se využívají též v případech, kdy se z nějakého důvodu hodí rozdělit kód třídy do více souborů. V jazyku C# lze podobného chování docílit pomocí tzv. „parciálních tříd“, případně pomocí vlastnosti „extension methods“ (více viz [39]). V Javě nic podobného neexistuje. Podobně jako snad ve všech objektově orientovaných jazycích, lze i v Objective-C definovat instanční proměnné jako soukromé (private), sdílené s potomky (protected) nebo volně dostupné (public). Na druhou stranu neexistuje přímá podpora pro definici privátních metod – chceme-li nějakou metodu zpřístupnit pouze samotné třídě nebo její instanci, musíme prostřednictvím tzv. „rozšíření“ vytvořit dva různé hlavičkové soubory. V Objective-C je možné definovat metody třídy (ekvivalent statických metod v Javě), nelze však definovat proměnné ani konstanty třídy (ekvivalent statických proměnných v Javě). Konstanty je možné definovat pouze na úrovni celého programu pomocí příkazu preprocesoru #define (poté však nemají žádnou návaznost na konkrétní třídu a jsou k dispozici v celém programu), proměnné vázané na konkrétní třídu lze definovat pouze v rámci statických metod této třídy, s využitím modifikátoru static. Pro přístup k hodnotě takto definované proměnné je zapotřebí definovat pomocné metody (tzv. „getters“ a „setters“), nelze k nim přistupovat přímo. Stránka 46 z 80


Z hlediska správy paměti dává Objective-C programátorovi na výběr mezi automatickou správou paměti (alternativa tzv. „garbage collectoru“) a explicitní správou paměti, při které je zapotřebí explicitně určit, kdy se má který objekt uvolnit z paměti. Jednoznačnou nevýhodou jazyku Objective-C oproti např. Javě a C# je absence jmenných prostorů (viz níže).

3.5 NÁROČNOST SYNTAXE Syntaxe jazyka Objective-C víceméně pouze rozšiřuje pravidla syntaxe jazyka C o podporu objektů – vše, co se tedy objektů bezprostředně netýká, by mělo být „běžnému“ programátorovi zvyklému na jazyky typu C, Java, C# nebo třeba i Javascript důvěrně známé. Jedinou výjimku v tomto ohledu představuje nutnost tvorby hlavičkových souborů, která se z dnešního pohledu může mnohým programátorům jevit jako překonaná a obtěžující23, a případně také práce s ukazateli. Část syntaxe jazyka Objective-C týkající se objektů byla inspirována syntaxí jazyka Smalltalk, a jako taková nemá mnoho společných prvků s ostatními běžně používanými programovacími jazyky. Za nejvýznamnější odlišnost lze označit princip zasílání zpráv objektům, namísto tradičnějšího volání metod objektů. Princip zasílání zpráv objektům (včetně způsobu definice parametrů zpráv) není sám o sobě příliš složitý na pochopení, na druhou stranu může programátory, kteří již mají zkušenosti s nějakým jiným objektově orientovaným jazykem, zmást, nebo dokonce odradit. Při výuce Objective-C bych proto jednoznačně doporučoval věnovat problematice zasílání zpráv velký prostor. Často zmiňovanou nevýhodou jazyka Objective-C je absence jmenných prostorů – díky ní musí programátoři používat před všemi názvy tříd prefixy, aby nedocházelo ke kolizím (například datové typy z knihovny tříd Cocoa obsahují prefixy NS – přestože se na to dá zvyknout, je práce s třídami NSString, NSInteger apod. zbytečně obtěžující).

23

Práci s hlavičkovými soubory do velké míry usnadňuje vývojové prostředí Xcode – při vytváření nové

třídy automaticky vytváří soubor s deklarací (*.h) i definicí (*.m), a v rámci editace jedné třídy je možné snadno přepínat mezi oběma soubory pomocí klávesové zkratky cmd + alt + nahoru.

Stránka 47 z 80


3.6 DOSTUPNOST A POUŽITELNOST VÝVOJOVÉHO PROSTŘEDÍ 3.6.1 STRUČNÉ PŘEDSTAVENÍ XCODE Pro programování v jazyku Objective-C je všem uživatelům systému Mac OS X k dispozici vývojové prostředí Xcode, které lze zdarma stáhnout společně s různými knihovnami tříd a SDK24 ze stránek http://developer.apple.com. Kromě tohoto vývojového prostředí ještě existují alternativy v podobě např. ProjectCenter (GNUstep, [12]), nicméně s ohledem na jejich (ne)použitelnost pro běžnou praxi jsem se rozhodl dále zabývat pouze prostředím Xcode25. Vývojové prostředí Xcode [40] je integrovaná sada nástrojů pro psaní programového kódu (kromě jazyku Objective-C je podporován také jazyk C++ a samozřejmě C), jeho kompilaci a ladění. Kromě těchto základních funkcí obsahuje též nástroje pro tvorbu grafického uživatelského rozhraní (Interface Builder) a animací (Quartz Composer), nástroj pro vytváření datového modelu (aplikace využívající framework Core Data26) a pokročilé nástroje pro testování aplikací (od jednotkových testů až po monitorování zátěže procesoru a paměti). Součástí Xcode je rovněž klient pro systém správy verzí (Subversion), funkce pro porovnávání obsahu dvou souborů, refactoring (např. pro bezpečné přejmenovávání názvů tříd), nápověda k jazyku Objective-C a oblíbená funkce code completion (našeptávač pro psaní kódu, ve „Windows světe“ označovaný jako „IntelliSense“).

3.6.2 ZÁKLADNÍ OKNO APLIKACE, VYTVÁŘENÍ PROJEKTŮ A PSANÍ KÓDU Vytváření projektů je v Xcode prakticky stejné jako v kterémkoli jiném moderním vývojovém prostředí (MS Visual Studio, Netbeans,…) – v menu Xcode stačí zvolit položku „File – New Project“, zvolit výchozí šablonu projektu (zda se bude jednat o aplikaci, knihovnu nebo zásuvný 24

SDK (Software Development Kit) – sada nástrojů pro tvorbu aplikací pro určitou platformu.

25

Možnosti vývojového prostředí Xcode jsou velice rozsáhlé, v rámci této diplomové práce se proto budu

zabývat jen těmi nejdůležitějšími vlastnostmi. 26

Framework Core Data poskytuje služby pro práci s daty aplikace, které programátora zcela odstiňují

např. od fyzického ukládání dat na pevný disk. S pomocí Xcode programátor nakreslí ER diagram (definuje tzv. „managed objekty“, jejich atributy a vazby mezi nimi), a poté již s daty pracuje podobně, jako kdyby byla uložena v relační databázi. Jedná se o určitou (velmi omezenou) analogii k Java Persistence API. Více v [54].

Stránka 48 z 80


modul a jaká knihovna tříd se má použít – zda Cocoa nebo Cocoa Touch – viz Obrázek 7 na následující straně) a určit název projektu. Následně dojde k automatickému vytvoření potřebné adresářové struktury a základu aplikace. Zvolíme-li jako šablonu projektu například Command Line Tool a typ Foundation, vygeneruje se nám aplikace, která na konzoli vypíše text „Ahoj, světe!“ („Hello, World!“):

OBRÁZEK 6: ZÁKLADNÍ OKNO PROJEKTU V XCODE

Na obrázku 6 vidíme základní okno projektu v Xcode. V levém sloupci vidíme odděleně soubory zdrojového kódu, soubory dokumentace, používané knihovny tříd a výsledné produkty (v našem případě aplikace AhojSvete – červená barva značí, že ještě neproběhla kompilace). Dále v levé části nalezneme seznam cílů projektu (můžeme chtít vytvořit více verzí jednoho programu – například pro různé verze operačního systému), ikonku pro systém správy verzí (SCM), seznam souborů s implementacemi tříd nebo soubory tvořící grafické uživatelské rozhraní (v případě konzolové aplikace je tato složka samozřejmě prázdná). Stránka 49 z 80


Horní část pravého sloupce obsahuje seznam souborů odpovídajících aktuálně vybrané složce v levém sloupci. Sloupeček nadepsaný kladívkem nás v případě zatržení informuje o tom, že daný soubor zatím nebyl přeložen, v posledním sloupci se dozvíme, zda je daný soubor součástí aktuálního zvoleného cíle. Ve spodní části okna se nachází obsah aktuálně vybraného souboru s demonstrací výše zmíněné funkce Code completion. Xcode se snaží nabídnout nejpravděpodobnější název zprávy, kterou bychom mohli chtít danému objektu poslat. Po stisknutí klávesové zkratky Fn+F5 nám je nabídnut seznam všech možností včetně popisu parametrů. Funkce Code completion samozřejmě funguje také pro psaní názvů tříd, proměnných atd. Dvojím poklepáním na název souboru se nám otevře velké okno editoru zdrojového kódu. Psaní kódu je díky funkci Code completion, zvýrazňování závorek a automatické kontrole syntaxe pohodlné (podobně jako v MS Visual Studio nebo Netbeans), zamrzí však neexistence nástroje pro řešení problémů27, který se stal v poslední době již víceméně standardem.

OBRÁZEK 7: VYTVOŘENÍ APLIKACE S GUI A VYUŽITÍM CORE DATA

27

V případě chybějícího importu hlavičkového souboru Xcode vypíše chybu, že používáme

nedeklarovanou třídu. Není však již schopen nabídnout automatické doplnění importu podle názvu používané třídy.

Stránka 50 z 80


3.6.3 EDITOR ER DIAGRAMŮ Chceme-li v rámci projektu využívat framework Core Data pro odstínění práce s ukládáním dat, stačí jeho využití zatrhnout při vytváření projektu. V levém sloupci hlavního okna Xcode se nám objeví složka s názvem Models, která bude obsahovat jeden soubor typu .xcdatamodel. Tento soubor můžeme otevřít v editoru ER diagramů (dvojklikem), a v grafickém režimu „naklikat“ entity, se kterými budeme chtít v aplikaci pracovat:

OBRÁZEK 8: TVORBA ER DIAGRAMU V XCODE

Na obrázku 8 je zobrazen ER diagram jednoduché aplikace pro evidenci kamarádů a jejich závazků. Ke každé entitě (která je vždy potomkem třídy NSManagedObject) máme možnost definovat libovolný počet atributů s uvedením typu, a následně definovat vazby mezi těmito entitami (vazby lze definovat tažením myší po klepnutí na ikonku čáry v levém spodním rohu). S definovanými entitami je následně možné pracovat buď v rámci vlastních tříd tvořících model aplikace (viz [41]), nebo je rovnou propojit s třídami grafického uživatelského rozhraní.

3.6.4 TVORBA GRAFICKÉHO UŽIVATELSKÉHO ROZHRANÍ Pro definici grafického uživatelského rozhraní (GUI) slouží přidružená aplikace Interface Builder, která se automaticky otevře po kliknutí na soubory typu xib ve složce Interface Builder Files (standardně je u grafických aplikací vytvářen soubor MainMenu.xib). Stránka 51 z 80


OBRÁZEK 9: PROSTŘEDÍ PROGRAMU INTERFACE BUILDER

Soubor *.xib v sobě sdružuje objekty tvořící jednu obrazovku GUI (viz obrázek 9) – mimo jiné objekt reprezentující hlavní menu aplikace (může obsahovat položky menu, oddělovače, víceúrovňové seznamy,…) a objekt okna, do kterého je možné přetahovat komponenty z knihovny. Po kliknutí na určitý objekt GUI je možné měnit jeho pozici, velikost (podržením klávesy ALT) a nastavovat různé vlastnosti v okně „Attributes“. Ovládání aplikace Interface Builder je velmi podobné například programům Netbeans nebo MS Visual Studio (s tím rozdílem, že Xcode a Interface Builder razí strategii mnoha malých oken, zatímco konkurenční prostředí integrují vše do jednoho okna aplikace s několika panely).

Stránka 52 z 80


Z odlišností stojí za zmínku snad jen přímé propojení dvou objektů pomocí zasílání zpráv28 a možnost přetahování entit z editoru ER diagramů do okna aplikace (za současného podržení klávesy ALT). Interface Builder automaticky nabídne několik možností grafické reprezentace dat včetně definování různých akcí (v [8] je uvedena ukázka jednoduché aplikace využívající framework Core Data, ve které nebylo zapotřebí napsat ani řádek vlastního programového kódu).

3.7 DOSTUPNOST LITERATURY Jazyk Objective-C dlouhodobě trpěl a částečně ještě stále trpí existencí tzv. „non-disclosure agreement“ (NDA, dohoda o mlčenlivosti), která do velké míry omezovala publikaci jakýchkoli materiálů týkajících se knihoven tříd Cocoa, Cocoa Touch a vývojového prostředí Xcode. V současné době licence na stránkách developer.apple.com (v rámci průvodce registrací vývojáře a stažení Xcode vč. knihoven tříd) zakazuje publikovat pouze detaily o oficiálně nevydaných verzích Xcode a knihovnách (aby např. nebyly vyzrazeny funkce připravovaných zařízení). Uživatelé si však na NDA mezitím docela zvykli, a při hledání informací na internetu lze běžně narazit na názory, že o určitých specifických vlastnostech knihoven nebo Xcode zkrátka diskutovat nelze. Přesto však literatury (zejména té na internetu) není málo. V České republice se dlouhodobě problematice programování v Objective-C věnuje RNDr. Ondřej Čada – prakticky veškeré materiály v českém jazyce pochází od něj (ať už se jedná o jedinou českou knihu o Objective-C – „Cocoa, úvod do programování počítačů Apple“ [8], nebo o „nekonečný“ online seriál článků „Nastal čas na kakao…“ [42]). Z anglicky psané literatury je vývojáři na internetu nejčastěji doporučována kniha Cocoa® Programming for Mac® OS X od Aarona Hillegasse. Velice kvalitní a srozumitelná je také dokumentace na stránkách developer.apple.com: -

Rozcestník návodů na tvorbu aplikací s knihovnou tříd Cocoa: http://developer.apple.com/mac/library/navigation/

-

Rozcestník návodů na tvorbu aplikací s knihovnou tříd Cocoa Touch: http://developer.apple.com/iphone/library/navigation/

28

Interface Builder u objektů GUI, které vytváří nějakou akci (například tlačítko vytváří akci / zprávu

performClick) nabídne zaslání této akce na objekty deklarující zprávy s typem IBAction (z hlediska

překladače je ekvivalentní k void). Deklarovat zprávy s návratovým typem IBAction přitom může libovolný objekt (nejen objekt GUI).

Stránka 53 z 80


3.8 SOULAD S MYŠLENKAMI OOP A MOŽNOSTI IMPLEMENTACE NÁVRHOVÝCH VZORŮ 3.8.1 APLIKACE ZÁSAD OOP NA JAZYK OBJECTIVE-C Pro účely zhodnocení souladu jazyka Objective-C s myšlenkami objektově orientovaného programování (OOP) jsem se rozhodl inspirovat knihou Návrhové vzory [43], ve které je v úvodu definováno 9 zásad OOP. Přestože se jedná spíše o rady „jak programovat objektově“, než „jak by měl vypadat objektově orientovaný jazyk“, domnívám se, že tyto věci spolu úzce souvisí. Nepochybně existují jazyky, ve kterých se objektově programuje lépe než v jiných jazycích, nebo dokonce jazyky, které díky svým vlastnostem programátora nutí k dodržování (nebo naopak porušování) zásad OOP. První zásadou OOP zmíněnou ve [43] je programování oproti rozhraní. Tato zásada doporučuje proměnné deklarovat spíše jako instance určitého rozhraní (tříd implementujících určité rozhraní), než jako instance konkrétních tříd. Dodržením této zásady si při programování otevíráme cestu pro snadnější rozšiřování aplikace o nové třídy – budeme-li chtít využít například určitou proměnnou pro instance dvou různých tříd, bude stačit, aby obě tyto třídy implementovaly určité (stejné) rozhraní. V Objective-C je programování oproti rozhraní velice snadno realizovatelné – libovolnou proměnnou můžeme deklarovat jako instanci odpovídající určitému protokolu, nebo dokonce instanci určité třídy odpovídající určitým protokolům (můžeme třeba chtít mít proměnnou, ve které bude instance potomka určité abstraktní třídy, která bude implementovat 2 různá rozhraní). Ukázka deklarace proměnných: // ukazatel na instanci libovolné třídy odpovídající protokolu MujProtokol id <MujProtokol> promennaJedna; // ukazatel na instanci třídy AbstraktniTrida (jejího potomka), která odpovídá // protokolům MujProtokol a TvujProtokol AbstraktniTrida <MujProtokol, TvujProtokol> *promennaDve;

Protokoly jsou v Objective-C dle [44] hojně využívány například pro zasílání zpráv mezi objekty ve vícevláknových aplikacích; hojně jich nalezneme také například u objektů grafického uživatelského rozhraní. Na druhou stranu je potřeba poznamenat, že používání protokolů není v rámci Objective-C díky možnosti dynamického typování nezbytné – pokud v kódu budeme chtít zaslat určitému objektu nepodporovanou zprávu, objeví se při překladu pouze varování. Stránka 54 z 80


S první zásadou úzce souvisí požadavek na odstranění přímých vazeb. Podobně jako proměnné by měly být i metody deklarované tak, aby pracovaly spíše s instancemi tříd odpovídajících určitým protokolům (implementujících určité rozhraní), než s instancemi konkrétních tříd. V Objective-C samozřejmě není vůbec žádný problém definovat vstupní parametry i návratové hodnoty metod jako instance objektů odpovídajících určitému protokolu. Zásada ukrývání implementace doporučuje zpřístupňovat okolí pouze ty metody, které jsou pro něj nezbytné. To je velmi důležité z hlediska možné budoucí změny funkcionality objektů – metody, které nejsou okolním objektům přístupné, lze bez obav měnit (ať už se jedná o počet vstupních parametrů, návratový typ nebo algoritmus) nebo je dokonce z objektu odebrat a nahradit je jinými metodami. Stejná situace panuje u atributů objektů (resp. instančních proměnných), které by v duchu této zásady měly být vždy soukromé (private) a zpřístupňované pouze prostřednictvím k tomu určených metod. V Objective-C je podporována definice soukromých instančních proměnných i atributů, soukromé metody však lze implementovat pouze oklikou – vytvořením soukromého rozhraní pomocí tzv. „rozšíření“ (ukázka a bližší popis je v první části této práce). Vzhledem k tomu, že je možné jakémukoli objektu zaslat libovolnou zprávu (buď na ni odpoví, nebo ji bude ignorovat), je evidentní, že dodržování této zásady je z velké míry ponecháno na přístupu programátorů. Přestože je dědičnost jedním ze základních pilířů OOP, neměla by se používat vždy, když je potřeba pouze sdílet určitou funkcionalitu nebo vlastnost objektů. Zjednodušeně řečeno, dědičnost je určena zejména pro vytváření takových tříd, o kterých je možné prohlásit, že jsou určitou specializací rodičovské třídy (u třídy Osoba má smysl definovat potomka Žena, na druhou stranu u třídy Pták nemá smysl vytvářet potomka Letadlo, přestože obě entity umí létat). V rámci zásad OOP je doporučováno upřednostňovat skládání před dědičností – objekt v takovém případě deleguje vykonání sdílené funkcionality na instanci nějakého jiného objektu. Aplikace výše uvedené zásady v Objective-C je velice jednoduchá – každý objekt může snadno delegovat reakci na zaslání určité zprávy pouhým přeposláním zprávy a vrácením obdrženého výsledku. Kromě toho je možné funkcionalitu zabalit do podoby tzv. „kategorie“, o kterou je možné rozšířit funkcionalitu libovolného objektu (ukázka a bližší popis v první části této práce).

Stránka 55 z 80


Poslední zásada OOP, kterou si z [43] vypůjčím29, spočívá v eliminaci duplicit v kódu. V praxi tato zásada znamená, že bychom při programování neměli kopírovat části kódů na více míst, ale umisťovat tyto části do samostatných objektů. V případě, že potřebujeme mezi různými objekty sdílet určitou proměnnou, je lépe ji v jednom objektu definovat jako statickou konstantu (případně statickou proměnnou). Zatímco eliminaci duplicit v kódu lze v Objective-C velmi efektivně řešit různými způsoby (např. pomocí kategorií), statické proměnné (proměnné třídy) definovat nelze. Je možné definovat pouze globálně existující konstantu (bez vazby na konkrétní třídu), nebo definovat v rámci metody třídy proměnnou s modifikátorem static (viz výše část Podobnost jazyka s ostatními).

3.8.2 IMPLEMENTACE VYBRANÝCH NÁVRHOVÝCH VZORŮ Soulad s myšlenkami OOP lze ověřit také na (ne)snadnosti implementace návrhových vzorů. Z [43] jsem se rozhodl vybrat následující 4 návrhové vzory: Knihovní třída (Library Class), Jedináček (Singleton), Dekorátor (Decorator) a Pozorovatel (Observer). Jednotlivé vzory jsem zvolil na základě jejich (ne)snadnosti implementace v Objective-C. Knihovní třída (dle [43], str. 103) “slouží jako obálka pro soubor statických metod“. Jelikož nemá smysl vytvářet instance této třídy, měla by jejich vytváření tato třída zakázat. Implementace knihovní třídy v Objective-C naráží na jeden základní problém – není možné definovat soukromé metody a ani 100% zabezpečit, aby nebylo možné určitému objektu zaslat například zprávu init (budeme-li dědit z třídy NSObject, bude vždy možné zprávu init zaslat bez varování při překladu, podstoupíme-li martyrium vytváření knihovní třídy bez dědění z třídy NSObject, docílíme pouze výpisu onoho varování při překladu).

Dle [45] je doporučováno vyvolat výjimku NSInternalInconsistencyException, případně definovat metodu init tak, aby pokaždé vracela konstantu nil. V každém případě půjde výsledný program přeložit, i pokud se v něm budeme (byť neúspěšně) pokoušet vytvářet instanci knihovní třídy. Oželíme-li nemožnost zákazu vytváření instance knihovní třídy, můžeme samozřejmě definovat třídu obsahující pouze samé statické metody. V diskusi na [46] nicméně diskutující připomínají, 29

Ostatní uvedené zásady se týkají pouze programování a nejsou závislé na programovacím jazyku –

jedná se o soudržnost (jedna entita má jeden úkol), návrh řízený odpovědnostmi (jeden úkol je řešen jednou entitou), minimální vzájemnou provázanost (objekt by měl pro funkčnost vyžadovat minimum dalších objektů) a nesnažení se o maximální efektivitu programu na úkor přehlednosti.

Stránka 56 z 80


že ne vše musí být nutně v Objective-C řešeno pomocí objektů – pro realizaci „knihovní třídy“ je ve většině případů nejvhodnější definovat sadu „obyčejných“ funkcí v jazyce C, a v případě potřeby tyto funkce importovat (podobně jako standardní funkce jazyka knihovny jazyka C – viz stručný přehled jazyka C v první části této práce). Soukromý konstruktor využívá ve většině jazyků také návrhový vzor Jedináček, jehož úkolem je zajistit, aby existovala vždy právě jedna instance určité třídy. Také v jeho případě se programátoři musí nějak vypořádat s neexistencí možnosti zablokovat vytváření nových instancí pomocí zpráv alloc / init. Níže uvedený příklad z [47] v případě opakovaného volání metody init vyvolá výjimku: static MojeTrida *mojeTrida = nil; + (id)getMojeTrida { @synchronize( self ) { if (mojeTrida == nil ) { mojeTrida = [[self alloc] init]; } } return mojeTrida; } - (id)init { if (mojeTrida!= nil ) { // vyhození výjimky v případě opakovaného volání init [NSException raise:NSInternalInconsistencyException format:@"[%@ %@] cannot be called; use +[%@ %@] instead"], NSStringFromClass([self class]), NSStringFromSelector(_cmd), NSStringFromClass([self class]), NSStringFromSelector(@selector(getMojeTrida)"]; } else if ( self = [super init] ) { mojeTrida = self; // zde může proběhnout další inicializace objektu } return mojeTrida; } // následující část je nutná pouze v případě využívání explicitní správy paměti - (NSUInteger)retainCount { return NSUIntegerMax; // nepřejeme si zrušit instanci } - (oneway void)release {} // nepřejeme si zrušit instanci - (id)retain { return sharedInst; // není potřeba předávat zprávu retain dál } - (id)autorelease { return mojeTrida; // zablokujeme možnost přechodu do režimu expl. správy paměti }

Dekorátor (dle [43], str. 343) „přidává další přídavnou funkcionalitu tak, že objekt „zabalí“ do jiného objektu, který má na starosti pouze přídavnou funkcionalitu, a zbytek požadavků deleguje na „zabalený“ objekt. Tím umožňuje přidávat funkčnost dynamicky a zavádí flexibilní alternativu k dědění.“

Stránka 57 z 80


Popis návrhového vzoru Dekorátor se téměř kryje s funkcionalitou kategorií v Objective-C, hlavním podstatným rozdílem je, že kategorie nedovoluje přidávat instanční proměnné. Dekorátor je možné realizovat samozřejmě také „klasicky“, a to přeposíláním zpráv na vnořený objekt. Návrhový vzor Pozorovatel (dle [43], str. 375) “zavádí vztah mezi objekty (pozorovateli) reagujícími na změnu stavu (pozorovaného) objektu nebo jím sledované události. Pozorovatelé se u pozorovaného objektu přihlásí, a ten je pak na každou změnu svého stavu či výskyt událostí upozorní.“ Pro návrhový vzor Pozorovatel existují v Objective-C (frameworku Cocoa) dva velice efektivní způsoby řešení – prostřednictvím tzv. „notifikačního centra“ (NSNotificationCenter), u kterého je možné libovolný objekt zaregistrovat pro příjem určitých zpráv a do kterého zároveň mohou všechny objekty zasílat vlastní zprávy, a tzv. „pozorovatele hodnot klíčů“ (Key-Value Observing), s jehož pomocí lze monitorovat změny hodnot atributů objektů (tento pozorovatel je dostupný jen u určitých objektů, proto se jím nebudu dále zabývat – podrobnosti viz [48]). Ukázka práce s třídou NSNotificationCenter – fragmenty kódu (více viz [49]): // registrace pozorovatele u NSNotificationCenter [[NSNotificationCenter defaultCenter] addObserver:self // zašli notifikaci mně selector:@selector(nazevMojiMetody) // notifikaci zpracuji touto metodou name:@"uzivatelSeOdhlasil" // chci přijímat notifikace s názvem uzivatelSeOdhlasil object:nil // které zaslal libovolný objekt (zde možno uvést odkaz na // konkrétní objekt) ]; // odeslání notifikace do notifikačního centra pozorovaným [[NSNotificationCenter defaultCenter] postNotificationName: @"uzivatelSeOdhlasil" // název notifikace object:self // chci uvést, že notifikaci odesílám já ]; // zpracování notifikace u pozorovatele -(void) nazevMojiMetody:(NSNotification *)upozorneni { NSString* nazevUpozorneni = [upozorneni name]; id pozorovanyObjekt = [upozorneni object]; }

Návrhový vzor Pozorovatel je možné samozřejmě řešit i „vlastními silami“ v duchu [43], využití notifikačního centra je však mnohem efektivnější.

3.9 OKAMŽITÝ UŽITEK ZE ZNALOSTI Učení jakéhokoli programovacího jazyku (a vlastně i čehokoli jiného) je výrazně snazší, jsou-li studenti ke studiu správně vnitřně motivováni. Domnívám se, že jedním z hlavních „spouštěčů“ Stránka 58 z 80


vnitřní motivace je možnost okamžitého užitku ze znalosti, možnost si hned vyzkoušet nově naučenou látku v praxi a na něčem smysluplném, tedy pokud možno něčem, co i během studia může přinést nějaké peníze. Zároveň by však praxe neměla studenty pohltit natolik, aby již neměli čas na další studium (nemělo by se jednat o práci na plný úvazek). Z tohoto úhlu pohledu má jazyk Objective-C nespornou výhodu – díky vyřešenému způsobu distribuce aplikací pro Mac i přenosná zařízení se programátoři mohou starat výlučně o programování. Vzhledem k možnosti samostatné práce na živnostenský list (většina aplikací, které slavily v App Store úspěch, byly velice primitivní a daly se naprogramovat za několik hodin až dní bez nutnosti spolupráce více programátorů) navíc odpadají problémy s případným tlakem zaměstnavatelů na zanedbávání školních povinností30. Další nespornou výhodou programování v Objective-C je nízká konkurence – například aplikace pro iPhone v současné době dle [50] vytváří zhruba jen dvě desítky Čechů.

3.10 ZÁJEM O PROGRAMÁTORY NA TRHU PRÁCE Přestože lze v Objective-C programovat i (komerčně úspěšné) jednoduché aplikace, má smysl se zaobírat také myšlenkou zaměstnání v nějaké firmě a začít (třeba po škole) dělat složitější aplikace. Podíváme-li se však na nabídky největších pracovních serverů v ČR, zjistíme, že na Monster.com, Sprace.cz ani Itjobs.cz neexistuje žádná poptávka po programátorech v Objective-C! Jediná

poptávka po programátorovi v Objective-C je v tomto momentě vystavena na portálu Jobs.cz (Alwil Software a. s., výrobce antivirového systému avast!). Programátorům v Objective-C hledajících uplatnění v současné době zbývají dvě alternativy – sledovat poptávky po programátorech v diskusním fóru Webtrh.cz (zasláno je cca 10 poptávek ročně, což rozhodně není mnoho), nebo přímo oslovovat firmy, které se vývojem aplikací zabývají (za nejvýraznějšího „hráče na trhu“ bych v tomto ohledu označil společnost uLikeIT, s.r.o.). Zájem o programátory na českém trhu práce je (s ohledem na popularitu telefonů iPhone) překvapivě velice nízký, a zcela zanedbatelný ve srovnání s jazyky Java, C# nebo C++.

30

Tento tlak vnímám u mnohých spolužáků z oboru, kteří jsou zaměstnáni.

Stránka 59 z 80


3.11 PRŮZKUM ZÁJMU STUDENTŮ O OBJECTIVE-C MEZI STUDENTY VŠ V ČR Za účelem zjištění zájmu studentů o výuku Objective-C jsem vytvořil prostřednictvím internetové služby Vyplnto.cz internetový dotazník [51], který jsem distribuoval mezi studenty VŠE zejména prostřednictvím stránky Vseborec.cz. Průzkumu se zúčastnilo 32 platných respondentů (studentů nebo absolventů VŠE, ostatní response byly filtrovány), z toho 28 mužů a 4 ženy. Návratnost dotazníků31 byla výrazně podprůměrná – pouhých 18,3% (při celkových 36 responsích byl dotazník zobrazen cca 200 lidem). Nízkou návratnost dotazníků mohla na jednu stranu způsobit jeho náročnost (nejzajímavější výsledky jsou k dispozici v příloze, kompletní neočištěné výsledky a dotazník je možné nalézt na [51]), na druhou stranu však také zájmem nerelevantních respondentů o vytváření aplikací pro iPhone. Předpokládám, že dotazník díky svému názvu („Chtěli byste umět vytvářet aplikace pro iPhone nebo Macintosh?“) lákal k vyplnění především ty respondenty, kteří mají o programování v Objective-C zájem. Přesto zájemci o programování v tomto jazyce tvořili menšinu – kolem 20% (viz obrázek 10).

OBRÁZEK 10: ZÁJEM O VÝVOJ APLIKACÍ V OBJECTIVE-C

31

Návratnost dotazníků je počítána jako poměr počtu vyplněných dotazníků a jeho unikátních zobrazení

(rozlišení dle cookies). Průměrná návratnost všech dotazníků publikovaných na Vyplnto.cz je 52,4%.

Stránka 60 z 80


Respondenti, kteří zcela nevyloučili vývoj aplikací pro iPhone / Macintosh byli dále dotázáni na největší výhody i nevýhody tohoto vývoje. Mezi výhodami se na předních místech objevil vyřešený obchodní model – prodej aplikací přes appStore (85%), nízká úroveň pirátství (46%) a uzavřenost platformy, včetně z toho vyplývající nižší variabilita koncových zařízení (46%). Největším problémem při programování v Objective-C je nutnost vlastnit počítač Macintosh (62%), závislost na firmě Apple a jejích restrikcích (38%) a nízký podíl koncových zařízení na trhu (31%). Celkem 12 respondentů nevyloučilo, že by si v případě otevření kurzu Objective-C tento kurz zapsali, pouze 3 respondenti však přiznali, že jsou majiteli počítače Macintosh (4 lidé připustili, že by si jej možná koupili). Přestože studenti označili vývoj aplikací pro iPhone jako nejsnazší způsob vydělání peněz programováním (viz příloha 1), lze z výsledků průzkumu usoudit, že zájem o výuku Objective-C je v tomto momentě mezi studenty VŠE nízký. Velmi pravděpodobně by se nepodařilo naplnit ani jeden kurz.

3.12 VYHODNOCENÍ KRITÉRIÍ V rámci výše uvedených deseti kritérií jsem se pokusil posoudit účelnost zařazení jazyka Objective-C do výuky, respektive diskutovat jeho přednosti a slabé stránky. Ukázalo se, že jazyk Objective-C (minimálně prozatím) není vhodný pro „plošnou“ výuku na vysokých školách, jelikož je pro tyto účely příliš specifický a příliš nedostupný. Vysoké bariéry vstupu v podobě nutnosti vlastnit počítač s operačním systémem Mac OS X se škole ani jejím studentům v současné době nevyplatí překonávat, zejména s ohledem na prakticky nulovou poptávku po programátorech Objective-C ze strany firem (které by jinak mohly pomoci například s vybavením učeben). V současné době je výhodné umět jazyk Objective-C prakticky pouze z důvodu úspěchu mobilního telefonu iPhone – vývoj aplikací pro tato zařízení však oslovuje pouze velmi specifickou skupinu lidí (což prokázal nejen průzkum provedený mezi studenty VŠE, ale i fakt, že je v ČR v současné době pouze kolem 20 vývojářů těchto aplikací). Přese vše uvedené výše však rozhodně nelze jazyk Objective-C zcela odepsat – právě naopak! Odpoutáme-li se totiž od „majoritního vidění světa“, opustíme-li platformu Windows a představíme-li si programátora, který je zvyklý používat počítač Macintosh, získáme rázem úplně jiný pohled na jazyk Objective-C. Stránka 61 z 80


Nebudeme zatíženi vůbec žádnými vstupními bariérami a budeme si užívat luxusu, který vývoj pro „Mac“ nabízí – např. perfektní vývojové prostředí Xcode v rámci licence operačního systému, nadstandardní kvalitu dokumentace na developer.apple.com, vyřešený způsob distribuce aplikací přes App Store a nízkou úroveň pirátství. Nesmíme zapomenout také na některé zajímavé vlastnosti jazyka Objective-C a frameworku Cocoa – například princip zasílání a předávání zpráv mezi objekty, snadné rozšiřování funkcionality tříd pomocí kategorií, notifikační centrum pro snadnou realizaci návrhového vzoru Pozorovatel, nebo volnost při výběru dynamického nebo statického typování, stejně tak jako možnost volby mezi automatickou a explicitní správou paměti. Z pohledu programátora Objective-C nemusíme řešit to, že se spousta věcí dělá v Objective-C zkrátka jinak než třeba v Javě, C# nebo PHP. Uvažujeme-li však o zařazení jazyka do výuky, je jakákoli kolize s majoritními jazyky velice nepříjemná. Sečteno a podtrženo – naučit se jazyk Objective-C může být velice dobrá volba pro ty, kteří chtějí vyvíjet mobilní aplikace a nebojí se počáteční investice do počítače Macintosh, případně již tento počítač mají. Jazyk Objective-C není ve výsledku natolik těžký, aby se jej nebylo možné naučit samostudiem, za pomoci dostupné literatury. Pro ostatní programátory bude lepší se porozhlédnout po některém z jiných, „konvenčnějších“ jazyků, jakými jsou například Java nebo C# – tímto směrem by se také měla i nadále ubírat výuka na vysokých školách.

Stránka 62 z 80


4 ZÁVĚR 4.1 SHRNUTÍ DIPLOMOVÉ PRÁCE V této diplomové práci jsem se zabýval popisem jazyka Objective-C a posouzením účelnosti jeho zařazení do výuky. V rámci úvodu práce jsem se pokusil vysvětlit, proč si myslím, že má nyní smysl se jazykem Objective-C zaobírat. Poukázal jsem na vzrůstající míru využití telefonů s operačním systémem, mezi kterými se výrazně prosadil přístroj iPhone. Přestože operační systém iPhone OS obsazuje ve statistikách mobilních systémů „až“ třetí pozici (po Symbianu a RIM), mediálnímu prostoru dominuje, což společně s vyřešeným způsobem distribuce aplikací činí vývoj pro iPhone lákavým. Primárním jazykem pro tvorbu „iPhone aplikací“ je právě Objective-C. První polovinu diplomové práce jsem věnoval popisu vlastností jazyka Objective-C, který je objektovou nadstavbou jazyka C. Jedná se o kompilovaný jazyk, umožňující dynamické i statické typování (lze si vybrat, zda bude překladač provádět kontrolu typů). Vzhledem ke zpětné kompatibilitě s jazykem C se nejedná o čistě objektový jazyk – je možné například používat základní datové typy nebo definovat funkce mimo objekty. Veškeré tzv. „neobjektové“ vlastnosti jsou zcela totožné s vlastnostmi jazyka C, proto lze první kapitoly brát i jako úvod do programování v tomto jazyku. Kromě základních jazykových konstrukcí, které jsou podobné v mnoha ostatních jazycích (definice funkcí, cykly, podmínky, …), jsem vysvětlil také práci s ukazateli a hlavičkovými soubory, které se v moderních jazycích již příliš nevyskytují (v Objective-C však ano). Část syntaktických pravidel jazyka Objective-C, která se týká práce s objekty, vychází ze syntaxe jazyka Smalltalk. Nejvýznamnější vlastností, kterou má Objective-C společnou s jazykem Smalltalk, je tzv. „posílání zpráv mezi objekty“, které nahrazuje v ostatních objektových jazycích běžnější volání metod objektů. Rozdíl mezi těmito dvěma koncepty spočívá především v tom, že zpráva je samostatnou jednotkou, kterou může příjemce například dále přeposlat na jiný objekt. Zatímco při volání metody objektu je již během překladu jasné, zda objekt danou metodu implementuje či nikoli, při zasílání zpráv není nikdy jasné, zda na zaslanou zprávu objekt odpoví, či bude zpracování zprávy delegovat na jiný objekt, nebo ji zahodí (program lze v každém případě přeložit, při zasílání zprávy, která není deklarována v rozhraní daného objektu, je vypsáno pouze příslušné varování). Stránka 63 z 80


Pro programování v Objective-C je k dispozici několik knihoven tříd (frameworků), z nichž nejpoužívanějšími jsou Cocoa (aplikace pro Mac OS X) a Cocoa Touch (aplikace pro iPhone OS). V rámci popisu jazyka jsem předvedl, jakým způsobem se deklarují i implementují vlastní třídy, a jak se vytváří jejich instance. Názorně jsem předvedl zasílání zpráv a jejich přeposílání (tzv. „forwarding“). Vysvětlil jsem princip a způsob definice tzv. „protokolů“, které jsou analogií k rozhraním (používaným v jazycích Java, C# nebo třeba PHP). Ze specifičtějších vlastností jazyka jsem se zaobíral tzv. „kategoriemi“, které dovolují rozšiřovat funkcionalitu libovolných objektů. Určitou variantou kategorií jsou tzv. „rozšíření“, která dovolují vytvořit více rozhraní pro jednu třídu – pouze s jejich pomocí lze definovat ekvivalent k soukromým metodám objektů. Přestože některé platformy Objective-C v současné době již podporují automatickou správu paměti (tzv. „garbage collector“), v určitých případech se může hodit umět pracovat s explicitní správou paměti (v případě vývoje aplikací pro malá přenosná zařízení typu iPhone nám v současné době ani jiná možnost nezbývá). V závěru první části jsem proto uvedl, jak se s explicitní správou paměti pracuje. Účelnost zařazení jazyka Objective-C do výuky jsem se rozhodl zhodnotit na základě 10 kritérií, jejichž výběr jsem zdůvodnil v úvodu druhé části práce. Velký prostor byl věnován souladu jazyka se zásadami objektově orientovaného programování. Objective-C umožňuje díky protokolům beze zbytku splnit zásadu programování oproti rozhraní a odstranění přímých vazeb – možností deklarace proměnné jako ukazatele na instanci objektu odpovídajícího vícero protokolům dokonce předčí některé konkurenční jazyky (např. Java). Díky kategoriím zase významně usnadňuje zamezení duplicit v kódu a nesvádí ke zneužívání dědičnosti. Největším problémem Objective-C ve vztahu k zásadám OOP je absence deklarace soukromých zpráv (metod), což ztěžuje ukrývání implementace a také použití některých návrhových vzorů (např. Jedináček, Knihovní třída,…). Přestože lze pro každou třídu definovat s pomocí tzv. „rozšíření“ vícero rozhraní (např. jedno rozhraní používané pouze pro danou třídu a její potomky, deklarující veškeré zprávy, a druhé rozhraní obsahující pouze deklaraci „veřejných“ zpráv), nelze zcela zakázat například volání konstruktoru třídy a vytvoření instance, která nemá smysl.

Stránka 64 z 80


Naopak implementace jiných návrhových vzorů může být v Objective-C snazší – jako příklad jsem uvedl vzor Dekorátor (s využitím kategorií) nebo Pozorovatel (pro tento vzor existuje podpora přímo v Cocoa frameworku v podobě notifikačního centra). Součástí druhé části této práce je rovněž srovnání jazyka Objective-C s ostatními běžně používanými jazyky – odlišnosti lze spatřovat v možnosti volby dynamického a statického typování, tzv. „forwardingu“ (přeposílání zpráv), již zmíněné nepodpoře deklarace soukromých metod (zpráv) a nemožnosti deklarace proměnných vázaných na třídu (statické proměnné třídy). Zmínil jsem též absenci jmenných prostorů v Objective-C, která jej znevýhodňuje oproti Javě nebo třeba C#. Z hlediska náročnosti syntaxe jsem zmínil nutnost práce s hlavičkovými soubory a poněkud neobvyklý princip zasílání zpráv mezi objekty. Naopak tzv. „neobjektová“ část syntaxe jazyka je velmi podobná s ostatními jazyky, které vycházejí ze syntaxe jazyka C (Java, C#, PHP, Javascript,…). Při hodnocení budoucnosti jazyka Objective-C jsem dospěl k závěru, že vzhledem k rostoucím prodejům přístrojů značky Apple a neustálému (byť pomalému) zvyšování tržního podílu Mac OS X má jazyk poměrně dobrou perspektivu. Současný nízký podíl Mac OS X (celosvětově kolem 5%, v ČR kolem 1-2%) však v tomto momentě představuje vysokou vstupní bariéru pro programování v Objective-C – pokročilé vývojové prostředí Xcode (které jsem v práci rovněž stručně představil) je dostupné pouze pro počítače Macintosh, „opensourcová“ alternativa v podobě projektu GNUstep (vývojové prostředí a kompilátory pro Windows, Linux, Mac a další systémy) je pro výuku příliš málo atraktivní. V rámci práce jsem provedl analýzu poptávky po programátorech Objective-C v ČR. Bohužel jsem musel konstatovat, že zájem o tyto programátory není velký. Ti, kteří (minimálně v ČR) v Objective-C programují, jsou obvykle osobami pracujícími na živnostenský list. V Objective-C nevznikají velké informační systémy, ale spíše drobné aplikace, pro jejichž tvorbu není zapotřebí vytvářet větší pracovní týmy. Pro tyto aplikace je také nejvhodnější distribuce přes portál App Store. Posledním kritériem vhodnosti zařazení jazyka Objective-C do výuky byl zájem ze strany studentů VŠE, který jsem zjišťoval prostřednictvím online průzkumu. Přestože ve tvorbě aplikací pro iPhone studenti vidí možnost relativně snadného výdělku (z nabízených variant obsadil vývoj aplikací pro iPhone nejlepší hodnocení), většina studentů se tvorbou těchto Stránka 65 z 80


aplikací nechce zabývat. Zájem o výuku jazyka Objective-C je pouze nepatrný, velmi pravděpodobně by se nepodařilo realizovat více než jeden kurz (+- 15 studentů) za rok. Vzhledem k nízkému zájmu ze strany studentů VŠE, zanedbatelné poptávce po programátorech Objective-C na trhu práce v ČR a nutnosti vybavit učebnu počítači Macintosh jsem zařazení Objective-C do výuky nedoporučil. Objective-C jsem nicméně vyhodnotil jako jazyk, který je vhodný pro individuální programátory, kteří mají dostatek nápadů na tvorbu vlastních aplikací. Tito lidé se obvykle nepotřebují jazyk učit na vysoké škole – jsou dostatečně vnitřně motivováni k tomu, aby se jazyk naučili sami, za pomoci dostupné literatury.

4.2 ZHODNOCENÍ MÍRY NAPLNĚNÍ CÍLŮ A NÁMĚTY NA ROZŠÍŘENÍ PRÁCE V první části této diplomové práce jsem poskytl čtenářům výklad syntaxe jazyku Objective-C v rozsahu, který jim dovolí vytvářet jednodušší aplikace. Jelikož jsem však až na výjimky důsledně abstrahoval od popisu tříd z knihoven Cocoa a Cocoa Touch (z důvodu omezeného rozsahu této diplomové práce a jejímu zaměření primárně na syntaxi jazyka), nelze tuto práci považovat za dostatečný návod na tvorbu plnohodnotných aplikací. Domnívám se, že popis každé z knihoven Cocoa a Cocoa Touch by sám o sobě stačil minimálně na napsání samostatné bakalářské práce, v rámci které by bylo vhodné vytvořit i nějakou komplexnější ukázku aplikace. V rámci popisu jazyka se mi nepodařilo uvést ukázku práce s výjimkami (resp. jejich zpracováním, které je však velmi podobné např. zpracování výjimek v jazyku Java nebo PHP) a práci s více vlákny aplikace. Věřím však, že po přečtení této práce nebude mít čtenář pochopit dokumentaci k třídám NSException a NSThread, které mají tyto problematiky primárně na starosti (tyto třídy nalezneme v rámci knihoven Cocoa i Cocoa Touch)32. Ve druhé části této diplomové práce jsem definoval (na základě svých dosavadních zkušeností a znalostí) 10 kritérií, podle kterých jsem se rozhodl zhodnotit účelnost jazyka. Tato kritéria by měla být aplikovatelná na libovolný objektově orientovaný jazyk.

32

Na dokumentaci ke knihovně Cocoa nebo Cocoa Touch budou závislí též ti, kteří budou chtít po přečtení

práce začít programovat vlastní aplikace – samozřejmě pokud si nevyberou některý z jiných zdrojů doporučených v kapitole 3.7.

Stránka 66 z 80


U každého kritéria jsem se pokusil uvést důvody, proč si myslím, že by mělo do rozhodování o účelnosti zařazení jazyka do výuky vstoupit, a následně jsem podle těchto kritérií jazyk postupně hodnotil. Údaje pro hodnocení jazyka jsem sbíral převážně literární rešerší, pro hodnocení míry zájmu o studium Objective-C ze strany studentů jsem využil online dotazník. Přestože lze pro hodnocení účelnosti zařazení jazyka Objective-C jen těžko určit nějaká objektivní a zejména (sou)měřitelná kritéria, domnívám se, že se mi podařilo určit kritéria, která dávají smysl a která dostatečně podporují mé konečné rozhodnutí o vhodné formě výuky Objective-C.

Stránka 67 z 80


5 TERMINOLOGICKÝ SLOVNÍK Termín

Zkratka

Atribut

Význam [zdroj] V jazyku Objective-C představuje atribut instanční proměnnou (definovanou pomocí direktivy @property), která je obvykle veřejně přístupná. K hodnotám atributů se přistupuje prostřednictvím přístupových metod, které mohou být buď definovány automaticky pomocí direktivy @syntesize, nebo definovány uživatelem. Přístupové metody jsou automaticky volány také při přistupování k hodnotám atributů pomocí tzv. tečkové notace. [autor]

Automatická správa

Automatická správa paměti zajišťuje automatické

paměti

odstraňování nepoužívaných instancí tříd (nebo obecně proměnných) z paměti. U každé proměnné eviduje počet odkazů (resp. ukazatelů), a v případě, že na proměnnou již nikde žádný odkaz neexistuje, proměnnou odstraní. [autor]

Cocoa

Aplikační programové rozhraní používané v rámci operačního systému Mac OS X, které programátorům mj. zpřístupňuje knihovny tříd a funkcí. [autor]

Dynamicky typovaný

Jazyk, ve kterém dochází ke kontrole typů objektů až za běhu

jazyk

programu. [autor]

Framework

Sada spolupracujících tříd, které vytváří znovupoužitelný návrh pro různé aplikace. [52]

Garbage collector Hlavičkový soubor

GC

Viz automatická správa paměti. Hlavičkový soubor slouží k uchovávání deklarací proměnných, tříd, funkcí a dalších prvků jazyka. [autor]

Jmenné prostory

Jmenné prostory slouží k uspořádání názvů tříd do hierarchické struktury na základě určitých kritérií (např. podobné funkcionality). Každou třídu jednoznačně identifikuje její název a příslušnost k určitému jmennému Stránka 68 z 80


Termín

Zkratka

Význam [zdroj] prostoru – s pomocí jmenných prostorů tak lze odlišit dvě různé třídy se stejným lokálním názvem. [autor]

Knihovna tříd

Viz Framework

Kompilátor

Nástroj pro překlad zdrojového kódu napsaného v jazyce vyšší úrovně do strojového kódu konkrétního typu procesoru. [autor]

Odvozené datové typy

Druh proměnných, které jsou složeny z více základních datových typů. [53]

Pole

Sada proměnných stejného datového typu. [15]

Staticky typovaný

Jazyk, ve kterém dochází ke kontrole typů objektů během

jazyk

překladu programu. [autor]

Struktura

Sada proměnných různého datového typu. [16]

Tečková notace

V jazyku Objective-C se jedná o přístup k hodnotám atributů. Chceme-li přečíst nebo nastavit hodnotu atributu určitého objektu, zapíšeme za odkaz na objekt tečku a název atributu – dále s hodnotou atributu pracujeme stejně jako kdybychom pracovali s lokální proměnnou. [autor]

Ukazatel

Odvozený datový typ, který v sobě uchovává odkaz na určité paměťové místo, na kterém je uložena hodnota proměnné určitého typu. [15]

Základní datové typy

Druh proměnných, které nemají žádnou vnitřní strukturu. [53]

Zpráva

Jednotka komunikace, kterou si mezi sebou posílají objekty, a která může a nemusí mít nějaké argumenty a návratovou hodnotu. [8]

Stránka 69 z 80


6 REJSTŘÍK #

Core Data, 48, 51

Interface Builder, 48, 51 invokeWithTarget:, 39

D

#define, 46 #import, 27

isKindOfClass:, 38

dekorátor, 57

#include, 23, 27

isSubclassOfClass:, 38

description, 37

@

isEqual:, 37

doesNotRecognizeSelector:, 38

J

dynamická alokace paměti, 17 @private, 29

dynamicky typovaný jazyk, 25

@property, 30

jedináček, 57 jmenné prostory, 47

E

@protected, 29

K

@protocol, 35 explicitní správa paměti, 39

@public, 29

extern, 19, 22

@selector, 36

knihovní třída, 56

@synthesize, 30

A

kategorie, 32, 46

F

kompilátor, 22

false, 21 forwarding, 27, 38, 46

alloc, 36 App Store, 12, 59

komentář, 18

forwardInvocation:, 38

kompilovaný jazyk, 17 konstruktor, 36

funkce, 21

atribut, 30 automatická alokace paměti, 17

M G

autorelease, 39

Garbage collector, 39

B

Mac OS X, 12, 16, 44 main (funkce), 21

GNUstep, 16, 17, 43

N

goto, 22

bool, 27

NDA, 53

Brad Cox, 15

H C

C (programovací jazyk), 17 class, 37

nil, 28

halda, 17

nízkoúrovňový jazyk, 17

hash, 37 hlavičkový soubor, 23, 27, 32

Class, 28, 45

I

Cocoa, 17, 28

NeXTstep, 16

NO, 27 NSArray, 28 NSConstantString, 28 NSCountedSet, 28

Cocoa Touch, 17, 28

id, 28, 45

NSDictionary, 28

Cocotron, 17, 28

implementace, 29

NSError, 28

code completion, 50

init, 36

NSException, 28

conformsToProtocol:, 38

instancesRespondToSelector:, 38

NSInteger, 28

const, 21

instanční proměnná, 29

Stránka 70 z 80


NSInternalInconsistencyException , 56

proměnná, 18

T

protokol, 35, 46, 54

NSInvalidArgumentsException, 38

přeposílání zpráv, 38

true, 21

NSInvocation, 38

R

NSManagedObject, 51 NSMutableString, 28 NSNotificationCenter, 58 NSNumber, 28 NSObject, 28, 37 NSString, 28

Tom Love, 15

U reflexe, 46 release, 39

ukazatel, 18, 20, 28

respondsToSelector:, 38

ukrývání implementace, 55

retain, 39

V

rozhraní, 29

null, 28

rozšíření, 34

O odkaz, 27

vstupní bariéry, 43

S selektor, 36

OOP, 54

self, 31

OPENstep, 16

X Xcode (IDE), 43, 48 xib, 51

Smalltalk, 15, 24

P

static, 19, 46, 56

Y

statická alokace paměti, 17

pole, 20

Steve Jobs, 16

pozorovatel, 58

struct, 21

privátní metody, 46

struktura, 21, 23

procedurální jazyk, 17

super, 31

programování oproti rozhraní, 54

superclass, 37

ProjectCenter (IDE), 43, 48

Stránka 71 z 80

YES, 27

Z zpráva, 25, 30


7 BIBLIOGRAFIE 1. Krasek, Jáchym. Gartner: Prodeje chytrých telefonů ve 2. čtvrtletí stoupaly. [Online] [Citace: 15. 1 2010.] http://channelworld.cz/spotrebni-elektronika/gartner-prodeje-chytrych-telefonuve-2-ctvrtleti-stoupaly-strme-nahoru-908. 2. Kocourek, Jiří. Gartner: trh mobilů v roce 2010 poroste o 9 %. [Online] [Citace: 15. 1 2010.] http://www.itbiz.cz/gartner-prodej-telefony-2010. 3. Mason, Sam a Korolev, Elise. Native and Java ME Development on Symbian OS. [Online] 2008. [Citace: 12. 4 2010.] http://whitepapers.zdnet.com/abstract.aspx?docid=1680585. 4. Ziegler, Chris. Apple's iPhone lockdown: apps must be written in one of three languages, Adobe in the hurt locker. [Online] 2010. [Citace: 12. 4 2010.] http://www.engadget.com/2010/04/08/apples-iphone-lockdown-apps-must-be-written-inone-of-three-la/. 5. Anderson, Tim. No native code development on Windows Phone 7 says Microsoft – so what about Flash? [Online] [Citace: 12. 4 2010.] http://www.itwriting.com/blog/2361-no-nativecode-on-windows-phone-7-says-microsoft-so-what-about-flash.html. 6. Noska, Martin. iPhone: Počet aplikací ke stažení z AppStore přesáhl 100 000. [Online] [Citace: 16. 1 2010.] http://computerworld.cz/aktuality/iphone-pocet-aplikaci-ke-stazeni-z-appstorepresahl-100-000-5076. 7. TIOBE Programming Community Index for January 2010. [Online] [Citace: 16. 1 2010.] http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html. 8. Čada, Ondřej. Cocoa – úvod do programování počítačů Apple. Praha : Grada Publishing, a. s., 2009. ISBN 978-80-247-2778-3. 9. Objective C – History. [Online] [Citace: 16. 1 2010.] http://www.experiencefestival.com/a/Objective-C_-_History/id/1812747. 10. The history od Objective-C. [Online] [Citace: 16. 1 2010.] http://www.techotopia.com/index.php/The_History_of_Objective-C. 11. A Quick Objective-C 2.0 Tutorial. [Online] [Citace: 17. 1 2010.] http://theocacao.com/document.page/510. Stránka 72 z 80


12. Gnustep – oficiální stránka. [Online] http://gnustep.org/. 13. Huss, Eric. The C Library Reference Guide. [Online] 1997. [Citace: 19. 1 2010.] http://www.acm.uiuc.edu/webmonkeys/book/c_guide/index.html. 14. Šaloun, Petr. Programování v jazyce C (kap. 9. Dynamické dative struktury). [Online] 1996. [Citace: 19. 1 2010.] http://docs.linux.cz/programming/c/c_saloun/kap09.htm. 15. Němec, Jan. C/C++ (9) - Pole. [Online] [Citace: 1. 5 2010.] http://www.linuxsoft.cz/article.php?id_article=560. 16. —. C/C++ (22) - Stuktury. [Online] [Citace: 2. 5 2010.] http://www.linuxsoft.cz/article.php?id_article=859. 17. —. C/C++ (16) - Hlavičkové soubory. [Online] [Citace: 18. 4 2010.] http://www.linuxsoft.cz/article.php?id_article=704. 18. Křivánek, Pavel. Seriál Squeak: návrat do budoucnosti. [Online] 2004. [Citace: 21. 1 2010.] http://www.root.cz/serialy/squeak-navrat-do-budoucnosti/. 19. Smalltalk. [Online] [Citace: 21. 1 2010.] http://cs.wikipedia.org/wiki/Smalltalk. 20. Working with String Objects in Objective-C. [Online] [Citace: 2. 5 2010.] http://www.techotopia.com/index.php/Working_with_String_Objects_in_Objective-C. 21. What's the difference between a string constant and a string literal? [Online] [Citace: 2. 5 2010.] http://stackoverflow.com/questions/25746/whats-the-difference-between-a-stringconstant-and-a-string-literal. 22. Objective-C: Categories. [Online] 2008. [Citace: 13. 4 2010.] http://macdevelopertips.com/objective-c/objective-c-categories.html. 23. Hoffman, Kevin. Objective-C Categories vs C# 3.5 Language Extensions. [Online] 2007. [Citace: 13. 4 2010.] http://dotnetaddict.dotnetdevelopersjournal.com/orcas_langextend_vs_categories.htm. 24. Messaging. [Online] [Citace: 2. 5 2010.] http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/ObjCRuntimeGuid e/Articles/ocrtHowMessagingWorks.html#//apple_ref/doc/uid/TP40008048-CH104.

Stránka 73 z 80


25. Forwarding. [Online] [Citace: 2. 5 2010.] http://developer.apple.com/Mac/library/documentation/Cocoa/Conceptual/ObjCRuntimeGuid e/Articles/ocrtForwarding.html. 26. Stevenson, Scott. Learn Objective-C. [Online] 2008. [Citace: 14. 4 2010.] http://cocoadevcentral.com/d/learn_objectivec/. 27. Klimánek, Oldřich. Microsoft dále ztrácí uživatele. Podíl Windows klesá. [Online] 2009. [Citace: 14. 4 2010.] http://www.dsl.cz/clanek/1313-microsoft-dale-ztraci-uzivatele-podilwindows-klesa. 28. Brůcha, Filip. Windows 7 svým podílem již pokořily Mac OS X. 2009. [Online] [Citace: 14. 4 2010.] http://computerworld.cz/software/windows-7-svym-podilem-jiz-pokorily-mac-os-x5207. 29. Globální statistiky Toplist.cz. [Online] [Citace: 14. 4 2010.] http://www.toplist.cz/global.html. 30. DiPasquale, Toby. Python up, Ruby down: If that runtime don't work, then its bound to drizzown. [Online] 2007. [Citace: 14. 4 2010.] http://cbcg.net/2007/04/22/python-up-rubydown-if-that-runtime-dont-work-then-its-bound-to-drizzown.html. 31. The Ruby Programming Language (statistika popularity jazyka). [Online] [Citace: 18. 4 2010.] http://www.tiobe.com/index.php/paperinfo/tpci/Ruby.html. 32. AMD, Apple a VMware zveřejnily hospodářské výsledky. Proč se jim dařilo? [Online] 2010. [Citace: 18. 4 2010.] http://channelworld.cz/hardware/amd-apple-a-vmware-zverejnilyhospodarske-vysledky-proc-se-jim-darilo-1433. 33. Top Operating System Share Trend. [Online] [Citace: 18. 4 2010.] http://www.netmarketshare.com/os-marketshare.aspx?qprid=9&qptimeframe=M&qpsp=111&qpnp=25. 34. Soudní válka s Applem kvůli porušení patentů pokračuje novými žalobami Nokie. [Online] 2010. [Citace: 18. 4 2010.] http://digiweb.ihned.cz/c1-39728450-soudni-valka-s-applem-kvuliporuseni-patentu-pokracuje-novymi-zalobami-nokie. 35. Kodak chce, aby soud v USA zakázal prodej iPhonů. [Online] 2010. [Citace: 18. 4 2010.] http://hn.ihned.cz/c1-39917620-kodak-chce-aby-soud-v-usa-zakazal-prodej-iphonu. Stránka 74 z 80


36. Čížek, Jakub. Microsoft, Apple, Google a jejich skutečné bohatství. [Online] 2010. [Citace: 19. č 2010.] http://www.zive.cz/clanky/microsoft-apple-google-a-jejich-skutecne-bohatstvi/sc-3-a151902/default.aspx. 37. Ruby versus Smalltalk versus Objective-C versus C++ versus Java versus Python versus CLOS versus Perl5 versus XOTcl. [Online] [Citace: 19. 4 2010.] http://www.approximity.com/ruby/Comparison_rb_st_m_java.html. 38. Objective-C Runtime Reference. [Online] [Citace: 19. 4 2010.] http://developer.apple.com/mac/library/documentation/Cocoa/Reference/ObjCRuntimeRef/R eference/reference.html. 39. Extension Methods (C# Programming Guide). [Online] [Citace: 19. 4 2010.] http://msdn.microsoft.com/en-us/library/bb383977.aspx. 40. Developer Tools Technology Overview. [Online] [Citace: 25. 4 2010.] http://developer.apple.com/technologies/tools/. 41. Introduction to Core Data Programming Guide. [Online] [Citace: 25. 4 2010.] http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/CoreData/cdProgr ammingGuide.html. 42. Čada, Ondřej. Nastal čas na kakao... [Online] [Citace: 25. 4 2010.] http://www.mujmac.cz/serial179.html. 43. Pecinovský, Rudolf. Návrhové vzory. Brno : Computer Press, a. s., 2007. ISBN 978-80-2511582-4. 44. The Objective-C Programming Language: Protocols. [Online] [Citace: 26. 4 2010.] http://developer.apple.com/mac/library/documentation/cocoa/conceptual/ObjectiveC/Article s/ocProtocols.html. 45. Is it possible to make the -init method private in Objective-C? [Online] [Citace: 26. 4 2010.] http://stackoverflow.com/questions/195078/is-it-possible-to-make-the-init-method-privatein-objective-c. 46. Cocoa Utility Class. [Online] [Citace: 26. 4 2010.] http://stackoverflow.com/questions/958864/cocoa-utility-class.

Stránka 75 z 80


47. What does your Objective-C singleton look like? [Online] [Citace: 26. 4 2010.] http://stackoverflow.com/questions/145154/what-does-your-objective-c-singleton-look-like. 48. Key-Value Observing Programming Guide. [Online] [Citace: 26. 4 2010.] http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/KeyValueObservi ng/Concepts/KVOBasics.html#//apple_ref/doc/uid/20002252-BAJEAIEE. 49. NSNotificationCenter Class Reference. [Online] [Citace: 26. 4 2010.] http://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classe s/NSNotificationCenter_Class/Reference/Reference.html. 50. Vidlák, Milan. Vynalézám pro iPhone. [Online] 2009. [Citace: 26. 4 2010.] http://www.lidovky.cz/vynalezam-pro-iphone-05k/ln_noviny.asp?c=A091127_100007_ln_noviny_sko&klic=234379&mes=091127_1. 51. Demčák, Marek. Chtěli byste umět programovat aplikace pro iPhone nebo Macintosh? (výsledky průzkumu). [Online] 2010. [Citace: 1. 5 2010.] http://www.vyplnto.cz/realizovanepruzkumy/objective-c/. 52. http://mail.serc.iisc.ernet.in/ComputingFacilities/systems/cluster/vac7.0/html/glossary/czgf.htm. [Online] [Citace: 2. 5 2010.] http://mail.serc.iisc.ernet.in/ComputingFacilities/systems/cluster/vac7.0/html/glossary/czgf.htm. 53. Datový typ. [Online] [Citace: 2. 5 2010.] http://cs.wikipedia.org/wiki/Datový_typ#Jednoduch.C3.A9_datov.C3.A9_typy. 54. Developing with Core Data. [Online] [Citace: 25. 4 2010.] http://developer.apple.com/macosx/coredata.html.

Stránka 76 z 80


PŘÍLOHA 1: VÝTAH Z VÝSLEDKŮ INTERNETOVÉHO PRŮZKUMU 1.) Které z níže uvedených technologií (programovacích jazyků) znáte natolik dobře, že byste se je nebál(a) alespoň zmínit ve svém životopise? (polouzavřená otázka s možností více odpovědí) Odpověď

Počet

%

PHP

18

62%

C# / .NET

12

41%

J2SE, Java SE

12

41%

J2EE, Java EE

5

17%

J2ME, Java ME

3

10%

2.) Na čem si myslíte, že se bude dát v nejbližších 5 letech nejsnáze vydělat (výhodný poměr výnosů a vynaloženého úsilí + nákladů, se zohledněním konkurence)? Ohodnoťte prosím jednotlivé oblasti (2 = nejsnáze vydělat, -2 = nelze vydělat vůbec); pokud nevíte, zvolte odpověď 0. Odpověď

Průměr

Tvorba firemních internetových stránek a webových aplikací (do cca 500 člověkohodin práce)

0,56

Vývoj velkých informačních systémů

0,59

Tvorba aplikací pro Facebook

0,44

Vývoj desktopových aplikací pro MS Windows

-0,13

Vývoj desktopových aplikací pro Linux

-0,97

Vývoj desktopových aplikací pro Mac OS X (Appstore)

-0,06

Vývoj mobilních aplikací pro iPhone, iPad, iPod,... (Appstore)

1,03

Vývoj mobilních aplikací pro Android (Android Market)

0,88

Vývoj mobilních aplikací v Java ME

0,13

Vývoj mobilních aplikací pro Windows Phone (Windows Marketplace)

0,31

Stránka 77 z 80


3.) Uvažoval(a) jste o vývoji aplikací pro iPhone, iPad, iPod nebo počítače Macintosh? V případě odpovědi “ne, vývoj podobných aplikací mě nezajímá” byli respondenti přesměrováni na otázku č. 7. Odpověď

Počet

%

ne, vývoj podobných aplikací mě nezajímá, orientuji se zcela jiným směrem

19

59%

uvažoval(a), ale spíše se budu orientovat jiným směrem

6

19%

ano - rád(a) bych se naučil(a) programovat v Objective-C, ale zatím na to nebyl čas

5

16%

ano - zatím se to však pouze učím

2

6%

4.) Jaké vidíte největší přednosti vývoje aplikací pro iPhone, iPad, iPod, počítače Macintosh? (výběr více možností) Odpověď

Počet

%

vyřešený obchodní model - prodej aplikací přes Appstore (70% vývojářům, 30% Applu)

11

85%

nízká úroveň pirátství

6

46%

uzavřenost a nízká variabilita koncových zařízení (snadné ladění, kompatibilita)

6

46%

5.) Jaké vidíte největší nevýhody vývoje aplikací pro iPhone, iPad, iPod, počítače Macintosh? (výběr více možností) Odpověď

Počet

%

nutnost vlastnit počítač Macintosh vývojové prostředí pro ostatní platformy neexistuje

8

62%

závislost na Apple a jeho rozhodnutí - mám problém s NDA, nelíbí se mi schvalování aplikací,...

5

38%

nízký tržní podíl Mac OS X / iPhone OS X

4

31%

Stránka 78 z 80


6.) Pokud by byl na VŠE otevřen kurz programování v jazyce Objective-C s využitím knihoven Cocoa / Cocoa Touch: Odpověď

Počet

%

možná bych si tento kurz zapsal(a)

7

54%

určitě bych si tento kurz rád zapsal(a)

5

38%

nezapsal(a) bych si tento kurz

1

8%

Odpověď

Počet

%

Ne, a neplánuji si jej koupit

25

78%

Ne, ale uvažuji o jeho koupi

4

13%

Ano

3

9%

Odpověď

Počet

%

iPod

7

89%

iPhone

4

56%

Odpověď

Počet

%

FIS

25

78%

Již jsem dostudoval

4

13%

FPH

2

6%

FNH

1

3%

7.) Vlastníte MacBook / MacBook Pro?

8.) Vlastníte jiné produkty Apple? (výběr více možností)

9.) Jakou fakultu studujete?

Stránka 79 z 80


10.) Jaký je Váš momentální (převažující) status? Odpověď

Počet

%

Studuji (navazující) magisterský studijní program

18

56%

Studuji bakalářský studijní program

10

31%

Již jsem dostudoval(a)

4

13%

Odpověď

Počet

%

Muž

28

87%

Žena

4

13%

11.) Jaké je Vaše pohlaví?

V této příloze byly uvedeny jen ty nejzajímavější výsledky průzkumu, kompletní neočištěné výsledky lze nalézt na adrese http://www.vyplnto.cz/realizovane-pruzkumy/objective-c/.

Stránka 80 z 80

Vysoká škola ekonomická v Praze

Recommend Documents