@property详解，@property修饰符以及各个修饰符区别（上）

相信很多参加过面试的人员很多都会被问到：weak与assign的区别，copy与strong的区别。如果你仅仅说一点点copy一般对NSString，weak对于控件的修饰，assign对于基本类型，那么面试官可以会对你深入问，block用过吗？修饰block用什么，又为什么用copy，这样一层层问下去，可能场面就很尴尬了，即使你进去，可能薪资也不能达到你所期望的。这篇我准备花几天完成，希望对大家有所帮助，阅读这篇问题大约需要20-30分钟……

 一.@property

1.讲解

Objective-C的属性（property）是通过用@property定义的公有或者私有的方法。属性（property）提供了一种安全、便捷的方式来与这些属性(attribute)交互，而不需要手动编写一系列的访问方法，如果需要的话可以自定义getter和setter方法来覆盖编译器自动生成的相关方法。

尽量多的使用属性（property）而不是实例变量（attribute）因为属性（property）相比实例变量有很多的好处:

（1）自动合成getter和setter方法。当声明一个属性(property)的时候编译器默认情况下会自动生成相关的getter和setter方法更好的声明一组方法。

（2）因为访问方法的命名约定，可以很清晰的看出getter和setter的用处。

2.用法

@interface Person : NSObject
{
    NSString *_name;
    NSUInteger _age;
}

- (void)setName:(NSString*)name;
- (NSString*)name;
- (void)setAge:(NSUInteger)age;
- (NSUInteger)age;

@end

@implementation Person

- (void)setName:(NSString*)name {
    _name = [name copy];
}

- (NSString*)name {
    return _name;
}

- (void)setAge:(NSUInteger)age {
    _age = age;
}

- (NSUInteger)age {
    return _age;
}

@end

上述代码就是手动创建变量的getter和setter的实现，getter和setter本质就是符合一定命名规范的实例方法。

具体使用

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p = [[Person alloc] init];
        //函数调用name的setter
        [p setName:@"Jiaming Chen"];
        //函数调用age的setter
        [p setAge:];
        //函数调用name和age的getter，输出 Jiaming Chen 22
        NSLog(@"%@ %ld", [p name], [p age]);
    }
    return ;
}

//另一种写法
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p = [[Person alloc] init];
        //使用点语法访问name的setter
        p.name = @"Jiaming Chen";
        //使用点语法访问age的setter
        p.age = ;
        //使用点语法访问name和age的getter，输出 Jiaming Chen 22
        NSLog(@"%@ %ld", p.name, p.age);
    }
    return ;
}

Objective-C允许使用点语法来访问getter和setter。

合成使用，使用@property方法

@interface Person : NSObject

@property (nonatomic, copy) NSString* name;
@property (nonatomic, assign) NSUInteger age;

@end

@implementation Person

//编译器会帮我们自动生成_name和_age这两个实例变量，下面代码就可以正常使用这两个变量了
@synthesize name = _name;
@synthesize age = _age;

- (void)setName:(NSString*)name {
    //必须使用_name来赋值，使用self.name来设置值时编译器会自动转为调用该函数，会导致无限递归
    //使用_name则是直接访问底层的存储属性，不会调用该方法来赋值
    //这里使用copy是为了防止NSMutableString多态
    _name = [name copy];
}

- (NSString*)name {
    //必须使用_name来访问属性值，使用self.name来访问值时编译器会自动转为调用该函数，会造成无限递归
    return _name;
}

@end

 二.@property后面有哪些修饰符

1.线程安全的-------atomic、nonatomic

atomic：原子性：Object-C使用的是一种线程保护技术，从基本上讲，是防止在未完成的时候被另一个线程更改，造成数据错误。而这种机制是耗费系统资源，所以在iPhone这种小型设备上，如果没有使用多线程之间的通讯编程，那么nonatomic是一个非常好的选择。

nonatomic：非原子性： 禁止多线程，变量保护，提高性能。

原子性：默认

这个属性是为了保证程序在多线程下，编译器会自动生成自旋锁代码，避免该变量的读写不同步问题，提供多线程线程，多线程只有一个线程对它访问。

attention

（1）atomic原子性指的是一个操作不可以被CPU中途叫停，然后再调度。即不能被中断，要么执行完，要么不执行。

