OC：属性的内部实现原理、dealloc内释放实例变量、便利构造器方法的实现原理、collection的内存管理

代码：

//
//  main.m
#import <Foundation/Foundation.h>
#import "Person.h"
#import "SingleDog.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //改为工程为 非ARC 就是 MRC机制
        Person * per = [[Person alloc]initWithName:@"lee" age:];
        NSString * name = [[NSString alloc]initWithFormat:@"Li"];//为对象改名字
        [per setName:name];
        [per setName:name];//问题（多赋值了一次） B
        [name release];//对应创建时候的 alloc 进行一次释放 E
        NSLog(@"%@",[per name]);//这里出现野指针 A
        NSString * na  = @"Zhang";
        [per setName:na];//C
    }

/**/
    //自动释放池 用来存声明为 autorelease 的对象
    //当自动释放池销毁时，会往池中的每一个对象（调用 autorelease 方法 的对象）（先进后出）发送一个 release 消息
    @autoreleasepool {
        Person * pp = [[Person alloc]init];
        Person * pp2 = [[Person alloc]init];
        Person * pp3 = [[Person alloc]init];
//        [p autorelease];
        @autoreleasepool {
            //栈 （ LIFO 后进先出 ）
            //队列 先进先出（ FIFO ）
            //自动释放池以 栈（ LIFO ） 的方式来管理池中的对象
            [pp retain];
            [pp2 retain];
            [pp3 retain];
            [pp autorelease];//对象调用 autorelease 方法,当自动释放池销毁的时候，引用计数器减1
            [pp2 autorelease];
            [pp3 autorelease];
        }
        NSLog(@"内部释放池销毁");
    }
        NSLog(@"外部释放池销毁");

/*
        @autoreleasepool {
            //面试题
//            for (long  i = 0; i < 1000000000; i++) {
//                Person * pp = [[Person alloc]init];
//                [pp autorelease];
//            }
            //解决内存不足问题办法
            for (long i = 0; i <10000000000000; i++) {
                @autoreleasepool {
                     Person * pp = [[Person alloc]init];
                    [pp retain];
                    [pp autorelease];
                }
            }
       }
*/

    //copy
    // copy 有深拷贝 和 浅拷贝 之分
    //浅拷贝 只拷贝地址
    //深拷贝 拷贝内容 新创建出一个对象
    @autoreleasepool {
        //
        Person * one = [[Person alloc]initWithName:@"first" age:];
        Person * two = [one copy];//直接 copy 一份
        //如果是同一个地址就是 浅拷贝 如果不是同一个地址就是 深拷贝
        NSLog(@"one %p",one);
        NSLog(@"two %p",two);
        NSLog(@"%lu  %lu",one.retainCount,two.retainCount);
    }

    //容器 （collection）的内存管理
    //1.当集合中添加对象元素时，集合会对每一个元素做一次 retain 的操作，使其引用计数加 1
    //2.当集合中移除某个元素的时候，集合会对其做一次 release 操作，使其引用计数器减 1
    //3.当容器对象销毁的时候，会向容器内部的每一个元素的发送一个release 消息，使其引用计数器减 1
    NSMutableArray * arr = [[NSMutableArray alloc]initWithCapacity:];
    Person * p1 = [[Person alloc]init];
    Person * p2 = [[Person alloc]init];
    Person * p3 = [[Person alloc]init];
    [arr addObject:p1];
    [arr addObject:p2];
    [arr addObject:p3];
    for (Person * per in arr) {
        NSLog(@"----%lu",per.retainCount);
    }
    [arr removeObject:p1];//这里我们移除一个对象 p1
    NSLog(@"--%lu",p1.retainCount);
    [arr removeAllObjects];//这里把所有的都释放掉
    for (Person * per in arr) {
        NSLog(@"--000--%lu",per.retainCount);
    }
    [arr release];//
    p3 = nil;
    NSLog(@"%lu",p3.retainCount);

    //便利构造器的内部内存管理
    Person * person = [Person personWithName:@"wang" age:];
    person.name = @"Hei";

    return ;
}

main.m

//
//  Person.h

