适合有java基础的同学迅速了解OC，个人喜好用代码来记笔记，看起来直观形象；

1. #import <Foundation/Foundation.h>
   
2. typedef enum{
   
3.         SexMal='m',SexFem='f'
   
4. } Sex;
   
5. 
   
6. @interface Score :NSObject
   
7. {
   
8.         @public
   
9.         double mathScore,engScore,cScore;
   
10. }
    
11. @end
    
12. @implementation Score
    
13. @end
    
14. 
    
15. @interface Person :NSObject
    
16. {
    
17.         //成员变量非public，而是提供get set方法访问，体现封装特性
    
18.         int _age;//命名规范，一般成员变量名以_开头
    
19.         double _weight;
    
20.         char* _name;
    
21.         Sex _sex;
    
22. }
    
23. - (void)setAge:(int)age;//get set方法的规范写法
    
24. - (int)age;
    
25. - (void)setWeight:(double)weight;
    
26. - (double)weight;
    
27. - (void)setName:(char*)name;
    
28. - (char*)name;
    
29. - (void)setSex:(Sex)sex;
    
30. - (Sex)sex;
    
31. 
    
32. 
    
33. - (void)eat;
    
34. - (void)exercise;
    
35. + (void) testSuper;
    
36. + (void) testSuper2;
    
37. @end
    
38. 
    
39. @implementation Person
    
40. - (void)setAge:(int)age{_age=age;}
    
41. - (int)age{return _age;}
    
42. - (void)setWeight:(double)weight{_weight=weight;}
    
43. - (double)weight{return _weight;}
    
44. - (void)setName:(char*)name{_name=name;}
    
45. - (char*)name{return _name;}
    
46. - (void)setSex:(Sex)sex{_sex=sex;}
    
47. - (Sex)sex{return _sex;}
    
48. 
    
49. - (void)eat
    
50. {_weight++;}
    
51. - (void) exercise
    
52. {_weight--;}
    
53. 
    
54. + (void) testSuper
    
55. {//%@为输出OC对象
    
56.         NSLog(@"Person super=%d,self=%d,super class=%@,self class=%@",super,self,[super class],[self class]);
    
57.         [self testSuper2];
    
58. }
    
59. + (void)testSuper2
    
60. {
    
61.         NSLog(@"Person testSuper2");
    
62. }
    
63. @end  
    
64. 
    
65. 
    
66. @interface Student :Person
    
67. {
    
68.         @public
    
69.         int _studentNo;
    
70.         Score* _score;//利用组合来降低耦合性
    
71. }
    
72. @end;
    
73. @implementation Student
    
74. - (void)eat
    
75. {
    
76.         [super eat];
    
77.         NSLog(@"Student eat...weight=%.2f",[self weight]);
    
78. }
    
79. - (void)exercise
    
80. {
    
81.         [super exercise];
    
82.         NSLog(@"Student exercise...weight=%.2f",[self weight]);
    
83. }
    
84. + (void) testSuper//方法重写(override)
    
85. {
    
86.         NSLog(@"Student super=%d,self=%d,super class=%@,self class=%@",super,self,[super class],[self class]);
    
87.         //利用super调用Person类中的方法与利用Person直接调用并非完全一样
    
88.         //用Person调用后，Person中testSuper方法中self指向Person类对象
    
89.         //而利用super调用后，Person中testSuper方法中self指向Student类对象       
    
90.         [super testSuper];
    
91.         [Person testSuper];
    
92. }
    
93. + (void)testSuper2
    
94. {
    
95.         NSLog(@"Student testSuper2");
    
96. }
    
97. @end;
    
98. 
    
99. 
    
100. @interface PrimaryStudent:Student
     
101. @end
     
102. @implementation PrimaryStudent
     
103. + (void)testSuper2
     
104. {
     
105.         NSLog(@"PrimaryStudent testSuper2");
     
106. }
     
107. @end
     
108. 
     
109. 
     
110. @interface Staff:Person
     
111. {
     
112.         @public
     
113.         int _staffNo;
     
114. }
     
115. 
     
116. @end
     
117. @implementation Staff
     
118. - (void)eat
     
119. {
     
120.         [super eat];
     
121.         NSLog(@"Staff eat...weight=%.2f",[self weight]);
     
122. }
     
123. - (void)exercise
     
124. {
     
125.         [super exercise];
     
126.         NSLog(@"Staff exercise...weight=%.2f",[self weight]);
     
127. }
     
128. @end
     
129. 
     
130. 
     
131. //利用OC多态特性，Person*可接收任意其子类对象
     
132. void eatSomething(Person* p)
     
133. {
     
134.         [p eat];
     
135. }
     
136. void doExercise(Person *p)
     
137. {
     
138.         [p exercise];
     
139. }
     
140. 
     
141. int main(int argc, const char * argv[])  
     
