OutMan——面向对象的三大特性、对象和对象之间的关系以及动态类型检测方法

面向对象的三大特性

封装
继承
多态

其实抽象也是面向对象的一大特性

面向过程和面向对象

一、面向过程和面向对象思想的区别：
1.面向过程关注的是解决问题需要哪些步骤
2.面向对象关注的是解决问题需要哪些对象

二、常用术语
1. 面向过程 Procedure Oriented
2. 面向对象 Object Oriented 简称: OO
3. 面向对象编程 Object Oriented Programming 简称: OOP

封装

一、封装的好处
1. 保护数据的安全
2. 隐藏复杂内容
3. 隔离变化（底层怎么变化不显示给用户）

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

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

三、封装练习
设计一个成绩类，c语言成绩可读可写，oc成绩可读可写，总分只读，平均分只读
（1）Score类的设计
Score.h文件


#import <Foundation/Foundation.h>@interface Score : NSObject
{// c语言成绩float _cScore;// oc语言成绩float _ocScore;// 总成绩float _totalScore;// 平均成绩float _avgScore;
}// c成绩的setter和getter声明
- (void)setCScore:(float)cScore;
- (float)cScore;// oc成绩的setter和getter声明
- (void)setOcScore:(float)ocScore;
- (float)ocScore;// 总成绩的getter声明
- (float)totalScore;// 平均成绩的getter声明
- (float)avgScore;@end

Score.m文件