#import <Foundation/Foundation.h>
#import "SingleDog.h"

@interface Person : NSObject<NSCopying>
//{
////    NSString * name; //只有在alloc 后才是一个对象，现在还是一个指针，是在栈区 D
//}
//属性的作用 自动生成setter getter
//copy只用于那些遵循 NSCopying协议的 ，retain 让计数器加1，  引用计数一定是对象，一定是在堆区
// assign 因为他不是对象，所以不用内存管理
@property (nonatomic,retain)NSString * name;
@property (nonatomic,assign)NSInteger age;
@property (nonatomic,retain) SingleDog * dog;
- (id)initWithName:(NSString *)name
               age:(NSInteger)age;
- (void)test;
//便利构造器（的内存处理）
+ (Person *)personWithName:(NSString *)name
                       age:(NSInteger)age;
@end

person.h

//
//  Person.m

#import "Person.h"

@implementation Person

-(id)copyWithZone:(NSZone *)zone{
    Person * per = [[Person allocWithZone:zone]init];//深拷贝copy
    per.name = self.name;
    per.age = self.age;
    per.dog = self.dog;
    return per;
}
@synthesize dog = _dog;//要自己写setter getter
-(void)setDog:(SingleDog *)dog{
    if (_dog != dog) {
        [_dog release];
        _dog = [dog retain];//以上是内存处理
    }
    //这里可以设置自己设置的属性
}

@synthesize name = _name;//这是我们要重新写setter getter的方法的时候，要用到，如果不需要重新写的话，就不用写这个方法
-(void)setNAme:(NSString *)name{
//    _name = name ;
//    [_name release];
    if (_name != name) {//（这里是新对象） 判断是不是新的对象 B
        [_name release];//。D （如果第一次初始化的时候，_name）如果还没有 E（原有的对象还没有释放） 保持对新的对象的所有权 C
        //对一个字符串 多次release 不会 crash 因为他不在堆区 初次初始化的时候 name = nil,在栈区
        _name  = [name retain];//（让新对象引用计数器加1）(retain 保留所有权)解决野指针问题 A  该处的 retain 需要下面dealloc  // retain 只是引用了对象的地址   copy 是拷贝对象（这里需要在学习） 如果对象的语义是 copy 这里就要写成_name  = [name copy];
    }
//    _name  = [name retain];//(retain 保留所有权)解决野指针问题 A
}
-(NSString *)name{
    return [_name retain];
//    return [_name copy];如果数据类型 为copy
//    _age = age; 基本的数据类型 直接的赋值操作 语义为 assign
}

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

- (id)initWithName:(NSString *)name
               age:(NSInteger)age{
    self = [super init];//这里为什么这样写
    if (self) {
//        _name = name;  没有走 setter 方法
//        _age = age;
        self.name = name;
        self.age = age;
    }
    return self;
}
//对象在销毁的时候会自动调用该方法（注意我们不能用对象直接去调用该方法）
-(void)dealloc{//一般对应于 语义属性为 retain copy 的，  注意：——》assign 的不会调用该方法（是直接的赋值 取值）
    //在 MRC 下才要写这些方法 如果在 ARC 下就打不出来这些方法。  在dealloc 中需要对该类中语义属性为 retain copy 的属性生成的实例变量进行 release 操作
//    [_name release];//与下面的作用是一样的（解决对象没有及时释放掉的）（这个方法建议不用）
    self.name = nil;//在release 的时候 又把 指针置为 nil 防止出现野指针 好处是 内部调用了setter 方法 在 setter 方法内部进行了实例变量的 release 一次操作，同时将对象指向 nil
    self.dog = nil;//处理狗的对象 所有的对象（有alloc retain的对象）在这里都要被销毁
    [super dealloc ];//调用父类的方法将对象的空间真正回收
}

//便利构造器（的内存处理）
+(Person * )personWithName:(NSString *)name
                       age:(NSInteger)age{
    Person * per = [[Person alloc]initWithName:name age:age];
//    [per release]; return per; //就相当于反回了一个野指针
//    return  per; [per release];//return 后面的代码不会执行
    return [per autorelease];//既可以避免野指针，同时还可以避免内存泄露。。系统的内部的便利构造器的内存处理也是一样的
}
@end

