因为当我们不知道父类在该办法中实现的功能时

初学Objective-C,总是对其中的一些概念和关键字搞不清楚,为了更好的学习oc,还是总结了一下。 1、关键字 @ 看到这个关键字,我们就应当想到,这是Object-C对C说话的扩大,例如@interface XXX。 @interface声明类 @implementation实现类 @protocol声明和谈 @optional与@protocol共同应用,申明和谈中的某个或者某几个办法可以不实现 @required 与@protocol共同应用,申明和谈中的某个办法或者某几个办法必须实现 @end 与@interface ,@implementation,@protocol共同应用,代表声明或者实现停止 @encode @encode为编译器宏,它可以将类型转换为响应的字符串。 id id是指向Objective-C类对象的指针,它可以声明为任何类对象的指针,当在Objective-C中应用id时,编译器会假定你知道,id指向哪个类的对象。与void是不同的是,void编译器不知道也不假定指向任何类型的指针。 nil 定义为一个常量,若是一个指针的值为nil,代表这个指针没有指向任何对象。 self 在Objective-C中,关键字self与c++中this是同一概念,就是类对象自身的地址,经由过程self可以调用本身的实例变量和办法 Super 当子类须要调用父类的办法时,会用到Super关键字. Super指向的是父类的指针,子类重写父类的办法时,调用父类的办法是一个非常好的习惯。因为当我们不知道父类在该办法中实现的功能时,若是不调用父类的办法,有可能我们重写的办法会落空该功能,这是我们不想看到的景象。 NSNull NSNull是没有的意思,若是一个字典的值为NSNull,那申明与该值对应的Key是没有值的,例如Key为address,申明与address对应的是值是没有。

关键字

参考此文:http://www.2cto.com/kf/201403/284687.html
@
看到这个关键字,我们就应该想到,这是Object-C对C语言的扩展,例如@interface XXX。
@interface
声明类
@implementation
实现类
@protocol
声明协议

了解Objective-C特点及特征是本文要介绍的内容,目前好象只有Apple使用Objective-C作为其支持的语言吧。 不多说,直接来看详细内容,与C++的不同之处有:

@
看到这个关键字,我们就应该想到,这是Object-C对C语言的扩展,例如@interface XXX。
@interface
声明类
@implementation
实现类
@protocol
声明协议

self super class public protected private id

@

@optional
与@protocol配合使用,说明协议中的某个或者某几个方法可以不实现

Objective-C中所有的类都必须继承自NSObject。

@optional
与@protocol配合使用,说明协议中的某个或者某几个方法可以不实现

[self class] [super class] or

看到这个关键字,我们就应该想到,这是Object-C对C语言的扩展,例如@interface XXX。

@required
与@protocol配合使用,说明协议中的某个方法或者某几个方法必须实现

Objective-C中所有对象都是指针的形式。

@required
与@protocol配合使用,说明协议中的某个方法或者某几个方法必须实现

objective-c runtime reference 标准用法 self = [super init]

@interface

@end
与@interface ,@implementation,@protocol配合使用,代表声明或者实现结束

Objective-C用self代替this。

@end
与@interface ,@implementation,@protocol配合使用,代表声明或者实现结束

new Objective-C有一个特点,就是可以把类当成对象来发送消息,这种用法凡是用于新建对象时,例如 XXX *object = [XXX new]; 类办法 + 若是想声明属于类而不属于类对象的办法,用+。+用来润饰类的办法,应用+润饰的类办法,是全部类的办法,不属于哪一个类对象,这与C++中的static在类中应用的概念一样, %@ 在NSLog中,应用%@默示要调用对象的description办法。 2、概念 类 是一种布局,它默示对象的类型,就像int与 char 一样,也可以声明类的变量 实例化 为类的对象分派内存和初始化,达到可以应用该 类对象的目标。

声明类

@encode
@encode为编译器宏,它可以将类型转换为相应的字符串。

Objective-C使用id代替void*。

@encode
@encode为编译器宏,它可以将类型转换为相应的字符串。

对象 类的实例化后的产品 消息 在Object-C中,类的对象履行的操纵,是经由过程给该类或者该类对象发送消息实现,如:[object func];就是给object对象发送func消息,类似C++中的办法调用。给object对象发送func消息后,object对象查询所属类的 func办法履行。 办法调剂 当向一个对象发送消息时,这个办法是怎么被调用的呢?这就依附于办法高度法度,办法调剂法度查找的办法如下: 在本类的办法中,找被调用的办法,若是找到了,就调用,若是找不到被沿着持续路径去查找,从哪个类找到,就调用哪个类的办法,若是到最根上的类还是没有找到,那编译就会失足。 持续与复合 在Objective-C中支撑持续,但只是支撑单一持续(有且只有一个父类有),若是想应用多持续的特点,可以应用分类和和谈技巧。 持续是is-a,复合是has-a。复合是经由过程包含指向对象的指针实现的,严格意义上讲,复合是针对于对象间来说,对于根蒂根基数据类型来说,它们被认为是对象的一项目组。 装箱与拆箱 因为NSArray,NSDirectory等类不克不及直接存储根蒂根基数据类型,所以要想在NSArray\NSDirectory中应用根蒂根基数据类型,就得应用装箱与拆箱。 在Objective-C中,可以应用NSNumber和NSValue来实现对数据类型的包装,NSNumber可以实现对根蒂根基数据类型的包装,NSValue可以实现对随便率性类型数据的包装。

@implementation

id
id是指向Objective-C类对象的指针,它可以声明为任何类对象的指针,当在Objective-C中使用id时,编译器会假定你知道,id指向哪个类的对象。与void是不同的是,void编译器不知道也不假定指向任何类型的指针。

Objective-C使用nil表示NULL

id
id是指向Objective-C类对象的指针,它可以声明为任何类对象的指针,当在Objective-C中使用id时,编译器会假定你知道,id指向哪个类的对象。与void*是不同的是,void*编译器不知道也不假定指向任何类型的指针。

