封装
封装：即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合形成“类”，其中数据和函数都是类的成员。
为什么要进行封装？
比如一台洗衣机，我们在买回来的时候通上电，根据他对外的给我们展示的按钮我们去操作就可以了。我们可以连接开关（如：我们的app登录），选择功能转动点击搅拌衣服
@interface** BaseModel : NSObject
{
@public
int _testNum;
}
@end
// 对于公共的属性以及外界的赋值，我们是不可控，可能会有其他的数据，而这个时候我们可以用封装来解决，我们可以隐藏这些属性然后提供对外的接口。
类其实就是对于数据和功能的封装，而在开发的时候我们对于一些功能，写一些功能类，功能接口及方便我们再开发的时候进行调用。而里面的设计是无法修改，这样就可以减少误用的可能，从而提高代码的灵活性及效率
封装的目的：达到高内聚低耦合
内聚：模块内部各部分之间的关系。
耦合：模块与模块之间的关联程度。
内聚和耦合有一个条件改变，必然导致另一个条件改变。（耦合低了内聚必然增高）
- 可见度修饰符 类的内部 子类
- @public 可以直接访问 可以直接访问
- @protect 可以直接访问 可以直接访问
- @private 可以直接访问 不可以直接访问
系统默认的实例变量可见度修饰符：@protect
public修饰的实例变量虽然可以在类的内部和外部直接访问，但他破坏了类的封装思想所以建议不要使用.
继承
继承是面向对象软件技术当中的一个概念，与多态、封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。
OC中的继承关系：
在OC中建立继承关系后，子类就可以继承父类。
- 实例变量 @public @protected @pricate（只是不能直接访问）。
- 公开的方法（写在父类的。h文件的方法）
- Oc是单继承，一个类只有一个父类，但一个父类可以有多个子类。
- Oc中的继承是单根类继承：所有类的基类都是NSobject，他是所有类的根类或者说基类。
子类可以调用父类的在.h中的公开方法
子类在调用方法的时候优先在自己的类中寻找有没有实现这个方法，如果没有就去父类中去查证有没有实现...一直到NSobject中，其中有一个实现就去停止寻找。
多态
多态：指为不同数据类型的实体提供统一的接口。 多态类型（英语：polymorphic type）可以将自身所支持的操作套用到其它类型的值上。
- 没有继承就没有多态
- 在使用多态时，会进行动态检测，以调用真实的对象方法.
- 多态在代码中的体现即父类指针指向子类对象。
- 如果方法参数使用父类类型，则可以传入父类子类对象，不需要定义多个对象方法进行匹配。
- 父类对象不能调用子类方法，如果其对象指向子类创建的地址，这个时候需要进行强制转换即可。
多态对于面向对象思想来说，个人感觉是真的很重要，他对以后的编写代码的优雅方式也是起到很重要的作用，其实现在很多设计模式中大部分都是用到了多态的特性。
例如：
动物类：
NS_ASSUME_NONNULL_BEGIN
#import <Foundation/Foundation.h>
@interface Animal : NSObject
- (void)eat;
@end
NS_ASSUME_NONNULL_END
#import "Animal.h"
**@implementation** Animal
- (**void**)eat{
NSLog(@"动物吃东西");
}
**@end**
狗类：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
**@interface** Dog : NSObject
- (**void**)eat;
**@end**
NS_ASSUME_NONNULL_END
#import "Dog.h"
**@implementation** Dog
- (**void**)eat{
NSLog(@"狗吃东西");
}
**@end**
猫类：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
**@interface** Cat : NSObject
- (**void**)eat;
**@end**
NS_ASSUME_NONNULL_END
#import "Cat.h"
**@implementation** Cat
- (**void**)eat{
NSLog(@"猫吃东西");
}
**@end**
People类：
#import <Foundation/Foundation.h>
#import "Animal.h"
NS_ASSUME_NONNULL_BEGIN
**@interface** People : NSObject
- (**void**)doAnimal:(Animal *)eat;
**@end**
NS_ASSUME_NONNULL_END
#import "People.h"
**@implementation** People
- (**void**)doAnimal:(Animal *)eat {
[eat eat];
}
**@end**
代码测试：
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import "People.h"
#import "Animal.h"
#import "Dog.h"
#import "Cat.h"
\
**int** main(**int** argc, **char** * argv[]) {
**@autoreleasepool** {
People *people = [[People alloc] init];
Dog *dog = [[Dog alloc] init];
Cat *cat = [[Cat alloc] init];
[people doAnimal:cat];
[people doAnimal:dog];
}
**return** 0;
}
多态的好处
people 类根据相应的类创建对象调用内部方法这个时候对其两个进行操作这个时候如果用多态的话我们就可以直接通过其父类调用他的方法。
Animal *p1 = [[Dog alloc] init];
Animal *p2 = [[Cat alloc] init];
[people doAnimal:p1];
[people doAnimal:p2];
我们只需要把函数的参数写成是Animal 类型的，那么我们直接就可以传进去，调用的时候自动强转就可以了。
多态的局限性
父类类型的指针变量不能直接调用子类特有的方法。
如果父类里面没有相同的方法的时候，根据继承的特性，父类是无法调用子类的方法的，如果继续按照上述的写法，调用子类的方法的话必须进行强制转换
Animal *a = [[Dog alloc] init];
[a run]; //在Animal类中没有run方法
解决方法：对对象a 进行强制转换
Dog *d = (Dog *)a; //使用强制转换，这里a和d指向的是同一个狗对象
