黑马程序员--OC面向对象三大基础总结

                                                ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面向对象的三大特征：

 

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

面向对象的三个基本特征就是：封装、继承和多态。

 

一、封装：

封装就是把客观事物封装成抽象的类。在编程语言的角度，封装就是把类的数据和方法只让可信的类或者对象操作，对不可信的类进行信息隐蔽。另外，通过接口，类隐蔽了其中的属性和方法的具体实现。

1、set方法和get方法的使用场合：
@public的成员变量可以被随意赋值，而使用set方法和get方法来管理成员的访问,避免成员变量别随意访问、修改。
2、set方法：
1) 作用：用来设置成员变量，可以在方法里面过滤掉一些不合理的值
2) 命名规范：

• 方法都是以set开头，而且后面跟上成员变量名，
• 成员变量名的首字母必须大写
• 返回值一定是void
• 一定要接受一个参数，而且参数类型跟成员变量类型一致
• 形参名称不要跟成员变量同名
  
  

3、get方法：
1) 作用：返回对象内部的成员变量
2) 命名规范：

• 肯定有返回值，返回值类型跟成员变量类型一直
• get方法的名称一般就跟成员变量同名
• 不需要接受任何参数
  
  

4、成员变量的命名规范

• 成员变量都以下划线 _ 开头
• 可以跟get方法的名称区分开
• 可以跟其他局部变量区分开，一看到下划线开头的变量，肯定是成员变量

@interface Student : NSObject
{

    int _age;    
    int _no; 
}
- (void)setAge:(int)newAge
{
    if (newAge <= 0) newAge = 1;    
    _age = newAge;
}

- (int)age
{
    return _age;
}
@end

int main()
{
    Student *stu = [Student new];
    [stu setAge:10];    
    NSLog(@"学生的年龄是%d岁", [stu age]);    
    return 0;
}

5、封装的好处：

• 过滤不合理的值
• 屏蔽内部的赋值过程
• 让外界不必关注内部的细节

二、继承

在现实世界中，可以看到很多按层次分类的概念。比如，动物分为哺乳动物、爬行动物等。哺乳动物又分为很多小类。整个分类就组成了一个树状结构。在面向对象中，上一层称为父类，下一层称为子类。继承实现了子类和父类：子类可以使用父类的所有功能，并可以对这些功能进行拓展。继承的过程，就是从一般到特殊的过程。通过使用继承，一个对象就只需定义它所在的所属类的属性即可，因为它可以从父类那里继承所有的通用属性。

1、继承的基本用法

@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
int main()
{
    Dog *d = [Dog new];
    
    [d setAge:10];
    
    NSLog(@"age=%d", [d age]);
    return 0;
}

2、继承的细节：

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

@interface Person : NSObject
{
    int _age;
}
- (void)setAge:(int)age;
- (int)age;
- (void)run;
@end
@implementation Person
- (void)run
{
    NSLog(@"person---跑");
}

- (void)setAge:(int)age
{
    _age = age;
}
- (int)age
{
    return _age;
}
@end

// 不允许子类和父类拥有相同名称的成员变量
// Student
@interface Student : Person
{
    int _no;
}
@end

@implementation Student
// 重写：子类重新实现父类中的某个方法，覆盖父类以前的做法
- (void)run
{
    NSLog(@"student---跑");
}
@end
int main()
{

    
    Student *s = [Student new];
    
   [s run];
    
    return 0;
}

3、继承的好处：

• 不改变原来模型的基础上，拓充方法
• 建立了类与类之间的联系
• 抽取了公共代码
• 坏处：耦合性强，类与类之间的联系性太强，父类出现问题，子类也出问题。

4、继承的使用场合：

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

三、多态

字面上理解就是多种状态，有继承才有多态。多态指同一个接口名称，但是体现为不同的功能。

1、多态的体现：

Person *p = [Student new];

p->age = 100;

[p walk];

子类对象赋值给父类指针

父类指针访问对应的属性和方法

2、多态的好处：

用父类接收参数，节省代码

3、多态的局限性：

不能访问子类的属性（可以考虑强制转换）

4、多态的细节：

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

@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(Animal *a)
{
    [a eat];
}
int main()
{
    Animal *aa = [Dog new];
    // 多态的局限性：父类类型的变量 不能 用来调用子类的方法
    //[aa run];
    
    // 将aa转为Dog *类型的变量
    Dog *dd = (Dog *)aa;
    [dd run];
 
    Animal *aa = [Animal new];
    feed(aa);
    
    Dog *dd = [Dog new];
    feed(dd);
    
    Cat *cc = [Cat new];
    feed(cc);
   
    // 多种形态
    //Dog *d = [Dog new]; // Dog类型
    
    // 多态：父类指针指向子类对象
    Animal *a = [Dog new];    
    // 调用方法时会检测对象的真实形象
    [a eat];
    */
    return 0;
}

四、类方法

1、对象方法

•   减号 - 开头
•  只能由对象来调用
• 对象方法中能访问当前对象的成员变量（实例变量） 

2、 类方法

•  加号 + 开头
• 只能由类（名）来调用
•  类方法中不能访问成员变量（实例变量） 

 3、类方法的好处和使用场合

•  不依赖于对象，执行效率高
• 能用类方法，尽量用类方法
•  场合：当方法内部不需要使用到成员变量时，就可以改为类方法
•  可以允许类方法和对象方法同名

@interface Person : NSObject
{
    int age;
}

// 类方法都是以+开头
+ (void)printClassName;
- (void)test;
+ (void)test;
@end

@implementation Person

+ (void)printClassName
{
    // error：instance variable 'age' accessed in class method
    // 实例变量age不能在类方法中访问
    //NSLog(@"这个类叫做Person-%d", age);
}

- (void)test
{
    NSLog(@"111-%d", age);
 }
+ (void)test
{    
    NSLog(@"333");
 }

@end

int main()
{
    
    Person *p = [Person new];
    [p test];
    
  
    // 系统会认为现在调用的printClassName是个对象方法
    [p printClassName];
     return 0;
}

五self使用说明

1、self的用途：

•   谁调用了当前方法，self就代表谁
•  self出现在对象方法中，self就代表对象
•  self出现在类方法中，self就代表类

 

 2、 在对象方法利用"self->成员变量名"访问当前对象内部的成员变量

 

3、[self 方法名]可以调用其他对象方法\类方法

@interface Dog : NSObject
- (void)bark;
- (void)run;
@end

@implementation Dog
- (void)bark
{
    NSLog(@"汪汪汪");
}
- (void)run
{
    [self bark];
    NSLog(@"跑跑跑");
}
@end

int main()
{
    Dog *d = [Dog new];
    
    [d run];
    
    return 0;
}