OC面向对象三大特征总结

面向对象的三大特征：

简单的说，类就是对象的模型，而对象就是类的一个实例。类是一种逻辑结构，而对象是真正存在的物理实体。面向对象的分析过程大致可分为：划分对象->抽象类->将类组织成为层次化结构（通过继承来完成）。面向对象的程序设计就是使用类与实例进行设计和实现程序。面向对象的三个基本特征就是：封装、继承和多态。

1、封装：

封装就是把客观事物封装成抽象的类。在创建一个类时，你要指定组成这个类的代码和数据。这些数据称为成员变量（或实例变量），这些代码称为方法。在编程语言的角度，封装就是把类的数据和方法只让可信的类或者对象操作，对不可信的类进行信息隐蔽。另外，通过接口，类隐蔽了其中的属性和方法的具体实现。比如，一个汽车类可以有启动、停止、加速等方法。、，作为驾驶员，你并不需要关心汽车方法的具体实现，而只是使用相关的方法即可。

set方法和get方法的使用场合：
@public的成员可以被随意赋值，应该使用set方法和get方法来管理成员的访问（类似机场的安检、水龙头过滤，过滤掉不合理的东西），比如僵尸的生命值不能为负数
set方法：
1) 作用：用来设置成员变量，可以在方法里面过滤掉一些不合理的值
2) 命名规范：
方法都是以set开头，而且后面跟上成员变量名，成员变量名的首字母必须大写
形参名称不要跟成员变量同名
get方法：
1) 作用：返回对象内部的成员变量
2) 命名规范：get方法的名称一般就跟成员变量同名
4. 成员变量的命名规范
成员变量都以下划线 _ 开头
可以跟get方法的名称区分开
可以跟其他局部变量区分开，一看到下划线开头的变量，肯定是成员变量

例如以下例子：

#import <Foundation/Foundation.h>@interface Student : NSObject{    // 成员变量尽量不要用@public    // @public    int age;        //@public    // 只读（readonly）：只允许外界访问我的no，不允许外界修改我的no    int no; // 只需要提供get方法}///* set方法 1.作用： 提供一个方法给外界设置成员变量值，可以在方法里面对参数进行相应过滤 2.命名规范： 1> 方法名必须以set开头 2> set后面跟上成员变量的名称，成员变量的首字母必须大写 3> 返回值一定是void 4> 一定要接收一个参数，而且参数类型跟成员变量类型一致 5> 形参的名称不能跟成员变量名一样 */- (void)setAge:(int)newAge;/* get方法 1.作用：返回对象内部的成员变量 2.命名规范： 1> 肯定有返回值，返回值类型肯定与成员变量类型一致 2> 方法名跟成员变量名一样 3> 不需要接收任何参数 */- (int)age;- (void)study;@end@implementation Student// set方法的实现- (void)setAge:(int)newAge{    // 对传进来的参数进行过滤    if (newAge <= 0)    {        newAge = 1;    }        age = newAge;}- (int)age{    return age;}- (void)study{    NSLog(@"%d岁的学生在学习", age);}@endint main(){    Student *stu = [Student new];    //stu->age = -10;        //stu->age = 10;        [stu setAge:10];            NSLog(@"学生的年龄是%d岁", [stu age]);        //[stu study];            return 0;}

对于封装的理解的实例：

/* 设计一个成绩类 * C语言成绩（可读可写） * OC成绩（可读可写） * 总分（只读） * 平均分（只读）*/#import <Foundation/Foundation.h>@interface Score : NSObject{    int _cScore; // C语言成绩    int _ocScore; // OC成绩        int _totalScore;// 总分    int _averageScoe; // 平均分}- (void)setCScore:(int)cScore;- (int)cScore;- (void)setOcScore:(int)ocScore;- (int)ocScore;- (int)totalScore;- (int)averageScore;@end@implementation Score- (void)setCScore:(int)cScore{    _cScore = cScore;        // 计算总分    _totalScore = _cScore + _ocScore;    _averageScoe = _totalScore/2;}- (int)cScore{    return _cScore;}- (void)setOcScore:(int)ocScore{    _ocScore = ocScore;        // 计算总分    _totalScore = _cScore + _ocScore;    _averageScoe = _totalScore/2;}// 监听成员变量的改变- (int)ocScore{    return _ocScore;}- (int)totalScore{    return _totalScore;}- (int)averageScore{    return _averageScoe;}@endint main(){    Score *s = [Score new];        [s setCScore:90];    [s setOcScore:100];        [s setCScore:80];            int a = [s totalScore];        NSLog(@"总分：%d", a);        return 0;}

封装的好处：
过滤不合理的值
屏蔽内部的赋值过程
让外界不必关注内部的细节

对于OC弱语法的体现：

