Share
Benvenuti alla terza parte di questa serie: spero che vi piaccia! La scorsa settimana abbiamo esaminato il modo in cui separiamo le classi in file separati (interfaccia e implementazione), questa settimana esamineremo nuovamente le classi, ma un po 'più in profondità. Daremo anche un picco all'ereditarietà e come funziona, insieme all'ambito variabile.
Finora, abbiamo ricevuto ottimi feedback via email, twitter e commenti. È bello vedere così tante persone sono interessate a questo argomento ed è ancora più bello vedere che molti di voi lo stanno provando per te stesso e stanno facendo alcune grandi domande. Continuate così!
Esaminiamo ciò che abbiamo imparato sulle lezioni di questa serie finora. Se non conosci nulla di ciò, sentiti libero di tornare all'ultimo tutorial per re-cap. Ok, allora, quali sono le classi?
Una classe è una raccolta di dati incapsulati e metodi personalizzati. Una classe può contenere molti tipi diversi di dati, ei metodi di classe solitamente (ma non sempre) eseguono azioni correlate a quei dati. In Objective-C, una classe è solitamente composta da due file: un file di interfaccia e un file di implementazione. Il file di interfaccia usa l'estensione di file .h per convenzione ed è dove la persona che usa la classe può trovare rapidamente i metodi e i membri di dati disponibili per la classe. Il file di implementazione utilizza l'estensione del file .m per convenzione ed è dove risiede la maggior parte del codice perché contiene l'effettiva implementazione di tutte le funzioni dichiarate nell'interfaccia.
Quindi, cosa rende una classe diversa da un oggetto? Cos'è un oggetto? Un oggetto è un'istanza di una classe. Ripensa al nostro esempio con la macchina nell'ultima parte della serie. Dove auto è la classe, quindi la mia auto, dansCar, e la tua auto sarebbero tutti oggetti perché sono esempi della classe dell'auto.
Prima di proseguire, mi piacerebbe condividere alcune (di molte) classi comuni che userete molto che sono fornite da Apple, ma prima una breve lezione di storia.
Molte classi fornite da Apple sono precedute dall'abbreviazione "NS", che sta per NextStep. Quando Steve Jobs lasciò Apple, fondò NeXT, creando computer workstation che funzionavano sul suo sistema operativo. Il linguaggio di programmazione orientato agli oggetti utilizzato su quelle macchine si chiamava NeXTSTEP, da cui viene ricavato il "NS". Quando Apple'acquired '(un'altra lezione di storia in sé) NeXTSTEP, ha deciso di basare Mac OS X su NeXTSTEP.
Ecco alcune classi semplici e comuni che vedremo molte:
Ne apprenderemo molti altri in seguito, ma per ora quanto sopra sarà utile. Probabilmente ti starai chiedendo quali sono i mezzi mutevoli e immutabili, che è una domanda del tutto ragionevole. Se un oggetto è immutabile ciò significa che quando creiamo l'oggetto e assegniamo un valore, allora è statico. Il valore non può essere modificato. Se un oggetto è mutevole allora è dinamico, il che significa che il valore può essere cambiato dopo la creazione.
Diciamo che vogliamo creare una stringa statica di testo e registrarla, come fare? Nel nostro codice sarebbe simile a questo:
#importareint main (int argc, const char * argv []) NSString * testString; testString = [[NSString alloc] init]; testString = @ "Ecco una stringa di test in testString!"; NSLog (@ "testString:% @", testString); ritorno 0;
Ho creato questo file in XCode andando a File> Nuovo progetto> Mac OS X> Applicazione> Strumento riga di comando> Tipo: Foundation (abbastanza un viaggio!) e modifica del file di implementazione (estensione: .m) nel progetto.
Ci sono alcune cose qui che sono nuove, quindi esaminiamo il pezzo precedente.
Prima di tutto, importiamo la libreria di base (questo perché impostiamo il tipo su Foundation nella finestra del nuovo progetto).
int main (int argc, const char * argv [])
Questo dichiara la funzione iniziale che verrà chiamata quando il nostro programma inizia l'esecuzione. I due parametri separati da una virgola servono per passare argomenti alla nostra applicazione. Per ora, non preoccuparti di questi perché non avremo bisogno di loro in questo momento.
NSString * testString; testString = [[NSString alloc] init];
Ora creiamo un puntatore a un oggetto NSString chiamato testString. Una volta terminata la prima riga, non esiste ancora alcuna stringa, solo un puntatore a una stringa che non abbiamo ancora creato. Nella riga successiva, creiamo la stringa a cui punta il puntatore.
Avremmo potuto in alternativa scrivere l'ultima riga come questa;
testString = [NSString alloc]; [testString init];
Questo può sembrare un po 'confuso all'inizio. Nella prima versione, abbiamo annidato le frasi tra parentesi sulla stessa riga, mentre nel secondo abbiamo separato le istruzioni in due righe. Il metodo init inizializza tutte le variabili di istanza nella classe.
testString = @ "Ecco una stringa di test in testString!";
Questa linea è piuttosto auto-esplicativa, la ragione per cui anteponiamo le virgolette con un segno @ è dire al compilatore che il seguente testo è una NSString.
NSLog (@ "testString:% @", testString);
Qui registriamo alcune informazioni alla console. XCode ha un debugger integrato che puoi trovare nel menu Esegui. È molto utile quando si sviluppa un'applicazione per registrare quando si verificano eventi e i valori di alcune variabili - può essere d'aiuto quando si risolvono i problemi dell'applicazione e del debug. Questo metodo funziona come printf (ricorda dalla prima settimana?) Dove forniamo una stringa di testo con un carattere sostitutivo (% @ significa un oggetto Objective-C).
Infine restituiamo 0, che sappiamo solo dice al sistema operativo che l'applicazione è terminata senza problemi.
Ricordi quando abbiamo creato la nostra NSString in precedenza, abbiamo usato il metodo init? Bene NSMutableString, NSArray e, di fatto, ogni singola classe NS, utilizza anche init. Sembra un sacco di codice sprecato per mettere il metodo init in ogni classe, giusto? Sarebbe, ecco perché init viene solitamente implementato solo una volta, nella classe radice nota come NSObject. Poiché le classi si ereditano l'una dall'altra, una classe creata come figlio di un'altra classe, la classe genitore otterrà automaticamente l'accesso ai metodi della classe genitore.
Prendiamo ad esempio NSMutableString. NSMutableString ha NSString per un genitore (rendendolo un figlio), il che significa che eredita da NSString. Nel frattempo. NSString ha NSObject come genitore, quindi eredita da NSObject.
Quindi, ad esempio, NSObject ha un metodo chiamato init, quindi ogni sottoclasse ha implementato questo metodo - che è chiamato un metodo di classe. Di fatto, il metodo init in NSObject non esegue in realtà nulla che restituisca semplicemente self. La ragione di ciò è che i metodi possono essere sovrascritti. Quindi la classe NSArray può sovrascrivere l'init che eredita per aggiungere funzionalità ad esso, come assicurarsi che la memoria sia disponibile o preparare qualsiasi variabile di istanza di cui potrebbe aver bisogno.
Come dimostrato, questo è utile perché significa che oltre ad ereditare dalle classi possiamo anche estendere le classi. Quando estendiamo una classe, prendiamo una classe esistente e aggiungiamo funzionalità aggiuntive a ciò che è già disponibile. Ciò significa che è possibile creare la propria versione di NSString con metodi aggiuntivi, come un metodo per riempire la stringa con testo casuale o eseguire una sorta di codifica dei caratteri.
A questo punto, i fondamenti su come funzionano le classi dovrebbero essere chiari. Per testare la tua comprensione, vedi se puoi rispondere alle seguenti domande nella tua mente:
Poiché le lezioni sono una parte così importante di Objective-C, è importante sentirsi davvero a proprio agio lavorando con loro. La scorsa settimana abbiamo iniziato a guardare le lezioni e questa settimana abbiamo approfondito. La prossima settimana potresti essere felice di ascoltare, ci sposteremo dal lato teorico e inizieremo a lavorare sulla nostra semplice classe o due per svolgere compiti semplici.
Dal momento che finora abbiamo fatto la teoria principalmente, i tuoi compiti questa settimana sono di navigare sul sito web degli sviluppatori di Apple (dovresti averlo fatto la scorsa settimana) e guardare alcune delle classi disponibili. Se non sai da dove iniziare, inizia con qualcosa come NSString. Diventerai più a tuo agio con i dettagli della classe genitore, i metodi e così via. Ciò sarà importante in seguito quando utilizzi le classi al di fuori di questa serie e desideri sapere quali metodi ereditano o utilizzano.
La settimana prossima diventeremo più pratici con alcune codifiche di classe. Le classi sono davvero centrali per Objective-C, quindi è molto importante che tu ti afferri con loro e l'obiettivo di questa serie è quello di assicurarti davvero che tu faccia!
Come al solito, se hai domande o commenti, puoi raggiungermi facendo cadere un commento o un'email. Se vuoi metterti in contatto con me personalmente e ottenere una risposta rapida, mandami un tweet!
Accentsconagua