person.m

//
//  Student.h

#import "Person.h"

@interface Student : Person
@property (nonatomic,readwrite,assign)NSInteger stuNum;
@property(nonatomic,readwrite,copy)NSString * school;
@property(nonatomic,readwrite,copy)NSString *address;

//初始化
-(id)initWithName:(NSString *)name
                age:(NSInteger)age
//                dog:(SingleDog*)dog
             stunum:(NSInteger)stunum
             school:(NSString *)school
            address:(NSString *)address;
- (void)dealloc;
+(Student *)studentWithName:(NSString *)name
                       age:(NSInteger)age
                    stunum:(NSInteger)stunum
                    school:(NSString *)school
                    address:(NSString *)address;
@end

student.h

//
//  Student.m

#import "Student.h"

@implementation Student

-(id)initWithName:(NSString *)name
                age:(NSInteger)age
//                dog:(SingleDog*)dog
             stunum:(NSInteger)stunum
             school:(NSString *)school
            address:(NSString *)address{
    self = [super init];//一般进行初始化设置
    if (self) {
        self.name = name;
        self.age =age;
        self.stuNum = stunum;
        self.school = school;
        self.address = address;
    }
    return self;
}
- (void)dealloc{
    self.name = nil;
    self.school = nil;
    self.address = nil;
    [super dealloc];
}

+(Student *)studentWithName:(NSString *)name
                        age:(NSInteger)age
                     stunum:(NSInteger)stunum
                     school:(NSString *)school
                    address:(NSString *)address{
    Student * stu = [[Student alloc]initWithName:name age:age stunum:stunum school:school address:address];
    return stu;
}
@end

student.m

//
//  SingleDog.h

#import <Foundation/Foundation.h>

@interface SingleDog : NSObject

@end

singleDog.h

//
//  SingleDog.m

#import "SingleDog.h"

@implementation SingleDog

@end

singleDog.h

---

---

//
//  main.m
//  Practice

#import <Foundation/Foundation.h>
#import "Man.h"
#import "Woman.h"
#import "Family.h"
#import "Child.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // OC比较综合的一个练习 (本工程手动为  MRC)
        Man * husband = [[Man alloc]initWithName:@"Lee" gender:@"man" age:];
        Woman * wife = [[Woman alloc]init];
        wife.age = ;
        wife.gender = @"woman";
        husband.wife = wife;//为丈夫设置一个媳妇
        Family * family = [[Family alloc]init];
        [family sayHi:husband];
        [family sayHi:wife];
        //多态，对一个方法传进去不同的值，反馈的结果不一样 对同一个方法的响应 回复的方法不一样
        Child * ch = [[Child alloc]init];
        /*
        ch.delegate = husband;
        ch.delegate = wife;
        [husband release];// 孩子代理的语义属性问题 assign （避免代理的循环引用问题）
        */
        //设置代理人
        ch.delegate = husband;
        [ch toGo];
        ch.delegate = wife;//这里把上面的代理 husband 覆盖了
        [ch toGo];
        //一般一个类里设置一个代理
    }
    return ;
}

mian.m

//
//  Person.h
//  Practice

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property(nonatomic,retain)NSString *name;
@property(nonatomic,retain)NSString *gender;
@property(nonatomic,assign)NSInteger age;

- (id)initWithName:(NSString *)name
            gender:(NSString *)gender
               age:(NSInteger)age;

- (void)dealloc;
@end
------------------------------------------------

person.h

//
//  Person.m
//  Practice

#import "Person.h"

@implementation Person

- (id)initWithName:(NSString *)name
            gender:(NSString *)gender
               age:(NSInteger)age{
    self = [super init];
    if (self) {
        self.name = name;
        self.age = age;
        self.gender = gender;
    }
    return self;
}

- (void)dealloc{
    self.name = nil;
    self.gender = nil;
    [super dealloc];
}
@end

person.m

//
//  Family.h
//  Practice

