第三讲.继承,完整初始化方法,遍历构造器,多态(代码) 另附植物大战僵尸练习

      //初始化和遍历构造器使用  //person.h文件 1 #import <Foundation/Foundation.h>
 2
 3 @interface Person : NSObject
 4
 5 {
 6
 7     NSString *_name;
 8     int _age;
 9     NSString *_sex;
10
11
12 }
13
14 +(id)PersonWithName:(NSString*)name age:(int)age;
15 -(id)initWithName:(NSString*)name age:(int)age;
16
17 -(void)setName:(NSString*)name;
18 -(NSString*)name;
19
20 -(void)setAge:(int)age;
21 -(int)age;
22
23 -(void)setSex:(NSString*)sex;
24 -(NSString *)sex;
25
26
27 +(id)PersonWithName:(NSString *)name;
28 -(id)initWithName:(NSString*)name;
29
30 @end

 //person.m文件 1 #import "Person.h"
 2
 3 @implementation Person
 4
 5 +(id)PersonWithName:(NSString*)name age:(int)age
 6 {
 7     Person *p = [[Person alloc] initWithName:(NSString*)name age:age];
 8     return p;
 9
10 }
11 //完整的初始化方法
12
13 -(id)initWithName:(NSString*)name age:(int)age
14 {
15     self = [super init];
16     if (self) {
17         _name = name;
18         _age = age;
19     }
20
21     return self;
22
23 }
24
25 +(id)PersonWithName:(NSString *)name
26 {
27
28     Person *p2 = [[Person alloc] initWithName:name];
29     return p2;
30
31
32 }
33
34
35 -(id)initWithName:(NSString*)name
36 {
37     self  = [super init];
38     if (self) {
39         _name = name;
40     }
41
42
43     return  self;
44
45
46 }
47
48
49
50
51
52 -(void)setName:(NSString*)name
53 {
54
55     _name = name;
56
57 }
58 -(NSString*)name
59 {
60
61     return _name;
62 }
63
64 -(void)setAge:(int)age
65 {
66     _age = age;
67
68
69 }
70 -(int)age
71 {
72
73     return _age;
74 }
75
76 -(void)setSex:(NSString*)sex
77 {
78
79     _sex = sex;
80
81 }
82 -(NSString *)sex
83 {
84     return _sex;
85
86
87 }
88
89
90
91 @end

  //main.m文件 1 #import <Foundation/Foundation.h>
 2
 3 #import "Person.h"
 4
 5 int main(int argc, const char * argv[]) {
 6     @autoreleasepool {
 7
 8         //注意在使用遍历构造器时,要和初始化方法结合到一起才能使用
 9         //类方法只有类才可以调用
10         Person *p1 = [Person PersonWithName:@"小明" age:12];
11         NSLog(@"%@ %d",[p1 name],[p1 age]);
12
13         //注意在使用遍历构造器时,要和初始化方法结合到一起才能使用
14         Person *p2 = [Person PersonWithName:@"小辉"];
15         NSLog(@"%@ ",[p2 name]);
16
17
18
19
20
21     }
22     return 0;
23 }

oc中植物大战僵尸练习(用继承的方法写)

Zombie.h(普通僵尸)

 1 #import <Foundation/Foundation.h>
 2
 3 @interface Zombie : NSObject
 4
 5 {
 6     NSString *_type;   //僵尸种类
 7     NSInteger _blood;  //总血量
 8     NSInteger _restBlood; //剩余血量
 9     NSInteger _lostBlood;  //失血量
10     BOOL _isDeath;  //是否死亡
11
12
13
14 }
15
16
17 //初始化方法(总血量)
18 -(id)initWithType:(NSString*)type
19             blood:(NSInteger)blood
20         restBlood:(NSInteger)restBlood
21         lostBlood:(NSInteger)lostBlood
22           isDeath:(BOOL)isDeath;
23
24 //遍历构造器
25 +(id)zombleWithType:(NSString*)type
26                     blood:(NSInteger)blood
27                 lostBlood:(NSInteger)loatBlood;
28
29
30
31 //赋值
32 -(void)setIsdeath:(BOOL)isDeath;
33
34 //取值
35 -(NSString*)type;
36 -(NSInteger)blood;
37 -(NSInteger)lostBlood;
38 -(BOOL)isDeath;
39
40 //被打失血
41 -(void)attack;
42
43 //死亡
44 -(void)dead;
45
46
47
48
49 @end

