黑马程序员——Objective-C语言知识点总结之面向对象

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

面向对象

面向对象的三大特性：封装（成员变量）、继承和多态

封装

Set方法

在开发过程中，考虑到安全性要求，我们一般不在成员变量名前面使用@public、@protected等关键字修饰，而是使用Set方法来为对象提供成员变量的值。在set方法的内部也可以对一些不合理的赋值进行筛选过滤。

1、作用:
提供一个方法给外界设置成员变量值，可以在方法里面对参数进行相应过滤

2、命名规范：
1> 方法名必须以set开头
2> set后面跟上成员变量的名称，成员变量的首字母必须大写
3> 返回值一定是void
4> 一定要接收一个参数，而且参数类型跟成员变量类型一致
5> 形参的名称不能跟成员变量名一样
例：

- (void)setAge:(int)newAge;

3、Set方法的好处：
1>不让数据暴露在外，保证了数据的安全性
2>对设置的数据进行过滤

4、Set方法的实现：

- (void)setAge:(int)newAge
{
    // 对传进来的参数进行过滤
    if (newAge <= 0)
    {
        newAge = 1;
    }
    age = newAge;
}

Get方法

1、作用：
返回对象内部的成员变量

2.命名规范：
1> 肯定有返回值，返回值类型肯定与成员变量类型一致
2> 方法名跟成员变量名一样
3> 不需要接收任何参数
例：

- (int)age;

3、Get方法的实现：

- (int)age
{
    return age;
}

注意：
1>在实际的开发中，不一定set和get方法都会提供，如果内部的成员变量比如学生的学号这样的数据只允许外界读取，但是不允许修改的情况，则通常只提供get方法而不提供set方法。
2>成员变量名的命名以下划线开头，get方法名不需要带下划线
使用下划线开头有两个好处：
1）与get方法的方法名区分开来；
2）可以和一些其他的局部变量区分开来，下划线开头的变量，通常都是类的成员变量。

例：设计一个成绩类
* C语言成绩（可读可写）
* OC成绩（可读可写）
* 总分（只读）
* 平均分（只读）

#import <Foundation/Foundation.h>

@interface Score : NSObject
{
    int _cScore; // C语言成绩
    int _ocScore; // OC成绩

    int _totalScore;// 总分
    int _averageScoe; // 平均分
}
// 可读可写，声明set方法和get方法
- (void)setCScore:(int)cScore;
- (int)cScore;
// 可读可写，声明set方法和get方法
- (void)setOcScore:(int)ocScore;
- (int)ocScore;
// 只读，声明get方法
- (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;
}

运行结果：
2015-04-27 00:26:34.850 c006[1161:150171] 总分：180

Self关键字

Self是一个指针，谁调用了当前方法，self就指向谁
出现在对象方法中，就代表着当前对象，出现在类方法中，就代表着当前类

Self的用途:

(1)可以利用”self->成员变量名”访问当前对象内部的成员变量（仅在对象方法中）
(2)[self 方法名]；可以调用其他的对象方法或者是类方法

例：设计一个计算器类
* 求和
* 求平均值

#import <Foundation/Foundation.h>

// 工具类：基本没有任何成员变量，里面的方法基本都是类方法
@interface JiSusnQi : NSObject
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
@end

@implementation JiSusnQi
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
{
    return num1 + num2;
}

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
{
    // 在这种情况下，self代表调用该方法的类
    int sum = [self sumOfNum1:num1 andNum2:num2];
    return sum / 2;
}
@end

int main()
{
    int a = [JiSusnQi averageOfNum1:10 andNum2:12];
    NSLog(@"a=%d", a);
    return 0;
}

运行结果：
2015-04-27 00:39:51.761 c006[1189:152725] a=11

继承

继承简介

1、继承的好处：

1> 抽取重复代码
2> 建立了类之间的关系
3> 子类可以拥有父类中的所有成员变量和方法

2、继承的缺点：

