是什么?
    对象初始化时,运行的方法!
有两个方法：
        +alloc : （类方法）给对象分配空间的方法        -init：（对象方法）初始化对象的方法，<真正的构造方法>
有什么用？
    在对象初始化的适合,就给属性赋值!
    (如:当需要创建此类很多对象时,可以避免多行代码
       Person *per1 = [Person new];
       per1.age =10;
       per1.name =@"huh";
       ...
   //构造方法只要一行代码 
   Person *per1 = [[Person alloc]init]
    )
    场景1：在对象创建的一瞬间，就给对象赋值!
    场景2:   在创建对象的时候,我想要动态的给对象赋值!
    场景3:   让子类能够给自己的属性,初始化的时候能够赋值!
怎么用?
    重写构造方法-(id) init
    自定义构造方法-(id)initXXX
    自定义子类的构造方法 -(id)initXXXX
    Person *per3 = [[Person alloc] init];
用的时候注意什么?
    1.NSObject的init方法必须调用
    2.在没有特殊要求的情况下,子类和父类的赋值都应该在各自的类里面,各司其职,
       这样才能隔离父类的变化!

1. //  Person.h
   
2. #import <Foundation/Foundation.h>
   
3. @interface Person : NSObject
   
4. //子类重写父类,声明不声明都可以
   
5. //-(id)init;
   
6. @property int age;
   
7. @end
   
8. //
   
9. //  Person.m
   
10. //
    
11. #import "Person.h"
    
12. @implementation Person
    
13. /*
    
14. 场景1：在对象创建的一瞬间，就给对象赋值!（对象创建的时候，必须调用init方法）
    
15. 子类重写父类的init方法，(init是真正的构造方法),
    
16. 在init方法里面，给属性赋值，就能实现初始化时,就给属性赋值的需求！
    
17. -(id)init{
    
18. _age = 10; //这还不够！
    
19. }
    
20. 父类的init方法里面有很多的操作，我不知道！(如：我并不知道父类的init,是如何进行实力化得)
    
21. 因为子类重写父类的方法后，就不会在执行父类里面的操作，只会执行子类的方法了！
    
22. 可我想要的是，执行父类里面的操作 -- 创建对象！创建对象的同时，给属性赋值？
    
23. 【super init】 调用父类的init方法，self = 【super init】 用本身对象去接收！
    
24. 
    
25. 严谨:
    
26.     如果初始化失败,该怎么办?初始化失败会返回nil,就不需要对属性赋值! nil ==0;
    
27.     if (self != nil) {}
    
28. 
    
29. 注意:重写父类的方法,不需要声明也可以!
    
30. */
    
31. -(id)init{
    
32.     if (self = [super init]) {//原理,非0则为真!
    
33.          _age =13;
    
34.     }
    
35.    
    
36.     return self;
    
37. }
    
38. @end
    
39. //
    
40. //  Cat.h
    
41. //
    
42. #import <Foundation/Foundation.h>
    
43. @interface Cat : NSObject
    
44. @property NSString *name;
    
45. @property int age;
    
46. -(id)initCat:(NSString*) name Age:(int)age;
    
47. @end
    
48. //
    
49. //  Cat.m
    
50. //
    
51. /*
    
52. 场景2:在创建对象的时候,我想要动态的给对象赋值!
    
53.     直接对重写父类的-(id)init方法,进行传参 ----不对,因为父类并没有带参数init方法!
    
54.     自定义带参数的init方法里面调用父类的init方法!
    
55. 
    
56. 注意:方法一定要声明,因为调用的是自己的方法,而不是父类的方法!
    
57. */
    
58. #import "Cat.h"
    
59. @implementation Cat
    
60. -(id)initCat:(NSString*) name Age:(int)age{
    
61.     if(self = [super init]){
    
62.         _age = age;
    
63.         _name = name;
    
64.     }
    
65.    
    
66.     return self;
    
67. }
    
68. @end
    
69. //
    
70. //  BSCat.h
    
71. //
    
72. #import <Foundation/Foundation.h>
    
73. #import "Cat.h"
    
74. @interface BSCat : Cat
    
75. @property NSString *color;//颜色
    
76. -(id)initBSCat:(NSString *)name Age:(int)age Color:(NSString *)color;
    
77. @end
    
78. //
    
79. //  BSCat.m
    
80. //
    
81. #import "BSCat.h"
    
82. @implementation BSCat
    
