面向对象的三大特性: 封装， 继承， 多态

1. 封装

1.1 基本概念

将零散的东西组合起来。

• 广义上封装指：将代码封装成函数，将实例变量和方法封装成类，将类封装成框架....
• 面向对象中的封装指：封装属性和方法放在一个对象中，只给外界公开访问的接口，而且把具体实现隐藏起来。

1.2 封装的好处

提高可读性，可维护性，可扩展性

1.3 OC中的封装

OC语言天然就是封装好的。

定义一个类时,@interface部分就是给外界公开的访问接口。@implementation部分就是隐藏起来的具体实现。

.h文件中写的是公开的接口

.m文件中写的是隐藏的实现

//私有方法,只要不在头文件的接口部分声明的方法就是私有方法

2. 继承

2.1 概念

继承是一种代码复用技术(代码重复使用)。是类与类之间的一种关系(“is a”关系)。

B类继承了A类。A类叫B类的父类，B类叫A类的子类。

其他语言中还有基类，派生类的概念

2.2 继承的方式

　　　　单继承  OC, Java...., Swift　　　　单继承指一个类只能有一个父类.

　　　　多继承  C++支持多继承　　　　　　多继承指一个类可以有多个父类.

　　　　OC语言中的类在一颗树上，只有一个祖宗NSObject; swift不只有一颗树，是一片森林。

2.3 OC中继承的语法

@interface 类名 : 父类名

@end

2.4 什么情况下用继承

理论上：

　　　　　　如果两个类之间拥有is a关系,这两个类应该是继承关系。

　　狗是动物  Dog is a Animal.

　　　　　　　 Animal是父类， Dog是子类

　　　　　　如果两个类之间拥有has a关系，应该用组合或聚合

　　计算中有一个CPU  Computer has a CPU

　　组合和聚合是另一种类与类之间的关系

实际开发中使用继承:

先写的父类，还是先写的子类？//都可以

2.5 抽象类

C++: 纯虚函数,没有函数体的函数。存在纯虚函数的类是抽象类，不可以实例化了对象。

Java: 抽象方法和抽象类, abstract来声明

OC： OC语言中没有抽象类和抽象方法的语法。

派生:在子类中添加新的属性和方法

2.6 重写：子类对父类的方法不满意时,可重写父类中的方法

           隐藏：当子类重写父类的方法后,子类中将有两个同名的方法,而从父类中继承的方法不能在类外被调用

2.6.1 概念

1) override 重写(覆盖): 子类不满意从父类中继承来的方法，重新将此方法实现了。

要求:方法名和父类一样,参数类型一样,返回值一样。只有方法的实现不一样。

2) overload 重载: OC中并不存在overload。

overload的概念是在一个范围内(比如一个类中)，出现多个方法名相同的方法，这些方法的参数类型不同，导致可以同时出现，我们说，这些方法之间形成了重载的关系。

OC中不允许同一个范围存在多个方法名相同的方法。

-(id)initWithName:(NSString *)name andAge:(NSUInteger)age;

-(id)initWithName:(NSString *)name andGender:(BOOL)gender; //OC中方法名不同

OC中只有重写，没有重载

方法的重写：子类对父类继承的方法不满意，可以在子类中重写父类的方法。

如果重写父类的方法，优先调用子类的方法，如果子类没有重写父类的方法，则调用父类的方法。

2.6.2 注意

虽然父类中的属性是公开的,但生成的实例变量却是私有的,在子类中不能访问

2.6.3 普通方法的重写

如同perimeter, area, show

方法名相同,参数类型相同,返回值相同

2.6.4 属性的重写

如同TRSqaure中的width,height属性

2.6.5 特殊方法的继承和重写

1) 初始化方法

在OC中初始化方法是会被继承的。

继承来的初始化方法有些可以用，有些不能用。

如果在子类中，继承自父类的初始化方法不能用(不能完成要求的初始化任务)，在子类中就需要重写这个初始化方法。

2) 类方法(工厂方法)

类方法也可以被继承

工厂方法自然也可以被继承,但直接继承的工厂方法名不匹配，实际开发中很少这样用。子类最好提供自己的工厂方法。

2.7 继承的缺陷

　　1) 提高了程序的复杂度，维护性和扩展性降低。 

　　2) 破坏类的封装性  慎用继承！

2.8 为什么使用继承？

　　1) 代码复用 

　　　　将子类重复的代码抽象到父类中

　　2) 制定规范（规则）

　　　　NSObject  

　　3) 为了多态

　　　　没有继承，就没有多态

