IOS开发学习笔记010-面向对象的三大特性

面向对象的三大特性

　　1、封装

　　2、继承

　　3、多态

一、封装

将类内部的属性保护起来，在外部不能直接访问，那么如果需要访问怎么办呢？

OC提供了set方法来对成员变量进行访问

set方法

1、作用：提供一个方法给外界设置age属性的值

2、命名规范

　　方法名必须是set开头

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

　　返回值一定是void

　　一定要接收一个参数，并且和成员变量类型一致

　　 形参名不能和成员变量名一样

声明

- (void)setAge:(int)newAge;//声明

实现

 - (void)setAge:(int)newAge//set方法实现
 {
     if(newAge <= )//如果小于0岁就赋值为1
     {
         newAge = ;
     }
     age = newAge;//设置年龄
 }

使用

  Student *p = [Student new];//新建对象
  [p setAge:];//设置属性
  [p study];//调用方法

get方法

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

2、命名规范：

肯定有返回值，返回类型和成员变量一致

方法名和成员变量名一样

不需要接收参数

声明

- (int)age;//

实现

 - (int)age//
 {
     return age;
 }

使用

  NSLog(@"%d岁的学生在学习！",[p age]);

成员变量的使用

命名规范：

　　成员变量都以下划线 _ 开头

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

　　可以跟其他局部变量区分开，一看到下划线开头的变量，肯定是成员变量

 @interface Student : NSObject
 {
     //@public
     //成员变量
     //让成员变量和get方法区分开，成员变量都要加_
     int _no;
     int _age;
     Sex _sex;
 }

 @end

练习1

 #import <Foundation/Foundation.h>

 //成绩类
 /*
     C成绩（读写）
     OC成绩（读写）
     平均分（只读）
     总分（只读）
  */
 //类的声明
 @interface Score : NSObject
 {
     int _cScore;//c成绩
     int _ocScore;//oc成绩

     int _totalScore;//总分
     int _averageScore;//平均分
 }

 //方法声明
 //set
 - (void)setCScore:(int)newCScore;
 - (void)setOcScore:(int)newOcScore;

 //get
 - (int)cScore;
 - (int)ocScore;
 - (int)totalScore;
 - (int)averageScore;

 @end

 //类的实现
 @implementation Score
 //方法实现
 - (void)setCScore:(int)newCScore
 {
     _cScore = newCScore;
     //计算总分和平均分
     _totalScore = _cScore + _ocScore;
     _averageScore = _totalScore/;
 }
 - (void)setOcScore:(int)newOcScore
 {
     _ocScore = newOcScore;
     //计算总分和平均分
     _totalScore = _cScore + _ocScore;
     _averageScore = _totalScore/;
 }

 - (int)cScore
 {
     return _cScore;
 }
 - (int)ocScore
 {
     return _ocScore;
 }
 - (int)totalScore
 {
     return _totalScore;
 }
 - (int)averageScore
 {
     return _averageScore;
 }
 @end

 int main()
 {
     Score *p = [Score new];//新建对象
     [p setCScore:];//set方法
     [p setOcScore:];//set方法

     NSLog(@"总分：%d",[p totalScore]);

     NSLog(@"平均分：%d",[p averageScore]);

     return ;
 }

OC弱语法

如果调用不存在的方法，那么在编译和链接时都不会报错，最多有一个警告。只有在运行时才回出错。

unrecognized selector sent to instance 0x0000034034C0

给对象发送的消息不能识别

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

类方法

1、以+开头

2、通过类名调用的方法。

3、类方法不能访问成员变量

4、类方法和对象方法可以重名

5、使用场合：当不需要访问成员变量时尽量用类方法

声明

+ (void)printClassName;//

实现

 + (void)printClassName//
 {
     NSLog(@"class name is Person");
 }

使用

 [Person printClassName];//类方法的调用，直接使用类名

工具类

没有成员变量的类，里面的方法全是类方法。