将根蒂根基类型封装成对象叫装箱,从封装的对象中提取根蒂根基类型叫拆箱,其它说话如Java原生支撑装箱与拆箱,Ojbective-C不支撑主动装箱与拆箱,若是须要得须要本身来实现装箱与拆箱。 存取办法 在应用类对象的实例变量时,不要直接应用对象中的实例,要应用存以办法来获取或者批改实例,既setter和 getter,在Cocoa中,存取办法有定名习惯,我们得合适这种习惯,以便于与其它团队成员合作。setter办法是批改或者设置实例值,定名习惯为 set+实例名,例有一个类有path实例变量,那setter定名为setPath,getter定名为Path,为什么不是getPath,因为 get在Cocoa中有特别的含义,这个含义就是带有get的办法就意味着这个办法经由过程形参指针(传入函数的参数指针)来返回值。我们要遵守这个定名 习惯或者说规矩。

实现类

nil
定义为一个常量,如果一个指针的值为nil,代表这个指针没有指向任何对象。

Objective-Ck只支持单继承。

nil
定义为一个常量,如果一个指针的值为nil,代表这个指针没有指向任何对象。

在Objective-C 2.0中参加了@property和@synthesize来庖代setter和getter,这两个关键字为编译器指令。 还有点表达式,存取类成员的值时,可以应用点表达式。

@protocol

self
在Objective-C中,关键字self与c++中this是同一概念,就是类对象自身的地址,通过self可以调用自己的实例变量和方法

Objective-C使用YES/NO表示TRUE/FALSE

self
在Objective-C中,关键字self与c++中this是同一概念,就是类对象自身的地址,通过self可以调用自己的实例变量和方法

Object.attribute,当点表达式在=号左边时,调用的是setter办法,在=号右边时,调用的是getter办法。

声明协议

Super
当子类需要调用父类的方法时,会用到Super关键字. Super指向的是父类的指针,子类重写父类的方法时,调用父类的方法是一个比较好的习 惯。因为 当我们不知道父类在该方法中实现的功能时,如果不调用父类的方法,有可能我们重写的方法会失去该功能,这是我们不愿意看到的情况。

Objective-C使用#import代替#include

Super
当子类需要调用父类的方法时,会用到Super关键字. Super指向的是父类的指针,子类重写父类的方法时,调用父类的方法是一个比较好的习 惯。因为 当我们不知道父类在该方法中实现的功能时,如果不调用父类的方法,有可能我们重写的方法会失去该功能,这是我们不愿意看到的情况。

@property 语法为:@property 类型 变量名.

@optional

NSNull
NSNull是没有的意思,如果一个字典的值为NSNull,那说明与该值对应的Key是没有值的,例如Key为address,说明与address对应的是值是没有。

Objective-C中用消息表示类的方法,并采用[aInstance method:argv]调用形式。

NSNull
NSNull是没有的意思,如果一个字典的值为NSNull,那说明与该值对应的Key是没有值的,例如Key为address,说明与address对应的是值是没有。

在这里首要申明一下参数.

与@protocol配合使用,说明协议中的某个或者某几个方法可以不实现

self super class public protected private id
[self class] [super class] selector
objective-c runtime reference

Objective-C支持反射机制

self super class public protected private id
[self class] [super class] selector
objective-c runtime reference

参数分为三种:

@required

标准用法
self = [super init]
new
1 Objective-C有一个特性,就是可以把类当成对象来发送消息,这种用法通常用于新建对像时,例如 XXX *object = [XXX new];
类方法 +

Objective-C支持Dynamic Typing, Dynamic Binding和Dynamic Loading。

标准用法
self = [super init]
new
1 Objective-C有一个特性,就是可以把类当成对象来发送消息,这种用法通常用于新建对像时,例如 XXX *object = [XXX new];
类方法 +

第一种:读写属性包含(readonly/readwrite/)

与@protocol配合使用,说明协议中的某个方法或者某几个方法必须实现

如果想声明属于类而不属于类对象的方法,用+。+用来修饰类的方法,使用+修饰的类方法,是整个类的方法,不属于哪一个类对象,这与C++中的static在类中使用的概念一样,

与C++的相同之处有:

如果想声明属于类而不属于类对象的方法,用+。+用来修饰类的方法,使用+修饰的类方法,是整个类的方法,不属于哪一个类对象,这与C++中的static在类中使用的概念一样,

第二种:setter属性(assign,copy,retain),assign是简单的赋值,copy是开释旧成员变量,并新分派内存地址给成员变 量,将传入参数内容复制一份,给成员变量。retain是将传 入 参数引用计数加1,然后将原有的成员变量开释,在将成员变量指向该传入参数。

@end

%@
在NSLog中,使用%@表示要调用对象的description方法。

与C共享的部分一致。

%@
在NSLog中,使用%@表示要调用对象的description方法。

第三种:与多线程有关(atomic,nonatomic).当应用多线程时,应用atomic,在不应用多线程时应用nonatomic对象创建与初始化 在Objective-C中创建对象有两种办法,一种是[类 new];另一种是[[类 alloc] init],这两种办法是等价的,但按常规来讲,应用[[类 alloc] init]; alloc操纵是为对象分派内存空间,并将对象的数据成员都初始,int 为0,BOOL 为NO, float 为0.0等。

与@interface ,@implementation,@protocol配合使用,代表声明或者实现结束

概念

是一种结构,它表示对象的类型,就像int与 char 一样,也可以声明类的变量(对像)

可以使用assert(BOOL), 一般用NSCParameterAssert(BOOL)代替。

概念

是一种结构,它表示对象的类型,就像int与 char 一样,也可以声明类的变量(对像)

初始化,默认的初始化函数为init,init返回值为id,为什么回返回id呢,因为要实现链式表达式,在Objective-C中叫嵌套调用。

@encode

实例化
为类的对象分配内存和初始化,达到可以使用该 类对象的目的。

Objective-C中的命名前缀说明:

实例化
为类的对象分配内存和初始化,达到可以使用该 类对象的目的。

