黑马程序员————OC面向对象三大特征总结

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

面向对象的三大特征：

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

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