Share
Acest capitol este conceput pentru a vă ajuta să se aclimatizeze cu stilul de programare Obiectiv-C. Până la sfârșitul acestui capitol, veți putea să instanțiați obiecte, să creați și să apelați metode și să declarați proprietăți. Amintiți-vă că obiectivul este de a oferi o scurtă trecere în revistă a aspectelor majore orientate pe obiect ale obiectivului C, nu o descriere detaliată a fiecărei componente. Capitolele ulterioare completează multe dintre detaliile conceptuale omise din acest capitol.
Eșantion de cod inclus: HelloObjectiveC With Class
Haideți să ne aruncăm în apă și să creăm un nou fișier Obiectiv-C. În IDE-ul Xcode, navigați la Fişier > Nou > Fişier… sau utilizați Cmd + N comanda rapidă pentru a adăuga un fișier la proiectul dvs. Următorul dialog vă permite să selectați tipul de fișier pe care doriți să îl creați. Sub Cocoa Touch categorie, selectați Clasa obiectiv-C.
Pictograma pentru clasa Objective-C Vi se oferă posibilitatea de a specifica un nume pentru noua dvs. clasă. Să ne sunăm la clasă Persoană. Pentru clasa parentală, utilizați NSObject, care este obiectul de nivel superior de la care moștenesc toate clasele Obiectiv-C.
Definirea unei noi clase de Persoane Făcând clic Următor → va deschide un browser de fișiere și vă va cere să introduceți un grup pentru clasa ta, precum și a Ţintă. Utilizați setările implicite grup, care ar trebui să fie HelloObjectiveC. Grupurile sunt un mecanism specific Xcode pentru gruparea unor fișiere similare, dar ele nu sunt implementate la nivel de fișier. Noua noastră clasă va apărea în același director ca restul fișierelor proiectului, indiferent de grupul în care se află Obiective, asigura-te HelloObjectiveC este selectat. Acest lucru asigură că noua clasă este compilată ori de câte ori construim ținta HelloObjectiveC.
Selectarea obiectivelor de construire pentru noua clasă În cele din urmă, faceți clic pe Crea pentru a crea clasa. În navigatorul de fișiere Xcode, ar trebui să găsiți două clase noi: Person.h și Person.m. La fel ca limbajul de programare C, Obiectiv-C folosește .h ca extensie pentru fișierele antet, care conțin interfața pentru o anumită funcție sau clasă - aceasta nu trebuie confundată cu o interfață C #, care este numită protocol în obiectivul C. .m fișierul este implementarea corespunzătoare pentru Persoană clasă.
Separarea unei interfețe de clasă de la implementarea acesteia face posibilă ascunderea detaliilor implementării de la obiecte terță parte. Alte fișiere care trebuie să interacționeze cu clasa importă antet fișier - niciodată punerea în aplicare fişier. Aceasta oferă definiția abstractă necesară pentru a apela metode și a accesa proprietăți, fiind totodată independentă de implementarea clasei.
În navigatorul de proiect, selectați Person.h pentru ao deschide în panoul editorului. Ar trebui să vedeți următorul cod Obiectiv-C:
#import@ persoană interfață: NSObject @end
#import directiva include un alt fișier în contextul actual. Includerea unui fișier antet ne oferă acces la toate clasele și funcțiile pe care le definește. În acest caz, am inclus cadrul fundației. Cadrul Fundației definește construcțiile de bază ale limbajului Objective-C - lucruri precum șiruri, matrice, dicționare etc. - deci este o parte necesară a practic fiecărui program Obiectiv-C.
@interface directiva începe o interfață pentru o clasă. Urmează numele clasei, Persoană, urmată de un colon și de clasa parentală, NSObject. După cum am menționat mai devreme, NSObject este obiectul de nivel superior din Obiectiv-C. Conține metodele necesare creării și distrugerii instanțelor, împreună cu alte funcții utile împărtășite de toate obiectele.
Orice metode sau proprietăți ar fi declarate înainte de @Sfârșit directivă, dar acum, Person.h este o interfață goală. Vom schimba asta într-un minut, dar mai întâi să luăm o privire rapidă asupra fișierului de implementare, Person.m:
#import "Person.h" @implementation Person @end
Acest lucru arată foarte mult ca fișierul antet, dar include și Person.h antet. Fisiere de implementare trebuie sa includeți antetul asociat, altfel nu vor putea găsi clasa pe care încearcă să o implementeze.
De asemenea, observați că acest lucru #import directiva utilizează ghilimele în loc de paranteze unghiulare. Mărimile de cotare ar trebui să fie utilizate pentru a importa local headers, în timp ce consolele indică global antetele. Antetele globale se află în afara proiectului și sunt legate de compilator în timpul procesului de construire. Cadrele standard ale Apple sunt incluse întotdeauna în paranteze unghiulare, în timp ce fișierele de proiect trebuie importate cu ghilimele.
Și bineînțeles .m fișierul utilizează @implementation directivă în loc de @interface. Rețineți că voi nu face trebuie să specificați clasa parentală aici, deoarece această informație este deja inclusă în antet.
Apoi, vom adăuga o declarație de metodă la Persoană clasă. Amintiți-vă că acesta este un proces în două etape: mai întâi trebuie să îl adăugăm la interfață și apoi la implementare. Deci, schimbați Person.h la următoarele:
#import@interface Persoana: NSObject - (void) sayHello; @Sfârșit
După cum puteți vedea, metodele de instanță sunt declarate cu o cratimă, tipul returului în paranteze (vid), urmată de numele metodei și punct și virgulă. Acum că avem asta în interfață, treceți la Person.m pentru a defini implementarea. Rețineți că Xcode a adăugat un mic triunghi galben de lângă @implementation linia. Dacă faceți clic pe el, veți găsi un mesaj de avertizare care spune Implementarea incompletă. Aceasta este una dintre numeroasele caracteristici de depanare ale Xcode. Să rezolvăm problema prin schimbare Person.m la următoarele:
#import "Person.h" @implementation Persoană - (void) sayHello NSLog (@ "Bună ziua, numele meu este HAL."); @Sfârșit
Ca și declarația de interfață, implementarea pentru o metodă de instanță începe cu o cratimă, tipul retur și numele funcției. Implementarea însăși este definită în bretelele curbate după numele metodei, la fel ca metoda C #. Pentru spune buna, doar trimitem un mesaj către consola folosind NSLog ().
Pe măsură ce tastați, Xcode prezintă câteva opțiuni de completare automată și, de asemenea, ar fi trebuit să vă închideți brațele pentru dvs. Aceste comportamente pot fi modificate prin navigarea către Xcode > Preferințe ... în bara de meniu și făcând clic pe Editare text icoană.
Să încercăm să ne instanțiăm Persoană clasa și chemarea noilor noștri spune buna metodă. Amintiți-vă că, ca orice program C, principal() este punctul de intrare în nostru HelloObjectiveC cerere. Deci, înapoi main.m, Schimbare NSLog (@ "Bună ziua, lumea!"); la următoarele:
#import#import "Person.h" int principal (int argc, const char * argv []) @autoreleasepool Persoana * somePerson = [[Person aloca] init]; retur 0;
Persoană * SomePerson expresia declară o variabilă numită o persoană și spune compilatorului că va organiza o instanță a Persoană clasă. Asteriscul de lângă numele variabilei indică faptul că este a ac indicator, care este cea mai obișnuită metodă de referință a obiectelor în Obiectiv-C. Vom discuta indicii cu mai multe detalii pe drum.
Apoi, [[Person alocare] init] codul creează o nouă instanță a Persoană clasă. Notația cu braț pătrate poate lua unele obișnuite, dar este conceptual aceeași cu parantezele folosite pentru apelurile de metode în C # și în alte limbi în stil Simula. Proba de cod anterioară este echivalentă cu cea din C #:
Persoană somePerson = persoană nouă (); somePerson.init ();
[Person alloc] apelul alocă memoria necesară pentru noua instanță și init apelul este utilizat pentru a executa orice tip de cod de inițializare personalizat. Rețineți că nu există "metode constructor" în Obiectiv-C, așa cum există în C # sau C ++ - trebuie să apelați manual init (sau o variantă a acesteia) pentru a configura obiectul. Ca rezultat, practic orice crearea de obiecte în Obiectiv-C este un proces în două etape: alocați și apoi inițializați. Veți vedea acest model destul de des în programele Obiectiv-C.
Acum, că avem un obiect de lucru, putem să ne sunăm spune buna metodă. Rețineți că terminologia corectă în Obiectiv-C este "trimiterea unui mesaj", nu "apelarea unei metode", dar pentru scopurile noastre le putem trata ca fiind sinonime. Adăugați următoarea linie main.m:
[somePerson sayHello];
La fel ca și aloc/init metodele din exemplul anterior, invocarea metodei personalizate folosește paranteze pătrate. Din nou, aceasta este aceeași cu execuția somePerson.sayHello () în C #. Rularea programului ar trebui să fie afișată Salut, numele meu este HAL. în panoul de ieșire Xcode:
Rezultat generat de metoda sayHello În afară de parantezele pătrate, convențiile de denumire a metodei Obiectiv-C sunt una dintre cele mai mari ajustări pentru dezvoltatorii proveniți din C #, C ++, Java, Python sau aproape orice altă limbă care nu este Smalltalk. Obiectivul-C nume de metode sunt proiectate să fie cât mai descriptive posibil. Ideea este de a defini o metodă în așa fel încât citirea cu voce tare să spună literalmente ceea ce face.
Ca exemplu, să adăugăm o Nume parametru pentru a noastră spune buna metodă. Mai întâi, trebuie să actualizăm declarația metodei din antet (Person.h):
- (void) sayHelloToName: (NSString *) aName;
Adăugarea unui parametru de fapt a schimbat numele funcției-parametrul nu este o entitate izolată, deoarece este în C # (de ex., sayHello (nume)). (NSString *) porțiunea definește tipul de date al parametrului și un nume este variabila actuală care poate fi accesată în codul de implementare, pe care îl vom defini acum. Schimbare spune buna în Person.m la proba de cod care urmează. Xcode ar trebui să completeze automat numele metodei noi atunci când începeți să o tastați.
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Bună ziua% @, numele meu este HAL.", aName);
Acest nou NSLog () configurația utilizează un șir de formate pentru a adăuga un nume argumentul pentru ieșire. Vom acoperi NSLog () în detaliu în capitolul următor, dar pentru moment tot ce trebuie să știți este că înlocuiește % @ în șirul format cu un nume. Aceasta este aproximativ echivalentă cu String.Format () în C #.
Apelarea parametrului un nume ar putea părea redundant cu sayHelloToName, dar are mai mult sens atunci când citiți metoda așa cum ar fi invocată. În main.m, schimba spune buna Sună la:
[somePerson sayHelloToName: @ "Bill");
Acum, ar trebui să vă puteți rula programul și să vedeți Bună Bill, numele meu este HAL. în panoul de ieșire. După cum puteți vedea, numele metodelor Obiectiv-C sunt verbose, dar destul de informative. Spre deosebire de stilul C # sayHello (nume) invocarea, obiectivul C face foarte greu să treci din greșeală valoarea greșită la o metodă. Desigur, compromisul este că numele metodelor sunt lungi, dar de aceea Xcode oferă o caracteristică convenabilă de completare automată. Vom vedea mai multe exemple mai detaliate (și mai practice) despre numele metodelor Obiectiv-C în această carte.
Eșantion de cod inclus: Cu proprietăți
Ca și în cazul oricărui limbaj orientat pe obiecte, metodele Obiectiv-C reprezintă un mijloc de a manipula starea internă a unui obiect. Această stare este în mod tipic reprezentată ca un set de proprietăți atașate unui obiect. De exemplu, putem adăuga a Nume proprietatea noastră Persoană pentru a memora dinamic numele fiecărei instanțe:
@property (copy) NSString * nume;
@proprietate declarația începe o nouă proprietate, (copie) tuple specifică comportamentul proprietății și Numele NSString * definește o proprietate numită Nume care deține o valoare de șir. În mod tipic, declarațiile de proprietate sunt plasate înainte de declarațiile de metode, dar atâta timp cât sunt undeva între ele @interface și @Sfârșit în Person.h, vei fi bine.
Utilizarea @proprietate în locul atributelor private vă oferă acces la @sintetiza în dosarul de implementare. Acesta vă permite să creați automat metode de acces pentru proprietatea asociată. De exemplu, în Person.m, adăugați următoarele (din nou, implementările de proprietăți apar de obicei înainte de implementările metodelor):
@synthesize name = _name;
@sintetiza este o direcție comodă care îi spune compilatorului să genereze metode getter și setter pentru proprietate. Partea după = semnul este folosit ca variabilă de exemplu (adică membru privat) pentru proprietate, ceea ce înseamnă că putem folosi _Nume pentru a accesa proprietatea de nume din interiorul Person.m. De exemplu, încercați să schimbați sayHelloToName la:
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Bună ziua% @, numele meu este% @.", aName, _name);
În mod implicit, numele metodei getter este același cu numele proprietății și setter-ul are a stabilit prefixate la numele proprietății capitalizate. Deci, putem să ne stabilim dinamic Persoană numele obiectului prin schimbare main.m la următoarele:
Persoana * somePerson = [[Person alloc] init]; [somePerson setName: @ "HAL 9000"]; [somePerson sayHelloToName: @ "Bill");
Rularea programului ar trebui să producă acum Bună ziua Bill, numele meu este HAL 9000.
Acest capitol prezintă componentele de bază ale unei clase Obiectiv-C. Am învățat cum să separăm clasele în interfață ( .h) și fișierele de implementare ( .m), instanțierea obiectelor, definirea și apelarea metodelor și declararea proprietăților. Sperăm că vă simțiți puțin mai confortabil cu notația patrată a obiectivului C și cu alte simțuri sintactice.
Amintiți-vă că acest capitol a fost conceput pentru a fi o introducere rapidă în construcțiile OOP ale obiectivului C, nu o discuție aprofundată a fiecărei componente. În capitolele viitoare vom examina mai detaliat tipurile de date, declarațiile de proprietate, definițiile metodei, precum și modelele de design comune ale programelor Obiectiv-C.
Această lecție reprezintă un capitol din Obiectiv-C Succinct, o carte electronică gratuită de la echipa de la Syncfusion.
Accentsconagua