为什么要嵌套调用??因为初始化办法init返回值可能与alloc返回的对象不是同一个?为什么会产生这种景象?基于类簇的初始化,因为init可以接管参数,在init内部有可能按照不合的参数来返回不合种类型的对象,所以最会产生上方说的景象。

@encode为编译器宏,它可以将类型转换为相应的字符串。

对象(实例)
类的实例化后的产物

NS-:NextStep   CF-:Core Foundation   CA-:Core Animation   CG-:Core Graphics   UI-:User Interface  

对象(实例)
类的实例化后的产物

在初始化时,建议应用if (self = [super init]) 便利初始化 当一个类须要按照不同的景象来初始化数据成员时,就须要便利初始化函数,与init初始化不同的是,便利初始化函数有参数,参数个数可以有1到N个,N是类数据成员个数。 指定初始化函数:什么是指定初始化函数?在类中,某个初始化函数会被指定为指定的初始化函数,断定指定初始化函数的规矩是初始化函数中,参数最多的为指定初始化函数,

id

消息
在Object-C中,类的对象执行的操作,是通过给该类或者该类对象发送消息实现,如:[object func];就是给object对象发送 func消息,类似C++中的方法调用。给object对象发送func消息后,object对象查询所属类的func方法执行。

Objective-C中的消息特殊性:

消息
在Object-C中,类的对象执行的操作,是通过给该类或者该类对象发送消息实现,如:[object func];就是给object对象发送 func消息,类似C++中的方法调用。给object对象发送func消息后,object对象查询所属类的func方法执行。

其它未被指定为指定初始化函数的初始化函数要调用指定初始化函数来实现。对于该类的子类也是一样,只要重写或者直接应用父类的指定初始化函数。上述文字有些绕,来个例子吧

id是指向Objective-C类对象的指针,它可以声明为任何类对象的指针,当在Objective-C中使用id时,编译器会假定你知道,id指向哪个类的对象。与void*是不同的是,void*编译器不知道也不假定指向任何类型的指针。

方法调度
当向一个对象发送消息时(调用方法),这个方法是怎么被调用的呢?这就依赖于方法高度程序,方法调度程序查找的方法如下:

调用消息的类可以不知道如何响应这个消息。如果它不知道如何处理这个消息,它会自动的将这个消息转给其他的类,比如它的父类。

方法调度
当向一个对象发送消息时(调用方法),这个方法是怎么被调用的呢?这就依赖于方法高度程序,方法调度程序查找的方法如下:

@interface A{

nil

在本类的方法中,找被调用的方法,如果找到了,就调用,如果找不到被沿着继承路径去查找,从哪个类找到,就调用哪个类的方法,如果到最根上的类还是没有找到,那编译就会出错。

调用消息的类可以是nil。在C++中,在使用类方法之前,我们都需要检查对象是否为空,所以在实现析构函数的时候,常会有如下的代码,如if (var) { delete var; } 但是在Objective-C中,我们就可以直接写[var release]; 即使var == nil, 也不会有问题。

在本类的方法中,找被调用的方法,如果找到了,就调用,如果找不到被沿着继承路径去查找,从哪个类找到,就调用哪个类的方法,如果到最根上的类还是没有找到,那编译就会出错。

int x;

定义为一个常量,如果一个指针的值为nil,代表这个指针没有指向任何对象。

继承与复合

Objective-C中的函数声明格式有:

继承与复合

int y;

self

在Objective-C中支持继承,但只是支持单一继承(有且只有一个父类有),如果想使用多继承的特性,可以使用分类和协议技术。
继承是is-a,复合是has-a。复合是通过包含指向对象的指针实现的,严格意义上讲,复合是针对于对象间来说,对于基本数据类型来说,它们被认为是对象的一部分。
装箱与拆箱
由于NSArray,NSDirectory等类不能直接存储基本数据类型,所以要想在NSArray\NSDirectory中使用基本数据类型,就得使用装箱与拆箱。
在Objective-C中,可以使用NSNumber和NSValue来实现对数据类型的包装,NSNumber可以实现对基本数据类型的包装,NSValue可以实现对任意类型数据的包装。
将基本类型封装成对象叫装箱,从封装的对象中提取基本类型叫拆箱(取消装箱),其它语言如Java原生支持装箱与拆箱,Ojbective-C不支持自动装箱与拆箱,如果需要得需要自己来实现装箱与拆箱。
存取方法

-/+ (return type) function_name;   -/+ (return type) function_name : (parameter type) parameter;   -/+ (return type) function_name :   (parameter type) parameter1 otherParameter :   (parameter_type) parameter2  

在Objective-C中支持继承,但只是支持单一继承(有且只有一个父类有),如果想使用多继承的特性,可以使用分类和协议技术。
继承是is-a,复合是has-a。复合是通过包含指向对象的指针实现的,严格意义上讲,复合是针对于对象间来说,对于基本数据类型来说,它们被认为是对象的一部分。
装箱与拆箱
由于NSArray,NSDirectory等类不能直接存储基本数据类型,所以要想在NSArray\NSDirectory中使用基本数据类型,就得使用装箱与拆箱。
在Objective-C中,可以使用NSNumber和NSValue来实现对数据类型的包装,NSNumber可以实现对基本数据类型的包装,NSValue可以实现对任意类型数据的包装。
将基本类型封装成对象叫装箱,从封装的对象中提取基本类型叫拆箱(取消装箱),其它语言如Java原生支持装箱与拆箱,Ojbective-C不支持自动装箱与拆箱,如果需要得需要自己来实现装箱与拆箱。
存取方法

}

在Objective-C中,关键字self与c++中this是同一概念,就是类对象自身的地址,通过self可以调用自己的实例变量和方法

在使用类对象的实例变量(成员数据)时,不要直接使用对象中的实例,要使用存以方法来获取或者修改实例,既setter和getter,在 Cocoa中, 存取方法有命名习惯,我们得符合这种习惯,以便于与其它团队成员合作。setter方法是修改或者设置实例值,命名习惯为set+实例名,例有一个类有 path实例变量,那setter命名为setPath,getter命名为Path,为什么不是getPath,因为get在Cocoa中有特殊的含 义,这个含义就是带有get的方法就意味着这个方法通过形参指针(传入函数的参数指针)来返回值。我们要遵守这个命名习惯或者说规则。