#import "Score.h"@implementation Score
// c成绩的setter和getter实现
- (void)setCScore:(float)cScore
{_cScore = cScore;// 计算总分_totalScore = _cScore + _ocScore;// 计算平均分_avgScore = _totalScore / 2;
}
- (float)cScore
{return _cScore;
}// oc成绩的setter和getter实现
- (void)setOcScore:(float)ocScore
{_ocScore = ocScore;// 计算总分_totalScore = _cScore + _ocScore;// 计算平均分_avgScore = _totalScore / 2;}
- (float)ocScore
{return _ocScore;
}// 总成绩的getter实现
- (float)totalScore
{return _totalScore;
}// 平均成绩的getter实现
- (float)avgScore
{return _avgScore;
}@end

（2）main.m文件

继承

一、继承的优缺点
继承的优点：
1. 抽取重复的代码
2. 建立了类与类之间的关系
3. 子类可以拥有父类的所用成员变量和方法
继承的缺点：
1. 耦合性太强

二、继承的使用注意
1. 重写：子类重新实现父类中的某个方法，会覆盖父类以前的方法
2. 子类不能拥有和父类相同的成员变量
3. 调用某个方法时，优先去当前类中找，如果找不到再去父类中找
4. 父类必须声明在子类前面

三、继承的练习
设计一个动物类，拥有速度和体重两个成员变量，吃和跑两个方法，设计一个狗类，拥有速度和体重两个成员变量，吃、跑和叫三个方法
（1）Animal类的设计
Animal.h文件


#import <Foundation/Foundation.h>@interface Animal : NSObject
{// 速度int _speed;// 体重float _weight;
}// 速度的setter和getter的声明
- (void)setSpeed:(int)speed;
- (int)speed;// 体重的setter和getter的声明
- (void)setWeight:(float)weight;
- (float)weight;// 跑方法的声明
- (void)run;// 吃方法的声明
- (void)eat;@end

Animal.m文件


#import "Animal.h"@implementation Animal
// 速度的setter和getter的声明
- (void)setSpeed:(int)speed
{_speed = speed;
}
- (int)speed
{return _speed;
}// 体重的setter和getter的声明
- (void)setWeight:(float)weight
{_weight = weight;
}
- (float)weight
{return _weight;
}// 跑方法的实现
- (void)run
{NSLog(@"动物在以每小时%d米的速度狂奔", self.speed);
}// 吃方法的实现
- (void)eat
{NSLog(@"动物体重已经%.2f斤了还在吃", self.weight);
}
@end

（2）Dog类的设计
Dog.h文件


#import "Animal.h"@interface Dog : Animal
// 叫的方法声明
- (void)bark;
@end

Dog.m文件


#import "Dog.h"@implementation Dog
// 叫的方法实现
- (void)bark
{NSLog(@"狗在叫");
}
// 重写父类跑方法
- (void)run
{NSLog(@"狗在以每小时%d米的速度狂奔", self.speed);
}// 重写父类吃方法
- (void)eat
{NSLog(@"狗体重已经%.2f斤了还在吃", self.weight);
}
@end

（3）main.m

组合模式

组合模式的定义：把具有相同基类的对象组合到树形结构中，以表示“部分—整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性

依赖关系

A对象作为B对象的局部变量或是方法形参的，B依赖于A，这时候我们成为A与B之间存在一种依赖关系。

面向对象设计中：
耦合度：当修改一个对象的时候，对另外一个对象的影响程度
低耦合：当修改一个对象的时候，对其他对象的影响比较小
高内聚：一个对象仅仅做自己相关的事情

例：美女用手机给土豪打电话

- (void)callPhoneToTuHao:(IPhone *)iphone;

关系：美女对象依赖于手机对象

关联关系

关联关系（HasA关系）：当一个对象拥有另外一个对象的时候，当B对象为A对象的成员变量的时候，B对象与A对象之间存在一种关联关系

多态

一、多态的好处
1. 多态的主要好处就是简化了编程接口（它容许类与类之间重用一些习惯性的命名）

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

三、多态的简单总结
1. 没有继承就没有多态
2. 代码的体现：父类类型的指针指向子类对象

四、多态的简单实现
（1）Animal类的设计
Animal.h文件


#import <Foundation/Foundation.h>@interface Animal : NSObject
{// 速度int _speed;// 体重float _weight;
}// 速度的setter和getter的声明
- (void)setSpeed:(int)speed;
- (int)speed;// 体重的setter和getter的声明
- (void)setWeight:(float)weight;
- (float)weight;// 跑方法的声明
- (void)run;// 吃方法的声明
- (void)eat;@end

Animal.m文件


#import "Animal.h"@implementation Animal
// 速度的setter和getter的声明
- (void)setSpeed:(int)speed
{_speed = speed;
}
- (int)speed
{return _speed;
}// 体重的setter和getter的声明
- (void)setWeight:(float)weight
{_weight = weight;
}
- (float)weight
{return _weight;
}// 跑方法的实现
- (void)run
{NSLog(@"动物在以每小时%d米的速度狂奔", self.speed);
}// 吃方法的实现
- (void)eat
{NSLog(@"动物体重已经%.2f斤了还在吃", self.weight);
}
@end

（2）Dog类的设计
Dog.h文件


#import "Animal.h"@interface Dog : Animal
// 叫的方法声明
- (void)bark;
@end

Dog.m文件


#import "Dog.h"@implementation Dog
// 叫的方法实现
- (void)bark
{NSLog(@"狗在叫");
}
// 重写父类跑方法
- (void)run
{NSLog(@"狗在以每小时%d米的速度狂奔", self.speed);
}// 重写父类吃方法
- (void)eat
{NSLog(@"狗体重已经%.2f斤了还在吃", self.weight);
}
@end

（3）main.m文件

动态绑定和动态类型检测方法

一、动态绑定
在objective-c中，一个对象是否能调用指定方法，不是由编译器决定的，而是由运行时决定的，这被称作是方法的动态绑定

二、动态类型检测方法
对象在运行时获取其类型的能力称为内省，内省可以有种方法来实现

（1）判断一个对象是否为某个类或子类的实例对象

- (BOOL)isKindOfClass:(Class)aClass;

调用格式： [对象 isKindOfClass:类对象]

（2）判断一个对象是否为某个类的实例对象

- (BOOL)isMemberOfClass:(Class)aClass;

调用格式： [对象 isMemberOfClass:类对象]

（3）判断一个类某个类是否为另一个类的子类

+ (BOOL)isSubclassOfClass:(Class)aClass;

调用格式： [类名/类对象 isSubclassOfClass:类对象]

（4）判断一个对象能否响应某个方法

- (BOOL)respondsToSelector:(SEL)aSelector;

调用格式： [对象 respondsToSelector:SEL类型数据]

（5）判断一个类是否有某个方法

+ (BOOL)instancesRespondToSelector:(SEL)aSelector;

调用格式： [类名/类对象 instancesRespondToSelector:SEL类型数据]

—— 如果您有不同的见解，请随时指出，期待与您的交流！——