oc语言--面向对象的三大特性

一、封装

1.什么是封装

在程序上，隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将对象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

1> set方法

　　① 作用：提供一个方法给外界设置成员变量值，实现对参数的相应过滤

　　② 命名规范

　　　*方法名必须以set开头

　　　*set后面跟上成员变量的名称，成员变量名首字母必须大写

　　　*返回值一定是void

　　　*一定要接收一个参数，而且参数类型跟成员变量类型一致

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

 #import <Foundation.foundation.h>

 @interface Student : NSObject  : NSObject //声明一个类
 {
     int _age;//设置一个成员变量
 }

 - (void)study;//声明一个study对象方法
 - (void)setAge:(int)age;//声明set方法

 @end

 @implementation Student //对声明的方法进行实现

 - (void)setAge:(int)age //set方法的实现
 {
     if(age <= )  //对不合理的值进行过滤
     {
         age = ;
     }

     _age = age;
 }

 - (void)study  //study方法的实现
 {
     NSLog("%d岁的学生在学习"，age);
 }

 @end

 int main()
 {
     Student *stu = [Student new];//新建一个Student类型对象
     [stu setAge :];//调用set方法进行赋值操作
     [stu study];// 对象调用对象方法
     return ;
 }

set方法例子

2> get方法

　　①作用：返回成员变量值

　　②命名规范

　　　*有返回值，返回值类型与成员变量类型相同

　　　*方法名跟成员变量名相同

　　　*不需要接收任何参数

 #import <Foundation.foundation.h>

 @interface Student : NSObject //声明一个类
 {
     int _age;//设置一个成员变量
 }

 - (void)study;//声明一个对象方法
 - (void)setAge:(int)age;//声明set方法
 - (int)age;//声明get方法

 @end

 @implementation Student //对声明的方法进行实现

 - (void)setAge:(int)age //set方法的实现
 {
     if(age <= )  //对不合理的值进行过滤
     {
         age = ;
     }

     _age = age;
 }

 - (int)age // get方法的实现
 {
     return _age;
 }

 - (void)study  //study方法的实现
 {
     NSLog("%d岁的学生在学习"，[stu age]);//get方法的调用
 }

 @end

 int main()
 {
     Student *stu = [Student new];//新建一个Student类型对象
     [stu setAge :];//调用set方法进行赋值操作
     [stu study];// 对象调用对象方法
     return ;
 }

get方法例子

3> 封装细节

　①成员变量名以_开头，命名规范

　　*作用1，让成员变量名与get方法名区分开

　　*作用2，跟局部变量名分开，带_一般就是成员变量名

 #import <Foundation.Foundation.h>

 @interface Score : NSObject //声明Score类
 {
     int _cScore;//设置成员变量 _cScore
     int _ocScore;//设置成员变量 _ocScore
     int _totalScore;//设置成员变量 _totalScore
     int _averageScore;//设置成员变量 _averageScore
 }

 - (void)setCScore:(int)cScore;//声明set方法
 - (int)cScore;//声明get方法

 - (void)setOcScore:(int)ocScore;//声明set方法
 - (int)ocScore;//声明get方法

 - (int)totalScore;//声明get方法
 - (int)averageScore;//声明get方法

 @end

 @implementation Score //方法的实现

 - (void)setCScore:(int)cScore //set方法的实现
 {
     _cScore = cScore;
     _totalScore = _cScore + _ocScore;//计算总分，监听成员变量的改变
     _averageScore = _totalScore/;//计算平均分
 }

 - (int)cScore // get方法的实现
 {
     return _cScore;
 }

 - (void)setOcScore:(int)ocScore //set方法的实现
 {
     _ocScore = ocScore;
     _totalScore = _cScore + _ocScore; //计算总分，监听成员变量的改变
     _averageScore = _totalScore/;//计算平均分
 }

 - (int)ocScore // get方法的实现
 {
     return _ocScore;
 }

 - (int)totalScore // get方法的实现
 {
     return _totalScore;
 }
 - (int)averageScore // get方法的实现
 {
     return _averageScore  ;
 }

 @end

 int main()
 {
     Score *sc = [Score new];

     int t = [sc _totalScore];
     int a = [sc _averageScore];

     NSLog("总分是%d,平均分是%d"，t， a);

     return ;
 }

封装练习

4> 封装的好处

　　*过滤不合理的值

　　*屏蔽内部的赋值过程

　　*让外部不必关注内部细节

二、继承

1.继承