以上参数说明:-表示一般函数,+表示静态函数。otherParameter是参数的别名(第一个参数的别名省略),在函数调用时方便指定。

在使用类对象的实例变量(成员数据)时,不要直接使用对象中的实例,要使用存以方法来获取或者修改实例,既setter和getter,在 Cocoa中, 存取方法有命名习惯,我们得符合这种习惯,以便于与其它团队成员合作。setter方法是修改或者设置实例值,命名习惯为set+实例名,例有一个类有 path实例变量,那setter命名为setPath,getter命名为Path,为什么不是getPath,因为get在Cocoa中有特殊的含 义,这个含义就是带有get的方法就意味着这个方法通过形参指针(传入函数的参数指针)来返回值。我们要遵守这个命名习惯或者说规则。

- init;

Super

在Objective-C 2.0中加入了@property和@synthesize来代替setter和getter,这两个关键字为编译器指令。还有点表达式,存取类成员的值时,可以使用点表达式。
Object.attribute,当点表达式在=号左边时,调用的是setter方法,在=号右边时,调用的是getter方法。
@property 语法为:@property (参数) 类型 变量名.
在这里主要说明一下参数.

Objective-C中的构造/析构函数

在Objective-C 2.0中加入了@property和@synthesize来代替setter和getter,这两个关键字为编译器指令。还有点表达式,存取类成员的值时,可以使用点表达式。
Object.attribute,当点表达式在=号左边时,调用的是setter方法,在=号右边时,调用的是getter方法。
@property 语法为:@property (参数) 类型 变量名.
在这里主要说明一下参数.

- initWithX: xValue;

当子类需要调用父类的方法时,会用到Super关键字. Super指向的是父类的指针,子类重写父类的方法时,调用父类的方法是一个比较好的习惯。因为当我们不知道父类在该方法中实现的功能时,如果不调用父类的方法,有可能我们重写的方法会失去该功能,这是我们不愿意看到的情况。

参数分为三种:
第一种:读写属性包括(readonly/readwrite/)
第二种:setter属性(assign,copy,retain),assign是简单的赋值,copy是释放旧成员变量,并新分配内存地址给成 员 变量,将传入参数内容复制一份,给成员变量。retain是将传入 参数引用计数加1,然后将原有的成员变量释放,在将成员变量指向该传入参数。
第三种:与多线程有关(atomic,nonatomic).当使用多线程时,使用atomic,在不使用多线程时使用nonatomic

Objective-C中的init()/release()对应于C++的构造/析构函数。alloc()/dealloc()也就对应于C++的new和delete,其中的dealloc()由于引用计数的自动调用而不用手动调用。

参数分为三种:
第一种:读写属性包括(readonly/readwrite/)
第二种:setter属性(assign,copy,retain),assign是简单的赋值,copy是释放旧成员变量,并新分配内存地址给成 员 变量,将传入参数内容复制一份,给成员变量。retain是将传入 参数引用计数加1,然后将原有的成员变量释放,在将成员变量指向该传入参数。
第三种:与多线程有关(atomic,nonatomic).当使用多线程时,使用atomic,在不使用多线程时使用nonatomic

- initWithY: yValue;

NSNull

对象创建与初始化
在Objective-C中创建对象有两种方法,一种是[类 new];另一种是[[类 alloc] init],这两种方法是等价的,但按惯例来讲,使用[[类 alloc] init];
alloc操作是为对象分配内存空间,并将对象的数据成员都初始,int 为0,BOOL 为NO, float 为0.0等。
初始化,默认的初始化函数为init,init返回值为id,为什么回返回id呢,因为要实现链式表达式,在Objective-C中叫嵌套调用。

Objective-C中父类的init()/release()函数需要子类的手动调用。而且每次都必须调用。不同于C++的自动调用。

对象创建与初始化
在Objective-C中创建对象有两种方法,一种是[类 new];另一种是[[类 alloc] init],这两种方法是等价的,但按惯例来讲,使用[[类 alloc] init];
alloc操作是为对象分配内存空间,并将对象的数据成员都初始,int 为0,BOOL 为NO, float 为0.0等。
初始化,默认的初始化函数为init,init返回值为id,为什么回返回id呢,因为要实现链式表达式,在Objective-C中叫嵌套调用。

- initWithXY: xValue

NSNull是没有的意思,如果一个字典的值为NSNull,那说明与该值对应的Key是没有值的,例如Key为address,说明与address对应的是值是没有。

为什么要嵌套调用??因为初始化方法init返回值可能与alloc返回的对象不是同一个?为什么会发生这种情况?基于类簇的初始化,因为init可以接受参数,在init内部有可能根据不同的参数来返回不同种类型的对象,所以最会发生上面说的情况。

构造函数(- (id) init)调用形如:CSample* pSample=[CSample alloc] init];其中alloc(+ (id) alloc)是继承来的static函数,init是继承来的一般函数,如重写一般函数时,则相当于C++的覆盖(不带参数)或重载(带参数)。

为什么要嵌套调用??因为初始化方法init返回值可能与alloc返回的对象不是同一个?为什么会发生这种情况?基于类簇的初始化,因为init可以接受参数,在init内部有可能根据不同的参数来返回不同种类型的对象,所以最会发生上面说的情况。

yVal: yValue;

self super class public protected private id

在初始化时,建议使用if (self = [super init])
便利初始化

析构函数(- (void) release)将引用计数减1,当=0时父类的release()会自动调用dealloc(- (void) dealloc);

在初始化时,建议使用if (self = [super init])
便利初始化

@end

[self class] [super class]  selector

当一个类需要根据不同的情况来初始化数据成员时,就需要便利初始化函数,与init初始化不同的是,便利初始化函数有参数,参数个数可以有1到N个,N是类数据成员个数。

当Objective-C没有数据成员时,可省略{},建议保留。

当一个类需要根据不同的情况来初始化数据成员时,就需要便利初始化函数,与init初始化不同的是,便利初始化函数有参数,参数个数可以有1到N个,N是类数据成员个数。