#import <Foundation/Foundation.h>// 尽管编译器容错能力比较，但是写代码必须规范@interface Person : NSObject- (void)test;@end@implementation Person- (void)test{    NSLog(@"哈哈哈");}@end// 一旦运行过程中出错，就会闪退/* -[Person test]: unrecognized selector sent to instance 0x7fd2ea4097c0 给Person对象发送了一个不能识别的消息：test */int main(){    Person *p = [Person new];    // OC是在运行过程中才会检测对象有没有实现相应的方法    [p test];    return 0;}

2、继承：

在现实世界中，可以看到很多按层次分类的概念。比如，动物分为哺乳动物、爬行动物等。哺乳动物又分为很多小类。整个分类就组成了一个树状结构。在面向对象中，上一层称为父类，下一层称为子类。继承实现了子类和父类：子类可以使用父类的所有功能，并可以对这些功能进行拓展。通过继承创建的心类称为“子类”或“派生类”。被继承的类称为‘基类“、”父类“或”超类“。继承的过程，就是从一般到特殊的过程。通过使用继承，一个对象就只需定义它所在的所属类的属性即可，因为它可以从父类那里继承所有的通用属性。比如，一个银行账号类的子类可以是定期账号类和活期账号类，他们直接从父类继承开户人、地址等属性和方法。

继承的基本用法：

设计两个类Bird、Dog

// Bird的声明@interface Bird : NSObject{    @public    int weight;}- (void)eat;@end// Bird的定义@implementation Bird- (void)eat {    NSLog(@"吃吃吃-体重：%d", weight);}@end// Dog的声明@interface Dog : NSObject{    @public    int weight;}- (void)eat;@end// Dog的定义@implementation Dog- (void)eat {    NSLog(@"吃吃吃-体重：%d", weight);}@end有相同的属性和行为，抽出一个父类Animal（先抽取weight属性，再抽取eat方法）// Animal的声明@interface Animal : NSObject{    @public        int weight;}- (void)eat;@end// Animal的定义@implementation Animal- (void)eat {    NSLog(@"吃吃吃-体重：%d", weight);}@end子类在父类的基础上拓充属性和方法// Bird的声明@interface Bird : Animal{    @public        int height;}- (void)fly;@end// Bird的定义@implementation Bird- (void)fly {    NSLog(@"飞飞飞-高度：%d", height);}@end// Dog的声明@interface Dog : Animal{    @public        int speed;}- (void)run;@end// Dog的定义@implementation Dog- (void)run {    NSLog(@"跑跑跑-高度：%d", speed);}@end

子类方法和属性的访问过程：如果子类没有，就去访问父类的
父类被继承了还是能照常使用的
父类的静态方法
画继承结构图，从子类抽取到父类
NSObject的引出：全部OC类的最终父类，包含了一些常用方法，比如+new

继承的细节：
单继承
子类和父类不能有相同的成员变量
方法的重写


继承的好处：
不改变原来模型的基础上，拓充方法
建立了类与类之间的联系
抽取了公共代码
坏处：耦合性强

对于继承的理解实例：

#import <Foundation/Foundation.h>/* 1.继承的好处： 1> 抽取重复代码 2> 建立了类之间的关系 3> 子类可以拥有父类中的所有成员变量和方法  2.注意点 1> 基本上所有类的根类是NSObject *//********Animal的声明*******/@interface Animal : NSObject{    int _age;    double _weight;}- (void)setAge:(int)age;- (int)age;- (void)setWeight:(double)weight;- (double)weight;@end/********Animal的实现*******/@implementation Animal- (void)setAge:(int)age{    _age = age;}- (int)age{    return _age;}- (void)setWeight:(double)weight{    _weight = weight;}- (double)weight{    return _weight;}@end/********Dog*******/// : Animal 继承了Animal，相当于拥有了Animal里面的所有成员变量和方法// Animal称为Dog的父类// Dog称为Animal的子类@interface Dog : Animal@end@implementation Dog@end/********Cat*******/@interface Cat : Animal@end@implementation Cat@endint main(){    Dog *d = [Dog new];        [d setAge:10];        NSLog(@"age=%d", [d age]);    return 0;}

继承的使用场合：
它的所有属性都是你想要的，一般就继承
它的部分属性是你想要的，可以抽取出另一个父类

继承的使用场合的实例：

