黑马程序员—Objective-C学习—封装、继承、多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

三大特性：成员变量的封装、继承、多态

一、封装

写成员变量时，不要写@public，应使用set方法。成员变量尽量不要用@public，不让外界直接访问应提供一个方法给外界设置和访问成员变量的值。即set方法和getf方法。

1、set方法

a、作用：提供一个方法给外界设置成员变量值，可以在方法里面对参数进行相应过滤；

b、命名规范：

(1)、方法名必须以set开头；

(2)、set后面跟上成员变量的名称，成员变量的首字母必须大写；

(3)、形参名称不能跟成员变量同名；

(4)、返回值一定是void；

(5)、一定要接收一个参数，而且参数类型跟成员变量类型一致；

2、get方法

a、作用：返回对象内部的成员变量

b、命名规范：

(1)、肯定有返回值，返回值类型肯定与成员变量一致；

(2)、方法名跟成员变量名一样；

(3)、不需要接收任何参数；

3、只允许外界访问成员变量，不允许外界修改成员变量(只读readonly),只需提供get方法；

      只允许外界修改成员变量，不允许外界访问成员变量,只需提供set方法；

4、封装的好处

(1)、过滤不合理的值；

(2)、屏蔽内部的赋值过程；

(3)、让外界不必关注内部的细节；

5、成员变量的命名规范：一定要以下划线 _ 开头。好处：

a) 可以跟get方法的名称区分开；

b) 可以跟局部变量区分开，一看到下划线开头的变量，一般都是成员变量；

6、弱语法

调用未定义的方法时，编译有警告，链接可以通过，执行时报错，闪退

//-[Student test]: unrecognized selector   sent to instance 0x7fce28c09710;

//给Student对象发送了一条不能识别的消息：test

OC在运行过程中才会检测对象有没有实现相应方法（动态检测）

7、setter和getter实例

        #import <Foundation/Foundation.h>

       @interface Student : NSObject

{

    int _age; 

} 

//set方法

- (void)setAge :(int)newAge;

//get方法

- (int)age;

- (void)study;

@end

@implementation Student

//set方法的实现

- (void)setAge :(int)newAge

{

    //对传进来的参数进行过滤

    if(newAge <=0)

    {

        newAge = 1;

    }

    _age = newAge;

}

//get方法的实现

- (int)age

{

    return _age;

}

- (void)study

{

    NSLog(@"%d岁的学生在学习", _age);

}

@end

int main()

{

    Student *stu = [Student new];

    [stu setAge:10];

    [stu study];

    NSLog(@"学生的年龄是%d岁", [stu age]);

   

    /*

     //-[Student test]: unrecognized selector   sent to instance 0x7fce28c09710;

     //给Student对象发送了一条不能识别的消息：test

     [stu test];

    */

    return0;

}

8、类方法

a、概念：直接可以用类名来执行的方法(类本身会在内存中占据存储空间，里面有类/对象方法列表)；

b、类方法定义：类方法都是以 + 开头；

c、1>类方法只能用类来调用，不能用对象调用；

     2>对象只能调用对象方法(-)，类不能调用对象方法；

     3>可以允许类方法跟对象方法同名；

     4>类方法内能调用其他的类方法，对象方法内也能调用类方法； 

     5>类方法不能调用自己，会引发死循环；

d、类方法和对象方法区别：

对象方法：

(1)、减号 – 开头；

(2)、只能由对象调用；

(3)、对象方法中能访问当前对象的成员变量；

类方法：

(1)、加号 + 开头；

(2)、只能由类(名)调用；

(3)、成员变量不能在类方法中访问；

e、类方法的好处和使用场合

(1)、不依赖于对象，执行效率高；

(2) 、能用类方法尽量用类方法；

(3) 、场合：当方法内部不需要使用成员变量时，就可以改为类方法；

f、工具类：基本没有任何成员变量，里面的方法基本都是类方法；

g、类方法实例

#import <Foundation/Foundation.h>

@interface Person : NSObject

//类方法都是以+开头

+ (void)printClassName;

- (void)test;

@end

@implementation Person

+ (void)printClassName

{

    NSLog(@"这个类叫做Person");

}

- (void)test

{

    NSLog(@"调用了test方法");    

    [Person printClassName];

}

@end

int main()

{

    /*

     Person *p = [Person new];

     //系统会认为现在调用的printClassName是个对象方法

     [p printClassName];这个是错误的，报不能识别消息错误，他找的是对象方法(-)，在对象里面找printClassName对象方法

    */

     [Person printClassName];

    /*

     //系统会认为现在调用的test是个类方法

     [Person test];//在类里面找test，找不到test类方法

    */  

    return 0;

}

h、self关键字

(1)、self是个指针，指向调用当前方法内变量，代表着当前变量。

