OC--封装，继承，多态

一、封装

@public 的成员可以被随意赋值，应该使用 set 方法和 get 方法来管理成员的访问，设置过滤。

1、set方法

  

1)作用： 提供一个方法给外界设置成员变量值，可以在方法里面对参数进行相应过滤
2)命名规范：
1> 方法名必须以set开头
2> set后面跟上成员变量的名称，成员变量的首字母必须大写
3> 返回值一定是void
4> 一定要接收一个参数，而且参数类型跟成员变量类型一致

5> 形参的名称不能跟成员变量名一样   

方法声明  - (void)setAge:(int)newAge;

方法实现 

- (void)setAge:(int)newAge

{
    // 对传进来的参数进行过滤
    if (newAge <= 0)
    {
        newAge = 1;
    }
   
    _age = newAge;
}

2、get方法

1）作用：返回对象内部的成员变量
2）命名规范：
1> 肯定有返回值，返回值类型肯定与成员变量类型一致
2> 方法名跟成员变量名一样
3> 不需要接收任何参数

方法声明

- (int)age; 

- (void)study;

方法实现

- (int)age

{
    return age;
}

- (void)study
{
    NSLog(@"%d岁的学生在学习", age);
}

3、成员变量命名规范

1）   成员变量的命名规范：一定要以下划线 _ 开头
  作用：
  1.让成员变量和get方法的名称区分开
  2.可以跟局部变量区分开，一看到下划线开头的变量，一般都是成员变量

 int _no;

4、封装的好处

>过滤不合理的值
>屏蔽内部的赋值过程
>让外界不必关注内部的细节

5、常见错误

-[Person test]: unrecognized selector sent to instance 0x7fd2ea4097c0
给Person对象发送了一个不能识别的消息：test

声明一个方法，却没有实现相应的方法。

OC是在运行过程中才会检测对象有没有实现相应的方法

6、类方法

1）基本概念
直接可以用类名来执行的方法（类本身会在内存中占据存储空间，里面有类\对象方法列表）

2）类方法和对象方法的对比

对象方法
1> 减号 - 开头
2> 只能由对象来调用
3> 对象方法中能访问当前对象的成员变量（实例变量）

类方法
1> 加号 + 开头
2> 只能由类（名）来调用
3> 类方法中不能访问成员变量（实例变量）


3）类方法的好处和使用场合
1> 不依赖于对象，执行效率高
2> 能用类方法，尽量用类方法
3> 场合：当方法内部不需要使用到成员变量时，就可以改为类方法

可以允许类方法和对象方法同名

4）类方法调用

[类名 类方法名];

[Person test];

5）常见错误

>error：instance variable 'age' accessed in class method

 实例变量age不能在类方法中访问

+ (void)printClassName
{
   NSLog(@"这个类叫做Person-%d", age);

}

>对象方法中不能调用类方法。

-[Person printClassName]: unrecognized selector sent to instance 0x7fa520c0b370

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

Person *p = [Person new];

[p printClassName];

>死循环

+ (void)test
{
  
   [Person test];
   
   NSLog(@"333");
   
   [Person test];
}

7、self关键字

1）self的用途：
1> 谁调用了当前方法，self就代表谁
* self出现在对象方法中，self就代表对象
* self出现在类方法中，self就代表类

2> 在对象方法利用"self->成员变量名"访问当前对象内部的成员变量

3> [self 方法名]可以调用其他对象方法\类方法

2）当成员变量和局部变量同名时，采取就近原则，访问的是局部变量

     用self访问成员变量，区分同名的局部变量

3）使用注意

>可以在所有的OC方法中（对象方法\类方法）使用，但 不能出现在函数中

>不能用self去调用函数

>不能在类方法中用self调用对象方法，对象方法中用self调用类方法

>注意 self 死循环

二、继承

1.继承的好处：
1> 抽取重复代码
2> 建立了类之间的关系
3> 子类可以拥有父类中的所有成员变量和方法

2.注意点
1> 基本上所有类的根类是NSObject

代码示例：

/******创建父类，Animal****/
@interface Animal : NSObject
{
    int _age;
}
- (void)setAge:(int)age;
- (int)age;
@end

@implementation Animal
- (void)setAge:(int)age
{
    _age = age;
}
- (int)age
{
    return _age;
}
@end

/******子类Dog继承Animal***/
@interface Dog : Animal
@end

@implementation Dog
@end

Dog继承了Animal，相当于拥有了Animal里面的所有成员变量和方法
Animal称为Dog的父类
Dog称为Animal的子类

3、子类在父类的基础上拓充属性和方法

1）方法重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

2）注意
 1> 父类必须声明在子类的前面
 2> 子类不能拥有和父类相同的成员变量
 3> 调用某个方法时，优先去当前类中找，如果找不到，去父类中找

3）

好处:
>不改变原来模型的基础上，拓充方法
>建立了类与类之间的联系

>抽取了公共代码

坏处：耦合性太强

4、继承的使用场合

1> 当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取到一个父类中
2> 当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类
A
{
    int _age;
    int _no;
}

B : A
{
    int _weight;
}

// 继承：xx 是 xxx
// 组合：xxx 拥有 xxx

2.组合
A
{
     int _age;
     int _no;
}

B
{
     A *_a;
     int _weight;
}

5、super关键字

>作用
1.直接调用父类中的某个方法
2.super处在对象方法中，那么就会调用父类的对象方法
   super处在类方法中，那么就会调用父类的类方法

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

三、多态

代码实现

Person *p = [Student new];

p->age = 100;

[p walk];

>子类对象赋值给父类指针
>父类指针访问对应的属性和方法

1.没有继承就没有多态
2.代码的体现：父类类型的指针指向子类对象
3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象

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

Animal *aa = [Dog new];

[aa run];

强制转换

Animal *aa = [Dog new];

Dog *dd = (Dog *)aa;
[dd run];

5.动态绑定

在运行时根据对象的类型确定动态调用的方法

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

void feed(Animal *a)
{
    [a eat];
}

7.

   NSObject *n = [Dog new];

    NSObject *n2 = [Animal new];
   
   
    多种形态
    Dog *d = [Dog new]; // Dog类型
   
     多态：父类指针指向子类对象
    Animal *a = [Dog new];
   
    调用方法时会检测对象的真实形象
    [a eat];