//Zombie.m(普通僵尸) 1 #import "Zombie.h"
 2
 3 @implementation Zombie
 4 //初始化
 5 -(id)initWithType:(NSString*)type
 6             blood:(NSInteger)blood
 7         restBlood:(NSInteger)restBlood
 8         lostBlood:(NSInteger)lostBlood
 9           isDeath:(BOOL)isDeath
10 {
11
12     if(self = [super init])
13     {
14        _type = type;
15        _blood = blood;
16        _restBlood = restBlood;
17        _lostBlood = lostBlood;
18        _isDeath = isDeath;
19
20     }
21     return self;
22
23 }
24
25 //遍历构造器
26 +(id)zombleWithType:(NSString*)type
27                     blood:(NSInteger)blood
28                 lostBlood:(NSInteger)lostBlood
29 {
30
31     return [[Zombie alloc] initWithType:type blood:blood restBlood:blood lostBlood:lostBlood isDeath:NO];
32
33  }
34
35
36 -(void)setIsdeath:(BOOL)isDeath
37 {
38
39         _isDeath = isDeath;
40 }
41
42
43             //取值
44 -(NSString*)type
45 {
46  return _type;
47
48 }
49 -(NSInteger)blood
50 {
51     return _blood;
52
53 }
54  -(NSInteger)lostBlood
55 {
56
57    return _lostBlood;
58 }
59  -(BOOL)isDeath
60 {
61    return _isDeath;
62
63 }
64
65
66
67
68 //被打击失血
69 -(void)attack
70 {
71   if(_restBlood <=_lostBlood){
72    _isDeath = YES;
73     [self dead];
74
75   }  else {
76     NSLog(@"普通僵尸每次失去血量:%ld",_lostBlood);
77       _restBlood -= _lostBlood;
78       NSLog(@"普通僵尸剩余血量:%ld",_restBlood);
79
80     }
81 }
82
83  //死亡
84 -(void)dead
85 {
86    NSLog(@"....普通僵尸已死亡!!!");
87
88 }
89
90
91
92 @end

ArmorZombie.文件(路障僵尸)

 1 #import <Foundation/Foundation.h>
 2
 3 #import "Zombie.h"
 4
 5 @interface ArmorZombie : Zombie
 6
 7 {
 8
 9     NSString* _armorType; //防具类型
10     BOOL _isArmorDrop;  //防具是否掉落
11
12
13 }
14
15 //初始化
16 -(id)initWithType:(NSString*)type
17             blood:(NSInteger)blood
18         lostBlood:(NSInteger)lostBlood
19           isDeath:(BOOL)isDeath
20         armorType:(NSString*)armorType;
21
22
23 //遍历构造器
24 +(id)armorZombieType:(NSString*)type
25                     blood:(NSInteger)blood
26                 lostBlood:(NSInteger)lostBlood
27                 armorType:(NSString*)armorType;
28
29
30 //赋值
31 -(void)setlostBlood:(NSInteger)lostBlood;
32
33 //取值
34 -(NSString*)type;
35 -(NSInteger)blood;
36 -(NSInteger)lostBlood;
37 -(NSString*)armorType;
38 -(BOOL)isArmorDrop;
39
40 //被打失血
41 -(void)attack;
42
43 //防具被打烂
44 -(void)armorBreak;
45
46 //死亡
47 -(void)dead;
48
49
50 @end

