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);
}

@end

int 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;
}
@end


int 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
@end

int 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(@"往前挪两步----");

}
@end

int 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;
}
@end

int 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;
}