耦合性太强

3、注意点

1>基本上所有类的根类是NSObject
2>子类重新实现父类中的某个方法，覆盖父类以前的做法
3> 父类必须声明在子类的前面
4> 子类不能拥有和父类相同的成员变量
5> 调用某个方法时，优先去当前类中找，如果找不到，再去父类中找

OC中的继承

@interface Animal:NSObject
//动物类继承了NSObject，获得NSObject类的方法；
@end

@interface Dog :Animal
//dog类继承Animal类
@end

注意：OC语言是单继承语言。在oc语言中，基本上所有类的根类都是NSObject类。

例如：Student *s=[[Student alloc] init];
此时会把Student类和这个类的父类加载进内存。
提示：每个类中都有一个super class指针，该指针指向自己的父类。对象中有一个isa指针，该指针指向调用该对象的类。

继承的适用场合：

1>当两个类拥有相同的属性和方法时，就可以将相同的属性和方法抽取到一个父类中。
2>当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类（考虑），在这种情况下，也可以考虑使用组合。

继承：###是xxx,如狗是动物，可以让狗继承动物类
组合：###拥有xxx，如学生有书，可以让书这个类作为学生类的属性

关键字super

Super关键字，在子类中重写方法时，可以让调用者跳过这一层而调用父类中的方法

作用：

1>直接调用父类中的某一个方法
2>super处在对象方法中，那么就会调用父类的对象方法；
super处于类方法中，那么就会调用父类的类方法。

使用场景：子类在重写父类方法时，想要保留父类的一些行为。

例：僵尸类拥有walk对象方法，test对象方法和test类方法，跳跃僵尸继承僵尸类，且增加haha类方法和haha2对象方法，并且重写walk 方法，并增加行为

#import <Foundation/Foundation.h>

@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];
    [jz walk];

    return 0;
}

运行结果：
2015-04-27 01:01:40.775 c006[1235:157883] Zoombie+test
2015-04-27 01:01:40.775 c006[1235:157883] Zoombie-test
2015-04-27 01:01:40.775 c006[1235:157883] 跳两下
2015-04-27 01:01:40.776 c006[1235:157883] 往前挪两步

多态

基本概念

多态在代码中的体现，即为多种形态，在使用多态是，会进行动态检测，以调用真实的对象方法。
1>没有继承就没有多态
2>代码的体现：父类类型的指针指向子类对象
3>好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象
4>局限性：父类类型的变量不能直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法

#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(Animal *a)
{
    [a eat];
}

int main()
{
     Animal *aa = [Dog new];
     // 多态的局限性：父类类型的变量 不能 用来调用子类的方法
     //[aa run];
     // 将aa转为Dog *类型的变量
     Dog *dd = (Dog *)aa;
     [dd run]; // Dog---跑起来

     Dog *d = [Dog new];
     [d run]; // Dog---跑起来


     Animal *aaa = [Animal new];
     // 参数中使用的是父类类型，可以传入父类、子类对象
     feed(aaa); // Animal-吃东西----

     Dog *ddd = [Dog new];
     feed(ddd); // Dog-吃东西----

     Cat *ccc = [Cat new];
     feed(ccc); // Cat-吃东西----

     // 多态：父类指针指向子类对象
     Animal *a = [Dog new];

     // 调用方法时会检测对象的真实形象
     [a eat]; // Dog-吃东西----
     return 0;
}

运行结果：
2015-04-27 01:18:45.450 c006[1253:161521] Dog—跑起来
2015-04-27 01:18:45.451 c006[1253:161521] Dog—跑起来
2015-04-27 01:18:45.451 c006[1253:161521] Animal-吃东西—-
2015-04-27 01:18:45.451 c006[1253:161521] Dog-吃东西—-
2015-04-27 01:18:45.452 c006[1253:161521] Cat-吃东西—-
2015-04-27 01:18:45.452 c006[1253:161521] Dog-吃东西—-