ArmorZombie.m 文件(路障僵尸)

  1 #import "ArmorZombie.h"
  2
  3 @implementation ArmorZombie
  4 //初始化
  5 -(id)initWithType:(NSString*)type
  6             blood:(NSInteger)blood
  7         lostBlood:(NSInteger)lostBlood
  8           isDeath:(BOOL)isDeath
  9         armorType:(NSString*)armorType
 10 {
 11     self = [super initWithType:type blood:blood restBlood:blood lostBlood:lostBlood isDeath:NO];
 12
 13     if(self){
 14
 15         _armorType = armorType;
 16         _isArmorDrop = NO;
 17
 18     }
 19     return self;
 20
 21 }
 22
 23
 24 //遍历构造器
 25 +(id)armorZombieType:(NSString*)type
 26                        blood:(NSInteger)blood
 27                    lostBlood:(NSInteger)lostBlood
 28                    armorType:(NSString*)armorType;
 29 {
 30     return [[ArmorZombie alloc]initWithType:type blood:blood restBlood:blood lostBlood:lostBlood isDeath:NO];
 31
 32
 33
 34 }
 35
 36
 37 //赋值
 38 -(void)setlostBlood:(NSInteger)lostBlood
 39 {
 40     _lostBlood = lostBlood;
 41
 42 }
 43
 44 //取值
 45 -(NSString*)type
 46 {
 47     return _type;
 48 }
 49 -(NSInteger)blood
 50 {
 51     return  _blood;
 52
 53 }
 54 -(NSInteger)lostBlood
 55 {
 56     return _lostBlood;
 57
 58 }
 59 -(NSString*)armorType
 60 {
 61     return _armorType;
 62
 63 }
 64 -(BOOL)isArmorDrop
 65 {
 66  return _isArmorDrop;
 67
 68 }
 69
 70 //被打失血
 71 -(void)attack
 72 {
 73     static int flag = 1;
 74     if (_restBlood <= _blood/2&&1==flag) {
 75         _isArmorDrop = YES;
 76         [self armorBreak];
 77         [self setlostBlood:3];
 78         flag = 0;
 79     }
 80     if (_restBlood <= _lostBlood) {
 81          _isDeath = YES;
 82           [self dead];
 83     }else {
 84         NSLog(@"路障僵尸每次失血量:%ld",_lostBlood);
 85         _restBlood -= _lostBlood;
 86         NSLog(@"路障僵尸剩余血量:%ld",_restBlood);
 87
 88     }
 89 }
 90
 91 //防具被打烂
 92 -(void)armorBreak
 93 {
 94     NSLog(@"路障掉落.....");
 95
 96 }
 97
 98 //死亡
 99 -(void)dead
100 {
101     NSLog(@".....路障僵尸已死亡!!!");
102
103
104 }
105
106
107
108
109
110
111
112 @end

IronZombie.h文件(路障僵尸)

 1 #import <Foundation/Foundation.h>
 2
 3
 4 #import "ArmorZombie.h"
 5
 6 @interface IronZombie : ArmorZombie
 7
 8 {
 9
10     NSString*_weakness; //弱点
11
12
13
14
15 }
16
17 //初始化
18 -(id)initWithType:(NSString*)type
19             blood:(NSInteger)blood
20         lostBlood:(NSInteger)lostBlood
21           isDeath:(BOOL)isDeath
22         armorType:(NSString*)armorType
23          weakness:(NSString*)weakness;
24
25
26 //遍历构造器
27 +(id)ironZombieType:(NSString*)type
28                blood:(NSInteger)blood
29            lostBlood:(NSInteger)lostBlood
30            armorType:(NSString*)armorType
31            weakness:(NSString*)weakness;
32
33
34
35
36 //取值
37 -(NSString*)type;
38 -(NSInteger)blood;
39 -(NSInteger)lostBlood;
40 -(NSString*)armorType;
41 -(NSString*)weakness;
42
43 //被打失血
44 -(void)attack;
45
46 //防具被打烂
47 -(void)armorBreak;
48
49 //防具被磁铁吸走
50 -(void)absorb;
51
52 //死亡
53 -(void)dead;
54
55 @end

