V minulΘm pokraΦovßnφ tohoto serißlu jsme se seznßmili s pojmy objekt, zprßva a t°φda. Tentokrßt nßÜ krßtk² p°ehled zßklad∙ objektovΘho programovßnφ dokonΦφme.
Jak jsme si minule °ekli, proto₧e t°φda znß vÜechny informace o objektech, je₧ reprezentuje, je p°irozenΘ, aby sama tyto objekty vytvß°ela. Je tu vÜak dalÜφ "novß v∞c" û nem∞li bychom podobn∞, jako jsme p°idali do jazyka objekt (a operace nad nφm, tj. zasφlßnφ zprßvy), p°idat do jazyka t°φdu a n∞jakΘ operace nad nφ? Samoz°ejm∞, bylo by to mo₧nΘ a nap°φklad C++ to tak d∞lß. Existuje vÜak daleko elegantn∞jÜφ °eÜenφ.
Uv∞domme si, ₧e objekty jsme zavedli natolik obecn∞, ₧e mohou d∞lat prakticky cokoli û proΦ by tedy t°φdy samy nemohly b²t objekty jako ka₧dΘ jinΘ? Pro komunikaci s t°φdami pak m∙₧eme pou₧φt naprosto standardnφ mechanismus zprßv. Jen op∞t pro lepÜφ Φitelnost budeme pro t°φdy pou₧φvat namφsto typu id typ Class a mφsto hodnoty nil hodnotu Nil. Znovu ovÜem p°ipome≥me, ₧e to d∞lßme jen pro sebe, aby se nßm lΘpe Φetly zdrojovΘ texty. P°ekladaΦi to je jedno a vÜe by fungovalo stejn∞ dob°e, i kdybychom pou₧φvali kdekoli kter²koli z trojice typ∙ (vΦetn∞ void*) a hodnot (vΦetn∞ NULL). P°ece jen ale jazyk o n∞co rozÜφ°it musφme: o prost°edky pro tvorbu t°φd a pro popis toho, jak budou objekty zpracovßvat zprßvy.
Poznamenejme, ₧e t°φdy jsou standardnφmi objekty a₧ na jednu v²jimku: samy ji₧ nemajφ ₧ßdnou "t°φdu t°φd" Φili metat°φdu. Bylo by mo₧nΘ ji zavΘst a n∞kterΘ objektovΘ systΘmy to skuteΦn∞ d∞lajφ. PraktickΘ v²hody jsou vÜak minimßlnφ.
Rozhranφ, properties, implementace a metody
Popis t°φdy mß dv∞ jasn∞ odd∞lenΘ Φßsti: rozhranφ, kterΘ obsahuje informace o tom, jak se s jejφmi objekty pracuje (a kv∙li d∞diΦnosti i n∞co mßlo o jejich vnit°nφ struktu°e), a implementaci, je₧ urΦuje, jak objekty budou zpracovßvat zprßvy. Ve zdrojov²ch textech pro jejich popis slou₧φ direktivy @interface, @implementation a @end.
NejjednoduÜÜφ rozhranφ prost∞ urΦφ jmΘno nov∞ vytvß°enΘ t°φdy. Pokud vyu₧φvßme d∞diΦnosti (co₧ je v praxi tΘm∞° v₧dy), zapφÜeme za jmΘno novΘ t°φdy dvojteΦku a za ni jmΘno ji₧ existujφcφ t°φdy, od nφ₧ chceme novou d∞d∞nφm odvodit (budeme jφ °φkat nadt°φda):
@interface MyClass:NSObject @end
Velice Φasto by se nßm hodilo, aby ka₧d² objekt t°φdy obsahoval n∞jakΘ vlastnφ prom∞nnΘ (properties), je₧ tak Φi onak definujφ jeho obsah: objekt kniha by asi m∞l prom∞nnΘ autor, nßzev, vydavatel a podobn∞. VÜechna objektovß prost°edφ proto umo₧≥ujφ v rßmci t°φdy takovΘ prom∞nnΘ definovat. Je celkem z°ejmΘ, ₧e se obsah t∞chto prom∞nn²ch stane souΦßstφ toho "n∞Φeho v pam∞ti", co û jak vφme z p°edeÜlΘho dφlu û reprezentuje objekt. Ve zdrojovΘm textu m∙₧eme takovΘ prom∞nnΘ definovat ve slo₧en²ch zßvorkßch hned za jmΘnem t°φdy a nadt°φdy:
@interface MyClass2:NSObject
{ // ka₧d² objekt t°φdy MyClass2 bude mφt vlastnφ...
int i,j; // ...dv∞ prom∞nnΘ typu int...
double d; // ...jednu typu double...
id o1,o2,o3; // ...a t°i (odkazy na) objekty.
}
@end
(P°ipome≥me, ₧e id je vlastn∞ ukazatel û nap°. mezi prom∞nnou i a o2 je tedy urΦit² rozdφl, z°ejm² zkuÜen²m programßtor∙m v C: Φφslo i le₧φ skuteΦn∞ uvnit° objektu t°φdy MyClass, zatφmco objekt o2 je n∞kde venku û uvnit° objektu t°φdy MyClass je jen odkaz na n∞j.)
Pokud m∞la n∞jakΘ vlastnφ prom∞nnΘ nadt°φda, budou v definovanΘ t°φd∞ k dispozici takΘ. Jin²mi slovy, vlastnφ prom∞nnΘ kterΘkoli t°φdy zahrnujφ nejen ty, je₧ jsou deklarovßny v jejφm rozhranφ, ale takΘ vÜechny deklarovanΘ v jejφ nadt°φd∞, v nadt°φd∞ nadt°φdy a tak dßle a₧ po "nejvyÜÜφ" t°φdu, kterß ji₧ nadt°φdu nemß.
PeΦliv² Φtenß° odstavce, v n∞m₧ jsem popisoval zprßvy, se mo₧nß zarazil: zprßva intValue vracela Φφslo typu int, zprßva doubleValue vracela Φφslo typu double; t°i argumenty zprßvy drawCircleWithCentreX:Y:radius:title: byly typu int a Φtvrt² char* û jak to mß p°ekladaΦ v∞d∞t? Snadno: poslednφ standardnφ souΦßstφ rozhranφ je toti₧ deklarace zprßv a jejich typ∙. Syntaxe je jednoduchß: p°ed ka₧dou zprßvu napφÜeme znak '-', argumenty oznaΦφme identifikßtory a p°ed n∞ i p°ed celou zprßvu v zßvorkßch napφÜeme typy:
Je d∙le₧itΘ mφt na pam∞ti, ₧e jde jen o informaci pro p°ekladaΦ! Za b∞hu pak dφky pozdnφ vazb∞ m∙₧e libovoln² objekt dostat libovolnou zprßvu bez ohledu na to, jestli je zapsanß v jeho rozhranφ nebo ne. M∙₧eme mimochodem pou₧φvat i zprßvy, je₧ nejsou zapsanΘ v ₧ßdnΘm rozhranφ: jejich nßvratovΘ hodnoty i jejich p°φpadnΘ argumenty pak budou typu id. TotΘ₧ platφ pro nßvratovΘ hodnoty nebo argumenty, u kter²ch ₧ßdn² typ v zßvorce neuvedeme.
Implementace z hlediska programßtora vlastn∞ nenφ nic jinΘho ne₧ naprogramovßnφ n∞kolika metod. Metoda je v zßsad∞ standardnφ "cΘΦkovß" funkce û mφsto hlaviΦky funkce vÜak pou₧ijeme hlaviΦku, kterß p°esn∞ odpovφdß deklaraci zprßvy v rozhranφ (jen nenφ zakonΦena st°ednφkem). P°ekladaΦ pak ud∞lß dv∞ v∞ci: (a) p°elo₧φ k≤d metody, (b) umφstφ do t°φdy informaci, ₧e dostane-li kter²koli jejφ objekt zprßvu odpovφdajφcφ hlaviΦce metody, bude vyvolßna prßv∞ tato metoda. Na rozdφl od deklaracφ v rozhranφ tedy metody v implementaci skuteΦn∞ popisujφ chovßnφ objektu: dostane-li objekt zprßvu, jφ₧ neodpovφdß ₧ßdnß z jeho metod, odmφtne ji a dojde k b∞hovΘ chyb∞ (pro ·plnost poznamenejme, ₧e jsou k dispozici prost°edky, jak programovat plnΘ dynamickΘ zpracovßnφ zprßv, tj. takovΘ, ₧e objekt m∙₧e zpracovßvat nap°φklad libovolnou zprßvu, jejφ₧ jmΘno zaΦφnß na "a" a mß sud² poΦet pφsmen; prozatφm si vÜak takov²mi v∞cmi nebudeme komplikovat ₧ivot).
@implementation MyClass3
-(int)intValue
{
return 1;
}
-(double)doubleValue
{
return 1.0;
}
-(char)charValue
{
return 'a';
}
@end
PovÜimn∞me si, ₧e metody v implementaci neodpovφdajφ p°esn∞ zprßvßm z rozhranφ. To, ₧e v implementaci je metod vφce, je naprosto b∞₧nΘ: odpovφdajφcφ zprßvy z toho Φi onoho d∙vodu nejsou souΦßstφ rozhranφ, ale objekty t°φdy MyClass3 je p°esto dokß₧ou zpracovat. OpaΦn² p°φpad (zprßva uvedenß v rozhranφ nemß metodu v implementaci) je mΘn∞ obvykl², ale takΘ mo₧n².
Uvnit° implementace metod jsou p°φstupnΘ vÜechny vlastnφ prom∞nnΘ objektu (tak₧e kdybychom nap°φklad implementovali metodu t°φdy MyClass2, mohli bychom vracet hodnotu prom∞nnΘ d p°φkazem return d;).
Nakonec je t°eba °φci, ₧e s odmφtnutφm zprßvy a b∞hovou chybou jsem malinko lhal: pokud toti₧ nenφ souΦßstφ implementace metoda pro p°ijatou zprßvu, hledß se metoda v nadt°φd∞. Nenφ-li ani tam, hledß se v jejφ nadt°φd∞, a tak dßle, dokud nenarazφme na "nejvyÜÜφ" t°φdu, kterß ji₧ nadt°φdu nemß. Teprve nenajde-li se metoda ani tam, je zprßva odmφtnuta. To pohodln∞ a automaticky zajiÜ¥uje d∞d∞nφ zprßv: jestli₧e v implementaci t°φdy NSObject byla metoda name, m∙₧eme odpovφdajφcφ zprßvu posφlat nap°φklad objekt∙m t°φdy MyClass3 bez obavy, ₧e by byla odmφtnuta.
Metody t°φd
P°ipome≥me si, ₧e t°φda sama je objektem a sama dokß₧e p°ijφmat a zpracovßvat zprßvy. Proto m∙₧eme v rozhranφ krom∞ deklarace zprßv urΦen²ch pro objekty deklarovat i zprßvy urΦenΘ pro samotnou t°φdu. Podobn∞ v implementaci m∙₧eme definovat metody, kterΘ budou vyvolßny v p°φpad∞, ₧e t°φda sama dostane zprßvu odpovφdajφcφ hlaviΦce metody. V obou p°φpadech je deklarace i definice stejnß jako minule, jen znak '-' na zaΦßtku je nahrazen znakem '+':
@interface MyClass4:NSObject
+alloc; // vrßtφ nov² objekt tΘto t°φdy
+(char*)name; // pro t°φdu
-(char*)name; // pro objekty
@end
@implementation MyClass4
+alloc { ... }
+(char*)name
{
return "T°φda MyClass4";
}
-(char*)name
{
return "Objekt MyClass4";
}
@end
Poslednφ informace, kterß nßm chybφ k tomu, abychom mohli zaΦφt opravdu programovat, je, jak se dostaneme k "objektu t°φda" z programu. To je ale prostΘ: pokud jmΘno t°φdy pou₧ijeme v hranat²ch zßvorkßch jako p°φjemce zprßvy, reprezentuje prßv∞ po₧adovan² "objekt t°φda". Tak₧e malΘ cviΦenφ pro pozornΘ Φtenß°e: je jasnΘ, co vypφÜe nßsledujφcφ funkce, je-li pou₧ita po deklaraci a definici t°φdy MyClass4?
void printout(void) {
id o=[MyClass4 alloc];
printf("%s, %s",[MyClass4 name],[o name]);
}
Samoz°ejm∞ ₧e metody t°φd se d∞dφ analogick²m zp∙sobem jako metody objekt∙: jestli₧e dostane t°φda zprßvu, pro ni₧ nenajde ve vlastnφ implementaci ₧ßdnou "plusovou" metodu, hledß metodu v implementaci svΘ nadt°φdy...
Shrnutφ
Ukßzali jsme si zßkladnφ p°φstup k objekt∙m a principy jejich pou₧φvßnφ. V rßmci p°φklad∙ jsme se p°itom seznßmili s nejd∙le₧it∞jÜφmi souΦßstmi jazyka Objective C. Ti, kdo majφ jeho p°ekladaΦ k dispozici (jako GNU C je k dispozici na libovolnΘ platform∞, od Mac OS X p°es vÜechny varianty Unixu a₧ po DOS Φi Windows), skuteΦn∞ ji₧ mohou zaΦφt programovat.
P°φÜt∞ si ukß₧eme t∞ch n∞kolik mßlo (skuteΦn∞ mßlo a pom∞rn∞ nev²znamn²ch) prvk∙ jazyka Objective C, na n∞₧ se zatφm nedostalo. Pak se u₧ zaΦneme bavit o skuteΦn²ch vlastnostech prost°edφ Cocoa: ukß₧eme si mechanismus tvorby a zßniku objekt∙ a podobn∞.
