Ez a lap egy ellenőrzött változata
| Objective-C | |
| Paradigma | többelvű: generic,objektumorientált, imperatív |
| Jellemző kiterjesztés |
|
| Megjelent | 1984 |
| Tervező | Brad Cox ésTom Love |
| Kiadó | Apple Inc. |
| Utolsó kiadás | 2.0(stabil verzió)[1] |
| Típusosság | duck, static, weak |
| Hatással volt rá | |
| Weboldal | |
AzObjective-C egy teljesenobjektumorientált kibővített változata aC programozási nyelvnek. A tervezők a C nyelvhez társították a Smalltalk stílusú üzenetközvetítést az objektumok között.A nyelv leginkább aMac OS X platform fő programozási nyelve, azon belül is aCocoa API használja. Olyan Objective-C programokat, amelyek nem használják a Cocoa könyvtárakat, GCC-vel is lefordíthatók gépi kódra.
Az1980-as években astrukturált programozás volt a legelterjedtebb programozási modell. Előnye az volt, hogy a programokat kisebb modulokra lehetett bontani, így olvashatóbbak voltak. Nagy hátránya az volt, hogy a kód újrafelhasználása szinte nem létezett, valamint a nagy programok megint csak olvashatatlanok voltak.
Hogy ezt kiküszöböljék, a XEROXPalo Alto-i kutatóközpontjában kifejlesztették aSmalltalk nyelvet, amely objektumorientált volt. A Smalltalk nagy hátránya, hogy a programot egy Virtuális gép (VM) futtatja, emiatt nagyon nagy a memóriafelhasználása és sokkal lassúbb is, mint egy natívan futó program.
Az Objective-C nyelvetBrad Cox ésTom Love fejlesztette ki az 1980-as évek elején.MikorSteve Jobs elhagyta azApple-t és megalapította aNeXT céget, megvásárolta az Objective-C licencét, ami lehetővé tette, hogy aNeXTstep operációs rendszert és minden fejlesztői alkalmazást Objective-C-ben írjanak meg. A NeXTstep ezáltal a kor legelőrehaladottabb operációs rendszere volt.
AGNU projekt1992-ben megjelentette a NeXTstep ingyenes klónját, azOpenStep operációs rendszert, amely már tartalmazott egy Objective-C fordítót és könyvtárakat, az gnuc-obj-t.
Mikor az Apple1996-ban megvásárolta a NeXT-et, a Mac OS X alapjául az OpenStep-et vették. Az OS tartalmazta az Objective-C-t és a NeXT fejlesztői rendszerét, aProject Builder-t (amelyből később azXcode lett), valamint azInterface Builder-t. Ezek a programok a mai napig a Mac OS X legfontosabb fejlesztői eszközei. ACocoa API az Objective-C osztályokra támaszkodik és a legelterjedtebb Objective-C környezet a mai napig.
A nyelv egy nagyon vékony réteg a C nyelv fölött (csakis C és nem C++ kiterjesztés). Bármilyen C program lefordítható Objective-C fordítóval.
Az Objective-C szintaxisa a Smalltalkból ered. Minden nem objektumorientált müvelet (változók, preprocesszálás, függvény deklarációk, függvényhívások) egyezik a C-ben használtakkal, míg az objektumorientált része a Smalltalk üzenetküldö mechanizmusának egyik változata.
Az Objective-C objektumorientált modellje az objektum példányok köztiüzenetküldésen alapul. Ez teljesen eltér a C++ stílusú programozási nyelvektől: itt nem az objektum egyikmetódusát hívjuk meg, hanem egy üzenetet küldünk az objektumnak és itt van a lényeges eltérés. ASimula stílusú nyelvekben a metódus neve a fordító által pontosan meg van határozva akódszegmensben, de a Smalltalkban és Objective-C-ben az üzenet csak egy név és futásidő alatt lesz meghatározva a tárbeli címe: a fogadó objektum kell feldolgozza a kapott üzenetet. Ebböl következik, hogy az üzenet küldésekor nincs típusellenőrzés, és nincs rá garancia, hogy az objektum válaszolni is fog az üzenetre. Ha nem tudja feldolgozni, akkor egyszerűen egy NULLpointert ad vissza.
C++ kód egy objektum metódusának meghívására:
foo->bar (parameter);Ugyanez Objective-C nyelvben:
[foo bar:parameter];Mindkét stílusnak megvan az előnye és hátránya. A Simula OOP-ben többszörösöröklődés és kisebb futásidő lehetséges, de alapértelmezetten nincs dinamikus kötés. Ugyanakkor kötelező (hacsak nem virtuális) minden metódusnak lennie egy implementációnak minden osztályban. A Samalltalk OOP lehetővé teszi, hogy az üzenetek ne legyenek implementálva. A Cocoa platform ezt kihasználja maximálisan: minden objektumnak a platform inicializáláskor elküldi az 'awakeFromNib:' üzenetet amint a program elindul, és erre az objektumok inicializálódhatnak. Ugyanakkor nem kötelező definiálni egy objektumot az üzenet küldésekor a kódban, dinamikus kötéssel a függöségeket aruntime oldja meg.Egy Objective-C üzenet feldolgozása legalább háromszor annyi időbe telik, mint egy virtuális C++ metódus hívás.
Az Objective-C nyelvben egy osztály interfésze és implementációja különálló kód-tömbökben kell legyen. Megegyezés szerint az interfészt egy header fájlban (általában .h kiterjesztéssel) míg az implementációt egy kód fájlban helyezzük el (általában .m kiterjesztéssel).
Az interfész általában a header fájlban van leírva. Szokványos hogy a fájl neve az osztály neve is egyúttal. Ha van egy Foo osztályunk, akkor ezt általában a Foo.h fájlba tesszük.
Példa egy interfész leírásra:
@interfaceosztálynév :ősosztálynév{// változók}+osztályMetódus1;+(típus)osztályMetódus2;+(típus)osztályMetódus3:(típus)paraméter_neve;-(típus)példányMetódus1:(param1_type)paraméter1_neve:(típus)paraméter2_neve;-(típus)példányMetódus2Paraméter1:(típus)paraméter1_neveésParaméter2:(típus)paraméter2_neve;@end
A '+' azt jelenti, hogy osztálymetódus, a '-' hogy példány metódusa. Az osztálymetódusok nem férhetnek hozzá a változókhoz.
Ugyanez a kód C++ nyelven:
classosztálynév:ősosztálynév{{// változók// Osztály (statikus) metódusokstaticvoid*osztályMetódus1();statictípusosztályMetódus2();statictípusosztályMetódus3(típusparaméter_neve);// Példány metódusokreturn_typepéldányMetódus1(típusparaméter1_neve,típusparaméter2_neve);return_typepéldányMetódus1Paraméterek(típusparaméter1_neve,típusparaméter2_neve);};
Megfigyelhetjük, hogy apéldányMetódus2Paraméter1 példázza az Objective-C egyik különlegességét, hogy a paramétereket nevesíteni lehet a függvény nevében -- ennek nincs C++ megfelelője.
A visszatérési típusok lehetnek bármilyen standard C típusok, egy pointer egy Objective-C objektumra, vagy egy specifikus objektumra mutató pointer (NSArray *, NSImage *, NSString *). Az alapértelmezett típusid, ami bármilyen Objective-C objektumot jelöl.
A metódusok paraméterei kettősponttal kezdődnek, utána következik a típus majd a neve. Sok esetben érdemes megnevezni a paramétereket:
-(void)setRange:(int)start:(int)end;-(void)importDocumentWithName:(NSString*)namewithSpecifiedPreferences:(Preferences*)prefsbeforePage:(int)insertPage
Az interfész csak a metódusok és változók neveit deklarálja; maga a kód az implementációban létezik. Általában .m kiterjesztésű fájlokba tesszük.
@implementationclassname+osztályMetódus{// implementáció}-példányMetódus{// implementáció}@end
Összehasonlítva a C++ és Objective-C közti különbségeket:
-(int)foo:(int)bar{return[selfsquare_root:bar];}
intfoo(intbar){returnsquare_root(bar);}
Itt egy példa a paraméterek nevesítésére és használatára:
-(int)changeColorToRed:(float)redgreen:(float)greenblue:(float)blue[myColorchangeColorToRed:5.0green:2.0blue:6.0];
Az Objective-C osztályokat két lépésben példányosítjuk: először lefoglaljuk a memóriát az új objektum számára majd inicializáljuk. Egy objektum addig nem működőképes, amíg mindkét lépést nem végeztük el. Ezeket általában egyetlen sorban meg lehet oldani:
MyObject*o=[[MyObjectalloc]init];
Azalloc hívás elegendő memóriát foglal le, azinit hívás felülírható, hogy a változókat inicializálhassuk:
-(id)init{self=[superinit];if(self){ivar1=value1;ivar2=value2;...}returnself;}
A protokollok lehetővé teszik a többszörös öröklődést. Két féle protokoll van: ad-hoc vagyinformális és fordító által szabályozott, vagyformális protokollok.
Egy informális protokoll egyszerüen egy metódus lista, amit az osztály implementálhat. A dokumentációban létezik, mivel a nyelvben nem jelenik meg. Ilyenek például az opcionális metódusok, ahol a metódus implementálása az osztály teljes működését befolyásolja.
A formális protokoll hasonló a Java vagy C#interface típusaihoz. Ez egy metódus lista amelyet az osztály felsorol implementálás céljából. A 2.0 Objective-C változatok előtt minden felsorolt metódust implementálni kellett, máskülönben a fordító hibát jelzett, ha az osztály nem implementálta minden metódusát a felsorolt protokollokban. Ez már nem kötelezö a 2.0 változattól kezdődően.
A leglényegesebb különbség a Java és C# nyelvekkel szemben, hogy egy osztály implementálhatja a protokollt anélkül, hogy deklarálta volna. A különbség kódon kívül nem látható.
Szintaxis:
@protocolLocking-(void)lock;-(void)unlock;@end
Ez a protokoll alock müveletet implementálja, amelyet a következö osztály felhasznál:
@interfaceOsztaly :OsOsztaly<Locking>@end
Ez azt jelenti, hogy azOsztaly implementálni fogja a két metódust a Locking protokollból, ahogyan akarja.
Főbb programozási nyelvek | |
|---|---|
