>> TIANYU LIU: Ehi, come è andando tutti?
E questa è l'app iOS programmazione dell'obiettivo c seminario.
E il mio nome è Tianyu Liu.
Sono una junior Lowell in questo momento, concentrandosi in informatica.
Quindi, in questo seminario sono andare a insegnare ragazzi
un po 'su come fare un app.
Yay, emozionarsi per esso.
>> Quindi, prima ancora di iniziare le immersioni nel lato effettiva programmazione,
diciamo solo molto velocemente parlare motivo per cui si potrebbe desiderare di costruire un app iOS?
Perché iOS così impressionante?
Quindi il primo problema, la prima cosa che è abbastanza impressionante per noi,
soprattutto come CS50 studente, è che iOS
utilizza Objective C. Bene, c'è un nuovo linguaggio chiamato Swift,
ma non stiamo andando a utilizzare che in questo seminario.
Se siete interessati a Swift, là è un seminario indipendente di questo.
Ma Objective C è fondamentalmente un superset di C. Significato
che tutto ciò che si utilizza in C può essere tradotto in Objective C
molto facilmente.
>> Come si può vedere in seguito, che in effetti ci sono una sintassi molto semplice, sono
fondamentalmente esattamente lo stesso, C e Objective C. Quindi,
dal momento che avete preso CS50 up fino a questo punto, è già
conoscere Objective C, almeno il 40%.
Inoltre, Apple ha davvero robusto API per iOS.
Ci sono un sacco di veramente pazzesco cose che si possono fare con esso.
Uno dei quali è qualcuno di fatto creato un app iOS
per autoveicoli, che controllano è piuttosto interessante.
Probabilmente un elicottero è più emozionante.
Ma questo è quanto potente l'API iOS può essere.
>> E come si potrebbe avere capito subito,
l'overflow stack è probabilmente una le più importanti risorse online
a vostra disposizione.
E una buona notizia, per ogni singolo problema si può eventualmente
pensare mentre la costruzione vostra progetto finale in Objective C,
è probabile una risposta overflow dello stack.
E 'semplicemente incredibile.
In aggiunta a ciò, iOS è davvero una piattaforma
dove si può raggiungere un enorme pubblico con poco sforzo.
Non è come Android, dove tutto è piuttosto frammentato.
>> Tutto iOS è unificato.
E finché si creano un app per iPhone,
si può molto facilmente porta a iPad, iPad mini, o diverse misure di iPhone.
Questi sono tutti davvero conveniente.
Ed è solo veramente buono per impressionare i vostri amici.
Si può solo tenere un iPhone e dire al vostro amico hey,
questa è l'applicazione che faccio.
Si può fare che per ogni applicazioni desktop, che è bello.
>> Bene, ora andiamo in realtà get nella lingua Objective C.
Allora perché non si comincia con una sintassi molto semplice.
Come ho detto prima Obiettivo C E 'fondamentalmente un superset di C.
Così un sacco di sintassi di base sono realtà esattamente lo stesso.
Dichiarare una variabile e aggiungendo due variabili insieme
è esattamente come abbiamo fatto in Mario.
Niente di nuovo qui.
>> Allo stesso modo, l'inquilino ciclo for e condizione è anche lo stesso.
Si può fare un ciclo for come te hanno fatto in un Mario [incomprensibile].
E si può fare condizioni proprio come quello che si
avete fatto nei vostri set p precedenti.
Tuttavia, Objective C Non è completamente C,
e c'è qualcosa che è una specie di strano su di esso.
>> Il primo è che quando si è facendo di programmazione C, in genere si chiama
includere e quindi un nome di libreria.
Ma in Objective C si chiama che l'importazione.
Fondamentalmente dicendo funzionalità, solo nomi diversi.
E le stringhe sono in realtà un po 'strano.
Si può vedere che il primo cosa che è un po 'strano
è che avete un bel weird-- sorry-- avete un bel strano NS
firmare qui.
E la seconda cosa questo è un po 'strano
è che hai una chiocciola prima in realtà dichiarando la stringa.
Così il simbolo significa fondamentalmente che una stringa non è solo una stringa,
in realtà è un oggetto.
Stiamo andando a spiegare che poi così non fare
panico se non lo fai capire che cosa significa.
E la stampa di console è un po ' diverso perché in C che chiamiamo printf,
ma in Objective C chiamiamo [incomprensibile].
>> Ci si potrebbe chiedere che cosa è quella.
Questo è fondamentalmente printf, solo una lingua diversa.
Esattamente lo stesso uso, esattamente la stessa funzionalità.
Ebbene si scopre che Objective C realtà
Ha un ns prefisso quasi ogni cosa, ogni tipo di dati di base,
NSString, NSArray, NSDictionary.
Il motivo è che ns in realtà l'acronimo di Next Step,
che è una società che Steve Jobs ha fondato,
che è una società dove la il linguaggio Objective C è nato.
Quindi, questo è fondamentalmente la tradizione.
So che è un po ' strano, ma è Apple.
>> Quindi qualcosa che è ancora più strano quello è una dichiarazione di funzione.
Questo è molto diverso da quello che abbiamo vedere in C, perché qui in realtà
non sembra C più.
Quello che hai qui-- dal modo questo non è un punto di proiettile,
questo è un segno meno.
Hai un segno meno tra parentesi nulla e quindi il nome della funzione.
Diciamo se hanno ciao mondo, allora
il tipo di ritorno sarebbe nullo perché torniamo nulla.
>> Ciò che fa veramente strano è che quando sei
avere più di un parametro passando in una stessa funzione che
sarà davvero strano come mostrato qui.
Abbiamo un nome di metodo, chiamato addInt a [incomprensibile]
e stiamo passando un parametro.
Ma dopo che abbiamo più chiamata nome del metodo con.
E dopo con stiamo passando il secondo parametro.
Questo è in realtà un po 'strano, ma tutte queste dichiarazioni di funzione
seguire lo stesso schema questo.
>> Abbiamo un segno meno per cominciare.
Il segno meno potrebbe essere un segno più a volte in base a che tipo di metodo
è esso.
Metodo è fondamentalmente un altro nome per la funzione.
E stiamo andando a spiegare che più tardi, quando
stiamo parlando di oggetti programmazione orientata.
Dopo l'introduzione di ritorno digitare parentesi all'interno,
dopo di che viene il nome del metodo.
Stai passando un parametro.
E se avete più parametri è necessario estendere il nome del metodo
e in fondo scrivere qualcosa di più qui.
>> Potrebbe essere tutto quello che vuoi.
Nel nostro caso si tratta di con.
Ma si potrebbe dire fine, o, o, o abc bar completo, quello che volete.
E poi, dopo che sei passando parametro b.
Questo è un davvero strano convention ma siamo
andare a capire perché Apple ha voluto di farlo molto rapidamente.
Così come si chiama la funzione?
Chiamare una funzione in Objective C è anche diverso da C.
>> In realtà, chiamando un funzione in Objective C
è più come stai parlando con qualcuno.
Qui abbiamo sé, che è chiamato un oggetto.
Tu sei fondamentalmente dicendo la opporsi sé per dire "Ciao Mondo!"
Questo è il modo per chiamare la funzione.
Un oggetto e un nome di metodo combinati tra loro.
Ed è qui che l'estensione strano per nome del metodo davvero entra in gioco.
>> Vediamo il secondo esempio.
Abbiamo appena definito un metodo chiamato addInt con blah blah blah.
Quindi, in questo caso, quando si sta chiamando che specifica [? messaggio?] sta andando
a guardare come auto addInt: 10 con: 2.
Suona come l'inglese.
Sebbene la funzione dichiarazione di funzione è strano,
il punto di C di Obiettivo Metodo modello di dichiarazione,
è che quando si sta chiamando la funzione o il metodo
che suonerà come reale inglese.
Quindi è molto intuitivo una volta che si entra in esso.
>> Soprattutto in questo caso, dove si può sostanzialmente
vedere che il nome della funzione è sorta di documentazione stessa.
Non hai bisogno di alcuna ulteriori spiegazioni per vedere
cosa sta succedendo, cosa esattamente un parametro che fa.
Al di là di questo, parliamo un po ' po 'di programmazione orientata agli oggetti.
Oggetto programmazione orientata uno della programmazione fondamentale
tecniche o modelli che è usato da Objective C. Objective C
si chiama Objective C non, C, per una buona ragione.
>> Quindi, prima di entrare in Sintassi C Obiettivo,
Diamo un'occhiata molto rapidamente a che cosa è esattamente un oggetto.
Probabilmente abbiamo fatto qualcosa come oggetto prima che
si chiama struct quando si è l'attuazione di un albero o una lista collegata
o [? provare. ?] Quindi, è fondamentalmente come una struct,
ma è molto più potente di quello.
Un oggetto ha metodi e proprietà.
I metodi sono fondamentalmente funzioni.
FUNZIONI sostanza che un specifico per un determinato oggetto.
>> E le proprietà sono fondamentalmente la campo si specifica nella struct.
Così, per ogni singolo oggetto abbiamo qualche proprietà
che ha alcune variabili che sono specifici per l'oggetto.
E abbiamo alcune funzioni che sono anche specifici all'oggetto.
E le funzioni sono chiamate metodi e le variabili sono chiamate proprietà.
E 'solo un nome di fantasia.
Mentre infatti, ogni singola vista si vede mentre si apre un app iOS,
diciamo solo che Twitter o Facebook, ogni singola vista che si vede è un oggetto.
E anche l'intera applicazione è un oggetto per cominciare.
Molto interessante concept.
>> E perché vogliamo oggetto programmazione orientata?
Così si può immaginare che quando si programma diventa piuttosto complicato.
Diciamo solo che quando sei attuazione scacchiera,
la logica sta per essere davvero complicato.
Hai 36 diversi pezzi, in modo che se si
voglio scrivere logica per tutti 36 diversi pezzi di scacchi,
che sta per essere un sacco di funzioni e variabili diverse.
E 'un sacco di guai.
E probabilmente si sta andando a scrivere un metodo diverso o funzione diversa
per ciascuno del pezzo controllare esattamente quello che fanno.
>> Ma se si fa object oriented programmazione, tutti questi pezzi
può essere sottratto in un singolo oggetto.
E l'oggetto avrà qualche comune proprietà, come che tipo di pezzo
è vero?
Di che colore è?
Come si può muovere?
E in questo modo si ha notevolmente semplificata la logica di esso.
Quindi è solo un ottimo modo per rendere i programmi complessi,
e relazione gerarchica all'interno del programma, molto semplice.
Come stiamo andando a vedere perché molto rapidamente quando
in realtà stiamo facendo programming-- quando siamo in realtà
facendo un codice S la programmazione successiva sessione.
>> Ebbene in aggiunta a ciò, programmazione orientata agli oggetti
è solo un sacco di divertimento.
Hai a progettare il proprio oggetto.
Devi progettare quello che fa sembrare da soli.
Non esiste una risposta giusta ad esso.
Ed è assolutamente interessante.
Quindi, in programmazione orientata agli oggetti, due concetti fondamentali
sarà di classe e istanza.
Una classe è sostanzialmente un modello per l'oggetto.
E un caso è sostanzialmente un oggetto specifico.
>> Diciamo solo che si sta facendo un cookie.
In questo caso, ogni singolo biscotto in realtà finisce con
sta per essere un oggetto.
Ma il piatto biscotto si usa per cuocere tutti i biscotti sarà una classe.
Una classe è fondamentalmente un modello.
E l'istanza sarà uno specifico oggetto creato in tale ramo.
>> E verrà creata un'istanza sulla base di dichiarazione di classe,
come vedremo nelle diapositive successive.
Quindi cerchiamo di fare in realtà davvero esempio veloce [incomprensibile].
Diciamo che stiamo dichiarando un oggetto per un gatto.
L'oggetto dovrebbe have-- la classe gatto dovrebbe
hanno alcune proprietà e metodi.
Che tipo di proprietà qualora le Classe have-- dovrebbe avere il gatto?
>> Ad esempio, il colore, età e razza, quelli
sarà variabili che sono specifici per ogni gatto.
E queste sono alcune cose che usiamo per descrivere un gatto.
Che tipo di metodo, o che cosa può fare un gatto?
Alcuni esempi veloci sarebbe chase topo, mangiare pesce o semplicemente miagolare.
Questo è davvero un veloce esempio di classe di cat.
E davvero una specifica oggetto gatto sarà un gatto
dove specifichiamo il colore, l'età e la razza.
>> In tal caso, il nostro oggetto è non più di una classe più.
Noi copiamo il modello dalla classe e Si precisa ogni informazione specifica
a tale oggetto specifico per renderlo indipendente.
E quando si sta chiamando un metodo all'interno di un oggetto,
basta chiamare miagolio sull'oggetto, che è il gatto che avete appena creato.
>> Probabilmente si stampare qualcosa come "Ciao Mondo!
Miao. "
Piuttosto carino.
Va bene, facciamo solo entrare in alcuni dettagli
e vedere che cosa fa esattamente questo tradurre in essere programmazione iOS.
Così in iOS di programmazione ogni singolo Classe sarà attuata in due file.
Un file è qui, che è chiamato l'interfaccia.
Un altro file è qui, che è chiamato attuazione.
>> Tipicamente l'interfaccia avrà extension.h
come abbiamo visto in librerie C.
E file di implementazione è andando ad avere extension.n.
E 'un po' strano.
Ma .n realtà significa .c, non c'è fondamentale differenza tra chi
due.
Quindi, in questo caso, possiamo vedere che siamo dichiarando interfaccia, Cat: oggetti.
Che si chiama eredità.
Stiamo fondamentalmente ereditando il Classe gatto dalla classe di oggetti.
Così ogni proprietà e metodo che era precedentemente definito nella classe dell'oggetto
saranno definiti automaticamente in una classe gatto pure.
>> In aggiunta a ciò, si definisce il colore, razza, ed età, tre variabili.
Che sembra in realtà come qualcosa che hai fatto prima.
Sembra struct.
Questo è fondamentalmente la sintassi per la dichiarazione struct,
e che è totalmente corretto.
E dal momento che ho detto prima, la differenza una struct
e un oggetto, una delle differenze fondamentali
è che un oggetto ha metodo, mentre una struct ha solo variabili.
Quindi, oltre alle proprietà o variabili che abbiamo creato per l'oggetto,
specifichiamo un metodo.
>> Diciamo qui abbiamo due metodi, uno è meow,
un altro è il mouse caccia.
Probabilmente vogliamo essere il superamento di un parametro basato sulla nostra precedente metodo
modello di dichiarazione.
Probabilmente vuole essere il superamento di un mouse.
E probabilmente si vorrà per restituire un significante bool
se il vostro gatto ha successo catturato il mouse o meno.
>> Questa è l'interfaccia, ma possiamo vedere che l'interfaccia in realtà
non fare nulla.
Semplicemente dice di un programma che cosa exists-- ciò che esiste nella classe cat.
Quindi, al fine per il programma di fare qualcosa,
abbiamo bisogno di avere file di implementazione.
Ecco, la prima cosa che facciamo è ovviamente importiamo l'interfaccia.
Dopo importiamo l'interfaccia, definiamo il metodo.
>> Diciamo solo che qui meow sarebbe solo stampare
"Ciao Mondo!" alla console.
E dopo l'attuazione di file, stiamo praticamente fatto.
Questo è fondamentalmente una classe Dichiarazione per una classe.
Così ora la domanda diventa, come si fa a dichiarare una variabile?
Il modo in cui si utilizza una classe per creare una oggetti in Objective C è scritto qui.
>> Per prima cosa specifica che questo è un puntatore gatto,
perché ogni oggetto in Objective C è infine implementato come un puntatore.
E si chiama la classe, li chiamano come alloc, che è fondamentalmente malloc,
raccontando il sistema operativo bisogno di spazio di memoria per questo oggetto.
Dopo che avete un oggetto già e basta inizializzato.
Questo è solo convention.
So che è è un po 'strano, ma questo è in realtà come Apple fa roba.
>> Assegnazione proprietà è in realtà abbastanza semplice.
E 'molto simile a quello che stai facendo, quando
si sta assegnando alcuni specifici campo all'interno di struct.
Devi solo la variabile nome, il nome della proprietà,
e assegnare un valore specifico ad esso.
E chiamare un metodo è molto simile.
L'chiamare un metodo è fondamentalmente quello che parlo
per chiamare qualsiasi metodo in Objective C.
>> Stai passando un oggetto, in questo caso sarà miacategoria,
e si sta passando il nome del metodo.
Come se stai parlando con l'oggetto, miacategoria, che si dovrebbe miagolare.
E 'piuttosto interessante.
Dopo di che, c'è un modello più essenziale di progettazione
che abbiamo bisogno di parlare prima di arrivare al codice vero S.
Questo modello di progettazione si chiama evento guidato la programmazione.
Questo è probabilmente anche uno dei più idee fondamentali nella programmazione iOS.
>> Quindi probabilmente non sa cosa esattamente è la programmazione event driven,
ma non è poi così spaventoso.
Beh, in realtà, si ha già fatto prima.
Questa è una delle linee probabilmente avete già scritto negli ultimi [incomprensibile]
di CS50, google.maps.event.addListener (marker,
"Click", function () {}) :.
Chiamando questa linea si è in sostanza dire al computer
che quando l'evento chiamato "Click" avviene sul marcatore,
utilizzare tale funzione.
>> Questo è molto diverso da ciò che si fa in mario.c.
In mario.c basta eseguire il programma una volta, ti dà un output,
e il gioco è fatto.
Si tratta di una specie di uno dei programmi tiro.
Programmi event driven sono molto, molto diverso.
Immaginiamo, se Facebook è uno programma tiro non è davvero buono.
Basta andare su Facebook una volta ed è fatta.
Ti dà un output e non avete mai avuto indietro.
Non hai mai avuto nulla di più.
>> Così qui, in particolare il modello che usiamo è
evento guidato, in modo che ogni funzione sarà
essere catturati sulla base di ciò evento è accaduto.
Per esempio, se abbiamo un pulsante e specifichiamo
che ogni volta che si fa clic su tale pulsante, chiamare la funzione chiamata "Ciao Mondo!"
In questo modo possiamo davvero gestire la logica di funzionamento
scorrere in un modo altamente flessibile.
L'utente può fare o chiamare una funzione che è già stato chiamato.
E 'completamente basata su ciò che gli utenti fanno.
>> Così possiamo vedere che questo è in realtà molto meglio di mario.c.
E buona notizia è che è in realtà non è un concetto nuovo.
Voi ragazzi avete già fatto che in ultimo problema impostato.
Così in Objective C ci sono tre diversi diagrammi
per la programmazione event driven.
Il primo diagramma è chiamato azione bersaglio,
dove si associa un tasto stampa con qualche funzione.
Diciamo solo che, ogni volta che si fa clic qualche tasto, si chiama qualche funzione.
Questo è molto semplice azione di destinazione.
>> Il secondo è in realtà la più difficile,
si chiama delega sul protocollo.
Stiamo andando a spiegare che in grande dettaglio più avanti.
E la terza via è la notifica.
Questo non è effettivamente molto importante dal punto
come ci riguarda, perché la possibilità che hai intenzione di utilizzare la notifica
nel progetto finale è piuttosto basso.
Quindi stiamo andando a saltare quella parte.
>> E stiamo andando a fare immersioni in delegazione il protocollo.
Così che cosa è esattamente un protocollo?
O che cosa è esattamente una delegazione?
Parliamo di protocollo per iniziare.
I protocolli non sono altro che manifestazioni.
Ma questi eventi sono date da Apple per iniziare.
Ad esempio, non sono completamente sicuro di come molti di voi
ragazzi usano originale di Apple elettronica app o contatto,
ma ogni volta che si scorre il tavolo e premere il cellulare specifico
sul tavolo, che è un evento.
>> E se si vuole fare quell'evento da soli,
in realtà è un po 'difficile.
Così Apple ha dato che anche per voi in modo che si può semplicemente utilizzare direttamente
l'evento per fare qualcosa da soli.
I protocolli sono in realtà molto, molto diffuso
in Objective C. Bene in Infatti, ogni singola app
ha qualcosa catturato delegato app.
All'interno di delicata è tutta la protocolli per caricare l'applicazione.
>> Diciamo c'è un evento per app ha fatto carico.
Così che cosa dovrebbe accadere dopo che hai ha creato un app, dopo aver aperto l'applicazione,
dopo aver chiuso l'applicazione, o dopo si mette l'iPhone a dormire.
Questi sono tutti eventi che ha già stato dato.
E originariamente all'interno di queste particelle ci sarà alcuna implementazione.
Apple ha appena detto che questa funzione succederà quando qualche evento si verifica,
ma quello che fai con quel funzione è completamente a voi.
>> La delega è sostanzialmente raccontare la classe
che si dovrebbe gestire questi protocolli.
E 'un po' confuso, ma sarà
molto più chiaro quando facciamo i codici s in azione.
Delega su protocollo è in realtà un molto robusto meccanismo nel senso
che se lo facciamo delegazione a una classe specifica,
siamo in grado di gestire essenzialmente tutti i tipi di eventi
utilizzando qualsiasi classe che abbiamo, strumento molto comodo.
>> Così un rapido esempio per delega sul protocollo
sarà quello che ho appena parlato.
Questo protocollo specificamente è chiamato Tableview [incomprensibile] selezionare ruolo
a [? index?] [? passato. ?] Quindi questo un evento che essere catturati quando si
in realtà toccare uno specifico cellula del vostro Tableview,
diciamo solo che nella vostra posta o nel vostro contatti app.
>> All'interno di una funzione non c'era originariamente non fare nulla.
La funzione non è così fare nulla per impostazione predefinita.
Ma è possibile specificare ciò che la funzione fa,
dato quello che volete dalla vostra applicazione.
Strumento molto comodo.
E con tutto ciò che Detto questo, ho praticamente
coprire una sintassi molto semplice e concetto fondamentale per l'obiettivo C
programmazione, e siamo in grado di fare un po 'di codice s.
Molto più emozionante.
Così codice s è in realtà un po 'opprimente
quando si apre per la prima volta.
>> Una breve nota, quindi se si voglia di fare lo sviluppo iOS,
Mi raccomando di avere un Mac.
Perché fare sviluppo iOS su Windows è molto, molto difficile.
E 'fattibile, ma è davvero difficile.
E sicuramente fare Non voglio usare g modifica.
Quindi, nel codice di s abbiamo diverse aree diverse.
La prima volta che aprite s codice vedrete una zona di navigazione,
che fondamentalmente mostra tutte le i file che è nel progetto attuale.
>> Avete una barra degli strumenti, che è fondamentalmente la gestione vista,
o qualche piccolo veloce Strumenti circa codice s stesso.
E questa è l'area effettiva dell'editor.
Questa zona è molto simile g di modifica, ma molto meglio di g di modifica.
E in questa zona destra, è chiamato la zona di servizio.
La zona diventa veramente utile quando si sta creando l'interfaccia o specificando
alcune impostazioni rapide per la vostra applicazione.
>> E la zona finale è il debugging.
Quest'area contiene la console.
Così ogni volta che dite printf, o NSLog nel nostro caso,
tutti i risultati sono andare da stampare qui.
Bene?
Credo che possiamo davvero fare in fretta un esempio per la programmazione iOS.
E diciamo effettivamente aprire il codice su s.
Così ogni volta che si apre il codice in alto s, è intenzione di mostrare qualcosa di simile.
E 'intenzione di chiedere cosa vuoi fare?
Vuoi iniziare a qualcosa casuale, un parco giochi, in pratica si
può solo testare il codice senza realmente impegnarsi in qualsiasi applicazione.
>> Vuoi creare un nuovo progetto?
O vuoi continuare lavoro esistente?
Nel nostro caso stiamo andando per creare un nuovo progetto.
Quindi è davvero bello, s codice è in realtà già
dato alcuni modelli per la creazione di oggetti.
Se si vuole fare un gioco, s codice in realtà ha un modello di gioco per voi,
ha applicazioni basate pagina, applicazione basata tab.
In questo caso, stiamo andando di fare qualcosa di molto semplice,
e abbiamo intenzione di utilizzare un singola applicazione vista.
>> Dopo di che solo ciò che si desidera chiamare il prodotto, e come ti chiami,
qual è il tuo identificativo, e Che lingua si usa.
Qui non vogliamo Controllare con Core Data.
Core Data è fondamentalmente un databasing iOS.
Se lo fai Core Data, s codice sta per definire
un sacco classi più complicato per voi.
Quindi, per tenere tutto semplice, siamo solo andando a fare a meno di Core Data
proprio adesso.
>> Il problema che stiamo andando a essere utilizzando è che-- il problema
stiamo andando ad essere la creazione è che abbiamo fondamentalmente desidera importare da Mario C
ad un app iOS.
Quindi diciamo che Mario-iOS.
Naturalmente si specifica che cosa vuole mettere nel progetto.
E ci andiamo.
>> Quindi questo è un po ' schiacciante, ma questo è in realtà
quello che abbiamo appena visto nelle diapositive.
E la prima area si vede in questo momento è fondamentalmente configurazione del progetto.
Quindi tutto quello che volete fare progetto, che tipo di dispositivo,
diciamo solo che tipo di dispositivo vuoi la vostra applicazione per apparire?
È iPhone, iPad o universale?
Quindi l'orientamento del dispositivo, tutta questa roba.
Non molto importante, ma potrebbe essere, ma questo
è un luogo in cui si imposta il vostro progetto se effettivamente
desidera distribuire al negozio di Apple.
>> Va bene, diamo un'occhiata a qualcosa che è dentro il nostro codice.
Andiamo attraverso il file navigatore.
E questi sono tutti i file che già è venuto con il modello, molto bello.
Così, quando si fa clic su uno di loro questo è quello che sembra.
Molto simile a g modifica.
Ma si può vedere che la evidenziazione della sintassi è probabilmente
un po 'più bello.
Ed è in realtà molto di più potente di g editing.
E si può completamento automatico un sacco di cose per voi,
come vedremo molto rapidamente.
>> Apriamo la zona di debug pure.
Va bene, come possiamo vedere, la console è proprio qui.
Questo è quello che si sta andando a vedere dove sei in printf nsloging o qualcosa.
Quindi, senza ulteriori indugi, andiamo in realtà compilare il app e vedere cosa succede.
Una caratteristica essenziale per codice s, è che il codice s
è dotato di un simulatore di iPhone.
Quindi non c'è bisogno di avere un iPhone per provare il vostro progetto,
codice s in grado di simulare che per voi, come si può vedere in questo momento.
>> E 'molto bello.
Sta prendendo un po ' po 'di tempo per la compilazione
e fondamentalmente abbiamo un'applicazione vuota,
che in realtà non fa nulla.
Ma si compila.
E 'abbastanza impressionante.
E 'molto meglio di C, eh?
Va bene, allora facciamo provare ad aggiungere qualcosa.
Un file che è un po ' strano qui si chiama storyboard.
Questo è in realtà un grande, caratteristica impressionante per il codice s.
Perché in codice s, si può effettivamente trascinamento e rilasciare elementi sull'interfaccia
e mostrerà direttamente up.
Proviamo questo.
>> Lasciamo cadere una etichetta qui, "Ciao Mondo !!!"
Possiamo centrare tale.
Pretty cool.
Ora corriamo questa simulazione di arresto.
Qui abbiamo "Ciao Mondo !!!"
Non abbiamo neanche fare ancora alcuna codifica.
Che diavolo sta succedendo?
Questo è il modo potente Interface Builder può essere.
Qualcuno addirittura ha detto che si può probabilmente solo
completare un app senza scrivere probabilmente mille righe di codice
semplicemente utilizzando l'Interface Builder.
Ma probabilmente non è il modo migliore per farlo.
>> Ora diamo effettivamente ottenere fino a codifica.
Quindi la struttura del file in realtà è davvero interessante
perché, come si può vedere, ci è funzione principale ovunque.
Vedi?
Come abbiamo accennato prima, si può vedere che questo
è un file di implementazione per una classe specifica.
Ma non c'è nessuna parte principale.
Allora, dove è il principale?
In realtà, vi è un principale, ma la principale è nascosto da voi.
Il principale è qui.
Che sembra familiare.
>> Quindi, in pratica quello che iOS sta facendo all'interno principale
è che ogni volta principale è chiamato, che è fondamentalmente
ogni volta che l'applicazione viene eseguita, essa crea un oggetto chiamato AppDelegate.
Come ho detto prima, l'intero app è in realtà un oggetto di per sé.
Quindi, in questo modo, sostanzialmente iOS app sta dicendo il compilatore
che OK, ho intenzione di creare un prodotto chiamato AppDelegate,
e che sta per essere la mia app.
Quindi è necessario andare attraverso quel AppDelegate
e vedere che quel ragazzo sta facendo.
Il mio lavoro è fatto per me.
>> E in AppDelegate si può vedere che ci sono alcune funzioni davvero strano,
Beh in realtà i metodi, che Apple ha già dato.
Cosa sono questi?
Questi sono in realtà solo protocolli che stavo parlando.
Quindi questi sono eventi che Apple vi ha dato per iniziare.
Non c'è nulla in qualche delle funzioni in questo momento,
ma se vogliamo inizializzare qualcosa per la nostra app
prima di entrare in visualizzazione qualsiasi vista, lo facciamo qui.
>> Si può solo leggere il nome e credo l'evento è in realtà molto chiara.
Così ora principale ha creato un oggetto per AppDelegate.
E che cosa AppDelegate sta per fare in realtà è anche nascosta da voi.
Il AppDelegate sta per iniziare caricamento del magazzino ViewController.
Quindi è fondamentalmente sta per iniziare caricando tutti i punti di vista che avete
e solo rendono la vista in base alla gerarchia.
>> Quindi, in questo caso abbiamo solo un punto di vista, che è qui.
In modo che è l'unica vista che sta per essere chiamato.
La logica ViewController è proprio qui.
Questo è il codice che effettivamente controlla la vista che abbiamo appena visto.
Va bene, facciamo qualcosa qui.
Così viewDidLoad suona come un evento, quando in realtà questo è anche un delegato,
questo è anche un protocollo.
>> Quindi, qualunque sia caricata la vista, tutto all'interno della funzione
sarà chiamato.
In questo caso dovremmo vedere "Ciao Tianyu! "Se si esegue il programma.
Si sta facendo un po 'lento compilare file storyboard.
Ebbene infatti, che vediamo un'uscita per esso.
E 'piuttosto fresco.
Ora facciamo realmente fare Mario.
Ho intenzione di definire il funzionamento molto rapidamente.
marioWithLevels: risultati (int) livello.
>> Va bene, questo è in realtà il terribile caratteristica di codice s completamento automatico.
Così, quando si scrive e digita entrare, ha già dato il modello
per voi, che è piuttosto fresco.
Questo dovrebbe guardare veramente familiare a voi ragazzi.
Siamo spiacenti, questo è colpa mia.
Va bene, fresco.
Questa logica dovrebbe essere molto familiare a voi ragazzi, specialmente subito Mario.
>> Ma noi ora stampare su un la console ogni volta,
perché vogliamo mantenere in qualche modo traccia di ciò che stiamo stampando.
Stiamo per usare il risultati in qualche modo più tardi,
per visualizzare la stampa out comportare per l'utente.
Così invece siamo solo nslogging tutto,
che stiamo memorizzare tutto in un risultato chiamata di funzione,
ma la logica è esattamente la stessa.
Dopo che abbiamo finito, abbiamo basta stampare i nostri risultati.
>> E qui invece di stampare il mio nome, stiamo andando a chiamare una funzione.
Vediamo cosa succede.
Oops, ovviamente.
Abbiamo un bel piccola piramide qui fuori.
Questo è fondamentalmente C, siamo solo manipolando dove si chiama una funzione
e come fa una funzione simile.
Non c'è nulla di diverso.
Ma questo è in realtà non molto eccitante qui,
perché non stiamo vedendo nulla dalla app iPhone.
>> Quindi, se effettivamente avete un iPhone app-- se effettivamente avete Mario iOS destra
Ora, non si sta andando di vedere tutto ciò che
ha a che fare con Mario, perché tutte quelle uscite in una console
sono nascosti da un utente.
Questo è ciò che si vede, che è "Ciao Mondo !!!"
Non bene.
Ora cerchiamo di rendere l'utente vedere che cosa esattamente stiamo stampando.
Quindi non abbiamo bisogno di etichettare più.
Proviamo e capire qualcosa altra cosa che potrebbe essere utile.
>> Vi è in realtà uno elemento che si chiama
campo di testo, che potrebbe essere molto utile per noi.
Fondamentalmente visualizza una regione di testo che può essere modificato.
In modo che sembra davvero utile.
Ora diamo trascinarlo e rilasciarlo.
Wow, abbiamo una visione di testo a nostro avviso, veramente elegante.
Questo è un po 'troppo grande.
Facciamo più piccolo.
Mettere in centro.
Rendere più piccolo pure.
>> Ora abbiamo una visione del testo, che potremmo essere utilizzato per visualizzare il nostro risultato finale.
Ma adesso è sicuramente non andare a lavorare
perché c'è il no-- ViewController abbiamo appena
definito non sa che c'è una vista testo là fuori.
Quindi abbiamo bisogno di qualche modo collegare la visione del testo che abbiamo appena
creato con la classe che è già venuto con noi.
>> Il nostro modo di fare che è in realtà davvero magico.
Quindi aprire storyboard.
C'è una speciale [incomprensibile] chiamato [? assistant?] [incomprensibile].
Quando si fa clic su questo, è andando ad aprire due file.
Uno è una classe e l'altra è una vista corrispondente per esso.
E 'molto, molto utile.
E facciamo solo passa attraverso il file h.
Controllo, questo è [incomprensibile] logica.
Premere Ctrl e trascinare il vista testo nella dichiarazione.
Stiamo andando a chiamare quel outputView.
Collega.
Così qui abbiamo dichiarato una nuova immobili per la nostra classe ViewController.
E la nuova proprietà è solo la vista testo
abbiamo creato nella costruzione dell'interfaccia.
Quindi, in questo modo abbiamo potuto accesso tutti i dati
e manipolare tutto ciò che si trova all'interno la visualizzazione di output, che è impressionante.
>> Quindi, nel nostro codice attuale, facciamo qualcosa con esso.
Così, questa volta, quando noi siamo come la stampa il risultato finale per Mario,
siamo in non registrazione nulla.
Voglio dire che potevamo tenere la dichiarazione di registrazione.
In aggiunta a ciò, abbiamo inviare la lettura che abbiamo appena
creato alla vista di uscita, che è una UI TextView abbiamo appena creato.
Ora vediamo cosa succede.
Wow.
Abbiamo una piramide in app in questo momento.
>> Così l'utente può vedere la nostra produzione perché abbiamo copiato l'uscita dal nostro codice
alla nostra interfaccia.
E 'abbastanza buono.
Non è in realtà che emozionante perché abbiamo can--
Tutta l'applicazione sta facendo è mostrando una piramide a voi,
e non c'è niente che tu possa fare.
Non è particolarmente eccitante.
Così ora facciamo un tasto che sarà chiaro il punto di vista.
Sembra che un tasto sarà utile.
Trascinare e rilasciare.
Un pulsante.
Button due.
>> Così, quando si clicca sulla sinistra tasto, la visualizzazione dovrebbe risolversi.
Ci dovrebbe essere nulla sullo schermo.
E quando si clicca il tasto destro, Mario,
la vista sta per apparire di nuovo.
Quindi in questo modo facciamo anche il magia roba, il controllo e trascinare
la dichiarazione di classe nell'assistente director--
nell'assistente spettatore.
In questo caso stiamo specificando che ciò sia un'azione.
clearMario.
>> Così qui abbiamo già creato un'azione chiamata clearMario,
che è il metodo che sarà chiamato ogni volta che si preme il tasto di cancellazione.
Quindi, nella nostra realtà il codice, diciamo solo mettere il testo di output e la vista di uscita
nel nulla, e in questo modo apparirà essere chiaro.
In aggiunta a ciò, creiamo un altro metodo chiamato runMario.
Oh mi dispiace, che non dovrebbe essere una proprietà.
D'accordo, che dovrebbe essere un'azione pure.
>> E quando quella funzione è chiamato, abbiamo appena corriamo Mario dieci.
Speriamo che andrà bene.
Ha compilare?
Sì.
Ora abbiamo una visione.
Abbiamo una produzione.
E facciamo solo vedere cosa succede.
Che è andato.
E 'di nuovo.
Così qui abbiamo specificato che tipo di funzione
sarà chiamato quando scriviamo in qualcosa,
quando premiamo un pulsante specifico.
Questo è fondamentalmente la programma di azione bersaglio
per event driven programmazione in Objective C.
>> In aggiunta a ciò, non è molto eccitante
perché non possiamo davvero cambiare quanto in alto la piramide sarà,
quindi probabilmente si vuole in qualche modo ottenere un ingresso dall'utente
e modificare l'altezza del piramide sulla base di quello che in uscita.
Quindi stiamo andando a farlo.
Così, questa volta, quando chiamiamo runMario, non ci limitiamo a chiamare direttamente Mario.
Il titolo di questo uno.
>> Delegato.
Questo è molto interessante.
Che cosa è un delegato?
Ho intenzione di mettere auto qui.
E stiamo andando a vedere che cosa significa più tardi.
Così qui abbiamo praticamente creato una caso specifico chiamato un avviso UI
view.
Una vista di allerta UI è fondamentalmente quello che volete
vedere ogni volta che qualcosa pops e si chiede per l'ingresso,
come quello che accadrà quando si sta cercando per l'acquisto di qualcosa su un app store.
>> In aggiunta a ciò, dopo aver crearla, dobbiamo solo mostrare l'avviso.
Va bene, facciamo solo rapidamente Test voglio che il lavoro oppure no.
Questo è molto cool.
Ora diamo realmente creare un campo di input per l'avviso UI.
Questo è il modo in cui facciamo.
E dovremmo avere un Vista ingresso per la segnalazione.
Very cool.
Diciamo 10.
>> E non sta facendo niente di buono ora perché la chiamata in realtà
non ha cambiato per l'esecuzione di mario.
Quindi questo è diventato un po po 'strano perché ogni volta
premiamo un pulsante in basso, ogni volta che premere un pulsante nella vista di allerta,
dovesse succedere qualcosa, ma non succede.
Come facciamo a prendere quel?
Come facciamo a sapere che un utente ha respinto una vista avviso
e già inserito un numero, perché in questo momento nulla è realmente accadendo.
>> Beh, si può immaginare bene, la delega.
Quindi, oltre a tutti queste dichiarazioni,
abbiamo bisogno di aggiungere una nuova delegazione di si chiama UI vista avviso delegato.
Così che ogni singola interazione o evento
che stiamo andando ad avere con la vista di allerta UI
sta per essere gestito dalla nostra classe pure.
>> Quindi, in aggiunta a ciò, sarà avviso pulsante View Clicca all'indice.
Questo è raggiunto.
Quindi, in questo caso abbiamo already-- così abbiamo
scoperto un protocollo che gestirà l'evento quando
clicchiamo il pulsante Fine sulla vista di allerta.
Così ogni volta che respingere il vista avviso, questo dovrebbe accadere.
Lasciatemi prova molto rapidamente.
Beh in effetti, abbiamo raggiunto qui.
>> Ecco, ciò che non lo farà effettivamente ottenere è in realtà
otteniamo the-- Quindi vogliamo uscire il testo che abbiamo in precedenza
entrato nella vista di allerta.
E in base al testo, siamo andando a visualizzare Mario.
Questo risulta molto rapidamente se funziona davvero o no.
Quindi, in questo caso, se in ingresso, diciamo, 10, dovremmo vedere 10.
>> Molto bene, abbiamo un numero qui.
E 'abbastanza buono.
Ora l'ultimo passo sarà essere-- Così il ultimo passo che dobbiamo fare in questo momento
è solo un Mario chiamare con livello base all'input
che abbiamo messo in vista avviso.
Quindi abbiamo bisogno di convertire questa stringa in iOS.
Troppopieno statica è molto impressionante.
E poi chiamiamo semplicemente auto valore marioWithLevels.
Vediamo che sarà in realtà lavorare o meno.
>> Stiamo già dato una piramide.
Proviamo a cambiare l'altezza.
Che in realtà funziona.
E 'piuttosto fresco.
Così che ora si può solo inserire qualsiasi valore desiderato.
Diciamo solo quattro.
Questo è abbastanza impressionante.
Quindi, questo è fondamentalmente un esempio molto veloce
per come creare un progetto in codice s e come collegare realmente rapidamente
alcuni eventi davvero semplici e funzioni.
>> Quindi la sorgente sta per essere messo in linea in seguito.
Quindi, se siete interessati in come funziona iOS Mario,
Ho intenzione di mettere esattamente la stessa progetti sul sito CS50 tardi.
Siamo praticamente finito con il estate, e prima di finire
Voglio solo puntare voi ragazzi a alcune risorse davvero impressionante che
sono disponibili online.
>> Ovviamente la documentazione di Apple sta per essere molto utile.
Ma in aggiunta a questo, soprattutto raccomandare quattro fonti, scuola di codice,
casa sull'albero, AppCoda e WWDC video.
Scuola Codice e casa sull'albero sono due siti web Educative online,
che specificamente fuoco sull'ingegneria del software.
Soprattutto per la scuola del codice, si hanno davvero buon tutorial su iOS.
>> Questo è davvero un rapido esempio per esso.
Essi in realtà creano davvero cute-- guardare quel piccolo iPhone carino
tizio laggiù, è abbastanza impressionante.
E il loro modo di spiegare Obiettivo Sintassi C è perfettamente chiaro.
Tree house è la stessa.
E AppCoda è un forum.
In realtà è un blog che è stato eseguito da un esperto davvero Objective C
programmatore.
E tutti quei tutorial in AppCoda sono piuttosto breve e facile da implementare,
altamente raccomandato.
>> E se sei uno sviluppatore, sicuramente andare a controllare
come i video WWDC dove è possibile conoscere le ultime programmazione iOS
tecniche, API e le librerie.
In modo che sia più o meno per il seminario.
Vi ringrazio tanto.
E spero che vi divertiate creare la propria app iOS.