（2）atomic是自旋锁，当上一个线程没有执行完毕的时候（被锁住），下一个线程会一直等待，不会进入睡眠，当上一个线程执行完毕后，下一个线程会立即执行。它区别于互斥锁，互斥锁在等待的时候，会进入睡眠状态，当上一个线程执行完毕之后，会被唤醒，然后再执行。

（3）atomic需要消耗大量的资源，执行效率低

但是atomic并不保证线程安全，因为只会保持set内部安全，在外面并不能保证安全！例如在数组array set方法中atomic原子操作，但是外面使用array addobject并不会保证线程安全！

二、访问权限

readwrite 默认 拥有getter/setter方法，可读可写

readonly 只读属性，只会生成getter方法，不会生成setter方法

三、内存管理

1.assign 默认

适用于基本数据类型：NSInteger，CGFloat和C数据类型int，float等，另外还有id类型

2.strong对应MRC中的retain

强引用，只有OC对象才能使用该属性，它使对象的引用计数加1

3.weak

弱引用，只是单纯引用某个对象，但是并未拥有该对象

即一个对象被持有无数个弱引用，只要没有强引用指向它，那么它就会被清楚释放。

下面通过一些拓展一下：面试重点！！！

（1）strong与retain

相同点：strong和retain都是针对对象类型进行内存管理。如果去修饰基本数据类型，Xcode会直接报错，当给对象类型使用此修饰符时，setter方法先将旧的对象属性release掉，再将新的对象赋值给属性并对该对象进行一次retain操作，两者都会增加对象的引用计数。

不同点：strong一般用于ARC，retain一般用于MRC环境。

（2）assgin与weak

相同点：assgin和weak不会牵扯到内存管理，不会增加引用计数

不同点：assign可修饰基本数据类型，也可修饰OC对象，但如果修饰对象类型指向的是一个强指针，当它指向的这个指针释放后，他仍指向这块内存，必须手动给置为nil，否则就会产生野指针，如果还通过此指针操作那块内存，便会导致EXC_BAD_ACCESS错误，调用了已经释放的内存空间；而weak只能修饰OC对象，且相比assign比较安全，如果指向的对象消失了，那么他会自动置为nil，不会产生野指针。

（3）strong与copy（重点重点）--这个可能比较难懂，多看两遍，可能有点乏味，不过很重要！！！

1.copy(拓展)----深拷贝和浅拷贝的区别

浅拷贝：指针拷贝，不产生新的对象，源对象的引用计数器加1；只是多了一个指向这块内存的指针，共用一块内存。

深拷贝：对象拷贝，会产生新的对象，源对象的引用计数器不变；两块内存是完全不同的，也就是两个对象指针分别指向不同的内存，互不干涉。

判断是浅拷贝和深拷贝就看一下两个变量的内存地址是否一样，一样就是浅拷贝，不一样就是深拷贝，也可以改变一个变量的其中一个属性值看两者的值都会发生变化；

系统原生的对象深浅拷贝区别：

NSObject类提供了copy和mutableCopy方法，通过这两个方法即可拷贝已有对象的副本，主要的系统原生对象有:NSString和NSMutableString、NSArray和NSMutableArray、NSDictionary和NSMutableDictionary、NSSet和NSMutableSet。 NSValue和NSNumber 只遵守的NSCopying协议。

NSString-------copy/mutableCopy

NSString *string = @"copyTest";
NSString *copyString = [string copy];
NSString *mutableCopyString = [string mutableCopy];
NSMutableString *copyMutableString = [string copy];
NSMutableString *mutableCopyMutableString = [string mutableCopy];
NSLog(@"\n string = %p \n copystring = %p \n mutablecopystring = %p "
       "\n copyMutableString = %p \n mutableCopyMutableString = %p \n",
      string, copyString, mutableCopyString, copyMutableString, mutableCopyMutableString);  

打印结果：

-- ::51.209346+ copy[:]
 string = 0x100001040
 copystring = 0x100001040
 mutablecopystring = 0x10058c8e0
 copyMutableString = 0x100001040
 mutableCopyMutableString = 0x10058cde0
Program ended with exit code: 

小结论：在字符串是直接赋值的，是否生成新对象是和=右边相关的，如果=右边的是mutableCopy才会产生新的对象

NSMutableString----copy/mutableCopy

