面向对象的三大特性

面向对象的三大特性：封装、继承、多态

封装

封装，成员变量的封装，保证了数据的安全性。封装的好处：过滤了不合理的值、屏蔽内部的赋值过程、让外界不必关注内部的细节

Set方法

1. 1.     提供一个方法给外界设置成员变量

2. 2.     命名规范：

1）        方法名必须以set开头

2）        Set后面跟上成员变量的名称，成员变量的首字母必须大写！

3）        Set方法的返回值一定是void

4）        一定要接受一个参数，而且参数类型跟成员变量类型一致

5）        形参的名称不能跟成员变量的命名一样

1. 3.     在set方法里面可以对参数进行相应的过滤

提示：成员变量尽量不要用public

Get方法

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

2. 2.     命名规范：

1）        肯定有返回值，且返回值类型肯定与成员变量的类型一致

2）        方法名必须以get开头，方法名跟成员变量名一致；

3）        不需要接受任何参数

注意：值只允许外界访问，其不能更改的时间只需要提供get方法，有只读数据（readonly）

三）封装所需要注意的细节

1. 1. 成员变量名的命名规范

        1） 一定要以下划线“_”开

                           作用：  1> 让成员变量和get方法的名称区分开

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

 

练习

设计一个成绩类

1）        属性：C语言成绩、OC成绩、IOS成绩

2）        行为：

• 比较C语言成绩：跟另外一个成绩对象比较C语言成绩，返回成绩差（自己-其他成绩）

• 比较OC成绩：跟另外一个成绩对象OC成绩，返回成绩差（自己-其他成绩）

• 比较iOS成绩：跟另外一个成绩对象IOS成绩，返回成绩差（自己-其他成绩）

• 计算总分：算出3课成绩的总分

• 计算平均分：算出3科成绩的平均分

设计一个成绩类

• C语言成绩（可读可写）

• OC成绩（可读可写）

• 总分（只读）

• 平均分（只读）

#import <Foundation/Foundation.h>

@interface Score : NSObject

{

Int _cScore;

Int _ocScore;

Int _totalScore;

Int _averageScore;

}

-        (void)setCScore(int)cScore;

-        (int)cScore;

-        (void)setOcScore(int)ocScore;

-        (int)cScore;

-        (int)totoalScore;

-        (int)averageScore;

@end

@implemetation Score

-        (void)setCScore(int)cScore;

{

        _cScore=cScore;

        _totalScore=_cSore+_csScore;

        _averageScore=_totalScore/2;

}

-        (int)cScore;

{

        Return _cScore;

}

-        (void)setOcScore(int)ocScore;

{

        _ocScore=ocScore;

        _totalScore=_cSore+_csScore;

        _averageScore=_totalScore/2;

 

}

-        (int)ocScore;

{

        Return ocScore;

}

-        (int)totoalScore;

{

        ReturntotoalScore;

}

-        (int)averageScore;

{

        ReturnaverageScore;

}

 

@end

Int main()

{

       Score*s=[Score new];

       [ssetCScore:90];

       [ssetOcScore:100];

Int a=[s totalScore];

NSLog(@“总分为：%d”，a);

              Return0;

}

如上程序写法可以监听程序的改变

弱语法

在OC中再运行过程中才会检测对象有没有实现相应的方法

错误：

弱语法：当不写声明时间仅是警告（此情况仅发生在@implementation和@end放在main方法前面）

当方法不存在就运行的时间，而且主方法中存在这个方法的调用也会出现警告，当方法在声明中存在没有实现是也会出现警告（在手机上会出现闪退！）；

类方法

使用类名调用的方法我们称之为类方法

使用类方法来提高我们程序的性能

类方法是以+号开头，对象方法是以-号开头的方法

类方法只能通过类名来调用不能通过对象来调用；

对象方法只能有对象调用；

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

类方法中不能直接访问成员变量（实例变量）的，但是对象方法中就能访问当前对象的成员变量；

对象方法可以调用类方法；

