OC方法 属性
OC中的私有方法
本小节知识点:
- 【掌握】OC中的私有变量
- 【掌握】OC中的私有方法
OC中的私有变量
- 在类的实现即.m文件中也可以声明成员变量,但是因为在其他文件中通常都只是包含头文件而不会包含实现文件,所以在.m文件中声明的成员变量是@private的。在.m中定义的成员变量不能和它的头文件.h中的成员变量同名,在这期间使用@public等关键字也是徒劳的。
@implementation Dog
{
@public
int _age;
}
@end
OC中的私有方法
-
私有方法：只有实现没有声明的方法
-
原则上：私有方法只能在本类的方法中才能调用。
-
注意: OC中没有真正的私有方法
-
@interface Dog : NSObject
@end
@implementation Dog
- (void)eat
{
NSLog(@"啃骨头");
}
@end
int main(int argc, const char * argv[]) {
Dog *d = [Dog new];
SEL s1 = @selector(eat);
[d performSelector:s1];
return 0;
}
@property修饰符
本小节知识:
- 【掌握】@property修饰符
@property修饰符
- 修饰是否生成getter方法的
- readonly 只生成setter方法，不生成getter方法
- readwrite 既生成getter 又生成setter方法（默认）
@property (readonly) int age;
- 指定所生成的方法的方法名称
- getter=你定制的getter方法名称
- setter=你定义的setter方法名称(注意setter方法必须要有 ?
@property (getter=isMarried) BOOL married;
说明，通常BOOL类型的属性的getter方法要以is开头
@property增强
本小节知识:
- 【掌握】@property增强
- 【掌握】@property增强注意点
@property增强
- 自从Xcode 4.x后，@property可以同时生成setter和getter的声明和实现
@interface Person : NSObject
{
int _age;
}
@property int age;
@end
@property增强注意点
- 默认情况下，setter和getter方法中的实现，会去访问下划线 _ 开头的成员变量。
@interface Person : NSObject
{
@public
int _age;
int age;
}
@property int age;
@end
int main(int argc, const char * argv[]) {
Person *p = [Person new];
[p setAge:30];
NSLog(@"age = %i, _age = %i", p->age, p->_age);
return 0;
}
-
如果没有会自动生成一个_开头的成员变量,自动生成的成员变量是私有变量, 声明在.m中,在其它文件中无法查看,但当可以在本类中查看
-
@property只会生成最简单的getter/setter方法,而不会进行数据判断
Person *p = [Person new];
[p setAge:-10];
NSLog(@"age = %i", [p age]);
- 如果需要对数据进行判断需要我们之间重写getter/setter方法
- 若手动实现了setter方法，编译器就只会自动生成getter方法
- 若手动实现了getter方法，编译器就只会自动生成setter方法
- 若同时手动实现了setter和getter方法，编译器就不会自动生成不存在的成员变量
构造方法
本小节知识:
- 【掌握】重写init方法
- 【理解】练习
- 【掌握】构造方法使用注意
- 【掌握】instancetype的作用
重写init方法
-
想在对象创建完毕后，成员变量马上就有一些默认的值就可以重写init方法
-
重写init方法格式:
- (id)init {
self = [super init];
if (self) {
// Initialize self.
}
return self;
}
+ [super init]的作用:
面向对象的体现,先利用父类的init方法为子类实例的父类部分属性初始化。
+ self 为什么要赋值为[super init]:
简单来说是为了防止父类的初始化方法release掉了self指向的空间并重新alloc了一块空间。还有[super init]可能alloc失败,这时就不再执行if中的语句。
- 重写init方法其它格式
- (id)init {
if (self = [super init]) {
// Initialize self.
}
return self;
}
练习
- 要求通过Person类创建出来的人初始化值都是10岁。
@implementation Person
- (instancetype)init
{
if (self = [super init]) {
_age = 10;
}
return self;
}
@end
- 让学生继承人类,要求学生对象初始化之后,年龄是10,学号是1,怎么办?
@implementation Person
- (instancetype)init
{
if (self = [super init]) {
_age = 10;
}
return self;
}
@end
@implementation Student
- (instancetype)init
{
if (self = [super init]) {
_no = 1;
}
return self;
}
@end
构造方法使用注意
-
子类拥有的成员变量包括自己的成员变量以及从父类继承而来的成员变量,在重写构造方法的时候应该首先对从父类继承而来的成员变量先进行初始化。
- 原则:先初始化父类的,再初始化子类的。
- 先调用父类的构造方法[super init];
- 再进行子类内部成员变量的初始化。
- 原则:先初始化父类的,再初始化子类的。
-
千万不要把
self = [super init]写成self==[super init] -
重写构造方法的目的:为了让对象方法一创建出来,成员变量就会有一些固定的值。
instancetype的作用
- instancetype与id相似，不过instancetype只能作为方法返回值，它会进行类型检查，如果创建出来的对象，赋值了不相干的对象就会有一个警告信息，防止出错。
// init此时返回值是id
NSString *str = [[Person alloc] init];
// Person并没有length方法, 但是id是动态类型, 所以编译时不会报错
NSLog(@"length = %i", str.length);
// init此时返回值是instancetype
// 由于instancetype它会进行类型检查, 所以会报警告
NSString *str = [[Person alloc] init];
NSLog(@"length = %i", str.length);
instancetype *p = [[person alloc] init];
// 错误写法instancetype只能作为返回值
自定义构造方法
本小节知识:
- 【掌握】自定义构造方法
自定义构造方法
-
有时候仅仅靠重写构造方法（初始化方法），不能满足需求。比如一个班级中不可能所有学生的年龄都一样，这时候我们需要在创建某个学生的时候能够传入这个学生的年龄。这时候就需要来自定义构造函数（初始化函数）
-
自定义构造方法的规范
- (1)一定是对象方法,以减号开头
- (2)返回值一般是instancetype类型
- (3)方法名必须以initWith开头
-
示例
@interface Person : NSObject
@property int age;
@property NSString *name;
// 当想让对象一创建就拥有一些指定的值,就可以使用自定义构造方法
- (id)initWithAge:(int)age;
- (id)initWithName:(NSString *)name;
- (id)initWithAge:(int)age andName:(NSString *)name;
@end
继承中的自定义构造方法
本小节知识:
- 【掌握】继承中的自定义构造方法
- 【掌握】自定义构造方法的使用注意
继承中的自定义构造方法
- 不能在子类访问父类私有变量
@interface Person : NSObject
@property int age;
- (id)initWithAge:(int)age;
@end
@interface Student : Person
@property NSString *name;
- (id)initWithAge:(int)age andName:(NSString *)name;
@end
@implementation Student
- (id)initWithAge:(int)age andName:(NSString *)name
{
if (self = [super init]) {
// 这个_Age是父类中通过property自动在.m中生成的无法继承,不能直接访问
// _age = age;
[self setAge:age];
_name = name;
}
return self;
}
@end
- 父类的属性交给父类的方法来处理
@interface Person : NSObject
@property int age;
- (id)initWithAge:(int)age;
@end
@interface Student : Person
@property NSString *name;
- (id)initWithAge:(int)age andName:(NSString *)name;
@end
@implementation Student
- (id)initWithAge:(int)age andName:(NSString *)name
{
if (self = [super initWithAge:age]) {
_name = name;
}
return self;
}
@end
自定义构造方法的使用注意
-
(1)自己做自己的事情
-
(2)父类的属性交给父类的方法来处理,子类的方法处理子类自己独有的属性
-
自定义构造方法必须以intiWith开头,并且’W’必须大写
自定义类工厂方法
本小节知识:
- 【掌握】自定义类工厂方法
- 【掌握】子父类中的类工厂方法
自定义工厂方法
-
什么是工厂方法(快速创建方法)
- 类工厂方法是一种用于分配、初始化实例并返回一个它自己的实例的类方法。类工厂方法很方便，因为它们允许您只使用一个步骤（而不是两个步骤）就能创建对象. 例如new
-
自定义类工厂方法的规范
- (1)一定是+号开头
- (2)返回值一般是instancetype类型
- (3)方法名称以类名开头,首字母小写
-
示例
+ (id)person;
+ (id)person
{
return [[Person alloc]init];
}
+ (id)personWithAge:(int)age;
+ (id)personWithAge:(int)age
{
Person *p = [[self alloc] init];
[p setAge:age];
return p;
}
- apple中的类工厂方法
其实苹果在书写工厂方法时也是按照这样的规划书写
[NSArray array];
[NSArray arrayWithArray:<#(NSArray *)#>];
[NSDictionary dictionary];
[NSDictionary dictionaryWithObject:<#(id)#> forKey:<#(id<NSCopying>)#>];
[NSSet set];
[NSSet setWithObject:<#(id)#>];
子父类中的类工厂方法
-
由于之类默认会继承父类所有的方法和属性, 所以类工厂方法也会被继承
-
由于父类的类工厂方法创建实例对象时是使用父类的类创建的, 所以如果子类调用父类的类工厂方法创建实例对象,创建出来的还是父类的实例对象
-
为了解决这个问题, 以后在自定义类工厂时候不要利用父类创建实例对象, 改为使用self创建, 因为self谁调用当前方法self就是谁
-
示例
@interface Person : NSObject
+ (id)person;
@end
@implementation Person
+ (id)person
{
return [[Person alloc]init];
}
@end
@interface Student : Person
@property NSString *name;
@end
@implementation Student
@end
int main(int argc, const char * argv[])
{
Student *stu = [Student person];// [[Person alloc] init]
[stu setName:@"lnj"]; // 报错, 因为Person中没有setName
}
- 正确写法
@interface Person : NSObject
+ (id)person;
@end
@implementation Person
+ (id)person
{
// return [[Person alloc]init];
// 谁调用这个方法,self就代表谁
// 注意:以后写类方法创建初始化对象,写self不要直接写类名
return [[self alloc]init];
}
@end
@interface Student : Person
@property NSString *name;
@end
@implementation Student
@end
int main(int argc, const char * argv[])
{
Student *stu = [Student person];// [[Student alloc] init]
[stu setName:@"lnj"];
}
类的启动过程
本小节知识:
- 【掌握】+load方法
- 【掌握】+initialize方法
+load方法
- 在程序启动的时候会加载所有的类和分类，并调用所有类和分类的+load方法(只会调用一次)
- 先加载父类，再加载子类；也就是先调用父类的+load，再调用子类的+load
- 先加载元原始类，再加载分类
- 不管程序运行过程有没有用到这个类，都会调用+load加载
@implementation Person
+ (void)load
{
NSLog(@"%s", __func__);
}
@end
@implementation Student : Person
+ (void)load
{
NSLog(@"%s", __func__);
}
@end
输出结果:
+[Person load]
+[Student load]
+initialize
- 在第一次使用某个类时（比如创建对象等），只会调用一次+initialize方法
- 一个类只会调用一次+initialize方法，先调用父类的，再调用子类的
@implementation Person
+ (void)initialize
{
NSLog(@"%s", __func__);
}
@end
@implementation Student : Person
+ (void)initialize
{
NSLog(@"%s", __func__);
}
@end
int main(int argc, const char * argv[]) {
Student *stu = [Student new];
return 0;
}
输出结果:
+[Person initialize]
+[Student initialize]
id类型
本小节知识:
- 【理解】静态类型和动态类型
- 【理解】为什么要有动态类型?
- 【理解】id数据类型与静态类型
静态类型和动态类型
- 静态类型
- 将一个指针变量定义为特定类的对象时,使用的是静态类型,在编译的时候就知道这个指针变量所属的类,这个变量总是存储特定类的对象。
Person *p = [Person new];
- 动态类型
- 这一特性是程序直到执行时才确定对象所属的类
id obj = [Person new];
为什么要有动态类型?
- 我们知道NSObject是OC中的基类
- 那么任何对象的NSObject类型的指针可以指向任意对象，都没有问题
- 但是NSObject是静态类型，如果通过它直接调用NSObject上面不存在的方法，编译器会报错。
- 你如果想通过NSObject的指针调用特定对象的方法，就必须把NSObject * 这种类型强转成特定类型。然后调用。如下
//定义NSObject * 类型
NSObject* obj = [Cat new];
Cat *c = (Cat*)obj;
[c eat];
- id 是一种通用的对象类型,它可以指向属于任何类的对象,也可以理解为万能指针 ,相当于C语言的 void *
- 因为id是动态类型,所以可以通过id类型直接调用指向对象中的方法, 编译器不会报错
/// Represents an instance of a class.
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
/// A pointer to an instance of a class.
typedef struct objc_object *id;
id obj = [C at new];
[obj eat]; // 不用强制类型转换
[obj test]; //可以调用私有方法
- 注意：
- 在id的定义中,已经包好了*号。id指针只能指向OC中的对象
- 为了尽可能的减少编程中出错，Xcode做了一个检查，当使用id 类型的调用本项目中所有类中都没有的方法，编译器会报错
- id类型不能使用.语法, 因为.语法是编译器特性, 而id是运行时特性
##3.id数据类型与静态类型
-
虽然说id数据类型可以存储任何类型的对象，但是不要养成滥用这种通用类型
- 如没有使用到多态尽量使用静态类型
- 静态类型可以更早的发现错误(在编译阶段而不是运行阶段)
- 静态类型能够提高程序的可读性
- 使用动态类型前最好判断其真实类型
-
动态类型判断类型
- - (BOOL)isKindOfClass:classObj 判断实例对象是否是这个类或者这个类的子类的实例
Person *p = [Person new];
Student *stu = [Student new];
BOOL res = [p isKindOfClass:[Person class]];
NSLog(@"res = %i", res); // YES
res = [stu isKindOfClass:[Person class]];
NSLog(@"res = %i", res); // YES
- (BOOL) isMemberOfClass: classObj 判断是否是这个类的实例
Person *p = [Person new];
Student *stu = [Student new];
BOOL res = [p isMemberOfClass:[Person class]];
NSLog(@"res = %i", res); // YES
res = [stu isMemberOfClass:[Person class]];
NSLog(@"res = %i", res); // NO
+ (BOOL) isSubclassOfClass:classObj 判断类是否是指定类的子类
BOOL res = [Person isSubclassOfClass:[Student class]];
NSLog(@"res = %i", res); // NO
res = [Student isSubclassOfClass:[Person class]];
NSLog(@"res = %i", res); // YES
new方法实现原理
本小节知识:
- 【掌握】new方法实现原理
new方法实现原理
- 完整的创建一个可用的对象:Person *p=[Person new];
- new方法的内部会分别调用两个方法来完成3件事情:
- (1)使用alloc方法来分配存储空间(返回分配的对象);
- (2)使用init方法来对对象进行初始化。
- (3)返回对象的首地址
This method is a combination of alloc and init. Like alloc, it initializes the isa instance variable of the new object so it points to the class data structure. It then invokes the init method to complete the initialization process.
-
可以把new方法拆开如下:
- (1)调用类方法+alloc分配存储空间,返回未经初始化的对象
Person *p1=[person alloc]; - (2)调用对象方法-init进行初始化,返回对象本身
Person *p2=[p1 init]; - (3)以上两个过程整合为一句:
Person *p=[[Person alloc] init];
- (1)调用类方法+alloc分配存储空间,返回未经初始化的对象
-
说明：
- alloc 与 init合起来称为构造方法，表示构造一个对象
- alloc 方法为对象分配存储空间，并将所分配这一块区域全部清0.
The isa instance variable of the new instance is initialized to a data structure that describes the class; memory for all other instance variables is set to 0.
+ init方法是初始化方法（构造方法），用来对象成员变量进行初始化，默认实现是一个空方法。
An object isn’t ready to be used until it has been initialized. The init method defined in the NSObject class does no initialization; it simply returns self.
- 所以下面两句的作用是等价的
Person *p1 = [Person new];
Person *p = [[Person alloc] init];
- iOS 程序通常使用[[类名 alloc] init] 的方式创建对象，因为这个可以与其他initWithXX:…的初始化方法，统一来。代码更加统一
@property基本概念
本小节知识:
- 【理解】什么是@property
- 【掌握】@property基本使用
- 【理解】寻找方法的过程
- 【理解】OC方法查找顺序
1.什么是@property
-
@property是编译器的指令
-
什么是编译器的指令 ？
- 编译器指令就是用来告诉编译器要做什么！
-
@property会让编译器做什么呢？
- @property 用在声明文件中告诉编译器声明成员变量的的访问器(getter/setter)方法
- 这样的好处是:免去我们手工书写getter和setter方法繁琐的代码
2.@property基本使用
- 在@inteface中,用来自动生成setter和getter的声明
用@property int age;就可以代替下面的两行
- (int)age; // getter
- (void)setAge:(int)age; // setter
- @property编写步骤
1.在@inteface和@end之间写上@property
2.在@property后面写上需要生成getter/setter方法声明的属性名称, 注意因为getter/setter方法名称中得属性不需要_, 所以@property后的属性也不需要_.并且@property和属性名称之间要用空格隔开
3.在@property和属性名字之间告诉需要生成的属性的数据类型, 注意两边都需要加上空格隔开
SEL类型
本小节知识:
- 【理解】什么是SEL类型
- 【掌握】SEL使用
- 【理解】OC方法查找顺序
1.什么是SEL类型
-
SEL类型代表着方法的签名，在类对象的方法列表中存储着该签名与方法代码的对应关系
-
每个类的方法列表都存储在类对象中
-
每个方法都有一个与之对应的SEL类型的对象
-
根据一个SEL对象就可以找到方法的地址，进而调用方法
-
SEL类型的定义
- typedef struct objc_selector *SEL;
-
首先把test这个方法名包装成sel类型的数据
-
根据SEL数据到该类的类对象中，去找对应的方法的代码，如果找到了就执行该代码
-
如果没有找到根据类对象上的父类的类对象指针，去父类的类对象中查找，如果找到了，则执行父类的代码
-
如果没有找到，一直像上找，直到基类(NSObject)
-
如果都没有找到就报错。
-
注意：
- 在这个操作过程中有缓存,第一次找的时候是一个一个的找，非常耗性能，之后再用到的时候就直接使用。
Dog *dog=[[Dog alloc] init];
[dog eat];
2.SEL使用
-
定义普通的变量
- 如：SEL sel = @selector(show);
-
作为方法实参与NSObject配合使用
-
检验对象是否实现了某个方法
- - (BOOL) respondsToSelector: (SEL)selector 判断实例是否实现这样方法
- + (BOOL)instancesRespondToSelector:(SEL)aSelector;
BOOL flag;
// [类 respondsToSelector]用于判断是否包含某个类方法
flag = [Person respondsToSelector:@selector(objectFun)]; //NO
flag = [Person respondsToSelector:@selector(classFun)]; //YES
Person *obj = [[Person alloc] init];
// [对象 respondsToSelector]用于判断是否包含某个对象方法
flag = [obj respondsToSelector:@selector(objectFun)]; //YES
flag = [obj respondsToSelector:@selector(classFun)]; //NO
// [类名 instancesRespondToSelector]用于判断是否包含某个对象方法
// instancesRespondToSelectorr只能写在类名后面, 等价于 [对象 respondsToSelector]
flag = [Person instancesRespondToSelector:@selector(objectFun)]; //YES
flag = [Person instancesRespondToSelector:@selector(classFun)]; //NO
- 让对象执行某个方法
- - (id)performSelector:(SEL)aSelector;
- - (id)performSelector:(SEL)aSelector withObject:(id)object;
- - (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;
Person *p = [Person new];
SEL s1 = @selector(objectFun);
[p performSelector:s1];
SEL s2 = @selector(objectFun:);
[p performSelector:s2 withObject:@"lnj"];
SEL s3 = @selector(objectFun:value2:);
[p performSelector:s3 withObject:@"lnj" withObject:@"lmj"];
SEL s4 = @selector(classFun);
[Person performSelector:s4];
SEL s5 = @selector(classFun:);
[Person performSelector:s5 withObject:@"lnj"];
SEL s6 = @selector(classFun:value2:);
[Person performSelector:s6 withObject:@"lnj" withObject:@"lmj"];
- 作为方法形参
@implementation Person
- (void)makeObject:(id) obj performSelector:(SEL) selector
{
[obj performSelector:selector];
}
@end
int main(int argc, const char * argv[]) {
Person *p = [Person new];
SEL s1 = @selector(eat);
Dog *d = [Dog new];
[p makeObject:d performSelector:s1];
return 0;
}
3.OC方法查找顺序
-
1.给实例对象发送消息的过程(调用对象方法)
- 根据对象的isA指针去该对象的类方法中查找，如果找到了就执行
- 如果没有找到，就去该类的父类类对象中查找
- 如果没有找到就一直往上找，直到跟类（NSObject）
- 如果都没有找到就报错
-
2.给类对象发送消息(调用类方法)
- 根据类对象的isA指针去元对象中查找，如果找到了就执行
- 如果没有找到就去父元对象中查找
- 如果如果没有找到就一直往上查找，直到根类（NSOject）
- 如果都没有找到就报错
@synthesize基本概念
本小节知识:
- 【理解】什么是@synthesize
- 【掌握】@synthesize基本使用
- 【掌握】@synthesize注意点
1.什么是@synthesize
- @synthesize是编译器的指令
- 什么是编译器的指令 ？
- 编译器指令就是用来告诉编译器要做什么！
- @synthesize会让编译器做什么呢？
- @synthesize 用在实现文件中告诉编译器实现成员变量的的访问器(getter/setter)方法
- 这样的好处是:免去我们手工书写getterr和setter方法繁琐的代码
2.@synthesize基本使用
- 在@implementation中, 用来自动生成setter和getter的实现
用@synthesize age = _age;就可以代替
- (int)age{
return _age;
}
- (void)setAge:(int)age{
_age = age;
}
- @synthesize编写步骤
1.在@implementation和@end之间写上@synthesize
2.在@synthesize后面写上和@property中一样的属性名称, 这样@synthesize就会将@property生成的什么拷贝到@implementation中
3.由于getter/setter方法实现是要将传入的形参 给属性和获取属性的值,所以在@synthesize的属性后面写上要将传入的值赋值给谁和要返回哪个属性的值, 并用等号连接
- 以下写法会赋值给谁?
@interface Person : NSObject
{
@public
int _age;
int _number;
}
@property int age;
@end
@implementation Person
@synthesize age = _number;
@end
int main(int argc, const char * argv[]) {
Person *p = [Person new];
[p setAge:30];
NSLog(@"_number = %i, _age = %i", p->_number, p->_age);
return 0;
}
3.@synthesize注意点
-
@synthesize age = _age;
- setter和getter实现中会访问成员变量_age
- 如果成员变量_age不存在，就会自动生成一个@private的成员变量_age
-
@synthesize age;
- setter和getter实现中会访问@synthesize后同名成员变量age
- 如果成员变量age不存在，就会自动生成一个@private的成员变量age
-
多个属性可以通过一行@synthesize搞定,多个属性之间用逗号连接
@synthesize age = _age, number = _number, name = _name;
在这里插入图片描述
扫一扫
1287
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
