黑马程序员-OC的面向对象

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

一.什么是面向对象
面向对象是指一种程序设计范型，同时也是一种程序开发的方法，将抽像的事物用计算机能理解的方式描述和实现的一种概念。

二.面向对象与面向过程编程语言有什么不同
面向对象更侧重如抽象，往往需要先抽象出一个对象，通过对象的行为的实现来达到目的，面向过程则侧重于过程，往往先有一个入口，然后按步就班的就一步步实现。

三.面向对象的好处
1、易维护
采用面向对象的设计结构，就可以使用一种经典的设计模式，可读性高，而且因为继承，协议，接口等存在，即使改变需要，也可能只需要维护少数模块。
2、兼容性强
在设计时，因为其模块化，所以可能重复利用，并且互不干扰，这样就可以让代码相互兼容。
3、效率高
在软件开发时，可以将常用的模块封装，当需要时就嵌入进去，使用这样的方法，可免去编写重复的代码。
4、易扩展
由于继承、封装、多态的特性，自然设计出高内聚、低耦合的架构，使得架构更灵活、更容易扩展。

四,面向对象的原则
找出应用中可能需要变化之处，把它们独立起来，不要和那些不需要变化的代码混在一起，封装那些可能变化的代码，以便轻易改动和扩展，并不影响其它的代码。

五.设计原则
针对接口编程而不针对实现编程

六.常用术语
1.面向过程 Procedure Oriented
2.面向对象 Object Oriented 简称oo
3.面向对象编程 Object Oriented Programming 管称oop

七.面向对象的三大特性

1.封装：用抽象的数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型内部。
2.继承：子类拥有父类的所有数据和操作。
3.多态：一个程序中同名的不同方法共存的情况。

八.设计类的三个步骤
1.类的名称
2.类的属性
3.类的行为(功能)
类与对象的关系
1.oc中的因相当于图纸，用来描述一类事物，也就是说，要想创建对象，必须先有类
2.oc利用类来创建对象，对象是类的具体存在。
3.因此，面向对象解决问题应该是先考虑需要设计哪些类，再利用类创建多少个对象。

九.OC例子

第1个oc类程序 第一个类的声明与实现
bogon:02oc whome$ touch 07oc.m
bogon:02oc whome$ open 07oc.m

试验性例子。

#import <Foundation/Foundation.h>//声明对象的属性，行为@interface Car{    //用来声明对象属性    int wheels;//轮胎个数        }{    int speed;//时速（xxkm/h）}@end

//2.类的实现

@implementation Car@end;int main(){    Car s = new Car();    s.wheels=0;    s.speed = 2;    NSLog(@"wheels=%d,speed=%d",s.wheels,s.speed);        return 0;}

