黑马程序员-OC的三大特性：封装、继承、多态

• 封装：目前我的理解是将类声明里的实例变量“包裹”好，一旦“包裹”好，由类生成的对象也就“包裹”的“严实”了，这样外部的东西就不会随意修改对象的重要数据了，之前我们要想对类的实例变量赋值，是通过指针访问的，并且要在实例变量前面加上关键字@public，其实这个@public关键字像是把类里面的实例变量“赤裸裸”的暴露在外面，很不安全。那么不通过这种途径要想访问对象的数据咋办呢？set方法（setter）和get方法（getter）很好的解决了这一问题。

         set方法：

1.  它是对象方法，肯定是用减号'-'开头，方法名必须以set开头，紧跟着是实例变量名，并且首字母要大写
2. 没有返回值，并且有参数，参数的类型跟对应的实例变量类型一致
3. 能过滤掉一些不合理的赋值

        get方法：

1. 也是对象方法，必须用减号'-'开头，方法名不能以get开头，方法名和实例变量名一致（为了区分到底是方法名还是实例变量，以后所有实例变量都是以下划线‘_’开头）
2. 有返回值，返回值类型与实例变量的类型一致，没有参数

#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    int _age; //年龄
    double _weight; // 体重
}

//年龄的setter和getter声明
- (void)setAge:(int)age;
- (int)age;

@end

@implementation Person

//年龄的setter和getter实现
- (void)setAge:(int)age{
    if (age <= 0) {
        _age = 1;
    }else{
        _age = age;
    }
}

- (int)age{
    return _age;
}

@end

//测试age的setter和getter
int main(){
    Person *p = [Person new];
    [p setAge:-3];
    NSLog(@"年龄为%d", [p age]);
    return 0;
}

• 继承：继承是OC语法最重要的一个特性，他是类之间的一种关系，如果说B类继承了A类，那么A类的所有实例变量和方法B类都会拥有而不需要重复说明省去了不必要的重复代码，上面的B类叫父类，A类成为子类，它的写法就是：“: 类名”。OC中基本所有的类都是继承NSObject类的，称NSObject为root Class（根类）

  #import <Foundation/Foundation.h>
  /************Person类************/
  @interface Person : NSObject
  {
      int _age; //年龄
      double _weight; // 体重
  }
  
  //年龄的setter和getter声明
  - (void)setAge:(int)age;
  - (int)age;
  
  @end
  
  @implementation Person
  
  //年龄的setter和getter实现
  - (void)setAge:(int)age{
      if (age <= 0) {
          _age = 1;
      }else{
          _age = age;
      }
  }
  
  - (int)age{
      return _age;
  }
  
  @end
  
  /**************Studengt类***************/
  @interface Studengt : Person
  
  @end
  
  @implementation Studengt
  
  @end
  
  //测试Student类
  int main(){
      Studengt *stu = [Studengt new];
      [stu setAge:17];
      NSLog(@"学生的年龄是%d", [stu age]);
      
      return 0;
  }

  因为Studengt类继承了Person类，所以虽然子类没有明确说明实例变量和方法，但是学生依然有年龄_age的实例变量以及_age的getter和setter

        但是继承有很多需要注意的地方：

1. 如果父类和子类在同一个文件中，父类的声明和实现必须要在子类的前面，
2. 子类拥有的新实例变量必须保证不能和父类的实例变量相同否则会报错：duplicate member

3. 子类可以拥有和父类一样的方法，并且这个一样的方法可以在子类中只写实现，不用再写声明，我们称这种现象叫重写 。当一个的对象调用方法时，它首先会在自己里面找有没有该方法，如果没有，那么就去父类中找，直到找到为止。那么诱人会问了，子类和父类在内中具体是怎么联系在一起的？和前面提到的isa指针一样，每一个子类里都会有一个superclass指针指向它的父类。
   