#import <Foundation/Foundation.h>
#import "Person.h"
@class Man;
@class Woman;
@class Child;

@interface Family : NSObject

- (void)sayHi:(Person * )per;//自我介绍方法
@end

family.h

//
//  Family.m
//  Practice

#import "Family.h"
#import "Man.h"
#import "Woman.h"
#import "Child.h"

@implementation Family

- (void)sayHi:(Person * )per{
    NSLog(@"my name is %@  age is %ld gender is %@",per.name,per.age,per.gender);
}//自我介绍方法
@end

family.m

//
//  Man.h
//  Practice
//
//
#import "Person.h"
@class Woman;
//@class Child;
#import "Child.h"

@interface Man : Person<TakecareDelegate>//3代理人遵循协议
//son wife
@property(nonatomic,retain)Child *son;
@property(nonatomic,retain)Woman *wife;
#pragma --------delegate-----

- (void)playWithScore;
#pragma --内存释放--
- (void)dealloc;
@end

man.h

//
//  Man.m
//  Practice

#import "Man.h"
#import "Woman.h"
#import "Child.h"

@implementation Man

@synthesize wife = _wife, son = _son;

//setter getter
- (void)setWife:(Woman *)wife{
    if (_wife != wife) {
        [_wife release];
        _wife = [wife retain];
      // _wife = [_wife retain];//这是出错的方法，相当于_wife自己没有任何操作
    }
    _wife.name = @"Anni";//在这里做一些额外的操作
    NSLog(@"my wife is %@",_wife.name);
}
- (Woman *)wife{
    return [[_wife retain]autorelease];
}

- (void)setSon:(Child *)son{
    if (_son != son) {
        [_son release];
        _son = [son retain];
    }
}
- (Child *)son{
    return [[_son retain]autorelease];
}

#pragma -----delegate----

- (void)playWithScore{
     NSLog(@"踢足球");
}
#pragma ----内存释放-----
- (void)dealloc{
    self.wife = nil;
    self.son = nil;
    [super dealloc];
}
@end

man.m

//
//  Woman.h
//  Practice

#import "Person.h"
@class Man;
//@class Child;
#import "Child.h"

@interface Woman : Person<TakecareDelegate>//3代理人遵循协议
//husband child
@property(nonatomic,retain)Man *husband;
@property(nonatomic,retain)Child *son;
#pragma -------delegate-----
- (void)getMeToSchool;
#pragma ---内存释放-----
-(void)dealloc;
@end

woman.h

//
//  Woman.m
//  Practice

#import "Woman.h"
#import "Man.h"
#import "Child.h"

@implementation Woman
#pragma ----delegate----
- (void)getMeToSchool{
    NSLog(@"上学去");
}
#pragma ---内存释放----
-(void)dealloc{
    self.son = nil;
    self.husband = nil;
    [super self];
}
@end

woman.m

//
//  Child.h

#import "Person.h"
@class Man;
@class Woman;

//协议 (1)制定协议
@protocol TakecareDelegate <NSObject>

- (void)getMeToSchool;
- (void)playWithScore;

@end

@interface Child : Person
//father mother
@property(nonatomic,retain)Man *father;
@property(nonatomic,retain)Woman *mother;
//协议 (2) 设置代理人  设置代理的语义属性 assign  主要是避免循环引用问题 （*****如果设置为 retain 在对应的 dealloc 方法里面）
@property(nonatomic,assign)id<TakecareDelegate>delegate;

- (void)toGo;

#pragma ---内存管理----
- (void)dealloc;
@end

child.h

//
//  Child.m
//  Practice

#import "Child.h"
#import "Man.h"
#import "Woman.h"

@implementation Child