当类方法调用本身的类方法的时间会出现死循环现象一定要注意不要这么做！

经典错误

#import <Foundation/Foundation.h>

@interface Person: NSObject

+（void）printClassName；

@end

@implementation Person

+（void）printClassName

{

       NSLog（@“这个类叫做Person”）；

}

@end

Int main（）

{

       [PersonprintClassName];

       Return0;

}

类方法的好处

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

2）        能用类方法的时候尽量用类方法

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

例：

/*

设计一个计算器类

* 求和

* 求平均值

*/

#import <Foundation/Foundation.h>

@interface JiSuanQi : NSObject

+ (int)sumOfNum1(int)num1andNum2(int)num2;

+ (int)averageOfNum1(int)num1 andNum2(int)num2;

@end

@implementation JiSuanQi

+ (int)sumOfNum1(int)num1andNum2(int)num2

{

Returnnum1+num2;

}

+ (int)averageOfNum1(int)num1 andNum2(int)num2

{

Return (num1+num2)/2;d

}

@end

Int main()

{

[JiSuanQi sumOfNum1:10 andNum2:20];

Return 0;

}

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

#import <Foundation/Foundation.h>

@interface JiSuanQi : NSObject

+ (int)sumOfNum1(int)num1andNum2(int)num2;

+ (int)averageOfNum1(int)num1 andNum2(int)num2;

@end

@implementation JiSuanQi

+ (int)sumOfNum1(int)num1andNum2(int)num2

{

Returnnum1+num2;

}

+ (int)averageOfNum1(int)num1 andNum2(int)num2

{

Int sum=[JiSuanQi sumOfNum1:num1 andNum2:num2];

Returnsum/2;

}

@end

Int main()

{

[JiSuanQi sumOfNum1:10 andNum2:20];

Return 0;

}

Self关键字

1. 1.     Self:谁调用了方法他就指向谁，代表当前对象

Self是一个指针

#import <Foundation/Foundation.h>

@interface Person: NSObject

{

       Int_age;

}

- (void)setAge(int)age；

- (int)age;

- (void)test;

@end

@implementation Person

-（void）setAge(int)age

{

       _age=age;

}

-(int)age

{

       Retrun_age;

}

- (void)test;

{

       Int _age=20;

      NSLog(@”Person的年龄是%d岁”,_age);

}

@end

Int main（）

{

       Person*p=[Person new];

[p setAge:10];

[p test];

       Return0;

}

更改后：

#import <Foundation/Foundation.h>

@interface Person: NSObject

{

       Int_age;

}

- (void)setAge(int)age；

- (int)age;

- (void)test;

@end

@implementation Person

-（void）setAge(int)age

{

       _age=age;

}

-(int)age

{

       Retrun_age;

}

- (void)test;

{

       Int _age=20;

      NSLog(@”Person的年龄是%d岁”,self->_age);

}

@end

Int main（）

{

       Person*p=[Person new];

[p setAge:10];

[p test];

       Return0;

}

Self调用方法：

#import <Foundation/Foundation.h>

@interface Dog: NSObject

- (void)break；

- (void)run;

@end

@implementation Dog

- (void)break

{

       NSLog(@”汪汪汪”)；

}

- (void)run

{

       [selfbrak];

       //NSLog(@“汪汪汪”)；

       NSLog(@“跑跑跑”)

}

@end

Int main（）

{

       Dog*d=[Dog new];

[d run];

       Return0;

}

Self的用途：

1）         随调用了当前方法，self就代表谁

• Self 出现在对象方法中，self就代表对象

• Self出现在类方法中，self就代表类

2）         可以了用“self->成员变量名”访问当前对象内部的成员变量名

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

#import <Foundation/Foundation.h>

@interface JiSuanQi : NSObject

+ (int)sumOfNum1(int)num1andNum2(int)num2;

+ (int)averageOfNum1(int)num1 andNum2(int)num2;

@end

@implementation JiSuanQi

+ (int)sumOfNum1(int)num1andNum2(int)num2

{

Returnnum1+num2;

}

