[Powered by Google Translate] [Seminario] [iOS: Scrivere applicazioni Like a Boss]
[Tommy MacWilliam] [Harvard University]
[Questo è CS50.] [CS50.TV]
>> Va bene, tutti, benvenuti a iOS: Scrivere applicazioni come un Boss.
Questo seminario si concentrerà sulla scrittura di applicazioni per l'iPhone
e, a sua volta scrivere applicazioni per l'iPad, e quindi stiamo andando praticamente a piedi attraverso
un paio di esempi diversi di come fare un app, un gioco semplice come Tic Tac Toe,
o se siete più interessati a fare un app come una specie di lettore di news
o qualcosa che interagisce con Internet parlerò anche di questo.
Ecco il nostro ordine del giorno breve.
>> Applicazioni IOS sono scritti in un linguaggio chiamato Objective-C,
e quindi questo è un po 'simile al C ma non lo sono affatto,
così parleremo un po 'di lingua stessa
e poi come costruire applicazioni per iPhone utilizzando questo programma app chiamato XCode,
che se non l'avete ancora scaricato sentitevi liberi di avviare il download adesso.
Si tratta di diversi gigabyte.
Dovrebbe essere gratuito su App Store, quindi avrai bisogno di avere un Mac
idealmente utilizzando l'ultima versione di OS X.
Se non sei, non c'è problema.
Abbiamo Mac nel centro scientifiche disponibili per il vostro uso
con XCode installato, e quindi sentitevi liberi di utilizzare quelli per lo sviluppo.
Se si desidera fare un app, ma non hanno un Mac, non ti preoccupare.
C'è un sacco di risorse del campus per questo.
E così poi andremo a coprire 2 esempi più grandi di applicazioni che si possono fare.
Objective-C è tecnicamente quello che si chiama un insieme di super C.
Questo significa che il codice C è valida anche codice Objective-C.
Ciò significa che tipo di canale registrato su alcune caratteristiche aggiuntive a C.
Alcune di queste caratteristiche comprendono non dover scrivere mai malloc di nuovo, grazie a Dio,
non doversi preoccupare di tali puntatori stupidi e liberarli e tutta quella roba
hai odiato di C, ed è una specie di andata in Objective-C.
>> Ora, Objective-C ha anche una libreria standard molto più grande,
quindi non c'è funzionalità molto di più si ottiene per interno privo di Objective-C.
Ti ricordi quando stavamo scrivendo PHP abbiamo notato che siamo passati da
questa piccola lingua alla libreria gigante di tutte queste cose folli che si possono fare.
La stessa cosa accade in iOS.
Ci sono oggetti per cose come il calendario buddista, e davvero nulla
si può eventualmente pensare esiste probabilmente già in attuazione di Objective-C.
La parte obiettivo di Objective-C è qualcosa di riferimento
chiamato Object-Oriented Programming.
Questa è una specie di un nuovo concetto, ma abbiamo imparato in realtà per lo più
molti di questi concetti già.
L'idea alla base di Programmazione orientata agli oggetti è che si sta andando a strutturare
un sacco di codice intorno a queste cose chiamati classi,
e queste classi sono davvero glorificato strutture.
All'interno di una struttura abbiamo praticamente detto qui è una cosa,
e questa cosa può avere membri.
Ad esempio, un nodo in una lista collegata potrebbe avere altre cose
come un valore, un puntatore al nodo successivo nella lista,
e insieme quel puntatore e che il valore composto da questa istanza di una struttura.
Le classi sono molto simili, tranne
classi possono anche avere funzioni all'interno di essi.
Quando abbiamo dichiarato una struct, possiamo solo dire int n * o nodo successivo.
>> Ora, con Objective-C si può effettivamente mettere funzioni
all'interno di quelle cose.
Un'altra cosa che le classi possono fare è che i dati possono ereditare da altre classi.
Per esempio, ci troveremmo di fronte a un gruppo di built-in Objective-C classi.
Uno di loro potrebbe essere la classe che rappresenta la visualizzazione di una schermata,
e così dicendo Voglio implementare mio punto di vista
abbiamo praticamente diciamo assieme alla Apple, la gente probabilmente veramente bello,
ha scritto questa classe per me, e gestisce le cose come la visualizzazione di pulsanti
o rendere lo schermo, e ci sarebbe veramente addolorato
di attuare tutto ciò che noi stessi le funzionalità, e così semplicemente
ereditando dati possiamo dire tutto quello che hai fatto in quella classe
Voglio anche all'interno della mia classe, e poi ho intenzione di fare un po 'di altre cose,
vale a dire realizzare un app.
Questo è ciò che la parola significa eredità. Vedremo un esempio più concreto.
>> E, infine, la chiave con Programmazione orientata agli oggetti è che
porta ad incapsulamento dei dati.
In alcuni dei nostri problemi imposta potremmo avere questi grandi, le variabili globali
e globali in tutto il mondo, e questo è il modo in cui ci tenere traccia dello stato.
Con le classi possiamo iniziare a incapsulare le informazioni all'interno di un oggetto.
Se abbiamo uno schermo sulla nostra applicazione, non abbiamo davvero bisogno di avere tutti i dati di
un altro schermo nella nostra applicazione all'interno di questo,
e così, incapsulando le cose all'interno delle classi di questa realtà conduce
di progettazione di codice molto meglio, e questo è possibile con alcune delle caratteristiche aggiuntive
di Objective-C.
Preavviso, la sintassi per Objective-C è banane.
E 'qualcosa che non abbiamo visto prima,
quindi è un po 'di una curva di apprendimento per abituarsi
che diavolo significa?
Ma una volta passato che curva di apprendimento iniziale è davvero, davvero liscia
per iniziare a scrivere applicazioni.
>> Per dichiarare una classe, a dire qui è la mia classe, esiste,
e forse qui ci sono alcune cose che ho intenzione di definire in seguito,
Io vado a dire l'interfaccia @.
Io vado a dire l'interfaccia @. Ho intenzione di dare la mia classe un nome.
E poi da qualche altra parte ho intenzione di dire @ end,
e tutto il resto l'interfaccia e la fine @ @
sarà la mia classe.
Questo sarà quello che c'è dentro i nostri file. H.
Proprio come in C i nostri file. H ha detto in sostanza qui ci sono alcune cose che esistono.
Non sto necessariamente dicendo quello che fanno ancora,
ma il compilatore ha bisogno di sapere che esistono.
In seguito all'interno del nostro. M file, perché m per Objective-C
è dove stiamo effettivamente andando a definire ciò che fanno queste classi.
Proprio come i nostri. File c, abbiamo fornito un'implementazione per le funzioni.
All'interno della nostra. M del file che andremo a dire qui è quello che tutte le funzioni
all'interno della mia classe, che cosa fanno tutti.
E, infine, all'interno di una struttura potremmo dire all'interno di tali parentesi graffe
int, n o nodo successivo *
e in Objective-C che andremo a utilizzare la parola chiave @ property
e questo è quello che sta succedendo per definire le proprietà,
o le non-funzioni che fanno parte dei miei corsi.
>> Chiamare funzioni in Objective-C è anche banane.
Quando abbiamo dichiarato le funzioni in C abbiamo detto qualcosa del tipo int foo
e aperta parentesi e poi ha dato un elenco di argomenti.
Questo è ciò che dichiara metodi o funzioni si presenta come in Objective-C.
Se voglio dichiarare una funzione o di un metodo
dove sto dicendo che il metodo è in realtà solo una funzione che è un membro di una classe,
molto gentile da parte intercambiabili, ma non proprio,
così all'interno del mio metodo che voglio creare un nuovo metodo.
E 'intenzione di restituire alcun valore, in modo che sarà di tipo void.
Questo è il tipo di ritorno della mia funzione.
Ora abbiamo parentesi qui perché, non lo so.
Prossimo sarà il nome della mia funzione,
e poi finalmente abbiamo un punto e virgola, proprio come abbiamo avuto in C.
Cosa c'è di nuovo qui è questo tizio qui.
Questo trattino è effettivamente necessario, e ciò che dice è che questo
questo metodo qui deve essere chiamato in un'istanza di una classe.
>> Dopo aver dichiarato le nostre strutture che probabilmente ha detto qualcosa di simile
n nodo struct, e che in realtà ha creato
un'istanza o una di quelle strutture in modo da poter effettivamente iniziare a lavorare
con quello che c'è dentro di essa, quindi questo trattino significa che dobbiamo
creare un'istanza della classe, proprio come abbiamo un'istanza che struct
prima di poter chiamare questo metodo su di esso.
Se voglio iniziare ad aggiungere argomenti per i miei metodi
diventa ancora più banane.
Ecco il mio nome del metodo.
Poi ho intenzione di avere due punti, due punti e dopo questo qui dice che arriva alcuni argomenti.
Questo metodo accetta un argomento.
Il tipo della sua tesi è un int, e il nome di tale argomento
o la variabile che ho intenzione di iniziare a utilizzare all'interno del metodo è ho chiamato.
Di nuovo, questo è il metodo. Prende un argomento.
>> Se si desidera iniziare ad aggiungere più argomenti diventa più banane
in quanto abbiamo il colon che dice ecco che arriva la mia lista di argomenti.
Il primo argomento è un numero intero.
Ora, questo secondo argomento è interessante.
La variabile che ho intenzione di utilizzare all'interno della mia funzione
si chiama f, quindi all'interno della mia funzione potrei dire
f + = 1 o qualcosa del genere.
Questa cosa qui è fondamentalmente una chiave per l'argomento o parametro.
Proprio come abbiamo avuto coppie di valori chiave e qualcosa come JSON o array associativi
Objective-C ha preso la decisione di dire, va bene, solo in modo che è davvero chiaro
quando si chiama un metodo che cosa tutti questi parametri sono
In realtà sto andando a nominarli tutti.
Quando si chiama un metodo, ci troveremo a dire andFloat,
e poi ti trovi a passare
>> È interessante notare, questo non è nominato, ma tutti gli altri parametri,
quindi se abbiamo avuto una discussione 3 potrei dire andFloat
e un altro galleggiante e così via.
Quando chiamo questi metodi è di banane del corso,
quindi se ho un oggetto, e ho definito un metodo chiamato foo,
e voglio chiamarlo, piuttosto che dire foo aperto / chiudi parentesi
Ho intenzione di aprire una parentesi.
Ecco il nome del mio metodo.
Ho intenzione di chiudere la parentesi, e questo è l'oggetto che sto chiamando su di esso.
Ricordate, tutti questi metodi esistono all'interno delle classi
perché le classi possono avere metodi definiti all'interno di essi.
>> Qui ho arbitrariamente creato un oggetto di una classe,
e questa è la sintassi per farlo.
Ci sono 2 fasi per la creazione di un oggetto.
Il primo passo è quello di dire che voglio per allocare lo spazio.
Questo è l'equivalente di un malloc. Noi non abbiamo da dire malloc più.
Abbiamo lasciato la m, ha reso alloc, e sostituito il. C con. M.
Dopo aver qualcosa alloc abbiamo poi bisogno di inizializzarlo.
In pratica quando si creano oggetti che si potrebbe desiderare di avere un po 'di logica
che viene eseguito quando vengono creati, in modo da poter passare in alcuni valori di default
o qualcosa del genere, e quindi questo metodo init è ciò che crea l'oggetto.
In primo luogo abbiamo allocare lo spazio, proprio come abbiamo fatto in C,
e poi inizializzarlo, che può o non può fare un bel po '.
Poi stiamo tornando questa cosa in un oggetto o.
C'è una stella qui perché questo è tecnicamente un puntatore,
ma non preoccupatevi, i puntatori non sono un grosso problema in Objective-C più.
>> Ora abbiamo istanziato la classe chiamata NSObject,
e questo è solo una classe casuale che Apple ha.
Abbiamo istanziato questo, e ora ho una istanza di questa classe
o in questo oggetto, in modo che significa che se ho definito
questi metodi Potrei chiamare in questo modo.
Allo stesso modo, se volevo chiamare un metodo con un argomento,
quindi questo è il metodo bar, che accetta un argomento,
ed ecco la baz: metodo Qux, quindi questo richiede 2 argomenti.
Questo si chiama una funzione di questo oggetto o.
Ha senso?
La sintassi dovrebbe avere un senso, ma è tipo di abituarsi ad esso.
>> Ok, parliamo di un paio di cose che sono costruiti in Objective-C
che non sono stati necessariamente integrato in C.
In C abbiamo tipo avuto a che fare con le stringhe come array di caratteri di questi stupidi,
e ha ottenuto davvero fastidioso.
Objective-C è di quelli tutto integrato per noi, ed è costruito in
utilizzo di questa classe denominata NSString.
Quando voglio creare un NSString abbiamo sintassi più arcana.
Piuttosto che dire "CS50" diciamo @ "CS50"
e questo è solo la sintassi per dichiarare le stringhe in Objective-C.
Questo è estremamente facile da dimenticare, in modo da non farlo.
Ora, una volta che ho questa, questa è una stringa, a meno di notare
in realtà è solo un oggetto.
Ho detto NSString, il che significa che un'istanza della classe
chiamato NSString, che qualcun altro ha scritto per me,
ed erano molto bello su di esso, e così ora
Posso iniziare a chiamare i metodi su di esso.
Se chiamo il metodo della lunghezza di s questo oggetto
che sta per tornare da me la lunghezza della stringa.
Questo è proprio come strlen in C.
Questo ritorno 4.
>> Allo stesso modo, un altro metodo che potrebbe desiderare da tenere presente è questo characterAtIndex.
Questo è un metodo che dice su questa stringa s
Voglio che per ottenere il carattere 0,
e quindi questo sarebbe tornato a me il carattere c,
e c'è un bel po 'più di questi metodi che è possibile Google davvero facilmente.
Documentazione di Apple è grande, e noi provvederemo a dare un'occhiata a che in un po '.
Queste sono le stringhe.
Abbiamo anche array di dimensione variabile costruito pollici
Ricorda in C quando abbiamo dichiarato un array
abbiamo dovuto dire di avere 5 elementi, fine della storia.
Quando siamo arrivati ​​a JavaScript e PHP si potrebbe iniziare
fare le cose come l'aggiunta di elementi o elementi in movimento.
Siamo in grado di fare lo stesso in Objective-C.
Invece di creare un array in modo normale C
abbiamo di nuovo un'altra classe denominata NSMutableArray.
C'è anche NSArray,
e questo sta per incapsulare in fondo un po 'di array.
Questo dice la prima cosa che voglio fare è che voglio assegnare
spazio per un nuovo array, e dopo che l'ho allocare
Ho quindi bisogno di inizializzarlo.
Anche in questo caso, basta chiamare questi 2 metodi.
Ora, questo significa che all'interno di questo oggetto un
Ho un array vuoto seduto lì.
Se voglio aggiungere qualcosa a questo array, posso chiamare il metodo addObject.
Voglio aggiungere un oggetto alla matrice a, e voglio aggiungere la stringa CS50.
Se avessi voluto rimuovere viceversa che posso dire che voglio
rimuovere l'oggetto al primo posto in un array o un oggetto.
>> Ha senso?
Ok, tipo di abituarsi a questa cosa parentesi quadra.
Tra l'altro, all'interno di un sacco di librerie di Apple vedrete questo NS.
Il NS sta effettivamente per passo successivo, che è stata una delle prime aziende Steve Jobs,
ed è lì che ha davvero iniziato a scrivere un sacco di codice
come una sorta di base per Mac OS X e tutte le altre cose,
e quindi questo NS è una specie di questa eredità bel gridare ad una delle società precedenti
indietro quando Apple è stato prima di partire.
E 'ovunque.
Diamo un'occhiata a un approccio olistico più Objective-C esempio.
Eccomi all'interno di XCode.
Per arrivare qui, ho scaricato XCode da App Store,
lo aprì, e poi sono andato qui in un file,
qui di nuovo progetto, e poi.
Dopo lo faccio ho tutte queste opzioni di ciò che voglio creare,
e così daremo uno sguardo a queste opzioni in seguito,
ma proprio per questo esempio, perché non stiamo in realtà sta per avere un app ancora,
Sono venuto qui, e ho detto a riga di comando,
e questo è un app che ho potuto eseguire dalla riga di comando
proprio come siamo stati in esecuzione da C.
È così che ho creato questo progetto, e così ora sono qui,
quindi diamo prima occhiata a questo file, e questo dovrebbe essere abbastanza familiare.
Ho un nome int. Ecco il mio argc amico, il mio altro amico argv.
E così possiamo vedere che questo è il punto di ingresso per il mio primo obiettivo-C.
Qui possiamo ignorare questo per ora.
Questo è fondamentalmente un po 'di roba di gestione della memoria che si vuole veramente
mai si deve preoccupare.
>> Diamo un'occhiata a questo primo blocco qui.
La prima linea, se dico Student * alice = [[alloc studente] init] cosa che fai?
Questo primo studente qui, questo è probabilmente una classe.
Non si tratta di una classe che ha scritto di Apple, ma è una classe che ho scritto.
La prima cosa che voglio fare è che voglio allocare spazio per un nuovo studente,
e poi voglio inizializzarlo, quindi questo mi restituisce
questo oggetto nuovo studente, e sto memorizzando questo in una variabile chiamata Alice.
Da dove viene quella classe viene?
Beh, qui a sinistra sono tutti i file di diverse all'interno del mio progetto.
Possiamo vedere qui ho un Student.h e Student.m.
Il file. H, lo ricordiamo, è dove dichiaro tutte le cose
che esistono all'interno della classe.
>> Diamo uno sguardo a questo.
Va bene, qui abbiamo questa interfaccia @, e questo dice che viene qui
le dichiarazioni di tutto ciò che esiste all'interno della mia classe.
Poi ho due punti. Poi ho questa cosa NSObject.
Questo significa che due punti po eredità stavamo discutendo un po 'prima.
Questo dice tutto quello che un NSObject può fare
dove NSObject è questa classe scritto da qualcun altro,
tutto questo può fare NSObject Voglio essere in grado di farlo.
Dicendo: NSObject che significa che in pratica
ereditato tutte le funzionalità di un'altra classe.
Questo mi ha dato un sacco di diversi metodi e proprietà che posso utilizzare.
Quaggiù Sto creando 2 immobili.
Ciò significa che il mio studente, se si trattasse di una struttura, queste sarebbero le 2 cose
interno della mia struttura, in modo che ogni studente ha un nome
che è una stringa, e uno studente ha anche un grado,
che è un int.
>> Infine, qui ho intenzione di creare un metodo per il mio studente.
Ho chiamato il mio metodo, initWithName, e ci vuole un argomento,
e questo argomento è una stringa, e ho chiamato il nome.
Ora diamo un'occhiata a come in realtà abbiamo implementato questa classe.
Ecco, ora sono all'interno del mio file. M,
m per l'attuazione, credo.
Ho la mia realizzazione, la mia fine, e qui è dove sto in realtà la definizione di
cosa initWithName fa.
Ho initWithName, il nome del mio parametro, e quindi questo
è dove sto realtà la creazione di uno studente,
e quindi questo è un po 'criptico, ma questo è una specie di boilerplate
che si desidera includere nei costruttori.
Questa funzione di inizializzazione qui, initWithName, è un tipo di costruzione.
Tu sei fondamentalmente la costruzione di un nuovo oggetto studente
e forse l'invio di alcuni dati all'interno di esso.
La prima cosa che voglio fare è che voglio chiamare init su questa cosa super.
>> Ricorda che quando ho detto di nuovo qui nel file. H
che ogni cosa ha un NSObject uno studente ha anche.
Ciò significa che quando creo uno studente quello che anch'io ho bisogno di fare è
assicurarsi che il NSObject che sto ereditare tutti i dati da
è inizializzato correttamente.
Che cosa ho bisogno di dire è questo super è in realtà sta per fare riferimento alla classe padre
che sto ereditando da, quindi voglio essere sicuro di inizializzare
tutto quello che sto seconda prima di iniziare a provare a usarlo.
Poi, se inizializzato correttamente che questo è proprio come dire se malloc
non ha restituito nulla allora posso iniziare a impostare alcune proprietà.
>> In JavaScript e PHP abbiamo questa parola chiave chiamato questo,
e ciò di cui l'istanza corrente di una classe.
In Objective-C che noi chiamiamo questa auto.
Quando dico self.name, che significa che l'oggetto
Ho appena creato quando ho detto alloc studente init,
che sta per restituirmi un oggetto.
Questo significa che voglio impostare il nome di tale oggetto
a tutto ciò che ho appena superato trovi
Proprio come in C, si accede ai membri di questo punto,
così self.name dice il nome dell'oggetto studente
sta ora per essere quello che trovi appena passato
E così alla fine, posso tornare quindi dovrei tornare qualcosa.
>> Domande?
Ok, allora questa auto = super-init,
se non completamente capire la roba eredità non ti preoccupare.
Basta sapere che se si volesse fare un proprio metodo init solo
farlo, e sarete pronti per partire.
Si '. >> [Studente] Che cosa significa se stessi?
Questo significa che quando si malloc qualcosa che abbiamo sempre controllato se fosse uguale a zero,
e se fosse nullo, allora siamo usciti.
Questa è la stessa cosa, perché se questo restituisce null, allora probabilmente stai andando a guasto seg
se cominciamo cercando di manipolarla.
Questa è la nostra classe di studenti.
Questo significa che siamo in grado di inizializzare i nostri studenti in uno dei due modi.
Se dico alloc studente init non sto usando questo metodo che ho appena scritto,
e invece posso semplicemente dire alice.name,
e ora ho intenzione di impostare il nome della proprietà.
>> Allo stesso modo, se voglio usare questo metodo initWithName
Posso semplicemente dire alloc, e quindi invece di dire init
Io vado a chiamare il metodo che ho appena creato, e ho intenzione di passare in Bob.
A questo punto, questo Bob oggetto ha un nome uguale a Bob.
Ok, qui sto usando che NSMutableArray che abbiamo esaminato in precedenza.
Sto assegnazione space.Then sto l'inizializzazione di una nuova matrice.
Ho intenzione di aggiungere 2 cose ad esso.
Questo array ora detiene oggetti studenti.
Si noti che da nessuna parte ho dire che questo è un array di studenti.
Ho detto che è un, periodo di array.
Allora posso mettere quello all'interno di esso che voglio.
Qui ho 2 oggetti.
>> Infine, ho un altro oggetto qui, questo TF.
Da noi in TF.h fondamentalmente la stessa cosa.
Sto ereditando da NSObject, e tra l'altro,
quando si crea classi di tutto questo è fatto per voi,
questo tipo di interfaccia boilerplate.
Ha una proprietà di studenti.
Ho un paio di metodi qui che in realtà non fanno un bel po ',
e quindi questo significa che dopo che ho creare questo oggetto TF
Posso chiamare questo metodo su di grado in questo modo.
Hai domande su Objective-C la sintassi prima di iniziare a muoversi in qualche altro
interessante sviluppo applicazioni roba?
>> Va bene, quindi cerchiamo di fare in realtà una applicazione per iPhone.
Le classi principali che userete all'interno della vostra applicazione per iPhone sono chiamati controller di vista,
e un controller di vista rappresenta sostanzialmente un unico schermo
all'interno della vostra applicazione, quindi se sono in app musica, per esempio,
un controller di vista potrebbe rappresentare la vista in cui visionare tutte le canzoni sul mio iPhone.
Un altro controller della vista potrebbe essere quando si fa clic su un brano e iniziare a giocare
o come sto il drill-down in artisti.
Ciascuno di tali schermi diversi potrebbe essere rappresentato come un controller di vista diverso,
e un controller di vista è in realtà solo una classe che dice come funziona questa schermata.
Cose all'interno di un controller della vista, abbiamo intenzione di avere proprietà,
quindi le cose come un pulsante sta per essere una proprietà del nostro controller della vista.
>> Stiamo anche andando a disporre di metodi, e questi sono fondamentalmente i gestori di eventi.
Questo metodo dice che quando si preme questo tasto
Voglio fare qualcosa, e, infine, ancora una volta,
abbiamo intenzione di utilizzare questa parola chiave auto per accedere all'istanza corrente.
Per costruire interfacce in iOS è in realtà molto, molto facile.
Hanno questa resistenza piacevole e l'interfaccia menu chiamato Interface Builder,
e il Core 2 concetti che collegate i vostri Objective-C e Interface Builder
sono IBOutlet e IBAction.
Un IBOutlet dice semplicemente che se si dichiara una proprietà che è un pulsante,
e si desidera collegarlo a qualcosa nella vostra interfaccia utente reale,
si sta andando a dire che è una presa di corrente.
Allo stesso modo, se si vuole rappresentare un gestore di eventi
allora si sta andando a dire che è un'azione.
>> Per cablare in realtà fino questa rappresentazione grafica
e il tuo codice è molto, molto semplice.
Se si desidera collegare un IBOutlet, tutto ciò che dovete fare è di controllare clic,
e vedremo un esempio di questo davvero veloce.
Sei tu che controlli fare clic su cui si dice View Controller.
Stai andando a trascinare nell'interfaccia, o viceversa,
se si desidera collegare un gestore di evento che si vuole trascinare dall'interfaccia
nella direzione opposta.
Diamo un'occhiata a un esempio molto semplice iOS.
>> Creiamo un nuovo progetto.
Ho intenzione di venire qui ad applicazione,
e ho intenzione di fare clic su Applicazione Singola Vista.
Ho intenzione di fare clic su Avanti. Darò il mio progetto un nome.
Io lo chiamo Ciao.
È interessante notare che Apple non si assume che si sta creando un prodotto
in modo che si può vendere e possono fare i soldi.
Quaggiù ho intenzione di dire che si tratta di una applicazione per iPhone.
È possibile creare un app per iPad, o se si desidera creare una di quelle applicazioni
che supporta entrambi i dispositivi che si possono fare anche questo.
Si tratta di ciò che si desidera che il segno di spunta a guardare come.
>> Si desidera utilizzare storyboard, che vedremo più avanti,
e se lo desiderate utilizzare il conteggio automatico di riferimento,
che è una bella caratteristica che ti impedisce di dover dire malloc e free.
A meno che non si desidera chiamare malloc e free, avrei lasciate selezionata.
Io fare clic su Avanti, e, infine, si tratta di andare a chiedere a me dove voglio salvarlo.
Mi ha colpito di creare, e ci siamo.
Ho creato un nuovo progetto.
Nel corso qui a sinistra sono tutti i file che si trovano all'interno del mio progetto,
e notare che ho un sacco, e non ho nemmeno fatto niente.
IOS è grande.
>> Ad esempio, qui questo ViewController.h,
questo sta andando a rappresentare il mio primo controller di vista,
in modo che la prima schermata all'interno della mia app.
Ora sappiamo che cosa sta dicendo.
Stiamo dicendo che chiamo questo ViewController classe,
e un ViewController fa tutto ciò che un UIViewController fa,
e questo, ancora una volta, è una classe che Apple ha scritto che fa un sacco di cose a portata di mano per noi
come visualizzare la schermata.
Qui è dove io possa effettivamente iniziare a definire ciò che il mio controller della vista fa,
e si scopre che davvero non hanno bisogno di niente di tutto questo.
Si tratta di codice standard che Apple mi dà gratuitamente.
Ho bisogno che la prima linea, o non ho una classe,
in modo da poter sbarazzarsi di quella e di sbarazzarsi di questo.
Ok, allora questa è la mia schermata vuota.
>> Ora clicca su questo MainStoryboard.storyboard,
ed è qui che inizia a diventare interessante.
Questo rappresenta la prima schermata sul mio app.
Se voglio aggiungere un pulsante, in HTML ho dovuto creare un tag pulsante.
In Android è necessario creare una variabile pulsante,
ma in iOS se ho appena venuto qui in basso a destra
e se clicco su questo terzo qui dove si dice oggetti,
e posso scorrere verso il basso, oppure posso iniziare a cercare per il pulsante.
E guarda, un pulsante, quindi se ho effettivamente trascinare questo proprio lì,
Ho appena aggiunto un pulsante per questa schermata sul mio app.
Se voglio modificare il testo, posso fare doppio clic su di esso,
dire qualcosa di seducente come "Me Premere".
Ok, ora se corro questo app, quindi abbiamo compilato,
in modo da eseguirlo clicco sul pulsante play in alto a sinistra, e c'è la mia app.
Io non ho fatto niente, e ho avuto un app iPhone dolce cercando.
Se voglio fermarlo, è possibile fare clic sul pulsante di arresto
perché è più divertente.
>> Diciamo che io in realtà voglio che accada qualcosa quando si preme questo tasto.
Per fare questo quello che devo fare è che ho bisogno di creare
un gestore nuovo evento o un'azione.
Questo significa che ho bisogno di creare un metodo che voglio essere chiamato
quando si preme il pulsante, quindi cerchiamo di creare un nuovo metodo.
Sono dentro di ViewController.h.
Ho bisogno di dire che un metodo esiste.
Ho bisogno di un primo trattino, perché ho intenzione di chiamare questo sul controller della vista.
Ho bisogno di dare a questo un tipo.
Il tipo di questo sarà che cosa IBAction che abbiamo visto in precedenza.
Si tratta di un gestore di eventi, in modo che sta per restituire un IBAction,
e questo è un suggerimento per XCode dire che
questo è qualcosa che voglio collegare a qualcosa.
Posso dare un nome, come buttonPressed, punto e virgola.
>> Ora ho dichiarato un nuovo metodo all'interno della mia classe.
Ho detto questo metodo deve esistere.
Ora veniamo in ViewController.m,
e diciamo ciò che questo metodo può fare.
Se inizio a digitare, ad esempio, (void) buttonPressed
Avviso XCode è davvero bello e autocompletes per me.
E 'davvero meraviglioso.
Si noti qui che all'interno del. File di m posso anche dire nulla,
e questo è dovuto al fatto che IBAction non è realmente un tipo.
In realtà è hashtag definito da qualche parte per essere un vuoto,
e di nuovo, questo è solo un suggerimento per XCode che dice
Voglio che questo sia un gestore di eventi, e vedremo perché in un attimo.
Quando si preme questo tasto ho intenzione di fare qualcosa di fastidioso
come visualizzare un popup.
>> Per fare questo posso creare una nuova istanza di questa classe chiamata UIAlertView,
e questa è una classe che Apple ha scritto che sta per visualizzare pop-up fastidiosi.
Chiameremo questo servizio di avvisi pop-up, e ho 2 passi, lo ricordiamo, per la creazione di questo oggetto.
La prima cosa che devi fare è allocare spazio.
Voglio un UIAlertView.
Voglio allocare spazio. Questo è il mio primo metodo.
Il mio metodo successivo è che voglio inizializzarlo,
e così ho questo grande metodo lungo chiamato initWithTitle.
Questo è fondamentalmente andando a controllare ciò che dice questo popup.
Il titolo del mio popup può essere ciao.
Il messaggio di questo pop-up può essere "Questo è iOS."
Cosa delegato, non so di cosa si tratta.
Diciamo che non è niente.
Ora il pulsante che sta per apparire può dire qualcosa del tipo "E 'sicuro"
e io non voglio altri tasti, quindi cerchiamo di eliminare tale e chiudere la staffa.
>> Ok, ho creato uno in più. Ecco fatto.
Questo è come posso creare un nuovo popup.
Se voglio mostrare effettivamente il popup che voglio chiamare il metodo show.
Per fare questo posso dire alert e spettacolo,
e ancora, completamento automatico era super bella.
Se ho dimenticato quello che era, se ho scritto in s,
Posso scorrere qui per capire di cosa si trattasse,
e filtra bene.
Ora ho creato questo nuovo popup.
Torneremo di quanto delegato significa più tardi,
e ora voglio dire che voglio questo metodo per essere licenziato
quando si preme il pulsante, così ho intenzione di tornare al mio storyboard,
e voglio allegare ora questo IBAction.
La prima cosa che voglio fare è fare clic sul pulsante.
Quando si preme questo tasto che voglio che accada qualcosa.
Io non ho intenzione di tenere premuto il controllo.
Ho intenzione di fare clic e trascinare con il pulsante
di qui dove si dice View Controller.
Possiamo vedere che si illumina piacevolmente l'alto.
>> Se lascio andare con il mio mouse ora ho questo popup qui dove ho alcune opzioni.
Uno di questi sono gli eventi che posso registrare.
Si tratta di tutti quei metodi che ho dichiarato nel mio file h come IBActions.
Questo è il modo XCode sa cosa deve apparire in questa piccola lista,
quindi questo è solo un suggerimento.
Se si fa clic sul pulsante premuto, ora ho registrato il gestore eventi.
In JavaScript abbiamo dovuto dire che ho un po 'di codice che ha registrato il gestore eventi.
In Objective-C è stato davvero così facile.
Se corro di nuovo
Ora quando si preme il pulsante il mio gestore di eventi sta per sparare,
e ho intenzione di ottenere questo popup.
Super, super semplice lì.
>> Se mai voglia di vedere tutti gli eventi che accadono da registrare
su un componente se clicco su questo pulsante
e vengo qui a destra
prima si può vedere qui posso fare cose come il tipo di pulsante,
quindi se volete uno di quelli che ho o il pulsante Aggiungi Contatto
o qualsiasi altra cosa.
Se voglio vedere tutti gli eventi che si trovano su questo pulsante
se ho fatto tutta la strada qui a destra
possiamo vedere qui in occasione degli eventi che ho tutti questi diversi eventi.
Posso premere il pulsante, quando ho lasciato andare il tasto, quando si fa doppio tap o qualsiasi altra cosa,
e quello che ho appena registrato questo evento chiamato Ritocco All'interno,
e questo dice che non appena il mio dito si stacca il pulsante
tale evento sta per fuoco, e questo è esattamente quello che è appena accaduto.
Questa è una specie di manifestazione pulsante predefinito premuto.
>> Tutte le domande fino ad ora?
Va bene, è così che possiamo iniziare a collegare le cose nel nostro codice
in cose all'interno della nostra interfaccia.
Ricordate la prima cosa che abbiamo dovuto fare è stato quello di trovare il codice,
e poi abbiamo collegato l'interfaccia al codice,
e c'è la nostra prima applicazione.
Ok, era veramente fresco, e abbiamo creato questo pulsante.
E se non ci si vuole avere per creare un gruppo di proprietà
che rappresenta questi pulsanti?
Ad esempio, in punta di Tic Tac io ho 9 pulsanti,
e sarebbe super, super-fastidioso dover trascinare 9 volte
o se ho dovuto fare Tic Tac Toe con 81 invece di 9
e ho dovuto trascinare 81 volte, e questo è zoppo.
Quello che possiamo fare, invece, è molto simile a un HTML
quando abbiamo avuto cose come ID e nomi e siamo in grado di cercare le cose
dal loro ID, c'è un concetto simile in iOS chiamato tag.
>> Un tag è semplicemente un identificatore numerico univoco per un componente.
Se dico questo ha un tag di 0, per esempio,
se creo un pulsante e dare un tag di 0, e vedremo come farlo in un secondo,
se voglio ottenere quel tasto posso semplicemente dire che desidera chiamare
viewWithTag il metodo sull'oggetto qui,
la self.view, che rappresenta la schermata corrente, per esempio.
Se chiamo il metodo che viewWithTag, ho intenzione di tirare indietro il pulsante con etichetta 0.
Diamo un'occhiata a questo edificio Tic Tac Toe.
In primo luogo, questo è il mio storyboard.
Ho creato questi 10 pulsanti dell'interfaccia utente.
Si noti che sono tutti della stessa dimensione.
Se si fa clic su uno di questi e torno qui su questo lato destro
vedrai ho regolato il carattere proprio qui, così ho fatto il carattere un po 'più grande,
ma quello che ho fatto è stato anche a impostare questo tag.
Ho detto che questo ha un tag di 1, e che è in alto a sinistra.
>> Ora, se si fa clic su un altro pulsante, come questo secondo qui,
Ora vedrai che la mia tag è 2.
Ognuno di questi pulsanti ha solo un unico tag,
e quindi questo è più avanti come ho intenzione di iniziare a interagire
con la mia app.
Questo è tutto all'interno di un controllore vista,
ma ecco quello che abbiamo.
Noi disponiamo di 3 immobili qui.
Il primo e ultimo stanno per rappresentare lo stato della mia tavola.
Fondamentalmente questo primo è un array che rappresenta dove le X e O sono.
Questo altro qui ci dice chi è il turno.
Avrete notato che ho anche queste cose qui.
Prima, quando abbiamo dichiarato proprietà abbiamo dato loro un nome e un tipo.
Si può anche dare loro alcune informazioni aggiuntive qui.
Questo primo dice nonatomic, e ciò che questo dice
è fondamentalmente solo una cosa sarà mai cercare di accedere a questa variabile alla volta.
Si potrebbe fare applicazioni più complesse che sono multi-threaded,
e così torna in Scratch abbiamo avuto diversi thread,
e sprite differenti che si possono fare cose diverse allo stesso tempo.
>> Se questo non è il caso, che non è in tutto ciò che ci troveremmo di fronte a,
se diciamo nonatomic che è in realtà sta per rendere le cose un po 'più veloce.
Abbiamo anche questa cosa chiamata assegnazione, forte o debole.
Questo assegnare dice solo che si tratta di un tipo standard.
Questo non è un oggetto o un puntatore, perché questo è solo un bool,
così bool è incorporato in Objective-C.
Questo dice di non provare a fare niente di eccezionale con i puntatori qui.
Si tratta di un normale scaler vecchio.
Forte e debole, questo debole dice che in realtà
Voglio che questo puntare a qualcosa nel controller della vista.
Non ho intenzione di allocare in atto o in init questo me stesso.
Il costruttore di interfaccia, quando si esegue l'applicazione, sta andando a gestire tutto ciò che l'inizializzazione.
Se dico debole, che dice qualcun altro sta per essere creare questo.
Se dico forte, questo dice che ho intenzione di essere quello
che è la creazione di questo oggetto tavola,
e così qui ho qualche altro metodo qui,
per esempio, un'azione per quando il pulsante viene premuto nuovo gioco,
un ricorso per quando uno degli altri pulsanti sono premuti,
e et cetera.
>> Non entrare in troppo gran parte della logica di Tic Tac Toe,
anche se è molto eccitante, ma diamo un'occhiata a
alcune delle cose che possiamo fare all'interno di iOS.
Questo metodo nuovo gioco sta per essere licenziato
ogni volta che si preme il pulsante nuovo gioco.
Per collegare che fino ho semplicemente venire al mio storyboard.
Ho cliccato su nuovo gioco.
Se io vengo qui a destra vedo che
Touch Up Inside è collegato al metodo newGame.
Questo è il motivo per cui questo sta per essere licenziato.
Il metodo newGame sta per fare un po 'set up.
E 'intenzione di dire che voglio che tu per cancellare lo stato della scheda.
Questo è un metodo piacevole sul mutevoli array.
Questo sta a dire che è ora è il turno di X,
e ora ho intenzione di approfittare di questa cosa viewWithTag.
>> So che i miei pulsanti hanno i tag 1-9,
e questo è qualcosa che ho scelto arbitrariamente.
Se voglio impostare il testo di ogni pulsante per essere vuoto
perché ho appena iniziato un nuovo gioco e io non ne voglio
Xs o O per essere rimasto io possa fare questo.
Posso dire che voglio la vista con il tag, 1, 2, 3, 4 eccetera.
Questo tirerà un pulsante diverso ogni volta.
Qui ho intenzione di lanciare a UIButton.
Proprio come si possa mettere in int a float e viceversa
questo dice che voglio lanciare ad un UIButton.
Questo significa che il tipo di questo sarà un * UIButton
a causa di puntatori, ma non preoccupatevi, non sono piu 'paura.
>> Una volta che ho questo pulsante ho intenzione di chiamare un metodo su di esso.
Questo metodo viene chiamato setTitle forState, e quindi questo dice
Voglio impostare il testo del pulsante di essere la stringa vuota,
e io voglio che sia una stringa vuota quando non è premuto.
Se sto usando questo metodo, posso modificare il testo del pulsante
non appena qualcuno si colpisce, ma vogliamo dire quando il pulsante è appena seduto lì
Voglio che il testo sia vuota.
Infine, stiamo andando a inizializzare la mia tavola,
e ho intenzione di dire che tutto ciò che è attualmente a 0,
quindi questa scheda membri immutabile è un mutevole array,
il che significa che è possibile chiamare il metodo addObject e solo uno 0 all'interno di esso.
Questo è quello che succede quando creo una nuova partita.
>> Diamo un'occhiata a un altro.
Questo metodo qui è il IBAction che sta per essere premuto
ogni volta che una di quelle piazze è premuto.
Ora abbiamo un po 'di Tic Tac Toe logica qui.
Abbiamo capire a chi tocca,
e sulla base di che ci sia impostare una X o una O,
ma ci accorgiamo che stiamo riutilizzando questo stesso gestore di eventi
per ognuno di questi pulsanti.
Questo significa che non si dispone di un metodo per il pulsante in alto a sinistra,
un metodo diverso per il pulsante in basso a destra, anche se ho potuto farlo.
Non sarebbe davvero un buon design.
Quello che sto facendo qui è realtà sto andando a determinare
ciò il tag del pulsante che è stato premuto.
Si noti che questo metodo di esecuzione accetta un argomento.
Si chiama mittente, e ciò che si sta mittente mittente sta per
rappresentano esattamente ciò che è stato dato seguito al momento.
Se si preme un pulsante, questo mittente sarà che UIButton
che ho effettivamente premuto, in modo che significa che quel UIButton
ha un tag, perché ho creato un tag.
>> Se voglio arrivare al tag posso semplicemente dire
Voglio il tag del mittente,
e di nuovo, ho appena colato a un UIButton.
Mi è capitato di sapere che il mittente sarà un UIButton.
Non sempre deve essere un UIButton.
Potrei, ad esempio, registrare il gestore stesso evento
per uno per un pulsante, una per un cursore.
In questo caso, so che sono tutti i pulsanti, così ho intenzione di dire
Voglio che questo sia un pulsante, e poi posso ottenere il tag,
e dal tag adesso so dove mi trovo all'interno del consiglio di amministrazione.
Allora posso semplicemente impostare X o la O, può capovolgere il turno,
controllare chi ha vinto, et cetera.
>> Hai domande su questo fino ad ora?
Va bene, tutto il codice che abbiamo pubblicato online-non vogliamo entrare in troppo
della logica Tic Tac Toe, ma ora si può vedere che in realtà
tutto quello che stiamo facendo è che stiamo ciclare su questa matrice,
quindi abbiamo un paio di cicli for qui, e stiamo solo confrontando a vedere
abbiamo una partita in tutte le righe, una partita in una colonna o qualcosa di simile.
Per eseguire questa applicazione in realtà, se si tocca su uno di questi pulsanti
che il metodo di gioco è stato licenziato, in modo che significa che ho appena impostato
il pulsante da una X, così ora questo pulsante sarà un O, e così via,
e così è così che stiamo iniziando a interagire con questa applicazione singola pagina.
>> Ci pubblicare il codice, quindi sentitevi liberi di sfogliare che,
ma andiamo ora parlare di alcune applicazioni che sono più di una pagina.
Per quanto emozionante come Tic Tac Toe è stato, un sacco di applicazioni all'interno di iOS
sono un po 'di questi drill down cose con più schermi.
Il primo concetto che abbiamo bisogno di parlare sono i protocolli,
e un protocollo è semplicemente un insieme di metodi
che si può promettere da definire.
Se ho creato questo nuovo protocollo con 2 metodi, il primo,
se il tipo restituito è void, ho chiamato foo.
E 'non accetta argomenti. Ho un altro metodo.
Esso restituisce un int. Ho chiamato bar, e ci vuole un argomento.
Tutto questo protocollo è che si chiama SomeProtocol qui,
questo è un insieme di cose che qualcuno può implementare.
Non ho all'interno di questo protocollo ha detto cosa fa foo.
Al contrario, dico solo che si potrebbe definire foo se si vuole.
Se Sto creando un controller della vista o la creazione di una classe
Posso all'interno di quella promessa classe per implementare
alcuni di questi metodi, così per esempio, se dire
questo dice ora sto facendo una promessa a voi che all'interno
di questa classe controller della vista avrò definizioni sia per foo e bar.
>> Perché è così utile?
Un sacco di componenti all'interno di iOS approfittare di questo
design pattern chiamato delega, e ciò che dice delegazione
è che, per esempio, se ho una casella di testo
e ci sono alcuni eventi che possono essere registrati all'interno della mia casella di testo,
invece di creare eventi separati quello che posso fare è che posso dire
il delegato di questa casella di testo sarà qualche oggetto.
Quando dico che si tratta di un delegato, ora che significa che
ogni volta che un evento sarebbe stato licenziato nella casella di testo
piuttosto che per registrarlo o qualcosa di simile
è solo andare a chiamare un metodo sul delegato.
Per esempio, all'interno della mia casella di testo ho un metodo per quando si preme
fatto che il pulsante in basso a destra,
e così, piuttosto che registrare gestore di eventi quello che posso dire è
casella di testo, ecco un oggetto che voglio che chiamare un metodo su
ogni volta che qualcuno preme il pulsante Fine,
e ciò significa che tale oggetto deve implementare un protocollo
che dice che io prometto di definire che l'azione pulsante di fatto,
perché se non definisce tale metodo e premere Fine,
allora sta per essere fonte di confusione.
>> Diamo un'occhiata a un esempio.
Qui ho semplicemente una casella di testo,
e una delle proprietà di questa casella di testo qui da noi su questo lato destro è il delegato.
Questa è una proprietà della classe.
Quello che ho fatto qui è che ho cliccato il controllo, e ho trascinato da questo luogo qui
il controller della vista, e che ora dice il delegato di questa casella di testo
sarà il controller della vista.
Ciò significa che quando alcune azioni accadere, piuttosto che la registrazione
gestori di eventi separati che voglio di inviare loro al delegato.
Ora diamo uno sguardo al mio controller della vista.
All'interno del file. H ho fatto una promessa.
Ho promesso di implementare alcuni metodi all'interno di questo protocollo
chiamato UITextFieldDelegate, e di nuovo,
questo è solo un po 'elenco di alcune cose che possono scegliere di implementare.
>> Se vengo qui nel mio. M file, ho implementato uno di questi metodi.
Ho chiamato textFieldShouldReturn
perché è quello che è stato chiamato all'interno del protocollo.
E ora ogni volta che premete il bottone interno fatto di quel campo di testo
questo è ciò che sta per ottenere chiamato, quindi non ho fatto registrare un gestore eventi.
Ho collegato il delegato, e ogni volta che questo evento viene generato
questo è il metodo che verrà chiamato, quindi se vengo qui al mio storyboard ed eseguirlo-
mentre che sta caricando si può vedere cosa fa.
Sul mio schermo ho 2 cose.
Ho questo campo di testo, e ho questa etichetta.
Sto semplicemente dicendo che voglio il testo di questa etichetta
essere uguale a quello che l'utente digitato all'interno del campo di testo.
Questa linea successiva qui è semplicemente un metodo che sto chiamando
sul campo di testo che dice che io voglio che tu per nascondere la tastiera.
Questo è solo il metodo arbitrario che Apple ha scelto.
>> Anche in questo caso, prima di me tutto quello che ha dovuto cablare tutto, quindi sono venuto qui.
Dal controller della vista ho trascinate sopra alla casella di testo.
Ho lasciato andare, e posso vedere che posso fare questo la proprietà campo di testo
poiché qui nel controller della vista che ho definito una proprietà
che è un IBOutlet di un campo di testo.
Questo dice che posso cablare questa proprietà fino
per un campo di testo nel mio utente.
Ora, quando si fa clic su questo posso iniziare a digitare.
Ora, se si fa clic sul pulsante di fatto questo sta andando a fuoco
un evento che ora posso rispondere.
Non ci sono gestori di eventi.
È così che ho appena risposto a quel pulsante fare.
Ha senso?
>> Non si tratta di un modello di progettazione che-non si potrebbe mai vi trovate
creare il proprio protocollo, ma è sufficiente sapere che un po 'di
diverse componenti iOS registrare gli eventi in modi diversi.
Pulsanti, per esempio, utilizzare tali IBActions.
Campi di testo, invece, si intende utilizzare delegati.
Possiamo vedere e si può guardare tutto questo all'interno di documentazione.
A proposito, c'è in realtà un sacco di roba UI integrato in iOS per voi,
così per esempio, il modo in cui ho fatto che dire fatto in basso a destra
si Ho selezionato questo campo di testo.
Sono venuto qui.
Ho scorrere verso il basso un po 'per tornare chiave,
e posso effettivamente fare questo un sacco di cose, come se voglio che dire
chiamata di emergenza invece posso farlo, che è del tutto casuale,
e io non so perché c'è un pulsante incorporato chiamata di emergenza,
ma, si dice chiamata di emergenza in lettere molto piccole.
Ci si va.
>> Sicuramente esplorare tutte queste diverse opzioni in iOS.
Hai domande su delegati?
Anche in questo caso, solo un modello di progettazione interessante che si dovrebbe essere a conoscenza.
Okay, dopo un'occhiata a visualizzazioni per tabella.
Una vista tabella è sostanzialmente quella lista di voci che è tutto il luogo in iOS.
Quando stai sfogliando tutti i tuoi contatti, si sta guardando
la pagina delle impostazioni, e quel tipo di lista di cose è chiamato una visualizzazione per tabella.
Implementazione di una visualizzazione per tabella in iOS è abbastanza semplice.
Invece di fare una classe che discende da tale UIViewController
come abbiamo fatto prima abbiamo semplicemente bisogno di dire piuttosto che
tutto quello che un UIViewController non voglio fare,
Dico tutto ciò che un UITableViewController non voglio fare,
in modo che aggiunge semplicemente alcune cose aggiuntive che sono totalmente fatto per noi.
Dobbiamo fare molto poco per riempire sostanzialmente gli spazi vuoti all'interno della tavola.
>> Al fine di visualizzare una tabella ho bisogno di rispondere ad alcune domande.
La prima domanda che devo rispondere è il numero di sezioni sono in tabella?
Quando stai sfogliando la vostra applicazione contatti si noterà che è una specie di
organizzata dal nome, allora si ha la B, e si dispone che il colpo di testa poco sotto.
Ciascuno di questi è chiamato una sezione.
Si può o non può bisogno di questi.
La prima cosa che devi fare è implementare un metodo
chiamato tableView: numberOfSectionsInTableView.
Che restituisce semplicemente il numero di sezioni che hanno,
quindi questo potrebbe dire restituire uno se si dispone di una vista grande tavolo.
La domanda successiva che iOS ha bisogno di sapere è il numero di righe hai?
Ad esempio, si sta sfogliando una visualizzazione per tabella.
Si dispone di un numero fisso di canzoni che stai guardando o un determinato numero di contatti.
Se tu sei me, naturalmente, non che molti,
e così è così che iOS sa quante celle da visualizzare.
>> Ancora una volta, questo potrebbe dire qualcosa di simile di ritorno 3.
La mia opinione tabella ha 3 righe.
Infine, iOS ha bisogno di sapere ciò che ogni cellula sembra,
così che cosa è in realtà sta per fare è chiamare questo metodo qui,
questo tableView: cellForRowAtIndexPath.
E 'intenzione di chiamare questo metodo su ogni singola cella all'interno della tabella.
Come fa a sapere quante volte a chiamarlo?
Beh, l'ha raccontata all'interno del numero di righe nella sezione.
Stiamo andando a chiamare questo su ciascuna delle nostre cellule,
e all'interno di questo è dove si può effettivamente fare le cose come
impostare il testo o dirti cosa che piccolo pulsante blu sul lato destro fa.
Il modello per ottenere queste cellule, abbiamo intenzione di utilizzare questo metodo
chiamato dequeueReusableCellWithIdentifier.
>> Objective-C è in realtà molto ben conosciuta per la durata ridicola di loro i nomi dei metodi,
e questo è davvero un bel caso in esempio punto.
Ciò che questo metodo non fa altro che questo dice voglio solo che tu mi dia una cella.
Solo una cosa iOS.
Se si dispone di qualcosa come 100.000 canzoni sul vostro iPod
ciò che iOS non vuole fare è destinare 100.000 cellule,
perché se si è in cima alla vostra lista, non si ha realmente bisogno di allocare la memoria
per la cella che è 99.000 righe verso il basso?
No, perché come si sta scorrendo è possibile tipo di destinare come si va avanti.
Questo è fatto per voi.
Non devi preoccuparti di tutta quella roba prestazioni stupido.
Tutto ciò che dici è si chiama questo metodo dequeueReusableCellWithIdentifier,
e questo la dice, va bene, se è necessario ho intenzione di creare una nuova cella per voi.
>> Ma se siete in fondo al tavolo e hai già assegnato alcune cellule
nella parte superiore della tabella che si sta veramente andando ad avere bisogno in qualunque momento presto
Sto per darvi una di quelle retro invece di allocare una nuova,
e quindi questo è un problema bella prestazione.
Non è necessario assegnare le celle da soli.
Che sta per dare indietro una cella.
E 'intenzione di tornare a te un oggetto di cella.
Una volta ottenuto l'oggetto cella si possono fare cose ad esso.
È possibile impostare il testo della cella con questa proprietà chiamata etichetta di testo.
Si può aggiungere che la freccia a destra o un po 'di altre cose a caso
con questa proprietà altra chiamato accessoryType, e così via e così via.
>> Diamo uno sguardo in realtà l'attuazione di una visualizzazione della tabella ora.
Quando ho creato questo progetto
piuttosto che dire di domanda unica vista che in realtà è venuto qui
di master-detail applicazione, e quindi sostanzialmente corrisponde alla applicazione posta
su iPad con la vista tabella a sinistra e poi il contenuto sulla destra.
Sul iPod o iPhone questo sta per corrispondere a una visione singola tabella.
È lì che ho ottenuto il mio codice di avvio.
>> Diamo prima un'occhiata al storyboard.
Tutto questo è stato fatto per me, fondamentalmente creato.
Questa barra di navigazione mi ha fatto vedere quello che una cella esempio potrebbe sembrare,
e posso fare doppio clic su questo, cambiare il titolo.
Qualsiasi preoccupazione dell'interfaccia utente sono in grado di gestire lì.
Il file di intestazione sembra davvero semplice.
Piuttosto che dire questo è UIViewController ora stiamo dicendo che questo è un
TableViewController, quindi sappiamo che vogliamo chiamare tutti quei metodi di tabella.
Avanti Voglio creare una proprietà che sta per rappresentare
le cose all'interno del mio tavolo.
Questa tabella è di andare a visualizzare arbitrariamente
un elenco di frutta, e quindi ho bisogno di creare un po 'di matrice
in cui è possibile inserire frutta.
All'interno del mio file di implementazione la prima cosa che voglio fare
è che voglio essere sicuro di inizializzare l'array.
>> Ho detto alloc init, creato il mio array di frutta,
e io sono l'aggiunta di 4 cose ad esso, uno dei quali è molto più controversa rispetto agli altri 3.
E ora ho un array di dimensione 4.
Lo stiamo agitando in CS50.
Ora ho un array di dimensione 4.
Ora ho intenzione di iniziare a rispondere a queste domande, e in realtà,
quando ho creato questa applicazione tutto questo è stato già fatto per me.
Non c'era bisogno di digitare il numero di sezioni in vista tabella.
Era già lì, e sto riempiendo gli spazi vuoti.
Quante sezioni ho?
Uno. Tutto fatto.
Quante righe ho?
Beh, ho una riga per ogni frutto, in modo da questo conteggio
è una proprietà di qualsiasi matrice che dice quanto è grande?
Questo è il numero di righe che ho.
Infine, ho bisogno di dire che cosa fa ogni cellula assomiglia?
Sto per dire dequeueReusableCellWithIdentifier.
>> Ancora una volta, questo è stato già scritto per me.
Non ho dovuto fare da solo, e voglio tornare
questa cellula in questa posizione.
Ricordate che stiamo chiamando lo stesso metodo su ogni singola cella,
e questo argomento qui, questo argomento indexPath,
dice quello che fila Sono dentro
Se dico indexPath.row qui
questo sarà 0, allora sarà 1, allora sarà 2, e questo è quindi so
quale cella sto visualizzato.
Voglio impostare il testo della cella di questa proprietà textLabel
per andare dentro la mia matrice di frutta e ottenere
l'oggetto corrispondente a ciascuna riga.
Se si tratta di una stringa, ora sto impostando
la proprietà Text su una stringa.
Posso fare un'altra cosa.
Posso anche registrare un gestore eventi su ciascuna delle celle,
così quando mi tocca ognuna di queste cellule
questo didSelectRowAtIndexPath, questo sta per essere chiamato per me,
così semplicemente definendo questo posso ora gestire ciò che accade
quando si tocca una cella, e di nuovo, stiamo passando in cui è stato sfruttato cella
in modo da poter riutilizzare questo stesso gestore di eventi per tutte le nostre cellule.
>> Ancora una volta, questo è qualcosa che iOS sta facendo per me.
Facciamo visualizzare un altro fastidioso popup
dice semplicemente che hai scelto qualcosa in cui quel qualcosa
sarà l'oggetto riga.
Quando ho eseguito questo, ho intenzione di avere questa bella vista tabella
con una riga per ciascuno di questi frutti, e se si tocca uno
mi dice quello che è successo.
Ha senso?
Costruiamo un po 'più complessa di un app,
quanto hai scelto cliccando pomodoro è.
La parte bella del storyboard
è che non è solo andare per aiutarci a schermi di progetto individuale,
è anche ci aiuterà a legare insieme la nostra intera applicazione,
modo che l'applicazione finale saremo edificio è questo simpatico sport lettore di news,
e così sta andando ad avere più schermi, e in modo che possa effettivamente rappresentare
ciascuna di queste schermate multiple sullo storyboard,
e posso eseguire lo zoom indietro e vedere la mia app da un livello elevato.
>> Per creare un nuovo elemento all'interno del mio storyboard
è molto semplice all'interno di Interface Builder.
Se voglio aggiungere un altro schermo per questo, ad esempio,
Posso prima lo zoom con lo zoom pizzico che Apple ama tanto,
e qui prima di cercare un pulsante
Io e trascinare e rilasciare un pulsante
se voglio creare una nuova schermata che posso in realtà solo il drag and drop
un controller della vista intera, quindi se scelgo questo, tirare qui,
ehi, c'è un altro schermo, e così ora utilizzando questo stesso file storyboard
Posso avere tutti gli schermi all'interno della mia app, e posso diminuire
e vedere come interagiscono.
Questi non potranno interagire ancora.
Il modo in cui questi 2 Interazione delle schermate è possibile definire relazioni.
Si può sostanzialmente dire che questa schermata, quando si preme questo tasto,
Voglio che scivolare verso questo nuovo schermo.
Questo significa che c'è questo tipo di rapporto tra
la prima schermata e nella seconda schermata.
Avrete fondamentalmente una freccia da quel pulsante alla seconda schermata
dicendo che quando si preme questo tasto è lì che voglio andare.
Proprio come ci controllano cliccato e trascinato per definire questi punti di vendita
stiamo andando a fare la stessa cosa per definire questi sfocia.
>> Vedremo un esempio per questo, e prima di riuscire a transizione
da uno schermo all'altro iOS è abbastanza bello chiamare questo metodo
prepareForSegue chiamato, ed è qui che possiamo cominciare
l'invio dei dati da una applicazione all'altra.
Nell'esempio che stiamo per vedere le cose che in fondo ci permetterà
per filtrare squadre di baseball di campionati e divisioni.
Quando seleziono una lega, per esempio, voglio transizione
alla mia schermata successiva dove posso visualizzare tutte le divisioni
in quel campionato o tutte le squadre differenti.
Ho bisogno di inviare a schermo quello che le squadre che si dovrebbe visualizzare.
Per fare questo ho intenzione di prendere vantaggio di questo metodo qui.
>> Infine, solo un punto a caso su iOS.
Se si desidera memorizzare i dati c'è questa cosa chiamata dati di base,
che in realtà è un po 'complicato con cui lavorare.
È inoltre possibile utilizzare SQL per memorizzare i dati,
che, di nuovo, è bello ma tipo di sul lato più complicato da lavorare,
ma iOS supporta anche queste cose davvero cool chiamati elenchi delle proprietà,
e un elenco di proprietà è solo un file che rappresenta coppie di valori chiave.
È possibile definire un elenco di chiavi, e tu dici questo tasto sarà un array.
Questa chiave sta per essere una stringa, e in fondo tutto ciò che si può fare
in JSON si può fare all'interno di un elenco di proprietà,
e quindi questo davvero ben ci permette di lavorare con alcuni dati.
Per esempio, io ho questo Teams.plist che ho creato.
Ho creato un nuovo file plist, e posso eseguire il drill down.
Questo è un dizionario, questo è un dizionario, questi sono stringhe,
e quindi questa è una bella rappresentazione grafica di un documento JSON
o solo una serie di coppie di valori chiave,
e così questo è il dato che lavorerò con all'interno della mia app.
>> Si deve prima venire qui. Abbiamo i file molto più ora.
Ma si deve prima venire qui allo storyboard.
Lo storyboard qui, se riesco a diminuire-
ora possiamo vedere che questo è il flusso della mia app.
Sto andando prima ad iniziare in questa schermata.
Ho intenzione di drill-down per questa schermata,
e ho intenzione di drill-down per questa schermata, e possiamo vedere qui che se io tipo di
spostare uno di questi intorno abbiamo queste frecce andare da qui a qui,
e il mio modo di definire che la freccia era se lo zoom in un po ',
e se mi vieni a questo controller di vista,
ed ecco una cella, e voglio dire che quando si tocca una cella
Voglio che scivolare su un altro schermo.
Posso semplicemente tenere premuto il controllo,
scorrere sopra un po ', tenere premuto il tasto Ctrl, trascinare la cella più e lasciarsi andare.
>> E qui diciamo qual è la transizione che si desidera utilizzare?
Vuoi usare quella cosa che si chiama diapositiva spinta?
Vuoi far scorrere dal fondo?
Questo si chiama modale.
E una volta che si fa clic su uno di questi, sta andando a disegnare questa freccia per me,
e ciò significa che in realtà ho maneggiato ciò che accade quando si preme questo tasto graficamente.
Non ho scritto alcun codice a scivolare in realtà da una schermata a quella successiva.
Ho definito questo visivamente all'interno di Interface Builder.
Se clicco su questa freccia, possiamo vedere che questa cosa ho dato un nome.
L'ho chiamato showDivisions, e questo è così che io possa conoscere
cosa transizione sta per accadere, e vedremo perché in appena un secondo.
È così che ho collegato le diverse schermate della mia app.
Se questo fosse un pulsante, ad esempio, piuttosto che una vista tabella,
Ho potuto controllare fare clic sul pulsante, trascinare verso la schermata successiva,
ed è così che posso fare in questo modo la navigazione.
>> Molto velocemente, se noi entreremo nel MasterViewController,
ancora una volta, stiamo semplicemente andando a definire un elenco di cose
che verrà visualizzato nella vista tabella.
Qui sto dicendo che voglio che tu prenda il file plist,
e voglio che tu a caricarlo in un dizionario,
e una volta che si dispone di dizionario, ho intenzione di rispondere a queste domande di nuovo gli stessi.
Ecco il numero di sezioni.
Uno, non c'è una riga per ogni campionato, e il testo di ogni cella
dovrebbe essere il primo, il primo campionato, la seconda di campionato, e così via.
Infine, ho intenzione di utilizzare questo metodo che abbiamo appena visto chiamato prepareForSegue,
e questo è il metodo che sta per essere licenziato quando si fa clic
su uno di tali righe e quindi attivando tale transizione
che ho impostato con le frecce.
Questo sta dicendo che posso avere più
relazioni da uno schermo all'altro.
Se ho 2 pulsanti e ogni pulsante vi porta a una schermata diversa
Ho intenzione di avere 2 sfocia, 1 per ogni pulsante.
Ma questo prepareForSegue è, ancora, andando a essere riutilizzato
per ciascuno dei rapporti differenti, in modo che significa che ho bisogno di un modo
di individuare se si preme il pulsante prima o si preme il secondo pulsante.
>> Ricordo che quando ho dato quel Segue un nome, questo showDivisions,
è così che ora so che questa è la Segue che è stato attivato.
Tutto quello che voglio fare è che voglio dire
Voglio capire quello che ho appena colpito,
e così per ottenere che, posso dire che voglio il indexPath per la riga selezionata,
Ricordo il indexPath dice solo dove ho appena fatto clic,
e poi voglio dire che voglio capire dove sto andando.
Questo destinationViewController, che è una proprietà della Segue.
Questa è la schermata che sto per,
quindi so che lo schermo ho intenzione di è chiamato DivisionsViewController
perché ho creato quella classe,
e così ora se dico d.divisions
Ora sto impostando una proprietà del controller della vista che sto per andare a.
Questo è il modo che sto l'invio di dati da uno schermo ad un altro schermo.
>> Basta guardare a questo DivisionsViewController
si può vedere qui che nel file. h
non vi è che le divisioni di proprietà, e questo è quello che sto praticamente popolamento,
è così che so che sto visualizzando le divisioni corrispondenti alle
il campionato che ho cliccato, e di nuovo,
la vista tabella effettiva sembra più o meno lo stesso, basta rispondere a quelle
3 domande semplici e ad individuare
cosa succede quando si passa alla schermata successiva.
Solo un paio di altre cose qui.
Si nota in alto qui che invece di dire # include
Ora sto dicendo # import.
Questo è solo un Objective-C cosa.
L'importazione è sostanzialmente una versione più bello di inclusione,
e, per esempio, abbiamo bisogno di sapere che cosa questa classe è,
quindi non posso solo dire DivisionsViewController.
Se non avessimo hashtag standardio.c all'interno del nostro file. C
il compilatore non aveva idea di cosa fosse printf.
Allo stesso modo, se non si importa il DivisionsViewController
il compilatore ha davvero idea di cosa sia un DivisionsViewController.
Basta fare in modo che all'interno dei diversi file. M hai la certezza di importare
i file corrispondenti. h in modo che il compilatore sa che cosa sta succedendo.
>> Infine, in ultima analisi, quello che Apple non fa altro che visualizzare alcuni dati utilizzando una vista web,
e così una vista web è un oggetto in cui è possibile incorporare
un browser Web po 'all'interno della vostra applicazione.
Tutto quello che devi fare è fornire un URL al tuo browser web,
quindi voglio andare a mlb.mlb.com,
ed è così che io possa accedere alla home page per ogni squadra,
e quindi passando in questo URL
la visualizzazione Web può visualizzare questo per me, e posso passare in rassegna intorno,
e il simulatore è in uso da quello.
Ora, questo è venuto dal mio plist.
Se si fa clic su questo questo è venuto anche dal mio plist, e questo scorrevole è stata gestita
attraverso la definizione di tali sfocia.
Clicco questo e molto altro uno,
ed ora ecco il mio UIWebView, quindi basta così
ecco il sito per l'URL che ho appena incorporato,
e io non ho dovuto gestire qualsiasi cosa folle.
Questo è il modo di visualizzare una pagina web.
Cose come questo pulsante di nuovo qui è dato anche a me
completamente gratis perché ho definito queste relazioni con sfocia.
>> Hai ancora domande? Gia '.
[Studente] Così, quando si utilizza alloc, non devi mai qualcosa gratis?
Esattamente, quando si chiama alloc e init non è per liberarlo.
IOS sta per gestire tutto questo per voi.
E 'meraviglioso, e tu non sei infrangere alcuna regola. Gia '.
[Studente] Se si dovesse includere più squadre che possono stare su schermo,
sarebbe automaticamente hanno un opzione di scorrimento, o è qualcosa che è necessario aggiungere?
Esattamente, se avessi più squadre, per esempio, sarebbe gestire automaticamente
lo scorrimento per me, e tutti i problemi di prestazioni
con l'enorme tavolo sono trattati anche del tutto per me.
>> Altre domande?
Tutto questo codice sta per essere pubblicato.
Abbiamo tipo di sorvolare un po 'di dettagli più piccoli,
ma cose come l'impostazione di alcune proprietà alla visualizzazione Web
sono solo cose che si possono ottenere sfogliando la documentazione di Apple,
che è molto, molto ben strutturate.
Hanno un sacco di applicazioni di esempio e l'esempio usi
di diverse API, quindi sicuramente esaminare quelli, se potete.
Solo alcuni link utili si potrebbe desiderare di dare un'occhiata a.
Queste sono alcune guide di documentazione a portata di mano.
Gli URL sono enormi, quindi sono accorciati.
Questo primo è l'intera libreria di documentazione.
Ci sono piccole barre di ricerca, quindi se si avvia il pulsante digitare
sarà iniziare a dare tutte le informazioni su tutte le cose che puoi fare con un pulsante.
Ho anche incluso la visualizza guida Tabella di Programmazione.
Gestisce visualizzazioni per tabella in modo molto più dettagliato,
come fare le cose come aggiungere dinamicamente le cellule o cellule modifica o rimuoverli.
>> C'è un sacco di applicazioni di esempio da Apple che vi mostrerà come fare,
e, infine, quest'ultimo è la Human Interface Guidelines,
e questo è fondamentalmente una discussione di componenti dell'interfaccia utente,
cose come non fare un pulsante che sono 4 pixel per 4 pixel.
E 'una cattiva idea, e altre cose che Apple vuole che tu faccia
per favorire un buon design.
>> Le ultime domande prima di finire?
Va bene, sicuramente non esitate a: siamo sta per avere etichette speciali discutere.
Avremo un iOS uno, in modo sicuramente sentire liberi di utilizzare questo.
Se si desidera lavorare con i vostri compagni di classe su progetti
o aiutare a capire un po 'di cose a caso iOS
sentitevi liberi di scrivermi, e sicuramente sfogliare on-line tutto il codice, perché
solo nell'interesse di tempo che tipo di glissato sulla più
dettagli più fini grana delle cose.
Ma se no, allora buona fortuna per i tuoi progetti iOS, e spero che avremo
un grande afflusso di applicazioni in App Store.
[CS50.TV]