(2)、谁调用了当前方法，self就代表谁；self出现在对象方法中，self代表对象，self出现在类方法中，self代表类；

(3)、在对象方法中，可以利用“self->成员变量名”访问当前对象内部的成员变量；

         [self 方法名]，可以调用其他对象方法或类方法。

二、继承

1、概念：某一个类A继承另一个类B，就可以拥有那个类的所有成员变量和方法。

1>A叫做子类，B叫做父类；

2>所有的类最终继承根类，根类(最基本的类)：NSObject

3>每个类中都有一个superclass指针指向父类；

2、继承的好处：

a、抽取重复代码，不改变原来模型的基础上，拓充代码；

b、建立了类之间的关系；

c、子类可以拥有父类中的所有成员变量和方法。

3、继承的使用场合

a、当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取；

b、当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类；

4、继承的专业术语

1>父类\超类    superclass

2>子类   subclass\subclasses

5、继承的注意点

a、单继承

b、不允许子类和父类拥有相同名称的成员变量；

c、子类可以重写父类的方法，子类重新实现父类中的某个方法，覆盖父类以前的做法；

1>父类必须声明在子类之前；

2>调用某个对象的方法时，优先去当前对象中找，如果找不到，去父类中找；

d、继承的坏处：耦合性太强(类之间的关系太紧密);

6、继承实例

#import <Foundation/Foundation.h>

/********Animal********/

@interface Animal : NSObject

{

    int _age;

    double _weight;

}

- (void)setAge:(int)age;

- (int)age;

- (void)setWeight:(double)weight;

- (double)weight;

@end

 

@implementation Animal

 

- (void)setAge:(int)age

{

    _age = age;

}

- (int)age

{

    return _age;

}

- (void)setWeight:(double)weight

{

    _weight = weight;

}

- (double)weight

{

    return _weight;

}

@end

/********Dog********/

// : Animal 继承了Animal, 相当于拥有了Animal里面的所有成员变量和方法

//Animal称为Dog的父类

//Dog称为Animal的子类

@interface Dog : Animal

@end

@implementation Dog

@end

/********Cat********/

@interface Cat : Animal

@end

@implementation Cat

@end

int main()

{

    Dog *d = [Dog new];

    [d setAge:10];

    NSLog(@"age = %d",[d age]);

    return0;

}

7、super作用：

a、直接调用父类中的某个方法

b、super处在对象方法中，那么就会调用父类的对象方法

   super处在类方法中，那么就会调用父类的类方法

 

c、使用场合：子类重写父类的方法时想保留父类的一些行为

8、继承和组合的区分：

继承：XX是XXX；组合：XX拥有XXX；

继承：

@interface A : NSObject

{

int _age;

}

@end

@interface B : A

{

int _weight;

}

@end

组合：

@interface A : NSObject

{

int _age;

}

@end

@interface B : NSObject

{

A _a;

int _weight;

}

@end

三、多态

1、基本概念：某一类事物的多态性，OC对象具有多态性

2、没有继承就没有多态；

a、代码体现：用父类类型的指针指向子类对象；

b、调用方法时，会检测对象的真实类型，调用的是真实类型的方法。

3、多态的好处：当遇到多个函数，每个方法相差不大，用父类接收参数，节省代码。(将多个函数合成一个函数)

4、多态的局限性：父类类型的变量，不能用来调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法。

5、多态实例：

#import <Foundation/Foundation.h>

@interface Animal : NSObject

- (void)eat;

@end

@implementation Animal

- (void)eat

{

    NSLog(@"Animal--吃东西----");

}

@end

@interface Dog : Animal

- (void)run;

@end

@implementation Dog

- (void)eat

{

    NSLog(@"Dog--吃东西----");

}

- (void)run

{

    NSLog(@"Dog--跑起来----");

}

@end

@interface Cat : Animal

@end

@implementation Cat

- (void)eat

{

    NSLog(@"Cat--吃东西----");

}

@end

//如果参数中使用的是父类的类型，可以传入父类、子类的对象

void feed(Animal *a)

{

    [a eat];

}

int main()

{

    Dog *d = [Dog new];

    [d run];

    

    Animal *aa = [Dog new];

    //多态的局限性：父类类型的变量不能用来调用子类的方法

    //[aa run];

    

    //将aa转为Dog *类型的变量

    Dog *dd = (Dog *)aa;

    [dd run];

    

    /*

    Dog *dd = [Dog new];

    feed (dd);

    

    Cat *cc = [Cat new];

    feed(cc);

     */

    /*

    //多种形态

    Dog *d = [Dog new];//Dog类型

    [d eat];

    

    //多态：父类指针指向子类对象

    Animal *a = [Dog new];

    

    //调用一个方法时会检测对象的真实类型

    [a eat];

    */

    return 0;

}