+ (int)averageOfNum1(int)num1 andNum2(int)num2

{

Int sum=[selfsumOfNum1:num1 andNum2:num2];

Return sum/2;

}

@end

Int main()

{

[JiSuanQi sumOfNum1:10 andNum2:20];

Return 0;

}

Self使用时间要注意的地方：

#import <Foundation/Foundation.h>

@interface Person: NSObject

- (void)test;

@end

@implementation Person

- (void)test;

{

       NSLog(@”调用了test方法”);

}

@end

Int main（）

{

       Person*p=[Person new];

 [p test];

       Return0;

}

Self使用时间要注意的地方：

1）        注意避免死循环！

2）        一定注意方法的书写！

继承

#import <Foundation/Foundation.h>

@interface Animal: NSObject

{

Int _age;

Double _weight;

}

-        (void)setWeight:(double)weight;

-        (double)weight;

-        (void)setAge:(int)age;

-        (int)age;

@end

@Implementation Animal

-        (void)setAge(int)age

{

_age=age;

}

-        (int)age

{

Return _age;

}

-        (void)setWeight:(double)weight

{

_weight=weigjt;

}

-        (double)weight

{

Return _weight;

}

@end

@interface Dog: Animal

@end

@Implementation Dog

@end

@interface Cat: Animal

@end

@Implementation Cat

@end

Int main()

{

Dog *d = [Dog new];

[d setAge:10];

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

Return 0;

}

继承的好处：

1. 1.    抽取重复代码

2. 2.    建立了类之间的关系

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

继承的注意点：

1. 1.     基本上所有类的根目录是NSObject

2. 2.     父类必须写在子类的前面

3. 3.     子类跟父类中不能出现相同名称的成员变量但方法的实现可以重名可以重复；

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

提示：每个类中都有一个指针 superclass

1. 5.     调用摸个对象的方法时，优先去当前对象中找，如果找不到就去父类中找

继承的关系的坏处：

1. 1.     耦合性太强了，当某个类不见了或者出现错误的其他的类有可能不能继续使用

继承的使用场合：

1. 1.     当两个类拥有相同的属性跟方法的时候，就可以将相同的东西抽取到一个父类中

2. 2.     当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类

组合跟继承的区别：

继承：xxx是xxxx

组合：xxx拥有xxxx   Score *_score

继承中的关键字：Super

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

作用：

（1）直接调用父类中的某一个方法

（2）Super处在对象方法中，那么就会调用父类的对象方法；super处于类方法中，那么就会调用父类的类方法。

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

/*

僵尸

跳跃僵尸、舞王僵尸、铁桶僵尸

*/

#import <Foundation/Foundation.h>

//僵尸

@interface Zoombie ：NSobject

-        （void）walk；

@end

@implementation Zoombie

-        （void）walk

{

NSLog（@“往前挪两步----“）；

}

@end

//跳跃僵尸

@interface JumZoombie ：Zoombie

@end

@implementation JumZoombie

-        （void）walk

{

NSLog（@“跳两下---“）；

[super walk];

}

@end

Int main()

{

JumZoombie *jz=[JumZoombienew];

[jz walk];

Return 0;

}

多态

多态在代码中的体现，即为多种形态，必须要有继承，没有继承就没有多态。

在使用多态是，会进行动态检测，以调用真实的对象方法。

多态在代码中的体现即父类指针指向子类对象。

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

多态的局限性：

父类类型的变量是不能用来调用子类的方法

OC字符串类

案例：

#import<Foundation/Foundation.h>

int main()

{

NSString*str = @”Jeason”;

Char *a = “Jeason”;

NSLog(@”这是我的名字：%@”,a);

return 0;

}

案例：

#import<Foundation/Foundation.h>

int main()

{

intage=15;

int no=5;

NSString *name= @”Jeason”;

NSString*str=[NSStringstringWithFormat:@”My age is %d and no is %d and name is %@”,age,no,name];

NSLog(@”这是我的名字%@”,str);

return 0;

}

[对象 lengh]