Objective-C—对象的三大特性：封装、继承、多态

---对象的三大特性：封装

#import<Foundation/Foundation.h>

@interface Student : NSObject

{

    //成员变量尽量不要用@public

    //@public

    /*成员变量的命名规范：一定要以下划线 _ 开头

     作用：

     1.让成员变量和get方法的名称区分开

     2.可以跟局部变量区分开，一看到下划线开头的变量，一般都是成员变量

     */

    int _age;

}

/*

 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;

}

- (void)study

{

    NSLog(@"%d岁的学生在学习",_age);

}

- (int)age

{

    return _age;

}

@end

int main()

{

    Student *stu = [Student new];

    [stu setAge:10];

    [stu study];

    

    NSLog(@"学生的年龄是%d岁",[stu age]);

    

    return 0;

}

OC属于若语法，比C还要弱：在运行过程中才会检测对象有没有实现相应的方法，一旦运行过程中出错，就会闪退

---类方法

#import<Foundation/Foundation.h>

/*

 对象方法

 1>减号 - 开头

 2>只能由对象来调用

 3>对象方法中能访问当前对象的成员变量（实例变量）

 

 类方法

 1>加号 + 开头

 2>只能由类（名）来调用

 3>类方法中不能访问成员变量（实例变量）

 

 类方法的好处和使用场合

 1>不依赖于对象，执行效率高

 2>能用类方法，尽量用类方法

 3>场合：当方法内部不需要使用到成员变量时，就可以改为类方法

 

 可以允许类方法和对象方法同名

 

 工具类：基本没有任何成员变量，里面的方法基本都是类方法

 */

@interface Person : NSObject

//类方法都是以+开头

+ (void)printClassName;

@end

@implementation Person

+ (void)printClassName

{

    NSLog(@"这个类叫做Person");

}

@end

int main()

{

    [Person printClassName];   

    return 0;

}

注意点:

//例如以下类方法，一旦调用类方法即[Person test]就会引发死循环

+ (void)test

{

    NSLog(@"3333");

    [Person test];
}

---面向对象三大特性：继承

#import<Foundation/Foundation.h>

 /*

 1.继承的好处：

 1>抽取重复代码

 2>建立了类之间的关系

 3>子类可以拥有父类中的所有成员变量和方法

 

 2.注意点

 1>基本上所有类的根类是NSObject

 2>不允许子类再创建和父类相同名称的成员变量

 3>父类必须声明在子类的前面

 4>重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

 5>调用某个方法时，优先去当前类中找，如果找不到，去父类中找

 

 3.继承的坏处：

 耦合性太强，父类与子类之间关系紧密，一个类的改变会导致其他类的变化

 

 4.继承的使用场合

 1>当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取到一个父类中，也可以考虑使用组合

 2>当A类拥有B类中的部分属性和方法，可以考虑让B类继承A类,但是应该在语言逻辑上合情合理

 

 继承：

 A

 {

 int _age;

 int _no;

 }

 

 B

 {

 int _age;

 int _no;

 int _weight;

 }

 B  : A

 {

 int _weight;

 }

 组合：

 A

 {

 int _age;

 int _no;

 }

 

 B

 {

 int _age;

 int _no;

 int _weight;

 }

 

 B(组合）

 {  A *_a;

 int _weight;

 }

*/

/**********Animal的声明***********/

@interface Animal : NSObject

{

    int _age;

    double _weight;

}

- (void)setAge:(int)age;

- (int)age;

- (void)setWeight:(double)weight;

- (double)weihgt;

@end

/**********Animal的实现***********/

@implementation Animal

- (void)setAge:(int)age

{

    _age = age;

}

- (int)age

{

    return _age;

}

- (void)setWeight:(double)weight

{

    _weight = weight;

}

- (double)weihgt

{

    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:20];

    

    NSLog(@"age = %d",[d age]);

    

    return 0;

}

---面向对象三大特性：多态

#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)eat;

- (void)run;

@end

@implementation Dog

- (void)run

{

    NSLog(@"Dog跑起来了");

}

- (void)eat

{

    NSLog(@"Dog吃东西---");

}

@end

//猫

@interface Dog : Cat

- (void)eat;

@end

@implementation Cat

- (void)eat

{

    NSLog(@"Dog吃东西---");

}

@end

//这个函数是专门用来喂动物

//如果参数中使用的是父类类型，可以传入父类、子类对象

void feed(Animal *a)

{

    [a eat];

}

int main()

{

    Animal *aa = [Dog new];

    //多态的局限性：父类类型的变量 不能 用来调用子类的方法（虽然能调用成功）

    //[aa run];

    

    //将aa转为Dog *类型的变量

    Dog *dd = (Dog *)aa;

    

    //Dog *d = [Dog new];

    //[d run];

    

    //Animal *aa = [Animal new];

    //feed(aa);

    

    //Dog *d = [Dog new];

    //feed(d);

    

    //Cat *c = [Cat new];

    //feed(c);

    
4000

    //多种形态

    //Dog *d = [Dog new];//Dog

    

    //多态：父类指针指向子类对象

    //Animal *a = [Dog new];

    

    //调用方法时会检测对象的真实形象

    //[a eat];

    

    return 0;

}