/*1.继承的使用场合 1> 当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取到一个父类中 2> 当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类 A {    int _age;    int _no; }  B : A {    int _weight; }  // 继承：xx 是 xxx // 组合：xxx 拥有 xxx  2.组合 A {     int _age;     int _no; }  B {     A *_a;     int _weight; }*/@interface Score : NSObject{    int _cScore;    int _ocScore;}@end@implementation Score@end@interface Student : NSObject{    // 组合    Score *_score;//    int _cScore;//    int _ocScore;    int _age;}@end@implementation Student@end

super关键字的用法：
分别调用父类的对象方法和类方法

/* 僵尸  跳跃僵尸、舞王僵尸、铁桶僵尸 */#import <Foundation/Foundation.h>/* super的作用 1.直接调用父类中的某个方法 2.super处在对象方法中，那么就会调用父类的对象方法   super处在类方法中，那么就会调用父类的类方法  3.使用场合：子类重写父类的方法时想保留父类的一些行为 */// 僵尸@interface Zoombie : NSObject- (void)walk;+ (void)test;- (void)test;@end@implementation Zoombie- (void)walk{    NSLog(@"往前挪两步******");}+ (void)test{    NSLog(@"Zoombie+test");}- (void)test{    NSLog(@"Zoombie-test");}@end// 跳跃僵尸@interface JumpZoombie : Zoombie+ (void)haha;- (void)haha2;@end@implementation JumpZoombie+ (void)haha{    [super test];}- (void)haha2{    [super test];}- (void)walk{    // 跳两下    NSLog(@"跳两下");        // 走两下(直接调用父类的walk方法)    [super walk];    //NSLog(@"往前挪两步----");}@endint main(){    //[JumpZoombie haha];    JumpZoombie *jz = [JumpZoombie new];        [jz haha2];        return 0;}

3、多态：

多态是指同一个接口名称，但是体现为不同的功能。它有两种方式：覆盖和重载。覆盖是指子类从新定义父类的方法，而重载是允许存在多个同名方法，而这些方法的参数不同（或者参数的个数不同，或者参数的类型不同，或者两者都不同）。比如，”+“方法在针对字符串和数字上的参数和功能是不同的。

多态的体现：
Person *p = [Student new];
p->age = 100;
[p walk];
子类对象赋值给父类指针
父类指针访问对应的属性和方法

多态的好处：
用父类接收参数，节省代码

多态的局限性：
不能访问子类的属性（可以考虑强制转换）

多态的细节：
动态绑定：在运行时根据对象的类型确定动态调用的方法

对于多态的综合实例：

#import <Foundation/Foundation.h>/* 多态 1.没有继承就没有多态 2.代码的体现：父类类型的指针指向子类对象 3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象 4.局限性： 1> 父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法 */// 动物@interface Animal : NSObject- (void)eat;@end@implementation Animal- (void)eat{    NSLog(@"Animal-吃东西----");}@end// 狗@interface Dog : Animal- (void)run;@end@implementation  Dog- (void)run{    NSLog(@"Dog---跑起来");}- (void)eat{    NSLog(@"Dog-吃东西----");}@end// 猫@interface Cat : Animal@end@implementation Cat- (void)eat{    NSLog(@"Cat-吃东西----");}@end// 这个函数是专门用来喂动画//void feed(Dog *d)//{//    [d eat];//}////void feed2(Cat *c)//{//    [c eat];//}//// 如果参数中使用的是父类类型，可以传入父类、子类对象void feed(Animal *a){    [a eat];}int main(){    // NSString *d = [Cat new];    // [d eat];        /*    Animal *aa = [Dog new];    // 多态的局限性：父类类型的变量 不能 用来调用子类的方法    //[aa run];        // 将aa转为Dog *类型的变量    Dog *dd = (Dog *)aa;        [dd run];    */        //Dog *d = [Dog new];        //[d run];        /*    Animal *aa = [Animal new];    feed(aa);        Dog *dd = [Dog new];    feed(dd);        Cat *cc = [Cat new];    feed(cc);     */        /*    // NSString *s = [Cat new];    Animal *c = [Cat new];            NSObject *n = [Dog new];    NSObject *n2 = [Animal new];            // 多种形态    //Dog *d = [Dog new]; // Dog类型        // 多态：父类指针指向子类对象    Animal *a = [Dog new];        // 调用方法时会检测对象的真实形象    [a eat];    */    return 0;}

NSStirng的简单使用：

字符串的快速创建：
NSStirng *str = @“Hello”;
使用静态方法创建
使用%@输出字符串
NSString *name = @”mj”;
NSLog(@“我的名字是%@”,  name);

#import <Foundation/Foundation.h>@interface Person : NSObject{    //char *_name;    NSString *_name;}@endint main(){    /*    // 最简单的创建字符串的方式    NSString *str = @"itcast";        char *name = "itcast";            NSLog(@"我在%@上课", str);    //NSLog(@"%s", name);    */        int age = 15;    int no = 5;    NSString *name = @"哈哈jack";    // length方法算的是字数    int size = [name length];        NSLog(@"%d", size);        // 创建OC字符串的另一种方式    NSString *newStr = [NSString stringWithFormat:@"My age is %d and no is %d and name is %@", age, no, name];            NSLog(@"---- %ld", [newStr length]);        return 0;}