Protokoll och kategorier
Utforska protokoll för att definiera kommunikationskontrakt och kategorier för att lägga till metoder i befintliga klasser utan att ärva från dem.
Protokoll och kategorier är en gratis lektion i Objective-C för iOS-utveckling av äldre appar och företagsappar på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Objective-C för iOS-utveckling av äldre appar och företagsappar, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Objective-C för iOS-utveckling av äldre appar och företagsappar innehåller totalt 4 lektioner.
Utökat beteende: introduktion
Välkommen till denna lektion om Objective-C-protokoll och kategorier! Detta är kraftfulla funktioner som låter Er utöka funktionaliteten hos Era klasser på flexibla sätt.
Vi går igenom hur protokoll definierar kontrakt för kommunikation mellan objekt och hur kategorier låter Er lägga till metoder i befintliga klasser utan att behöva skapa subklasser.
Protokoll: kommunikationskontraktet
Tänk på ett protokoll i Objective-C som en ritning eller ett kontrakt. Det deklarerar en lista över metoder som andra klasser kan välja att implementera.
- En klass som ”antar” ett protokoll lovar att implementera dess obligatoriska metoder.
- Detta är avgörande för att skapa kommunikationsmönster, till exempel det populära delegate-mönstret.
- Protokoll liknar gränssnitt i språk som Java och C#.
Definiera ett protokoll
För att definiera ett protokoll använder Ni direktivet @protocol. Ni kan ange metoder som @required (måste implementeras) eller @optional (kan implementeras).
Protokoll följer ofta <NSObject>, vilket innebär att alla klasser som antar protokollet måste vara ett Objective-C-objekt.
@protocol MyServiceDelegate <NSObject>
@required
- (void)serviceDidFinishLoadingData:(NSArray *)data;
@optional
- (void)serviceDidStartRequest;
@endAnta och implementera ett protokoll
En klass antar ett protokoll genom att ange det inom vinkelparenteser efter sin superklass. Därefter måste den implementera alla @required-metoder.
Vi ska titta på ett exempel där en klass av typen DataLoader behöver en delegat som meddelar den när data är klar.
#import <Foundation/Foundation.h>
// 1. Define the delegate protocol
@protocol DataLoaderDelegate <NSObject>
- (void)dataLoader:(id)loader didFinishLoadingData:(NSString *)data;
- (void)dataLoaderDidFail:(id)loader withError:(NSError *)error;
@end
// 2. Class that uses the delegate
@interface MyDataLoader : NSObject
@property (nonatomic, weak) id<DataLoaderDelegate> delegate; // The delegate property
- (void)loadData;
@end
@implementation MyDataLoader
- (void)loadData {
NSLog(@"DataLoader: Starting data load...");
// Simulate network request
NSString *result = @"Sample Data Loaded!";
// Notify the delegate
if ([self.delegate respondsToSelector:@selector(dataLoader:didFinishLoadingData:)]) {
[self.delegate dataLoader:self didFinishLoadingData:result];
}
}
@end
// 3. Class that conforms to the protocol (the delegate)
@interface MyDataConsumer : NSObject <DataLoaderDelegate> // Adopting the protocol
- (void)startConsumption;
@end
@implementation MyDataConsumer
- (void)startConsumption {
MyDataLoader *loader = [[MyDataLoader alloc] init];
loader.delegate = self; // Set self as the delegate
[loader loadData];
}
#pragma mark - DataLoaderDelegate Methods
- (void)dataLoader:(id)loader didFinishLoadingData:(NSString *)data {
NSLog(@"DataConsumer: Received data: %@", data);
}
- (void)dataLoaderDidFail:(id)loader withError:(NSError *)error {
NSLog(@"DataConsumer: Failed with error: %@", error.localizedDescription);
}
@end
// 4. Main execution
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyDataConsumer *consumer = [[MyDataConsumer alloc] init];
[consumer startConsumption];
}
return 0;
}Kategorier: utöka klasser
Kategorier gör det möjligt att lägga till nya metoder i en befintlig klass, även i en klass som Ni inte äger (som NSString eller NSObject), utan att ändra den ursprungliga källkoden eller skapa en subklass.
- De är utmärkta för att organisera kod i logiska grupper.
- Ni kan inte lägga till nya instansvariabler i en klass med hjälp av en kategori.
- Om en kategorimetod har samma namn som en befintlig metod används kategorins implementation (vilket kan leda till oväntat beteende!).
Definiera en kategori
För att definiera en kategori skapar Ni en gränssnittsfil (.h) och en implementationsfil (.m). Syntaxen ser ut så här:
@interface ClassName (CategoryName)Vi skapar en kategori för NSString för att lägga till några hjälpmetoder.
// NSString+MyStringAdditions.h
#import <Foundation/Foundation.h>
@interface NSString (MyStringAdditions)
- (BOOL)isEmailValid;
- (NSString *)stringByCapitalizingFirstLetter;
@endImplementera kategorimetoder
Nu ska vi implementera metoderna som vi deklarerade i kategorin NSString+MyStringAdditions. När de har implementerats blir dessa metoder tillgängliga för alla NSString-instanser!
Prova att köra detta exempel för att se hur det fungerar:
#import <Foundation/Foundation.h>
// 1. Define the Category Interface
@interface NSString (MyStringAdditions)
- (NSString *)stringWithPrependedHello;
- (NSString *)stringWithAppendedExclamation;
@end
// 2. Implement the Category Methods
@implementation NSString (MyStringAdditions)
- (NSString *)stringWithPrependedHello {
return [NSString stringWithFormat:@"Hello, %@", self];
}
- (NSString *)stringWithAppendedExclamation {
return [NSString stringWithFormat:@"%@!", self];
}
@end
// 3. Main execution
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSString *name = @"CoddyKit";
// Use category methods
NSString *greeting = [name stringWithPrependedHello];
NSString *excitedGreeting = [greeting stringWithAppendedExclamation];
NSLog(@"Original: %@", name);
NSLog(@"Greeting: %@", greeting);
NSLog(@"Excited: %@", excitedGreeting);
}
return 0;
}När ska protokoll respektive kategorier användas?
Det är viktigt att veta när Ni ska välja protokoll framför kategorier:
- Protokoll: Används när Ni behöver definiera ett gemensamt gränssnitt eller kontrakt som flera orelaterade klasser kan följa (till exempel delegate-mönster och datakällor). De definierar vad ett objekt kan göra.
- Kategorier: Används när Ni vill lägga till hjälpmetoder i en befintlig klass, gruppera relaterade metoder eller utöka en klass utan att skapa en subklass (till exempel lägga till en anpassad tolkningsmetod i
NSString). De utökar hur ett objekt kan bete sig.
Protokoll och arv
Ett protokoll kan även anta andra protokoll och på så sätt skapa en hierarki av krav. Till exempel innebär @protocol ChildProtocol <ParentProtocol> att ChildProtocol innehåller alla metoder från ParentProtocol.
Detta gör det möjligt att bygga mer komplexa kontrakt genom att kombinera enklare kontrakt.
Snabbkontroll: protokoll
Betrakta följande kodavsnitt i Objective-C:
@protocol DataProcessor
@required
- (void)processData:(NSArray *)data;
@optional
- (void)didStartProcessing;
@end Vad är det huvudsakliga syftet med detta protokoll?
Sammanfattning: protokoll och kategorier
Bra jobbat! I den här lektionen har Ni lärt Er om två kraftfulla funktioner i Objective-C:
- Protokoll: Definierar ett kontrakt med metoder som klasser kan anta för att möjliggöra kommunikation och skapa gemensamma gränssnitt.
- Kategorier: Utökar befintliga klasser genom att lägga till nya metoder utan arv, vilket är användbart för hjälpmetoder och kodorganisation.
Om Ni behärskar dessa funktioner kan Ni bygga mer flexibla och modulära Objective-C-appar!
Lär dig Objective-C med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Protokoll och kategorier” gratis?
Ja – hela texten till ”Protokoll och kategorier” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Objective-C för iOS-utveckling av äldre appar och företagsappar, kan Ni uppgradera till CoddyKit PRO. Kursen i Objective-C för iOS-utveckling av äldre appar och företagsappar innehåller totalt 4 lektioner.
Vad lär jag mig i ”Protokoll och kategorier”?
Utforska protokoll för att definiera kommunikationskontrakt och kategorier för att lägga till metoder i befintliga klasser utan att ärva från dem. Ni övar på Objective-C för iOS-utveckling av äldre appar och företagsappar med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Objective-C för iOS-utveckling av äldre appar och företagsappar?
Du behöver inga förkunskaper. Utbildningen i Objective-C för iOS-utveckling av äldre appar och företagsappar på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Protokoll och kategorier”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Objective-C för iOS-utveckling av äldre appar och företagsappar-lektionen?
Ja. Varje Objective-C för iOS-utveckling av äldre appar och företagsappar-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Klasser, objekt och metoder
- Egenskaper och instansvariabler
- Protokoll och kategorier
- Arv och åsidosättning av metoder