示例

 #import <Foundation/Foundation.h>
 /*
 工具类
     没有成员变量
     所有方法全是类方法
  */
 //类声明
 @interface JiSuanQi : NSObject

 + (void)printClassName;//类方法

 + (int)sumOfSum1:(int)sum1 andSum2:(int)sum2;//类方法

 @end
 //类的实现
 @implementation JiSuanQi
 + (void)printClassName
 {
     NSLog(@"class name is JiSuanQi");

 }
 + (int)sumOfSum1:(int)sum1 andSum2:(int)sum2
 {
     return sum1 + sum2;
 }

 @end

 int main()
 {

     [JiSuanQi printClassName];//类方法的调用，直接使用类名
     int res = [JiSuanQi sumOfSum1: andSum2:];
     NSLog(@"%d",res);
     return ;
 }

self关键字

谁调用，self代表谁。

如果用对象调用，就代表对象，如果是类调用，就代表类。

成员变量和局部变量同名

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

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

self出现的位置：

　　所有的OC方法中（对象方法\类方法），不能出现在函数

作用方式：

　　使用 "self->成员变量名" 访问当前方法调用的成员变量

　　使用 "[self 方法名];" 来调用方法（对象方法\类方法）

 - (void)setAge:(int)newAge
 {
     _age = newAge;

     int _age = ;//局部变量与成员变量同名时，如果需要使用成员变量，则需要使用self关键字
     NSLog(@"age is %d",self->_age);//self 是一个指指针，指向调用的对象
 }

 小练习

　　设计Car类，一个对象方法跟其他车子比较车速，返回速度差，一个类方法比较两辆车的车速，返回速度差

 #import <Foundation/Foundation.h>

 //类的声明
 @interface Car : NSObject
 {
     int _speed;//速度
 }
 - (void)setSpeed:(int)newSpeed;
 - (int)speed;
 //对象方法
 /*
 作用：比较两辆车的速度大小，返回差值
 方法名：differenceSpeedWithOtherCar:
 参数：(Car *)otherCar
 返回值：int
  */
 - (int)differenceSpeedWithOtherCar:(Car *)otherCar;

 //类方法
 /*
  作用：比较两辆车的速度大小，返回差值
  方法名：differenceSpeedWithCar1: :
  参数：(Car *)Car1 (Car *)Car2
  返回值：int
  */
 + (int)differenceSpeedWithCar1:(Car *)Car1 andCar2:(Car *)Car2;
 @end

 //类的实现
 @implementation Car
 //对象方法的实现
 - (void)setSpeed:(int)newSpeed
 {
     _speed = newSpeed;
 }

 - (int)speed
 {
     return _speed;
 }

 //对象方法
 - (int)differenceSpeedWithOtherCar:(Car *)otherCar
 {
     return [self speed] - [otherCar speed];//self指向调用者也就是本对象
 }

 //类方法

 + (int)differenceSpeedWithCar1:(Car *)Car1 andCar2:(Car *)Car2;
 {
     return [Car1 speed] - [Car2 speed];//通过类调用的话，只能传进来两个参数，因为默认成员变量是0，没有任何实际意义。
 }

 @end

 int main()
 {
     Car *p1 = [Car new];
     [p1 setSpeed:];

     Car *p2 = [Car new];
     [p2 setSpeed:];

     Car *p3 = [Car new];
     [p3 setSpeed:];

     int  res = [p1 differenceSpeedWithOtherCar:p2];//使用对象调用方法
     NSLog(@"%d",res);

     res = [Car differenceSpeedWithCar1:p1 andCar2:p3];//使用类调用方法
     NSLog(@"%d",res);
     return ;
 }

二、继承

子类从父类继承一些公共属性和方法。

不允许子类和父类拥有同名的成员变量。

方法可以和父类的方法同名（重写），调用过程是先找子类的，再找父类的。

继承的使用场合

　　1、当两个类拥有相同的属性和方法时，可以将相同的东西抽象到一个类中