//通知代理去执行协议方法
- (void)toGo{
    //下面是代理是父亲或者母亲单方（两个协议都执行了）
//    if (_delegate) {
//        [_delegate getMeToSchool];
//        [_delegate playWithScore];
//    }

    //下面是一个代理响应了某个方法，该代理就会去执行相对应的方法 （父母都为代理，分别执行一个协议）
    //了解  respondsToSelector 方法（返回的是一个bool 数值） （看API 文档）
    if (_delegate && [_delegate respondsToSelector:@selector(getMeToSchool)]) {//判断如果实现了 @selector(某方法) 下面就执行 某方法
        [_delegate getMeToSchool];
    }
    if (_delegate && [_delegate respondsToSelector:@selector(playWithScore)]) {
        [_delegate playWithScore];
    }
}
#pragma -----内存管理------
- (void)dealloc{
    self.mother = nil;
    self.father = nil;
    [super dealloc];
}
@end

child.m

Objective-C概述

Objective-C简称OC, 扩充自C语言的面向对象编程语言。是OS X 和IOS操作系统的主要编程语言。一种面向对象的计算机语言。开发环境和类库叫“NEXTSTEP”，1996年，把NEXTSTEP/OPENSTEP用于Mac OS操作系统开发。它的版本和开发环境叫Cocoa，使用Objective - C作为基础语言，开发环境Xcode和interface Builder.

OC语言的特点：

C语言的超集，允许在OC中使用C语言源代码，编译器兼容C语言程序。

具备完善的面向对象特性。

包含一个运行时系统。

类库丰富。

面向对象编程：

	面向过程	面向对象
特点	分析解决问题的步骤，实现函数，依次调用函数	分析某问题需要参与的对象，各对象的作用，多个对象协作完成任务
侧重点	实现功能	对象的设计
语言举例	C语言	OC、C++、Java等

基本介绍：面向对象编程 OOP（Object Oriented Programming ）

                 面向对象语言 ： C++、 Java、 C#

                 概念： 对象、类、封装、继承、多态等等

面向对象3大特征：封装、继承、多态。

封装的思想：”麻烦自己，方便别人”。

两种编程思想：

面向对象设计具有良好的可扩展性、可重用性。

类和对象

类：具有相同特征和行为的事物的抽象。

对象：对象就是类的实例，类的具体表现。生活中的万物都是对象。

类和对象是面向对象的核心。对象是类的实例。类是对象的类型。

面向对象编程中使用对象完成程序。

开发中：先定义类，再创建对象，然后使用对象。

OC中类的定义

定义类包含两部分：接口部分和实现部分。

        接口部分：对外声明类的特征和行为。（类似说明书）

        实现部分：对内实现行为。（内部的具体实现）

接口部分标志：@interface...@end

作用：声明类的实例变量和方法，即特征和行为。

包含内容：类名、父类名、实例变量、方法等。

实现部分标志：@implementation...@end

作用：实现方法，即实现类的行为。

类和文件

类：@interface...@end      @implementation…@end

文件：.h称为接口文件或头文件， .m称为实现文件。

文件和类本质没有关系。

创建对象

类是模板，对象是具体表现，任何对象都要占用内存空间。

创建对象分两步：分配内存空间和初始化。

分配内存空间：根据类中声明的实例变量为对象分配内存，将所有实例变量置为默认值0，并返回首地址。

初始化：为对象的实例变量设置初始值，

+（id）alloc；+表示这个方法属于类，只能类执行。id返回值类型，表示任意类型的对象，即创建好的对象。

-（id）init；-表示这个方法属于对象，只能对象执行。id返回值类型，表示初始化完成的对象。

使用对象 

指针存储对象的首地址，代指对象。OC中使用指针代指对象，进行操作。

实例变量操作

实例变量在初始化只做少量设置，后期还需要进行设置。

实例变量区分可见度，共三种。 默认的可见度是@protected

         @public    （公有）    实例变量可在类的外部和内部操作

         @protected:(受保护)   实例变量只能在该类和其子类内操作

         @private:（私有的）  实例变量只能在该类内访问

public修饰的实例变量，可以直接使用“->”访问。

面向对象和面向过程是两种不同的编程思想，思考角度不同，前者以对象为中心，后者以事件为中心。

类是对象的抽象，对象是类的体现。面向对象编程中，先创建出对应的类，再由类生成对象，进而完成我们的开发。

 

方法

OC中的方法分两种：类方法(只能类使用) 和 实例方法(只能对象使用)

