一. 成员变量,实例变量,属性变量

1. 成员变量 : 用在类的内部,无须与外部接触.成员变量默认是被保护的,所以不会有setter和getter方法. 成员变量是定义在{}中的变量.

2. 实例变量: 如果变量类型是一个类. 如: UILabel * label;那么这个变量就是实例化变量. 所以实例化变量也是成员变量的一种. 不需要与外部接触.或者称为类的私有变量.

3. 属性量.@property (nonatomic, copy) NSString *age;
   属性变量声明之后,编译器会自动生成一个以下划线开头的实例变量_age. 不需要自己手动再去写实例变量. 也会自动生成对应的setter和getter.

二. 属性变量的getter和setter方法

1. setter: 给外部提供一个修改内部属性的接口,通过给对象指针发送该消息(调用setter方法)可以做到修改内部的属性值.
2. getter: 为外部提供的一个查看内部变量的接口.
3. 举例说明.

   UILabel * label = [[UILabel alloc] init];
   [label setText:@"这是一个label"];  // 外部调用UILabel内>部的text属性的setter方法,修改属性值.
   NSString * textStr = [label text];// 外部访问UILabel的getter方法,读取该属性的值.
  NSLog(@"textStr = %@",textStr);
   

   //setter方法
  - (void)setAge:(NSString *)age {
       _age = age;
 }
  //getter方法
   - (NSString *)age {
       return _age;
   }
  
   // 点调用
   label.text = @"这是一个label";  // '.'调用在'='左边相当于setter
   textStr = label.text;          // '.'调用在'='右边相当于getter

4. 实战
   (1). setter: 可以添加一个规则来保证set的值是否正确等用法.

// 重写set方法,并保证该属性的值为 >= 1
- (void)setCount:(int)count {
   if (count < 1) {
       count = 1;
   }
   _count = count;
}

(2). getter : 可以精简代码等其他好处.
声明一个UIColor的对象属性.每当该类中的一个label的背景颜色改变之后,就 赋值给这个对象.那么每次都要读取这个label的颜色属性. 但是如果用getter方法就可以简化为

- (UIColor *)color {
   return label.backgroundColor;
}

二. 原子性修饰符 atomic / nonatomic

1. atomic : 原子性. 为setter方法加锁.线程安全,但需要消耗大量的资源. 属性默认为原子性atomic.
2. nonatomic : 非原子性. 不为setter方法加锁.线程不安全.适合.资源占用低.
3. 在多线程中原子操作是必须的.之所以这么做就是为了保证在写未完成的时候被另一个线程读取.造成数据错误.经典案例: 火车票的预定和购买. 加入atomic属性修饰之后,setter方法就会加锁.

{lock}
   if (property != newValue) {
        [property release];
        property = [newValue retain];
    }
{unlock}

4. nonatomic直接访问内存的地址,不关心其他线程是否改变整个值,并且没有死锁现保护.只需要从内存中访问到当前内存地址中能用到的数据即可.
5. 不要误以为多线程加了atomic就是安全的. atomic只有在setter和getter的时候是原子操作.其他方面就不是atomic能管理的了. 想要安全就需要其他线程安全的操作了,比如加锁.

三. 读写型修饰符

1. readonly: 表明这个属性只能读,不能写.系统只为我们生成一个getter方法下划线开头的成员变量.不会创建setter方法.
   当希望外界能读取我们这个属性，但是不希望被外界改变的时候就用readonly。
2. readwrite: 表明这个属性是可读可写的. 系统为我们这个属性生成了setter和getter方法.
3. 系统默认为readwrite.
4. 一般我们封装的方法只允许外界read不允许写. 在.h文件里用readonly修饰，在.m文件里面用readwrite修饰。这样就可以外部只读,内部读写.

// .h文件
#import <UIKit/UIKit.h>

@interface SecondViewController : UIViewController

@property (nonatomic, strong, readonly) NSString * str;

@end

// .m文件
#import "SecondViewController.h"

@interface SecondViewController ()

@property (nonatomic, strong, readwrite) NSString * str;

@end

四. 预备知识

内存的栈区 : 由编译器自动分配释放, 存放函数的参数值, 局部变量的值等.

内存的堆区 : 一般由程序员分配释放, 若程序员不释放, 程序结束时可能由OS回收.

五. copy

1. copy 和 mutableCopy
   如果想要创建一个对象,该对象与源的内容一致,那么可以用拷贝(copy或mutableCopy).
   copy拷贝出来的对象类型总是不可变类型(例如, NSString, NSDictionary, NSArray等等)
   mutableCopy拷贝出来的对象类型总是可变类型(例如, NSMutableString, NSMutableDictionary, NSMutableArray等等)

NSString *string = @"Jerry";
[string copy] --> 拷贝出内容为Jerry的NSString类型的字符串
[string mutableCopy] --> 拷贝出内容为Jerry的>NSMutableString类型的字符串

NSDictionary *dict = @{@"name" : @"Jerry"};
[dict copy] --> 拷贝出内容与dict相同的NSDictionary类型的字典
[dict mutableCopy] --> 拷贝出内容与dict相同的>NSMutableDictionary类型的字典

NSArray *array = @[@"Jerry"];
[array copy] --> 拷贝出内容与array相同的NSArray类型的数组
[array mutableCopy] --> 拷贝出内容与array相同的>NSMutableArray类型的数组

copy和mutableCopy