142. {        
     
143.     Student * p=[Student new];[p setWeight:50];
     
144.      Person * p2=[Staff new];[p2 setWeight:60];
     
145.     eatSomething(p);
     
146.     doExercise(p2);
     
147. 
     
148.   
     
149.    
     
150.    
     
151.     //测试super
     
152.      [Person testSuper];
     
153.      [Student testSuper];
     
154.          [PrimaryStudent testSuper];
     
155.    
     
156.      return 0;  
     
157. }
     
158. 
     
159. 
     
160. /*
     
161. OC面向对象语法：
     
162. 1>封装：
     
163.         成员变量命名以_开始，非public，提供get set方法，
     
164.         例 {int _age;}    -setAge:(int)age;   -(int)age;
     
165. 2>继承：
     
166.         NSObject与NSProxy为OC中两大root class，大部分类都继承NSObject，
     
167.         NSObject类中声明了一个Class类型的指针变量isa，该指针指向该对象对应的类对象；
     
168.         每个类对象中都有一个superClass指针变量，指向其父类的类对象，
     
169.         该指针变量声明在Class类中，所有类加载进内存后都是一个类对象，类对象是Class类的实例；
     
170.         子类继承父类，则拥有父类所有成员变量及方法，包括类方法与对象方法；
     
171.         子类成员变量名不允许与父类重名（java成员变量可重名），但是方法名可以重复（重写）;
     
172.         OC调用方法时，会从子类到父类的层级顺序查找(通过类对象中的superClass指针变量查找父类方法)；
     
173.         父类声明的方法可以子类中实现;
     
174.        
     
175.         继承缺点：
     
176.         类与类之间关系太紧密导致代码耦合性太强；
     
177.                   有些场合可利用组合降低耦合性
     
178.                                 *继承表示子类是父类
     
179.                                 *组合表示A类拥有B类
     
180.                                
     
181.         super关键字：
     
182.         (super本质上与 self不同，self是类的隐藏的参数变量,指向当前调用方法的对象（类也是对象，类对象）,
     
183.         另一个隐藏参数是_cmd，代表当前类方法的selector，
     
184.     而super并不是隐藏的参数,它只是一个"编译器指示符"）
     
185.         调用方法时，使用[super methodName]可以调用父类的方法，对象方法则调用父类
     
186.         对象方法，类方法中则调用父类的类方法，无法调用成员变量(java中super可以调用父类成员变量)
     
187.    
     
188.         OC普通方法调用通过消息机制发送，调用
     
189.         id objc_msgSend(id theReceiver, SEL theSelector, ...)方法，
     
190.         receiver为调用该方法的对象或类对象指针，与self一样，SEL为方法选择器，...为动态方法参数，
     
191.         该方法实现伪代码大致为
     
192.         id objc_msgSend(id theReceiver, SEL theSelector, ...)
     
193.         {
     
194.                 if theReceiver 是Class对象
     
195.                 {
     
196.                         根据theSelector在theReceiver中从当前类到父类顺序查找类方法;
     
197.                        
     
198.                 }else if theReceiver是对象
     
199.                 {
     
200.                         根据theSelector在theReceiver->isa中从当前类到父类顺序查找对象方法;
     
201.                        
     
202.                 }
     
203.                 找到后调用该方法，将theReceiver传给隐藏形参self
     
204.                 return theReceiver;
     
205.         }
     
206.        
     
207.         而当编译器遇到通过[super XXX]方式调用的方法则调用
     
208.         id objc_msgSendSuper(struct objc_super *super, SEL op, ...)方法，
     
209.         super的结构为 struct objc_super {
     
210.                             id receiver;
     
211.                            Class superClass;
     
212.                         };
     
213.         这里superClass即类对象中的superClass指针变量，
     
214.         receiver为当前方法中的self ,类方法指向类对象，对象方法则指向对象;
     
215.         该方法实现的伪代码大致是
     
216.         id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
     
217.         {
     
218.                 通过SEL在super->superClass中查找到需要调用的方法的selector，
     
219.                 然后调用上面那个消息发送的方法
     
220.                 注：selector为方法的选择器，子类重写父类方法，他们的selector是不一样的；
     
221.                 return objc_msgSendSuper(super->receiver, selector, ...);
     
222.                
     
223.         }
     
224.         因此在每个有用到super的方法中，都会生成一个struct objc_super,
     
225.         通过[super XXX]调用的方法中的self等于生成super的方法中的self;
     
226. 
     
227. 多态：
     
228.         父类指针可以接收任意子类对象实例
     
229.         使用场景：函数参数设置为父类指针，可接收任意子类对象
     
230. */
     

复制代码

有几个疑问就是，老师说的OC中子类成员变量不允许与父类中的重名，而我这里测试重名没问题，不加public的成员变量也可以直接访问，
不过应该是我用window写的
，编译器不完善还是什么原因吧；
有发生同样问题的么？

好牛逼的样子！