组合与聚合

　　类与类之间的一种关系，比较常见；主要作用：代码复用！

1.1 什么是组合

　　表示两个对象之间是整体和部分的强关系，是“contains(包含) a”关系，要求两个类同生共死。

生命周期完全一致，同生共死。部分的生命周期不能超越整体！

例如：一个窗口内有按钮、标签，当窗口关闭时，窗口与按钮、标签同时销毁。

1.2 组合的定义：

　　组合Demo：

1.3 组合的优缺点：

优点：

1）当前对象只能通过所包含的那个对象去调用其方法，所以所包含的对象的内部细节对当前对象是不可见的。

2）当前对象与包含的对象是一个低耦合关系，如果修改包含对象的类中代码，不需要修改当前对象类的代码。

3）当前对象可以在运行时动态的绑定所包含的对象。可以通过set方法给所包含对象赋值。

缺点：

容易产生过多的对象

为了能组合多个对象，必须仔细对接口进行定义。

1.4 什么是聚合

表示两个对象之间是整体和部分的弱关系，是”has a”关系，不要求两个类同生共死。

生命周期不一致，一个类无法控制另一个类的生死。部分的生命周期可以超越整体。

例如：电脑和鼠标，电脑被销毁时，鼠标可以留下在其他电脑上继续使用。

1.5 聚合的定义

　　聚合Demo：

1.6 聚合的优缺点：

优点：

1）被包含的对象通过包含它们的类来访问

2）很好的封装

3）被包含的对象内部细节不可见

4）可以在运行时动态定义聚合的方式

缺点：

1）系统可能会包含太多对象

2）当使用不同的对象时，必须小心定义的接口。

组合和聚合的生命周期不一样，组合是同生共死（关系紧密）；聚合没有特别的关系。

1.7  类与类之间常见的三种关系：继承、组合、聚合

　　1） 继承（继承的主要目的：代码复用，制定规范，为了多态）  慎用继承！（is a关系才用继承，否则滥用继承）

　　2） 组合和聚合（单纯的为了代码复用）

        　　组合和聚合的主要目的：是为了代码的复用。

应用场景：（代码的重复使用。如果想使用别人的代码，组合、聚合在一起就可以了）

实际开发中,如果为了复用代码,提倡使用组合或聚合来复用,而不用继承。即是把一个类作为另一个类的属性。(整体与部分)

一个类想使用另一个类的方法？怎么实现...

1.继承：我继承你，我就可以直接调你的方法（提高程序的复杂度…不建议用!）

2.组合/聚合：把你变成我的一部分（即你是我的属性），我可以通过访问你去调用你的方法！[我.你 你的方法];

组合：关系很紧密，同生共死。（cpu焊在主板上，主板坏了cpu也就坏了；绑在一起同生共死！）

聚合：关系很疏远，不同生共死。（计算机是计算机，cpu是cpu；这个cpu可以用给这个计算机，也可以用给那个计算机，cpu可以从主板上拔下来给另一个计算机用）

3. 多态（Polymorphism）

3.1 什么是多态

多种形态，引用的多种形态。对于一个引用变量，可以指向任何类的对象 （一个对外接口，多个内在实现）

　　　　父类的引用指向本类或任何子类的对象，会调用不同的方法（表现出多种形态，这种表现叫多态）

　　 多态的表现：同一个引用变量s，调用相同的方法（show），显示不同的结果。

3.2 编译期类型和运行期类型

编译器编译时，引用的类型叫编译期类型。

程序运行时，引用指向的类型叫运行期类型。

　　程序编译时按编译期类型找方法编译，程序运行时按运行期类型找方法调用。

　　父类的引用指向子类的对象时，只能调用父类中有的方法。

　　因为编译器在编译时是按父类来检查的，虽然运行时调用的是子类的方法，但是编译时是按父类来检查的。

3.3 为什么用多态

为什么用父类的引用指向子类的对象：

为了写出更加能用（通用），兼容性更好的代码。

3.4 多态的各种表现【用途】

1）【参数多态】经常在方法的参数表现多态：参数类型使用父类型，可以传任何子类的对象

NSObject *和id类型做为方法的参数区别在于：

NSObject *类型的引用只能调用NSObject类中有的方法。

id类型的引用可以调用任何存在(不能瞎写)的方法。

（一般不用NSObject *类型，用id类型替代。id有风险的，编译器根本不检查对错）

　　2）【返回值多态】方法的返回值上表现多态

3）【数组多态】在数组和集合中表现的多态

　多态无处不在！

多态Demo