Objective-C——思想、类和对象

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一、面向对象和面向过程思想
OC是面向对象的，C是面向过程的。面向对象和面向过程只是解决问题的两种不同思想
1、面向对象和面向过程的区别
面向过程关注的是解决问题需要哪些步奏；面向对象关注的是解决问题需要哪些对象
没有开发经验很难感受到他们的区别，两种思想都能达到解决问题的目的，但是解决思路不一样
2、常用术语
面向过程 Procedure Oriented
面向对象 Object Oriented，简称OO
面向对象编程 Object Oriented Programming，简称OOP
二、类和对象的关系
面向对象中有2个非常重要的概念：类和对象
1、如何创建对象
现实生活的例子：如何创造汽车对象
需要先有汽车的建造图纸，图纸上描述清楚汽车应该具备的属性和功能（行为）
属性：轮子数、时速
功能（行为）：跑
然后再根据图纸上描述生成汽车
每一辆汽车都是对象，都有自己的具体的属性值，都是图纸的实例
图纸是抽象的，房子是具体的。图纸是对房子的高度概括
2、OC中的面向对象
OC中的类相当于图纸，用来描述一类事物。也就是说，要想创建对象，必须先有类
OC利用类来创建对象，对象是类的具体存在
因此，面向对象解决问题的应该是先考虑需要设计哪些类，再利用类创建多少个对象
需要设计哪些类，如何设计类
类的设计，只关心三样东西
事物的名称（类名）：人（person）
属性：身高（height）、年龄（age）
行为（功能）：跑（run）、打架（fight）
一般名词都是类
坦克发射3颗炮弹轰掉了2架飞机
3、拥有相同（或者类似）属性和行为的对象都可以抽象出一个类
4、类的设计
1）、类名
类名的第一个字母必须是大写
不能有下划线
多个英文单词，用驼峰标识
2）、属性
3）、行为
5、植物大战僵尸的僵尸
1）、僵尸
*类名：Zoombie
*属性：Life 、speed 、gongjili
*行为：walk 、bite 、die
3、雷电的飞机
*类名：plane
*属性：Lifegognjili 、speed 、bombCount
*行为：fly 、bomb 、shoot 、die
三、定义OC的类和创建OC的对象
接下来就在OC中模拟现实生活中的情况，创建一辆车出来。首先要有一个车子类，然后在利用车子类创建车子对象
要描述OC中类稍微麻烦一点，分2大步奏：类的声明、类的实现（定义）。跟函数类似，函数有分声明和定义
1、类的声明
1）、代码编写
定义一个Car类，拥有2个属性：轮子数、时速，1个行为：跑
类名、属性名的命名规则：标识符的规则
类名的命名规范：有意义、驼峰标识、首字母大写

//因为使用了NSObject
#import <Foundation/Foundation.h>
//完整地写一个函数：函数的声明和定义（实现）
//完整地写一个类：类的声明和实现
// 1、类的声明：
//声明对象的属性、行为
//NSObject目的是：让Car这个类具备创建对象的能力
@interface Car : NSObject
{//用来声明对象的属性
    @public
    int wheels; // 多少个轮子
    int speed; // 时速
}

//方法（行为）：方法名、参数、返回值（声明、实现）
//只要是OC对象的方法，必须以减号 - 开头
//OC方法中任何数据类型都必须用小括号（）括住。
//OC方法中的小括号（）：括住数据类型
-  (void)run; // 跑的行为
@end

2)成员变量
@interface的大括号{}中声明的变量：wheels、speed
@interface的大括号和函数的大括号是不一样的
默认会初始化为0

3)@public
@public可以让Car对象的wheels和speed属性被外界访问
可以让外部的指针间接访问对象内部的成员变量
4)NSObject
加上:NSObject的目的是让Car类具备创建对象的能力

2、类的实现

//用来实现@inteface中声明的方法
@implementation Car
//写方法的实现（说清楚方法里面有什么代码）
- (void) run
{
    NSLog(@"%i个轮子，%i时速的车子跑起来了", wheels, speed);
}
@end

第二个OC的类
/*
人
类名：Person
属性：（成员变量/实例变量）：体重、年龄
行为：（方法）：走路
*/
/*
1、类的声明
	*成员变量
	*方法的声明
*/
@interface 类名：NSObject
{
成员变量；……
}
方法声明；……
@end


@interface Person：NSObject
{
	@public
	Int  age；
	Double  weight;
}
- (void)walk;
@end
2、类的实现
@implementation 类名
//实现@interface中声明的方法
- （void）walk
{
	NSLog(@“走了一段路”)；
}
@end

Int main()
{
	Person *p = [Person new];
	P->age = 20;
	P->weight = 50.0;
	[p walk];
	Return 0;
}

3、创建对象
1）、代码编写

// 主函数
int main()
{//在OC中，想执行一些行为，就写上一个中括号【行为执行者 行为名称】
//利用类来创建对象
//执行了Car这个类的new行为来创建对象

//定义一个指针变量p,p将来指向的是Car类型的对象
//【Car new】会创建出一个新对象，并且会返回新对象本身（新对象的地址）
    // 创建车子对象
    Car *c = [Car new];
    c->wheels = 3;
    c->speed = 300;
//给c所指向对象发动一条run消息
    [c run];
    return 0;
}

2)main函数的代码分析、内存分析（对象在内存中有成员）
[Car new]每次都会创建出新的对象，并且返回对象的地址，那么就应该用一个指针变量保存对象的地址
Car *c = [Car new];
用一个指针变量c指向内存中的Car对象	
设置车子对象的属性
跟用指向结构体的指针访问结构体属性一样，用->
c->wheels = 3;
c->speed = 300;

