#import <Foundation/Foundation.h>
@interface Student : NSObject
{
//OC02_方法和继承
//方法分为:一种是+号(称为类方法,这个方法一般由类使用),一种是减号(称为实例方法,一般由对象来使用);
//通过方法给成员变量进行赋值;
//对应类的是+号,对应对象的是-号
//id相当于void *,称为泛型指针,可以代表指针的类型,用id的时候不加*号;
//例如:定义一个类叫Student(自己任意定),在.h中编译成员变量和制
@public//暂时还用public 也可以用默认被保护的protected
NSString *_stuName;
NSString *_stuSex;
NSInteger _stuAge;
NSString * _stuHobby;
CGFloat _stuScore;
}
-(void)play;
-(id)init;
//方法带一个参数
-(void)eat:(NSString *)str;//str相当于形参的名
-(void)play:(NSString *)str withWho:(NSString *)who;
//方法名不能重复
//设置器(setter)和访问器(getter)方法;
//每一对成员变量都有一对设置器和访问器,setter和getter只对一个成员变量进行设置;
//设置器,主要针对成员变量如:NSString *_stuName,给成员变量赋值;
-(void)setStuName:(NSString *)stuName;
//访问器,是对成员变量取值;
-(NSString *)stuName;
//下面对上面的成员变量逐个进行赋值取值
-(void)setStuSex:(NSString *)stuSex;
-(NSString *)stuSex;
-(void)setStuAge:(NSInteger)stuAge;
-(NSInteger)stuAge;
-(void)setStuHobby:(NSString *)stuHobby;
-(NSString *)stuHobby;
-(void)setStuScore:(CGFloat)stuScore;
-(CGFloat)stuScore;
//写一个自定义初始化方法:方法方法必须以init作为开头,然后with,W必须大写,这是系统对自定义初始化方法的要求;
-(id)initWithStuName:(NSString *)stuName
stuSex:(NSString *)stuSex
stuAge:(NSInteger)stuAge
stuHobby:(NSString *)stuHobby
stuScore:(CGFloat)stuScore;
//在每一个成员变量空格后面加回车,以便整理内容;把初始化方法和setter和getter方法加入到.m文件中.用复制;
#import "Student.h"
@implementation Student
//进行打印
-(void)play{
NSLog(@"%@,%@,%ld,%g",_stuName,_stuSex,_stuAge,_stuHobby,_stuScore);
}
-(id)init{
_stuName =@"男的";
_stuSex =@"女";
_stuAge =20;
_stuHobby =@"跳舞";
_stuScore =59.9;
return self;
}
//getter和setter实现部分
-(void)setStuName:(NSString *)stuName{
_stuName =stuName;
}
//访问器,是对成员变量取值;
-(NSString *)stuName{
return _stuName;
}
//下面对上面的成员变量逐个进行赋值取值
-(void)setStuSex:(NSString *)stuSex{
_stuSex =stuSex;
}
-(NSString *)stuSex{
return _stuSex;
}
-(void)setStuAge:(NSInteger)stuAge{
_stuAge =stuAge;
}
-(NSInteger)stuAge{
return _stuAge;
}
-(void)setStuHobby:(NSString *)stuHobby{
_stuHobby= stuHobby;
}
-(NSString *)stuHobby{
return _stuHobby;
}
-(void)setStuScore:(CGFloat)stuScore{
_stuScore =stuScore;
}
-(CGFloat)stuScore{
return _stuScore;
}
//自定义初始化方法的实现
-(id)initWithStuName:(NSString *)stuName
stuSex:(NSString *)stuSex
stuAge:(NSInteger)stuAge
stuHobby:(NSString *)stuHobby
stuScore:(CGFloat)stuScore{
_stuName =stuName;
_stuSex =stuSex;
_stuAge =stuAge;
_stuHobby =stuHobby;
_stuScore =stuScore;
return self;
}
#import <Foundation/Foundation.h>
@interface Zombie : NSObject
{
@private//私有的
NSInteger _blood;//血
NSInteger _attack;//攻击
CGFloat _speed;//速度
}
//行为
-(void)walk;//行走
-(void)attackVegetable;//攻击蔬菜;
-(void)dead;//死亡
//子类可以继承父类的所有的特征,但是被@private修饰的成员变量子类可以继承,但是不能使用.
#import "Zombie.h"
@implementation Zombie //僵尸
-(void)walk{
NSLog(@"僵尸会走");
}
-(void)attackVegetable{
NSLog(@"僵尸可以攻击蔬菜");
}
-(void)dead{
NSLog(@"僵尸会死亡");
}
@ end
//再创建一个新类(luZhangZombie),把Zombie当做下一个类父类.新建时在NSobject处换成父类的名字(Zombie);
#import "Zombie.h"
@interface LuZhangZombie : Zombie
{
//这里只需要写父类没有的变量
@public
NSString *_equipment;//装备
}
//行为
-(void)loseEquipment;//失去装备
//这里父类的行为都可以不用再写.只写新更改的.
//若是行为内容有更改,可以再写一遍,稍作更改,调用时会优先使用子类更改的内容
@end
#import "LuZhangZombie.h"
@implementation LuZhangZombie
-(void)loseEquipment{
NSLog(@"僵尸会丢失装备");
}
//这里我暂不做更改.下面的新类TieTongZombie的创建和LuZhangZombie一样;
@end
///最后到主函数里
#import <Foundation/Foundation.h>
#import "Student.h"
#import "Zombie.h"
#import "LuZhangZombie.h"
int main(int argc, const char * argv[]) {
//OC02_方法和继承
//调用Student进行打印 在上面加入#import "Student.h"
Student *stu =[[Student alloc]init];
[stu play];
[stu eat:@"不知道吃什么"];
[stu play:@"游戏" withWho:@"女生"];
//调用Student设置器
NSString *stuName =[stu stuName];
NSLog(@"%@",stuName);
//调用访问器可直接打印
NSLog(@"%@",[stu stuHobby]);
//调用自定义初始化
Student *stu1 =[[Student alloc]initWithStuName:@"哪吒" stuSex:@"人妖" stuAge:10 stuHobby:@"乾坤陵" stuScore:2];
//继承:继承是面向对象的重要的特点,主要目的是为了解决代码重复的问题;
//子类可以继承父类所有的特征和行为,子类只需要写独有的成员变量即可,其余都可以通过继承的方式得到,如果重复写,会报错;
//比如新定义三个类进行相互继承,一个是zombie 一个是luZhangZombie和TieTongZombie;
//调用一下刚才创建的类,需要在上面把类添加进来
Zombie *zombie =[[Zombie alloc]init];
[zombie walk];//这样就可以打印 前面的zombie填写我们自己定义的对象;
LuZhangZombie *luZhang =[[LuZhangZombie alloc]init];
[luZhang walk];//luZhang同理
//继承有明显的优势在于可以节省重复的代码,但是弊端在于代码的耦合度高,也就是类和类指点的关联性高;
//OC可以使用继承,但是不推荐多层的继承,就是为了防止,因为关联性高,造成前一发动全身;
//继承是单向的,一个类只有一个父类,但是可以有多个子类,NSObject是OC里的根类,我们使用init和alloc都是NSObject里继承过来的