这里initWithXY被断定为指定初始化函数。

objective-c runtime reference

指定初始化函数:什么是指定初始化函数?在类中,某个初始化函数会被指定为指定的初始化函数,确定指定初始化函数的规则是初始化函数中,参数最多的为指定初始化函数,其它未被指定为指定初始化函数的初始化函数要调用指定初始化函数来实现。对于该类的子类也是一样,只要重写或者直接使用父类的指定初始化函数。上述文字有些绕,来个例子吧
@interface A{

继承下来的方法,如:-(id) init可以头文件中省略,建议保留

指定初始化函数:什么是指定初始化函数?在类中,某个初始化函数会被指定为指定的初始化函数,确定指定初始化函数的规则是初始化函数中,参数最多的为指定初始化函数,其它未被指定为指定初始化函数的初始化函数要调用指定初始化函数来实现。对于该类的子类也是一样,只要重写或者直接使用父类的指定初始化函数。上述文字有些绕,来个例子吧
@interface A{

- initWithXY: xValue

标准用法

int x;
int y;
}

0-C中只有数据成员的访问限制,没有方法的访问限制。

int x;
int y;
}

yVal: yValue{

self = [super init]

-(id) init;

同C++一样,数据成员有三种访问限制public, protected, private,缺省是protected。

-(id) init;

if (self = [super init]){

new

-(id) initWithX:(int) xValue;

示例:

-(id) initWithX:(int) xValue;

x = xValue;

1 Objective-C有一个特性,就是可以把类当成对象来发送消息,这种用法通常用于新建对像时,例如 XXX *object = [XXX new];

-(id) initWithY:(int) yValue;

 @interface AccessExample: NSObject {  @public      int publicVar;  @protected      int protectedVar;  @private      int privateVar;  }  @end  

-(id) initWithY:(int) yValue;

y = yValue;

类方法 +

-(id) initWithXY:(int) xValue

方法的访问限制可通过Category实现

-(id) initWithXY:(int) xValue

}

如果想声明属于类而不属于类对象的方法,用+。+用来修饰类的方法,使用+修饰的类方法,是整个类的方法,不属于哪一个类对象,这与C++中的static在类中使用的概念一样,

yVal:(int) yValue;

示例:

yVal:(int) yValue;

return self;

%@

@end

@interface MyClass  - (void) sayHello {      NSLog(@"Hello");  }  @end      @interface MyClass(Private)  - (void) kissGoodbye;  @end  

@end

}

在NSLog中,使用%@表示要调用对象的description方法。

这里initWithXY被确定为指定初始化函数。

Objective-C中没有类的静态变量,只有全局变量

这里initWithXY被确定为指定初始化函数。

- init{

概念

-(id) initWithXY:(int) xValue

Objective-C中的数组NSArray可以保存不同类型的数据。

-(id) initWithXY:(int) xValue

if (self = self initWithXY:10

yVal:(int) yValue{

Objective-C也支持run-time时的类类型检查

yVal:(int) yValue{

yVal:20){

是一种结构,它表示对象的类型,就像int与 char 一样,也可以声明类的变量(对像)

if (self = [super init]){

- (BOOL) isKindOfClass: classObj 

if (self = [super init]){

}

实例化

x = xValue;

用于判断该对象是否属于某个类或者它的子类

x = xValue;

return self;

为类的对象分配内存和初始化,达到可以使用该 类对象的目的。

y = yValue;

- (BOOL) isMemberOfClass: classObj 

y = yValue;

}

对象(实例)

}

用于判断该对象是否属于某个类这里不包括子类)

}

…….

类的实例化后的产物

return self;
}

- (BOOL) respondsToSelector: selector 

return self;
}

@interface B: A{

消息

-(id) init{

用于判断该对象是否能响应某个消息。这里,我们可以将@selector后面带的参数理解为C++中的函数指针。

-(id) init{

int z;

在Object-C中,类的对象执行的操作,是通过给该类或者该类对象发送消息实现,如:[object func];就是给object对象发送func消息,类似C++中的方法调用。给object对象发送func消息后,object对象查询所属类的func方法执行。

if (self = self initWithXY:10

注意:

if (self = self initWithXY:10

}

方法调度

yVal:20){

1)不要忘了@

yVal:20){

- initWithXY……;

当向一个对象发送消息时(调用方法),这个方法是怎么被调用的呢?这就依赖于方法高度程序,方法调度程序查找的方法如下:

}

2)@selector后面用的是(),而不是[]。

}

@end

在本类的方法中,找被调用的方法,如果找到了,就调用,如果找不到被沿着继承路径去查找,从哪个类找到,就调用哪个类的方法,如果到最根上的类还是没有找到,那编译就会出错。

return self;

3)要在消息名称后面跟:,无论这个消息是否带参数。如:

return self;

@implementation B

继承与复合

}
.......

[pSquare respondsToSelector:@selector(Set: andHeight:)]。   + (BOOL) instancesRespondToSelector: selector 

}
.......

- initWithXY: xValue

在Objective-C中支持继承,但只是支持单一继承(有且只有一个父类有),如果想使用多继承的特性,可以使用分类和协议技术。

