面向对象的三大特性
- 封装
- 继承
- 多态
其实抽象也是面向对象的一大特性
面向过程和面向对象
一、面向过程和面向对象思想的区别：
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类型数据]
137
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
