Objective-C Language
Klassen en objecten

Syntaxis

• Cat * cat = [[Cat alloc] init]; // Maak een katobject van het type Cat
• Dog * dog = [[Dog alloc] init]; // Maak een hondobject van het type Hond
• NSObject * someObject = [NSObject alloc]; [someObject init]; // doe dit niet
• XYZObject * object = [XYZObject nieuw]; // Gebruik nieuw om objecten te maken als er GEEN argumenten nodig zijn voor initialisatie
• NSString * someString = @ "Hallo wereld!"; // Een NSString maken met letterlijke syntaxis
• NSNumber * myFloat = @ 3.14f; // Nog een voorbeeld om een NSNumber te maken met behulp van letterlijke syntaxis
• NSNumber * myInt = @ (84/2); // Maak een object met behulp van een uitdrukking in een kader

Klassen met initialisatiewaarden maken

#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

De methode initWithMotorValue: type andChassisValue: type wordt gebruikt om de Car-objecten te initialiseren.

Singleton-klasse

Wat is een Singleton-klasse?

Een singleton-klasse retourneert dezelfde instantie, ongeacht hoe vaak een toepassing erom vraagt. In tegenstelling tot een gewone klasse biedt een singleton-object een wereldwijd toegangspunt tot de bronnen van zijn klasse.

Wanneer Singleton Classes gebruiken?

Singletons worden gebruikt in situaties waarin dit enkele controlepunt wenselijk is, zoals bij klassen die algemene service of middelen bieden.

Hoe Singleton-klassen te maken

Maak eerst een nieuw bestand en subklasse dit van NSObject . Noem het maar op, we zullen CommonClass hier gebruiken. Xcode genereert nu CommonClass.h- en CommonClass.m-bestanden voor u.

In uw CommonClass.h bestand:

#import <Foundation/Foundation.h>

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

In uw CommonClass.m bestand:

#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

Hoe Singleton Classes te gebruiken

De Singleton Class die we eerder hebben gemaakt, is overal in het project toegankelijk zolang u het CommonClass.h bestand in de relevante module hebt geïmporteerd. Als u de gedeelde gegevens in Singleton Class wilt wijzigen en openen, moet u toegang krijgen tot het gedeelde object van die klasse, waartoe u toegang kunt krijgen met de methode sharedObject , zoals:

[CommonClass sharedObject]

Ga als volgt te werk om de elementen in Shared Class te lezen of te wijzigen:

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

Het retourtype "instancetype"

Objective-C ondersteunt een speciaal type genaamd `instancetype dat alleen kan worden gebruikt als een type dat wordt geretourneerd door een methode. Het evalueert de klasse van het ontvangende object.

Overweeg de volgende klassenhiërarchie:

@interface Foo : NSObject

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

@end

@interface Bar : Foo
@end

Wanneer [[Foo alloc] initWithString:@"abc"] wordt aangeroepen, kan de compiler afleiden dat het retourtype Foo * . De klasse Bar afgeleid van Foo maar heeft de opheffing van de initialisatie niet overschreven. Dankzij instancetype kan de compiler echter concluderen dat [[Bar alloc] initWithString:@"xyz"] een waarde van het type Bar * retourneert.

Beschouw het -[Foo initWithString:] van -[Foo initWithString:] zijnde Foo * plaats daarvan: als je [[Bar alloc] initWithString:] zou aanroepen, zou de compiler concluderen dat een Foo * wordt geretourneerd, geen Bar * zoals de bedoeling is van de ontwikkelaar. Het instancetype heeft dit probleem opgelost.

Vóór de introductie van instancetype waren initializers, statische methoden zoals singleton-accessors en andere methoden die een exemplaar van de ontvangende klasse willen retourneren, nodig om een id . Het probleem is dat id "een object van elk type" betekent . De compiler kan dus niet detecteren dat NSString *wrong = [[Foo alloc] initWithString:@"abc"]; wijst toe aan een variabele met een onjuist type.

Vanwege dit probleem moeten initializers altijd instancetype plaats van id als de retourwaarde.

Generics opgeven

U kunt uw eigen klassen verbeteren met generieke geneesmiddelen, net als NSArray of NSDictionary .

@interface MyClass<__covariant T>

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

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

@end

Verschil tussen toewijzing en initialisatie

In de meeste objectgeoriënteerde talen is het toewijzen van geheugen voor een object en initialiseren een atomaire bewerking:

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

In doelstelling-C zijn dit afzonderlijke bewerkingen. De class-methoden alloc (en zijn historische broer allocWithZone: ervoor dat de Objective-C runtime het vereiste geheugen reserveert en wist. Met uitzondering van enkele interne waarden, zijn alle eigenschappen en variabelen ingesteld op 0 / NO / nil .

Het object is dan al "geldig" maar we willen altijd een methode aanroepen om het object daadwerkelijk in te stellen, die we een initializer noemen. Deze dienen hetzelfde doel als constructeurs in andere talen. Volgens afspraak beginnen deze methoden met init . Uit taaloogpunt zijn dit slechts 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];