Objective-C readonly properties in a subclass - ios

Question

I have a superclass called SuperClass a read-only property. That looks like this:
#property (nonatomic, strong, readonly) NSArray *arrayProperty;
In a subclass I need an initializer that takes a instance of SuperClass as a parameter:
- (instancetype)initWithSuperClass:(SuperClass *)superClass
I created a GitHub sample project that shows what the problem is: https://github.com/marosoaie/Objc-test-project
I cannot do _arrayProperty = superClass.arrayProperty in the initializer.
I want to keep the property read-only in SubClass as well.
Any ideas on how this could be solved?
I know I could declare the property as readwrite in a class extension inside the SubClass implementation file, but I'm hoping that there's a better solutions than this.
Edit:
SuperClass.h
#import <Foundation/Foundation.h>
#interface SuperClass : NSObject
- (instancetype)initWithDictionary:(NSDictionary *)dictionary;
#property (nonatomic, strong, readonly) NSString *stringProperty;
#property (nonatomic, strong, readonly) NSArray *arrayProperty;
#end
SuperClass.m
#import "SuperClass.h"
#implementation SuperClass
- (instancetype)initWithDictionary:(NSDictionary *)dictionary
{
self = [super init];
if (self) {
_arrayProperty = dictionary[#"array"];
_stringProperty = dictionary[#"string"];
}
return self;
}
#end
SubClass.h:
#import <Foundation/Foundation.h>
#import "SuperClass.h"
#interface SubClass : SuperClass
#property (nonatomic, strong, readonly) NSString *additionalStringProperty;
- (instancetype)initWithSuperClass:(SuperClass *)superClass;
#end
SubClass.m:
#import "SubClass.h"
#implementation SubClass
#synthesize additionalStringProperty = _additionalStringProperty;
- (NSString *)additionalStringProperty
{
if (!_additionalStringProperty) {
NSMutableString *mutableString = [[NSMutableString alloc] init];
for (NSString *string in self.arrayProperty) {
[mutableString appendString:string];
}
_additionalStringProperty = [mutableString copy];
}
return _additionalStringProperty;
}
- (instancetype)initWithSuperClass:(SuperClass *)superClass
{
self = [super init];
if (self) {
// Doesn't work
// _stringProperty = superClass.stringProperty;
// _arrayProperty = superClass.arrayProperty;
}
return self;
}
#end

Answer 1

You already exposed an initializer, that writes to that readonly property -initWithDictionary:. Call that in your SubClass, instead [super init]:
- (instancetype)initWithSuperClass:(SuperClass *)superClass {
NSDictionary *dict = #{
#"array": superClass.arrayProperty,
#"string": superClass.stringProperty,
};
self = [super initWithDictionary:dict];
if (self) {
// Nothing here.
}
return self;
}
It’s quite common to have an initializer for readonly properties, although using dictionary is not that good solution. Typically, I would create:
- (instancetype)initWithArray:(NSArray *)array string:(NSString *)string;

Answer 2

First of all, there is a bug in your test setup: Your key in - (instancetype)initWithDictionary:(NSDictionary *)dictionary is #"array", where the array contains #"arrayProperty".
Regarding your problem:
//...
#interface SuperClass : NSObject
{
#protected // this is what you want: a protected class property, accessible in subclasses, but no where else
NSString *_stringProperty;
NSArray *_arrayProperty;
}
#property (nonatomic, strong, readonly) NSString *stringProperty;
#property (nonatomic, strong, readonly) NSArray *arrayProperty;
- (instancetype)initWithDictionary:(NSDictionary *)dictionary;
#end
// SubClass.m
//...
#implementation SuperClass
- (instancetype)initWithDictionary:(NSDictionary *)dictionary
{
self = [super init];
if (self) {
_arrayProperty = dictionary[#"arrayProperty"]; // this was #"array", so could not work
_stringProperty = dictionary[#"stringProperty"]; // same here
}
return self;
}
#end
Then it works. In addition, I would write
#interface SubClass ()
#property (nonatomic, strong, readwrite) NSString *additionalStringProperty;
#end
#implementation SubClass
- (instancetype)initWithSuperClass:(SuperClass *)superClass
{
self = [super init];
if (self) {
_stringProperty = superClass.stringProperty;
_arrayProperty = superClass.arrayProperty;
}
return self;
}
because I prefer the readwrite property in a class extension over the #synthesize magic. But this is a personal opinion.
One main issue regarding to class design still holds: What happens if (similar to your test setup) the dictionary of the superclass does not contain the key? Then it won't be initialized, which is not a good idea, because you expect them to be initialized. So you should check in the subclass if superclass.stringProperty is not nil and add a standard constructor for the superclass to avoid that the two dictionaries are uninitialized.

Answer 3

In your SuperClass.m:
- (instancetype)initWithDictionary:(NSDictionary *)dictionary
{
self = [super init];
if (self) {
// these were always nil, check your dictionary keys
_arrayProperty = dictionary[#"arrayProperty"];
_stringProperty = dictionary[#"stringProperty"];
}
return self;
}
In your SubClass.m:
#interface SubClass ()
#property (strong, nonatomic) NSString * additionalStringProperty;
#property (strong, nonatomic) NSString * subClassString;
#property (strong, nonatomic) NSArray * subClassArray;
#end
#implementation SubClass
- (instancetype)initWithSuperClass:(SuperClass *)superClass
{
self = [super init];
if (self) {
_subClassString = superClass.stringProperty;
_subClassArray = superClass.arrayProperty;
}
return self;
}

Answer 4

I tried the answers here to no avail. What ended up working for me was this answer which mentions that you should directly access the member variable (after declaring it as protected) like so:
self->_stringProperty = #"some string";