------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
面向对象和面向过程思想
OC是面向对象的，C是面向过程的。面向对象和面向过程只是解决问题的两种不同思想
面向对象和面向过程的区别
以用电脑听歌为例子
面向过程
打开电脑
播放电脑中的歌曲
关闭电脑
面向对象
电脑
开机
播放歌曲
关机
区别分析
面向过程关注的是解决问题需要哪些步骤；面向对象关注的是解决问题需要哪些对象
没有开发经验很难感受到它们的区别，两种思想都能达到解决问题的目的，但是解决思路不一样
现实生活中面向对象的例子
想打电话\发短信 找手机，不用分析电话要怎样才能拨通
去饭店吃饭 找服务员，不用分析怎么到厨房炒菜
汽车坏了 找汽车维修工，不用分析修车的步骤
境界：万物皆对象
常用术语
面向过程 Procedure Oriented
面向对象 Object Oriented，简称OO
面向对象编程 Object Oriented Programming，简称OOP
类和对象的关系
面向对象中有2个非常重要的概念：类和对象
如何创建对象
面向对象解决问题的时候必须有对象，那如何创建对象呢？
现实生活的例子：如何创造汽车对象？
需要先有汽车的建造图纸，图纸上描述清楚汽车应该具备的属性和功能（行为）
属性：*数、时速
功能（行为）：跑
然后再根据图纸上的描述生成汽车
每一辆汽车都是对象，都有自己具体的属性值，都是图纸的实例
图纸是抽象的，房子是具体的。图纸是对房子对象的高度概括
OC中的面相对象
OC中的类相当于图纸，用来描述一类事物。也就是说，要想创建对象，必须先有类
OC利用类来创建对象，对象是类的具体存在
因此，面向对象解决问题应该是先考虑需要设计哪些类，再利用类创建多少个对象
需要设计哪些类，如何设计类
类的设计，只关心3样东西：
事物名称（类名）：人（Person）
属性：身高（height）、年龄（age）
行为（功能）：跑（run）、打架（fight）
一般名词都是类
坦克发射3颗炮弹轰掉了2架飞机
小明在公车上牵着一条叼着热狗的狗
拥有相同（或者类似）属性和行为的对象都可以抽像出一个类
愤怒的小鸟游戏界面
植物大战僵尸
新浪微博
类名、属性、行为练习
僵尸、炮弹、车、学生、书本
哪个对象最清楚这个行为，就把这个行为写到哪个对象中去。打开电脑（开机）这个行为应该是属于电脑的。
定义OC的类和创建OC的对象
接下来就在OC中模拟现实生活中的情况，创建一辆车出来。首先要有一个车子类，然后再利用车子类创建车子对象
要描述OC中的类稍微麻烦一点，分2大步骤：类的声明、类的实现（定义）。跟函数类似，函数有分声明和定义
类的声明
示例：
定义一个Car类，拥有2个属性：*数、时速，1个行为：跑
类名\属性的命名规则：标示符的规则
类名的命名规范：有意义、驼峰标识、首字母大写
/*
类名：Car
属性：轮胎个数、时速（速度）
行为：跑
*/
// 因为使用了NSObject
#import <Foundation/Foundation.h>
// 完整地写一个函数：函数的声明和定义（实现）
// 完整地写一个类：类的声明和实现
// 1.类的声明
// 声明对象的属性、行为
// : NSObject 目的是：让Car这个类具备创建对象的能力
@interface Car : NSObject
{// 用来声明对象属性（实例变量\成员变量，默认会初始化为0）
// @public可以让外部的指针间接访问对象内部的成员变量
@public
int wheels; // 轮胎个数
int speed; // 时速(xxkm/h)
}
// 方法（行为）:方法名、参数、返回值（声明、实现）
// 只要是OC对象的方法，必须以减号 - 开头
// OC方法中任何数据类型都必须用小括号()扩住
// OC方法中的小括号()：括住数据类型
- (void)run;
@end
// 2.类的实现
// 用来实现@inteface中声明的方法
@implementation Car
// 方法的实现（说清楚方法里面有什么代码）
- (void)run
{
NSLog(@"车子跑起来了");
}
@end
int main()
{
// 在OC中，想执行一些行为，就写上一个中括号[行为执行者 行为名称]
// 利用类来创建对象
// 执行了Car这个类的new行为来创建新对象
// 定义了一个指针变量p，p将来指向的是Car类型的对象
// [Car new]每次都会创建出一个新对象，并且会返回新对象本身（新对象的地址）
Car *p = [Car new];
Car *p2 = [Car new];
p2->wheels = 5;
p2->speed = 300;
[p2 run];
// 给p所指向对象的wheels属性赋值
p->wheels = 4;
p->speed = 250;
// 给p所指向对象发送一条run消息
[p run];
NSLog(@"车子有%d个*，时速位：%dkm/h", p->wheels, p2->speed);
return 0;
}
运行结果：
面向对象封装的好处
更加接近人类的思考方式
只需要关注对象，不需要关注步骤
对象与函数参数
对象成员变量作为函数参数
指向对象的指针作为函数参数
修改指向指向对象的成员
修改指针的指向
类的声明和实现
@interface和@implementation的分工
@interface就好像暴露在外面的时钟表面
@implementation就好像隐藏在时钟内部的构造实现
声明和定义多个类
常见错误
只有类的声明，没有类的实现
漏了@end
@interface和@implementation嵌套
两个类的声明嵌套
成员变量没有写在括号里面
方法的声明写在了大括号里面
语法细节
成员变量不能在{}中进行初始化、不能被直接拿出去访问
方法不能当做函数一样调用
成员变量\方法不能用static等关键字修饰，别跟C语言混在一起（暂时忽略）
类的实现可用写在main函数的后面，主要在声明后面就行了
OC方法和函数的区别
OC方法只能声明在@interface和@end之间，只能实现在@implementation和@end之间。也就是说OC方法不能独立于类存在
C函数不属于类，跟类没有联系，C函数只归定义函数的文件所有
C函数不能访问OC对象的成员
低级错误：方法有声明，但是实现的时候写成了函数
OC的方法注意
方法只有声明，没有实现（经典错误）
方法没有声明，只有实现（编译器警告，但是能调用，OC的弱语法）
编译的时候：访问没有的成员变量直接报错，访问没有的方法，只是警告
@implementation
没有@interface，只有@implementation，也是能成功定义一个类的
@implementation Car : NSObject
{
@public
int wheels; // 多少个*
int speed; // 时速
}
- (void) run
{
NSLog(@"%i个*，%i时速的车子跑起来了", wheels, speed);
}
@end
@implementation中不能声明和@interface一样的成员变量
方法
设计一个Caculator计算器类，它拥有计算的功能（行为）
不带参数的方法
设计一个返回PI的方法
// 方法声明
- (double)pi;
// 方法实现
- (double)pi
{
return 3.14;
}
方法调用
带一个参数的方法
设计一个计算平方的方法
// 方法声明
- (double)square:(double)number;
// 方法实现
- (double)square:(double)number
{
return number * number;
}
方法调用
带多个参数的方法
设计一个计算和的方法
// 方法声明
- (double)sumOfNum1:(double)num1 andNum2:(double)num2;
// 方法实现
- (double)sumOfNum1:(double)num1 andNum2:(double)num2
{
return num1 + num2;
}
方法调用
方法名注意
冒号也是方法名的一部分
同一个类中不允许两个对象方法同名
set方法和get方法
set方法和get方法的使用场合
@public的成员可以被随意赋值，应该使用set方法和get方法来管理成员的访问（类似机场的安检、水龙头过滤，过滤掉不合理的东西），比如僵尸的生命值不能为负数
set方法
作用：用来设置成员变量，可以在方法里面过滤掉一些不合理的值
命名规范：
方法都是以set开头，而且后面跟上成员变量名，成员变量名的首字母必须大写
形参名称不要跟成员变量同名
get方法
作用：返回对象内部的成员变量
命名规范：get方法的名称一般就跟成员变量同名
成员变量的命名规范
成员变量都以下划线 _ 开头
可以跟get方法的名称区分开
可以跟其他局部变量区分开，一看到下划线开头的变量，肯定是成员变量
代码示例
#import <Foundation/Foundation.h>
// 声明
@interface Car : NSObject
{
int _wheels; // *个数
}
/*set方法*/
- (void) setWheels:(int)wheels;
/*get方法*/
- (int) wheels;
@end
@implementation Car
// set方法的实现
- (void) setWheels:(int)wheels
{
//对外面传进来的*数进行过滤
if (wheels<=0)
{
wheels = 1;
}
_wheels = wheels;
}
// get方法的实现
- (int) wheels
{
return _wheels;
}
@end
封装的好处
过滤不合理的值
屏蔽内部的赋值过程
让外界不必关注内部的细节
示例：
/*
人
类名：Person
属性（成员变量\实例变量）：体重、年龄
行为（方法）：走路、吃
*/
#import <Foundation/Foundation.h>
/*
1.类的声明
* 成员变量
* 方法的声明
*/
@interface Person : NSObject
{
@public
int age;
double weight;
}
- (void)walk;
- (void)eat;
@end
// 2.类的实现
@implementation Person
// 实现@interface中声明的方法
- (void)walk
{
NSLog(@"%d岁、%f公斤的人走了一段路", age, weight);
}
- (void)eat
{
NSLog(@"%d岁、%f公斤的人在吃东西", age, weight);
}
@end
int main()
{
// 在使用类创建对象之前，会将类加载进内存
Person *p = [Person new];
p->age = 20;
p->weight = 40;
[p eat];
[p walk];
Person *p2 = [Person new];
p2->age = 30;
p2->weight = 60;
[p2 eat];
[p2 walk];
/*
Person *p2 = [Person new];
p2->age = 30;
p2->weight = 50;
p = p2;
p->age = 40;
[p2 walk];
*/
/*
Person *p = [Person new];
p->age = 20;
Person *p2 = [Person new];
p2->weight = 50.0;
[p walk];
*/
/*
Person *p = [Person new];
p->age = 20;
p->weight = 50.0;
[p walk];
Person *p2 = [Person new];
p2->age = 30;
p2->weight = 60.0;
[p2 walk];
*/
return 0;
}
类方法
基本概念
直接可以用类名来执行的方法（类本身会在内存中占据存储空间，里面有类\对象方法列表）
类方法和对象方法对比
对象方法
以减号-开头
只能让对象调用，没有对象，这个方法根本不可能被执行
对象方法能访问实例变量（成员变量）
类方法
以加号+开头
只能用类名调用，对象不能调用
类方法中不能访问实例变量（成员变量）
使用场合：当不需要访问成员变量的时候，尽量用类方法
类方法和对象方法可以同名
示例:
/*
设计一个计算器类
* 求和
* 求平均值
*/
#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
{
int sum = [JiSusnQi sumOfNum1:num1 andNum2:num2];
return sum / 2;
}
@end
int main()
{
int a = [JiSusnQi averageOfNum1:10 andNum2:12];
NSLog(@"a=%d", a);
// JiSusnQi *jsq = [JiSusnQi new];
//
//
// [jsq sumOfNum1:10 andNum2:13];
return 0;
}
运行结果：
self关键字
成员变量和局部变量同名
当成员变量和局部变量同名时，采取就近原则，访问的是局部变量
用self访问成员变量，区分同名的局部变量
使用细节
出现的地方：所有的OC方法中（对象方法\类方法），不能出现在函数
作用
使用 "self->成员变量名"访问当前方法调用的成员变量
使用 "[self 方法名];"来调用方法（对象方法\类方法）
常见错误
低级错误：用self去调用函数
类方法中用self调用对象方法，对象方法中用self调用类方法
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);
// JiSusnQi *jsq = [JiSusnQi new];
//
//
// [jsq sumOfNum1:10 andNum2:13];
return 0;
}
运行结果：
示例：
设计一个方法，用来和其他车比较车速，返回车速的差距
#import <Foundation/Foundation.h>
@interface Car : NSObject
{
@public
int speed;
}
- (int)compareSpeedWithOther:(Car *)other;
@end
@implementation Car
- (int)compareSpeedWithOther:(Car *)other
{
// speed
// other->speed
// 返回当前这辆车和other这辆车的速度差距
return speed - other->speed;
}
@end
int main()
{
Car *c1 = [Car new];
c1->speed = 300;
Car *c2 = [Car new];
c2->speed = 250;
int a = [c1 compareSpeedWithOther:c2];
NSLog(@"a=%d", a);
return 0;
}
运行结果：
继承
继承的基本用法
设计两个类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
继承的专业术语
父类\超类 superclass
子类 subclass\subclasses
继承的细节
单继承
子类和父类不能有相同的成员变量
方法的重写
示例：
/*
1.重写：子类重新实现父类中的某个方法，覆盖父类以前的做法
2.注意
1> 父类必须声明在子类的前面
2> 子类不能拥有和父类相同的成员变量
3> 调用某个方法时，优先去当前类中找，如果找不到，去父类中找
2.坏处：耦合性太强
*/
#import <Foundation/Foundation.h>
// Person
@interface Person : NSObject
{
int _age;
}
- (void)setAge:(int)age;
- (int)age;
- (void)run;
+ (void)test;
@end
@implementation Person
+ (void)test
{
NSLog(@"Person+test");
}
- (void)run
{
NSLog(@"person---跑");
}
- (void)setAge:(int)age
{
_age = age;
}
- (int)age
{
return _age;
}
@end
// 不允许子类和父类拥有相同名称的成员变量
// Student
@interface Student : Person
{
int _no;
// int _age;
}
+ (void)test2;
@end
@implementation Student
// 重写：子类重新实现父类中的某个方法，覆盖父类以前的做法
- (void)run
{
NSLog(@"student---跑");
}
+ (void)test2
{
[self test];
}
@end
int main()
{
[Student test2];
// Student *s = [Student new];
//
// [s run];
return 0;
}
运行结果：
示例：
#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;
}
super关键字
分别调用父类的对象方法和类方法
super的作用
1.直接调用父类中的某个方法
2.super处在对象方法中，那么就会调用父类的对象方法
super处在类方法中，那么就会调用父类的类方法
3.使用场合：子类重写父类的方法时想保留父类的一些行为
示例：
/*
僵尸
跳跃僵尸、舞王僵尸、铁桶僵尸
*/
#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];
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
多态
多态的基本概念
某一类事物的多种形态
OC对象具有多态性
多态的体现
Person *p = [Student new];
p->age = 100;
[p walk];
子类对象赋值给父类指针
父类指针访问对应的属性和方法
多态的好处
用父类接收参数，节省代码
多态的局限性
不能访问子类的属性（可以考虑强制转换）
多态的细节
动态绑定：在运行时根据对象的类型确定动态调用的方法
示例：
#import <Foundation/Foundation.h>
/*
多态
1.没有继承就没有多态
2.代码体现：父类类型的指针指向子类对象
3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、
子类对象
4.局限性：
1》父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后，
才能直接调用子类特有的方法
2》
*/
@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()
{
NSString *d = [Cat new];
[d eat];
//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);
*/
//NSString *s = [Cat new];
//Cat *c = [Animal new];
// 多种形态
//Dog *d = [Dog new];
// 多态：父类指针指向子类对象
//Animal *a = [Dog new];
// 调用方法时会检测对象的真实形象
//[a eat];
return 0;
}
NSString的简单使用
字符串的快速创建
NSStirng *str = @“Hello”;
使用静态方法创建
使用%@输出字符串
NSString *name = @”mj”;
NSLog(@“我的名字是%@”, name);
示例：
#import <Foundation/Foundation.h>
int main()
{
/*
最简单的创建字符串的方式
NSString *str = @"itcast";
char *name = "itcast";
NSLog(@"我在%@上课", str);
//NSLog(@"%s", name);
*/
int age = 10;
int no = 5;
NSString *name = @"jack";
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;
}
运行结果：
