OC基础 类的三大特性

OC基础  类的三大特性

OC的类和JAVA一样,都有三大特性:继承,封装,多态,那么我们就来看一下OC中类的三大特性。

1.继承

继承的特点:

(1)子类从父类继承了属性和方法。

(2)子类独有的属性和方法不能被父类使用。

(3)子类独有的属性和方法,不能够在子类之间互相使用。

(4)子类能够重写父类的方法,子类调用该方法时:首先调用子类的方法,如果子类没有该方法,就调用父类的该方法。

(5)子类对象指针可以转换成父类对象指针,但是父类对象指针不能够转换成子类对象指针。

 

三种权限变量的继承:

(1)public和protected修饰的变量可以被子类继承。

(2)private修饰的变量不可以被子类继承。

(3)继承的属性,如果要在子类里面修改,只能使用 "self.属性名",不能使用 "_属性名"

 

例子:

Father类,Father.h文件:

#import <Foundation/Foundation.h>

@interface Father : NSObject

@property (nonatomic,strong) NSString *name;

@property (nonatomic) int age;

-(id)initWithName:(NSString *)name andAge:(int)age;

-(void)speakChinese;

-(void)printf;

@end

 

Father.m文件:

#import "Father.h"

@implementation Father

-(id)initWithName:(NSString *)name andAge:(int)age
{
    self = [super init];
    if(self)
    {
        _name = name;
        self.age = age;
    }
    return self;
}

-(void)speakChinese
{
    NSLog(@"我会说中文");
}

-(void)printf
{
    NSLog(@"我叫%@,我%d岁",_name,_age);
}

@end

 

Son1类,Son1.h文件:

#import "Father.h"

@interface Son1 : Father

@property (nonatomic) int score;

-(void)speakEnglish;

@end

Son1.m文件:

#import "Son1.h"

@implementation Son1

-(void)speakEnglish
{
    NSLog(@"我会说英文");
}

-(void)printf
{
    NSLog(@"%@,%d,%d",self.name,self.age,self.score);
}

@end

 

Son2类,Son2.h文件:

#import "Father.h"

@interface Son2 : Father

@property (nonatomic) int money;

-(void)speakFrench;

@end

Son2.m文件:

#import "Son2.h"

@implementation Son2

-(void)speakFrench
{
    NSLog(@"我会说法语,我很屌!");
}

@end

 

main.m中使用:

#import <Foundation/Foundation.h>
#import "Son1.h"
#import "Father.h"
#import "Son2.h"

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        
        // insert code here...
        
        Father *fa = [[Father alloc] initWithName:@"王老大" andAge:40];
        NSLog(@"%@%d",fa.name,fa.age);
        
        [fa speakChinese];
        [fa printf];
        
        Son1 *son1 = [[Son1 alloc] initWithName:@"王小三" andAge:20];
        NSLog(@"%@%d,%d",son1.name,son1.age,son1.score);
        
        [son1 speakChinese];
        [son1 speakEnglish];
        [son1 printf];
        
        Son2 *son2 = [[Son2 alloc] initWithName:@"王小二" andAge:22];
        
        [son2 speakChinese];
        [son2 speakFrench];
        [son2 printf];
        
        Father *fa2 = (Father *)son1;
        [fa2 speakChinese];
        
        Son1 *son11 = (Son1 *)fa;
        [son11 speakEnglish];
        
    }
    return 0;
}

2.封装

封装:隐藏内部实现,稳定外部接口。

封装就是定义类,定义属性和定义方法。

然而类封装了实例变量和方法,属性则是封装的setter和getter方法

那么封装带来的好处:让我们使用更加简单 ,变量更加安全 ,并且可以隐藏内部实现细节 ,充分的提升了开发速度。

例子:

Student类,Student.h文件:

#import <Foundation/Foundation.h>

@interface Student : NSObject
{
    NSString *_name;
    NSString *_nickName;
}

//@property定义属性
//1,它给该类声明了一个属性名+下划线的变量
//2,它给该类声明了一个getter方法和一个setter方法

//修饰符
//atomic和nonatomic
//原子性和非原子性,atomic线程安全,nonatomic线程不安全
//一般情况下使用nonatomic

//setter修饰符指定赋值时调用哪个方法来实现setter
//setter修饰符指定读取值时调用哪个方法来实现getter
@property (nonatomic,setter = setNickName:,getter = nickName) NSString *nickName;

//修饰符
//assign用来修饰基本类的
//strong或者retain是用来修饰对象指针的
//readonly只读:只声明和实现getter,不声明和实现setter方法
//readwrite可读写:声明和实现了getter和setter,默认就是readwrite
@property (assign,readonly) int age;
@property (retain,readwrite) NSString *secondName;

-(void)setName:(NSString *)name;
-(NSString *)getName;
-(void)setaaa:(NSString *)aaa;

@end

 

3.多态

多态性(polymorphism):允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说:允许将子类类型的指针赋值给父类类型的指针。

不同对象对同一消息的不同响应,子类可以重写父类的方法,多态就是允许方法重名,参数或返回值可以是父类型传入或返回。

多态的特点:

(1)父类类型的指针指向子类对象。

(2)如果函数方法参数中使用的是父类类型,则可以传入父类和子类对象,而不用再去定义多个函数来和相应的类进行匹配了。

(3)父类类型的变量不能直接调用子类特有的方法,如果必须要调用,则必须强制转换为子类特有的方法。

例子:

Animal类,Animal.h文件:

#import <Foundation/Foundation.h>

@interface Animal : NSObject

- (void)name;

@end

Animal.m文件:

#import "Animal.h"

@implementation Animal

- (void)name {
    NSLog(@"动物");
}
@end

 

Cat继承Animal,Cat.h文件:

#import "Animal.h"

@interface Cat : Animal

- (void)name;

@end

Cat.m文件:

#import "Cat.h"

@implementation Cat

//重写方法
- (void)name {
    NSLog(@"");
}

@end

main.m中使用:

#import <Foundation/Foundation.h>
#import "Animal.h"
#import "Cat.h"

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        
        Animal *animal = [[Animal alloc] init];
        [animal name];
        
        Cat *cat1 = [[Cat alloc] init];
        [cat1 name];

        //这里会体现多态的用法:动态监控调用哪个方法
         Animal *cat2= [[Cat alloc] init];
         [cat2 name];

    }
    return 0;
}

 

你可能感兴趣的:(OC基础 类的三大特性)