Objective-C: Attributes of
a way to define the information that a class is intended to encapsulate. If you
declare an object/variable using @property, then that object/variable
will be accessible to other classes importing its class. If you
declare an object using @property in the header file, then you have to
synthesize it using @synthesize in the implementation file.
List of attributes of @property :
atomic : It is the
default behaviour. If an object is declared as atomic then it becomes
thread-safe. Thread-safe means, at a time only one thread of a particular
instance of that class can have the control over that object.
@property NSString *name; //by default atomic
@property (atomic)NSString *name; // explicitly declared atomic
nonatomic: It is not thread-safe. You can use the nonatomic
property attribute to specify that synthesized accessors simply set or return a
value directly, with no guarantees about what happens if that same value is
accessed simultaneously from different threads. For this reason, it’s faster to
access a nonatomic property than an atomic one.
@property (nonatomic)NSString *name;
retain: is required when the attribute is a pointer to an
object.The setter method will increase retain count of the object, so that it
will occupy memory in autorelease pool.
@property (retain)NSString *name;
you use copy, you can't use retain. Using copy instance of the class will
contain its own copy.
Even if a mutable string is
set and subsequently changed, the instance captures whatever value it has at
the time it is set. No setter and getter methods will be synthesized.
@property (copy) NSString *name;
NSMutableString *nameString = [NSMutableString stringWithString:@"Liza"];
xyzObj.name = nameString;
readonly: If you don't want to allow the property to be
changed via setter method, you can declare the property readonly.
@property (readonly) NSString *name;
is the default behaviour. You don't need to specify readwrite attribute
@property (readwrite) NSString *name;
assign: will generate a setter which assigns the value to
the instance variable directly, rather than copying or retaining it. This is
best for primitive types like NSInteger and CGFloat, or objects you don't
directly own, such as delegates.
@property (assign) NSInteger year;
is a replacement for retain.
@property (nonatomic, strong) AVPlayer *player;
are a few classes in Cocoa and Cocoa Touch that don’t yet support weak
references, which means you can’t declare a weak property or weak local
variable to keep track of them. These classes include NSTextView, NSFont and
NSColorSpace,etc. If you need to use a weak reference to one of these classes,
you must use an unsafe reference.
An unsafe reference is
similar to a weak reference in that it doesn’t keep its related object alive,
but it won’t be set to nil if the destination object is
@property (unsafe_unretained) NSObject *unsafeProperty;
weak is similar to strong
except that it won't increase the reference count by 1. It does not become an
owner of that object but just holds a reference to it. If the object's
reference count drops to 0, even though you may still be pointing to it here,
it will be deallocated from memory.