83. /*
    
84. 场景3:让子类能够给自己的属性,初始化的时候就赋值!且继承父类的属性也能够动态赋值?
    
85. 分析:   首先它是个自定义的动态初始化
    
86.         -(id)initBSCat:(NSString *)name Age:(int)age Color:(NSString *)color
    
87.         可是,因为父类给属性,定义的是@property
    
88.         (@property自动生成的属性的默认是@private权限,只能在本类使用,不能在子类使用)
    
89.         所以,两种解决方案
    
90.           1) 手动更改父类的get和set方法!(缺陷,可扩展性差.如:父类要改个名字,子类也要跟着改)
    
91.              调用NSObject 的init方法
    
92.              if(self=[super init]){
    
93.              _name = name;//_name2 = name;
    
94.              _age =age;
    
95.              _color = color;
    
96.              }
    
97.           2) 调用父类Cat的initCat方法!(父类的修改,对子类没有影响.)
    
98. 
    
99. */
    
100. -(id)initBSCat:(NSString *)name Age:(int)age Color:(NSString *)color{
     
101.    
     
102.     if(self =[super initCat:name Age:age]){//调用父类的方法
     
103.         _color = color;//添加自己的操作
     
104.         
     
105.     }
     
106.     return self;
     
107. }
     
108. @end
     
109. /*
     
110.     main.m
     
111.     构造方法
     
112.     是一个对象在初始化的时候执行的方法.
     
113.     init才是真的构造方法
     
114.     构造方法的操作有两种:
     
115.     1.重写.
     
116.     优点:实现简单. 不足:不能够根据不同对象赋不同的值,属性的值是固定的.
     
117.     2.自定义构造
     
118.     优点:使用灵活,可以根据不同的对象给属性设定不同的值. 不足:写法比较麻烦一些.
     
119.     3.子类继承父类自定义构造的写法.
     
120.     在子类里自定义构造时,要调用父类的自定义构造,而不是NSObject的init.这样才能隔离父类的变化.
     
121.     而且,父类的属性可以保持私有化private.
     
122. */
     
123. #import <Foundation/Foundation.h>
     
124. #import "Person.h"
     
125. #import "Cat.h"
     
126. #import "BSCat.h"
     
127. int main(int argc, const char * argv[]) {
     
128.     /*
     
129.      new 方法其实是封装了两个方法
     
130.      +alloc：给对象分配一块内存（类方法）
     
131.      -init：初始化这个对象（对象方法）
     
132.      */
     
133. //    Person *per = [Person new];
     
134.    
     
135. //    可以不初始化对象，直接赋值，但是不推荐，有时会出不可预知的错误
     
136. //    Person *per1 = [Person alloc];
     
137. //    per1.age =10;
     
138. //    NSLog(@"age1 =%d",per1.age);
     
139.    
     
140. //    标准方式
     
141. //    Person *per3 = [[Person alloc] init];
     
142. //    Person *per1 = [Person alloc];
     
143. //    Person *per2 = [per1 init];
     
144. //    per2.age =20;
     
145. //    NSLog(@"age2 =%d",per2.age);
     
146. //    简洁方式
     
147.     Person *per3 = [[Person alloc] init];
     
148.     per3.age =30;
     
149.     NSLog(@"age3 =%d",per3.age);
     
150. //    场景1：在对象创建的一瞬间，就给对象赋值!（对象创建的时候，必须调用init方法）
     
151.     Person *per4 = [[Person alloc]init];
     
152.     NSLog(@"age4 = %d",per4.age);
     
153.    
     
154.    
     
155. //    场景2:   在创建对象的时候,我想要动态的给对象赋值!
     
156.     Cat *ct = [[Cat alloc]initCat:@"boshimao" Age:3];
     
157.     NSLog(@"name = %@ ,age = %d",ct.name,ct.age);
     
158.    
     
159.    
     
160. //    场景3:让子类能够给自己的属性,初始化的时候就赋值!且继承父类的属性也能够动态赋值?
     
161. //    以下两个输出的结果是一样得,因为在BSCat实现里面,调用的就是父类的init方法!
     
162. //    Cat *ca =[[BSCat alloc] initBSCat:@"boSiMao" Age:2 Color:@"hua"];
     
163. //    NSLog(@"name=%@ ,age =%d, color%@",ca.name,ca.age,((BSCat *)ca).color);
     
164.    
     
165.     BSCat *bs =[[BSCat alloc] initBSCat:@"boSiMao" Age:2 Color:@"hua"];
     
166.     NSLog(@"name = %@ ,age =%d, color = %@",bs.name,bs.age,bs.color);
     
167.         return 0;
     
168. }

复制代码

学习了!

总结的很不错