Objective-C Language
Klasser och objekt

Syntax

• Cat * cat = [[Cat alloc] init]; // Skapa kattobjekt av typen Cat
• Dog * dog = [[Dog alloc] init]; // Skapa hundobjekt av typen Dog
• NSObject * someObject = [NSObject alloc]; [someObject init]; // gör inte det här
• XYZObject * object = [XYZObject nytt]; // Använd nya för att skapa objekt om INga argument behövs för initialisering
• NSString * someString = @ "Hej, världen!"; // Skapa en NSString med bokstavlig syntax
• NSNumber * myFloat = @ 3.14f; // Ett annat exempel för att skapa en NSNumber med bokstavlig syntax
• NSNumber * myInt = @ (84/2); // Skapa ett objekt med ett boxat uttryck

Skapa klasser med initialiseringsvärden

#import <Foundation/Foundation.h>
@interface Car:NSObject {
    NSString *CarMotorCode;
    NSString *CarChassisCode;
}

- (instancetype)initWithMotorValue:(NSString *) motorCode andChassisValue:(NSInteger)chassisCode;
- (void) startCar;
- (void) stopCar;

@end

@implementation Car

- (instancetype)initWithMotorValue:(NSString *) motorCode andChassisValue:(NSInteger)chassisCode{
    CarMotorCode = motorCode;
    CarChassisCode = chassisCode;
    return self;
}

- (void) startCar {...}
- (void) stopCar {...}

@end

Metoden initWithMotorValue: type andChassisValue: type kommer att användas för att initiera bilobjekten.

Singleton klass

Vad är en Singleton-klass?

En singleton-klass returnerar samma instans oavsett hur många gånger en ansökan begär det. Till skillnad från en vanlig klass ger ett singleton-objekt en global tillgång till dess resurs resurser.

När ska man använda Singleton-klasser?

Singletoner används i situationer där denna enda kontrollpunkt är önskvärd, till exempel med klasser som erbjuder viss allmän service eller resurs.

Hur man skapar Singleton-klasser

Skapa först en ny fil och underklassera den från NSObject . Namnge vad som helst, vi kommer att använda CommonClass här. Xcode genererar nu CommonClass.h- och CommonClass.m-filer för dig.

I din CommonClass.h fil:

#import <Foundation/Foundation.h>

@interface CommonClass : NSObject {
}
+ (CommonClass *)sharedObject;
@property NSString *commonString;
@end

I din CommonClass.m fil:

#import "CommonClass.h"

@implementation CommonClass

+ (CommonClass *)sharedObject {
    static CommonClass *sharedClass = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedClass = [[self alloc] init];
    });
    return sharedClass;
}

- (id)init {
    if (self = [super init]) {
        self.commonString = @"this is string";
    }
    return self;
}

@end

Hur man använder Singleton-klasser

Singleton-klassen som vi skapade tidigare kommer att vara tillgänglig från var som helst i projektet så länge du har importerat CommonClass.h filen i den relevanta modulen. För att ändra och få åtkomst till delade data i Singleton Class måste du komma åt det delade objektet för den klassen som kan nås med hjälp av sharedObject metoden som följande:

[CommonClass sharedObject]

Gör följande för att läsa eller ändra elementen i delad klass:

NSString *commonString = [[CommonClass sharedObject].commonString; //Read the string in singleton class

NSString *newString = @"New String";
[CommonClass sharedObject].commonString = newString;//Modified the string in singleton class

Returtypen "instancetype"

Objekt-C stöder en speciell typ som heter `instancetype som bara kan användas som typ som returneras med en metod. Den utvärderar till klassen för det mottagande objektet.

Tänk på följande klasshierarki:

@interface Foo : NSObject

- (instancetype)initWithString:(NSString *)string;

@end

@interface Bar : Foo
@end

När [[Foo alloc] initWithString:@"abc"] kallas, kan kompilatorn dra slutsatsen att returtypen är Foo * . Bar klassen härrörde från Foo men åsidosatte inte initialiseringsdeklarationen. Men tack vare instancetype kan kompilatorn dra slutsatsen att [[Bar alloc] initWithString:@"xyz"] returnerar ett värde av typ Bar * .

Tänk på returtypen av -[Foo initWithString:] som Foo * istället: om du skulle ringa [[Bar alloc] initWithString:] , skulle kompilatorn dra slutsatsen att en Foo * returneras, inte en Bar * som är avsikten med utvecklare. instancetype löste problemet.

Innan instancetype infördes, behövs initialiseringar, statiska metoder som singleton-accessorer och andra metoder som vill returnera en instans av den mottagande klassen för att returnera ett id . Problemet är att id betyder "ett objekt av vilken typ som helst" . Kompilatorn kan således inte upptäcka att NSString *wrong = [[Foo alloc] initWithString:@"abc"]; tilldelar en variabel med en felaktig typ.

På grund av detta problem bör initialiserare alltid använda instancetype istället för id som returvärde.

Ange generik

Du kan förbättra dina egna klasser med generika precis som NSArray eller NSDictionary .

@interface MyClass<__covariant T>

@property (nonnull, nonatomic, strong, readonly) NSArray<T>* allObjects;

- (void) addObject:(nonnull T)obj;

@end

Skillnad mellan allokering och initialisering

I de flesta objektorienterade språk är det en atomoperation att fördela minne för ett objekt och initiera det:

// Both allocates memory and calls the constructor
MyClass object = new MyClass();

I mål-C är det separata verksamheter. alloc (och dess historiska syskon allocWithZone: gör att Objekt-C körtid reserverar det erforderliga minnet och rensar det. Förutom några interna värden är alla egenskaper och variabler inställda på 0 / NO / nil .

Objektet är då redan "giltigt" men vi vill alltid kalla en metod för att faktiskt ställa in objektet, som vi kallar en initialisator . Dessa tjänar samma syfte som konstruktörer på andra språk. Genom konvention börjar dessa metoder med init . Ur språksynpunkt är de bara vanliga metoder.

// Allocate memory and set all properties and variables to 0/NO/nil.
MyClass *object = [MyClass alloc];
// Initialize the object.
object = [object init];

// Shorthand:
object = [[MyClass alloc] init];