IronZombie.m文件(路障僵尸)

 1 #import <Foundation/Foundation.h>
 2
 3
 4 #import "ArmorZombie.h"
 5
 6 @interface IronZombie : ArmorZombie
 7
 8 {
 9
10     NSString*_weakness; //弱点
11
12
13
14
15 }
16
17 //初始化
18 -(id)initWithType:(NSString*)type
19             blood:(NSInteger)blood
20         lostBlood:(NSInteger)lostBlood
21           isDeath:(BOOL)isDeath
22         armorType:(NSString*)armorType
23          weakness:(NSString*)weakness;
24
25
26 //遍历构造器
27 +(id)ironZombieType:(NSString*)type
28                blood:(NSInteger)blood
29            lostBlood:(NSInteger)lostBlood
30            armorType:(NSString*)armorType
31            weakness:(NSString*)weakness;
32
33
34
35
36 //取值
37 -(NSString*)type;
38 -(NSInteger)blood;
39 -(NSInteger)lostBlood;
40 -(NSString*)armorType;
41 -(NSString*)weakness;
42
43 //被打失血
44 -(void)attack;
45
46 //防具被打烂
47 -(void)armorBreak;
48
49 //防具被磁铁吸走
50 -(void)absorb;
51
52 //死亡
53 -(void)dead;
54
55
56
57 @end

main.m文件(调用)

 1 #import <Foundation/Foundation.h>
 2
 3 #import "Zombie.h"
 4
 5 #import "ArmorZombie.h"
 6
 7 #import "IronZombie.h"
 8
 9
10 int main(int argc, const char * argv[]) {
11     @autoreleasepool {
12
13       Zombie *ptjs = [Zombie zombleWithType:@"普通僵尸" blood:50 lostBlood:3];
14         int i=0;
15         while (![ptjs isDeath])
16         {
17             if(![ptjs isDeath])
18             {
19                 [ptjs attack]; //攻击普通僵尸
20             }
21             i++;
22
23         }
24
25         NSLog(@"--------------------------------");
26
27
28         ArmorZombie *lzjs = [ArmorZombie armorZombieType:@"防具僵尸" blood:80 lostBlood:2 armorType:@"路障防具"];
29          i=0;
30         while (![lzjs isDeath])
31         {
32             if(![lzjs isDeath])
33             {
34                 [lzjs attack]; //攻击普通僵尸
35             }
36             i++;
37
38         }
39
40         NSLog(@"--------------------------------");
41
42
43
44     IronZombie *ttjs = [IronZombie  ironZombieType:@"铁桶僵尸"  blood:120  lostBlood:1 armorType:@"铁桶防具" weakness:@"铁桶被吸走"];
45          i=0;
46         while (![ttjs isDeath])
47         {
48             if(![ttjs isDeath])
49             {
50                 [ttjs attack]; //攻击普通僵尸
51             }
52             i++;
53
54         }
55
56     }
57     return 0;
58 }

时间： 2024-11-08 17:30:26

第三讲.继承,完整初始化方法,遍历构造器,多态(代码) 另附植物大战僵尸练习的相关文章

OC基础:继承.初始化方法,便利构造器

继承: 1.单向继承,一个类只能有一个父类,一个父类可以有多个子类. 2.单向继承,基类(根类)是OSObject 3.子类可以继承父类的属性和方法当父类的方法不满足子类的需求时,子类可以重写父类的方法,重写父类的方法,在子类中不需要再次声明. 1.完全重写 2.部分重写使用super 建立继承关系之后,子类可以继承父类的: 1.实例变量,@[email protected]修饰情况之下 2.公开的方法一个方法如果在.h中声明了,那么这个方法就是公开的方法,如果没有声明,则是私有的.

Objective-C 继承、初始化方法、便利构造器

继承.初始化方法.便利构造器今天我们要学习继承初始化方法以及遍历构造器首先我们要理解一些概念性的东西. 继承: 在OC里,继承是单继承的,所谓的单继承就是一个子类继承一个父类,例如我们之前创建的Person类是继承于NSObject的.回顾一下继承的格式 @interface Person : NSObject //在冒号后面是继承的父类. 人继承与NSObject 子类是只能继承一个父类,但父类却可以有多个子类.例如: @interface Student : Person // 学生

Objective-C学习笔记_继承、初始化方法、便利构造器

