Objective-C Language
Classi e oggetti

Sintassi

• Cat * cat = [[allocazione gatto] init]; // Crea un oggetto cat di tipo Cat
• Cane * cane = [[Dog alloc] init]; // Crea oggetto cane di tipo Cane
• NSObject * someObject = [NSObject alloc]; [someObject init]; // non farlo
• XYZObject * object = [XYZObject new]; // Usa new per creare oggetti se non sono necessari argomenti per l'inizializzazione
• NSString * someString = @ "Hello, World!"; // Creazione di una NSString con sintassi letterale
• NSNumber * myFloat = @ 3,14f; // Un altro esempio per creare un NSNumber usando la sintassi letterale
• NSNumber * myInt = @ (84/2); // Crea un oggetto usando un'espressione in scatola

Creazione di classi con valori di inizializzazione

#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

Il metodo initWithMotorValue: type andChassisValue: type verrà utilizzato per inizializzare gli oggetti Car.

Singleton Class

Cos'è una classe Singleton?

Una classe singleton restituisce la stessa istanza indipendentemente dal numero di richieste da parte di un'applicazione. A differenza di una normale classe, un oggetto Singleton fornisce un punto globale di accesso alle risorse della sua classe.

Quando utilizzare le lezioni Singleton?

I single vengono utilizzati in situazioni in cui è desiderabile questo singolo punto di controllo, ad esempio con classi che offrono servizi o risorse generali.

Come creare classi Singleton

Per prima cosa, crea un nuovo file e sottoclassilo da NSObject . CommonClass nome, useremo CommonClass qui. Xcode genererà ora i file CommonClass.h e CommonClass.m per te.

Nel tuo file CommonClass.h :

#import <Foundation/Foundation.h>

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

Nel tuo file CommonClass.m :

#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

Come usare Classi Singleton

La classe Singleton creata in precedenza sarà accessibile da qualsiasi punto del progetto, a condizione che il file CommonClass.h sia stato importato nel modulo pertinente. Per modificare e accedere ai dati condivisi nella classe Singleton, è necessario accedere all'oggetto condiviso di quella classe a cui è possibile accedere utilizzando il metodo sharedObject come segue:

[CommonClass sharedObject]

Per leggere o modificare gli elementi in Shared Class, effettuare le seguenti operazioni:

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

Il tipo di ritorno "instancetype"

Objective-C supporta un tipo speciale chiamato `instancetype che può essere utilizzato solo come tipo restituito da un metodo. Valuta la classe dell'oggetto ricevente.

Considera la seguente gerarchia di classi:

@interface Foo : NSObject

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

@end

@interface Bar : Foo
@end

Quando viene chiamato [[Foo alloc] initWithString:@"abc"] , il compilatore può dedurre che il tipo restituito è Foo * . La classe Bar derivata da Foo ma non ha sovrascritto la dichiarazione dell'inizializzatore. Tuttavia, grazie a instancetype , il compilatore può dedurre che [[Bar alloc] initWithString:@"xyz"] restituisce un valore di tipo Bar * .

Considera il tipo di ritorno di -[Foo initWithString:] è Foo * invece: se chiamassi [[Bar alloc] initWithString:] , il compilatore deduce che viene restituito un Foo * , non una Bar * come è l'intenzione del sviluppatore. L' instancetype risolto questo problema.

Prima dell'introduzione di instancetype , inizializzatori, metodi statici come gli accessori singleton e altri metodi che vogliono restituire un'istanza della classe ricevente necessaria per restituire un id . Il problema è che id significa "un oggetto di qualsiasi tipo" . Il compilatore non è quindi in grado di rilevare che NSString *wrong = [[Foo alloc] initWithString:@"abc"]; sta assegnando una variabile con un tipo errato.

A causa di questo problema, gli inizializzatori devono sempre utilizzare instancetype anziché id come valore di ritorno.

Specifica generici

Puoi migliorare le tue classi con generici come NSArray o NSDictionary .

@interface MyClass<__covariant T>

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

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

@end

Differenza tra allocazione e inizializzazione

Nella maggior parte dei linguaggi orientati agli oggetti, allocare memoria per un oggetto e inizializzarlo è un'operazione atomica:

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

In Objective-C, queste sono operazioni separate. L' alloc metodi di classe (e il suo alloc allocWithZone: storico con allocWithZone: rende il runtime Objective-C riserva la memoria richiesta e la cancella. Tranne alcuni valori interni, tutte le proprietà e le variabili sono impostate su 0 / NO / nil .

L'oggetto quindi è già "valido", ma vogliamo sempre chiamare un metodo per impostare effettivamente l'oggetto, che chiamiamo un inizializzatore . Questi servono allo stesso scopo dei costruttori in altre lingue. Per convenzione, questi metodi iniziano con init . Da un punto di vista linguistico, sono solo metodi normali.

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