Access ivar from subclass in Objective-C

Question

I have class A which has this declaration in it's .m file:

@implementation A {
    NSObject *trickyObject;
}

And class B which has this declaration in it's .h file:

@interface B : A
@end

Is there any possibility to access the trickyObject from a method declared in the class B ?

Answer 1

If you have a property or method that is private, but you want to make accessible to subclasses, you can put the declaration in a category .

So consider A :

//  A.h

@import Foundation;

@interface A : NSObject

// no properties exposed

@end

And

//  A.m

#import "A.h"

// private extension to synthesize this property

@interface A ()

@property (nonatomic) NSInteger hiddenValue;

@end

// the implementation might initialize this property

@implementation A

- (id)init {
    self = [super init];
    if (self) {
        _hiddenValue = 42;
    }
    return self;
}

@end

Then consider this category:

//  A+Protected.h

@interface A (Protected)

@property (readonly, nonatomic) NSInteger hiddenValue;

@end

Note, this extension doesn't synthesize the hiddenValue (the private extension in A does that). But this provides a mechanism for anyone who imports A+Protected.h to have access to this property. Now, in this example, while hiddenValue is really readwrite (as defined in the private extension within A ), this category is exposing only the getter. (You obviously could omit readonly if you wanted it to expose both the getter and the setter, but I use this for illustrative purposes.)

Anyway, B can now do things like:

//  B.h

#import "A.h"

@interface B : A

- (void)experiment;

// but again, no properties exposed

@end

And

//  B.m

#import "B.h"
#import "A+Protected.h"

@implementation B

// but with this category, B now has read access to this `hiddenValue`

- (void)experiment {
    NSLog(@"%ld", (long)self.hiddenValue);
}

@end

Now A isn't exposing hiddenValue , but any code that uses this A (Protected) category (in this case, just B ) can now access this property.

And so now you can call B methods that might be using the hiddenValue from A , while never exposing it in the public interfaces.

//  ViewController.m

#import "ViewController.h"
#import "B.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    B *b = [[B alloc] init];
    [b experiment];          // this calls `B`’s exposed method, and that method is using the property not exposed by `A.h`
}

@end

---

If you're interested in a real-world example of this, consider UIKit's:

@import UIKit.UIGestureRecognizerSubclass;

Generally the state of a UIGestureRecognizer is readonly , but this UIGestureRecognizer (UIGestureRecognizerProtected) category exposes the readwrite accessors for state (to be used, as the name suggests, by gesture recognizer subclasses only).