属性@property中的关键字

作者: JoliLove | 来源:发表于2018-08-27 12:48 被阅读161次

一. 关于@property

@property, 是声明属性的语法,在iOS日常开发中经常会使用。
其实就是由编译器自动帮我们生成ivar成员变量,getter方法，setter方法。

二. @property属性关键字

我们经常使用assign,weak,strong,copy,nonatomic,atomic,readonly,readwrite,getter,setter等关键字, 他们具体作用是什么。

关键字	关键字作用
nonatomic	非原子性操作，不提供线程安全,多线程并发访问会提高性能。
atomic	原子操作,提供线程安全,默认是atomic,耗费系统资源
readwrite	读写的，默认属性
readonly	只可以读，不能写，可以获取
writeonly	只能写(set)，不能读(get), 一般用不到
assign	不会使引用计数加1,直接赋值,适用基础数据类型(int float double等)
retain	会使引用计数加1,ARC下已经不再使用，用strong代替。
copy	建立一个索引计数为1的对象，在赋值时使用传入值的一份拷贝,适用于NSString和block
strong	会使引用计数加1, ARC时才会使用，相当于retain。
weak	不增加引用计数,也不持有对象,ARC时才会使用，对象消失可以把对应的指针变量置为nil
unsafe_unretained	和weak类似，但是引用计数为0，变量不会置为nil
getter	手动设置获取实例变量的方法
setter	手动设置设置实例变量的方法

还有不常用关键字 nonnull,null_resettable,nullable

getter和setter关键字的解释

通过设置setter和getter关键字来修改setter和getter方法的方法名。

@property （getter=getName, setter=setName）object *obj;
//这样修饰就不会执行系统的getter和setter方法了，会执行自定义的getName和setName方法。

setter=<name>和getter=<name>一般用在特殊的情境下,当需要定义一个 init 开头的属性，但默认生成的 setter 与 getter 方法也会以 init 开头，而编译器会把所有以 init 开头的方法当成初始化方法，而初始化方法只能返回 self 类型，因此编译器会报错。

这时你就可以使用下面的方式来避免编译器报错：

@property(nonatomic, strong, getter=p_initBy, setter=setP_initBy:)NSString *initBy;

另外也可以用关键字进行特殊说明，来避免编译器报错：

@property(nonatomic, readwrite, copy, null_resettable) NSString *initBy;
- (NSString *)initBy __attribute__((objc_method_family(none)));

三. 自动合成(auto synthesize)

自动合成(auto synthesize)这个过程是由编译器在编辑阶段执行, 编译器自动向类中添加成员变量(在属性名前面加下划线)、生成setter、getter方法,在编译器里看不到这些"合成方法"源码。

但自动合成总有例外

在 protocol 中使用 property 只会生成 setter 和 getter 方法声明,
如果在协议中定义了是属性，就必须在实现类中用@synthesize添加对属性自动同步或者手动添加属性的成员变量及方法实现代码

// Protocol
@protocol MyProtocol <NSObject>
@property (nonatomic,strong) NSString *myImage;
@end

// 实现类
@interface ViewController : UIViewController<MyProtocol>
@end
@implementation ViewController
// 添加对属性自动同步
@synthesize myName = _myName;