4.创建多个Car对象
分别只设置wheels、speed属性
Car *c1 = [Car new];
c1->wheels = 4;
Car *c2 = [Car new];
c2->speed = 250;
[c1 run];
1个赋值给另一个，然后修改属性
Car *c1 = [Car new];
c1->wheels = 4;
c1->speed = 250;
Car *c2 = c1;
c2->wheels = 3;
[c1 run];

5.面向对象封装的好处
更加接近人类的思考方式
只需要关注对象，不需要关注步骤

6.对象与函数参数
对象成员变量作为函数参数
指向对象的指针作为函数参数
修改指向指向对象的成员
修改指针的指向

三、类的实现和声明
1.@interface和@implementation的分工
@interface就好像暴露在外面的时钟表面
@implementation就好像隐藏在时钟内部的构造实现
2、

/*方法和函数的区别
1、对象方法都是以减号 -
2、对象方法的声明必须写在@interface和@end之间
对象方法的实现必须写在@implementation和@end之间
3、对象方法只能由对象来调用
4、对象方法归类/对象所有
函数
1、函数能写在文件中的任意位置（@interface和@end之间除外），函数归文件所有
2、函数调用不依赖于对象
3、函数内部是不能直接通过成员变量名访问某个对象的成员变量
*/
@import<Foundation/Foundation.h>
@interface Car : NSObject
{
//成员变量/实例变量
//int wheels = 4 ;不允许在这里初始化
//static int wheels;不能随便将成员变量当作C语言中的变量来使用
Int wheels;
}
-(void)run;
@end
@implememtation Car
-(void)run
{
NSLog(@”%d个轮子的车跑起来了”，wheels);
}
@end

@interface Person : NSObject
@end
@implementation Person
@end
Int main ()

3、.OC方法和函数的区别
OC方法只能声明在@interface和@end之间，只能实现在@implementation和@end之间。也就是说OC方法不能独立于类存在
C函数不属于类，跟类没有联系，C函数只归定义函数的文件所有
C函数不能访问OC对象的成员
低级错误：方法有声明，但是实现的时候写成了函数
4、OC的方法注意
方法只有声明，没有实现（经典错误）
方法没有声明，只有实现（编译器警告，但是能调用，OC的弱语法）
编译的时候：访问没有的成员变量直接报错，访问没有的方法，只是警告

5.@implementation
没有@interface，只有@implementation，也是能成功定义一个类的
@implementation Car : NSObject
{
    @public
    int wheels; // 多少个轮子
    int speed; // 时速
}
- (void) run
{
    NSLog(@"%i个轮子，%i时速的车子跑起来了", wheels, speed);
}
@end
@implementation中不能声明和@interface一样的成员变量

四、方法

Typedef  enum{
SexMan,
SexWoman
}Sex;
Typedef struct{
Int year;
Int month;
Int day;
}Date;
Typedef enum{
ColorBlack,
ColorRed,
ColorGreen
}Color;
@interface Dog : NSObject
{
@public
Double weight;//体重
Color curColor;//毛色
}
- （void）eat;
-  (void)run;
@end
@implementation dog
- (void)eat
{//每吃一次，体重就加1
weight += 1;
//Weight = weight + 1;
NSLog(@”吃完这次后的体重是%f”,weight);
}
- (void)run
{//每跑一次，体重就减1
weight -= 1;
//Weight = weight - 1;
NSLog(@”跑完这次后的体重是%f”,weight);
}
@end
/*学生
成员变量：性别、生日、体重、最喜欢的颜色、狗(体重、毛色、吃、跑)
方法：吃、跑步、遛狗(让狗跑)、喂狗（让狗吃）
*/
#import<Foundation/Foundation.h>
@interface  Student : NSObject//声明
{
@public
Sex sex;//性别
Date birthday;//生日
Double weight;//体重（kg）
Color favcolor;//最喜欢的颜色
Char *name;
//重点：狗
Dog *dog;
}
- （void）eat;
-  (void)run;
- (void)print;
- （void）liugou;
- (void)weigou;
@end
@implementation Student
- （void）liudog
{//让狗跑起来（调用狗的run方法）
[dog run];

}
- (void)weidog
{
//让狗吃东西
[dog eat];
}

- (void)print
{
NSLog(@“性别=%d, 喜欢的颜色=%d, 姓名=%s， 生日=%d-%d-%d”, sex, favColor, name, birthday.year, birthday.month,birthday.day);
}
- (void)eat
{//每吃一次，体重就加1
weight += 1;
//Weight = weight + 1;
NSLog(@”吃完这次后的体重是%f”,weight);
}
- (void)run
{//每跑一次，体重就减1
weight -= 1;
//Weight = weight - 1;
NSLog(@”跑完这次后的体重是%f”,weight);
}
@end
Int main()
{
Student *s = 【Student new】;
Dog *d = [Dog new];
D->curColor = ColorGreen;
D->weight = 20;
S->dog = d;
[s liuDog];
[s weiDog];
S->weight = 50;
//性别
s->Sex = SexMan;
//生日
S->birthday.year = 2011;
S->birthday.month = 9;
S->birthday.day = 10;
//生日
Date d = {2011, 9 ,10};
S->birthday = d;
//Date d = {2011, 9 ,10};
//最喜欢的颜色
S->favColor = ColorBlack;
[s eat];
[s eat];

[s run];
[s run];
[s print];
Return 0;
}