[Powered by Google Translate] [Szeminárium] [iOS: Writing Apps Like a Boss]
[Tommy MacWilliam] [Harvard Egyetem]
[Ez a CS50.] [CS50.TV]
>> Rendben, mindenki, üdvözlünk iOS: Writing Apps, mint a Boss.
A szeminárium fog összpontosítani írásban apps az iPhone
és viszont írásban apps az iPad, és így mi alapvetően majd séta
egy pár másik példát arra, hogyan, hogy egy app, egy egyszerű játék, mint a Tic Tac Toe,
vagy ha jobban érdekel, hogy egy app, mint valami hírolvasó
vagy valami, hogy együttműködik az Internet fogok erről beszélni is.
Itt a rövid napirenden.
>> IOS apps nyelven írt nevezett Objective-C,
és így ez egy kicsit hasonlít a C, de nem igazán egyáltalán,
így fogunk beszélni egy kicsit a nyelv maga
és akkor hogyan kell építeni iPhone apps használatával app nevű program XCode,
amelyek, ha még nem töltötte le, hogy még nyugodtan a letöltés elindításához most.
Ez több gigabájt.
Meg kell ingyen az App Store, így lesz szükségük van egy Mac
ideálisan fut a legújabb verzióját OS X.
Ha nem, nem probléma.
Van Mac a tudományos központban rendelkezésre álló saját használatra
A XCode telepítve, és így nyugodtan használja ezeket a fejlődésnek.
Ha azt szeretnénk, hogy egy alkalmazás, de nincs Mac, ne aggódj.
Rengeteg campus források ezt.
És így aztán megyünk fedezésére 2 nagyobb példák a különböző alkalmazások megteheti.
Objective-C műszakilag az úgynevezett szuper sor C.
Ez azt jelenti, hogy a C kód is érvényes Objective-C kódot.
Ez azt jelenti, hogy a fajta kábelcsatorna szalagos néhány további funkciók a C.
Néhány ilyen funkciók közé tartozik, hogy nem kell soha többé írni malloc, hála istennek,
Nem kell aggódnia a hülye mutatók és felszabadítja őket, és minden ilyesmi
Ön utálta mintegy C, és ez a fajta ment Objective-C.
>> Most, Objective-C is van egy sokkal nagyobb standard könyvtár,
így sokkal több funkciót kapsz ingyen belsejének Objective-C.
Emlékszel, amikor írtak PHP vettük észre, hogy mi ment
E legkisebb nyelv a hatalmas könyvtár mindezek őrült dolog, amit tehetünk.
Ugyanez történik az iOS.
Van objektumok dolgok, mint például a buddhista naptár és igazán semmit
akkor esetleg gondolni talán már létezik Objective-C végrehajtását.
A cél részben az Objective-C hivatkozó valamit
úgynevezett objektum-orientált programozás.
Ez a fajta egy új koncepció, de még valójában többnyire tanult
sok ezeket a fogalmakat már.
Az ötlet mögött objektum-orientált programozás, hogy fogsz strukturálása
egy csomó kódot körül ezeket a dolgokat az úgynevezett osztályok,
és ezek az osztályok valóban megdicsőült struktúrákat.
Belül egy struct mi alapvetően azt mondta, itt van egy dolog,
és ez a dolog lehet tagja.
Például egy csomópont a csatolt jegyzék más dolgok
mint egy értéket, egy mutatót a következő csomópont a listán,
és ezzel együtt, hogy a mutató értéke, és hogy áll ez például egy struct.
Osztályok nagyon hasonló, kivéve
osztályok olyan funkciói is bennük.
Amikor hirdetett struct, mi csak annyit tudott mondani int n vagy csomópont * következő.
>> Most Objective-C tudjuk ténylegesen funkciók
belül azokat a dolgokat.
A másik dolog, hogy az osztályok tehetünk, hogy örökölheti adatokat más osztályokba.
Például, mi lesz nézi most egy csomó beépített Objective-C osztály.
Ezek egyike lehet az osztály, amely képviseli a nézetben a képernyőn,
és ezért azzal szeretném végre a saját érdekében
mi alapvetően mondjuk valakit az Apple valószínűleg nagyon kedves emberek,
írta ezt az osztályt nekem, és ez kezeli a dolgokat, mint a megjelenítő nyomógombok
vagy teszi a képernyőt, és mi lenne igazán fájdalmas
végrehajtása minden alkalmassága magunkat, és így egyszerűen
örökölje az adatok azt mondhatjuk, mindent, amit tettél ebben az osztályban
Azt is szeretném belsejében osztályban, aztán megyek, hogy néhány más dolgot,
nevezetesen végrehajtása app.
Ez az, amit ez a szó örökséget jelent. Meglátjuk, egy konkrét példát.
>> És végül, a legfontosabb az objektum-orientált programozás, hogy a
vezet adatok kapszulázáshoz.
A néhány probléma meghatározza mi lehetett volna ezek a nagy, globális változók
és globals mindenhol, és ez hogyan lenne nyomon követni az állam.
Az osztályok kezdhetjük kapszulázó információkat belsejében egy tárgy.
Ha van egy képernyő a app, akkor nem igazán kell, hogy olyan adatokat,
másik képernyőre a mi app belül, hogy a
így a dolgok kapszulázó belül osztályokba ez valójában vezet
A sokkal jobb kód tervezés, és ez lehetséges néhány a további funkciók
Az Objective-C.
Forewarning, a szintaxis Objective-C banán.
Ez olyan, mintha semmit sem láttuk korábban,
így egy kicsit a tanulási görbe megszokni
mi a francot jelent ez?
De ha egyszer kap múlt, hogy a kezdeti tanulási görbe, hogy ez nagyon, nagyon sima
írásához apps.
>> Ahhoz, hogy állapítsa meg egy osztályt, azaz itt az én osztály, létezik,
és talán itt van néhány dolog, amit meg fogok később,
Fogok mondani @ interfész.
Fogok mondani @ interfész. Fogok adni osztályomba egy nevet.
És majd később valahol máshol fogok mondani @ end,
és minden, ami a kettő között a @ interfész és a @ end
lesz az osztályomba.
Ez lesz a mi van benne a mi. H fájlokat.
Csakúgy, mint a C a. H fájlok lényegében azt mondta, itt van néhány dolog, ami létezik.
Én nem feltétlenül azt mondom, amit csinálnak még,
de a fordító tudnia kell, hogy léteznek.
Később belül mi. M-fájlokat, mert m Objective-C
van, ahol mi tényleg lesz meghatározni, hogy mi ezen osztályokba csinálni.
Akárcsak mi. C fájlokat, feltéve hogy a végrehajtási feladatokat.
Belül a mi. M fájlt fogunk mondani, itt van, amit minden funkcióját
belül az én osztály, amit mindannyian.
És végül, belsejében egy struct mondhatnánk belül e kapcsos zárójelek
int n vagy csomópont * next,
és Objective-C fogjuk használni a kulcsszó @ ingatlan,
és ez az, mi határozza meg a tulajdonságok,
vagy a nem-függvények, amelyek egy része az én osztályok.
>> Calling funkciók Objective-C is banán.
Amikor bejelentett funkciók C mondtunk valami hasonlót int foo
és nyitott zárójel, majd adott neki egy listát az érvek.
Ez az, amit nyilvánító módszerek vagy funkciók néz ki, mint az Objective-C.
Ha azt szeretnénk, hogy állapítsa meg a függvényt vagy eljárást
ha azt mondom, a módszer tényleg csak egy függvény, hogy ez egy tagja egy osztály,
olyan kedves cserélhető, de nem igazán,
így belseje én módszerem szeretnék létrehozni egy új módszert.
Ez megy vissza semmit, így lesz típusú semmis.
Ez a visszatérési típus az én funkció.
Most már parens itt, mert-nem tudom.
Következő lesz a neve az én funkció,
és végül van egy pontosvessző, mint volt a C.
Mi az új itt ez a srác itt.
Ez a kötőjel ténylegesen szükséges, és hogy ez mit mond az, hogy a
ezt a módszert itt kell hívni egy példány egy osztály.
>> Miután kijelentette, mi Struktúrák akkor valószínűleg valami olyasmit mondott
struct csomópont n, és a ténylegesen létrehozott
vagy példányai egy olyan struktúrákat, így én ténylegesen munkába
és mi van a belsejében, így ez dash azt jelenti, hogy meg kell
példányosítani az osztályt, mint mi példányosított hogy struct
mielőtt hívhatjuk ezt a módszert rajta.
Ha azt szeretnénk, hogy elkezd hozzá érvek a módszereim
kap még banánt.
Itt a módszer neve.
Aztán megyek egy kettőspont, majd ezt követően kettőspont azt mondja, itt jön néhány érvet.
Ez a módszer vesz egy érv.
A típus az érv int, és a nevét ezen érvelés
vagy a változó fogok kezdeni a belsejében a módszer az úgynevezett i.
Ismét, ez a módszer. Beletelik egy érvet.
>> Ha szeretne kezdeni hozzátéve, több érvet kap több banánt
az, hogy már ez a vastagbél, hogy azt mondja, itt jön a listámon érveket.
Az első argumentum egy egész szám.
Nos, ez a második érv érdekes.
A változó, hogy fogok használni belül saját függvény
hívják f, így az én belső függvény mondhatnám
f + = 1, vagy valami.
Ez a dolog itt alapvetően egy kulcs érvelés vagy paraméter.
Csakúgy, mint a mi volt kulcs érték párokat, és valami hasonló JSON vagy asszociatív tömbök
Objective-C elhatározta, hogy azt mondják, oké, csak azért, hogy ez tényleg tiszta
Ha hívja a módszer, amit ezek a paraméterek
Én valóban megy elnevezni őket.
Ha hívja a módszert, akkor tulajdonképpen mondani andFloat,
és akkor add be
>> Érdekes, hogy ez az ember nem nevezett, de az összes többi paraméter,
így ha volt egy 3. érv mondhatnám andFloat
és egy másik úszó és így tovább.
Amikor hívom ezeket a módszereket, hogy természetesen banán
így ha van egy tárgy, és meghatározott eljárás foo nevű,
és szeretném hívni, ahelyett mondván foo nyit / zár parens
Megyek megnyitni egy tartót.
Itt van a neve a módszer.
Megyek, hogy lezárja a konzol, és ez a tárgy hívom be.
Ne feledje, hogy az összes ilyen módszerek léteznek osztályok
mert osztályok lehetnek meghatározott módszerek bennük.
>> Itt már önkényesen létrehozott objektum egyes osztály,
és ez a szintaxis csinálja.
Vannak 2 lépés létrehozása egy objektum.
Az első lépés az, hogy azt szeretnék kiosztani helyet.
Ez egyenértékű a malloc. Nem kell mondanom malloc többé.
Mi elejtette a m tette alloc, és helyébe a. C-vel. M.
Miután alloc valami, amit akkor kell formáznia azt.
Alapvetően, ha új objektumok létrehozásához érdemes némi logika
amely végrehajtja, ha ők teremtett, így át néhány alapértelmezett értékek
vagy valami ilyesmi, és így ez a módszer init ami ténylegesen létrehozza az objektumot.
Először lefoglalni helyet, mint tettük a C,
és aztán inicializálni azt, ami lehet, hogy nem egy csomó.
Aztán mi vissza ezt a dolgot egy objektum o.
Van egy csillag itt, mert ez technikailag egy mutató,
de ne aggódj, mutatók nem olyan nagy ügy az Objective-C többé.
>> Most már ez az osztály példányai nevezett NSObject,
és ez csak egy véletlen osztályt, hogy az Apple rendelkezik.
Már példányai, és most van egy példány az ebbe az osztályba
e tárgy o, így ez azt jelenti, hogy ha meghatározott
ezek a módszerek tudtam hívni őket, mint ez.
Hasonlóképpen, ha akartam hívni eljárás egy érvet,
így ez a bár módszer, hogy vesz egy érv,
és itt van a BAZ: qux módszer, így ez tart 2 érveket.
Ez meghívják valamelyik funkció az objektum o.
Értelme?
A szintaxis kell semmi értelme, de a fajta szokni.
>> Oké, beszéljünk néhány dolog, amelyeket beépítettek Objective-C
, amelyek nem feltétlenül beépítve C.
A C-ben is ilyen volt kezelni húrok, mivel ezek a hülye karakter tömbök,
és ez aztán tényleg bosszantó.
Objective-C rendelkezik az összes beépített nekünk, és ez beépített
használatával nevű osztályt NSString.
Ha azt akarom, hogy hozzon létre egy NSString már több misztikus szintaxist.
Ahelyett, hogy azt mondja: "CS50" mondjuk @ "CS50"
és ez még csak a szintaxis nyilvánító húrok Objective-C.
Ez rendkívül könnyű elfelejteni, úgy nem.
Nos, ha már van ez, ez egy string, de észre
ez tényleg csak egy tárgy.
Azt mondtam NSString, ami azt jelenti, hogy az osztály példányai
nevű NSString, amely valaki más írt nekem,
és ők nagyon kedvesek voltak róla, és így most
Tudok kezdeni amelyben módszerek is.
Ha hívja a módszer hosszúság ezt a tárgyat s
ez fog visszatérni hozzám a hossza a húr.
Ez olyan, mint a C strlen
Ez vissza 4.
>> Hasonlóképpen, egy másik módszert talán szeretnék érdekli ez characterAtIndex.
Ez egy olyan módszer, amely azt mondja, ezen a húr s
Azt akarom, hogy a 0. karakter,
és így ez tér vissza hozzám a karakter c,
és van egy csomó több ilyen módszerek segítségével Google igazán könnyen.
Apple dokumentációja nagyon jó, és mi vessünk egy pillantást, hogy egy kicsit.
Azok szálakat.
Mi is változó méretű tömbök építettek be
Ne feledje, a C, amikor kijelentette, tömb
kellett mondani, van 5 elem, vége a történetnek.
Amikor odaértünk a JavaScript és a PHP tudtunk kezdeni
dolgok, mint hozzáadásával elemek vagy mozgó elemek.
Meg tudjuk csinálni ugyanezt Objective-C.
Ahelyett, hogy hozzon létre egy tömböt a szokásos módon, a C
már megint egy másik osztályba nevezett NSMutableArray.
Van még NSArray,
és ez fog alapvetően beágyazására néhány tömb.
Ez azt mondja, az első dolog, amit akarok, akarok kiosztani
hely az új tömb, és miután én osztja azt
Aztán kell formáznia azt.
Ismét, csak hívja e 2 módszereket.
Nos, ez azt jelenti, hogy az objektum belsejében egy
Én egy üres tömböt ül ott.
Ha azt akarom, hogy adjunk valamit az e tömb tudom hívni a addObject módszer.
Azt szeretnénk hozzáadni egy objektumot a tömb egy, és szeretném felvenni a húr CS50.
Ha akartam fordítva távolítsa el, hogy tudok mondani akarok
távolítsa el a tárgyat az első helyen a tömb vagy kifogás a.
>> Értelme?
Oké, akkor milyen szokni ezt a szögletes zárójel dolog.
By the way, belsejében egy csomó Apple könyvtárak meglátja ezt a NS.
Az NS ténylegesen áll a következő lépés, ami egyike volt az első vállalat, Steve Jobs,
, és ez az, ahol ő tényleg elkezdtem írni egy csomó kódot
A fajta alapját a Mac OS X és az összes többi dolog,
és így ez a fajta NS ezt a szép örökséget kiáltani az egyik korábbi társaságok
vissza, amikor az Apple először kezdik el.
Ez mindenhol.
Vessünk egy pillantást egy átfogóbb Objective-C példa.
Itt vagyok belül XCode.
Ahhoz, hogy itt, először le XCode az App Store,
nyitotta fel, aztán felmentem itt fájl,
ide az új, majd projekt.
Miután tudom, hogy én ezeket a lehetőségeket, hogy mit akarok létrehozni,
és így lesz vess egy pillantást ezeket a lehetőségeket később,
de csak ezt a példát, mert valójában nem megy, hogy egy app még,
Azért jöttem ide, és azt mondtam: Command Line Tool,
és ez egy app, hogy tudtam futni a parancssorban
csakúgy, mint mi már futó C.
Így hoztam létre ezt a projektet, és most itt vagyok,
úgyhogy az első pillantást a fájlt, és ez csinos ismerős.
Van egy int neve. Van barátom argc, a másik haver argv.
És így láthatjuk, hogy ez a belépési pont az első Objective-C alkalmazás.
Itt figyelmen kívül hagyhatjuk ezt most.
Ez alapvetően némi memória kezelése dolgokat, hogy nem fogod igazán
soha nem kell aggódnia.
>> Nézzük az első mondat itt.
Ez az első sor, ha azt mondom, Diák * alice = [[Student alloc] init] mi ez csinál?
Ez az első diák van, ez valószínűleg egy osztály.
Ez nem egy osztály, hogy az Apple írta, de ez egy osztályt, hogy én írtam.
Az első dolog, amit akarok, akarok kiosztani hely egy új diák,
aztán szeretném inicializálni, így ez ad vissza
Az új diák objektumot, és én ezt a tároló változó nevű Alice.
Honnan, hogy az osztály származik?
Hát, ide a bal oldalon ezek mind különböző fájlok belsejében az én projekt.
Láthatjuk, itt van egy Student.h és Student.m.
A. H fájl, emlékszem, ahol kijelentem minden dolog
amelyek léteznek az osztály.
>> Vessünk egy pillantást.
Rendben, itt van ez a @ interfész, és ez azt mondja, hogy itt jön
nyilatkozatok minden, ami létezik, az én osztályban.
Aztán van egy kettőspont. Aztán van ez NSObject dolog.
Ez azt jelenti, hogy vastagbél öröklés bit beszéltünk egy kicsit korábban.
Ez azt mondja, mindent egy NSObject tehet
amennyiben NSObject van ez az osztály írta valaki más,
Mindent ez NSObject tehetünk akarok, hogy képes legyen erre.
By mondván: NSObject, hogy azt jelenti, hogy alapvetően
örökölte összes funkciót egy másik osztály.
Ez tényleg adott nekem egy csomó különböző módszerek és tulajdonságok tudom használni.
Itt lent hozok létre 2 tulajdonságait.
Ez azt jelenti, tanítványom, ha ez a struct, ezek lennének a 2 dolog
belül a struct, így minden hallgató egy nevet
ez egy string, és a diák is van egy osztály,
ami egy int.
>> Végül ide megyek, hogy hozzon létre egy módszert a tanítványom.
Felhívtam a módszer, initWithName, és vesz egy érv,
és ez az érv egy string, és azt nevezte nevezni.
Most nézzük meg, hogyan ténylegesen végrehajtották ezt az osztályt.
Itt most én vagyok benne az én. M fájl,
m végrehajtását, azt hiszem.
Nálam van a végrehajtás, a végén, és itt, ahol vagyok ténylegesen meghatározó
mit initWithName csinál.
Én initWithName a neve az én paraméter, majd ezt
ahol én tulajdonképpen létre egy diák,
és így ez egy kicsit rejtélyes, de ez a fajta boilerplate
kívánt fel a kivitelezők.
Ez az inicializálási funkció itt initWithName, egyfajta kivitelező.
Te alapvetően építése egy új diák objektumot
és talán küld néhány adat benne.
Az első dolog, amit akarok, akarok hívni init e szuper dolog.
>> Ne feledje, hogy amikor azt mondtam, itt hátul a. H fájlban
hogy mindent egy NSObject egy diák is.
Ez azt jelenti, ha tudok létrehozni egy diák mit is kell tennie, hogy
győződjön meg arról, hogy a NSObject, hogy én vagyok örökölje minden adott adatok
is tökéletesen inicializálni.
Azt kell mondanom, ez a szuper ténylegesen megy nézze meg a szülő osztály
, hogy én vagyok-tól örökli, ezért szeretnénk, hogy győződjön meg arról, I inicializálása
mindent, hogy én vagyok függően mielőtt elkezdek akarják használni azt.
Aztán, ha ez megfelelően inicializálni ez csak, mintha azt mondanánk, ha malloc
nem tért vissza null, akkor tudok kezdeni beállításával néhány tulajdonságát.
>> A JavaScript és a PHP mi volt erre a kulcsszóra nevezte ezt,
és ez az említett, a jelenlegi például egy osztály.
Az Objective-C hívjuk ezt én.
Amikor azt mondom, self.name, ami azt jelenti, hogy az objektum
Én csak létre, amikor azt mondtam, diák alloc init,
hogy fog adni nekem vissza egy objektumot.
Ez azt jelenti, hogy szeretné állítani a nevét, hogy a tárgy
hogy amit csak telt be
Csakúgy, mint a C, akkor elérheti tagok e pont,
így self.name mondja a nevét, a hallgató objektum
most lesz, amit most telt be
És végül, én vissza, szóval én tényleg kap valamit.
>> Kérdései vannak?
Oké, szóval ez a self = super init,
ha nem teljesen értem, az öröklési anyag ne aggódj.
Csak tudom, hogy ha valaha is szeretnénk, hogy a saját init módszer csak
csinálni, és akkor lesz jó menni.
Aha. >> [Student] Mit jelent, ha ön jelent?
Ez azt jelenti, ha malloc valami, amit mindig ellenőrizni, ha ez egyenlő null,
és ha volt null, aztán kilépett.
Ez ugyanaz a dolog, mert ha ez visszatér null, akkor mi valószínűleg fog seg hiba
ha elkezdünk próbálja manipulálni.
Ez a mi hallgatói osztály.
Ez azt jelenti, hogy inicializálni a hallgatók kétféleképpen.
Ha azt mondom, hallgató alloc init Én nem használja ezt a módszert, hogy én csak írtam,
és ehelyett azt egyszerűen mondani alice.name,
és most megyek be, hogy a tulajdonság nevét.
>> Hasonlóképpen, ha akarom használni, hogy initWithName módszer
Én egyszerűen azt alloc, majd ahelyett, mondván init
Fogom hívni, hogy a módszer, hogy én csak létre, és megyek át a Bob.
Ezen a ponton, az objektum Bob van neve egyenlő Bob.
Oké, itt lent, hogy én vagyok a NSMutableArray hogy néztük korábban.
Én elosztásának space.Then Én inicializálása egy új tömböt.
Megyek hozzá 2 dolgot hozzá.
Ez a tömb most tart hallgató tárgyakat.
Figyeljük meg, hogy sehol nem azt kell mondanom, hogy ez egy tömb versenyző.
Azt mondtam, hogy ez egy tömb, időszak.
Aztán nem tud bármit belül az, hogy akarok.
Itt van 2 objektumokat.
>> Végül, van egy másik célja van, ez a TF.
Több itt TF.h alapvetően ugyanaz a dolog.
Én örökli származó NSObject, és az úton,
amikor létrehoz osztályok ez mindezt az Ön számára,
ilyen felület boilerplate.
Ez a tulajdonság a diákok.
Nekem van egy pár módszert, hogy itt nem igazán csinál egy csomó,
és így azt jelenti, hogy miután létrehozni ezt a TF objektumot
Tudom hívni ezt a módszert fokozat rajta, mint ez.
Bármilyen kérdésre Objective-C szintaxis mielőtt elkezdjük költözik még több
Érdekes apps fejlesztés cucc?
>> Oké, nézzük valójában, hogy egy iPhone app.
Az alapvető osztályok, hogy te leszel a belsejében az iPhone app nevezzük nézet vezérlők,
és kilátással vezérlő alapvetően jelentése egyetlen képernyőn
belül az app, így ha én vagyok a zene app, például
egy nézetet vezérlő reprezentálja a nézetet, amit többet az összes dal az én iPhone.
Egy másik nézet vezérlő lehet, amikor rákattintok egy dalt, és kezdj el játszani, hogy
vagy mint én belekattint művészek.
Minden e különböző képernyők is képviselteti magát egy másik nézet vezérlő,
és kilátással vezérlő tényleg csak egy osztály, amely azt mondja, hogy ez hogyan működik a képernyőn.
A dolgok belsejében egy nézet vezérlő fogunk tulajdonságokkal,
így a dolgok, mint egy gomb lesz egy ingatlan a mi nézet vezérlő.
>> Mi is lesz, hogy a módszerek, és ezek alapvetően eseménykezelőt.
Ez a módszer azt mondja, ha megnyomja ezt a gombot,
Azt akarom, hogy tegyen valamit, és végül ismét
fogjuk használni ezt a self kulcsszó eléréséhez az aktuális példány.
Kiépítéséhez interfészek iOS valójában nagyon, nagyon egyszerű.
Nekik van ez a szép drag and drop interface nevű Interface Builder,
és a 2 alapvető fogalmak vezeték fel Objective-C Interface Builder
a IBOutlet és IBAction.
Egy IBOutlet egyszerűen azt mondja, hogy ha egy ingatlant kijelenti, hogy ez a gomb,
és szeretné horog fel valami a tényleges UI,
fogod mondani, hogy ez egy konnektorba.
Hasonlóképpen, ha azt szeretnénk, hogy képviselje egy eseménykezelő
akkor fogod mondani, hogy ez egy műveletet.
>> Ahhoz, hogy valóban ezt a vezetéket grafikus ábrázolás
, és a kódot, ez nagyon, nagyon egyszerű.
Ha azt szeretnénk csatolni egy IBOutlet, mindössze annyit kell tennie, hogy te irányítod kattintással,
és meglátjuk, példa erre nagyon gyors.
Ön kontrollálhatja kattintson oda, ahol azt mondja megnézése Controller.
Fogsz húzza be a felületet, vagy fordítva,
ha azt szeretnénk, hogy beköt egy eseménykezelő fogsz húzza a felület
a másik irányba.
Vessünk egy pillantást egy nagyon egyszerű iOS példa.
>> Hozzunk létre egy új projektet.
Fogok jönni ide, Jelentkezés,
és megyek, hogy kattintson egy nézet Application.
Megyek kattintson a Tovább gombra. Adok a projekt nevét.
Hívom, hogy Hello.
Érdekes, hogy az Apple azt feltételezi, te létre egy terméket,
így eladni és ők is pénzt.
Itt lent fogom mondani, hogy ez egy iPhone app.
Hozhat létre egy iPad app, vagy ha azt szeretné, hogy hozzon létre egy olyan alkalmazások
, amely támogatja a két készülék, amit tehetünk, hogy túl.
Ezek mit szeretne a pipa, hogy néz ki.
>> Szeretné használni forgatókönyveket, amit majd látni fogjuk,
és akkor biztosan szeretné használni az automatikus referencia számlálást,
ami egy szép funkció, amely megakadályozza, hogy kelljen mondani malloc és free.
Hacsak nem akarod hívni malloc és free szeretném hagyni ezt lefoglalt.
Majd kattintson a Tovább gombra, és végül ez lesz kérdezni, ha akarom menteni.
Én hit létre, és itt vagyunk.
Hoztam létre egy új projektet.
Ide, a bal oldalon vannak a fájlok belül a projekt
, és vegyük észre, hogy kaptam egy csomó, és én nem is csináltam semmit.
IOS nagyszerű.
>> Például itt ez ViewController.h,
ez fogja képviselni az első nézet vezérlő,
így az első képernyő belsejében az én app.
Most már tudjuk, hogy ez mit mond.
Azt mondja, hogy én hívom ezt az osztályt ViewController,
és ViewController mindent megtesz, hogy egy UIViewController nem,
és ez ismét van néhány osztályt, hogy az Apple azt írta, hogy nem sok praktikus dolog számunkra
szeretném megjeleníteni a képernyőn.
Itt, ahol én ténylegesen elindulhasson meghatározzák, hogy mi véleményem adatkezelő nem,
, és kiderül, hogy tényleg nincs szükségem erre.
Ez boilerplate kódot, hogy az Apple ad nekem ingyen.
Én kell, hogy az első sorban, vagy én nem egy osztály,
így tudunk megszabadulni ez és hogy eltűnjön ez.
Oké, ez az én üres képernyő.
>> Most kattintson erre MainStoryboard.storyboard,
és ez az, ahol kezd érdekes.
Ez az első képernyő én kb.
Ha azt szeretnénk hozzáadni egy gombot, a HTML-ben kellett, hogy hozzon létre egy gombot tag.
Az Android létre kell hozni egy gombot tag,
de iOS ha csak gyere le ide, hogy a jobb alsó
és ha kattintson erre a 3. itt senki, ha azt mondja, Tárgyak,
és én lapozzunk lefelé, vagy tudok elkezdi keresni a gombot.
És nézd, a gomb, így ha én tényleg drag and drop e ott,
Már csak hozzá egy gombot a képernyő én kb.
Ha meg akarom változtatni a szöveget, én duplán kattintson rá,
mondani valamit, csábító, mint a "Nyomja meg engem."
Oké, most ha én ezt az alkalmazást futtatni, így fordítani,
így futtatni I. kattintson a lejátszás gombra a bal felső sarokban, és én kb.
Én nem csináltam semmit, és kaptam egy édes látszó iPhone app.
Ha azt szeretné állítani, akkor kattintson a stop gombra
mert ez több móka.
>> Tegyük fel, hogy én tényleg akarom, hogy történjen valami, amikor megnyomja ezt a gombot.
Ehhez mit kell tennie, azt létre kell hozni
új eseménykezelő vagy cselekvés.
Ez azt jelenti, hogy létre kell hozni valamilyen módszer, hogy szeretnék hívni
mikor nyomja meg a gombot, így hozzunk létre egy új módszer.
Én belül ViewController.h.
Meg kell mondani, hogy egy módszer létezik.
Szükségem van egy kötőjel elsősorban azért, mert fogom hívni ezt a nézetet vezérlő.
Meg kell adni ezt a típust.
A típus ez lesz, hogy IBAction dolog, hogy korábban láttuk.
Ez egy eseménykezelő, így megy vissza egy IBAction,
és ez egy célzást XCode mondani, hogy
ez az, amit szeretnék drót valamit.
Tudom, hogy ez a név, mint a buttonPressed, pontosvessző.
>> Most már bejelentett egy új módszer belsejében osztályban.
Már mondta, hogy ez a módszer létezik.
Most jönnek ViewController.m,
és mondjuk, amit ez a módszer képes.
Ha elkezdek gépelni, például a (void) buttonPressed
nyilatkozat XCode igazán szép és automatikus kiegészítéshez nekem.
Ez igazán csodálatos.
Figyeljük meg, hogy itt belsejét. M-fájlt, azt is mondhatom semmis,
és ez azért van, mert az IBAction valójában nem egy típus.
Ez valójában hashtag meghatározott valahol, hogy egy üres,
és újra, ez csak egy tipp, hogy azt mondja, hogy XCode
Azt akarom, hogy ez egy eseménykezelő, és majd meglátjuk, miért csak a második.
Ha ezt a gombot megnyomja fogok csinálni valamit bosszantó
mint megjelenítéséhez popup.
>> Ehhez, hogy hozzon létre egy új példányt ebbe az osztályba nevezett UIAlertView,
és ez egy olyan osztály, amely azt írta, hogy az Apple fog megjeleníteni idegesítő popup.
Hívjuk ezt a felugró figyelmeztető jelzést, és van 2 lépésben, ne feledje, hogy létre ezt az objektumot.
Az első dolog, amit tennie kell, hogy osztja tér.
Szeretnék egy UIAlertView.
Szeretnék kiosztani helyet. Ez az első módszer.
A következő módszer akarom inicializálni azt,
, és így van ez a nagy, hosszú metódust initWithTitle.
Ez alapvetően fogja irányítani, amit ez popup mondja.
A cím az én bezárása lehet hello.
Az üzenet az e Ablak lehet "Ez iOS."
Küldött dolog, nem tudom, mi az.
Tegyük fel, hogy ez semmi.
Most a gomb fog megjelenni lehet mondani valami ilyesmit: "Az biztos, hogy az, hogy"
és én nem igazán akarok más gombokat, úgyhogy törölje azt, és zárja be a konzolt.
>> Oké, hoztam létre egy extra egyet. Ott vagyunk.
Ezt hogyan lehet létrehozni egy új popup.
Ha azt akarom, hogy valóban azt mutatják, a felugró szeretném hívni a show módszer.
Ehhez mondhatom éber és show,
és újra, autocomplete was super nice.
Ha elfelejtettem, hogy mi volt, ha csak beírt s,
Én lapozhat itt, hogy kitaláljuk, mi volt,
és szűri szépen.
Most hoztam létre ezt az új popup.
Majd gyere vissza, amit küldött jelent később,
és most azt akarom mondani, hogy akarom ezt a módszert, hogy kirúgták
mikor nyomja meg a gombot, így megyek, hogy jöjjön vissza a storyboard,
és azt akarom, hogy most ezt a IBAction csatolni.
Az első dolog, amit akarok, kattintson a gombra.
Amikor ezt a gombot szeretnék, hogy történjen valami.
Én nem fogok tartsa lenyomva ellenőrzés.
Megyek, hogy kattintson, és húzza meg a gombot
több, mint itt, ahol azt mondja megnézése Controller.
Láthatjuk, hogy szépen világít.
>> Ha elengedem az én egér most már ezt bezárása ide, ahol van néhány lehetőség.
Ezek egyike az események, hogy tudok regisztrálni.
Ez az összes e módszerek kijelentettem az én h fájl IBActions.
Így XCode tudja, mit kell tüntetni ezt a kis listát,
annak érdekében, hogy ez csak egy tipp.
Ha kattintson a gombot lenyomva, már regisztrálta az eseménykezelő.
A JavaScript kellett mondani, van néhány kód regisztrált az eseménykezelő.
Az Objective-C, hogy tényleg ilyen egyszerű.
Ha elfutok ezt újra
Most, amikor a gombot a eseménykezelő fog a tűz,
és megyek, hogy ezt a popup.
Szuper, szuper egyszerű ott.
>> Ha valaha szeretné látni az összes eseményt, hogy ez megtörténjen kell bejegyeztetni
egy összetevő, ha rákattint erre a gombra
és jöttem ide, hogy a jobb oldalon
1. láthatod ide tudok csinálni a dolgokat, mint például, hogy milyen típusú a gombot,
így ha azt szeretnénk, egy olyan I-vagy kiegészítő érintkező gomb
vagy bármi.
Ha azt akarom, hogy az összes az eseményeket, amelyek ezt a gombot
ha jön egészen ide, hogy a jobb oldalon
látjuk itt az események Én mindezen különböző események.
Én nyomja meg a gombot, amikor elengedjük a gombot, amikor dupla csap, vagy bármi,
és az egyik én csak regisztrálva ez a rendezvény az úgynevezett Touch Up Inside,
és ez azt mondja, hogy amint az ujjam jön ki a gombot
Ez esetben fog tüzet, és hogy pontosan mi is történt.
Ez a fajta az alapértelmezett gomb megnyomása esemény.
>> Van még kérdése eddig?
Oké, ez hogyan lehet kezdeni, hogy kösse fel a dolgokat, a mi-kód
a dolgok belsejébe a felület.
Ne feledje, az első dolog, amit meg kellett tennem, hogy megtalálja a kódot,
és aztán vezetékes ki a felületet a kódot,
és van az első kb.
Oké, ez nagyon jó, és létrehozta ezt a gombot.
Mi van, ha nem akarjuk, hogy létre kell hozni egy csomó tulajdonságok
képviselő ezek a gombok?
Például, a Tic Tac Toe én 9 gombok,
és ez lenne szuper, szuper bosszantó, hogy a drag and drop 9-szer
vagy ha én kellett Tic Tac Toe, 81 helyett 9
és én a drag and drop 81 alkalommal, és ez béna.
Mit tehetünk, hanem olyan, mint egy HTML
amikor már dolgokat, mint azonosítókat és neveket, és kereshet a dolgokat
által azonosítója, van egy hasonló fogalom iOS nevű tag.
>> A címke csupán egy egyedi numerikus azonosító alkatrész.
Ha azt mondom ennek egy címke 0, például,
ha létrehoz egy gombot, és adja meg a tag a 0, és majd meglátjuk, hogy hogyan kell csinálni, hogy csak egy második,
ha azt szeretnénk, hogy a gomb tudok egyszerűen azt akarom hívni
A viewWithTag módszer az objektum felett van,
a self.view, ami a jelenlegi képernyő, például.
Ha hívom, hogy viewWithTag módszer, megyek, hogy húzza vissza a gombra tag 0.
Vessünk egy pillantást erre építve Tic Tac Toe.
Először is, ez az én storyboard.
Már létre a 10 UI gombok.
Értesítés ők mind azonos méretű.
Ha rákattintok egy ilyen, és én visszajövök ide, erre jobb oldalán
látni fogja azt állítani a betűtípust itt, ezért tette a font egy kicsit nagyobb,
de mit is tett, én meg ezt a címkét.
Azt mondta, hogy ez egy tag 1, és ez a bal felső sarokban.
>> Most, ha rákattintok egy gombra, így második itt,
Most látni fogod, hogy a tag a 2.
Mindegyik gombok csak egy egyedi címke,
, így ez később hogyan fogok kezdeni kölcsönható
az én app.
Ez mind belül egy nézet vezérlő,
de itt van, amink van.
Jelenleg 3 tulajdonságokkal van.
Az első és az utolsó is fogja képviselni az állam a fórumon.
Alapesetben ez az első egy olyan tömb, ahol a képviselő Xs és Os vannak.
Ez a másik, itt azt mondja, akinek a köre van.
Észre fogod venni, hogy én is ezeket a dolgokat itt.
Mielőtt amikor kijelentette tulajdonságokat adtunk nekik a nevet és a típust.
Azt is nekik néhány további információk itt.
Az első azt mondja nonatomic, és hogy ez mit mond
alapvetően csak az egyik dolog, amit valaha is kísérli meg elérni ezt a változót egy időben.
Lehet csinálni bonyolultabb alkalmazások, amelyek több szálon,
és így vissza Scratch volt a különböző szálak,
és különböző sprite lehetne csinál mást ugyanabban az időben.
>> Ha nem ez a helyzet, ami nem áll semmit, hogy mi lesz nézett,
ha azt mondjuk nonatomic ez tényleg megy, hogy a dolgok egy kicsit gyorsabban.
Mi is ezt a dolgot nevezett hozzárendelése, erős, vagy gyenge.
Ez rendelni most azt mondja, hogy ez egy standard típus.
Ez nem egy tárgy vagy egy mutatót, mert ez csak egy bool,
így bool be van építve Objective-C.
Ez azt mondja, ne próbálja meg semmit képzelet a mutató itt.
Ez egy szabályos régi scaler.
Erős és gyenge, ez a gyenge, azt mondja, hogy ténylegesen
Azt akarom, hogy mutat valamit a nézetben vezérlő.
Nem fogok, hogy ténylegesen kiosztani vagy init e magam.
A felület építőmester, amikor elindul az alkalmazás, fog kezelni minden inicializálás.
Ha azt mondom, gyenge, hogy azt mondja valaki más fog létrehozni ezt.
Ha azt mondom, erős, ez azt mondja, hogy én leszek az egyetlen
ez létrehozása ezen a fórumon objektumot,
és ezért itt van néhány módszer van,
például egy keresetet, amikor az új játékot megnyomja a gombot,
iránti keresetet, ha bármelyik másik gombot megnyomja,
és satöbbi.
>> Mi nem fog bele túl sok logika Tic Tac Toe,
bár ez nagyon izgalmas, de vessünk egy pillantást
néhány dolog, amit tehetünk belül iOS.
Ez az új játék módszer lesz rúgva
valahányszor nyomja meg az új játék gombra.
A horog, hogy akár egyszerűen gyere az én storyboard.
Rákattintottam az új játék.
Ha jöttem ide, hogy a megfelelő látom, hogy
Touch Up Inside van bekötve a newGame módszerrel.
Ez az, amiért ez fog rúgni.
A newGame módszer fog tenni némi létre.
Ez fogja mondani azt akarom, hogy törölje az állam a fórumon.
Ez egy szép módszer változékony tömbök.
Ezt fogja mondani, hogy ez most X viszont,
és most megyek, hogy kihasználják ezt a viewWithTag dolog.
>> Tudom, hogy a gombok a címkéket 1-9,
és ez olyasmi, amit önkényesen szedett.
Ha azt szeretnénk, hogy a szöveg minden egyes gomb üres
mert én csak most kezdődött el egy új játék, és én nem akarok
Xs és Os, hogy maradt meg tudom csinálni ezt.
Mondhatom azt akarjuk, hogy a nézet a tag, 1, 2, 3, 4 satöbbi.
Ez húzza egy másik gombot minden egyes alkalommal.
Itt fogom vetni, hogy UIButton.
Csakúgy, mint tudtunk leadott ints az úszók és fordítva
ez azt mondja, hogy szeretnék ezt a varázslatot a UIButton.
Ez azt jelenti, hogy milyen típusú az lesz, egy UIButton *
mert a mutatók, de ne aggódj, ők nem ijesztő többé.
>> Egyszer már ezt a gombot fogom hívni módszer rajta.
Ezt a módszert nevezik setTitle forState, és így ez azt mondja,
Azt akarom, hogy a szöveg a gomb legyen az üres string,
és azt akarom, hogy az üres string, ha ez nem nyomta.
Ha én vagyok ezzel a módszerrel, meg tudom változtatni a szöveget a gomb
amint valaki üt, de azt szeretném mondani, ha a gomb csak ül ott
Azt akarom, hogy a szöveg lehet üres.
Végül fogjuk inicializálni a fórumon,
és meg fogom mondani, hogy minden jelenleg 0,
így ez az igazgatósági tagok megváltoztathatatlan egy változékony tömb,
ami azt jelenti, hogy lehet hívni a addObject módszer, és csak a 0 belsejébe.
Ez történik, amikor egy új játékot.
>> Vessünk egy pillantást egy másik.
Ez a módszer itt a IBAction ez lesz nyomva
minden alkalommal, amikor az egyik ilyen négyzet van nyomva.
Most van néhány Tic Tac Toe logikát.
Mi kitaláljuk, akinek a köre van,
és ennek alapján mi vagy beállítani egy X vagy O,
de azt észre, hogy mi újrahasznosítással ugyanezt az eseménykezelő
minden egyes egy ilyen gomb.
Ez azt jelenti, hogy nem rendelkeznek olyan módszert a felső bal gomb,
egy másik módszer a jobb alsó gomb, bár tudtam, hogy megtettem.
Ez nem igazán jó design.
Mit csinálok itt én tényleg fogja meghatározni
mi a tag a gomb megnyomása is.
Azt veszi észre, hogy ez a játék mód egyikét veszi érv.
Úgy hívják feladónak, és mi feladó a feladó megy
jelentenek pontosan mit intézkedett rajta.
Ha megnyom egy gombot, a feladó lesz, hogy UIButton
hogy én tényleg megnyomja, így ez azt jelenti, hogy UIButton
van egy tag, mert létrehozott egy tag.
>> Ha azt szeretnénk, hogy a tag azt egyszerűen mondani
Azt akarjuk, hogy a tag a feladó
és újra, én már csak öntött el egy UIButton.
Véletlenül tudom, hogy a feladó lesz UIButton.
Nem kell mindig a UIButton.
Tudtam például, regisztráljon az azonos eseménykezelő
egy egy gomb, egy a csúszkát.
Ebben az esetben, tudom, hogy az összes gomb, így fogom mondani
Azt akarom, hogy ez a gomb, majd tudok a tag,
és a címke most már tudom, hol vagyok belsejében a fórumon.
Aztán egyszerűen beállítható az X vagy az O, akkor megfordítja a turn,
Nézd meg, ki nyert, satöbbi.
>> Van még kérdése erről eddig?
Oké, az összes kódot, beírás online nem akarunk belemenni túl sok
A Tic Tac Toe logika, de most már látom, hogy valóban
minden, amit csinálunk a mi looping át ezt a tömböt,
így van egy pár a hurkok itt, és mi csak képest látni
van még egy meccset az összes sort, a meccs egy oszlopban vagy ilyesmi.
Ahhoz, hogy valóban futtatni ezt az alkalmazást, ha megérinti az egyik ezeket a gombokat
hogy a játék mód kirúgták, hogy azt jelenti, csak meg
a gomb, hogy egy X-, így most ez a gomb lesz egy oxigénatom, és így tovább,
és hogy ez hogyan kezdünk, hogy befolyásolja ez az egyetlen oldal kb.
>> Majd tegye a kódot, így nyugodtan elolvassa, hogy a
de most már beszéljünk néhány apps, amelyek több, mint egy oldal.
Az izgalmas, mint Tic Tac Toe volt, egy csomó apps belsejében iOS
a fajta ilyen fúró le a dolgokat több képernyők.
Az első koncepció, hogy mi kell beszélnünk a jegyzőkönyvek,
és a protokoll egyszerűen egy sor módszer
hogy ígérhetem meghatározni.
Ha létre ezt az új protokollt 2 módszer, ez az első,
ha a visszatérési típusa void, hívtam foo.
Ez nem veszi érveket. Van egy másik módszer.
A tér vissza int. Hívtam, hogy akadályozza meg, és vesz egy érv.
Minden ez a protokoll, hogy hívják SomeProtocol itt,
Ez egy sor dolog, hogy valaki tud végrehajtani.
Én nem belül e jegyzőkönyv mit mondott foo csinál.
Ehelyett csak azt mondom meg tudná határozni foo ha akarod.
Ha hozok létre abból a célból adatkezelő vagy létrehozása osztály
Én belül, hogy az osztály ígéret megvalósítása
Ezek között a módszerek, így például, ha mondjuk
ez most azt mondja, én vagyok, hogy egy ígéretet, hogy belülről
E nézet vezérlő I. osztályú lesz meghatározások mind foo és bar.
>> Miért hasznos?
Sok alkatrészek belsejében iOS kihasználják ezt a
tervezési mintát nevezett küldöttség, és mit mond küldöttség
az, hogy például, ha van egy szövegdoboz
és vannak események, amelyek lehet nyilvántartásba belsejében az én mezőbe,
létrehozása helyett különálló esemény, amit tehetünk tudok mondani
a meghatalmazott e szövegdoboz lesz néhány objektumot.
Amikor azt mondom, hogy ez egy küldött már azt jelenti, hogy
ha valamilyen esemény volna lőttek a szövegdobozba
ahelyett, hogy regisztrálni vagy ilyesmi
ez csak megy, hogy hívja a módszer a küldöttet.
Például, az én belső szövegdoboz van egy módszer, amikor nyomja
hogy a kész gombra a jobb alsó,
így ahelyett, regisztráció eseménykezelő mit tudok mondani,
szövegdoboz, itt van egy tárgy, azt akarom, hogy hívja a módszer
Minden alkalommal, amikor valaki megnyomja a Kész gombra,
és ez azt jelenti, hogy az objektum végre kell hajtania bizonyos protokoll
azt mondja Ígérem, hogy meghatározzák, hogy a kész gombra fellépés,
mert ha nem határozza meg, hogy a módszer, és megnyomjuk a Kész gombot,
akkor lesz zavaró.
>> Vessünk egy pillantást egy példát.
Itt csak egy szövegmezőbe,
és az egyik tulajdonságait szövegdoboz ide ezen az jobb oldalon a küldöttet.
Ez a tulajdonság az osztály.
Amit tettem, itt én irányítani csattant, és hurcolta el ezt a helyet ide
arra az álláspontra vezérlő, és azt mondja, most már a küldött e szövegdoboz
lesz a nézetet vezérlő.
Ez azt jelenti, hogy bizonyos tevékenységek történnek, ahelyett, regisztráció
külön eseménykezelők Azt akarom, hogy küldje el a küldöttet.
Most vessünk egy pillantást a véleményem vezérlő.
Belül a. H fájlban Csináltam egy ígéret.
Már megígérte, hogy végre olyan módszereket belül e jegyzőkönyv
nevű UITextFieldDelegate, és újra,
Ez csak néhány lista néhány dolog, amit lehet választani végrehajtani.
>> Ha bejövök ide az én. M fájlt, már végre egy ilyen módszert.
Már nevezte textFieldShouldReturn
mert ez az, amit úgy nevezték belül a protokollt.
És most, amikor én nyomja meg a kész gombot belsejét, hogy a szöveges mezőben
ez az, hogy mi fog a tétet, így hát nem is regisztrálni egy eseménykezelő.
Én csatlakozik a küldött, és amikor ez az esemény van rúgva
ez az a módszer, amely a tétet, így ha jöttem ide, hogy a forgatókönyvbe, és fuss ez-
míg ez betöltődik láthatjuk, hogy ez mire jó.
Az én képernyőn van 2 dolog.
Én ezt a szöveget a területen, és én ezt a címkét.
Én csak azt mondom, hogy szeretné, hogy a szöveg a címke
azonos legyen függetlenül a felhasználó beírt belsejében a szövegmezőbe.
Ez a következő sor itt egyszerűen egy módszer, hogy én hívom
A szöveges mező, amely azt mondja, azt akarom, hogy elrejtse a billentyűzetet.
Ez csak az önkényes módszert, hogy az Apple választotta.
>> Ismét, mielőtt én bármit kellett bekötni mindent, úgyhogy először jöttem ide.
A nézet-vezérlő I húzza át a szövegmezőbe.
Elengedtem, és látom itt, hogy tudom, hogy ez a szöveg mezőtulajdonság
mivel ide a nézet-vezérlő, amit meghatározott tulajdonság
ez egy IBOutlet egy szövegmezőbe.
Ez azt mondja, hogy tudok kiosztani ezt a tulajdonságot fel
egy szöveges mező az én UI.
Most, amikor rákattint erre tudok kezdeni gépelni.
Most, ha én kattints a kész gombra fog ez a tűz
olyan esemény, amit most válaszolni.
Nincs eseménykezelők.
Így én csak válaszolt e tenni gombra.
Értelme?
>> Ez nem egy tervezési minta, lehet, hogy soha nem találja magát
létrehozhatja a saját protokoll, de csak tudom, hogy néhány
különböző iOS alkatrészek regisztrációja eseményeket különböző módon.
Gombok, például használja ezeket IBActions.
Text mezők, a másik viszont nem fog használni küldöttek.
Látjuk, és nézd az összes, hogy belsejében a dokumentációban.
By the way, van valójában egy csomó dolgot UI épített iOS az Ön számára,
így például, ahogy tettem azt mondják kelt a jobb alsó sarokban
van választottam ezt a szöveget a területen.
Azért jöttem ide.
Én görgetése le egy kicsit vissza gombot,
és tudom, hogy ez valójában egy csomó dolgot, mint ha azt akarom, hogy mondani
segélyhívást ehelyett meg tudom csinálni, ami teljesen véletlenszerű,
, és nem tudom, hogy miért van egy beépített segélyhívó gombot,
de ott, azt mondja Segélyhívás nagyon kicsi betűk.
Tessék.
>> Határozottan meg mindent ezeknek a különböző lehetőségek iOS.
Bármilyen kérdésre küldöttek?
Ismét, csak egy érdekes tervezési minta, amit tudnia kell.
Oké, a következő lépés, hogy egy pillantást asztalnál kilátást.
A tábla nézet alapvetően a lista tételek, ami az egész hely iOS.
Amikor essek át az összes kapcsolatot, akkor éppen a
a beállítási oldalra, és ez a fajta listát azokról a dolgokról nevezzük tábla nézetet.
Végrehajtási táblázat nézet iOS elég egyszerű.
Ahelyett, hogy egy osztályt, hogy leszáll az említett UIViewController
mint amit eddig csináltunk egyszerűen meg kell mondani, nem pedig
mindent egy UIViewController nem akarok,
Azt mondják, hogy minden a UITableViewController nem akarok,
úgy, hogy egyszerűen hozzáteszi, néhány további dolog, ami teljesen értünk.
Kell tennünk nagyon kevés alapvetően töltse ki az üres belsejében az asztalra.
>> Annak érdekében, hogy megjelenjen a táblázat azt kell válaszolni néhány kérdésre.
Az első kérdés, amit meg kell válaszolni, hogy hány szakasz van az asztalon?
Amikor essek át a partnerek app, észre fogod venni, hogy ez a fajta
által szervezett As, akkor megvan a Bs, és van, hogy a kis sub header.
Minden egyes ilyen nevezzük szakasz.
Akkor lehet, hogy nem kell ezeket.
Az első dolog, amit meg kell tennie, hogy végre olyan módszer
úgynevezett Tableview: numberOfSectionsInTableView.
Ez egyszerűen visszaadja, hogy hány szakasz van,
így ez is mondhatjuk vissza egyet, ha van egy nagy tábla nézetben.
A következő kérdés, hogy az iOS tudnia kell, hogy hány sor van?
Például, te essek át egy táblázat nézet.
Van egy meghatározott számú dalok nézel, vagy meghatározott számú kapcsolatok.
Ha én, persze, hogy nem sok,
és hogy ez hogyan iOS tudja hány sejtek megjelenítéséhez.
>> Ismét, ez mond valamit, mint a 3. visszatérő.
My table view van 3 sorban.
Végül, iOS tudnia kell, hogy mi minden cella néz,
akkor mi ez valójában csinálni az hívja ezt a módszert itt lenn,
E Tableview: cellForRowAtIndexPath.
Ez lesz meghívják ezt a metódust minden egyes sejt belsejében a táblázatban.
Honnan tudja, hogy hányszor kell nevezni?
Nos, azt mondtad, hogy belsejében a sorok számát szakaszban.
Fogjuk hívni ezt az egyes sejtjeink,
belsejét és ez az, ahol tudod valójában csinálni a dolgokat, mint a
a szöveg, vagy mondani, hogy mi az a kis kék gombot a jobb oldalon nem.
A minta az, hogy ezeket a sejteket, fogjuk használni ezt a módszert
hívott dequeueReusableCellWithIdentifier.
>> Objective-C valójában nagyon is jól ismert a nevetséges hossza módjára nevét,
és ez tényleg egy jó példa erre példa.
Mit jelent ez a módszer ez csak azt mondja, azt akarom, hogy adjon nekem egy cellába.
Csak egy iOS dolog.
Ha van valami, mint 100.000 dalokat az iPod
iOS mit nem akarok, kiosztani 100.000 sejtek,
mert ha te vagy a tetején a lista, akkor valóban szükség van a memóriát
A sejt, ami 99.000 sorok le?
Nem, mert ahogy te görgetéssel tudod milyen kiosztani, ahogy megy végig.
Ezt az Ön számára.
Önnek nem kell aggódnia, minden hülye teljesítmény cucc.
Minden, amit mondani, hívja ezt a módszert dequeueReusableCellWithIdentifier,
és ez azt mondja, oké, ha kell megyek egy új cellát az Ön számára.
>> De ha te vagy az alján a táblázat és a már kiosztott egyes sejtek
a táblázat tetején, hogy te valóban nem lesz szüksége a közeljövőben
Fogok adni egy ilyen hátsó helyett kiosztása egy új,
és így ez egy szép teljesítmény aggodalomra ad okot.
Nem kell kiosztani a sejtek magad.
Ez lesz adja vissza a cellába.
Ez lesz, hogy visszatérjen egy cella objektumot.
Miután a cella objektum meg tudod csinálni dolgokat hozzá.
Megadhatja a szöveg a cella az ingatlan úgynevezett szövegcímke.
Felveheti hogy nyíl a jobb oldalon vagy más random stuff
ezzel a másik tulajdonság hívott accessoryType, és így tovább, és így tovább.
>> Vessünk egy pillantást a ténylegesen végrehajtó tábla nézet most.
Amikor hoztam létre ezt a projektet
ahelyett, mondván, egyetlen nézetben kérelem Igazából átjött ide
A master-detail alkalmazás, és így alapvetően ez felel meg az e-mail alkalmazás
az iPad, a tábla nézetben a bal oldalon, majd a tartalmát a jobb oldalon.
Az iPod vagy iPhone fog ez felel meg egy tábla nézetben.
Ott kaptam starter kódot.
>> Nézzük először vessen egy pillantást a storyboard.
Mindez történt értem, alapvetően létre.
Ez a navigációs sáv megmutatta nekem, milyen egy példát ilyen sejt kinézni,
és én duplán rákattint erre, módosítsa a címet.
Minden más UI aggályok tudom kezelni ott.
A fejléc fájl néz ki, nagyon egyszerű.
Ahelyett, mondván ez UIViewController mi most azt mondják, hogy ez egy
TableViewController, így tudjuk, hogy szeretné hívni minden asztal módszerek.
Tovább szeretnék létrehozni egy ingatlant, ami fogja képviselni
a dolgok belsejét az asztalomon.
Ez a táblázat fog önkényesen megjelenítéséhez
egy listát a gyümölcsöt, és ezért létre kell hozni néhány tömb
ahol tudok beszúrni gyümölcs.
Belül az én végrehajtás fájl az első dolog, amit akarok
nem akarom, hogy győződjön meg arról, I elindítani ezt a tömböt.
>> Azt mondtam Alloc init létrehozott, a gyümölcs-tömb,
és én hozzá 4 dolog hozzá, melyek közül az egyik sokkal vitatott mint a másik 3.
És most van egy sor 4-es méretű.
Mi rázta fel a CS50.
Most van egy sor 4-es méretű.
Most fogom kezdeni választ ezekre a kérdésekre, és valóban,
amikor hoztam létre ezt az alkalmazást mindez már tett nekem.
Nem kellett, hogy írja meg a szakaszok száma táblázat nézetben.
Ez már ott volt, és én vagyok kitöltésével üres.
Hány szakasz van?
One. Minden kész.
Hány sor van?
Nos, van egy sor minden gyümölcs, így ez a szám
tulajdonsága olyan tömb, amely azt mondja, milyen nagy ez?
Ez hány sort nekem.
Végezetül, azt kell mondani, mit jelent minden egyes cella néz ki?
Fogok mondani dequeueReusableCellWithIdentifier.
>> Ismét, ez már írt nekem.
Nem kell, hogy ezt magam, és azt akarom, hogy újra
ez a sejt ezen a helyen.
Ne feledje, hogy mi hívja ezt ugyanazzal a módszerrel minden egyes cella,
és ezt az érvet itt, ez indexPath érvet,
azt mondja, amit sorban én vagyok!
Ha azt mondom, indexPath.row idelent
ez 0 lesz, akkor lesz 1, akkor lesz 2, és ez így tudom
mit sejt Én jelenleg kijelzés.
Azt akarom, hogy a szöveg a cella használatával textLabel ingatlan
bemenni a gyümölcs-tömb és kap
a tárgy megfelelő soronként.
Ha ez egy string, én most beállítás
A szöveg tulajdonság egy string.
Meg tudom csinálni egy másik dolog.
Én is regisztrálni egy eseménykezelő mind a sejtek,
így amikor koppintson mindegyik sejtek
E didSelectRowAtIndexPath, ez lesz a címe nekem,
így csupán a meghatározó ezt én már tudja kezelni, hogy mi történik
ha megérinti egy cellába, és újra, mi halad, amelynek cellát menetes
hogy így újra ugyanezt az eseménykezelő minden kedves sejtek.
>> Ez megint valami iOS tesz nekem.
Nézzünk egy másik kijelző idegesítő popup
hogy egyszerűen azt mondja, felvette valamit, ha ez a valami
lesz a sor objektumot.
Amikor elindítom ezt fogom ezt a szép table view
egy sor mindegyik gyümölcs, és ha én érintse meg
azt mondja nekem, hogy mi történt.
Értelme?
Építsünk kicsit bonyolultabb egy app,
mint kattintva Ön felvette paradicsom.
A szép az egészben az forgatókönyvek
van ez nem csak fog segíteni nekünk tervezés képernyők egyénileg,
ez is segíteni fog nekünk köti össze az egész app,
így a végső app leszünk épület ez a szép sport hírek olvasó,
és ez így megy, hogy több képernyők, és így valóban képviselt
Mindegyik több képernyők a storyboard,
és tudok kicsinyíteni, és látom app egy magas szinten.
>> Annak érdekében, hogy hozzon létre egy új elem belsejében a storyboard
ez tényleg egyszerű belsejében Interface Builder.
Ha azt szeretnénk, hogy egy újabb képernyő e, például,
Én is először kicsinyíteni a pinch zoom, hogy az Apple szeret annyira,
és itt lent, mielőtt keresni egy gombot
és én drag and drop a gomb
ha azt szeretnénk, hogy hozzon létre egy új képernyőt tudok valójában csak fogd és vidd
teljes nézet-vezérlő, így ha vehetem ezt húzza át ide,
hé, van egy másik képernyőre, és így most már ugyanezt a storyboard fájl
Tudom, hogy az összes képernyő belsejében az én app, és én is kicsinyítés
és hogyan hatnak egymásra.
Ezek nem lép kölcsönhatásba még.
A mód, ahogyan ezeket a 2 képernyő interakcióba is határozná meg kapcsolatok.
Ön alapvetően mondani ezt a képernyőt, ha megnyomja a gombot,
Azt akarom, hogy csúszik át az új képernyőn.
Ez azt jelenti, hogy ez a fajta kapcsolat
Az első képernyőn és a második képernyőn.
Itt van alapvetően egy nyíl az adott gombot, hogy a második képernyőn
mondván, hogy ha megnyomja ezt a gombot, hogy ott akarok menni.
Csakúgy, mint mi irányítjuk kattintottak, és vonszolta meghatározni e piacok
megyünk nem ugyanaz a dolog, hogy meghatározza ezeket segues.
>> Meglátjuk példát adott, és mielőtt ténylegesen átmeneti
a képernyőn egy másik iOS szép ahhoz, hogy hívja ezt a módszert
hívott prepareForSegue, és ez az, ahol elkezdhetjük
adatok küldése egy app a másikra.
A példában vagyunk arról, hogy nézd meg fogja alapvetően lehetővé teszi számunkra,
szűrni baseball csapatok által bajnokság és megosztottságot.
Amikor kiválaszt egy bajnoki, például szeretnék átmenet
az én következő képernyő, ahol képes megjeleníteni az összes megosztottság
abban a bajnokságban, illetve a különböző csapatok.
El kell küldeni a képernyőn, amit csapatoknak kell megjeleníteni.
Ehhez fogom, hogy kihasználják ezt a módszert itt.
>> Végül, csak egy véletlen pont iOS.
Ha azt szeretnénk, hogy az adatok tárolására van ez a dolog az úgynevezett alapvető adatokat,
ami valójában milyen bonyolult dolgozni.
Ön is használja az SQL adatok tárolására,
amely újra, szép, de ilyen a bonyolultabb oldalán dolgozni,
hanem iOS is támogatja ezeket a nagyon jó dolog az úgynevezett ingatlan listákat,
és egy ingatlan a lista csak egy fájl, amely képviseli kulcs érték párokat.
Te meg egy listát a kulcsokat, és azt mondod, ez a kulcs lesz egy tömb.
Ez a kulcs lesz egy string, és alapvetően bármit tehetünk
A JSON tudsz belsejében egy ingatlan lista
és így ez nagyon szépen lehetővé teszi számunkra, hogy működjön együtt néhány adat.
Én például ezt Teams.plist amit létre.
Létrehoztam egy új plist fájlt, és tudom bontani.
Ez egy szótár, ez egy szótár, ezek húrok,
és így ez egy szép grafikus ábrázolása egy JSON dokumentum
vagy csak egy sor kulcsfontosságú érték párokat,
és így ez az adat, hogy fogok dolgozni belsejében az én app.
>> Nézzük először gyere ide. Van egy csomó további fájlokat most.
De nézzük először jött ide, hogy a forgatókönyvbe.
A storyboard itt-ha tudok kicsinyíteni-
akkor látjuk, hogy ez az áramlás az én kb.
Én 1. fog kezdeni ezen a képernyőn.
Megyek lebontja ezt a képernyőt,
és megyek lebontja ezt a képernyőt, és mi lehet itt látni, hogy ha valahogy
mozog egyik ilyen körül már ezeket a nyilakat megy innen van,
és ahogyan azt határozza meg, hogy a nyíl volt, ha nagyítani egy kicsit,
és ha jöttem át ezt a nézetet vezérlő,
és itt egy cellába, és azt akarom mondani, hogy ha megérinti a cella
Azt akarom, hogy csúszik át másik képernyőre.
Én egyszerűen tartsa lenyomva a kontroll,
lépjünk át egy kicsit, tartsa lenyomva a vezérlő, húzza a cella felett, és elengedte.
>> És itt azt mondjuk, hogy mi az átmenetet, hogy a használni kívánt?
Szeretné használni, hogy slide dolog, hogy hívják nyomó?
Szeretné, hogy csúszik fel az alján?
Ezt hívják modális.
És ha rákattintok egy ilyen, ez lesz felhívni erre a nyílra nekem,
és ez azt jelenti, hogy én már tényleg kezelni, mi történik, ha megnyomom ezt a gombot grafikusan.
Én nem írtam semmilyen kódot, hogy valóban csúszik az egyik képernyőn a következő egy.
Meghatároztam ezt vizuálisan belül Interface Builder.
Ha kattintson erre a nyílra, láthatjuk, hogy én adtam ezt a dolgot egy nevet.
Hívtam showDivisions, és ez így van, hogy tudok tudom
milyen átmenet van szó fordul elő, és majd meglátjuk, miért csak egy másodperc.
Így voltam vezetékes A különböző képernyők az én kb.
Ha ez egy gombot, például, nem pedig egy tábla nézet,
Tudtam irányítani kattintson a gombra, húzza át a következő képernyőn,
és ez hogyan tudok csinálni navigációs így.
>> Igazán gyorsan, ha jön a MasterViewController,
Ismét, mi egyszerűen csak megy, hogy meghatározzák a listát azokról a dolgokról
amely megjelenik a tábla nézetben.
Itt mondom, azt akarom, hogy ezt a plist fájl,
és azt akarom, hogy töltsön fel egy szótár,
és ha van, hogy szótár, fogok válaszolni e ugyanazokra a kérdésekre újra.
Itt a szakaszok száma.
Az egyik, van egy sor minden bajnoki, és a szöveg minden egyes cella
kell lennie, vagy az első, az első osztály, a második liga, és így tovább.
Végül, fogom használni ezt a módszert, hogy csak látta hívott prepareForSegue,
és ez az a módszer, ami lesz rúgva, amikor rákattintok
az egyik, és ezért azokat a sorokat aktiválása, hogy az átmenet
hogy én létre a nyilak.
Ez azt mondja, hogy én is több
kapcsolatok a képernyőn egy másik.
Ha van 2 gomb és az egyes gombot úgy, hogy egy másik képernyőre
Megyek már 2 segues, 1 az egyes gombot.
De ez prepareForSegue van, újra lesz újra
minden egyes különböző kapcsolatok, így ez azt jelenti, hogy szükség van egy út
azonosítására, ha megnyomja az első gombot, vagy nyomja meg a második gombot.
>> Emlékszel, amikor adtam, hogy Segue nevet, ez a showDivisions,
hogy így most már tudom, hogy ez a Segue hogy működésbe lépett.
Minden, amit akarok, azt akarom mondani,
Azt akarom, hogy kitaláljuk, mi csak hit,
és így kap, hogy azt mondhatom, azt akarom, hogy indexPath a kiválasztott sor,
emlékszik a indexPath csak azt mondja, ha én csak rákattint,
majd azt akarom mondani, hogy akarom, hogy kitaláljuk, hová megyek.
Ez destinationViewController, ez a tulajdonság a Segue.
Ez a képernyő megyek,
úgy tudom, hogy a képernyőn fogok nevezik DivisionsViewController
mert hoztam létre az osztályban,
és most, ha azt mondom d.divisions
Én most beállításával tulajdonság azon a véleményen adatkezelő fogok menni.
Így Küldök adatokat a képernyőn egy másik képernyőre.
>> Csak nézi most ezt DivisionsViewController
itt látható, hogy a. h fájlban
van, hogy az ingatlan üzletágak, és ez az, amit én alapvetően benépesítő,
így van, hogyan tudom, hogy én vagyok megjelenítésére osztályok megfelelő
a liga, hogy csattant, és újra,
a tábla tényleges véli, úgy néz ki, nagyjából ugyanaz, csak az üzenetrögzítő
3 egyszerű kérdésekre, valamint az azonosító
mi történik, ha léphet a következő képernyőre.
Csak egy pár más dolog itt.
Azt veszi észre, a csúcson van, hogy ahelyett, mondván: # include
Én most azt mondják # importálni.
Ez csak egy Objective-C dolog.
Az import alapvetően egy szebb változata többek között,
és például, tudnunk kell, hogy mi ez az osztály,
így nem tudok csak mondani DivisionsViewController.
Ha nem hashtag standardio.c belül mi. C file
a fordító volt, fogalmam sincs, mit printf volt.
Hasonlóképpen, ha nem importálja a DivisionsViewController
a fordító tényleg fogalmam sincs, mi a DivisionsViewController van.
Csak győződjön meg arról, hogy belül a különböző. M fájlokat, győződjön meg arról, hogy a behozatali
a megfelelő. h fájlokat, oly módon, hogy a fordító tudja, mi folyik itt.
>> Végezetül, mit jelent az Apple végül is adatokat jelenítik meg egy web kilátás,
és így a web nézet egy tárgy, amelynek segítségével beágyaz
egy kis böngésző belsejében a kb.
Mindössze annyit kell tennie, hogy az URL-t a böngésző,
ezért szeretnék menni mlb.mlb.com,
és ez hogyan lehet hozzáférni a honlap minden egyes csapatnak,
és így az áthaladó e URL
A Web View képes megjeleníteni ezt nekem, és én is böngészhet körül,
és szimulátor használja azt.
Most ez jött az én plist.
Ha rákattint erre ezt is jött az én plist, és ezt a csúszó kezelték
meghatározásával e segues.
Én rákattint erre, és még egy,
és most itt van a UIWebView, úgyhogy csak úgy
itt a honlapon az URL-címet, hogy én csak a beágyazott,
és nem kell kezelni semmit őrült.
Ezt hogyan kell megjeleníteni egy internetes oldalon.
Dolgok, mint ez a vissza gomb itt is adott nekem
teljesen ingyen, mert már definiált ezeket a kapcsolatokat a segues.
>> Van még kérdése? Igen.
[Student] Szóval ha használja alloc, soha nem szabad semmit?
Pontosan, amikor telefonál, és alloc init nem kell szabadítani azt.
IOS fogja kezelni az összes e az Ön számára.
Ez csodálatos, és te nem törés semmilyen szabályt. Igen.
[Student] Ha volt, hogy több csapat is fér el a képernyőn,
lenne automatikusan egy scroll lehetőség, vagy az, hogy valami, amit hozzá kell adni?
Pontosan, ha lenne több csapat, például, ez automatikusan kezeli
a görgetés nekem, és az összes teljesítmény aggályok
A hatalmas táblázat is kezeli teljesen értem.
>> Egyéb kérdés?
Mindez kód lesz közzétéve.
Azt a fajta glossed egy kicsit a több kisebb részleteket,
de a dolgok, mint a beállítás néhány tulajdonságot az interneten nézet
csak dolog, hogy lehet kapni a böngészést Apple dokumentációja,
, ami nagyon, nagyon szépen lefektetett.
Nekik van egy csomó minta alkalmazások és felhasználások példa
A különböző API-k, így biztosan elolvassa ezeket, ha tudsz.
Csak néhány hasznos linkeket érdemes egy pillantást.
Ezek néhány hasznos dokumentációt útmutatókat.
Az URL-ek hatalmas, így ők rövidíteni.
Ez az első az egész könyvtár dokumentációt.
Kevés keresés bárok, így ha elkezdi gépelni gomb
kezd így az összes információt az összes dolog, amit tehetünk egy gombbal.
Én is benne a Table View Programming Guide.
Ez kezeli a táblázat nézetek sokkal részletesebben,
hogyan kell csinálni a dolgokat, mint a dinamikusan hozzáadni sejtek vagy szerkesztés sejtek vagy távolítsa el őket.
>> Van sok minta apps az Apple-től, hogy megmutatja, hogyan kell csinálni, hogy a
és végül, ez utóbbi az egyik a Human Interface iránymutatás
és ez alapvetően néhány vita UI komponensek,
dolgok, mint nem, hogy egy gomb, amely a 4 pixel 4 pixellel.
Ez egy rossz ötlet, és sok más dolog, hogy az Apple azt akarja csinálni
ösztönzése a jó design.
>> Bármilyen utolsó kérdés, mielőtt befejeznénk fel?
Rendben, biztosan nyugodtan haladhat-mi lesz speciális címkék megvitatni.
Lesz egy iOS egy, így biztosan nyugodtan használják ezt.
Ha azt szeretnénk, hogy működjön együtt az osztálytársaival a projektek
vagy segít kitalálni valami random iOS stuff
nyugodtan e-mailt nekem, és határozottan elolvas az összes kódot online, mert
Csak az az érdeke, mire ilyen glossed feletti látna
finomabb részleteket a dolgokat.
De ha nem, akkor sok szerencsét a iOS projekteket, és remélem, mi
egy nagy beáramló apps az App Store-ban.
[CS50.TV]