Share
Dette kapittelet er utformet for å hjelpe deg med å akklimatisere objektiv-C programmeringsstil. Ved slutten av dette kapitlet vil du kunne ordne objekter, lage og ringe metoder og deklarere egenskaper. Husk at målet er å gi en veldig kort oversikt over de viktigste objektorienterte aspektene av Objective-C, ikke en detaljert beskrivelse av hver komponent. Senere kapitler fyller ut mange av de konseptuelle detaljene utelatt fra dette kapittelet.
Inkludert kodeeksempel: HelloObjectiveC med klasse
La oss dykke rett inn og opprette en ny Objective-C-fil. I Xcode IDE, naviger til Fil > Ny > Fil… eller bruk Cmd + N snarvei for å legge til en fil i prosjektet. I neste dialogboks kan du velge hvilken type fil du vil lage. Under Kakao Touch kategori, velg Mål-C klasse.
Objektiv-C-ikonet Du får anledning til å spesifisere et navn for den nye klassen din. La oss ringe vår klasse Person. For foreldreklassen, bruk NSObject, som er det øverste nivåobjektet som alle mål-C-klasser arver.
Definere en ny personklasse Klikker neste vil åpne en filbrowser og be deg om å skrive inn en Gruppe for din klasse, så vel som a Mål. Bruk standardinnstillingen Gruppe, som burde være HelloObjectiveC. Grupper er en Xcode-spesifikk mekanisme for gruppering av lignende filer, men de er ikke implementert på filnivå. Vår nye klasse vil vises i samme mappe som resten av prosjektfilene, uansett hvilken gruppe den er. For Targets, forsikre HelloObjectiveC er valgt. Dette sikrer at den nye klassen blir samlet når vi bygger HelloObjectiveC-målet.
Velger byggemål for den nye klassen Til slutt klikker du Skape å lage klassen. I Xcode-filnavigatoren bør du nå finne to nye klasser: Person.h og Person.m. På samme måte som C-programmeringsspråket bruker Objective-C .h som utvidelse for headerfiler, som inneholder grensesnittet for en bestemt funksjon eller klasse - dette skal ikke forveksles med et C # -grensesnitt, som kalles en protokollen i mål-C. De .m filen er den tilsvarende implementeringen for Person klasse.
Å skille et klasses grensesnitt fra implementeringen gjør det mulig å skjule implementasjonsdetaljer fra tredjepartsobjekter. Andre filer som må samhandle med klassen importerer Overskrift fil-aldri den gjennomføring fil. Dette gir den abstrakte definisjonen nødvendig for å ringe metoder og tilgangseiendommer, mens de er helt uavhengige av klassens implementering.
I prosjektnavigatoren velger du Person.h for å åpne den i redigeringspanelet. Du bør se følgende mål-C-kode:
#importere@interface Person: NSObject @end
De #importere Direktivet inneholder en annen fil i den nåværende konteksten. Inkludert en headerfil gir oss tilgang til alle klassene og funksjonene den definerer. I dette tilfellet inkluderte vi stiftelsens rammeverk. Stiftelsesrammen definerer de grunnleggende konstruksjonene i Mål-C-språket - ting som strenge, arrays, ordbøker, etc. - så det er en nødvendig del av nesten alle mål-C-programmer.
De @interface Direktivet begynner et grensesnitt for en klasse. Neste kommer klassenavnet, Person, etterfulgt av en kolon og foreldreklassen, NSObject. Som nevnt tidligere, NSObject er toppnivåobjektet i Objective-C. Den inneholder de nødvendige metodene for å lage og ødelegge forekomster, sammen med noen annen nyttig funksjonalitet som deles av alle objekter.
Eventuelle metoder eller egenskaper vil bli erklært før @slutt direktiv, men akkurat nå, Person.h er et tomt grensesnitt. Vi endrer det om et minutt, men først får vi et raskt blikk på implementeringsfilen, Person.m:
#import "Person.h" @implementation Person @end
Dette ser mye ut som topptekstfilen, men det inkluderer Person.h Overskrift. Implementeringsfiler må Ta med tilhørende overskrift, ellers kan de ikke finne klassen de prøver å implementere.
Legg merke til at dette #importere Direktivet bruker anførselstegn i stedet for vinklede parenteser. Sitatkarakterer skal brukes til import lokal overskrifter, mens parentes angir global overskrifter. Globale overskrifter ligger utenfor prosjektet og er koblet til kompilatoren under byggeprosessen. Apples standardrammer er alltid inkludert i vinklede parentes, mens prosjektfilene dine skal importeres med anførselstegn.
Og selvfølgelig, .m filen bruker @gjennomføring direktivet i stedet for @interface. Legg merke til at du ikke må spesifisere foreldreklassen her, siden denne informasjonen allerede finnes i overskriften.
Deretter legger vi til en metodedeklarasjon til Person klasse. Husk at dette er en to-trinns prosess: først må vi legge til det i grensesnittet, og deretter implementeringen. Så, endre Person.h til følgende:
#importere@interface Person: NSObject - (void) sayHello; @slutt
Som du kan se, er eksempelmetoder oppgitt med en bindestrek, retur typen i parenteser (tomrom), etterfulgt av metodenavnet og en semikolon. Nå som vi har det i grensesnittet, bytt til Person.m å definere implementeringen. Legg merke til at Xcode la til en liten gul trekant ved siden av @gjennomføring linje. Hvis du klikker på det, finner du en advarsel som sier Ufullstendig implementering. Dette er en av Xcodes mange feilsøkingsfunksjoner. La oss løse dette problemet ved å endre Person.m til følgende:
#import "Person.h" @implementation Person - (void) sayHello NSLog (@ "Hei, jeg heter HAL."); @slutt
I likhet med grensesnittdeklarasjonen begynner implementeringen av en instansmetode med bindestrek, returtype og funksjonsnavn. Implementeringen selv er definert i de krøllete braces etter metodenavnet, akkurat som en C # -metode. Til si hei, Vi sender bare en melding til konsollen ved hjelp av NSLog ().
Når du skriver, presenterer Xcode noen autofullføringsalternativer, og det burde også ha lukket dine krøllete braces for deg. Disse oppføringene kan endres ved å navigere til Xcode > Preferanser… i menylinjen og klikk på Tekstredigering ikon.
La oss prøve å instansere vår Person klasse og ringe vår nye si hei metode. Husk det som et C-program, hoved() er inngangspunktet i vår HelloObjectiveC applikasjon. Så tilbake i main.m, endring NSLog (@ "Hei, Verden!"); til følgende:
#importere#import "Person.h" int main (int argc, const char * argv []) @ autoreleasepool Person * somePerson = [[Personallokering] init]; returnere 0;
De Person * noenPerson uttrykk forklarer en variabel som kalles somePerson og forteller kompilatoren at den skal holde en forekomst av Person klasse. Stjernen ved siden av variabelnavnet indikerer at det er en pekeren, som er den vanligste måten å referere til objekter i Objective-C. Vi drøfter poengene mer detaljert nedover veien.
Deretter [[Personallokering] init] kode oppretter en ny forekomst av Person klasse. Firkantbrakettnotatet kan ta litt vant til, men det er konseptuelt det samme som parentesene som brukes til metallsamtaler i C # og andre Simula-stil-språk. Den forrige kodesammenstillingen er ekvivalent med følgende i C #:
Person somePerson = ny person (); somePerson.init ();
De [Personallokering] samtale allokerer minnet som kreves for den nye forekomsten, og i det anrop brukes til å utføre noen form for tilpasset initialiseringskode. Vær oppmerksom på at det ikke finnes "konstruktormetoder" i Mål-C som det finnes i C # eller C ++ - du må manuelt ringe til i det metode (eller en variant derav) for å sette opp objektet ditt. Som et resultat er nesten alle objekter i Objective-C en to-trinns prosess: allokere, og deretter initialisere. Du vil se dette mønsteret ganske ofte i Objective-C-programmer.
Nå som vi har et objekt å jobbe med, kan vi ringe vår si hei metode. Merk at den riktige terminologien i Objective-C er "å sende en melding," ikke "kalle en metode", men for våre formål kan vi behandle dem som synonymt. Legg til følgende linje til main.m:
[noenPerson sayHello];
Akkurat som Alloc/i det metoder i det forrige eksempelet bruker tilpasset metodeoppfordring firkantede parenteser. Igjen, dette er det samme som å utføre somePerson.sayHello () i C #. Kjører programmet bør vises Hei, jeg heter HAL. i Xcode utgangspanelet:
Output generert fra sayHello-metoden Bortsett fra firkantede parenteser, er Objective-Cs metode navngivningskonvensjoner en av de største tilpasningene for utviklere som kommer fra C #, C ++, Java, Python, eller stort sett alle andre språk som ikke er Smalltalk. Mål-C metode navn er utformet for å være så beskrivende som mulig. Tanken er å definere en metode på en slik måte at det å lese det høyt, forteller deg hva det gjør.
Som et eksempel, la oss legge til en Navn parameter til vår si hei metode. Først må vi oppdatere metoden deklarasjonen i overskriften (Person.h):
- (void) sayHelloToName: (NSString *) aName;
Legge til en parameter faktisk Endret navnet på funksjonen-parameteren er ikke en isolert enhet som den er i C # (f.eks., sayHello (navn)). De (NSString *) del definerer datatypen til parameteren, og et navn er den faktiske variabelen som kan nås i implementeringskoden, som vi definerer nå. Endring si hei i Person.m til koden prøven som følger. Xcode skal autofullfør det nye metodenavnet når du begynner å skrive det.
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Hei% @, jeg heter HAL.", aName);
Dette nye NSLog () konfigurasjon bruker en format streng for å legge til et navn argument til utgangen. Vi vil dekke NSLog () mer detaljert i neste kapittel, men for nå er alt du trenger å vite at det erstatter % @ i formatet streng med et navn. Dette er omtrent likeverdig String.Format () i C #.
Ringer parameteren et navn kan virke overflødig med sayHelloToName, men det er mer fornuftig når du leser metoden som det ville bli påkalt. I main.m, endre si hei ring til:
[noenPerson sayHelloToName: @ "Bill"];
Nå bør du kunne kjøre programmet og se Hei Bill, jeg heter HAL. i utgangspanelet. Som du kan se, er Objective-C-metodenavne ekstreme, men ganske informative. I motsetning til C # -stilen sayHello (navn) invokasjon, Objective-C gjør det svært vanskelig å tilfeldigvis sende feil verdi til en metode. Selvfølgelig er avviket at metodenavnene er lange, men det er derfor Xcode gir en så praktisk autofullføringsfunksjon. Vi ser mange flere verbose (og mer praktiske) eksempler på Objective-C-metodenavn gjennom hele denne boken.
Inkludert kodeeksempel: Med Egenskaper
Som med ethvert objektorientert språk, er mål-C-metoder et middel til å manipulere den indre tilstanden til en gjenstand. Denne tilstanden er typisk representert som et sett med egenskaper knyttet til en gjenstand. For eksempel kan vi legge til en Navn eiendom til vår Person grensesnitt for å lagre hver forekomst navn dynamisk:
@property (copy) NSString * navn;
De @eiendom erklæring begynner en ny eiendom, den (kopiere) tuple angir egenskapen til eiendommen, og NSString * navn definerer en eiendom som kalles Navn som har en strengverdi. Typisk er eiendomserklæringer plassert før metodedeklarasjoner, men så lenge det er et sted mellom @interface og @slutt i Person.h, du klarer deg.
Ved hjelp av @eiendom i stedet for private attributter gir deg tilgang til @synthesize direktivet i implementasjonsfilen. Det lar deg automatisk lage tilgangsmetoder for den tilhørende eiendommen. For eksempel, i Person.m, legg til følgende (igjen, eiendomsimplementeringer kommer vanligvis før metodeimplementeringer):
@synthesize navn = _name;
@synthesize er et bekvemmelighetsdirektiv som forteller kompilatoren å generere getter og setter metoder for eiendommen. Delen etter = skilt brukes som instansvariabelen (dvs. privatmedlem) for eiendommen, noe som betyr at vi kan bruke _Navn for å få tilgang til navnegenskapen inne i Person.m. For eksempel, prøv å endre sayHelloToName metode for å:
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Hei% @, jeg heter% @.", aName, _name);
Som standard er getter-metodenavnet det samme som eiendomsnavnet, og setteren har sett prepended til det kapitaliserte eiendomsnavnet. Så, vi kan dynamisk sette vår Person objektets navn ved å endre main.m til følgende:
Person * somePerson = [[Personallokering] init]; [noenPerson settnavn: @ "HAL 9000"]; [noenPerson sayHelloToName: @ "Bill"];
Kjører programmet bør nå produsere Hei Bill, jeg heter HAL 9000.
Dette kapitlet presenterte de grunnleggende komponentene i en Objective-C-klasse. Vi lærte å skille klasser i grensesnitt ( .h) og implementeringsfiler ( .m), instantiate objekter, definere og ringe metoder, og deklarere egenskaper. Forhåpentligvis føler du deg litt mer komfortabel med Objective-Cs firkantbrakettnotasjon og andre syntaktiske quirks.
Husk at dette kapittelet var designet for å være en rask introduksjon til Objective-Cs OOP-konstruksjoner, ikke en grundig diskusjon av hver komponent. I de kommende kapitlene skal vi se nærmere på datatyper, eiendomserklæringer, metodedefinisjoner, samt de vanlige designmønstrene for Objective-C-programmer.
Denne leksjonen representerer et kapittel fra Objective-C Succinctly, en gratis eBok fra teamet på Syncfusion.
Accentsconagua