@interface B: A{
int z;

用于判断该类是否能响应某个消息。这是一个静态函数

@interface B: A{
int z;

yVal: yValue{

继承是is-a,复合是has-a。复合是通过包含指向对象的指针实现的,严格意义上讲,复合是针对于对象间来说,对于基本数据类型来说,它们被认为是对象的一部分。

}

-(id) performSelector: selector :调用对象的selector方法。

}

if (self = [super initWithXY:10

装箱与拆箱

-(jd) initWithXY......;

conformsToProtocol 类似于respondsToSelector ,用于动态检查某个对象是否遵守某个协议。

-(jd) initWithXY......;

yVal=20]){

由于NSArray,NSDirectory等类不能直接存储基本数据类型,所以要想在NSArray\NSDirectory中使用基本数据类型,就得使用装箱与拆箱。

@end

Category:在没有源代码的情况下,为一个已经存在的类添加一些新的功能

@end

z= 40;

在Objective-C中,可以使用NSNumber和NSValue来实现对数据类型的包装,NSNumber可以实现对基本数据类型的包装,NSValue可以实现对任意类型数据的包装。

@implementation B

只能添加新的方法,不能添加新的数据成员

@implementation B

}

将基本类型封装成对象叫装箱,从封装的对象中提取基本类型叫拆箱(取消装箱),其它语言如Java原生支持装箱与拆箱,Ojbective-C不支持自动装箱与拆箱,如果需要得需要自己来实现装箱与拆箱。

-(id) initWithXY:(int) xValue

Category 的名字必须是唯一的

-(id) initWithXY:(int) xValue

return self;

存取方法

yVal:(int) yValue{

Protocol:相当于C++中的纯虚类

yVal:(int) yValue{

}

在使用类对象的实例变量(成员数据)时,不要直接使用对象中的实例,要使用存以方法来获取或者修改实例,既setter和getter,在Cocoa中,存取方法有命名习惯,我们得符合这种习惯,以便于与其它团队成员合作。setter方法是修改或者设置实例值,命名习惯为set+实例名,例有一个类有path实例变量,那setter命名为setPath,getter命名为Path,为什么不是getPath,因为get在Cocoa中有特殊的含义,这个含义就是带有get的方法就意味着这个方法通过形参指针(传入函数的参数指针)来返回值。我们要遵守这个命名习惯或者说规则。

if (self = [super initWithXY:10

形如:

if (self = [super initWithXY:10

@end 主动开释池 内存经管是软件代码中的重中之重,内存经管的短长,直接影响着软件的稳定性。在Cocoa中,有主动开释池,这类似于C++中的智能指针。 NSObject有一个办法是autorelease,当一个对象调用这个办法时,就会将这个对象放入到主动开释池中。

在Objective-C 2.0中加入了@property和@synthesize来代替setter和getter,这两个关键字为编译器指令。 还有点表达式,存取类成员的值时,可以使用点表达式。

yVal=20]){

@interface MyDate: NSObject <Printing> { } @end  

yVal=20]){

drain,该办法是清空主动开释池,不是烧毁它。drain办法只实用于Mac OS X 10.4以上的版本,在我们写的代码中要应用release,release实用于所有版本。

Object.attribute,当点表达式在=号左边时,调用的是setter方法,在=号右边时,调用的是getter方法。

z= 40;

使用:

z= 40;

主动开释池是以栈的体式格式实现,当创建一个主动开释池A时,A被压入栈顶,这时将接入autorelease消息的对象放入A主动 开释池,这时创建一个新的B主动开释池,B被压入栈顶,创建完成后删除B,这个接管autorelease消息的对象依然存在,因为A主动开释池依然存 在。 引用计数 每个对象都有一个与之响应的整数,称它为引用计数,当该 引用计数为0时,Objective-C主动向该对象发送dealloc,以烧毁该对向,与该引用计数相干的办法有下面几个 1 增长引用计数:经由过程alloc,new,copy创建一个对象时,该对象的引用计数加1(其实就是1,因为之前为0)

@property 语法为:@property (参数) 类型 变量名.

}

MyDate * dat = [[MyDate alloc] init]; id<Printing> var = dat; [var print]。  

}

2 增长引用计数: retain

在这里主要说明一下参数.

return self;

说明:我们首先声明了Printing 协议,任何遵守这个协议的类,都必须实现print 方法。在Objective-C 中,我们通过<>来表示遵守某个协议。当某个类声明要遵守某个协议之后,它就必须在.m文件中实现这个协议中的所有方法。使用id<Printing> 作为类型,而不是象C++中的Printing* var。

return self;

3 削减引用计数: release

参数分为三种:

}
@end

IBOutlet, IBAction: 这两个东西其实在语法中没有太大的作用。如果你希望在Interface Builder中能看到这个控件对象,那么在定义的时候前面加上IBOutlet,在IB里就能看到这个对象的outlet,如果你希望在Interface Builder里控制某个对象执行某些动作,就在方法前面加上(IBAction)。

}
@end

局项目组配内存:

第一种:读写属性包括(readonly/readwrite/)

自动释放池

尽量避免在一行语句中进行两层以上的嵌套

自动释放池

1 若是应用alloc,new,copy创建对象,则须要主动调用对象的release办法

第二种:setter属性(assign,copy,retain),assign是简单的赋值,copy是释放旧成员变量,并新分配内存地址给成员变量,将传入参数内容复制一份,给成员变量。retain是将传 入参数引用计数加1,然后将原有的成员变量释放,在将成员变量指向该传入参数。

内存管理是软件代码中的重中之重,内存管理的好坏,直接影响着软件的稳定性。在Cocoa中,有自动释放池,这类似于C++中的智能指针。
NSObject有一个方法是autorelease,当一个对象调用这个方法时,就会将这个对象放入到自动释放池中。
drain,该方法是清空自动释放池,不是销毁它。drain方法只适用于Mac OS X 10.4以上的版本,在我们写的代码中要使用release,release适用于所有版本。
自动释放池是以栈的方式实现,当创建一个自动释放池A时,A被压入栈顶,这时将接入autorelease消息的对象放入A自动释放池,这时创建一 个新的 B自动释放池,B被压入栈顶,创建完成后删除B,这个接收autorelease消息的对象依然存在,因为A自动释放池依然存在。

消息转发:

内存管理是软件代码中的重中之重,内存管理的好坏,直接影响着软件的稳定性。在Cocoa中,有自动释放池,这类似于C++中的智能指针。
NSObject有一个方法是autorelease,当一个对象调用这个方法时,就会将这个对象放入到自动释放池中。
drain,该方法是清空自动释放池,不是销毁它。drain方法只适用于Mac OS X 10.4以上的版本,在我们写的代码中要使用release,release适用于所有版本。
自动释放池是以栈的方式实现,当创建一个自动释放池A时,A被压入栈顶,这时将接入autorelease消息的对象放入A自动释放池,这时创建一 个新的 B自动释放池,B被压入栈顶,创建完成后删除B,这个接收autorelease消息的对象依然存在,因为A自动释放池依然存在。

