Objective-C Language
Klassen und Objekte

Syntax

• Cat * cat = [[Katzezuweisung] init]; // Katzenobjekt vom Typ Kat. Erstellen
• Hund * Hund = [[Hundezuteilung] Init]; // Hundeobjekt vom Typ Hund erstellen
• NSObject * someObject = [NSObject-Zuordnung]; [someObject init]; // mach das nicht
• XYZObject * object = [XYZObject neu]; // Verwenden Sie new, um Objekte zu erstellen, wenn für die Initialisierung KEINE Argumente erforderlich sind
• NSString * someString = @ "Hallo, Welt!"; // NSString mit Literal-Syntax erstellen
• NSNumber * myFloat = @ 3.14f; // Ein weiteres Beispiel zum Erstellen einer NSNumber mit Literal-Syntax
• NSNumber * myInt = @ (84/2); // Ein Objekt mit einem geschachtelten Ausdruck erstellen

Klassen mit Initialisierungswerten erstellen

#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

Mit der Methode initWithMotorValue: type andChassisValue: type werden die Car-Objekte initialisiert.

Singleton-Klasse

Was ist eine Singleton-Klasse?

Eine Singleton-Klasse gibt dieselbe Instanz zurück, unabhängig davon, wie oft eine Anwendung sie anfordert. Im Gegensatz zu einer regulären Klasse bietet ein Singleton-Objekt einen globalen Zugriffspunkt auf die Ressourcen seiner Klasse.

Wann werden Singleton-Klassen verwendet?

Singletons werden in Situationen verwendet, in denen ein einzelner Steuerpunkt wünschenswert ist, z. B. bei Klassen, die allgemeine Dienste oder Ressourcen anbieten.

So erstellen Sie Singleton-Klassen

Erstellen Sie zuerst eine neue Datei und erstellen Sie eine Unterklasse von NSObject . CommonClass es irgendetwas, wir werden hier CommonClass . Xcode generiert jetzt CommonClass.h- und CommonClass.m-Dateien für Sie.

In Ihrer CommonClass.h Datei:

#import <Foundation/Foundation.h>

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

In Ihrer CommonClass.m Datei:

#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

So verwenden Sie Singleton-Klassen

Auf die Singleton-Klasse, die wir zuvor erstellt haben, kann von überall im Projekt aus CommonClass.h werden, solange Sie die CommonClass.h Datei in das entsprechende Modul importiert haben. Um auf die gemeinsam genutzten Daten in Singleton Class zuzugreifen und auf diese zuzugreifen, müssen Sie auf das gemeinsam genutzte Objekt dieser Klasse zugreifen, auf das Sie mit der sharedObject Methode wie folgt sharedObject :

[CommonClass sharedObject]

Gehen Sie folgendermaßen vor, um die Elemente in Shared Class zu lesen oder zu ändern:

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

Der Rückgabetyp "instancetype"

Objective-C unterstützt einen speziellen Typ namens `instancetype, der nur als von einer Methode zurückgegebener Typ verwendet werden kann. Sie wertet die Klasse des empfangenden Objekts aus.

Betrachten Sie die folgende Klassenhierarchie:

@interface Foo : NSObject

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

@end

@interface Bar : Foo
@end

Wenn [[Foo alloc] initWithString:@"abc"] aufgerufen wird, kann der Compiler darauf schließen, dass der Rückgabetyp Foo * . Die von Foo abgeleitete Bar Klasse hat die Deklaration des Initialisierers nicht überschrieben. Dank instancetype kann der Compiler jedoch darauf schließen, dass [[Bar alloc] initWithString:@"xyz"] einen Wert vom Typ Bar * zurückgibt.

Betrachten Sie den Rückgabetyp von -[Foo initWithString:] , der stattdessen Foo * : Wenn Sie [[Bar alloc] initWithString:] würden, würde der Compiler darauf schließen, dass ein Foo * zurückgegeben wird, nicht ein Bar * wie es der Intention von Entwickler. Der instancetype Typ hat dieses Problem gelöst.

Vor der Einführung von instancetype müssen Initialisierer, statische Methoden wie Singleton-Accessoren und andere Methoden, die eine Instanz der empfangenden Klasse zurückgeben möchten, die zur Rückgabe einer id . Das Problem ist, dass id "ein Objekt jeglichen Typs" bedeutet . Der Compiler kann daher nicht feststellen, dass NSString *wrong = [[Foo alloc] initWithString:@"abc"]; wird einer Variablen mit einem falschen Typ zugewiesen.

Aus diesem Grund sollten Initialisierer immer instancetype anstelle von id als Rückgabewert verwenden.

Generics angeben

Sie können Ihre eigenen Klassen wie NSArray oder NSDictionary mit Generika NSDictionary .

@interface MyClass<__covariant T>

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

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

@end

Unterschied zwischen Zuordnung und Initialisierung

In den meisten objektorientierten Sprachen ist das Zuordnen von Speicher für ein Objekt und dessen Initialisierung eine atomare Operation:

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

In Objective-C sind dies separate Operationen. Die Klassenmethoden alloc (und ihre historischen Geschwister allocWithZone: dass die Objective-C-Laufzeit den erforderlichen Speicher reserviert und löscht. Mit Ausnahme einiger interner Werte werden alle Eigenschaften und Variablen auf 0 / NO / nil .

Das Objekt ist dann bereits "gültig", aber wir möchten immer eine Methode aufrufen, um das Objekt tatsächlich einzurichten, das als Initialisierer bezeichnet wird . Diese haben denselben Zweck wie Konstruktoren in anderen Sprachen. Standardmäßig beginnen diese Methoden mit init . Aus sprachlicher Sicht sind dies nur normale Methoden.

// 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];