bogon:02oc whome$ cc 07oc.m -framework Foundation
07oc.m:20:1: error: expected identifier or '('
{
^
07oc.m:13:12: warning: class 'Car' defined without specifying a base class
      [-Wobjc-root-class]
@interface Car
           ^
07oc.m:13:15: note: add a super class to fix this problem
@interface Car
              ^
               : NSObject
07oc.m:29:9: error: interface type cannot be statically allocated
    Car s = new Car();
        ^
        *
07oc.m:29:13: error: use of undeclared identifier 'new'
    Car s = new Car();
            ^
07oc.m:30:7: error: property 'wheels' not found on object of type 'Car *'; did
      you mean to access instance variable 'wheels'?
    s.wheels=0;
     ~^
     ->
07oc.m:31:7: error: property 'speed' not found on object of type 'Car *'
    s.speed = 2;
      ^
07oc.m:32:35: error: property 'wheels' not found on object of type 'Car *'; did
      you mean to access instance variable 'wheels'?
    NSLog(@"wheels=%d,speed=%d",s.wheels,s.speed);
                                 ~^
                                 ->
1 warning and 6 errors generated.

正常的程序:

#import <Foundation/Foundation.h>/* 类名：Car 属性：轮胎个数，时速（速度） 行为：跑  *///完整地写一个函数：函数的声明和定义（实现）//完整地写一个类：类的声明和实现//1.类的声明//声明对象的属性，行为//：NSObject 目的是：让Ｃar这个类具备创建对象的能力@interface Car : NSObject{    @public    //@public可以让外部的指针间接访问对象内部的成员变量    //用来声明对象属性(成员变量，默认会初始化为0)    int wheels;//轮胎个数    int speed;//时速（xxkm/h）    }//方法（实为），跟函数类似，都有名称，参数与返回值（声明和实现）//只要是oc对象的方法，必须已减号-开头//oc方法中，作何数据类型都必须用小括号（）括住//oc方法中，括号的作用只有：括住数据类型-(void)run;@end

//2.类的实现@implementation Car//方法的实现-(void)run{    NSLog(@"跑起来了");}@end;int main(){    //在oc中，想执行一些行为，就写上一个中括号［行为执行者 行为名称］    //利用类来创建对象    //执行了Ｃar这个类的new行为来创建新对象        //定义了一个Ｃar指针变量s，s将来指向的是Car类型的对象    //［Ｃar new］每次都会创建出一个新对象，并且会返回新对象本身（新对象的地址）    Car *s = [Car new];    s->wheels=0;    s->speed = 2;    NSLog(@"wheels=%d,speed=%d",s->wheels,s->speed);    //方法的执行    //给s所指的对象发送一条run消息    [s run];            return 0;}

bogon:02oc whome$ cc 07oc.m -framework Foundation
bogon:02oc whome$ ./a.out
2014-09-11 23:31:44.546 a.out[640:507] wheels=0,speed=2
2014-09-11 23:31:44.555 a.out[640:507] 跑起来了

第2个oc类程序 方法和成员变量
bogon:~ whome$ cd Desktop/oc/02oc
bogon:02oc whome$ touse 08oc.m
bogon:02oc whome$ open 08oc.m

#import <Foundation/Foundation.h>/* 类名称 （人）person 类属性  (成员变量，实例变量)身高体重 类行为  (走)walk*/@interface person : NSObject{   //属性，身高，体重    @public        int height;        int weight;}//走方法- (void) walk;@end

//类的实现//实现@interface中声明的方法@implementation person//在oc的类里面小括号只用来括住数据类型-(void) walk{    //类对象调用类属性无需再次引用    NSLog(@"小明身高=%d,体重=%d,开始走了",height,weight);}@end

int main(){    //用指针调用新创建的类对象    person *p = [person new];    //给类对象属性赋值    p->height=170;    p->weight=120;    //调用类对象属性方法    [p walk];        //第二个类对象    person *p1 = [person new];    p1->height=160;    p1->weight=100;    [p1 walk];    }

bogon:02oc whome$ cc 08oc.m -framework Foundation
bogon:02oc whome$ ./a.out
2014-09-14 19:51:03.707 a.out[465:507] 小明身高=170,体重=120,开始走了
2014-09-14 19:51:03.709 a.out[465:507] 小明身高=160,体重=100,开始走了

//关于类指针的互相调用
    person *p2 = [person new];
    p2->height=20;
    p2->weight=40;
    
    person *p3 = [person new];
    p3->height = 30;
    p3->weight = 50;
    //当p2不再指向原先p2的对象，指向p3后，它修改的将是p3所指的对象
     p2=p3;
    p2->height = 40;
    [p2 walk];
    [p3 walk];
2014-09-14 20:29:15.527 a.out[519:507] 小明身高=40,体重=50,走了一段路
2014-09-14 20:29:15.528 a.out[519:507] 小明身高=40,体重=50,走了一段路

/* 类名称 （人）person 类属性  (成员变量，实例变量)身高体重 类行为  (走)walk*/@interface person : NSObject{   //属性，身高，体重    @public        int height;        int weight;}//走方法- (void) walk;//多个方法- (void) eat;@end

//类的实现//实现@interface中声明的方法@implementation person//在oc的类里面小括号只用来括住数据类型-(void) walk{    //类对象调用类属性无需再次引用    NSLog(@"小明身高=%d,体重=%d,走了一段路",height,weight);}//多个方法实现-(void) eat{    //类对象调用类属性无需再次引用    NSLog(@"小明身高=%d,体重=%d,吃了点东西",height,weight);}@end

#import <Foundation/Foundation.h>@interface Car : NSObject{    @public    //轮子    int wheels;    //时速    int speed;}-(void)run;@end

@implementation Car- (void)run{    NSLog(@"%d个轮子，时速为%dkm/h，跑起来了",wheels,speed);}@end

void test(int w,int s){    w=6;    s=100;    NSLog(@"%d个轮子，时速为%dkm/h test",w,s);    }void test1(Car *newCar){    newCar->wheels=5;}void test2(Car *newCar){    Car *c2 = [Car new];    c2->wheels = 5;    c2->speed = 300;        newCar = c2;    newCar->wheels = 6;}int main(){    Car *c =[Car new];    c->wheels = 4;    c->speed = 250;    //c = 4,250    test(c->wheels,c->speed);    //c不变    test1(c);    //c＝ 5，250    test2(c);    //c不变，同时test2函数域里的newCar指向c的对象        [c run];    return 0;}

2014-09-15 00:00:12.178 a.out[634:507] 6个轮子，时速为100km/h test
2014-09-15 00:00:12.180 a.out[634:507] 5个轮子，时速为250km/h，跑起来了

常见错误
只有类的声明@interface没有类的实列@implementation
漏了@end
@interface和@implementation嵌套
只有代码块{}没有方法名
两个类的声明嵌套
成员变量没有写在括号里
方法的声明写在了大括号里面

语法细节
成员变量不能在{}中初始化，不能被直接拿出来访问
方法不能当做函数一样调用
成员变量\方法不能用static等关键字修饰，不能跟c语言混在一起
类的实现@implementation可以写在main函数的后面,主要在声明后面就行了。

oc方法和函数的区别
oc方法只能声明在@interface和@end之间，只能实现在@implementation和@end之间，也就是说oc方法不能独立于类存在
c函数于属于类，跟类没有联系，c函数只归定义函数的文件所有

关于类在内存的方式
类有自己的内存空间，每一次[class new]将复制一个对象并存放在另一个内存区域，这里面放着类的对象
类的对象地址由类的指针来进行访问
关于类的属性和方法的调用，先由类的指针查询类内存中的声明，然后在类对象的内存中读取对应的实现。

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