2 若是应用非alloc,new,copy创建对象,我们认为该 对象引用计数为1,并已经参加了主动开释池,我们不须要主动的调用对象的release办法。

第三种:与多线程有关(atomic,nonatomic).当使用多线程时,使用atomic,在不使用多线程时使用nonatomic

引用计数
每个对象都有一个与之相应的整数,称它为引用计数,当该引用计数为0时,Objective-C自动向该对象发送dealloc,以销毁该对向,与该引用计数相关的方法(消息)有下面几个
1 增加引用计数:通过alloc,new,copy创建一个对象时,该对象的引用计数加1(其实就是1,因为之前为0)

- (void) forwardInvocation: (NSInvocation*)anInvocation;  

引用计数
每个对象都有一个与之相应的整数,称它为引用计数,当该引用计数为0时,Objective-C自动向该对象发送dealloc,以销毁该对向,与该引用计数相关的方法(消息)有下面几个
1 增加引用计数:通过alloc,new,copy创建一个对象时,该对象的引用计数加1(其实就是1,因为之前为0)

拥有对象(在类中以成员的办法存在):

对象创建与初始化

2 增加引用计数: retain

小结:了解Objective-C特点及特征的内容介绍完了,希望本文对你有所帮助!

2 增加引用计数: retain

1 若是应用alloc,new,copy创建对象,则须要在dealloc办法中,开释该对象

在Objective-C中创建对象有两种方法,一种是[类 new];另一种是[[类 alloc] init],这两种方法是等价的,但按惯例来讲,使用[[类 alloc] init];

3 减少引用计数: release

Objective-C 特点及特征是本文要介绍的内容,目前好象只有Apple使用 Objective-C 作为其支持的语言吧。 不多说,直接来看详细内容,与C...

3 减少引用计数: release

2 若是应用非alloc,new,copy创建对象,则在拥有该对象时,保存该对象(履行retain办法),在dealloc办法中,开释该对象。 dealloc 当对象的引用计数为0时,Objective-C会主动发送对象的dealloc消息(主动调用对象的dealloc办法,类似于C++的析构函数),所以我们可以本身重写dealloc办法,来实现类里的对其它应用资料的释放工作。 重视:不要直接在代码中显示调用dealloc办法。 垃圾收受接管 在Objective-C 2.0中引入了垃圾收受接管机制,在工程设置里设置Objective-C Garbage Collection为Required[-fobjc-gc-only]就可以应用垃圾收受接管机制。 启用垃圾收受接管机制后,凡是的内存经管号令都变成了空操纵指令,不履行任何操纵。

alloc操作是为对象分配内存空间,并将对象的数据成员都初始,int 为0,BOOL 为NO, float 为0.0等。

局部分配内存(临时对象):

局部分配内存(临时对象):

Objective-C的垃圾收受接管机制是一种持续性的垃圾收受接管器,垃圾收受接管器按期搜检变量和对象以及他们之间的指针,当发 明没有任何变量指向对象时,就将该对象视为被丢弃的垃圾。所以在不在应用一个对象时,将指针他的指针设置为nil,这时垃圾收受接管器就会清理该对象。

初始化,默认的初始化函数为init,init返回值为id,为什么回返回id呢,因为要实现链式表达式,在Objective-C中叫嵌套调用。

1 如果使用alloc,new,copy创建对象,则需要主动调用对象的release方法
2 如果使用非alloc,new,copy创建对象,我们认为该对象引用计数为1,并已经加入了自动释放池,我们不需要主动的调用对象的release方法。

1 如果使用alloc,new,copy创建对象,则需要主动调用对象的release方法
2 如果使用非alloc,new,copy创建对象,我们认为该对象引用计数为1,并已经加入了自动释放池,我们不需要主动的调用对象的release方法。

重视:若是开辟iPhone软件,则不克不及应用垃圾收受接管。在编写iPhone软件时,Apple公司建议不要在本身的代码中应用autorelease办法,并且不要应用创建主动开释对象的函数。 类别 什么是类别?类别是一种为现有类添加新办法的体式格式。

为什么要嵌套调用??因为初始化方法init返回值可能与alloc返回的对象不是同一个?为什么会发生这种情况?基于类簇的初始化,因为init可以接受参数,在init内部有可能根据不同的参数来返回不同种类型的对象,所以最会发生上面说的情况。

拥有对象(在类中以成员的方法存在):

拥有对象(在类中以成员的方法存在):

为什么应用类别或者说应用类此外目标是什么?有以下三点:

在初始化时,建议使用if (self = [super init])

1 如果使用alloc,new,copy创建对象,则需要在dealloc方法中,释放该对象

1 如果使用alloc,new,copy创建对象,则需要在dealloc方法中,释放该对象

第一,可以将类的实现分离到多个不合的文件或多个不合的框架中。

便利初始化

2 如果使用非alloc,new,copy创建对象,则在拥有该对象时,保留该对象(执行retain方法),在dealloc方法中,释放该对象。

2 如果使用非alloc,new,copy创建对象,则在拥有该对象时,保留该对象(执行retain方法),在dealloc方法中,释放该对象。

若是一个类须要实现很多个办法,我们可以将办法分类,把分好的类形成类别,可以有效的经管和驾驭代码。第二,创建对私有办法的前向引用。

当一个类需要根据不同的情况来初始化数据成员时,就需要便利初始化函数,与init初始化不同的是,便利初始化函数有参数,参数个数可以有1到N个,N是类数据成员个数。

dealloc

dealloc

第三,向对象添加非正式和谈。 委托 委托的意思就是你本身想做某事,你本身不做,你委托给别人做。

指定初始化函数:什么是指定初始化函数?在类中,某个初始化函数会被指定为指定的初始化函数,�确定指定初始化函数的规则是初始化函数中,参数最多的为指定初始化函数,