通过继承，子类可以拥有父类中所有的成员变量和方法

 #import <Foundation.Foundation.h>

 @interface Animal : NSObject //声明一个Animal类，并且继承了NSObject
 {
     int _age; // 声明了两个成员变量
     double _weight;
 }
 - (void)setAge:(int)age; //声明set方法
 - (void)setWeight:(double)weight;
 - int)age;  //声明get方法
 - (double)weight;
 - (void)run；

 @implementation Animal //类的实现
 - (void)setAge:(int)age //set方法的实现
 {
     _age = age;
 }

 - (void)setWeight:(double)weight//set方法的实现
 {
     _weight = weight;
 }

 - int)age //get方法的实现
 {
     return _age;
 }

 - (double)weight //get方法的实现
 {
     return _weight;
 }

 - (void)run
 {
     NSLog(@"动物跑了起来");
 }
 @end

 @interface Dog : Animal //Dog继承了Animal里面所有的成员变量和方法

 @end

 @implementation Dog

 @end

 int main()
 {
     Dog *d = [Dog new];
     [d setAge:];
     [d setWeight:20.0];
     NSLog(@"%岁的狗，%d公斤"，[d age], [d weight]);

     return ;
 }

继承例子

2.重写

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

 #import <Foundation.Foundation.h>

 @interface Animal : NSObject //声明一个Animal类，并且继承了NSObject
 {
     int _age; // 声明了两个成员变量
     double _weight;
 }
 - (void)setAge:(int)age; //声明set方法
 - (void)setWeight:(double)weight;
 - int)age;  //声明get方法
 - (double)weight;
 - (void)run；

 @implementation Animal //类的实现
 - (void)setAge:(int)age //set方法的实现
 {
     _age = age;
 }

 - (void)setWeight:(double)weight//set方法的实现
 {
     _weight = weight;
 }

 - int)age //get方法的实现
 {
     return _age;
 }

 - (double)weight //get方法的实现
 {
     return _weight;
 }

 - (void)run
 {
     NSLog(@"动物跑了起来");
 }
 @end

 @interface Dog : Animal //Dog继承了Animal里面所有的成员变量和方法

 - (void)run;
 @end

 @implementation Dog
 - (void)run //重写父类run方法
 {
     NSLog(@"%岁，%d公斤的狗跑了起来"，[d age], [d weight]);
 }

 @end

 int main()
 {
     Dog *d = [Dog new];
     [d setAge:];
     [d setWeight:20.0];
     [d run];
     NSLog(@"%岁的狗，%d公斤"，[d age], [d weight]);

     return ;
 }

重写（例子）

3.super作用

1> 直接调用父类中的某个方法

2> super处在对象方法中，就调用父类的对象方法；super处在类方法中，就调用父类的类方法

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

4.使用注意

1> 父类必须声明在子类前面

2> 子类不能拥有和父类相同的成员变量

3> 调用某个方法时，优先去当前类中寻找，如果找不到，再去父类中寻找

4> oc语言是单继承

5.缺点

　　*耦合性太强，删除父类后，子类就不能够继续使用

6.好处

　　* 不改变原来模型的基础上，拓充方法

　　* 建立了类与类之间的联系

　　* 抽取了公共代码

7.使用场合

1> 当两个类拥有相同的属性和方法时，就可以将相同的东西抽取出到父类中

2> 当A类中拥有B类的部分属性和方法时，可以考虑让B类继承A类

3> 组合：xxx拥有xx; 继承：xxx是xx

三、多态

1.多态：多种形态

1> 没有继承就没有多态

2> 代码体现：父类类型指针指向子类对象

#import <Foundation.Foundation.h>

@interface Animal : NSObject
- (void)eat;
@end

@implementation Animal
- (void)eat
{
    NSlog（@"动物吃东西"）;
}
@end

@interface Dog : Animal
- (void)eat;
@end

@implementation Dog
- (void)eat
{
    NSlog（@"Dog吃东西"）;
}
@end

int main()
{
    //多种形态
    Dog *d = [Dog new];// Dog类型

    //多态;父类指针指向子类对象
    Animal *a = [Dog new];

    [a eat];//调用方法时，检测对象的真实类型

    rerurn ;
}

多态（例子）

2.优缺点

1> 好处：如果函数\方法的参数类型使用的父类类型，可以传入子类和父类对象

2> 局限性：父类类型变量不能够直接调用子类特有的方法（编译过程会有警告）。必须强转为子类类型便后后，才能够直接调用子类特有的方法。

四、自我总结

　　面向对象的三大特性是面向对象语言的精华所在。面向对象是基于万物皆对象这个哲学观点。把一个对象抽象成类，具体上就是把一个对象的静态特征和动态特征抽象成相应的属性和方法，也就是把一类事物的算法和数据结构封装在一个类之中，程序就是多个对象和互相之间的通信组成的。面向对象具有封装性，继承性，多态性，封装隐蔽了对象内部不需要暴露给外人的细节，使得内部细节的变动跟外界不相关，只单纯依靠提供的接口进行通信。封装性降低了编程的复杂，通过继承，使得新建一个类变得更加容易，一个类从父类那里获得其方法和属性的工作就交给了编译器。而继承、实现和运行时的类型绑定机制所产生的多态,使得不同的类所产生的对象能够对相同的消息作出不同的反应，这极大地提高了代码的通用性。言而总之，面向对象的三大特性大大提高了程序的重用性和可维护性。