Share
Detta kapitel är utformat för att hjälpa dig att acklimatisera till Objective-C programmeringsstil. I slutet av detta kapitel kommer du att kunna ordna objekt, skapa och ringa metoder och deklarera egenskaper. Kom ihåg att målet är att ge en mycket kort undersökning av de viktigaste objektorienterade aspekterna av Objective-C, inte en detaljerad beskrivning av varje komponent. Senare kapitel fyller i många av de konceptuella detaljerna som saknas från det här kapitlet.
Inkluderat kodprov: HelloObjectiveC med klass
Låt oss dyka rätt in och skapa en ny Objective-C-fil. I Xcode IDE, navigera till Fil > Ny > Fil… eller använd Cmd + N genväg för att lägga till en fil i ditt projekt. I nästa dialogruta kan du välja vilken typ av fil du vill skapa. Under Kakao Touch kategori, välj Mål-C-klass.
Objektiv-C-klassikonen Du får möjlighet att ange ett namn för din nya klass. Låt oss ringa vår klass Person. För moderklassen, använd NSObject, vilket är det översta objektet från vilket alla objektiv-C-klasser ärver.
Definiera en ny personklass klick Nästa öppnar en webbläsare och ber dig ange en Grupp för din klass, såväl som a Mål. Använd standardvärdet Grupp, vilket borde vara HelloObjectiveC. Grupper är en Xcode-specifik mekanism för att gruppera liknande filer, men de inte implementeras på filnivån. Vår nya klass kommer att visas i samma mapp som resten av projektfilerna, oavsett vilken grupp den är. För mål, se till HelloObjectiveC är vald. Detta säkerställer att den nya klassen sammanställs när vi bygger HelloObjectiveC-målet.
Välja byggnadsmål för den nya klassen Slutligen klickar du på Skapa att skapa klassen. I Xcode-filnavigatorn borde du nu hitta två nya klasser: Person.h och Person.m. Precis som C-programmeringsspråket, använder Objective-C .h som förlängning för headerfiler, som innehåller gränssnittet för en viss funktion eller klass - detta får inte förväxlas med ett C # -gränssnitt, som kallas a protokoll i mål-C. De .m filen är det motsvarande genomförandet för Person klass.
Att separera en klassens gränssnitt från implementeringen gör det möjligt att dölja implementeringsdetaljer från tredje parts objekt. Andra filer som behöver interagera med klassen importerar rubrik fil-aldrig genomförande fil. Detta ger den abstrakta definitionen som krävs för att kalla metoder och åtkomstegenskaper samtidigt som de är helt oberoende av klassens genomförande.
I projektnavigatorn väljer du Person.h för att öppna den i redigeringspanelen. Du bör se följande mål-C-kod:
#importera@interface Person: NSObject @end
De #importera Direktivet innehåller en annan fil i det aktuella sammanhanget. Inkluderande en headerfil ger oss tillgång till alla klasser och funktioner som den definierar. I detta fall inkluderade vi stiftelsens ramverk. Stiftelsens ramverk definierar de grundläggande konstruktionerna i mål-C-språket - saker som strängar, arrays, ordböcker etc. - så det är en nödvändig del av praktiskt taget alla mål-C-program.
De @gränssnitt Direktivet börjar ett gränssnitt för en klass. Nästa kommer klassnamnet, Person, följt av ett kolon och förälderklassen, NSObject. Som noterat tidigare, NSObject är toppnivån i Objective-C. Den innehåller nödvändiga metoder för att skapa och förstöra instanser, tillsammans med någon annan användbar funktionalitet som delas av alla objekt.
Eventuella metoder eller egenskaper skulle deklareras före @slutet direktivet, men just nu, Person.h är ett tomt gränssnitt. Vi ändrar det på en minut, men först låt oss snabbt titta på implementeringsfilen, Person.m:
#import "Person.h" @implementation Person @end
Det här ser mycket ut som huvudfilen, men det innehåller Person.h rubrik. Implementeringsfiler måste inkludera deras associerade rubrik, annars kommer de inte att kunna hitta den klass som de försöker genomföra.
Observera också att detta #importera Direktivet använder citatmärken istället för vinklade parenteser. Citatmärken ska användas för import lokal rubriker, medan parentes anger global rubriker. Globala rubriker ligger utanför projektet och är länkade till kompilatorn under byggprocessen. Apples standardramar ingår alltid i vinklade fästen medan dina projektfiler ska importeras med citattecken.
Och såklart, det .m filen använder @genomförande direktivet istället för @gränssnitt. Observera att du inte måste ange förälderklassen här, eftersom denna information redan finns i rubriken.
Därefter lägger vi till en metoddeklaration till Person klass. Kom ihåg att det här är en tvåstegsprocess: först måste vi lägga till det i gränssnittet och sedan implementeringen. Så, ändra Person.h till det följande:
#importera@interface Person: NSObject - (void) sayHello; @slutet
Som du kan se, förklaras instansmetoder med bindestreck, returtypen inom parenteser (ogiltig) följt av metodnamnet och en semikolon. Nu när vi har det i gränssnittet, byt till Person.m att definiera genomförandet. Observera att Xcode lägger till en liten gul triangel bredvid @genomförande linje. Om du klickar på det hittar du ett varningsmeddelande som säger Ofullständigt genomförande. Detta är en av Xcodes många felsökningsfunktioner. Låt oss åtgärda problemet genom att ändra Person.m till det följande:
#import "Person.h" @implementation Person - (void) sayHello NSLog (@ "Hej, jag heter HAL."); @slutet
Liksom gränssnittsdeklarationen börjar implementeringen för en instansmetod med bindestreck, returtyp och funktionsnamn. Implementeringen i sig är definierad i de krökta axlarna efter metodnamnet, precis som en C # -metod. För Säg hej, vi skickar bara ett meddelande till konsolen med NSLog ().
När du skriver skriver Xcode några autokompletionsalternativ, och det borde också ha stängt dina lockiga hängslen för dig. Dessa beteenden kan ändras genom att navigera till Xcode > Inställningar ... i menyraden och klicka på Textredigering ikon.
Låt oss försöka instansera vår Person klass och ringa vår nya Säg hej metod. Kom ihåg det som något C-program, main () är ingången till vår HelloObjectiveC Ansökan. Så tillbaka i main.m, Byta NSLog (@ "Hej, Värld!"); till det följande:
#importera#import "Person.h" int main (int argc, const char * argv []) @autoreleasepool Person * somePerson = [[Personallokering] init]; returnera 0;
De Person * någonperson uttryck förklarar en variabel som heter någon person och berättar kompilatorn att det kommer att hålla en förekomst av Person klass. Stjärnan bredvid variabelnamnet indikerar att det är en pekare, vilket är det vanligaste sättet att referera till objekt i Objective-C. Vi kommer att diskutera tips mer i detalj på vägen.
Därefter [[Personallokering] init] kod skapar en ny instans av Person klass. Kvadratfästet notering kan ta lite att vänja sig, men det är konceptuellt samma som parenteserna som används för metodsamtal i C # och andra Simula-stil språk. Det föregående kodprovet motsvarar följande i C #:
Person somePerson = ny person (); somePerson.init ();
De [Personallokering] samtal allokerar det minne som krävs för den nya instansen, och i det samtal används för att utföra någon form av anpassad initialiseringskod. Observera att det inte finns några "konstruktormetoder" i Mål-C eftersom det finns C # eller C ++ - du måste manuellt ringa i det metod (eller någon variant av det) för att ställa in ditt objekt. Som ett resultat är nästan allt objekt skapande i Objective-C en tvåstegsprocess: allokera och initiera sedan. Du kommer att se detta mönster ganska ofta i mål-C-program.
Nu när vi har ett föremål att arbeta med, kan vi ringa vår Säg hej metod. Observera att rätt terminologi i mål-C är "att skicka ett meddelande", inte "anropa en metod", men i vårt syfte kan vi behandla dem som synonymt. Lägg till följande rad till main.m:
[någon person säger hej];
Precis som alloc/i det metoder i det föregående exemplet använder anpassad metodinventering fyrkantiga parenteser. Återigen är detta detsamma som att exekvera somePerson.sayHello () i C #. Att köra ditt program ska visas Hej, jag heter HAL. i Xcode-utmatningspanelen:
Output genererad från SayHello-metoden Bortsett från torghakarna är Objective-Cs metodnamnkonventioner en av de största anpassningarna för utvecklare som kommer från C #, C ++, Java, Python eller ganska mycket annat språk som inte är Smalltalk. Målnamn-C-metodenamn är utformade för att vara så beskrivande som möjligt. Tanken är att definiera en metod på ett sådant sätt att läsningen högt berättar för dig vad det gör.
Till exempel, lägg till en namn parameter till vår Säg hej metod. Först måste vi uppdatera metoddeklarationen i rubriken (Person.h):
- (void) sayHelloToName: (NSString *) aName;
Lägga till en parameter faktiskt ändrade namnet på funktionen-parametern är inte en isolerad enhet som den är i C # (t.ex.., sayHello (namn)). De (NSString *) del definierar datatypen för parametern, och ett namn är den faktiska variabeln som kan nås i implementeringskoden, som vi definierar nu. Byta Säg hej i Person.m till kodprovet som följer. Xcode ska automatiskt fylla i det nya metodenamn när du börjar skriva det.
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Hej% @, jag heter HAL.", aName);
Den här nya NSLog () konfigurationen använder en formatsträng för att lägga till ett namn argument till produktionen. Vi täcker NSLog () mer detaljerat i nästa kapitel, men för nu är allt du behöver veta att det ersätter % @ i formatet sträng med ett namn. Detta är ungefär lika med String.Format () i C #.
Ringer parametern ett namn kan tyckas redundant med sayHelloToName, men det är mer meningsfullt när du läser metoden som den skulle åberopas. I main.m, ändra Säg hej ring till:
[någon person sägerHelloToName: @ "Bill"];
Nu borde du kunna köra ditt program och se Hej Bill, jag heter HAL. i utmatningspanelen. Som du kan se är Objective-C-metodnamn verkliga, men ganska informativa. Till skillnad från C # -stilen sayHello (namn) uppmaning, Objective-C gör det väldigt svårt att oavsiktligt skicka det felaktiga värdet till en metod. Naturligtvis är avvägningen att metodnamnen är långa, men det är därför Xcode ger en så bekväm autofyllningsfunktion. Vi får se många mer verbala (och mer praktiska) exempel på Metod-C-metodenamn i hela den här boken.
Inkluderat kodprov: Med Egenskaper
Som med något objektorienterat språk är mål-C-metoder ett sätt att manipulera ett objekts interna tillstånd. Detta tillstånd representeras typiskt som en uppsättning egenskaper som är fästa vid ett objekt. Till exempel kan vi lägga till en namn egendom till vår Person gränssnitt för att lagra varje instans namn dynamiskt:
@property (copy) NSString * namn;
De @fast egendom deklarationen börjar en ny egendom, den (kopia) tuple anger egenskapens beteende, och NSString * namn definierar en egendom som heter namn som har ett strängvärde. Egenskapsdeklarationer placeras typiskt före metoddeklarationer, men så länge som det är någonstans mellan @gränssnitt och @slutet i Person.h, du mår bra.
Använder sig av @fast egendom istället för privata attribut ger dig tillgång till @synthesize direktivet i implementeringsfilen. Det låter dig automatiskt skapa accessor metoder för den tillhörande egendomen. Till exempel, i Person.m, lägg till följande (igen, egendom implementeringar kommer vanligtvis före metod implementeringar):
@synthesize name = _name;
@synthesize är ett bekvämlighetsdirektiv som berättar för kompilatorn att generera getter och setter metoder för fastigheten. Del efter = tecken används som instansvariabeln (dvs privat medlem) för egenskapen, vilket innebär att vi kan använda _namn för att komma åt namnegenskapen inuti Person.m. Försök till exempel ändra sayHelloToName metod för att
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Hej% @, jag heter% @.", aName, _name);
Som standard är getter-metodnamnet detsamma som egenskapsnamnet, och settern har uppsättning prepended till det kapitaliserade fastighetsnamnet. Så kan vi dynamiskt ställa in vår Person objektets namn genom att ändra main.m till det följande:
Person * somePerson = [[Personallokering] init]; [någonPerson setName: @ "HAL 9000"]; [någon person sägerHelloToName: @ "Bill"];
Att köra ditt program borde nu producera Hej Bill, jag heter HAL 9000.
I detta kapitel presenterades de grundläggande komponenterna i en Mål-C-klass. Vi lärde oss hur man skiljer klasser i gränssnitt ( .h) och implementeringsfiler ( .m), instansera objekt, definiera och anropa metoder och deklarera egenskaper. Förhoppningsvis känner du dig lite mer bekväm med Objective-C: s kvadratkonsolnotation och andra syntaktiska quirks.
Kom ihåg att detta kapitel var utformat för att vara en snabb introduktion till Objective-C: s OOP-konstruktioner, inte en djupgående diskussion av varje komponent. I de kommande kapitlen tar vi en mer detaljerad titt på datatyper, fastighetsdeklarationer, metoddefinitioner, samt de gemensamma designmönstren för Objective-C-program.
Denna lektion representerar ett kapitel från Objective-C Succinctly, en gratis eBook från laget vid Syncfusion.
Accentsconagua