NSMutableString *string = [NSMutableString stringWithString:@"学习研究"];
NSString *copyString = [string copy];
NSString *mutableCopyString = [string mutableCopy];
NSMutableString *copyMutableString = [string copy];
NSMutableString *mutableCopyMutableString = [string mutableCopy];
NSLog(@"\n string = %p \n copystring = %p \n mutablecopystring = %p "
       "\n copyMutableString = %p \n mutableCopyMutableString = %p \n",
      string, copyString, mutableCopyString, copyMutableString, mutableCopyMutableString);  

打印结果：

-- ::44.755398+ copy[:]
 string = 0x100504600
 copystring = 0x100554e10
 mutablecopystring = 0x100555880
 copyMutableString = 0x100506e40
 mutableCopyMutableString = 0x1005558f0
Program ended with exit code: 

小结论：只要=右边从创建到赋值，至少包含一个MSMutable便会重新创建生成一个对象。

其他对象NSArray、NSMutableArray 、NSDictionary、NSMutableDictionary、NSSet、NSMutableSet一样适用。

刚刚疏解完copy，下面看一下面试最喜欢问的strong和copy修饰的区别：

下面看一组例子：

以NSString为例说明下，首先定义以下属性。

 @property (nonatomic, strong) NSString *strongString;
 @property (nonatomic, copy) NSString *copyedString;
 @property (nonatomic, strong) NSMutableString *strongMutableString;
 @property (nonatomic, copy) NSMutableString *copyedMutableString; 

2.1 当外部赋给对应属性一个不可变（非mutable）的字符串 NSString

 - (void)testPropertyCopyOrStrong
 {
     NSString *string = [NSString stringWithFormat:@"abc"];
     self.strongString = string;
     self.strongMutableString = string;
     self.copyedString = string;
     self.copyedMutableString = string;
     string = [string stringByReplacingOccurrencesOfString:@"c" withString:@""];  

     NSLog(@"\n origin        string: %p, %p  %@  %@", string, &string, string, NSStringFromClass([string class]));
     NSLog(@"\n strong        string: %p, %p  %@  %@", _strongString, &_strongString, _strongS　　tring, NSStringFromClass([_strongString class]));
     NSLog(@"\n strongMutable string: %p, %p  %@  %@", _strongMutableString, &_strongMutableSt　　ring, _strongMutableString, NSStringFromClass([_strongMutableString class]));
     NSLog(@"\n copy          string: %p, %p  %@  %@", _copyedString, &_copyedString, _copyedS　　tring, NSStringFromClass([_copyedString class]));
     NSLog(@"\n copyMutable   string: %p, %p  %@  %@", _copyedMutableString, &_copyedMutableSt　　ring, _copyedMutableString, NSStringFromClass([_copyedMutableString class]));  

 }  

打印结果：

 origin        string: 0x103a74098, 0x7fff5c18ca88  ab233  __NSCFString
 strong        string: 0xa000000006362613, 0x7f84c9f056d8  abc  NSTaggedPointerString
 strongMutable string: 0xa000000006362613, 0x7f84c9f056e8  abc  NSTaggedPointerString
 copy          string: 0xa000000006362613, 0x7f84c9f056e0  abc  NSTaggedPointerString
 copyMutable   string: 0xa000000006362613, 0x7f84c9f056f0  abc  NSTaggedPointerString

可能大家不是很看懂这个例子：我们换一个简单的操作：

首先在类延展中声明两个属性变量：

 @property (nonatomic, strong)NSString * stringStrong;   //strong修饰的字符串对象
 @property (nonatomic, copy)NSString * stringCopy;       //copy修饰的字符串对象

接着创建两个不可变字符串(NSString)

 //新创建两个NSString对象
 NSString * strong1 = @"I am Strong!";
 NSString * copy1 = @"I am Copy!";

将这两个属性进行赋值

 //初始化两个字符串
 self.stringStrong = strong1;
 self.stringCopy = copy1;

分别打印四个变量的地址

   StrongOrCopy[:] strong1 = 0x10a0b3078
   StrongOrCopy[:] stringStrong = 0x10a0b3078 

//这是两个字符串

 StrongOrCopy[:] copy1 = 0x10a0b3098 

 StrongOrCopy[:] stringCopy = 0x10a0b3098 

结果发现：可以看出，无论是strong修饰的字符串还是copy修饰的字符串，都进行了浅拷贝（仅仅是多了个指向该内存的指针，地址不会发挥变化）

