ref – http://stackoverflow.com/questions/7057934/property-vs-instance-variable
http://stackoverflow.com/questions/9702258/difference-between-properties-and-variables-in-ios-header-file
An instance variable is unique to a class. By default, only the class and subclasses can access it. Therefore, as a fundamental principal of object-oriented programming, instance variables (ivars) are private—they are encapsulated by the class.
By contrast, a property is a public value that may or may not correspond to an instance variable. If you want to make an ivar public, you’d probably make a corresponding property. Declaring (and synthesizing) a property generates getter and setter methods for the instance variable.
But at the same time, instance variables that you wish to keep private should and do not have corresponding properties…so they cannot be accessed from outside of the class.
In Practice
Instance variables declared in .h files are NOT accessible from the outside.
|
1 2 3 4 5 |
@interface ViewController : UIViewController { int pubIVar; } @property(nonatomic, strong) NSNumber * publicProperty; @end |
As you can see, pubIVar does not show up and cannot be accessed. Whereas, publicProperty does show up, and we can access it. What we’re accessing in the image is its getter method.
Of course, instance variables declared in the private extensions of the .m files are obviously also private.
Defining Properties
The approach currently suggested by Apple (in templates) is:
Define property in header file, e.g.:
|
1 |
@property (assign, readonly) gameCenter; |
Then synthesize & declare ivar in implementation:
|
1 |
@synthesize gameCenter = __gameCenter; |
The last line synthesizes the gameCenter property and asserts that whatever value is assigned to the property will be stored in the __gameCenter ivar. Again, this isn’t necessary, but by defining the ivar next to the synthesizer, you are reducing the locations where you have to type the name of the ivar while still explicitly naming it.
Instance Variables (iVars)
Instance variables, sometimes referred to as
ivars
, are variables declared for a class that exist and hold their value throughout the life of a corresponding class instance (i.e., object). The memory used for instance variables is allocated when an object is first created, and freed when the object is deallocated.
In your interface, you can formally declare an instance variable between the braces, or via @property outside the braces, or both. Either way, they become attributes of the class. The difference is that if you declare @property, then you can implement using @synthesize, which auto-codes your getter/setter for you. The auto-coder setter initializes integers and floats to zero, for example. IF you declare an instance variable, and DO NOT specify a corresponding @property, then you cannot use @synthesize and must write your own getter/setter.
Access to those iVars
@private: The instance variable is only accessible within the class that declares it and other instances of this class type.
@protected: The instance variable is accessible within the class that declares it and the instance methods of any of its subclasses. This is the default scope if a protection level is not specified for an instance variable.
@public: The instance variable is accessible from everywhere.
@package: The instance variable is accessible from any other class instance or function, but outside the package, it is treated as private. This scope can be useful for libraries or framework classes.
Although instance variables provide convenient, direct access to an object’s state, they expose the internals of a class—and this violates the OOP principle of encapsulation. Therefore, instance variables should only be declared when necessary, and the declaration should be in the class implementation, not the public interface.
.m implementation file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
@interface MonthPerformance() //even though helper is synthesized, it is private and cannot be accessed from others. //The reason is because we declared it in the interface of our implementation file @property(nonatomic, retain) MonthPerformanceHelper * helper; @property (nonatomic, assign) int trash;//EXPLICIT definition. //1) Declared in Implementation only. //2) write method definitions @property (nonatomic, assign) NSInteger sort; @end @implementation MonthPerformance //if its just used like this: @synthesize sort; //self.sort is used to acces its getter/setter methods //and sort would be used to access the iVar //setter/getter = iVar //so self.helper would be the setter/getter and myHelper would be the iVar //helper is not used and compiler will show error @synthesize helper=myHelper; //EXPLICIT DEFINITIONS of property trash //we declare them because we do not use @synthesis, which means //we want to write our own getter setter definitions -(void)setTrash:(int)newTrash { _trash = newTrash; } -(int)getTrash { return _trash; } @end |
usage for trash:
|
1 2 3 4 5 6 7 8 |
self.trash = 10; //run through your explicit getter/setter methods _trash = 1; //ivar for our explicit self.helper = [[Helper alloc] init]; [myHelper release] self.sort = 10; //runs through getter/setter methods sort = -1; //iVar |
Also, take note that other classes can’t use ‘helper’ nor ‘trash’ because they are declared in the interface of the implementation file.
.h header file:
|
1 2 3 4 5 |
@interface MonthPerformance : NSObject { } @property (nonatomic, assign) int trash;//EXPLICIT definition. |
If we are to declare the variable in our header file, we can then proceed to go
instObj.trash = 100;
example
We declare a private variable datePickerView. Notice there is no synthesize. We do this because we want to declare our get/set methods. Which means we want explicit get/set definitions.
|
1 2 3 |
@interface RSDFDatePickerViewController() <RSDFDatePickerViewDelegate, RSDFDatePickerViewDataSource> @property (strong, nonatomic) RSDFDatePickerView *datePickerView; //has custom get method @end |
We want to define an explicit get method.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
@implementation RSDFDatePickerViewController //explicit definition - (RSDFDatePickerView *)datePickerView { if (!_datePickerView) { _datePickerView = [[RSDFDatePickerView alloc] initWithFrame:self.view.bounds calendar:self.calendar]; _datePickerView.delegate = self; _datePickerView.dataSource = self; _datePickerView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight; } return _datePickerView; } |
And we just use it like so. the get method in our example basically make sure there is a newly allocated variable if a previous one is not detected.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
-(void)viewDidLoad { .... [self.datePickerView selectDate:today]; .... } - (void)onRestyleButtonTouch:(UIBarButtonItem *)sender { if (!self.datePickerView.hidden) { self.navigationController.navigationBar.barTintColor = [UIColor colorWithRed:244/255.0f green:245/255.0f blue:247/255.0f alpha:1.0f]; self.datePickerView.hidden = YES; self.customDatePickerView.hidden = NO; } else { self.navigationController.navigationBar.barTintColor = [UIColor colorWithRed:248/255.0f green:248/255.0f blue:248/255.0f alpha:1.0f]; self.customDatePickerView.hidden = YES; self.datePickerView.hidden = NO; } } @end |