Share
Dit hoofdstuk is bedoeld om u te helpen te acclimatiseren in de programmeerstijl Objective-C. Aan het einde van dit hoofdstuk kunt u objecten instantiëren, maken en aanroepen en eigenschappen declareren. Vergeet niet dat het de bedoeling is om een zeer kort overzicht te geven van de belangrijkste objectgerichte aspecten van Objective-C, niet een gedetailleerde beschrijving van elk onderdeel. Latere hoofdstukken vullen veel van de conceptuele details in die in dit hoofdstuk zijn weggelaten.
Inclusief codevoorbeeld: HalloObjectiveC met klasse
Laten we meteen naar binnen duiken en een nieuw Objective-C-bestand maken. Navigeer in de Xcode IDE naar het dossier > nieuwe > Het dossier… of gebruik de Cmd + N snelkoppeling om een bestand aan uw project toe te voegen. In het volgende dialoogvenster kunt u selecteren welk type bestand u wilt maken. Onder de Cocoa Touch categorie, selecteer Objectieve C-klasse.
Het pictogram van de klasse Objective-C U krijgt de mogelijkheid om een naam voor uw nieuwe klas op te geven. Laten we onze klas bellen Persoon. Gebruik voor de bovenliggende klasse NSObject, Dit is het object op het hoogste niveau waarvan alle Objective-C-klassen worden geërfd.
Een nieuwe persoonsklasse definiëren klikken volgende opent een bestandsbrowser en vraagt u om een Groep voor uw klas, evenals een Doelwit. Gebruik de standaardinstelling Groep, welke zou moeten zijn HelloObjectiveC. Groepen zijn een Xcode-specifiek mechanisme voor het groeperen van vergelijkbare bestanden, maar ze zijn niet geïmplementeerd op bestandsniveau. Onze nieuwe klasse verschijnt in dezelfde map als de rest van de projectbestanden, ongeacht in welke groep het is. Voor targets, zorg ervoor dat HelloObjectiveC is geselecteerd. Dit zorgt ervoor dat de nieuwe klasse wordt gecompileerd wanneer we het HelloObjectiveC-doel maken.
Selecteren van bouwdoelen voor de nieuwe klasse Klik ten slotte op creëren om de klasse te maken. In de Xcode bestandsnavigator zou je nu twee nieuwe klassen moeten vinden: Person.h en Person.m. Net als de C-programmeertaal gebruikt Objective-C .h als de extensie voor header-bestanden, die de interface voor een bepaalde functie of klasse bevatten, dit moet niet worden verward met een C # -interface, die een protocol in Objective-C. De .m bestand is de overeenkomstige implementatie voor de Persoon klasse.
Het scheiden van de interface van een klasse van de implementatie ervan maakt het mogelijk om implementatiedetails van objecten van derden te verbergen. Andere bestanden die moeten communiceren met de klasse, importeren de hoofd bestand - nooit de implementatie het dossier. Dit biedt de abstracte definitie die nodig is om methoden en toegangseigenschappen aan te roepen, terwijl deze volledig onafhankelijk is van de implementatie van de klasse.
Selecteer in de projectnavigator Person.h om het te openen in het editorpaneel. Je zou de volgende Objective-C code moeten zien:
#importeren@interface Persoon: NSObject @end
De #importeren richtlijn bevat een ander bestand in de huidige context. Het opnemen van een headerbestand geeft ons toegang tot alle klassen en functies die het definieert. In dit geval hebben we het kader van de Foundation opgenomen. Het kader van de Foundation definieert de basisconstructies van de taal Objective-C (dingen zoals strings, arrays, woordenboeken, enz.), Dus het is een noodzakelijk onderdeel van vrijwel elk Objective-C-programma..
De @interface richtlijn begint een interface voor een klasse. Vervolgens komt de klassenaam, Persoon, gevolgd door een dubbele punt en de bovenliggende klasse, NSObject. Zoals eerder vermeld, NSObject is het object op het hoogste niveau in Objective-C. Het bevat de nodige methoden voor het maken en vernietigen van exemplaren, samen met enkele andere handige functies die door alle objecten worden gedeeld.
Alle methoden of eigenschappen worden vóór de @einde richtlijn, maar nu meteen, Person.h is een lege interface. We zullen dat in een minuut veranderen, maar laten we eerst een snelle blik werpen op het implementatiebestand, Person.m:
#import "Person.h" @implementation Persoon @end
Dit lijkt veel op het header-bestand, maar het bevat de Person.h header. Implementatiebestanden moet de bijbehorende header opnemen, anders kunnen ze de klas niet vinden die ze proberen te implementeren.
Merk ook op dat dit #importeren richtlijn gebruikt aanhalingstekens in plaats van schuine haken. Aanhalingstekens moeten worden gebruikt om te importeren lokaal headers, terwijl haakjes aangeven globaal headers. Globale headers bevinden zich buiten het project en zijn tijdens het bouwproces aan de compiler gekoppeld. Standaardkaders van Apple worden altijd opgenomen onder haakse haakjes, terwijl uw projectbestanden moeten worden geïmporteerd met aanhalingstekens.
En natuurlijk, de .m bestand gebruikt de @implementatie richtlijn in plaats van @interface. Merk op dat jij niet doen moet hier de bovenliggende klasse specificeren, omdat deze informatie al in de header zit.
Vervolgens voegen we een methodeverklaring toe aan de Persoon klasse. Houd er rekening mee dat dit een proces in twee stappen is: eerst moeten we het toevoegen aan de interface en vervolgens de implementatie. Dus, veranderen Person.h Naar het volgende:
#importeren@interface Persoon: NSObject - (void) sayHello; @einde
Zoals u kunt zien, worden voorbeeldmethoden gedeclareerd met een koppelteken, het retourtype tussen haakjes (leegte), gevolgd door de methode en een puntkomma. Nu dat we dat in de interface hebben, ga je naar Person.m om de implementatie te definiëren. Merk op dat Xcode een klein geel driehoekje naast de @implementatie lijn. Als u erop klikt, ziet u een waarschuwingsbericht dat zegt Onvolledige implementatie. Dit is een van de vele functies voor foutopsporing van Xcode. Laten we dat probleem oplossen door te veranderen Person.m Naar het volgende:
#import "Person.h" @implementation Person - (void) sayHello NSLog (@ "Hallo, mijn naam is HAL."); @end
Net als de interface-declaratie begint de implementatie voor een instantiemethode met een koppelteken, het retourneertype en de functienaam. De implementatie zelf wordt gedefinieerd in de accolades achter de naam van de methode, net zoals bij een C # -methode. Voor zeg hallo, we voeren gewoon een bericht uit naar de console met NSLog ().
Terwijl u typt, biedt Xcode enkele opties voor automatisch aanvullen en moet uw accolades ook voor u zijn gesloten. Dit gedrag kan worden gewijzigd door naar te navigeren Xcode > Voorkeuren ... in de menubalk en klik op de Tekstbewerking icoon.
Laten we proberen ons in te richten Persoon klas en onze nieuwe bellen zeg hallo methode. Onthoud dat zoals elk C-programma, hoofd() is het toegangspunt tot onze HelloObjectiveC toepassing. Dus, terug in main.m, verandering NSLog (@ "Hallo, Wereld!"); Naar het volgende:
#importeren#import "Person.h" int main (int argc, const char * argv []) @autoreleasepool init [i] person [persoon]]; retourneer 0;
De Persoon * somePerson expressie declareert een variabele genaamd iemand en vertelt de compiler dat deze een instantie van de Persoon klasse. Het sterretje naast de naam van de variabele geeft aan dat het een a is wijzer, Dit is de meest gebruikelijke manier om objecten te verwijzen in Objective-C. We bespreken de pointers verderop in meer detail.
Vervolgens de [[Person alloc] init] code maakt een nieuw exemplaar van de Persoon klasse. De notatie van de vierkante haakjes kan even wennen zijn, maar het is conceptueel hetzelfde als de haakjes die worden gebruikt voor methodeaanroepen in C # en andere Simula-achtige talen. Het vorige codevoorbeeld komt overeen met het volgende in C #:
Persoon somePerson = new Person (); somePerson.init ();
De [Person alloc] aanroep wijst het geheugen toe dat vereist is voor de nieuwe instantie, en de in het oproep wordt gebruikt om elke soort aangepaste initialisatiecode uit te voeren. Merk op dat er geen "constructormethoden" zijn in Objective-C zoals er zijn in C # of C ++ - je moet de in het methode (of een variant daarvan) om uw object in te stellen. Als gevolg hiervan is vrijwel alle objectcreatie in Objective-C een proces in twee stappen: toewijzen en vervolgens initialiseren. Je zult dit patroon vrij vaak zien in Objective-C-programma's.
Nu we een object hebben om mee te werken, kunnen we onze bellen zeg hallo methode. Let op: de juiste terminologie in Objective-C is "een bericht verzenden", niet "een methode aanroepen", maar voor onze doeleinden kunnen we ze als synoniemen behandelen. Voeg de volgende regel toe aan main.m:
[somePerson sayHello];
Net als de alloc/in het methoden in het vorige voorbeeld gebruikt aangepaste methode-aanroep vierkante haken. Nogmaals, dit is hetzelfde als het uitvoeren somePerson.sayHello () in C #. Het uitvoeren van uw programma zou moeten verschijnen Hallo, mijn naam is HAL. in het Xcode-uitvoerpaneel:
Uitgang gegenereerd door de SayHello-methode Afgezien van de vierkante haken zijn de benamingsconventies van Objective-C een van de grootste aanpassingen voor ontwikkelaars afkomstig van C #, C ++, Java, Python of vrijwel elke andere taal die geen Smalltalk is. Objectief-C-methode namen zijn ontworpen om zo beschrijvend mogelijk te zijn. Het idee is om een methode zo te definiëren dat het hardop lezen je letterlijk vertelt wat het doet.
Laten we bijvoorbeeld een toevoegen naam parameter voor onze zeg hallo methode. Allereerst moeten we de methode-declaratie in de kop bijwerken (Person.h):
- (ongeldig) sayHelloToName: (NSString *) aName;
Eigenlijk een parameter toevoegen veranderde de naam van de functie-de parameter is geen geïsoleerde entiteit zoals deze in C # is (bijv., sayHello (naam)). De (NSString *) gedeelte definieert het gegevenstype van de parameter, en een naam is de werkelijke variabele die kan worden geraadpleegd in de implementatiecode, die we nu zullen definiëren. Verandering zeg hallo in Person.m naar het codevoorbeeld dat volgt. Xcode moet de nieuwe methode automatisch aanvullen wanneer u begint met typen.
- (ongeldig) sayHelloToName: (NSString *) aName NSLog (@ "Hallo% @, mijn naam is HAL.", aName);
Deze nieuwe NSLog () configuratie gebruikt een format string om de een naam argument voor de uitvoer. We zullen dekken NSLog () in meer detail in het volgende hoofdstuk, maar voorlopig is alles wat je moet weten dat het vervangt % @ in de notatiereeks met een naam. Dit komt ongeveer overeen met String.Format () in C #.
De parameter aanroepen een naam lijkt misschien overbodig sayHelloToName, maar het is logischer als je de methode leest zoals die zou worden aangeroepen. In main.m, verander de zeg hallo bellen naar:
[somePerson sayHelloToName: @ "Bill"];
Nu zou u uw programma moeten kunnen uitvoeren en zien Hallo Bill, mijn naam is HAL. in het uitvoerpaneel. Zoals je kunt zien, zijn de namen van de Objective-C-methoden uitgebreid, maar zeer informatief. In tegenstelling tot de C # -stijl sayHello (naam) aanroepen, Objective-C maakt het heel moeilijk om per ongeluk de verkeerde waarde door te geven aan een methode. Natuurlijk is de wisselwerking dat de namen van de methoden lang zijn, maar dat is de reden waarom Xcode zo'n handige functie voor automatisch aanvullen biedt. We zullen veel meer uitgebreide (en meer praktische) voorbeelden van Objective-C-methoden in dit boek zien.
Inclusief codevoorbeeld: met eigenschappen
Zoals met elke objectgeoriënteerde taal, zijn Objective-C-methoden een middel om de interne toestand van een object te manipuleren. Deze status wordt meestal weergegeven als een reeks eigenschappen die aan een object is gekoppeld. We kunnen bijvoorbeeld een toevoegen naam eigendom van onze Persoon interface om de naam van elke instantie dynamisch op te slaan:
@property (kopie) NSString * naam;
De @eigendom aangifte begint een nieuw eigendom, de (kopiëren) tuple specificeert het gedrag van de eigenschap, en Naam NSString * definieert een eigenschap genaamd naam die een tekenreekswaarde bevat. Typeaanduidingen worden meestal vóór de systeemverklaringen geplaatst, maar zolang deze zich ergens tussen bevinden @interface en @einde in Person.h, het zal goed met je gaan.
Gebruik makend van @eigendom in plaats van privéattributen geeft u toegang tot de @synthetiseren richtlijn in het implementatiebestand. Hiermee kunt u automatisch toegangsmethoden maken voor de bijbehorende eigenschap. Bijvoorbeeld in Person.m, voeg het volgende toe (nogmaals, property-implementaties komen meestal vóór de implementaties van de methode):
@synthesize name = _name;
@synthetiseren is een gemaksrichtlijn die de compiler opdracht geeft getter- en settermethoden te genereren voor de eigenschap. Het deel na de = teken wordt gebruikt als de instantievariabele (dat wil zeggen privélid) voor de eigenschap, wat betekent dat we kunnen gebruiken _naam om toegang te krijgen tot de eigenschap name inside in Person.m. Probeer bijvoorbeeld de sayHelloToName methode om:
- (ongeldig) sayHelloToName: (NSString *) aName NSLog (@ "Hallo% @, mijn naam is% @.", aName, _name);
Standaard is de naam van de gettermethode gelijk aan de naam van de eigenschap en de setter heeft reeks toegevoegd aan de naam van de hoofdletter. Dus we kunnen ons dynamisch instellen Persoon de naam van het object door te veranderen main.m Naar het volgende:
Persoon * somePerson = [[Person allocation] init]; [somePerson setName: @ "HAL 9000"]; [somePerson sayHelloToName: @ "Bill"];
Het uitvoeren van je programma zou nu moeten produceren Hallo Bill, mijn naam is HAL 9000.
Dit hoofdstuk presenteerde de basiscomponenten van een Objective-C-klasse. We hebben geleerd klassen in een interface te scheiden ( .h) en uitvoeringsbestanden ( .m), instantiëren objecten, definieer en bel methoden en declareer eigenschappen. Hopelijk voel je je een beetje comfortabeler met Objective-C's vierkante haakjesnotatie en andere syntactische eigenaardigheden.
Vergeet niet dat dit hoofdstuk is ontworpen om een snelle introductie te zijn van de OOP-constructies van Objective-C, niet een diepgaande bespreking van elk onderdeel. In de komende hoofdstukken zullen we meer in detail kijken naar gegevenstypes, eigenschapsverklaringen, methodedefinities, evenals de gemeenschappelijke ontwerppatronen van Objective-C-programma's.
Deze les vertegenwoordigt een hoofdstuk uit Objective-C bondig, een gratis eBoek van het team van Syncfusion.
Accentsconagua