- (void)viewDidLoad {
    [super viewDidLoad];
    self.myName = @"name";
    NSLog(@"%@,%@",_myName,self.myName);
@end

在category中可以用@property来添加属性，此种方式会自动生成对应属性的set和get方法的声明，但是没有set和get方法的实现，也不会自动生成带有“_”的属性(编译会通过，但run之后就会崩溃),但category中不支持用@synthesize添加对属性自动同步,但我们可以通过runtime手动添加setter/getter方法。

// 在category的声明中添加name属性：
#import <UIKit/UIKit.h>
@interface UIView (ETName)
@property(nonatomic,copy) NSString *name;
@end

//在category的实现中通过运行时重写属性的set和get，必须引入runtime.h头文件。
#import "UIView+ETName.h"
#import <objc/runtime.h>
@implementation UIView (ETName)
-(void)setName:(NSString *)name
{
    //self表示正在运行的对象，“NAME”是C的标识，name为添加的新属性的值，最后一个参数是属性修饰符（枚举）
    objc_setAssociatedObject(self, "NAME", name, OBJC_ASSOCIATION_COPY_NONATOMIC );
}

-(NSString *)name
{
    return objc_getAssociatedObject(self, "NAME");
}
@end

四. @synthesize 和 @dynamic

@property 有两个对应的词,@synthesize和@dynamic
@synthesize 的语义是如果你没有手动实现 setter 方法和 getter 方法，那么编译器会自动为你加上这两个方法。
@dynamic 告诉编译器：属性的 setter 与 getter 方法由用户自己实现，不自动生成。
如果 @synthesize和 @dynamic都没有，默认自动合成

四. 以下是关于@property属性相关面试题

1. 使用 atomic 一定是线程安全的吗?

答案很明显。不是,

atomic 的本意是指属性的存取方法是线程安全的,并不保证整个对象是线程安全的。
例如：
声明一个 NSMutableArray 的原子属性 stuff,此时 self.stuff 和 self.stuff =othersulf 都是线程安全的。但是,使用[self.stuff objectAtIndex:index]就不是线程安全的,需要用互斥锁来保证线程安全性。

2. @property 的本质是什么？ivar、getter、setter 是如何生成并添加到这个类中的

@property 的本质是什么？

@property = ivar + getter + setter;
“属性” (property)有两大概念：ivar（实例变量）、存取方法（access method ＝ getter + setter）

ivar、getter、setter 是如何生成并添加到这个类中的?

“自动合成”( autosynthesis)
完成属性定义后，编译器会自动编写访问这些属性所需的方法，此过程叫做“自动合成”(autosynthesis)。需要强调的是，这个过程由编译器在编译期执行，所以编辑器里看不到这些“合成方法”(synthesized method)的源代码。除了生成方法代码 getter、setter 之外，编译器还要自动向类中添加适当类型的实例变量，并且在属性名前面加下划线，以此作为实例变量的名字。例如: 属foo，会生成实例变量 _foo。也可以在类的实现代码里通过 @synthesize 语法来指定实例变量的名字.

3. @protocol 和 category 中如何使用 @property

在 protocol 中使用 property 只会生成 setter 和 getter 方法声明,可以在实现类中用@synthesize添加对属性自动同步或者手动添加属性的成员变量及方法实现代码
category 使用 @property 也是只会生成 setter 和 getter 方法的声明,如果我们真的需要给 category 增加属性的实现,需要借助于运行时的两个函数：
1、objc_setAssociatedObject
2、objc_getAssociatedObject
具体实现见上文"自动合成"

4. @synthesize和@dynamic分别有什么作用

@property有两个对应的词，一个是 @synthesize，一个是 @dynamic。如果 @synthesize和 @dynamic都没写，那么默认的就是@syntheszie var = _var;
@synthesize 的语义是如果你没有手动实现 setter 方法和 getter 方法，那么编译器会自动为你加上这两个方法。
@dynamic 告诉编译器：属性的 setter 与 getter 方法由用户自己实现，不自动生成。（当然对于 readonly 的属性只需提供 getter 即可）。假如一个属性被声明为 @dynamic var，然后你没有提供 @setter方法和 @getter 方法，编译的时候没问题，但是当程序运行到 instance.var = someVar，由于缺 setter 方法会导致程序崩溃；或者当运行到 someVar = var时，由于缺 getter 方法同样会导致崩溃。编译时没问题，运行时才执行相应的方法，这就是所谓的动态绑定。

5.在有了自动合成属性实例变量之后，@synthesize还有哪些使用场景？

同时复写了setter和getter方法
复写了只读属性的getter方法
使用了@dynamic
Protocol里声明的所有属性
Category里声明的所有属性
重载的属性
当你在子类中重载了父类的属性必须使用@synthesize手动实现ivar
通过 @synthesize 语法来指定实例变量的名字

6. @synthesize合成实例变量的规则是什么？假如property名为foo，存在一个名为_foo的实例变量，那么还会自动合成新变量么？

合成实例变量规则

如果指定了成员变量的名称,会生成一个指定的名称的成员变量,
如果这个成员已经存在了就不再生成了.
如果是 @synthesize foo; 还会生成一个名称为foo的成员变量，也就是说：
如果没有指定成员变量的名称会自动生成一个属性同名的成员变量,
如果是 @synthesize foo = _foo; 就不会生成成员变量了.

假如 property 名为 foo，存在一个名为 _foo 的实例变量，那么还会自动合成新变量么
不会

@property(nonatomic, copy) NSString *name;
/*
下面一行代码会报出警告 
Auto property synthesis will not synthesize property "_name" because it cannot
share an ivar with another synthesized property
*/
@property(nonatomic,copy) NSString *_name;

7. ARC 下,不显式指定任何属性关键字时,默认的关键字都有哪些?

基本数据： atomic,readwrite,assign
普通的 OC 对象: atomic,readwrite,strong

8. 什么情况使用 weak 关键字,相比 assign 有什么不同?

什么情况下使用weak

在ARC中有可能会出现循环引用的情况,往往通过其中一端使用weak来解决, 比如delagate代理属性,自身已经对它有过一次强应用,没有必要再强引用一次。这个时候也会使用weak；还有就是自定义IBOutlet控件属性一般也使用weak，一般情况也可以使用strong。

weak和assign的区别

assign可以用于非OC对象, 可以修饰OC数据类型, 和基本数据类型.(OC: CGFloat, NSInteger等, 非OC: int, float等)
weak必须用于OC对象.
assign修饰对象会产生野指针, weak不会
weak 策略在属性所指的对象遭到摧毁时,系统会将 weak 修饰的属性对象的指针指向 nil,在 OC 给 nil 发消息是不会有什么问题的;如果使用 assign 策略在属性所指的对象遭到摧毁时,属性对象指针还指向原来的对象,由于对象已经被销毁,这时候就产生了野指针,如果这时候在给此对象发送消息,很容造成程序奔溃

不要用assign修饰对象

对象的内存一般被分配到堆上，基本数据类型和oc数据类型的内存一般被分配在栈上。

用weak修饰, 对象遭到摧毁时,引用计数为0,自动赋值为nil.而使用assign修饰,对象摧毁时,只是引用计数为0, 并不会自动赋值为nil,指针地址还是存在的,之后再向该対像发消息,就会导致野指针操作.
如果这个操作发生时内存还没有改变内容，依旧可以正确的运行，而如果发生时内存内容被改变了，就会crash。

总结

weak表明该属性定义了一种(nonowning relationship)非拥有关系.为这种属性赋值时, 既不会保留新值,也不释放旧值.
在ARC模式下编程时，指针变量一定要用weak修饰，例如delegate和block一定要用weak修饰。不会导致野指针问题，也不会循环引用
只有基本数据类型和结构体需要用assgin，因为值类型会被放入栈中，遵循先进后出原则，由系统负责管理栈内存。而引用类型会被放入堆中，需要我们自己手动管理内存或通过ARC管理。

9. runtime 如何实现 weak 属性

weak 属性的特点：
weak 此特质表明该属性定义了一种“非拥有关系” (nonowning relationship)。为这种属性设置新值时，设置方法既不保留新值，也不释放旧值。此特质同 assign 类似，然而在属性所指的对象遭到摧毁时，属性值也会清空(nil out)。
runtime 如何实现 weak 变量的自动置nil？
runtime对注册的类，会进行布局，对于 weak 对象会放入一个 hash 表中。用 weak 指向的对象内存地址作为 key，当此对象的引用计数为0的时候会 dealloc，假如 weak 指向的对象内存地址是a，那么就会以a为键，在这个 weak 表中搜索，找到所有以a为键的 weak 对象，从而设置为 nil。
如何让不使用weak修饰的@property，拥有weak的效果。
(在一些博客中看到利用runtime实现了此效果, 以下是参考源码)
源码: CYLDeallocBlockExecutor

10. IBOutlet连出来的视图属性为什么可以被设置成weak

参考链接： Should IBOutlets be strong or weak under ARC?

文章告诉我们：

因为既然有外链那么视图在xib或者storyboard中肯定存在，视图已经对它有一个强引用了。
不过这个回答漏了个重要知识，使用storyboard（xib不行）创建的vc，会有一个叫_topLevelObjectsToKeepAliveFromStoryboard的私有数组强引用所有top level的对象，所以这时即便outlet声明成weak也没关系

11. 怎么用 copy 关键字？

NSString、NSArray、NSDictionary 等等经常使用copy关键字，是因为他们有对应的可变类型：NSMutableString、NSMutableArray、NSMutableDictionary,他们之间可能进行赋值操作，为确保对象中的字符串值不会无意间变动，应该在设置新属性值时拷贝一份。
解释copy 此特质所表达的所属关系与 strong 类似。然而设置方法并不保留新值，而是将其“拷贝” (copy)。当属性类型为 NSString 时，经常用此特质来保护其封装性，因为传递给设置方法的新值有可能指向一个 NSMutableString 类的实例。这个类是 NSString 的子类，表示一种可修改其值的字符串，此时若是不拷贝字符串，那么设置完属性之后，字符串的值就可能会在对象不知情的情况下遭人更改。所以，这时就要拷贝一份“不可变” (immutable)的字符串，确保对象中的字符串值不会无意间变动。只要实现属性所用的对象是“可变的” (mutable)，就应该在设置新属性值时拷贝一份。
block 也经常使用 copy 关键字，
解释block 使用 copy 是从 MRC 遗留下来的“传统”,在 MRC 中,方法内部的 block 是在栈区的,使用 copy 可以把它放到堆区.在 ARC 中写不写都行：对于 block 使用 copy 还是 strong 效果是一样的，如果不写 copy ，该类的调用者有可能会忘记或者根本不知道“编译器会自动对 block 进行了 copy 操作”，他们有可能会在调用之前自行拷贝属性值。

12. 用@property声明的NSString（或NSArray，NSDictionary）经常使用copy关键字，为什么？如果改用strong关键字，可能造成什么问题？

因为父类指针可以指向子类对象,使用 copy 的目的是为了让本对象的属性不受外界影响,使用 copy 无论给我传入是一个可变对象还是不可对象,我本身持有的就是一个不可变的副本.
详情解释见第9题怎么用 copy 关键字
如果我们使用是 strong ,那么这个属性就有可能指向一个可变对象,如果这个可变对象在外部被修改了,那么会影响该属性.

13. 这个写法会出什么问题： @property (copy) NSMutableArray *array;

两个问题：

1. 添加,删除,修改数组内的元素的时候,程序会因为找不到对应的方法而崩溃.因为 copy 就是复制一个不可变 NSArray 的对象；
  详情解释见第9题怎么用 copy 关键字
1. 使用了 atomic 属性会严重影响性能；
  该属性使用了同步锁，会在创建时生成一些额外的代码用于帮助编写多线程程序，这会带来性能问题，通过声明 nonatomic 可以节省这些虽然很小但是不必要额外开销。