OC中方法采用消息发送机制：【receiver message】 给对象发送消息

setter 、getter

OC中，为实例变量赋值的方法称为setter（设置器）。读取实例变量值的方法称为getter（访问器）。

设置器用来为实例变量赋值，访问器用来取实例变量的值。

属性：@property (nonatomic,retain) NSString *name;

         @property (nonatomic,retain) NSString *gender;

         @property (nonatomic,assign) NSInteger age;

相当于设置器与访问器，系统自动生成，直接调用即可，默认生成的实例变量可见度为私有。（retain assign copy）为语义属性，声明对象时使用retain copy，声明基本数据类型时用assign。 

自定义初始化方法

- (id)init 这个方法只能给实例变量设置默认值，不灵活。

- (id)initWithName:自定义初始化方法，根据需求定义初始化方法。

#import 导入头文件，

#import””导入自定义类。#import<>导入；导入类库中的头文件。

@class 告诉编译器@class后的字符串作为类名使用，并未导入类的接口内容，有效避免嵌套循环导入。

继承

继承的作用：既能保证类的完整，而且简化代码

继承的特点：1.一个子类只能有一个父类；

                   2.继承是单向的（只允许单继承）；

                   3.一个父类可有多个子类；

                   4.继承具有传递性；

                   5.继承时会继承父类所有的特征和行为。

继承的内容：所有实例变量和方法。

没有父类的类称为根类，OC中的根类是NSObject.

super 

编译器指令，并非对象。作用是：给super发消息，可以执行父类中实现的方法。

初始化方法

创建对象分两步：开辟空间、初始化。

初始化方法的主要作用是：为某些实例变量赋初值

初始化方法在对象的整个生命周期里只使用一次。

完整的初始化方法：- （id）init

                            {

     做安全处理  //    self = [super init];  //执行父类中实现的init方法

                                 if(self){

                                //初始化设置   

                                  }

                                  return self;

                             }

便利构造器 ： 封装了对象创建过程

Block的使用：

Block允许嵌套定义，定义时最后加； 返回值可以省略。如：

int(^sum)(int x, int y) = ^(int x, int y){

      return x + y;

}；

挡在Block内部使用外部定义的局部变量时，如果变量没有被Block修饰，则在Block内部不能对它进行修改。若想修改，变量必须要有__block修饰。__block告诉编译器编译时在Block内部不要把外部变量当做常量使用，还是当做变量使用。如果在Block中访问全局变量，就不需要block修饰。

NSString

NSArray

NSDictionary

NSSet

NSNumber

NSDate

类的扩展

分类，类目，category为没有源代码的类添加方法（只添加方法，不添加实例变量）是扩展一个类的的功能的方式之一，为原有类扩展的方法会成为原类的一部分，使用即可。分类也分为.h（接口部分）以及.m（实现部分）。.h文件中填写声明的方法，.m文件中填写方法的实现。

协议

协议相当于任务清单，规定所要做的操作，谁服从协议，谁就要实现清单中的方法，所以协议只有.h文件，没有.m文件。协议要让类服从，服从完协议之后，要实现协议的方法。

内存管理

OC中采用引用计数机制管理内存。

内存管理的基本原则：如果你对一个对象进行alloc retain copy 之后，你就拥有了该对象的所有权，就必须对它进行release或者autorelease。

autorelease： 会将声明为autorelease的对象放到离他最近的自动释放池中，当自动释放池销毁时，会向池中的每一个对象发送一个release消息。

release：立即释放

当一个类的的对象引用计数为0时，系统会自动调用该类的dealloc方法来回收空间，该方法是由系统自动调用的，不用手动调用。

当把一个对象放入一个集合中（数组、字典、集合）时，会将对象的引用计数加1，因为内部做了retain操作，当collection（数组 集合 字典）空间被回收时，它们会向容器的每一个元素都发送一个release消息（对应添加元素时的retain操作）。当从collection中移除一个元素时，会release该对象，引用计数减1.

 

NSString *name; 它是在栈区的，并不是在堆区，现在的 name 是一个指针，因此在内存处理的时候，不要处理它，