　　2、当类a中含有类B所需的全部或部分属性和方法时，可以让B继承A

继承与组合区别

　　继承:A 是 B;

　　组合:A 拥有B；

示例

 #import <Foundation/Foundation.h>

 //Animal类的声明
 @interface Animal : NSObject
 {
     int _age;//年龄
     double _weight;//体重
 }
 //对象方法
 - (void)setAge:(int)newAge;
 - (int)age;

 - (void)setWeight:(int)newWeight;
 - (double)weight;

 - (void)run;
 @end

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

 - (void)setWeight:(int)newWeight
 {
     _weight = newWeight;
 }
 - (double)weight
 {
     return _weight;
 }

 - (void)run
 {
     NSLog(@"动物在奔跑！");
 }

 @end

 //Dog类的声明
 @interface Dog : Animal
 {
     //int _age;//子类不能和父类的成员变量重名
     int gouPai;//狗牌
 }
 //对象方法
 - (void)run;//重写父类的方法
 @end

 //Dog类的实现
 @implementation Dog
 //方法实现
 - (void)run
 {
     NSLog(@"Dog在奔跑！");
 }

 @end

 //Cat类的声明
 @interface Cat : Animal
 {

 }
 //对象方法

 @end

 //Cat类的实现
 @implementation Cat
 //方法实现

 @end

 int main()
 {
     Dog *d = [Dog new];
     [d setAge:];
     [d run];//子类的run会覆盖父类的run方法
     NSLog(@"%d",[d age]);

     return ;
 }

super关键字

如果在子类中想访问父类的方法(对象方法和类方法都可以)，可以使用关键字super进行调用 ;　　

[super walk];//具体是对象方法还是类方法取决于调用时所处于的环境。

使用场景：子类使用父类的方法时想保留父类的一些操作

 //方法实现
 - (void)run
 {
     NSLog(@"Dog在奔跑！");

     [super run];//super 关键字，调用父类的方法
 }

三、多态

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

1、没有继承就没有多态

2、父指针指向子类对象

3、优点：函数/方法传入父指针，则在调用时可以传入子类指针和父类指针

4、缺点：父类类型的变量，不能直接调用子类特有的方法

代码示例

 #import <Foundation/Foundation.h>
 /*
 多态

  */

 //Animal类的声明
 @interface Animal : NSObject
 {
    // int _age;//年龄
     //double _weight;//体重
 }
 //对象方法

 - (void)eat;
 @end

 //Animal类的实现
 @implementation Animal
 //方法实现
 - (void)eat
 {
     NSLog(@"吃吃吃！");
 }

 @end

 //Dog类的声明
 @interface Dog : Animal
 {
     //int _age;//子类不能和父类的成员变量重名
     //int gouPai;//狗牌
 }
 //对象方法
 - (void)eat;//重写父类的方法
 @end

 //Dog类的实现
 @implementation Dog
 //方法实现
 - (void)eat
 {
     NSLog(@"Dog在吃吃吃！");

    // [super eat];//super 关键字，调用父类的方法
 }

 @end

 //Cat类的声明
 @interface Cat : Animal
 {
     //int _age;//子类不能和父类的成员变量重名
     //int gouPai;//狗牌
 }
 //对象方法
 - (void)eat;//重写父类的方法
 - (void)run;
 @end

 //Dog类的实现
 @implementation Cat
 //方法实现
 - (void)eat
 {
     NSLog(@"Cat在吃吃吃！");

     // [super eat];//super 关键字，调用父类的方法
 }
 - (void)run
 {
       NSLog(@"Cat在跑！");
 }
 @end

 int main()
 {
     //Dog *d = [Dog new];

     //父类指针指向子类对象：多态
     Animal *a = [Dog new];
     //[a run];//父类指针调用子类的特有方法，会有警告

     Dog *d = (Dog *)a;//可以强制转换，调用子类特有的方法
     [d eat];

     return ;
 }