[Powered by Google Translate] [Seminar] [iOS: Het schrijven van applicaties zoals een Boss]
[Tommy MacWilliam] [Harvard University]
[Dit is CS50.] [CS50.TV]
>> Oke, iedereen, welkom op iOS: Het schrijven van applicaties zoals een Boss.
Dit seminar zal zich richten op het schrijven van apps voor de iPhone
en op zijn beurt het schrijven van apps voor de iPad, en dus we eigenlijk gaan lopen door
een paar verschillende voorbeelden van hoe je een app te maken, een eenvoudig spel als Tic Tac Toe,
of als je meer geïnteresseerd in het maken van een app als een soort nieuwslezer
of iets dat interageert met het internet zal ik praten over dat ook.
Hier is onze korte agenda.
>> IOS apps zijn geschreven in een taal genaamd Objective-C,
en dit is wat vergelijkbaar C maar niet echt helemaal,
dus we zullen praten een beetje over de taal zelf
en vervolgens hoe de iPhone apps met behulp van deze app programma genaamd XCode te bouwen,
die als je nog niet gedownload het nog te voelen vrij om het downloaden te beginnen.
Het is meerdere gigabytes.
Het moet vrij zijn in de App Store, zodat je nodig hebt om een ​​Mac hebt
idealiter de nieuwste versie van OS X.
Als je niet, geen probleem.
We hebben Macs in het science center tot uw beschikking
met XCode geïnstalleerd, en dus voel je vrij om deze te gebruiken voor ontwikkeling.
Als u wilt een app te maken, maar niet beschikt over een Mac, maak je geen zorgen.
Er is genoeg campus middelen voor dat.
En dus dan gaan we 2 grotere voorbeelden van verschillende apps die u kunt maken te dekken.
Objective-C is technisch wat heet een super set van C.
Dat betekent dat elke C-code ook geldig is Objective-C code.
Dat betekent dat we soort van kanaal geplakt op een aantal extra functies aan C.
Sommige van deze functies zijn niet te hoeven nooit meer schrijven malloc, God zij dank,
geen zorgen te hoeven maken over die stomme pointers en te bevrijden en al dat spul
je haatte over C, en het is een soort van verdwenen in Objective-C.
>> Nu, Objective-C heeft ook een veel grotere standaard bibliotheek,
dus er is veel meer functionaliteit die je gratis krijgt binnenkant van Objective-C.
Weet je nog dat we het schrijven van PHP hebben we gemerkt dat we gingen van
deze kleinste taal om de reusachtige bibliotheek van al deze gekke dingen die je kunt doen.
Hetzelfde gebeurt in iOS.
Er is objecten voor dingen zoals de boeddhistische kalender, en echt iets
kun je eventueel denken aan waarschijnlijk bestaat reeds in de uitvoering Objective-C's.
Het doel deel van Objective-C is verwijzing naar iets
genaamd Object-Oriented Programming.
Dit is een soort van een nieuw concept, maar we hebben eigenlijk vooral geleerd
veel van deze concepten reeds.
Het idee achter Object-Oriented Programming is dat je gaat structureren
veel van uw code rond deze dingen genoemd klassen,
en deze klassen zijn erg verheerlijkt structs.
Binnenkant van een struct we eigenlijk zei hier is een ding,
en dit ding kan hebben leden.
Zo zou een knooppunt in een gekoppelde lijst andere dingen
als een waarde, een pointer naar het volgende knooppunt in de lijst,
en samen die wijzer en die waarde dit ene geval van een struct samengesteld.
De lessen zijn zeer vergelijkbaar, behalve
klassen kunnen ook functies in hen.
Wanneer we een struct verklaard, kunnen we alleen maar zeggen int n of knooppunt * volgende.
>> Nu met Objective-C kunnen we daadwerkelijk in functies
binnenkant van die dingen.
Een ander ding dat klassen kan doen is dat ze kunnen erven gegevens van andere klassen.
Bijvoorbeeld, zullen we kijken naar een stel ingebouwde Objective-C klassen.
Een van hen zou de klasse die de weergave voor een scherm staat te zijn,
en dus door te zeggen Ik wil mijn eigen mening te implementeren
we eigenlijk zeggen dat iemand bij Apple, waarschijnlijk echt aardige mensen,
schreef deze klasse voor mij, en het behandelt zaken zoals het weergeven van knoppen
of waardoor het scherm, en we zouden echt gepijnigd
naar alles, wat de functionaliteit zelf implementeren, en ga zo maar door simpelweg
erven gegevens kunnen we zeggen alles wat je deed in die klasse
Ik wil ook de binnenkant van mijn klas, en dan ga ik naar een aantal andere dingen te doen,
namelijk implementeren van een app.
Dat is wat dat woord betekent erfenis. We zien een meer concreet voorbeeld.
>> En tot slot, de sleutel met Object-Oriented Programming is dat
leidt tot data inkapseling.
In sommige van ons probleem stelt dat we zouden kunnen hebben deze grote, globale variabelen
en globals overal, en dat is hoe we zouden bijhouden van de staat.
Met lessen kunnen we beginnen met het inkapselen van informatie binnenkant van een object.
Als we een scherm op onze app, hebben we niet echt nodig om alle gegevens van zijn
een ander scherm in onze app binnenkant van die,
en zo door het inkapselen van dingen binnen klassen leidt dit eigenlijk
veel beter code design, en dit is mogelijk met enkele extra functies
van Objective-C.
Waarschuwen, de syntaxis voor Objective-C is bananen.
Het is alsof er niets we al eerder gezien,
dus het is een beetje een leercurve wennen
wat de heck betekent dit?
Maar als je eenmaal voorbij dat de eerste leercurve het is echt, echt glad
om te beginnen met het schrijven van apps.
>> Om een ​​klasse te verklaren, te zeggen is mijn klas, het bestaat,
en misschien hier zijn enkele dingen die ik ga later te definiëren,
Ik ga @-interface zeggen.
Ik ga @-interface zeggen. Ik ga mijn klas een naam te geven.
En dan later ergens anders ga ik @ end zeggen,
en alles wat daar tussen de @-interface en de @ end
gaat mijn klas zijn.
Dat gaat worden wat er in onze. H-bestanden.
Net als in C onze. H bestanden in feite gezegd hier zijn enkele dingen die zal bestaan.
Ik ben niet per se te vertellen wat ze nog doen,
maar de compiler moet weten dat ze bestaan.
Later binnenkant van onze. M-bestanden-omdat m voor Objective-C
is waar we daadwerkelijk gaat om te bepalen wat deze klassen doen.
Net als onze. C-bestanden, we voorzien een implementatie voor functies.
Binnenkant van onze. M. bestand gaan we hier zeggen is wat alle functies
binnenkant van mijn klas-wat ze allemaal doen.
En tenslotte, de binnenkant van een struct kunnen we binnen zeggen over de accolades
int n of knooppunt * volgende,
en in Objective-C gaan we het zoekwoord te gebruiken @ onroerend goed,
en dit is wat er aan de hand om de eigenschappen te definiëren,
of de niet-functies die een deel van mijn klassen.
>> Belfuncties in Objective-C is ook bananen.
Als we functies in C verklaard zeiden we iets als int foo
en open haakje en dan gaf het een lijst van argumenten.
Dit is wat verklaren methoden of functies lijkt in Objective-C.
Als ik wil een functie of een methode te verklaren
waar ik zeg methode is eigenlijk alleen maar een functie die is een lid van een klasse,
zo vriendelijk van verwisselbare, maar niet echt,
dus binnenkant van mijn methode wil ik een nieuwe methode te creëren.
Het gaat om niets terug, dus het gaat worden van het type nietig zijn.
Dit is de return type van mijn functie.
Nu hebben we parens hier omdat-ik weet het niet.
Volgende gaat naar de naam van mijn functie zijn,
en dan uiteindelijk hebben we een puntkomma, net als we in C.
Wat is hier nieuw is deze man hier.
Dit streepje is eigenlijk noodzakelijk, en wat dit zegt is dat
deze methode hier moet worden aangeroepen voor een instantie van een klasse.
>> Nadat we onze verklaard structs we waarschijnlijk iets gezegd als
struct knoop n, en dat eigenlijk gemaakt
of geïnstantieerd een van die structs zodat ik kon eigenlijk aan de slag
met wat er in het, dus dit streepje betekent dat we moeten
een instantie van de klasse net als wij geïnstantieerd dat struct
voordat we noemen deze methode op.
Als ik wil beginnen met het toevoegen argumenten om mijn methoden
het wordt nog meer bananen.
Hier is mijn methode naam.
Dan ga ik een dubbele punt te hebben, en na deze dubbele punt staat hier komt een aantal argumenten.
Deze methode houdt een argument.
Het type van het argument is een int, en de naam van dit argument
of de variabele die ik ga om te beginnen met de binnenkant van de methode wordt aangeroepen i.
Ook dit is methode. Het duurt een argument.
>> Als u wilt beginnen met het toevoegen van meer argumenten het wordt meer bananen
in dat wij deze dubbele punt, dat hier zegt, komt mijn lijst met argumenten.
Dit eerste argument is een geheel getal.
Nu, dit tweede argument is interessant.
De variabele die ik ga naar binnen worden met behulp van van mijn functie
heet f, dus binnenkant van mijn functie die ik zou kunnen zeggen
f + = 1 of iets dergelijks.
Dit ding hier is in feite een sleutel voor dat argument of parameter.
Net zoals we hadden de belangrijkste waarde-paren en iets als JSON of associatieve arrays
Objective-C de beslissing genomen om te zeggen, oke, gewoon zo dat het echt duidelijk
wanneer u belt een methode wat al deze parameters zijn
Ik ben eigenlijk ga ze allemaal op te noemen.
Wanneer u een methode aan te roepen, dan heb je eigenlijk zeggen andFloat,
en dan kom je langs het erin
>> Interessant is deze niet genoemd, maar alle andere parameters,
dus als we hadden een 3e argument dat ik zou kunnen zeggen andFloat
en een float enzovoort.
Toen ik deze methoden noemen is natuurlijk bananen,
dus als ik een voorwerp, en ik definieerde een methode genaamd foo,
en ik wil noemen, in plaats van te zeggen foo open / dicht Parens
Ik ga een beugel te openen.
Hier is de naam van mijn methode.
Ik ga aan de beugel te sluiten, en dit is het object Ik bel hem op.
Vergeet niet, al deze methoden bestaan ​​binnen klassen
omdat klassen kunnen hebben methoden die zijn gedefinieerd binnenkant van hen.
>> Hier heb ik willekeurig een object aangemaakt van bepaalde klasse,
en dit is de syntax om dat te doen.
Er zijn 2 doen om een ​​object.
De eerste stap is om te zeggen ik wil ruimte toewijzen.
Dit is het equivalent van een malloc. We hoeven niet meer te zeggen malloc.
We vallen de m, maakte het Alloc, en vervangen de. C met. M..
Nadat we Alloc iets wat we dan nodig om het te initialiseren.
In principe als je objecten maken wilt u misschien wat logica hebben
die wordt uitgevoerd wanneer ze zijn gemaakt, zodat je kan passeren in een aantal standaard waarden
of iets dergelijks, en dus is deze init methode is wat er werkelijk het object ontstaat.
We hebben eerst toe te wijzen ruimte, net zoals wij deden in C,
en dan initialiseren, die al dan niet een heleboel doen.
Dan zijn we terug dat ding in een object o.
Er is een ster hier, want dit is technisch gezien een pointer,
maar maak je geen zorgen, pointers zijn niet zo groot een deal in Objective-C meer.
>> Nu hebben we geïnstantieerd deze klasse met de naam NSObject,
en dit is slechts een willekeurige klasse die Apple heeft.
We hebben geïnstantieerd dit, en nu heb ik een instantie van deze klasse
in dit object o, dus dat betekent dat als ik bepaalde
deze methoden kon ik noem ze op deze manier.
Evenzo, als ik wilde een methode aan te roepen met een argument,
dus dit is de bar-methode, dat duurt een argument,
en hier is de baz: QHx methode, dus dit duurt 2 argumenten.
Dit roept een functie van dit object o.
Logisch?
De syntaxis moet zinvol zijn, maar je soort van wennen.
>> Oke, laten we praten over een paar dingen die zijn ingebouwd in Objective-C
die niet noodzakelijkerwijs ingebouwd C.
In C hebben we soort van te maken gehad met strings als die stomme personage arrays,
en het werd echt vervelend.
Objective-C heeft die allemaal gebouwd in voor ons, en het is gebouwd in
het gebruik van deze klasse met de naam NSString.
Als ik wil een NSString hebben we meer geheimzinnige syntax te creëren.
In plaats van te zeggen "CS50" zeggen we @ "CS50"
en dit is slechts de syntax voor de aangifte van strings in Objective-C.
Dit is zeer gemakkelijk om te vergeten, dus niet doen.
Nu, zodra ik heb dit, dit is een string, maar merkt
het is echt gewoon een object.
Ik zei NSString, wat betekent dat ik geïnstantieerd de klas
genaamd NSString, die iemand anders heeft geschreven voor mij,
en ze waren erg aardig over, en dus nu
Ik kan gaan bellen methoden op.
Als ik bel de methode lengte op dit object s
het gaat om terug te keren voor mij de lengte van de string.
Dit is net als strlen in C.
Dit zou terugkeren 4.
>> Ook een andere methode die ik zou willen geven om is dit characterAtIndex.
Dit is een methode die zegt op deze string s
Ik wil dat je de nulde teken te krijgen,
en dus dit zouden terugkeren om me het karakter c,
en er is een hele hoop meer van deze methoden die u kunt heel gemakkelijk Google.
Apple's documentatie is groot, en we zullen een kijkje nemen op dat in een beetje.
Dat zijn strings.
We hebben ook een variabele grootte arrays ingebouwd
Vergeet niet in C als we verklaarde een array
we moesten zeggen dat je 5 elementen, einde verhaal.
Toen we bij JavaScript en PHP kunnen we beginnen
om dingen te doen zoals het toevoegen van elementen of bewegende elementen.
We kunnen hetzelfde doen in Objective-C.
Dan een array in de normale manier C
hebben we weer een andere klasse NSMutableArray genoemd.
Er is ook NSArray,
en dit gaat in principe in te kapselen sommige array.
Dit zegt het eerste wat ik wil doen is wil ik wijzen
ruimte voor een nieuwe array, en nadat ik wijzen het
Vervolgens heb ik nodig om het te initialiseren.
Nogmaals, alleen het aanroepen van deze 2 methoden.
Nu betekent dat de binnenkant van dit object een
Ik heb een lege array zitten.
Als ik iets wil toevoegen aan deze reeks, kan ik bellen met de addObject methode.
Ik wil een object toe te voegen aan de array een, en ik wil de string CS50 toe te voegen.
Als ik wilde omgekeerd te verwijderen, dat ik kan zeggen dat ik wil
verwijder het voorwerp op de eerste plaats op de array of object een.
>> Logisch?
Oke, je soort van wennen aan deze vierkante haken ding.
By the way, de binnenkant van veel van Apple's bibliotheken zie je deze NS.
De NS staat eigenlijk voor de volgende stap, dat was een van Steve Jobs eerste bedrijven,
en dat is waar hij echt begon te schrijven een groot deel van de code
als een soort basis voor Mac OS X en alle andere dingen,
en dus is deze NS is een soort van deze mooie erfenis uit schreeuwen om een ​​van de eerdere bedrijven
toen Apple voor het eerst begon uit.
Het is overal.
Laten we eens een kijkje nemen op een meer holistische Objective-C bijvoorbeeld.
Hier ben ik de binnenkant van XCode.
Om hier te komen, heb ik eerst gedownload XCode uit de App Store,
opende het, en toen ging ik hier naar bestand,
hier om nieuwe, en dan project.
Nadat ik doen, opdat ik al deze opties van wat ik wil creëren,
en dus zullen we een kijkje nemen op deze opties later,
maar alleen voor dit voorbeeld, omdat we niet daadwerkelijk gaat om een ​​app nog,
Ik kwam hier, en ik zei: Command Line Tool,
en dit is een app die ik kon draaien op de opdrachtregel
net zoals we al die loopt van C.
Dat is hoe ik dit project gemaakt, en dus nu ben ik hier,
dus laten we eerst eens kijken naar dit bestand, en dit moeten kijken redelijk bekend.
Ik heb een int naam. Er is mijn vriend argc, mijn andere vriend argv.
En zo kunnen we zien dat dit het startpunt voor mijn eerste Objective-C toepassing.
Hier kunnen we negeren voor nu.
Dit is in principe een aantal geheugenbeheer dingen die je zal niet echt
ooit zorgen te maken over.
>> Laten we hier kijken naar deze eerste blok.
Deze eerste lijn, als ik zeg Student * alice = [[Student alloc] init] wat is dat nou?
Deze eerste student hier, dit is waarschijnlijk een klasse.
Dit is niet een klasse die Apple schreef, maar het is een klasse die ik geschreven heb.
Het eerste wat ik wil doen is wil ik ruimte voor een nieuwe student toe te wijzen,
en dan wil ik het initialiseren, dus dit geeft mij terug
Deze nieuwe student object, en ik ben het opslaan van deze in een variabele met de naam Alice.
Waar kwam die klasse vandaan?
Wel, hier aan de linkerkant zijn alle verschillende bestanden in mijn project.
We kunnen hier zien dat ik heb een Student.h en een Student.m.
Het. H bestand, vergeet niet, is waar ik verklaar alle dingen
dat zal bestaan ​​binnen de klasse.
>> Laten we eens een kijkje nemen op die.
Oke, hier hebben we dit @ interface, en deze zegt dat hier komt
de verklaringen van alles wat zal bestaan ​​in mijn klas.
Dan heb ik een dubbele punt. Dan heb ik dit NSObject ding.
Deze dubbele punt betekent dat erfenis beetje waren we een beetje vroeger te bespreken.
Dit zegt alles wat een NSObject kan doen
waar NSObject is deze klasse geschreven door iemand anders,
alles wat deze NSObject kan doen Ik wil in staat zijn om dat te doen.
Door te zeggen: NSObject dat betekent dat ik in principe
erfde alle functionaliteit van een andere klasse.
Dat gaf me echt een hele hoop verschillende methoden en eigenschappen die ik kan gebruiken.
Hier beneden Ik ben het creëren van 2 woningen.
Dat betekent dat mijn student, als dit een struct, zouden dit de 2 dingen
binnenkant van mijn struct, zodat elke student heeft een naam
dat is een string, en een student heeft ook een graad,
die een int.
>> Tot slot, hier beneden Ik ga op een werkwijze voor mijn student te creëren.
Ik belde mijn methode, initWithName, en het duurt een argument,
en dat argument is een string, en ik noemde het noemen.
Laten we nu eens kijken hoe we daadwerkelijk geïmplementeerd deze klasse.
Hier, nu ben ik de binnenkant van mijn. M-bestand,
m voor de uitvoering, denk ik.
Ik heb mijn implementatie, mijn einde, en hier is waar ik eigenlijk het definiëren van
initWithName wat doet.
Ik heb initWithName, de naam van mijn parameter, en dit
is waar ik eigenlijk het creëren van een student,
en dus dit is een beetje cryptisch, maar dit is een soort van standaardtekst
die u wilt opnemen in uw constructeurs.
Deze initialisatie functie hier, initWithName, is een soort constructor.
Je bent in principe de bouw van een nieuwe leerling object
en misschien het verzenden van een aantal gegevens binnen van het.
Het eerste wat ik wil doen is wil ik noemen init op deze super ding.
>> Vergeet niet dat toen ik zei dat hier in de. H-bestand
dat alles een NSObject heeft een student ook.
Dat betekent dat als ik een leerling wat ik ook moet doen is het creëren
Zorg ervoor dat de NSObject dat ik al die gegevens erven van
Ook correct geïnitialiseerd.
Wat ik nodig heb te zeggen is dit super er werkelijk gaande is te verwijzen naar de bovenliggende klasse
dat ik geërfd uit, dus ik wil zeker weten dat ik initialiseren
alles wat ik ben afhankelijk van voordat ik begin te proberen om het te gebruiken.
Als dat dan geïnitialiseerd goed dit is net als zeggen dat als malloc
kwam niet terug null dan kan ik beginnen met het instellen een aantal eigenschappen.
>> In JavaScript en PHP we hadden dit trefwoord noemde dit,
en dit verwees naar de huidige instantie van een klasse.
In Objective-C noemen we dit zelf.
Als ik self.name zeggen, dat betekent dat het object
Ik heb zojuist, toen ik zei student Alloc init,
dat gaat mij terug te geven een object.
Dat betekent dat ik wil de naam van dat object instellen
naar wat ik gewoon voorbij inch
Net als in C, we toegang tot de leden met deze stip,
dus self.name zegt dat de naam van de student object
gaat nu zijn wat je gewoon voorbij inch
En dus eindelijk, kan ik deze retourneren zodat ik ook echt iets terug.
>> Vragen?
Oke, dus dit zelf = super init,
als je het niet helemaal begrijpt de erfenis dingen maak je geen zorgen.
Weet gewoon dat als je ooit wilt uw eigen init methode maken net
dat te doen, en je zult goed om te gaan.
Ja. >> [Student] Wat doet als zelf in?
Dit betekent dat wanneer we malloc iets wat we altijd gecontroleerd of het was gelijk aan null,
en als het null, dan verlaten.
Dit is hetzelfde, want als deze retourneert nul, dan zijn we waarschijnlijk gaan seg fout
als we beginnen proberen te manipuleren.
Dat is onze student klas.
Dat betekent dat we kunnen onze studenten initialiseren in een van twee manieren.
Als ik zeg student alloc init Ik ben niet met behulp van die methode die ik net schreef,
en in plaats daarvan kan ik alleen maar zeggen alice.name,
en nu ga ik die eigenschap in te stellen.
>> Evenzo, als ik wil dat initWithName methode te gebruiken
Ik kan alleen maar zeggen Alloc, en dan in plaats van te zeggen init
Ik ga die methode die ik zojuist te bellen, en ik ga pas in Bob.
Op dit punt, dit object Bob een naam gelijk aan Bob.
Oke, hier beneden Ik gebruik dat NSMutableArray dat we eerder hebben bekeken.
Ik ben toewijzing space.Then ik het initialiseren van een nieuwe array.
Ik ga 2 dingen aan toe te voegen.
Deze array heeft nu student daartegen bezwaar heeft.
Merk op dat nergens heb ik moet zeggen dat dit is een array van studenten.
Ik zei dat het een array, periode.
Dan kan ik zetten wat de binnenkant van het dat ik wil.
Hier heb ik 2 objecten.
>> Tot slot, ik heb een ander object hier, dit TF.
Hier in TF.h in principe hetzelfde.
Ik erven van NSObject, en door de manier,
wanneer je lessen maakt dit alles voor u gedaan,
dit soort interface standaardtekst.
Het heeft een eigenschap van leerlingen.
Ik heb een paar methoden die hier die niet echt heel veel,
en dus dat betekent dat nadat ik deze TF-object te maken
Ik kan deze methode aanroepen cijfer op het zo.
Hebt u vragen over Objective-C syntax voordat we beginnen te bewegen in een aantal meer
interessante apps ontwikkeling spullen?
>> Oke, dus laten we eigenlijk een iPhone app te maken.
De kern klassen die u zult binnen worden met behulp van uw iPhone app heten uitzicht controllers,
en een uitzicht controller vormt in feite een enkel scherm
binnenkant van uw app, dus als ik op de muziek app, bijvoorbeeld,
een weergave controller kunnen vertegenwoordigen de weergave waarin ik alle nummers bekijken op mijn iPhone.
Een andere kijk controller zou kunnen zijn als ik op een liedje en beginnen te spelen
of zoals ik het boren naar beneden in kunstenaars.
Elk van de verschillende schermen kan worden weergegeven als een anders controller,
en een uitzicht controller is eigenlijk gewoon een klasse die zegt hoe dit scherm werkt.
Dingen binnenkant van het oog controller, gaan we eigenschappen hebben,
dus dingen als een knop gaat een eigenschap van onze visie controller.
>> We zijn ook gaan om methoden te hebben, en deze zijn in principe event handlers.
Deze methode zegt dat wanneer u op deze knop drukt
Ik wil iets doen, en tot slot, nogmaals,
we gaan worden met behulp van deze zelf sleutelwoord om de huidige instantie te openen.
Om interfaces te bouwen in iOS is eigenlijk heel, heel gemakkelijk.
Ze hebben deze mooie drag-and-drop interface genaamd Interface Builder,
en de 2 kernbegrippen die draad-up van uw Objective-C Interface Builder
zijn IBOutlet en IBAction.
Een IBOutlet zegt gewoon dat als je een eigenschap die is een knop te verklaren,
en u wilt het aansluiten op iets in uw huidige UI,
je gaat zeggen dat het een stopcontact.
Evenzo, als je wilt om een ​​event handler te vertegenwoordigen
dan ga je zeggen dat het een actie.
>> Om daadwerkelijk bedraden dit grafische weergave
en uw code het is echt, echt eenvoudig.
Als u een IBOutlet bevestigen, alles wat je hoeft te doen is je controle klik,
en we zullen zien een voorbeeld van deze echt snel.
Je bestuurt op de plaats waar het zegt View Controller.
Je gaat slepen in de interface, of omgekeerd,
als je wilt aansluiten een event handler je gaat slepen van de interface
in de andere richting.
Laten we eens een kijkje nemen op een heel eenvoudige iOS voorbeeld.
>> Laten we een nieuw project.
Ik ga hier te komen naar toepassing,
en ik ga Single View Application klikken.
Ik ga naar de volgende klik. Ik zal mijn project een naam te geven.
Ik noem het Hello.
Interessant is dat Apple aanvaardt u een product creëren
zodat u kunt verkopen en ze kunnen geld verdienen.
Hier beneden Ik ga zeggen dat dit een iPhone app.
U kunt een iPad app, of als u wilt een van deze apps te maken
die ondersteuning biedt voor beide apparaten kunt u ook doen.
Dit zijn wat je wilt dat je vinkjes te lijken.
>> U wilt storyboards, die we later zullen zien gebruiken,
en u zeker wilt automatische reference counting te gebruiken,
dat is een leuke feature die voorkomt dat je hoeft te zeggen malloc en free.
Tenzij je wilt bellen malloc en gratis, zou ik laat dit aangevinkt.
Ik zal volgende klik, en ten slotte, dit gaat om te vragen waar ik het wilt opslaan.
Ik raakte te maken, en daar gaan we.
Ik heb een nieuw project.
Hier aan de linkerkant zijn alle bestanden die zijn binnenkant van mijn project,
en merk dat ik een hele hoop gekregen, en ik heb niet eens iets doen.
IOS is geweldig.
>> Bijvoorbeeld, hier deze ViewController.h,
dit wordt mijn eerste opvatting controller vertegenwoordigen,
dus het eerste scherm binnenkant van mijn app.
Nu weten we wat deze zegt.
We zeggen dat ik deze klasse ViewController bellen,
en een ViewController doet alles wat een UIViewController doet,
en dit, nogmaals, is enige klasse die Apple schreef dat doet veel handige dingen voor ons
graag weer te geven op het scherm.
Hier is waar ik eigenlijk kan beginnen te definiëren wat mij controller doet,
en het blijkt dat ik echt niet nodig een van deze.
Dit is boilerplate code dat Apple mij geeft gratis.
Ik heb nodig dat eerste regel, of ik heb geen klasse,
dus we kunnen ontdoen van die en zich te ontdoen van deze.
Oke, dus dit is mijn lege scherm.
>> Laten we nu eens klikken op deze MainStoryboard.storyboard,
en dit is waar het interessant begint te worden.
Dit is de eerste scherm op mijn app.
Als ik wil een knop toe te voegen, in HTML moest ik een knop label aan te maken.
In Android moet je een knop tag te maken,
maar in iOS als ik gewoon hier te komen tot op de bodem rechts
en als ik hier op deze 3de waar het zegt Objects,
en ik kan naar beneden scrollen, of ik kan beginnen met zoeken naar de knop.
En kijk, een knop, dus als ik eigenlijk slepen en daar neer dit recht,
Ik heb net een toets om dit scherm op mijn app.
Als ik de tekst wilt wijzigen, kan ik dubbelklik erop,
iets zeggen verleidelijke als "Druk op Mij."
Oke, nu als ik zonder deze app, dus we compileren,
dus om het te draaien ik op de play knop in de linkerbovenhoek, en daar is mijn app.
Ik heb niks gedaan, en ik kreeg een lief zoekt iPhone app.
Als ik wil om het te stoppen, klikt u op de stop-knop
want het is leuker.
>> Laten we zeggen dat ik eigenlijk iets te gebeuren als ik op deze knop wilt.
Om dat te doen wat ik moet doen is dat ik moet maken
een nieuwe event-handler of een actie.
Dat betekent dat ik moet een methode die ik wil noemen creëren
als ik op de knop drukt, dus laten we een nieuwe methode.
Ik ben binnenkant van ViewController.h.
Ik moet zeggen dat een methode bestaat.
Ik heb een koppelteken eerste omdat ik ga moeten bellen dit op het uitzicht controller.
Ik moet geven deze een type.
Het type van deze gaat dat IBAction ding dat we eerder zagen zijn.
Dit is een event handler, dus het gaat om een ​​IBAction terug te keren,
en dit is een hint voor XCode om te zeggen dat
dit is iets wat ik wil iets draad aan.
Ik kan het een naam geven, zoals buttonPressed, puntkomma.
>> Nu heb ik uitgeroepen tot een nieuwe methode binnenkant van mijn klas.
Ik heb gezegd deze methode te bestaan.
Laten we nu eens komen ViewController.m,
en laten we zeggen wat deze methode kan doen.
Als ik begin te typen, bijvoorbeeld, (void) buttonPressed
aankondiging XCode is echt mooi en autocompletes voor mij.
Dat is echt geweldig.
Let hier op dat de binnenkant van de. M. bestand dat ik ook kan leegte zeggen,
en dit is omdat dat IBAction is niet echt een type.
Het is eigenlijk hashtag ergens gedefinieerd als een nietig,
en nogmaals, dit is slechts een hint naar XCode dat zegt
Ik wil dat dit een event handler te zijn, en we zullen zien waarom in slechts een seconde.
Wanneer deze toets wordt ingedrukt, Ik ga iets vervelend doen
graag weer een popup.
>> Om dat te doen kan ik een nieuwe instantie van deze klasse met de naam UIAlertView te creëren,
en dit is een klasse die Apple schreef dat gaat vervelende pop-ups weer te geven.
We noemen dit popup alert, en ik heb 2 stappen, vergeet niet, tot het creëren van dit object.
Het eerste wat ik moet doen is toe te wijzen ruimte.
Ik wil een UIAlertView.
Ik wil ruimte toewijzen. Dat is mijn eerste methode.
Mijn volgende methode is wil ik het initialiseren,
en dus heb ik deze grote, lange methode genaamd initWithTitle.
Dat is in principe gaat om te bepalen wat deze popup zegt.
De titel van mijn popup kan hello.
De boodschap van deze popup kan worden: "Dit is iOS."
Afgevaardigde ding, ik weet niet wat dat is.
Laten we zeggen dat het niets is.
Nu is de knop die gaat verschijnen kan iets zeggen als "Het is zeker,"
en ik heb niet echt wil geen andere knoppen, dus laten we verwijderen dat en sluit de beugel.
>> Oke, heb ik een extra is. Daar gaan we dan.
Dit is hoe ik kan een nieuwe popup.
Als ik wil eigenlijk tonen de popup Ik wil de show methode aan te roepen.
Om dat te doen kan ik alert en show zeggen,
en nogmaals, autocomplete was super leuk.
Als ik ben vergeten wat dat was, als ik getypt in s,
Ik kan hier bladeren door om erachter te komen wat het was,
en het filtert mooi.
Nu heb ik deze nieuwe pop-up.
We zullen later terugkomen op wat afgevaardigde betekent,
en nu wil ik zeggen dat ik wil deze methode worden ontslagen
als ik op de knop drukt, dus ik ga om terug te komen op mijn storyboard,
en ik wil nu bevestigen dit IBAction.
Het eerste wat je wilt doen is op de knop.
Als ik op deze knop drukt Ik wil dat er iets gebeurt.
Ik ga niet ingedrukt te houden controle.
Ik ga om te klikken en op de button te slepen
tot meer dan hier, waar het zegt View Controller.
We kunnen zien dat het mooi oplicht.
>> Als ik laat gaan met mijn muis heb ik nu deze pop-up meer dan hier, waar ik een aantal opties.
Een van deze is de gebeurtenissen die ik kan registreren.
Dit zijn allemaal van die methoden verklaarde ik in mijn h bestand als IBActions.
Dit is hoe XCode weet wat moet worden weergegeven in deze kleine lijst,
dus dat is gewoon een hint.
Als ik klik op de knop gedrukt, heb ik nu geregistreerd de gebeurtenis-handler.
In JavaScript moesten we zeggen dat ik een aantal code die de gebeurtenis-handler geregistreerd.
In Objective-C was het echt zo makkelijk.
Als ik zonder dit weer
nu als ik op de knop druk mijn event handler gaat ontslaan,
en ik ga om dit popup.
Super, super eenvoudig daar.
>> Als je ooit wilt alle van de gebeurtenissen die worden geregistreerd zien
op een component als ik klik op deze knop
en ik kom hier naar de rechterkant
eerst moet je hier kunt zien dan kan ik dingen doen, zoals het type van de knop,
dus als je wilt een van die I's of de add contact knop
of wat dan ook.
Als ik wil alle van de gebeurtenissen die zich op deze knop te zien
als ik kom helemaal hier naar de rechterkant
kunnen we hier zien op de gebeurtenissen die ik heb al deze verschillende evenementen.
Ik kan op de knop drukt, laat ik de knop los, toen ik tik verdubbelen of wat dan ook,
en degene die ik net ingeschreven is dit evenement genaamd Touch Inside Up,
en dit zegt dat zodra mijn vinger komt uit de knop
dat geval gaat om brand, en dat is precies wat er net gebeurd.
Dit is een soort van de standaard knop ingedrukt evenement.
>> Eventuele vragen tot nu toe?
Oke, dat is hoe we kunnen beginnen met bedraden dingen in onze code
in dingen binnenkant van onze interface.
Vergeet niet het eerste wat we moesten doen was om de code te vinden,
en dan hebben we bedraad de interface naar de code,
en er is onze eerste app.
Oke, dat was echt cool, en hebben we op deze knop.
Wat als we niet willen hebben om een ​​bos van eigenschappen te creëren
vertegenwoordigen deze knoppen?
Bijvoorbeeld, in Tic Tac Toe Ik heb 9 knoppen,
en het zou super, super vervelend om te slepen en neerzetten 9 keer
of als ik moest Tic Tac Toe te maken met 81 in plaats van 9
en ik moest slepen en 81 keer laten vallen, en dat is lame.
Wat we wel kunnen doen in plaats is net als een HTML-
toen we dingen als ID's en namen en we kunnen zoeken naar dingen
door hun ID, is er een soortgelijke gedachte in iOS tags genoemd.
>> Een tag is gewoon een unieke numerieke identificatie van een component.
Als ik zeggen dat dit een tag van 0 bijvoorbeeld
Als ik een knop en geef het een label van 0, en we zullen zien hoe dat te doen in slechts een seconde,
als ik wil die knop krijg ik kan alleen maar zeggen dat ik wil bellen
de viewWithTag methode op het object hier,
de self.view, dat het huidige scherm staat, bijvoorbeeld.
Als ik noem dat viewWithTag methode, ik ga terug te trekken op de knop met tag 0.
Laten we eens een kijkje nemen op dit door het bouwen van Tic Tac Toe.
Ten eerste, dit is mijn storyboard.
Ik heb gemaakt deze 10 UI knoppen.
Let op ze zijn allemaal even groot.
Als ik op een van deze en ik kom terug hier op deze rechts
je zult zien dat ik het lettertype aangepast hier, dus maakte ik het lettertype iets groter,
maar wat ik ook deed, was ik deze tag.
Ik zei dat dit een tag van 1 heeft, en dat is de linkerbovenhoek.
>> Nu, als ik klik op een andere knop, zoals deze tweede hier,
nu zal je zien dat mijn tag is 2.
Elk van deze knoppen heeft alleen een unieke tag,
en dus dit wordt later hoe ik ga beginnen interactie
met mijn app.
Dit is allemaal binnenkant van een view controller,
maar hier is wat we hebben.
Wij hebben 3 woningen hier.
De eerste en de laatste gaan naar de toestand van mijn bord te vertegenwoordigen.
In principe is dit eerste is een array die waar de X'en en O's zijn.
Deze andere vertelt ons wiens beurt het is.
U zult merken dat ik ook deze dingen hier.
Toen we eigenschappen die zijn gedeclareerd gaven we ze een naam en een type.
We kunnen ook geven ze wat extra informatie hier.
Deze eerste zegt nonatomic, en wat dit zegt
is in principe maar een ding ooit zal proberen om deze variabele te openen op een moment.
Je zou kunnen doen meer complexe toepassingen die zijn multi-threaded,
en zo terug in de Scratch hadden we verschillende draden,
en verschillende sprites zou kunnen doen verschillende dingen op hetzelfde moment.
>> Als dat niet het geval is, wat niet het is in alles wat we kijken naar,
als we zeggen nonatomic het is daadwerkelijk gaat om dingen een beetje sneller.
Wij hebben ook dit ding genaamd toewijzen, sterk of zwak.
Toewijzen Dit zegt alleen dat dit een standaard type.
Dit is niet een object of een pointer, want dit is gewoon een bool,
dus bool is ingebouwd in Objective-C.
Dit zegt niet proberen om iets bijzonders met pointers hier doen.
Het is een gewone oude scaler.
Sterke en zwakke, deze zwakke zegt dat eigenlijk
Ik wil dat dit te wijzen op iets in de weergave controller.
Ik ben niet van plan om daadwerkelijk toe te wijzen of init dit zelf.
De interface builder, toen ik de app draaien, gaat alles wat initialisatie af te handelen.
Als ik zeg zwak, dat zegt iemand anders zal worden het creëren van deze.
Als ik zeg sterk, deze zegt dat ik ga de een
dat is het creëren van dit board object,
en dus hier heb ik wat meer methoden hier,
bijvoorbeeld een actie voor wanneer de nieuwe game wordt ingedrukt,
een actie voor als een van de andere knoppen worden ingedrukt,
en et cetera.
>> We gaan nu niet in te veel van de logica van Tic Tac Toe,
hoewel het heel spannend, maar laten we een kijkje nemen op
sommige van de dingen die we kunnen doen binnenkant van iOS.
Deze nieuwe methode spel zal worden ontslagen
wanneer ik op de nieuwe game te drukken.
Aan te sluiten, dat op de voor mij overkomen naar mijn storyboard.
Ik klikte op nieuw spel.
Als ik hier aan het juiste ik kan zien dat
Touch Up Binnen is aangesloten op de NewGame methode.
Dat is de reden waarom dit is, word je ontslagen.
De NewGame methode gaat een aantal set-up te doen.
Het zal zeggen dat ik wil dat je de staat van het bord te verwijderen.
Dit is een mooie methode op veranderlijk arrays.
Dit gaat zeggen dat het nu X aan de beurt,
en nu ga ik om te profiteren van deze viewWithTag ding.
>> Ik weet dat mijn knoppen hebben de tags 1-9,
en dat is iets wat ik willekeurig geplukt.
Als ik de tekst van de knop ingesteld op leeg
omdat ik net begonnen met een nieuw spel en ik wil geen
Xs of O om over te laten dan ik dit kan doen.
Ik kan zeggen ik wil het uitzicht met de tag, 1, 2, 3, 4 et cetera.
Dit zal een andere knop te trekken elke keer.
Hier ga ik te werpen UIButton.
Net zoals we konden uitbrengen ints naar praalwagens en vice versa
Dit zegt dat ik wil dit gegoten om een ​​UIButton.
Dat betekent dat het van dit type zal een UIButton * zijn
als gevolg van pointers, maar maak je geen zorgen, ze zijn niet eng meer.
>> Zodra ik heb op deze knop ga ik een methode aan te roepen op.
Deze methode heet setTitle forState, en dus is deze zegt
Ik wil de tekst van de knop ingesteld op de lege tekenreeks zijn,
en ik wil het aan de lege string als hij niet ingedrukt zijn.
Als ik met behulp van deze methode, kan ik de tekst van de knop
zodra iemand je slaat, maar we willen zeggen wanneer de knop net zit daar
Ik wil de tekst leeg te zijn.
Tot slot, we gaan mijn board te initialiseren,
en ik ga om te zeggen dat alles op dit moment is op 0,
dus dit bestuursleden onveranderlijk is een veranderlijk array,
wat betekent dat ik kan bellen met de addObject methode en slechts een 0 binnenkant van het.
Dat is wat er gebeurt als ik een nieuw spel.
>> Laten we eens een kijkje nemen op een andere.
Deze methode is hier de IBAction die gaat worden ingedrukt
telkens een van die vlakken gedrukt.
Nu hebben we een aantal Tic Tac Toe logica hier.
We erachter te komen die aan de beurt is,
en op basis van dat we ofwel een X of een O in te stellen,
maar we merken dat we deze zelfde event handler te hergebruiken
voor elk van deze knoppen.
Dat betekent dat ik niet over een methode voor de knop linksboven,
een andere methode voor de knop rechtsonder, hoewel ik zou kunnen hebben gedaan.
Dat zou niet echt een goed ontwerp.
Wat ik hier doe is dat ik eigenlijk aan de hand om vast te stellen
wat de tag van de knop die is ingedrukt is.
Je merkt dat dit spel methode een argument neemt.
Het heet afzender, en wat afzender wordt afzender gaat
vertegenwoordigen precies wat er actie op.
Als ik op een knop drukt, wordt deze afzender plan te zijn dat UIButton
dat ik eigenlijk gedrukt, dus dat betekent dat UIButton
heeft een tag, omdat ik een tag.
>> Als ik wil krijgen op de tag kan ik alleen maar zeggen
Ik wil dat de tag van de afzender,
en nogmaals, ik heb net gegoten naar een UIButton.
Ik weet toevallig dat de afzender een UIButton zijn.
Het is niet altijd een UIButton zijn.
Ik kon bijvoorbeeld Registreer hetzelfde event handler
voor een voor een knop, een voor een schuif.
In dit geval, ik weet dat ze alle knoppen, dus ik ga zeggen
Ik wil dat dit een knop te zijn, en dan kan ik de tag krijgen,
en van de tag ik nu weet waar ik ben binnenkant van de raad van bestuur.
Dan kan ik gewoon kiezen of u de X of de O, kan het de beurt spiegelen,
controleren wie, et cetera gewonnen.
>> Eventuele vragen over deze tot nu toe?
Oke, de code die we online geplaatst: we willen niet te diep in
van de Tic Tac Toe logica, maar nu kun je dat echt zien
alles wat we doen is dat we een lus over deze array,
dus we hebben een paar voor loops hier, en we zijn gewoon te vergelijken om te zien
hebben we een wedstrijd in alle rijen, een wedstrijd in een kolom of iets dergelijks.
Om daadwerkelijk uitvoeren van deze app, als ik tik op een van deze knoppen
dat spel methode in brand werd gestoken, dus dat betekent dat ik gewoon te stellen
de knop om een ​​X, dus nu deze knop zal een O, enzovoort,
en dus dat is hoe we beginnen om te interageren met deze enkele pagina app.
>> We zullen de code plaatsen, dus voel je vrij om die inzage,
maar laten we nu praten over een aantal apps die meer dan slechts een pagina.
Zo spannend als Tic Tac Toe was, een heleboel apps binnenkant van iOS
zijn een soort van deze drill down dingen met meerdere schermen.
Het eerste concept dat we moeten praten over zijn protocollen,
en een protocol is gewoon een reeks methoden
die u kunt beloven te definiëren.
Als ik maken van dit nieuwe protocol met 2 methoden, deze eerste,
als de return type is nietig, ik noemde het foo.
Het heeft geen argumenten. Ik heb een andere methode.
Het geeft een int. Ik noemde het blokkeren, en het duurt een argument.
Dit alles protocol is dat is SomeProtocol heet hier op,
Dit is een set van dingen die iemand kan implementeren.
Ik heb niet de binnenkant van dit protocol gezegd wat foo doet.
In plaats daarvan, ik ben gewoon zeggen dat je kon foo definiëren als u wilt.
Als ik u een weergave-controller of het creëren van een klasse
Ik kan de binnenkant van die klasse belofte uit te voeren
Sommige van deze methoden, dus bijvoorbeeld als zeggen
Dit zegt nu ben ik een belofte maken voor u dat binnen
van deze visie controller class zal ik definities voor zowel foo en bar.
>> Waarom is dat nuttig?
Veel onderdelen in van iOS gebruik maken van deze
ontwerp patroon genaamd delegatie, en wat delegatie zegt
is dat, bijvoorbeeld, als ik een tekstvak
en er zijn enkele gebeurtenissen die zouden kunnen worden geregistreerd binnenkant van mijn tekstvak,
in plaats van het creëren van afzonderlijke gebeurtenissen wat ik kan doen is wat ik kan zeggen
de afgevaardigde van dit tekstvak wordt een object zijn.
Als ik zeg dat dit nu een afgevaardigde dat betekent dat
wanneer een bepaalde gebeurtenis zou zijn ontslagen in het tekstvak
in plaats van te moeten of iets dergelijks te registreren
het is gewoon gaat om een ​​methode aan te roepen op de gemachtigde.
Bijvoorbeeld, binnenkant van mijn tekstvak heb ik een methode voor wanneer ik op
dat gebeurt knop in de rechter,
en dus in plaats van het registreren van gebeurtenis-handler wat ik kan zeggen is
tekstvak, hier is een object dat ik wil dat je een methode een beroep doen op
elke keer dat iemand drukt op de knop Gereed,
en dat betekent dat het object moet het uitvoeren van sommige protocol
dat zegt dat ik beloof dat gedaan knop actie te definiëren,
want als het niet definiëren die methode en je druk op Gereed,
dan is het gaat worden verwarrend.
>> Laten we eens een kijkje nemen op een voorbeeld.
Hier heb ik gewoon nog een tekstvak,
en een van de eigenschappen van dit tekstvak hier op deze rechterkant is de gemachtigde.
Dit is een eigenschap van de klasse.
Wat ik deed is hier ik controle klikte, en ik sleepte vanaf deze plek hier
om de weergave-controller, en dat zegt nu de afgevaardigde van dit tekstvak
gaat om de weergave-controller is.
Dat wil zeggen dat een acties gebeuren, dan registreren
aparte event handlers Ik wil dat je om ze te sturen aan de gemachtigde.
Laten we nu eens een kijkje op mijn ogen controller.
Binnenkant van de. H-bestand Ik heb een belofte gedaan.
Ik heb beloofd om een ​​aantal methoden toe te passen binnenkant van dit protocol
riep UITextFieldDelegate, en opnieuw,
dit is gewoon een lijst met een aantal dingen die ik kan kiezen om uit te voeren.
>> Als ik hier in mijn. M-bestand, heb ik geïmplementeerd een dergelijke methode.
Ik heb noemde het textFieldShouldReturn
want dat is wat het werd genoemd binnenkant van het protocol.
En nu wanneer ik op de knop Gereed binnenkant van dat tekstveld
dit is wat er gaat gecalled, dus ik heb niet te registreren op het event handler.
Ik heb de afgevaardigde, en wanneer deze gebeurtenis wordt ontslagen
Dit is de methode die wordt gecalled, dus als ik hier kom naar mijn storyboard en voer het uit-
terwijl dat is geladen kunnen we zien wat dit doet.
Op mijn scherm heb ik 2 dingen.
Ik heb dit tekstveld, en ik heb dit label.
Ik ben gewoon te zeggen ik wil dat de tekst van dit label
gelijk aan wat de gebruiker heeft ingevoerd in binnenkant van het tekstveld.
Deze volgende regel hier is gewoon een methode die ik bel
op het tekstveld dat zegt dat ik wil dat je het toetsenbord te verbergen.
Dit is slechts de willekeurige methode die Apple heeft gekozen.
>> Nogmaals, voordat ik deed wat ik moest alles bedraden, dus ik kwam voor het eerst hier.
Vanuit het standpunt controller sleep ik naar het tekstvak.
Ik liet gaan, en ik kan hier zien dat ik kan dit het tekstveld eigendom te maken
omdat hier in het uitzicht controller die ik heb gedefinieerd een woning
dat is een IBOutlet van een tekstveld.
Deze zegt dat ik kan deze eigenschap bedraden
aan een tekstveld in mijn UI.
Nu als ik dit op kan ik beginnen met typen.
Nu als ik klik op de knop Klaar dit gaat ontslaan
een gebeurtenis die ik nu kan reageren.
Geen event handlers.
Dat is hoe ik gereageerd op deze knop Gereed.
Logisch?
>> Dit is niet een ontwerp patroon dat-je misschien niet ooit merkt dat je
het maken van uw eigen protocol, maar weet gewoon dat sommige
verschillende iOS componenten te registreren gebeurtenissen op verschillende manieren.
Knoppen, bijvoorbeeld, gebruik deze IBActions.
Tekstvelden, daarentegen, gaat personen gebruiken.
We kunnen zien en je kunt kijken dat alles tot de binnenkant van de documentatie.
By the way, is er eigenlijk een ton van de UI dingen ingebouwd in iOS voor u,
dus bijvoorbeeld, de manier waarop ik maakte dat zeggen gedaan aan de onderkant rechts
is Ik kan dit tekstveld.
Ik kwam hier.
Ik gescrold een beetje de belangrijkste terug te keren,
en ik kan eigenlijk maken dit een hele hoop dingen, zoals als ik wil dat zeggen
noodoproep plaats ik dat kan doen, dat is volstrekt willekeurig,
en ik weet niet waarom er een ingebouwde alarmtoets te drukken,
maar daar, er staat noodoproep in heel kleine letters.
Daar ga je.
>> Zeker verkennen al deze verschillende opties in iOS.
Hebt u vragen over gedelegeerden?
Nogmaals, alleen een interessant ontwerp patroon dat u moet zich bewust zijn van.
Oke, laten we vervolgens een kijkje op tafel uitzicht op te nemen.
Een tabelweergave is in feite de lijst met items die overal in iOS.
Als je bladert door al uw contacten, bent u op zoek naar
de instelling pagina, en dat soort lijst van dingen wordt een tabelweergave.
Het implementeren van een tabelweergave in iOS is vrij eenvoudig.
In plaats van het maken van een klasse die stamt uit die UIViewController
zoals we hebben gedaan voordat we moeten gewoon om te zeggen in plaats van
alles wat een UIViewController doet wat ik wil doen,
Ik zeg alles wat een UITableViewController doet wat ik wil doen,
zodat voegt gewoon wat extra dingen die helemaal klaar zijn voor ons.
We moeten heel weinig om in principe Vul in binnenkant van de tafel doen.
>> Om een ​​tabel Ik moet een aantal vragen te beantwoorden geven.
De eerste vraag die ik moet beantwoorden is hoeveel secties in de tabel?
Wanneer u bladert door uw contacten app zul je merken dat het is een soort van
georganiseerd door de As, dan heb je de B's, en je hebt dat kleine sub-header.
Elk van deze wordt een sectie.
Je kan wel of deze niet nodig.
Het eerste wat je hoeft te doen is implementatie van een methode
riep TableView: numberOfSectionsInTableView.
Dat geeft alleen maar aan hoeveel secties je hebt,
dus dit zou kunnen zeggen een keer terug als je er een grote tafel uitzicht.
De volgende vraag die iOS moet weten is hoeveel rijen hebt u?
Bijvoorbeeld, je bladert door een tabelweergave.
Je hebt een vast aantal nummers die u zoekt op of een vast aantal contacten.
Als je mij natuurlijk niet zoveel,
en dus dat is hoe iOS weet hoeveel cellen weer te geven.
>> Nogmaals, kan dit iets zeggen als terug 3.
Mijn tabelweergave heeft 3 rijen.
Tot slot, iOS moet weten wat elke cel eruit ziet,
dus wat het is eigenlijk aan de hand te doen is bellen deze methode hier beneden,
deze TableView: cellForRowAtIndexPath.
Het gaat om deze methode aan te roepen op elke cel binnenkant van uw tafel.
Hoe werkt het weten hoe vaak het ook noemen?
Nou, je verteld dat de binnenkant van het aantal rijen in paragraaf.
We gaan dit doen op elk van onze cellen,
en de binnenkant van dit is waar je kunt eigenlijk doen dingen zoals
stelt u de tekst of vertellen wat dat kleine blauwe knop aan de rechterkant doet.
Het patroon voor het krijgen van deze cellen, gaan we deze methode te gebruiken
genoemd dequeueReusableCellWithIdentifier.
>> Objective-C is eigenlijk heel bekend om de belachelijke lengte van hun methode namen,
en dit is echt een mooi voorbeeld van voorbeeld.
Wat deze methode doet is dit gewoon zegt dat ik wil dat je me een cel.
Gewoon een iOS-ding.
Als je iets als 100.000 nummers op je iPod
wat iOS niet wilt doen, is toe te wijzen 100.000 cellen,
want als je aan de top van de lijst, heb je echt nodig om geheugen toe te wijzen
voor de cel dat is 99.000 rijen naar beneden?
Nee, want als je scrolt kun je soort van toe te wijzen als je verder gaat.
Dit wordt voor u gedaan.
U hoeft geen zorgen te maken over al die stomme prestaties spul.
Alles wat je zegt is u deze methode aanroept dequeueReusableCellWithIdentifier,
en dit zegt, oke, als je nodig hebt om Ik ga een nieuwe cel voor u maakt.
>> Maar als je aan de onderkant van de tafel en je hebt reeds toegewezen sommige cellen
aan de bovenkant van de tabel die je echt niet van plan om op elk moment snel nodig
Ik ga u een van die rug in plaats van de toewijzing van een nieuwe,
en dus dit is een mooie prestatie van zorg.
Je hoeft niet toe te kennen de cellen zelf.
Dat zal u terug te geven een cel.
Het zal bij u terug een cel object.
Zodra u de cel object kunt u dingen doen om het te.
U kunt de tekst van de cel met deze eigenschap heet tekstlabel.
U kunt de pijl aan de rechterkant of een andere random stuff
deze andere eigenschap die accessoryType, enzovoort, enzovoort.
>> Laten we eens een kijkje nemen op het daadwerkelijk implementeren van een tabelweergave nu.
Toen ik gemaakt dit project
in plaats van te zeggen enkele weergave applicatie die ik kwam eigenlijk hier
naar master-detail toepassing, en dus in principe komt dit overeen met de e-mail app
op de iPad met de tabelweergave aan de linkerkant en vervolgens de inhoud aan de rechterkant.
Op de iPod of iPhone dit gaat overeenkomen met een enkele tabelweergave.
Dat is waar ik mijn starter code.
>> Laten we eerst een blik op het storyboard te nemen.
Dit alles werd gedaan voor mij, in principe gemaakt.
Deze navigatiebalk liet me zien wat een voorbeeld cel eruit zou kunnen zien,
en ik kan dubbelklik hierop klikt, verandert de titel.
Elke andere UI zorgen die ik aankan daar.
De header-bestand ziet er echt simpel.
In plaats van dit te zeggen is UIViewController we nu zeggen dat dit een
TableViewController, dus we weten dat we willen al die tabel methoden noemen.
Daarna ga ik weer een eigenschap die gaat vertegenwoordigen creëren
de dingen binnenkant van mijn tafel.
Deze tabel gaat willekeurig weer te geven
een lijst van de vrucht, en dus moet ik een aantal array te maken
waarin ik kan invoegen fruit.
Binnenkant van mijn uitvoering bestand is het eerste wat ik wil doen
is wil ik ervoor zorgen dat ik initialiseren deze array.
>> Ik zei Alloc init, creëerde ik mijn fruit array,
en ik ben het toevoegen van 4 dingen aan, waarvan er een is veel meer omstreden dan de andere 3.
En nu heb ik een array van grootte 4.
We schudden het op in CS50.
Ik heb nu een array van grootte 4.
Nu ga ik om te beginnen met het beantwoorden van deze vragen, en eigenlijk,
Toen ik deze app gemaakt van dit alles was al voor mij gedaan.
Ik hoefde niet te typen het aantal secties in tabelweergave.
Het was er al, en ik ben invuloefeningen.
Hoeveel luiken heb ik?
One. Helemaal klaar.
Hoeveel rijen heb ik?
Nou, ik een rij voor elke vrucht, dus deze telling
is een eigenschap van een array die zegt hoe groot is het?
Dat is hoeveel rijen ik heb.
Tot slot, ik moet zeggen wat doet elke cel eruit?
Ik ga dequeueReusableCellWithIdentifier zeggen.
>> Opnieuw werd dit al voor mij geschreven.
Ik hoefde niet te doen dit zelf, en ik wil terug
deze cel op deze locatie.
Vergeet niet dat we dezelfde methode een beroep op elke cel,
en dit argument hier, dit indexPath argument,
zegt wat rij ik ben binnen
Als ik zeg indexPath.row hier beneden
dit aan 0, dan zal 1 dan een 2, en dit is zo ik weet
welke cel ik momenteel weergegeven.
Ik wil de tekst van de cel met behulp van deze TextLabel eigenschap in te stellen
om te gaan in mijn fruit array en krijgen
het object overeenkomstig elke rij.
Als dit een string, ik ben nu het instellen van
de eigenschap text naar een string.
Ik kan een ander ding.
Ik kan ook registreren op het event handler op elk van de cellen,
dus als ik tik op elk van deze cellen
deze didSelectRowAtIndexPath, dit gaat te noemen voor mij,
dus gewoon door het definiëren van deze Ik kan nu overweg met wat er gebeurt
wanneer u een cel tikt, weer en, we passeren in welke cel werd afgeluisterd
zodat we kunnen hergebruiken deze zelfde event handler voor al onze cellen.
>> Nogmaals, dit is iets wat iOS doet voor mij.
Laten we weer een andere vervelende popup
dat zegt je gewoon opgepakt iets waar dat er iets
zal de rij object.
Toen ik dit run, ga ik deze mooie tafel uitzicht heeft
met een rij voor elk van deze vruchten, en als ik tik op een
hij vertelt me ​​wat er gebeurd is.
Logisch?
Laten we bouwen aan een beetje meer complex van een app,
zo veel als het klikken je geplukt tomaat is.
Het leuke deel over de storyboards
is het niet alleen gaat om individueel te helpen ons ontwerp-schermen,
het is ook gaan om ons te helpen met elkaar in verband onze hele app,
zodat de uiteindelijke app we zullen gebouw is dit leuke sport nieuws lezer,
en dus het gaat om meerdere schermen hebben, en dus kan ik eigenlijk vertegenwoordigen
elk van deze meerdere schermen op het storyboard,
en ik kan uitzoomen en zie mijn app van een hoog niveau.
>> Om een ​​nieuw element binnenkant van mijn storyboard creëren
het is echt simpel binnenkant van Interface Builder.
Als ik wil naar een ander scherm toe te voegen, bijvoorbeeld,
Ik kan eerst uit te zoomen met de pinch zoom dat Apple houdt zo veel,
en hier beneden voordat ik zoeken naar een knop
en ik sleep een knop
als ik wil een nieuw scherm te creëren kan ik eigenlijk gewoon slepen en neerzetten
een hele uitzicht controller, dus als ik dit pak, trek hem over hier,
hey, er is een ander scherm, en dus nu met behulp van deze zelfde storyboard bestand
Ik kan alle van de schermen binnenkant van mijn app, en ik kan uitzoomen
en zie hoe ze op elkaar inwerken.
Deze zullen nog niet met elkaar omgaan.
De manier waarop deze 2 schermen interactie is die u definieert relaties.
U kunt in principe zeggen dat dit scherm wanneer u op deze knop drukt,
Ik wil dat je meer dan schuiven om deze nieuwe scherm.
Dat betekent dat er dit soort relatie tussen de
het eerste scherm en het tweede scherm.
Je zult in principe een pijl van die knop naar het tweede scherm
zeggen dat wanneer u op deze knop drukt, dat is waar ik heen wil.
Net zoals we de controle geklikt en gesleept naar de verkooppunten te definiëren
we gaan om hetzelfde te doen om deze segues definiëren.
>> We zullen zien een voorbeeld voor die, en voordat we daadwerkelijk de overgang
van het ene scherm naar het andere iOS is leuk genoeg om deze methode aan te roepen
riep prepareForSegue, en dit is waar we beginnen kunnen
het verzenden van gegevens van het ene programma naar het andere.
In het voorbeeld dat we gaan kijken zal in principe ons in staat stellen
om honkbal teams filteren op competities en divisies.
Toen ik een competitie selecteren, bijvoorbeeld, ik wil de overgang
naar mijn volgende scherm waar ik kan alle van de divisies
in die competitie of de verschillende teams.
Ik moet naar dat scherm wat teams je moet geven.
Om dat te doen ga ik hier om te profiteren van deze methode.
>> Tot slot, op slechts een willekeurig punt op iOS.
Als u gegevens wilt opslaan is er dit ding heet kerngegevens,
dat is eigenlijk wel ingewikkeld om mee te werken.
U kunt ook gebruik maken van SQL om gegevens op te slaan,
die weer, is leuk, maar soort van op de meer ingewikkelde kant om mee te werken,
maar iOS ondersteunt ook deze echt coole dingen geroepen eigendom lijsten,
en een property list is gewoon een bestand dat de belangrijkste waarde-paren vertegenwoordigt.
U definieert een lijst met toetsen, en je zegt deze toets gaat een array zijn.
Deze toets wordt een string zijn, en eigenlijk alles wat je kunt doen
in JSON kunt u binnen doen van een property list,
en dus dit is echt mooi stelt ons in staat om te werken met een aantal gegevens.
Bijvoorbeeld, ik heb dit Teams.plist die ik heb gemaakt.
Ik heb een nieuwe plist-bestand, en ik kan doorklikken.
Dit is een woordenboek is een woordenboek zijn strings,
en dus dit is een mooie grafische weergave van een JSON-document
of gewoon een aantal belangrijke waarde-paren,
en dus dit is de gegevens die ik ga werken met binnenkant van mijn app.
>> Laten we eerst hierheen komen. We hebben veel meer bestanden nu.
Maar laten we hier voor het eerst komen naar het storyboard.
Het storyboard hier-als ik kan uitzoomen-
we kunnen nu zien dat dit de stroom van mijn app.
Ik ben eerst gaan beginnen op dit scherm.
Ik ga inzoomen op dit scherm,
en ik ga inzoomen op dit scherm, en we kunnen hier zien dat als ik soort van
verplaatsen van een van deze rond hebben we deze pijlen te gaan van hier naar hier,
en de manier waarop ik te definiëren die pijl was als ik in te zoomen een beetje,
en als ik kom naar deze visie controller,
en hier is een cel, en ik wil dat zeggen wanneer u op een cel
Ik wil dat je meer dan glijden naar een ander scherm.
Ik kan gewoon houd controle,
scrollen over een beetje, houd controle, sleep deze cel over en loslaten.
>> En hier zeggen we wat is de overgang die u wilt gebruiken?
Wilt u die dia ding dat heet push gebruiken?
Wilt u naar boven voelt vanaf de onderkant?
Dat heet modale.
En toen ik eenmaal op een van deze, het gaat om deze pijl te trekken voor mij,
en dat betekent dat ik eigenlijk heb behandeld wat er gebeurt als ik op deze knop grafisch.
Ik schreef niet een code om daadwerkelijk schuiven van het ene scherm naar het volgende.
Definieerde ik dit visueel binnenkant van Interface Builder.
Als ik klik op deze pijl, kunnen we zien dat gaf ik dit ding een naam.
Ik noemde het showDivisions, en dit is zo dat ik weet kan
wat de overgang staat te gebeuren, en we zullen zien waarom in slechts een seconde.
Dat is hoe ik heb bedraad de verschillende schermen in mijn app.
Als dit een toets, bijvoorbeeld in plaats van een tabelweergave
Ik kon beheersen klik op de knop, sleept u over naar het volgende scherm,
en dat is hoe ik kan doen navigatie op die manier.
>> Heel snel, als we komen in de MasterViewController,
weer, we gewoon naar een lijst van dingen te definiëren
die wordt weergegeven in de tabelweergave.
Hier Ik zeg dat ik wil dat je dat plist-bestand te nemen,
en ik wil dat je om het te laden op in een woordenboek,
en als je eenmaal dat woordenboek hebt, ga ik opnieuw te beantwoorden dezelfde vragen.
Hier is het aantal secties.
Een, er is een rij voor elke competitie, en de tekst van elke cel
moet ofwel de eerste, de eerste competitie, de tweede liga, en ga zo maar door.
Tot slot, ik ga deze methode die we net zagen genoemd prepareForSegue te gebruiken,
en dit is de methode die zal worden ontslagen als ik klik
een van deze rijen en derhalve activeren die overgang
dat ik opgezet met de pijlen.
Dit is te zeggen dat ik kan meerdere heb
relaties van het ene scherm naar het andere.
Als ik 2 knoppen en elke knop brengt u naar een ander scherm
Ik ga naar 2 segues, 1 hebben voor elke knop.
Maar prepareForSegue is opnieuw zullen worden hergebruikt
voor elk van de verschillende relaties, dat betekent dat ik een manier moet
van het identificeren als u op de eerste knop of druk op de tweede knop.
>> Weet je nog dat ik gaf dat segue een naam, deze showDivisions,
dat is hoe ik nu weet dat dit de segue die werd geactiveerd.
Het enige wat ik wil doen is dat ik wil zeggen
Ik wil uitzoeken wat ik gewoon op,
en zo om dat te krijgen, kan ik zeggen dat ik wil dat de indexPath voor de geselecteerde rij,
herinner me de indexPath zegt precies waar ik net geklikt,
en dan wil ik zeggen dat ik wil uitzoeken waar ik heen ga.
Dit destinationViewController, dat is een eigenschap van de segue.
Dat is het scherm ga ik,
dus ik weet dat het scherm ga ik heet DivisionsViewController
omdat ik geschapen die klasse,
en dus nu als ik zeg d.divisions
Ik ben nu het instellen van een eigenschap van het uitzicht controller Ik sta op het punt om te gaan.
Dit is hoe ik het verzenden van gegevens van het ene scherm naar het andere scherm.
>> Gewoon kijken naar dit DivisionsViewController
kun je hier zien dat in de. h-bestand
Er is die eigenschap verdeeldheid, en dat is wat ik eigenlijk ben vullen,
dus dat is hoe ik weet dat ik de divisies die overeenkomt met het weergeven van
de competitie die ik geklikt, weer in en,
de werkelijke tabelweergave ziet er vrijwel hetzelfde, alleen het beantwoorden van die
3 eenvoudige vragen en het identificeren van
wat er gebeurt als je naar het volgende scherm.
Gewoon een paar andere dingen hier.
Je merkt aan de top hier dat in plaats van te zeggen # include
Ik ben nu zeg # importeren.
Dit is slechts een Objective-C ding.
De import is eigenlijk een mooier versie van omvatten,
en bijvoorbeeld, moeten we weten wat deze klasse is,
dus ik kan niet zomaar zeggen DivisionsViewController.
Als we niet hashtag standardio.c binnenkant van ons. C bestand
de compiler had geen idee wat printf was.
Ook als ik niet importeren DivisionsViewController
de compiler heeft echt geen idee wat een DivisionsViewController is.
Zorg ervoor dat de binnenkant van uw verschillende. M. bestanden die u er zeker van te importeren
de bijbehorende. h-bestanden, zodat de compiler weet wat er gaande is.
>> Tot slot, wat Apple doet uiteindelijk weer een aantal gegevens met behulp van een web-uitzicht,
en dus een web-view is een object waarin je kunt insluiten
een beetje webbrowser binnenkant van uw app.
Het enige wat u hoeft te doen is te voorzien van een URL naar uw webbrowser,
dus ik wil naar mlb.mlb.com,
en dit is hoe ik kan de home pagina te gaan voor elk team,
en zo door het passeren in deze URL
het web weergave kan dit voor mij, en ik kan rond bladeren,
en simulator in gebruik is door die ene.
Nu dit kwam van mijn plist.
Als ik klik op deze dit kwam ook van mijn plist, en dit sliding werd behandeld
door het definiëren van die segues.
Ik klik op deze en nog een,
en nu hier is mijn UIWebView, dus net als dat
hier is de website voor de URL die ik net ingebed,
en ik heb niets te gek af te handelen.
Dit is hoe om te laten zien van een webpagina.
Dingen zoals deze terug-knop hier worden ook gegeven voor mij
helemaal gratis, want ik heb gedefinieerd met behulp van deze relaties segues.
>> Nog vragen? Ja.
[Student] Dus als je Alloc gebruiken, hoef je nooit om gratis iets?
Precies, wanneer u belt Alloc en init je hoeft niet te bevrijden.
IOS gaat dat allemaal voor u te behandelen.
Het is prachtig, en je bent niet overtreden van regels. Ja.
[Student] Als je meer teams die zouden kunnen passen op het scherm zijn,
zou het automatisch een scroll optie, of is dat iets wat je nodig hebt om toe te voegen?
Precies, als ik meer teams, bijvoorbeeld, zou het automatisch verwerken
het scrollen voor mij, en alle prestaties zorgen
met de enorme tafel zijn ook totaal behandeld voor mij.
>> Andere vragen?
Alle van deze code zal worden geplaatst.
We soort verdoezeld een beetje van de meer kleine details,
maar dingen zoals het instellen van een aantal eigenschappen van de webweergave
zijn gewoon dingen die je kunt krijgen door te bladeren Apple's documentatie,
dat is echt, echt mooi aangelegd.
Ze hebben veel van het monster apps en voorbeeld gebruiksmogelijkheden
van verschillende API's, dus zeker kennisnemen van die als je kunt.
Gewoon een aantal handige links die u zou willen om een ​​kijkje te nemen.
Dit zijn enkele handige documentatie gidsen.
De URL's zijn enorm, zodat ze ingekort.
Dit eerste is de gehele bibliotheek van documentatie.
Er is weinig zoekbalken, dus als je het typen knop starten
het zal beginnen met het geven u alle informatie over alle dingen die je kunt doen met een knop.
Ik heb ook de Table View Programming Guide.
Het behandelt tabelweergaven in veel meer detail,
hoe om dingen te doen, zoals dynamisch toe te voegen cellen of bewerken cellen of verwijderen.
>> Er is veel van het monster apps van Apple die zal u tonen hoe dat te doen,
en ten slotte, dit laatste is de Human Interface Guidelines,
en dit is eigenlijk een discussie van UI-componenten,
dingen als niet maken een knop dat is 4 pixels met 4 pixels.
Dat is een slecht idee, en andere dingen die Apple wil dat je doet
goede vormgeving stimuleren.
>> Nog een laatste vraag voordat we eindigen?
Oke, zeker te voelen vrij om-We gaan naar speciale etiketten op te discussiëren.
We hebben een iOS-een, dus zeker voel je vrij om dat te kunnen benutten.
Als u wilt met je klasgenoten werken aan projecten
of helpen erachter te komen wat willekeurige iOS stuff
voel je vrij om me te mailen, en zeker kennisnemen van alle code online omdat
alleen in het belang van de tijd dat we soort van verbloemd de meer
fijnere korrel details van dingen.
Maar zo niet, dan veel geluk op uw iOS-projecten, en ik hoop dat we
een grote instroom van apps in de App Store.
[CS50.TV]