Share
Welkom bij deel drie van deze serie -Ik hoop dat je het leuk vindt! Vorige week hebben we gekeken naar hoe we klassen scheiden in afzonderlijke bestanden (interface en implementatie), deze week gaan we opnieuw naar klassen kijken, maar een beetje meer diepgaand. We nemen ook een piek in overerving en hoe het werkt, samen met een variabel bereik.
Tot nu toe hebben we geweldige feedback gehad via e-mail, twitter en reacties. Het is geweldig om te zien dat zoveel mensen geïnteresseerd zijn in dit onderwerp en het is nog beter om te zien dat zoveel van jullie het zelf uitproberen en een paar geweldige vragen stellen. Ga zo door!
Laten we eens kijken wat we tot nu toe hebben geleerd over lessen in deze serie. Als je niets weet, kijk dan terug naar de laatste tutorial om opnieuw te capten. Oké, dus wat zijn klassen?
Een klasse is een verzameling ingekapselde gegevens en aangepaste methoden. Een klasse kan veel verschillende soorten gegevens bevatten en de klassemethoden voeren gewoonlijk (maar niet altijd) acties uit die verband houden met die gegevens. In Objective-C bestaat een klasse gewoonlijk uit twee bestanden: een interfacebestand en een implementatiebestand. Het interfacebestand maakt volgens de conventie gebruik van de extensie .h. Hier kan de persoon die de klasse gebruikt snel de methoden en gegevensleden vinden die beschikbaar zijn voor de klas. Het implementatiebestand gebruikt de bestandsextensie .m volgens conventie en bevat de meerderheid van de code omdat deze de daadwerkelijke implementatie bevat van alle functies die in de interface zijn gedeclareerd.
Dus, wat maakt een klas anders dan een object? Wat is een object? Een object is een instantie van een klasse. Denk terug aan ons voorbeeld met de auto in het laatste deel van de serie. Waar auto is de klas dan mijn auto, dansCar, en jouw auto zouden allemaal objecten zijn omdat ze voorbeelden van de autoklasse zijn.
Voordat we verder gaan, wil ik graag een paar (van veel) gewone lessen delen die je veel zult gebruiken die door Apple worden aangeboden, maar eerst een snelle geschiedenisles.
Veel klassen die Apple aanbiedt, zijn voorafgegaan door de afkorting "NS", wat staat voor NextStep. Toen Steve Jobs Apple verliet, richtte hij NeXT op en maakte hij werkstationcomputers die op zijn besturingssysteem draaiden. De object georiënteerde programmeertaal die op die machines werd gebruikt, heette NeXTSTEP, waar we de "NS" vandaan halen. Toen Apple'acquired 'was (een andere geschiedenisles op zich) NeXTSTEP, besloten ze om Mac OS X te baseren op NeXTSTEP.
Hier zijn enkele eenvoudige, gemeenschappelijke lessen die we veel zullen zien:
We zullen later veel meer leren, maar voor nu zal het bovenstaande van pas komen. Je vraagt je waarschijnlijk af wat veranderlijk en onveranderlijk betekent, wat een heel redelijke vraag is. Als een object is onveranderlijk dat betekent dat wanneer we het object maken en een waarde toewijzen, het dan statisch is. De waarde kan niet worden gewijzigd. Als een object is veranderlijk dan is het dynamisch, wat betekent dat de waarde na het maken kan worden gewijzigd.
Laten we zeggen dat we een statische tekenreeks willen maken en het willen loggen. Hoe gaan we ermee om? In onze code zou het er ongeveer zo uitzien:
#importerenint main (int argc, const char * argv []) NSString * testString; testString = [[NSString alloc] init]; testString = @ "Hier is een testreeks in testString!"; NSLog (@ "testString:% @", testString); retourneer 0;
Ik heb dit bestand in XCode gemaakt door naar Bestand> Nieuw project> Mac OS X> Toepassing> Opdrachtregelhulpprogramma> Type: Stichting (nogal een reis!) en het bewerken van het bestand implementatie (extensie: .m) in het project.
Er zijn nogal wat dingen die nieuw zijn, dus laten we het stuk voor stuk onderzoeken.
Allereerst importeren we de foundationbibliotheek (dit komt omdat we het type eerder in het nieuwe projectvenster hebben gezet).
int main (int argc, const char * argv [])
Dit verklaart de initiële functie die wordt aangeroepen wanneer ons programma met de uitvoering begint. De twee parameters gescheiden door een komma zijn voor het doorgeven van argumenten aan onze applicatie. Maak je voorlopig geen zorgen over deze omdat we ze nu niet nodig hebben.
NSString * testString; testString = [[NSString alloc] init];
We maken nu een aanwijzer naar een NSString-object met de naam testString. Zodra de eerste regel hiervan is voltooid, bestaat er nog geen tekenreeks, alleen een verwijzing naar een tekenreeks die we nog niet hebben gemaakt. Op de volgende regel maken we de reeks waarnaar onze aanwijspunten verwijzen.
We hadden als alternatief de laatste zin als volgt kunnen schrijven;
testString = [NSString-allocatie]; [testString init];
Dit lijkt in het begin misschien een beetje verwarrend. In de eerste versie hebben we de statements tussen haakjes op dezelfde regel genest, terwijl we in de tweede de statements hebben gescheiden in twee regels. De methode init initialiseert alle instantievariabelen in de klasse.
testString = @ "Hier is een testreeks in testString!";
Deze regel spreekt voor zich, de reden dat we de aanhalingstekens met een @ -teken plaatsen is om de compiler te laten weten dat de volgende tekst een NSString is.
NSLog (@ "testString:% @", testString);
Hier loggen we wat informatie in om te troosten. XCode heeft een ingebouwde debugger die u kunt vinden in het menu Uitvoeren. Het is erg handig bij het ontwikkelen van een applicatie om te loggen wanneer gebeurtenissen plaatsvinden en de waarden van bepaalde variabelen - het kan helpen bij het oplossen van problemen met uw toepassing en het opsporen van fouten. Deze methode werkt als printf (onthoud vanaf de eerste week?) Waar we een reeks tekst met een vervangend teken leveren (% @ betekent een Objective-C-object).
Eindelijk geven we 0 terug, waarvan we weten dat het besturingssysteem gewoon vertelt dat de applicatie zonder problemen is geëindigd.
Weet je nog dat toen we onze NSString eerder maakten, we de methode init gebruikten? Nou NSMutableString, NSArray en in feite maakt elke NS-klasse ook gebruik van init. Lijkt veel verspilde code om de init-methode in elke klas te zetten, toch? Het zou zijn, dat is waarom init gewoonlijk maar één keer wordt geïmplementeerd, in de root-klasse die bekend staat als NSObject. Omdat klassen van elkaar overerven, krijgt een klasse die is gemaakt als een kind van een andere, bovenliggende klasse automatisch toegang tot de bovenliggende klassenmethoden.
Laten we NSMutableString bijvoorbeeld nemen. NSMutableString heeft NSString voor een ouder (waardoor het een kind wordt), wat betekent dat het van NSString wordt geërfd. Ondertussen. NSString heeft NSObject als ouder, dus erft van NSObject.
Dus bijvoorbeeld, NSObject heeft een methode genaamd init, dus elke subklasse heeft deze methode geïmplementeerd - wat een klassenmethode wordt genoemd. De init-methode in NSObject doet feitelijk eigenlijk niets, maar keert gewoon terug naar zichzelf. De reden hiervoor is dat methoden kunnen worden overschreven. De NSArray-klasse kan dus de init overschrijven die wordt geërft om er functionaliteit aan toe te voegen, zoals ervoor zorgen dat het geheugen beschikbaar is of eventuele instantievariabelen voorbereiden die het nodig heeft.
Zoals aangetoond, is dit nuttig omdat het betekent dat we naast het overerven van klassen ook klassen kunnen uitbreiden. Wanneer we een klasse uitbreiden, nemen we een bestaande klasse en voegen we extra functionaliteit toe aan wat al beschikbaar is. Dit betekent dat u uw eigen versie van NSString kunt maken met aanvullende methoden, zoals een methode om de tekenreeks te vullen met willekeurige tekst of een soort tekencodering uit te voeren.
Op dit punt moeten de fundamenten van hoe klassen werken duidelijk zijn. Om je bevattingsvermogen te testen, kijk of je de volgende vragen in gedachten kunt beantwoorden:
Omdat lessen een belangrijk onderdeel zijn van Objective-C, is het belangrijk om je echt prettig te voelen bij het werken met hen. Vorige week zijn we begonnen met het kijken naar lessen en deze week hebben we dieper ingegaan. Volgende week kun je blij zijn om te horen, we gaan weg van de theoretische kant en gaan werken aan onze eigen simpele klas of twee om eenvoudige taken uit te voeren.
Omdat we de theorie tot nu toe vooral hebben gedaan, is je huiswerk deze week om te surfen op de ontwikkelaarswebsite van Apple (je had dit vorige week moeten doen) en een aantal van de beschikbare lessen bekijken. Als u niet weet waar u moet beginnen, begin dan met iets als NSString. Je zult je meer op je gemak voelen met de details van de ouderklasse, de methoden, enzovoort. Dit zal later van belang zijn wanneer u lessen buiten deze reeks gebruikt en u wilt weten welke methoden zij overnemen of gebruiken.
We zullen volgende week meer praktisch worden met wat klassencodering. Klassen staan echt centraal in Objective-C, dus het is mega belangrijk dat je ze begrijpt en het doel van deze serie is om echt te zorgen dat je doet!
Zoals gewoonlijk, als je vragen of opmerkingen hebt, kun je me bereiken door een reactie of e-mail te verzenden. Als je persoonlijk contact met me wilt opnemen en een snel antwoord wilt ontvangen, stuur me dan een tweet!
Accentsconagua