4. 一个子类只能有一个父类，这就好比生活中你只能有一个爸爸一样，当然父类是可以拥有多个子类的
5. 这种继承关系耦合性太强（耦合性可以理解成没有了父类，子类就会崩溃）
6. 使用场合也要注意，要符合了一定的逻辑，不能乱继承。比如说Student类里面有各种学习成绩，我们可以把这种成绩抽出来建一个Score类，但是这种情况下，我们不能将Student类继承Score类，我们只能说Student类包含或者说组合了Score类，此时的做法是将Score这个类作为Student类的实例变量。一般情况下如果从逻辑上有“A类是B类”这层关系，那么就能将A类作为B类子类，否则就不行。

• 多态：正式由于继承这个特性才导致了多态性比如：

  #import <Foundation/Foundation.h>
  /************Person类************/
  @interface Person : NSObject
  
  @end
  
  @implementation Person
  
  @end
  
  /**************Studengt类***************/
  @interface Student : Person
  
  @end
  
  @implementation Student
  
  @end
  
  
  int main(){
      // 创建一个Student类让Student类型的指针指向该对象
      Studengt *stu = [Studengt new];
      
      return 0;
  }

  代码的第23行可以根据多态性（因为Student是继承了Person类）改为

  Person *p = [Studengt new];

  由于Person类又是继承根类NSObject，第23行又可以改为

  NSObject *n = [Studengt new];

  但是反过来是不行的

      //错误代码
      Student *stu = [Person new]; // 不能用子类类型的指针指向父类的对象

  虽然不能这么写但是编译器在编译的时候不会报错，只会发出警告，这是由于OC的弱语法的特性导致的

       但是要注意的是多态也有一定的局限性：父类类型的指针变量不能调用子类的方法

// 假设Person类里没有study方法，但是子类Student里面有
// 错误代码示范
int main(){
    
    Person *p = [Student new];
    // 因为p是父类类型的指针，所以它会去父类里找run方法
    [p study];
    
    return 0;
}

虽然编译器编译的时候不会报错只会付出警告，但是对于初学者很不利，上述的错误我们可以采取强制转换措施

int main(){
    
    Person *p = [Student new];
    
    //强制把Person类型的指针转化为和stu同类型的指针，这里p和stu同时指向Student类对象
    Student *stu = (Person *)p;
    
    [p study];
    
    return 0;
}

• 补充：关于self和super的使用，首先self和super都是一种指针，self是指向当前调用者（方法调用者），可以理解成谁调用了当前方法（包括对象方法和类方法）self就指向谁，或者说是self出现在哪个方法里，self就只指向它；而super跟self差不多，只是super指向的时当前类的父类。代码实现self和super：

  #import <Foundation/Foundation.h>
  /************Person类*************/
  @interface Person : NSObject
  
  - (void)test;
  + (void)test;
  
  @end
  
  @implementation Person
  
  - (void)test{
      NSLog(@"调用了父类的对象方法test");
  }
  
  + (void)test{
      NSLog(@"调用了父类的类方法test");
  }
  
  @end
  /************Student类************/
  @interface Student : Person
  
  - (void)study; // 学习方法声明
  - (void)sleep; // 睡觉方法声明
  + (void)playFootball; // 踢足球方法声明
  + (void)playBasketball; // 打篮球方法声明
  
  @end
  
  @implementation Student
  
  - (void)study{
      [super test]; // 调用当前类的父类test对象方法
      //[self playBasketball];错误写法，因为在该类中找不到playFootball对象方法
      NSLog(@"学习时间到！！！");
  }
  
  - (void)sleep{
      [self study]; // 调用当前类的study对象方法
      NSLog(@"睡觉时间到！！！");
  }
  
  + (void)playFootball{
      [self playBasketball]; // 调用当前类的playBasketball类方法
      // [self study]; 错误写法，因为找不到该类的study类方法
      NSLog(@"足球时间到！！！");
  }
  
  + (void)playBasketball{
      [super test]; // 调用当前类的父类的test类方法
      NSLog(@"篮球时间到！！！");
  }
  
  @end
  
  
  int main(){
      // 创建学生对象
      Student *stu = [Student new];
      
      [Student playFootball];
      [Student playBasketball];
      
      [stu sleep];
      [stu study];
      
  
      return 0;
  }