当对象的引用计数为0时,Objective-C会自动发送对象的dealloc消息(自动调用对象的dealloc方法,类似于C++的析构函数),所以我们可以自己重写dealloc方法,来实现类里的对其它使用资源的释放工作。

当对象的引用计数为0时,Objective-C会自动发送对象的dealloc消息(自动调用对象的dealloc方法,类似于C++的析构函数),所以我们可以自己重写dealloc方法,来实现类里的对其它使用资源的释放工作。

在Ojbective-C中,实现委托是经由过程类别或者和谈来实现。

其它未被指定为指定初始化函数的初始化函数要调用指定初始化函数来实现。对于该类的子类也是一样,只要重写或者直接使用父类的指定初始化函数。上述文字有些绕,来个例子吧

注意:不要直接在代码中显示调用dealloc方法。

注意:不要直接在代码中显示调用dealloc方法。

举个例子:Apple要临盆iPhone,Apple本身不临盆(各种原因,此中之一就是在中国临盆本钱低,他们赚的银子 多),Apple委托富士康来临盆,底本富士康本来不临盆iPhone,如今要临盆了,所以他得本身加一个临盆iPhone的临盆线(类别,增长临盆 iPhone办法),这就是经由过程类别来实现委托。下面用代码来申明这个例子。

@interface A{

垃圾回收

垃圾回收

…..

int x;

在Objective-C 2.0中引入了垃圾回收机制(自动管理内存),在工程设置里设置Objective-C Garbage Collection为Required[-fobjc-gc-only]就可以使用垃圾回收机制。

在Objective-C 2.0中引入了垃圾回收机制(自动管理内存),在工程设置里设置Objective-C Garbage Collection为Required[-fobjc-gc-only]就可以使用垃圾回收机制。

Apple *apple = [[Apple alloc ] init];

int y;

启用垃圾回收机制后,通常的内存管理命令都变成了空操作指令,不执行任何操作。

启用垃圾回收机制后,通常的内存管理命令都变成了空操作指令,不执行任何操作。

Foxconn *fox = [[Foxconn alloc] init];

}

Objective-C的垃圾回收机制是一种继承性的垃圾回收器,垃圾回收器定期检查变量和对象以及他们之间的指针,当发现没有任何变量指向对象时,就将该对象视为被丢弃的垃圾。所以在不在使用一个对象时,将指针他的指针设置为nil,这时垃圾回收器就会清理该对象。

Objective-C的垃圾回收机制是一种继承性的垃圾回收器,垃圾回收器定期检查变量和对象以及他们之间的指针,当发现没有任何变量指向对象时,就将该对象视为被丢弃的垃圾。所以在不在使用一个对象时,将指针他的指针设置为nil,这时垃圾回收器就会清理该对象。

[apple setDelegate:fox];

-(id) init;

注意:如果开发iPhone软件,则不能使用垃圾回收。在编写iPhone软件时,Apple公司建议不要在自己的代码中使用autorelease方法,并且不要使用创建自动释放对象的函数。

注意:如果开发iPhone软件,则不能使用垃圾回收。在编写iPhone软件时,Apple公司建议不要在自己的代码中使用autorelease方法,并且不要使用创建自动释放对象的函数。

[apple produceIPhone];

-(id) initWithX:(int) xValue;

类别

类别

……..

-(id) initWithY:(int) yValue;

什么是类别?类别是一种为现有类添加新方法的方式。

什么是类别?类别是一种为现有类添加新方法的方式。

@implementation Apple

-(id) initWithXY:(int) xValue

为什么使用类别或者说使用类别的目的是什么?有以下三点:

为什么使用类别或者说使用类别的目的是什么?有以下三点:

- setDelegate: x{

yVal:(int) yValue;

第一,可以将类的实现分散到多个不同的文件或多个不同的框架中。
如果一个类需要实现很多个方法,我们可以将方法分类,把分好的类形成类别,可以有效的管理和驾驭代码。
第二,创建对私有方法的前向引用。
第三,向对象添加非正式协议。

第一,可以将类的实现分散到多个不同的文件或多个不同的框架中。
如果一个类需要实现很多个方法,我们可以将方法分类,把分好的类形成类别,可以有效的管理和驾驭代码。
第二,创建对私有方法的前向引用。
第三,向对象添加非正式协议。

delegate = x; //! 将委托的临盆对象指定为x

@end

委托
委托的意思就是你自己想做某事,你自己不做,你委托给别人做。
在Ojbective-C中,实现委托是通过类别(或非正式协议)或者协议来实现。

委托
委托的意思就是你自己想做某事,你自己不做,你委托给别人做。
在Ojbective-C中,实现委托是通过类别(或非正式协议)或者协议来实现。

}

这里initWithXY被确定为指定初始化函数。

举个例子:Apple要生产iPhone,Apple自己不生产(种种原因,其中之一就是在中国生产成本低,他们赚的银子多),Apple委托富士 康来生 产,本来富士康原来不生产iPhone,现在要生产了,所以他得自己加一个生产iPhone的生产线(类别,增加生产iPhone方法),这就是通过类别 来实现委托。下面用代码来说明这个例子。
....
Apple *apple = [[Apple alloc ] init];

举个例子:Apple要生产iPhone,Apple自己不生产(种种原因,其中之一就是在中国生产成本低,他们赚的银子多),Apple委托富士 康来生 产,本来富士康原来不生产iPhone,现在要生产了,所以他得自己加一个生产iPhone的生产线(类别,增加生产iPhone方法),这就是通过类别 来实现委托。下面用代码来说明这个例子。
....
Apple *apple = [[Apple alloc ] init];

- produceIPhone{

-(id) initWithXY:(int) xValue

Foxconn *fox = [[Foxconn alloc] init];

Foxconn *fox = [[Foxconn alloc] init];

[delegate produceIPhone]; //! 委托对象临盆iPhone

yVal:(int) yValue{

[apple setDelegate:fox];

[apple setDelegate:fox];

}

if (self = [super init]){

[apple produceIPhone];

[apple produceIPhone];

本文由必威发布于必威-编程,转载请注明出处:因为当我们不知道父类在该办法中实现的功能时

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。