2. block为什么用copy.
   block是一个对象,所以block在创建的时候内存是默认在stack(栈)上的. 而不是在heap(堆)上的.所以他的作用域仅限创建时候的当前上下文(函数,方法等),当在作用域外调用block就会崩溃. Copy可以将block从内存栈区移动到堆区.这样在作用域外也不会崩溃了. 但在ARC下, 使用copy与strong其实都一样, 因为block的retain就是用copy来实现的.block还是建议使用copy修饰.因为MRC下就是就是用copy修饰的.
3. copy相对于直接赋值的好处.
   先来看这个两个的区别.

   NSArray * array;
   NSMutableArray * arrayM = [NSMutableArray array];
   [arrayM addObject:@"A"];
   array = arrayM;
   [arrayM addObject:@"B"];
   
   NSLog(@"array = %@, arrayM = %@",array,arrayM);

  // 结果
 array = (
   "A",
   "B"
 ), arrayM = (
   "A",
   "B"
 )

明明可变数组添加对象是在赋值之后, 为什么后面添加对象还会影响到不可变数组呢?
因为Objective-C支持多态.所以表面上array是NSArray对象,但是其骨子里还是NSMutableArray对象.
这样的话将会对后期DEBUG增加很大的成本, 可能会导致莫名其妙的错误.

   NSArray * array;
   NSMutableArray * arrayM = [NSMutableArray array];
   [arrayM addObject:@"A"];
   array = [arrayM copy];     // 此处有不同
   [arrayM addObject:@"B"];
   
   NSLog(@"array = %@, arrayM = %@",array,arrayM);
   
// 结果
array = (
   "A"
), arrayM = (
   "A",
   "B"
)

这样就能保证不管赋值的是可变还是不可变数组, NSArray就是NSArray了!

所以@property中NSString,NSArray,NSDictionary属性用copy而不是strong了.

如果能够在你的工程中正确使用copy, 将会对你的程序有不小的帮助.细节决定成败.

4. 深拷贝和浅拷贝
   深拷贝(内容拷贝): 直接拷贝整个对象内容到另一块内存中.
   浅拷贝(指针拷贝): 并不拷贝对象本身，仅仅是拷贝指向对象的指针,指向该内存地址.拷贝出来的对象与源对象的地址一致!这意味着修改拷贝对象的值会直接影响到源对象.

如果在多层数组中，对第一层进行内容拷贝，其它层进行指针拷贝，这种情况是属于深复制，还是浅复制？对此，苹果官网文档有这样一句话描述:This kind of copy is only capable of producing a one-level-deep copy. If you only need a one-level-deep copy... If you need a true deep copy, such as when you have an array of arrays...

从文中可以看出，苹果认为这种复制不是真正的深复制，而是将其称为单层深复制(one-level-deep copy)。因此，有人对浅复制、完全深复制、单层深复制做了概念区分。当然，这些都是概念性的东西，没有必要纠结于此。只要知道进行拷贝操作时，被拷贝的是指针还是内容即可。

5. 自定义复制

先自定义一个MyPerson的类.初始化并进行copy或者mutableCopy会出现如图问题.找不到copyWithZone或者mutableCopyWithZone方法.

自定义类的copy.png

其实当程序调用对象的copy方法来复制自身时，底层需要调用copyWithZone:方法来完成实际的复制工作，copy返回实际上就是copyWithZone:方法的返回值；mutableCopy与mutableCopyWithZone:方法也是同样的道理。
那么怎么做才能让自定义的对象进行copy与mutableCopy呢？需要做以下事情:
1.让类实现NSCopying/NSMutableCopying协议。

遵守NSCoding协议.png

2.让类实现copyWithZone:/mutableCopyWithZone:方法

实现copyWithZero.png

该段参考:
小结iOS中的copy
iOS之对象复制

六. assign

1. assign是赋值属性.引用计数不加1.
2. 一般用来修饰基础数据类型(NSInteger,CGFloat等)和C数据类型(int,float,double)等.
3. assign是指针赋值，不对引用计数操作，使用之后如果没有置为nil，可能就会产生野指针.指向对象地址但计数不+1，但当地址引用计数为0时，assign不会对地址进行数据的抹除操作，只是进行值释放。这就导致野指针存在，即当这块地址还没写上其他值前，能输出正常值，但一旦重新写上数据，该指针随时可能没有值，造成奔溃。

七. weak

1. 引用计数不加1.
2. 当使用weak修饰的属性，当对象释放的时候，系统会对属性赋值nil,objective-c有个特性就是对nil对象发送消息也就是调用方法。weak特性要求不保留传入的对象。如果该对象被释放，那么相应的实例变量会被自动赋为nil。这么做可以避免产生悬空指针。悬空指针指向的是不再存在的对象。向悬空指针发送消息通常会导致程序崩溃。相应的存方法会将传入的对象直接赋给实例变量。

3. weak只能修饰对象类型.
   weak只能修饰对象类型
4. 用weak修饰代理属性和用来解决循环强引用.

八.retain

1. retain用在MRC情况下，被retain修饰的对象，引用计数retainCount要加1的。
2. retain只能修饰oc对象，不能修饰非oc对象，比如说CoreFoundation对象就是C语言框架，它没有引用计数，也不能用retain进行修饰。
3. retain一般用来修饰非NSString 的NSObject类和其子类。

九. strong

1. 表示对对象的强引用.
2. strong和weak默认用strong
3. retainCount + 1
4. 对两个对象之间互相强引用造成循环引用,内存泄露.