一.继承继承的上层:父类,继承的下层:子类.继承是单向的,不能相互继承.继承具有传递性:A继承于B,B继承于C,A具有B和C的特征和?为.子类能继承父类全部的特征和行为. 例题打僵尸.需求: 1.定义普通僵尸类: 实例变量:僵尸总血量.僵尸每次失血量. 方法:初始化方法(总血量).被打击失血.死亡. 2.定义路障僵尸类: 实例变量:僵尸总血量.僵尸每次失血量,道具,弱点. 方法:初始化方法(总血量).被打击失血.失去装备.死亡. 3.定义铁桶僵尸类: 实例变量:僵尸总血量.僵尸每次失血量,道

继承、初始化?方法、便利构造器

继承特点 OC中只允许单继承. 没有?父类的类称为根类,OC中的根类是NSObject(祖宗). 继承的内容:所有实例变量和?方法. 如果?子类不满意?父类?方法的实现,可以重写(overwrite)?父类的?方法. 继承具有传递性完成初始化方法 - (void)init { //给super发送init消息:即执行父类中实现的init方法 self = [super init]; if (self) { //初始化设置 } //返回初始化完成的对象 return self; } 上面称作

Objective-C( 继承，初始化方法)

一.继承 1.继承的上层:父类,继承的下层:子类 2.继承是单向的 3.继承具有传递性:子类继承父类的特征和行为 4.子类扩展父类,更加具体 oc中的继承 1.oc中的继承,即一个类继承另一个类: 2.被继承的类称为父类或超类: 3.继承的类为子类继承的特点 1.oc中只允许单继承 2.没有父类的类称为根类.oc中的根类是 NSObject 3.继承的内容:除了私有变量外的所有实例变量和方法 4.子类可以重写父类的方法 super 1.oc中的关键字 2.作用:给super发送消息,可执行父

继承，初始化方法，便利构造器

1.成员访问类型 private:私有成员,不能被外部函数访问(使用),也不能被子类继承: protected:保护成员,不能被外部函数访问,可以被子类继承: public:公有成员,可以被外部函数访问,也可以被子类继承. OC中,所有的方法(消息),都是公有的. 2.重写(继承的另一部分) 子类可以从父类继承方法,但是有时候父类的方法不适合子类,子类就可以写一个自己的同名方法,覆盖掉父类的同名方法,叫做重写. 重写的时候,在子类的.h中不必重新声明,直接在.m中写实现就可以. 1 //父类声明

OC3-完全形态的初始化，初始化方法；；遍历初始化

理解继承,掌握他的属性和方法的使用还有关系::完全形态的初始化,初始化方法::遍历初始化, 1.oc里面继承的特点:(1)继承中上一层时父类,下一层是子类,父类和子类时相对的.(2)所有的类是最根本的父类是NSObject:类的始祖(3)继承具有传递性(4)核心:子类能继承父类全部(private除外)特征和行为. 2.继承:(1)增强代码的复用性,减少代码的开发时间,实现的代码的层级分离, 3.继承的使用,(1)在interface后面类名:父类名继承实现. 注意:(1)oc中是单继承

Swift----方法、下标、继承、初始化、析构方法、可选链

1 下标的使用 1.1 问题下标可以定义在类.结构体和枚举中,可以认为是访问对象.集合或序列的快捷方式,不需要再调用实例的特定的赋值和访问方法. 本案例定义一个Matrix结构体,用于呈现一个Double类型的二维矩阵,其结构体内部使用一个一维数组保存数据,并且定义一个下标用于判断是否会造成数组越界. 1.2 方案首先定义一个Matrix结构体,该结构体有一个存储属性grid,是一个Double类型的结构体,用于存储矩阵的数据. Matrix结构体另有两个整型的常量存储属性rows和colu

OC03-继承,便利构造器,初始化方法

继承继承继承的主要作用就是保证类的完整以及简化代码. 使用时把公共的方法和实例变量写在父类里,子类只需要写自己独有的实例变量和方法就行特点: 只允许单继承 OC中的根类是NSObject 继承的内容:是所有实例变量和方法如果子类中不想用父类方法的实现,可以重写方法注意: 继承的上层是父类,下层是子类继承是单向的,不能相互继承继承是有传递性的,即如果A继承于B,B继承于C,A就具有B和C的特征和行为子类可以继承父类全部的特征和行为继承的实现 #import <Foundation