标签：
------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -----
第一讲 类的继承和派生概念
本小节知识点：
1、【理解】什么是继承？
2、【掌握】类的继承和派生概念
1、什么是继承？
2、OC中的继承与派生
1 #import <Foundation/Foundation.h>
2
3 @interface Animal : NSObject
4 {
5 @public
6 //动物得年龄
7 int _age;
8
9 }
10 -(void)eat:(NSString *)foodName;
11 -(void)run;
12 @end
13
14 #import "Animal.h"
15
16 @implementation Animal
17 -(void)eat:(NSString *)foodName{
18 NSLog(@"正在吃:%@",foodName);
19 }
20 -(void)run{
21 NSLog(@"动物正在跑");
22 }
23 @end
24
25 #import <Foundation/Foundation.h>
26 #import "Animal.h"
27 //狗这个类要继承动物类
28
29 //如何继承
30 //1）导入要继承得那个类得头文件
31 //2）@interface Dog :父类名
32 // Animal
33 @interface Dog : Animal
34 -(void)lookHome;
35 @end
36
37 #import "Dog.h"
38
39 @implementation Dog
40 -(void)lookHome{
41 NSLog(@"狗已经进入警戒状态!");
42 }
43 @end
44
45 #import "Animal.h"
46
47 @interface Cat : Animal
48 {
49 }
50 -(void)catchMouse;
51 @end
52
53 #import "Cat.h"
54
55 @implementation Cat
56 -(void)catchMouse{
57 NSLog(@"猫正在抓老鼠!");
58 }
59 @end
60
61 #import "Dog.h"
62
63 @interface JunDog : Dog
64 {
66 }
67 -(void)zhaDiaoBao;
68 @end
69
70 #import "JunDog.h"
71
72 @implementation JunDog
73 -(void)zhaDiaoBao{
74
75 NSLog(@"军犬叼起炸药包迅速得跑了");
76 }
77 @end
78
79 #import "Dog.h"
80
81 @interface BigYellowDog : Dog
82 -(void)catchMouse;
83 @end
84
85 #import "BigYellowDog.h"
86
87 @implementation BigYellowDog
88 -(void)catchMouse{
89
90 NSLog(@"狗拿耗子，多管闲事!");
91 }
92 @end
93
94 #import <Foundation/Foundation.h>
95 #import "Animal.h"
96 #import "Dog.h"
97 #import "BigYellowDog.h"
98 int main(int argc, const char * argv[])
99 {
100
101 @autoreleasepool {
//
104 Animal *ani = [Animal new];
105
106 ani->_age = 1;
107 [ani eat:@"??"];
108 [ani run];
109
110 Dog *d1 = [Dog new];
111 d1->_age = 3;
112 [d1 eat:@"一坨新鲜得。。。!!!"];
113 [d1 run];
114 [d1 lookHome];
115
116 //BigYellowDog本身没有吃和跑得行为，
117 //但是BigYellowDog父类Dog有吃和跑得行为
118 //所以，BigYellowDog 也就有类，因为继承过来的
119 BigYellowDog *BYD = [BigYellowDog new];
120 [BYD eat:@"同伴得一坨新鲜得。。。!!!"];
121 [BYD run];
122 [BYD catchMouse];
123 }
124 return 0;
125 }
第二讲 基类和派生类之间的关系
本小节知识点：
1、【理解】基类和派生类之间的关系
2、【理解】方法的重写
1、基类和派生类之间的关系
派生类不但拥有基类的属性和方法，同时还可以自己创建自己的属性和方法。
派生类方法属性 = 基类方法属性 + 派生类自己新增的方法和属性
注意：
1）基类的私有属性能被继承，不能被使用。
2）OC中的继承是单继承：也就是说一个类只能一个父类，不能继承多个父类
3）继承的合理性：
引用《大话西游》里的一句话来描述继承的。“人是人他妈生的，妖是妖他妈生的”
2、方法的重写
方法的重写，从父类继承的方法，可能这个方法并不适合子类，可以在子类中重写父类的方法。
1 #import <Foundation/Foundation.h>
2
3 @interface Animal : NSObject
4 {
5
6 }
7 -(void)eat;
8 -(void)bark;
9 @end
10
11 #import "Animal.h"
12
13 @implementation Animal
14 -(void)eat{
15 NSLog(@"动物会吃");
16 }
17 -(void)bark{
18 NSLog(@"动物会叫");
19 }
20 @end
21
22 #import "Animal.h"
23
24 @interface Dog : Animal
25 {
26
27 }
28 -(void)eat;
29 -(void)bark;
30 @end
31
32 #import "Dog.h"
33
34 @implementation Dog
35 //把父类的方法，在子类中重新给实现了
36 //这种做法就称之为：方法的重写
37 -(void)eat{
38 NSLog(@"狗会吃");
39 }
40 -(void)bark{
41 NSLog(@"狗会叫");
42 }
43 @end
44
45 #import <Foundation/Foundation.h>
46 #import "Animal.h"
47 #import "Dog.h"
48 int main(int argc, const char * argv[])
49 {
50
51 @autoreleasepool {
52 //先查找当前类有没有eat和bark，
53 //如果有，先调用自己的，
54 //如果没有，查看父类有没有bark方法
55 //如果父类还没有，去父父类
56 // 如果有，就执行
57 Dog *d = [Dog new];
58 [d eat];
59 [d bark];
60
61 //ani 调用它自己的吃和叫的方法
62 Animal *ani = [Animal new];
63 [ani eat];
64 [ani bark];
65 }
66 return 0;
67
68 }
第三讲 继承的注意事项
本小节知识点：
1、【理解】继承的注意事项
2、【理解】继承体系中方法调用的顺序
1、继承的注意事项
1）子类不能定义和父类同名的变量，但是可以继承父类的变量
2）OC类支持单一继承，不支持多继承
3）OC类支持多层继承
Animal-->Dog--->junDog
2、继承体系中方法调用的顺序
第四讲 实例变量修饰符介绍
【理解】实例变量的作用域
1、实例变量的作用域
public 任意程序集
访问修饰符
protected 同一类和派生类
private 同一类
（1）@public（公开的）在有对象的前提下，任何地方都可以直接访问。
前提没有其他作用域，从写@public定义开始，一直到结束。
（2）@protected（受保护的）只能在当前类和子类的对象方法中访问。
（3） @private（私有的）只能在当前类的对象方法中才能直接访问
（4）@package（框架级别的）作用域介于私有和公开之间，只要处于同一个框架中就可以直接通过变量名访问
第五讲 实例变量修饰符对子类的影响
本小节知识点：
1、【掌握】变量修饰符在子类中的访问
2、【了解】实例变量作用域使用注意事项
1、变量的修饰符在子类中访问
1）@private私有成员是不能被继承，也不能被外部函数访问。
2） @public 共有成员能被继承，也能被外部方法访问。
3） @protected 保护成员能够被继承，不能够被外部函数访问。
2、实例变量作用域使用注意事项
（1）在@interface @end 之间声明的成员变量如果不做特别的说明，那么其默认是protected的。
(2）一个类继承了另一个类，那么就拥有了父类的所有的成员变量和方法，注意所有的成员变量它都拥有，只是有的它不能直接访问。
1 #import <Foundation/Foundation.h>
2
3 @interface Animal : NSObject
4 {
5 @public
6 int _age;
7
8 @private
9 int _tuiNum;
10
11 @protected
12 float _weight;
13 }
14
15 @end
16
17 #import "Animal.h"
18
19 @implementation Animal
20
21 @end
22
23 #import "Animal.h"
24
25 @interface Dog : Animal
26 {
27
28 }
29 -(void)run;
30 @end
31
32 #import "Dog.h"
33
34 @implementation Dog
35 -(void)run{
36 //@public 类型的变量，在子类中可以正常的访问和使用
37 //@protected类型的变量，在子类中使用,不能在其它类中使用
38 //@private类型的变量
39
40 //面试题:
41 //@private类型的变量，能否被子类继承？
42 //子类可以继承父类的所有的实例变量和方法
43 //但是，不是所有的都可以访问
44
45 //@private类型的变量，能否被子类访问？
46 //不能访问
47
48 NSLog(@"public _age : %d",_age);
49
50 _weight += 10;
51 NSLog(@"protect _weight = %.2f",_weight);
52
53 // NSLog(@"private _tuiNum : %d",_tuiNum);
54 //此处是能继承过来，但不能访问
55
56 }
57 @end
58
59 #import <Foundation/Foundation.h>
60 #import "Animal.h"
61 #import "Dog.h"
62 int main(int argc, const char * argv[])
63 {
64
65 @autoreleasepool {
66
67 Dog *d = [Dog new];
68 d->_age = 1;
69 [d run];
70
71 }
72 return 0;
73 }
第六讲 OC中的私有变量
【掌握】OC中的私有变量
1、OC中的私有变量
（1）在类的实现 即.m文件中 也可以声明成员变量，但是因为在其他文件中通常都只是包含头文件而不会包含实现文件，所以在.m文件中声明的成员变量是@private的。 在.m中定义的成员变量不能和它的头文件.h中的成员变量同名，在这期间使用@public等关键字也是徒劳的。
1 #import <Foundation/Foundation.h>
2
3 @interface Person : NSObject
4 {
5 int _age; //默认的是protect类型，能在当前类和子类中使用
6
7 @private
8 NSString *_name; //_name 不能在子类中使用，但是可以被子类继承
9
10 }
11 -(void)run;
12 -(void)eat;
13 @end
14
15 #import "Person.h"
16
17 //在.m中定义实例变量
18 //纯私有的变量，改变量只能在当前类中使用，不能被子类继承，也不能被访问
19
20 int m = 100;
21 @implementation Person
22 -(void)run{
23
24 NSLog(@"人在走,速度是%d!",m);
25 }
26 -(void)eat{
27 NSLog(@"eat m = %d",m);
28 }
29 @end
30
31 #import "Person.h"
32
33 @interface Student : Person
34
35 @end
36
37 #import "Student.h"
38 //int m = 10;
39 @implementation Student
40 -(void)run{
41
42 //Person类的实现类.m文件中定义的变量，此处不能使用
43 // NSLog(@"人在走,速度是%d!",m);
44 }
45 @end
46
47 #import <Foundation/Foundation.h>
48 #import "Person.h"
49 int main(int argc, const char * argv[])
50 {
51
52 @autoreleasepool {
53
54 Person *p = [[Person alloc] init];
55
56 [p run];
57 [p eat];
58
59 }
60 return 0;
61 }
第七讲 oc中的私有方法
【掌握】OC中的私有方法
1、OC中的私有方法
在.h 中没有声明
在 .m中实现，此时该方法被称为私有方法
1 #import <Foundation/Foundation.h>
2
3 @interface Person : NSObject
4 {}
5 -(void)run;
6
7 @end
8
9 #import "Person.h"
10
11 @implementation Person
12 -(void)run{
13 NSLog(@"人在走");
14
15 Person *p1 = [Person new];
16 [p1 test];
17
18 //可以访问私有方法
19 [self test];
20 }
21
22 //test方法，没有在.h文件中声明，在.m中实现了
23 //不能被子类继承和访问
24
25
26 -(void)test{
27
28 NSLog(@"test!");
29 }
30 @end
31
32 #import "Person.h"
33
34 @interface Student : Person
35
36 @end
37
38 #import "Student.h"
39
40 @implementation Student
41
42 @end
43
44 #import <Foundation/Foundation.h>
45 #import "Student.h"
46 #import "Person.h"
47 int main(int argc, const char * argv[])
48 {
49
50 @autoreleasepool {
51
52 //创建一个stu对象
53 Student *stu = [Student new];
54
55 [stu run];
56
57 // [stu test]; //没有声明
58 Person *p = [Person new];
59 [p run];
60
61 // [p test];
62 }
63 return 0;
64 }
65
66 #import <Foundation/Foundation.h>
67
68 //.h文件可以看作是对外的一个接口
69 @interface Animal : NSObject
70 {
71
72 }
73 -(void)run;
74 @end
75
76 #import "Animal.h"
77
78 @implementation Animal
79 -(void)run{
80
81 NSLog(@"动物正在跑");
82
83 //调用eat
84 [self eat];
85 }
86
87 //私有方法（相对私有）
88 //不能被子类继承
89 -(void)eat{
90
91 NSLog(@"动物正在吃");
92 }
93 @end
94
95 #import "Animal.h"
96
97 @interface Dog : Animal
98
99 @end
100
101 #import "Dog.h"
102
103 @implementation Dog
104
105
106 -(void)test{
107 //私有方法不能被子类继承
108 // [self eat];
109 }
110 @end
111
112
113
114 //创建一个Animal对象
115 Animal *ani = [Animal new];
116 [ani run];
117
118 //eat 没有在.h中声明
119 // [ani eat];
120
121 Dog *d = [Dog new];
122 [d run];
123 [d eat ];
第八讲 description方法介绍及重写
本小节知识点：
1、【掌握】description方法概述
2、【掌握】description重写的方法
3、【了解】description陷阱
1、description方法概述
2、description重写的方法
//对象的description方法
-(NSString *)description{
return [NSString stringWithFormat:@"", ];
}
//类的description方法
+(NSString *)description{
return @"+开头的方法";
}
3、description陷阱
千万不要在description方法中同时使用%@和self，下面的写法是错误的：
-(NSString *)description{
return [NSString stringWithFormat:@"%@",self];
}
同时使用了%@和self，代表要调用self的description方法，因此最终会导致程序陷入死循环，循环调用description方法。
1 #import <Foundation/Foundation.h>
2
3 @interface Dog : NSObject
4 {
5 int _age;
6
7 @public
8 int _color;
9 }
10 -(void)run;
11 -(void)setAge:(int)age;
12 -(int)age;
13 @end
14
15 #import "Dog.h"
16
17 @implementation Dog
18 -(void)run{
19
20 NSLog(@"狗在跑");
21 }
22 -(void)setAge:(int)age{
23
24 _age = age;
25 }
26 -(int)age{
27 return _age;
28 }
29 //重写父类的description
30 -(NSString *)description{
31 // NSString *str = [NSString stringWithFormat:@"年龄:%d,颜色:%d",_age,_color ];
32 return [NSString stringWithFormat:@"年龄:%d,颜色:%d",_age,_color ];
33 }
34 +(NSString *)description{
35 //类方法中不能访问实例变量，所以下面的写法是错误的
36 // return [NSString stringWithFormat:@"年龄:%d,颜色:%d",_age,_color ];
37
38 return @"这是类方法";
39 }
40 @end
41
42 #import <Foundation/Foundation.h>
43 #import "Dog.h"
44 int main(int argc, const char * argv[])
45 {
46
47 @autoreleasepool {
48
49 Dog *d = [Dog new];
50 [d setAge:3];
51 d->_color = 1;
52 [d run];
53
54 //查看对象的地址
55 NSLog(@"d = %p",d);
56
57 //查看对象实例变量的值
58 NSLog(@"%d",[d age]);
59
60 //NSString *str = @"abc";
61 //NSLog(@"%@",str);
62 //<Dog: 0x100202ed0>
63 // 类名 对象的地址
64 NSLog(@"\n %@",d);//打印d的对象
65 //当我们以%@的格式，打印了对象d，此时调用了对象的descripiton方法
66 //对象中如果没有重写父类的description方法，则调用父类的
67
68 //需求：
69 //当我们以%@格式打印对象的时候，输出对象的所有属性信息
70 //在方法中重写description方法
71 //对象的description方法
72 //-(NSString *)description{
73 // return [NSString stringWithFormat: ];}
74 //类的description方法
75 // +(NSString *)description{
76 // return @"+开头的方法";}
77
78 //打印类的信息
79 //打印类
80 // [d class]; --->Dog
81 //以%@的形式，打印类信息
82 NSLog(@"%@",[d class]);
83
84 }
85 return 0;
86 }
标签：
原文地址：http://www.cnblogs.com/xiaokang520/p/5062342.html