如果创建两个不可变字符串对象(NSMutableString)呢

 //新创建两个NSMutableString对象
 NSMutableString * mutableStrong = [NSMutableString stringWithString:@"StrongMutable"];
 NSMutableString * mutableCopy = [NSMutableString stringWithString:@"CopyMutable"];

分别对属性再次赋值

self.stringStrong = mutableStrong;
self.stringCopy = mutableCopy;  

打印结果：

  StrongOrCopy[:] mutableStrong = 0x7fccba425d60
  StrongOrCopy[:] stringStrong = 0x7fccba425d60
  StrongOrCopy[:] mutableCopy = 0x7fccba40d7c0
  StrongOrCopy[:] stringCopy = 0x7fccba4149e0  

结果发现：这时就发现了,用strong修饰的字符串依旧进行了浅Copy,而由copy修饰的字符串进行了深Copy,所以mutableStrong与stringStrong指向了同一块内存，而mutableCopy和stringCopy指向的是完全两块不同的内存。

看了一些实例，有什么用呢，看如下：

 //新创建两个NSString对象
 NSString * strong1 = @"I am Strong!";
 NSString * copy1 = @"I am Copy!";  

 //初始化两个字符串
 self.stringStrong = strong1;
 self.stringCopy = copy1;  

 //两个NSString进行操作
 [strong1 stringByAppendingString:@""];
 [copy1 stringByAppendingString:@""]; 

结果如下：

  StrongOrCopy[:] strong1 = I am Strong!
  StrongOrCopy[:] stringStrong = I am Strong!
  StrongOrCopy[:] copy1 = I am Copy!
  StrongOrCopy[:] stringCopy = I am Copy! 

分别对在字符串后面进行拼接，当然这个拼接对原字符串没有任何的影响，因为不可变自字符串调用的方法都是有返回值的，原来的值是不会发生变化的.打印如下，对结果没有任何的影响:（不可变的字符串）

然后是对可变字符串进行操作:

 //新创建两个NSMutableString对象
 NSMutableString * mutableStrong = [NSMutableString stringWithString:@"StrongMutable"];
 NSMutableString * mutableCopy = [NSMutableString stringWithString:@"CopyMutable"];  

 //初始化两个字符串
 self.stringStrong = mutableStrong;
 self.stringCopy = mutableCopy;  

 //两个MutableString进行操作
 [mutableStrong appendString:@"Strong!"];
 [mutableCopy appendString:@"Copy!"];  

打印结果如下：

  StrongOrCopy[:] stringStrong = StrongMutableStrong!
  StrongOrCopy[:] mutableStrong = StrongMutableStrong!
  StrongOrCopy[:] stringCopy = CopyMutable
  StrongOrCopy[:] mutableCopy = CopyMutableCopy! 

对mutableStrong进行的操作，由于用strong修饰的stringStrong没有进行深Copy，导致共用了一块内存，当mutableStrong对内存进行了操作的时候，实际上对stringStrong也进行了操作;   相反，用copy修饰的stringCopy进行了深Copy，也就是说stringCopy与mutableCopy用了两块完全不同的内存，所以不管mutableCopy进行了怎么样的变化，原来的stringCopy都不会发生变化.这就在日常中避免了出现一些不可预计的错误。

总结：在不可变对象之间进行转换，strong与copy作用是一样的，但是如果在不可变与可变之间进行操作，那么楼主比较推荐copy,这也就是为什么很多地方用copy，而不是strong修饰NSString,NSArray等存在可变不可变之分的类对象了，避免出现意外的数据操作.

>>>>>>>拓展

修饰block为什么要用copy修饰？

关于block的用法，前几篇博客有，请关注：下面直接说原因：

（1）block内部没有调用外部局部变量时存放在全局区(ARC和MRC下均是)

（2）block使用了外部局部变量,这种情况也正是我们平时所常用的方式。MRC：Block的内存地址显示在栈区,栈区的特点就是创建的对象随时可能被销毁,一旦被销毁后续再次调用空对象就可能会造成程序崩溃,在对block进行copy后,block存放在堆区.所以在使用Block属性时使用copy修饰。但是ARC中的Block都会在堆上的，系统会默认对Block进行copy操作

（3）用copy，strong修饰block在ARC和MRC都是可以的，都是在堆区

下面继续讲解

4.指定方法名称： setter= getter=

今天到此结束（如果太多，可能大家一时接受不了），下一步，我可能继续讲解block造成的循环引用，@property与ivar的区别等，看@property引出的那些问题