95992828九五至尊2

882828九五至尊手机版property括号内属性讲解

二月 2nd, 2019  |  882828九五至尊手机版

一、前言

来源于 Ry’s Objective-C Tutorial – RyPress

   
 一个object的性质允许其余object监督和更改他的景况。不过在一个统筹雅观的面向对象程序中,直接访问一个object的中间景观是不容许的。相反,存取器(getter
setter)方法是一个虚幻互相成效object的平底数据。

一个就学Objective-C基础知识的网站.

 

私家觉得很棒,所以决定抽时间把章节翻译一下.

透过访问器方法与品质举行互动

自身的爱沙尼亚语水平有限,有让我们误会或者迷惑的地点还请指正.

@property指令的目标是由此自行的始建这几个存取器方法使创办和安排属性变得越来越简约。它同意你在语义级别上点名公有属性的一言一行。而且它相比较关切您的事无巨细完成。

原稿地址:http://rypress.com/tutorials/objective-c/properties.html

   
 那些模型调查无独有偶的特性,那个属性可以让你改改getter和setter行为。其中的一些品质确定是怎样处理内存的,所以这么些模型也服务于在Objective-C中对内存管理的骨子里的介绍。

仅供就学,如有转摘,请注明出处.

 二、@property指令


   
 首先,让大家看一下当大家一直动用@property时暴发了什么工作,考虑一下下边的次第,一个Car类和它的完结。

882828九五至尊手机版,一个目的的性质允许任何对象查看或者修改它的状态.可是,在一个美妙的面向对象设计中,是不可能(允许)直接得到一个对象的中间状态.而是通过存取器(getters与setters)与对象的里边数据举行交互.

Car.h

882828九五至尊手机版 1

#import <Foundation/Foundation.h>

@interface Car : NSObject

@property BOOL running;
@end

Car.m

#import "Car.h"

@implementation Car

@synthesize running = _running;   //Xcode 4.4以上可选
@end

Interacting with a property via accessor methods

  

@property指令的目标是由此自动生成存取器方法来便宜的始建,配置属性.它同意你在语义上指定公有属性的一坐一起,并且毫不你担心达成细节.

 
 编译器会为running属性创设一个getter和setter方法。默许的命名习惯是用属性自己当做getter,加上前缀set作为setter方法,并且在面前加下划线作为实例变量,如同上边那样:

以此模块概览那些分歧的同意你变更getters与setters行为的特性.其中的部分特性决定了品质怎么着支配(管理)自己内存,所以该模块也是对OC内存管理的一个实用介绍.对于(那地方)更详实的座谈,请参阅内存管理.

-(BOOL)running
{
    return _running;
}
-(void)setRunning:(BOOL)running
{
    _running = running;
}
当用

@property指令

率先,让我们先看一下当使用@property指令时究竟发生了何等事情.请看上边的一个简易Car类的接口和对应完成.

// Car.h
#import <Foundation/Foundation.h>

@interface Car : NSObject

@property BOOL running;

@end

// Car.m
#import "Car.h"

@implementation Car

@synthesize running = _running;    // Optional for Xcode 4.4+

@end

编译器为running属性(分别)生成了getter和setter.默许的命名规则是利用其特性名称作为getter,在属性名从前增进set作为setter,其相应的实例变量则是在品质名前添加下划线,就如那样:

- (BOOL)running {
    return _running;
}
- (void)setRunning:(BOOL)newValue {
    _running = newValue;
}

在您通过@property指令讲明了质量之后,你就能调用那几个艺术,好像(那些艺术)已经被含有在你的类接口和兑现公文中.你也得以在Car.m中重写它们以提供自定义的getter/setter,那样的话就得必须运用@synthesize指令.可是,你应该没有需求要自定义存取器,固然@property指令允许在抽象的层级上如此做.

经过点语法访问属性实际上是转换成通过上述的存取器方法,所以上边(代码块)的honda.running代码在给其赋值时实际上是调用setRunning:在读取它的值时是调用running方法:

// main.m
#import <Foundation/Foundation.h>
#import "Car.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Car *honda = [[Car alloc] init];
        honda.running = YES;                // [honda setRunning:YES]
        NSLog(@"%d", honda.running);        // [honda running]
    }
    return 0;
}

为了改变已转移的存取器的一举一动,你能够在@property指令后的小括号内指定其特性.上面的模块将介绍那一个可用的特性.

@property直接生成属性,你可以直接调用那几个主意,就好像这么些主意就是带有在此类的interface和兑现文件中。你也可以在.m中重写他们,可是这么会使得@synthesize指令强制。不过,你应有很少须要传统的存取器固然@property属性供那样做在空洞的级别。

getter= 与 setter= 特性

假定您不希罕@property那种默许的命名规则,你能够使用getter=与setter=特性来更改getter/setter的主意名.对于Boolean属性,常用的getter方法名是(在其属性名)添加is前缀.将Car.h的质量注解调整成上面那样:

@property (getter=isRunning) BOOL running;

那时候生成的存取器就是isRunning以及setRunning了.注意,公有属性(名称)依旧是running,这也是您在点语法中该应用的称呼:

Car *honda = [[Car alloc] init];
honda.running = YES;                // [honda setRunning:YES]
NSLog(@"%d", honda.running);        // [honda isRunning]
NSLog(@"%d", [honda running]);      // Error: method no longer exists

那是唯一一个索要参数的性能特性(用于标识存取器方法) –
其余的都是boolean标识.

质量访问可以是用类实例后加.访问。所以看上面的代码:

只读特性

只读特性让您方便地将一个性质改为只读的.它会忽略setter方法,并会阻止通过点语法(给其)赋值,不过对getter没有影响.作为例子,将Car接口修改如下,注意大家怎么利用逗号分隔来给属性指定四个特性.

#import <Foundation/Foundation.h>

@interface Car : NSObject

@property (getter=isRunning, readonly) BOOL running;

- (void)startEngine;
- (void)stopEngine;

@end

近来,我们将通过startEngine和stopEngine方法在里边设置running属性,而不是让其余对象修改.对应的兑现如下.

// Car.m
#import "Car.h"

@implementation Car

- (void)startEngine {
    _running = YES;
}
- (void)stopEngine {
    _running = NO;
}

@end

请记住,@property也为大家转移了一个实例变量,那是我们怎么在不表明的动静下,也能够拔取_running的缘故(在此间,大家不可能使用self.running因为它是只读的).我们在main.m中添加如下代码来测试新的Car类.

Car *honda = [[Car alloc] init];
[honda startEngine];
NSLog(@"Running: %d", honda.running);
honda.running = NO;                      // Error: read-only property

到此(来看),属性是一个幸免我们协调(依照样板)写getter/setter方法的便捷格局.(与readonly比较),那种状态不适用于其他的这几个能明确变更属性行为的特性.它们只适用于存储OC对象的品质(并非C语言的骨干项目).

   

非原子特性

原子性必须处理线程环境下的性质行为.当有多少个线程时,有可能会同时调用setter与getter方法.那也就表示getter/setter会被其它操作打断,也就可能会生出坏数据.

原子属性通过锁定一个基础的(普通的)对象来阻止那种业务的发出,并确保get/set操作的完整性(数据完整性).可是,使用原子属性只是线程安全的一个上边,并不意味你的代码是线程安全的,精通这点很紧要.

@property表明的质量默许是原子特性,这会暴发一些管制基金(开支).所以,即使处在一个非二十八线程的环境(或者您自己达成了线程安全),你一定会用nonatomic特性来重写(变更)那么些作为,像这么:

@property (nonatomic) NSString *model;

那有一个关于atomic特性小的,实用的警告.对于持有原子特性的性质,它的存取器要么自己生成,要么自定义.只有non-atomic特性的特性才同意混合-既可利用synthesized,又可以自定义.可以通过移除下面代码中的nonatomic,并在Car.m增加一个自定义的getter来验证那一点.

Car *honda = [[Car alloc] init];
    honda.running = YES;
    NSLog(@"%d",honda.running);  

内存管理

在其它一种OOP(objected-oriented
Pragram)语言中,对象都驻留在电脑内存中,在运动设备上-
这几个(内存)是薄薄资源.内存管理的靶子通过一种高效的创制,销毁对象的主意来有限援救程序不会占用超出它们所需(内存)空间的附加空间.

诸多编程语言由此垃圾回收机制来兑现(内存管理),而OC使用另一种更急忙的,被称作object
ownership的机制.当你与一个目标初步开展交互时,你便享有了更加目的,也就代表这种关系(拥有该目的)能保障在你利用时期,该对象一向存在.当你不在使用,你便打破(扬弃)那种具有关系,此时,借使该对象没有任何拥有者,系统便会销毁该目的,并释放其内存.

882828九五至尊手机版 2

Destroying an object with no owners

趁着活动引用计数的产出,编译器会帮自动给帮你管理那么些具有关系.意味着大部分状态下,你都不要操心内存管理怎么着工作.但是,你要么都知晓属性的strong,weak与copy特性,因为它们告诉编译器那种对象关联属于哪类.

 当执行honda.running时,也就是调用setRunning:方法。

strong特性

strong特性下,无论给属性分配什么样的靶子,都会创建一个有所关系.那对负有的对象属性来说都是显明地作为,那样就有限协助了一旦属性被赋值,那值就会蕴藏(存在).

我们创立另一个Person类来看一下上诉的劳作原理.该类的接口仅宣称了一个name属性:

// Person.h
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic) NSString *name;

@end

下边是达成.它使用@property默许生成的存取器.还重写了NSObject的description方法,该方法是用来回到对象的字符串描述.

// Person.m
#import "Person.h"

@implementation Person

- (NSString *)description {
    return self.name;
}

@end

接下去,我们在Car类中添加一个Person属性,修改Car.h如下.

// Car.h
#import <Foundation/Foundation.h>
#import "Person.h"

@interface Car : NSObject

@property (nonatomic) NSString *model;
@property (nonatomic, strong) Person *driver;

@end

下一场,调整(又三遍出现的)main.m的代码:

// main.m
#import <Foundation/Foundation.h>
#import "Car.h"
#import "Person.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *john = [[Person alloc] init];
        john.name = @"John";

        Car *honda = [[Car alloc] init];
        honda.model = @"Honda Civic";
        honda.driver = john;

        NSLog(@"%@ is driving the %@", honda.driver, honda.model);
    }
    return 0;
}

因为driver是一个strong关系(强引用),所以handa对象具备john.那样就保障了john(对象)只要在honda对象需求,它就径直有效(存在).

 当给他分配值并且运行时,就是调用getter方法。

weak特性

半数以上状态,在安装对象属性时,第一向觉都是给它strong特性.不过,strong引用(在有些情景下)会滋生一个问题.举个例证,大家需求一个对Car对象的引用来标识人正在开车.首先,大家在Person.h中追加一个car属性.

// Person.h
#import <Foundation/Foundation.h>

@class Car;

@interface Person : NSObject

@property (nonatomic) NSString *name;
@property (nonatomic, strong) Car *car;

@end

@class
Car这一行是对Car类的向前申明.似乎在告知编译器,”相信自己,Car类肯定存在,不用现在去加载它.”大家必须用这种格局来取代大家常用的#import语句,因为Car也得以导入Person.h,那样大家就会陷入一个无尽的导入循环.(编译器可不欣赏无尽的循环.)

接下去,在main.m中,给honda.driver分配值之后进入下边一行代码:

honda.driver = john;
john.car = honda;       // Add this line

如今,我们有一个honda拥有john的关系,也有一个jhon拥有honda的关系.那意味着五个目的互相拥有(引用),导致内存管理系列不可以销毁它们,即使那多少个对象不再必要了.

882828九五至尊手机版 3

A retain cycle between the Car and Person classes

那被称作是retain cycle,一种内存走漏的格局,内存走漏are
bad
.幸运的是,很简单修复那些难点-只要告诉其中的一个属性对别的一个目标保证一个弱引用即可.在Person.h中,将car的扬言调整如下:

@property (nonatomic, weak) Car *car;

weak特性创立一个对car的非拥有关系.那样就允许john在幸免retain
cycle的景色下,仍存在一个对honda的引用.那意味,很可能存在(下述的)这种状态,honda已经被销毁了,而john仍有一个对honda的引用.这不该发生,weak特性会安装car为nil以避免指针悬挂.

882828九五至尊手机版 4

A weak reference from the Person class to Car

一个常用weak特性的意况是在父子数据结构中.根据规则,父对象应该维持对子对象的强引用,子对象则维持对父对象的弱引用.弱引用也是代理设计方式中与生俱来部分.

(上述的)关键点在于,多少个对象永远不要相互强引用.weak特性让在不发出retain
cycle的情况下保持一个循环引用的涉嫌变成可能.

为了改变那种存取器形式,大家得以在@properry后加括号指定,上面就是介绍可用的性质。

copy特性

周旋于strong特性,copy特性可以当做代表(品).它不形成一个怀有关系,而是对其余分配给属性的对象创造一个副本,然后对副本有颇具关系.唯有听从NSCopying
协议
的目的才足以动用这一个特性.

Properties that represent values (opposed to connections or
relationships) are good candidates for copying.
比如,开发人士一般都会复制NSString属性,而不是强引用它们:

// Car.h
@property (nonatomic, copy) NSString *model;

近年来,无论你给model赋什么值,Car都将积存一个全新的实例.即使你使用的是可变值,那么当(属性)第三回被赋值时,它便是不变的了.*
If you’re working with mutable values, this has the added perk of
freezing the object at whatever value it had when it was
assigned.*.可以经过上面的代码阐明:

// main.m
#import <Foundation/Foundation.h>
#import "Car.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Car *honda = [[Car alloc] init];
        NSMutableString *model = [NSMutableString stringWithString:@"Honda Civic"];
        honda.model = model;

        NSLog(@"%@", honda.model);
        [model setString:@"Nissa Versa"];
        NSLog(@"%@", honda.model);            // Still "Honda Civic"
    }
    return 0;
}

NSMutableString是NSString的一个子类,可以每天编辑.若是model没有对本来的实例创造一个副本,咱们将会看出第二行NSLog()输入的是改变后的字符串(Nissan
Versa) .

1、The getter= and setter=
Attributes     

其余特色

对于新型的OC程序(iOS5+),上述的@property特性是你应当需求(使用)的,可是那依旧有局地别的的(特性),你可能会在相比较旧的库或者文档中遇到.

        如果大家不喜欢@property默认的命名形式,大家可以经过The getter=
and setter= Attributes
来改变存取器方法名。最常用的就是对Boolean属性使用这几个。可以把getter把规矩的改成is,例如:

retain特性

retain特性是strong特性在手动引用计数中的版本,它装有相同地效率:分配值时必要一个存有关系.在活动引用计数环境下,你不应有再拔取它.

 @property(getter=isRunning) BOOL running;
unsafe_unretained 特性

有着unsafe_unretained特性的属性在行为上与(有着)weak特性的品质类似,可是只要被引用的靶子被销毁后,它们的值不会自动设为nil.你应该运用unsafe_unretained特性的绝无仅有原因就算为了让您的类与不帮忙weak属性的代码兼容.

   
 现在转变存储器叫做isRunning和setRunning.而标注公共性质仍旧名为running。上边是我们应该怎么用逗号使用它。

assign特性

assign特性在给属性赋值时不会进行其它一种内存管理必要.它是骨干数据类型的默许行为,并且它曾是在iOS5从前完成弱引用的一种格局.与retain一样,在风靡的(当代)应用程序你不需求显然地使用它.

        

总结

其一模块浮现了@property所有的供选拔的特征,希望你对修改已生成的存取器方法感觉相对适应.请牢记,那么些特色的目标是帮衬你关切怎么样的数额应该被记录.(这几个)特性被总计如下.

特性 描述
getter= Use a custom name for the getter method.
setter= Use a custom name for the setter method.
readonly Don’t synthesize a setter method.
nonatomic Don’t guarantee the integrity of accessors in a multi-threaded environment. This is more efficient than the default atomic behavior.
strong Create an owning relationship between the property and the assigned value. This is the default for object properties.
weak Create a non-owning relationship between the property and the assigned value. Use this to prevent retain cycles.
copy Create a copy of the assigned value instead of referencing the existing instance.

现行,大家早已搞定了质量,大家将深切明白OC类中的另一半:方法.大家将探索(与方法有关的)一切,从命名规则背后的更加(原因)到动态方法调用.


写于15年09月06号

 Car *honda = [[Car alloc] init];
    honda.running = YES;
    NSLog(@"%d",honda.running);
    NSLog(@"%d",[honda isRunning]);

    这一个是唯一的性质,他们都是boolean标记。

2、readonly属性

    
readonly属性是一个很有益的法门让你的性质只读。这样会省略setter方法,并且预防作恶通过.调用,不过getter不受影响。例如,大家修改running的特性为readonly,注:大家得以制定多少个属性,然后用“,”分开:

#import <Foundation/Foundation.h>
@interface Car : NSObject

@property(getter=isRunning,readonly) BOOL running;

-(void)startEngine;
-(void)stopEngine;
@end

  

不是让其余object改变running的质量,大家将会设置五个点子去访问。这五个点子的而落到实处如下:

-(void)startEngine
{
    _running = YES;
}
-(void)stopEngine
{
    _running = NO;
}

要记得,@property还为大家转变了一个实例变量,那就是大家怎么可以访问_running在并未阐明的尺码下(大家也可以一贯行使self.running因为这些特性是只读的)。让大家来运作下列代码测试:

   Car *honda = [[Car alloc] init];
//    honda.running = YES;
    NSLog(@"%d",honda.running);
    honda.running = NO;

俺们会意识最后一句出错,因为它是只读属性,不能修改。

到那些地方,大家得以很方便火速地让我们防止书写样板的getter和setter方法。而对remaining属性,那不是一个好的场所。他们也只适用于属性存储OC对象(相当于C数据类型)。

3、nonatomic属性  

     
原子性(Atomicity)的功用是性质在线程的条件中怎么表现。当你不光有一个线程,
那么getter和setter可能会在同一时间去调用,那就象征getter/setter可能会被另一个方法打扰,很有可能引致数据失实。

               
 原子的特性会封锁object,幸免那种意况时有暴发,确保get或者set操作的操作对象是共同体的。没有被毁掉。可是,那无非是一个线程安全的上边,大家必须求清楚那或多或少。使用原子性并不可能担保我们的代码就是线程安全的。

                 
属性用@property评释默许是原子性的,那会导致部分开销,因而,若是您不是高居多线程环境(或者您正完毕您协调的线程安全),你会用notatomic属性重写那几个作为,如同下面:

   @property (nonatomic) NSString *model;  //设置非原子性

   
 当使用原子性属性时,会有一个小的同时相比较实际的警示。针对原子属性的质量访问器必必要么是转变的,要么是用户自定义的,唯有传统非原子性的习性会让您混合搭合作成存储方法。你可以看一下,即使移去nonatomic从下面的代码,然后再Car.m添加传统的getter。

       
 会爆发一个警示:Setter和getter必须被合成,或者用户自定义,或者性质必须是nonatomic

4、内存管理

     
在面向对象语言中,objects存在于统计机内存中,尤其在移动设备中,内存那是一个很缺少的资源。内存管理种类以一个飞速的管理办法创立和破坏object,目的就是确保程序不占用超出它所需求的空间。

         
许多语言都是透过垃圾回收去做到的,然而OC用的是一个越发急忙替代品,就是Object
ownership(目的拥有者)。当您起来与目的交互时,你会报告对象自己,那就代表它确保一旦您再使用对象,它就会存在.当你不再动用的时候,你废弃所有权,倘使目标没有其余的主人,操作系统会销毁那么些目的,然后释放底层内存资源。

         
随着活动引用计数(ARC)出现,编译器自动管理你有着的靶子,一大半景况下,意味着你向来不必担心内存管理连串是怎么工作的,不过,你不可能不精通strong,weak和copy属性,因为他俩告诉编译器对象应该有哪些关系。

5、strong属性

         
无论对象被指定为何属性,强壮的质量能够创制拥有关系,那对富有目的属性来说是一种内隐行为,它默许是高枕无忧的,因为只要它被指定为strong属性,它就会保障对目标的值存在。

     通过下边的例证,让大家看一下它是怎么工作的。

@interface Person : NSObject

@property(nonatomic)NSString *name;
@end

它的已毕如下,它@property暴发的运用默许的贮存方法,它也重写了NSObject的讲述方法,重临一个意味着该目的的字符串。

#import "Person.h"

@implementation Person

-(NSString *)description
{
    return self.name;
}
@end

 然后,让大家添加Person属性给车,改变Car.h如下:

#import <Foundation/Foundation.h>
#import "Person.h"

@interface Car : NSObject


@property (nonatomic) NSString *model;
@property(nonatomic,strong) Person *driver;

@end

然后考虑上边的代码: 

    Person *john = [[Person alloc] init];
    john.name = @"John";


    Car *honda = [[Car alloc] init];
    honda.model = @"Honda Civic";
    honda.driver = john;
    NSLog(@"%@ is driving the %@",honda.driver,honda.model);

   
 只要driver是一个strong关联,honda对象就会拥有john,那确保一旦honda须要它,它就会有效。

6、weak属性

一大半情状下,强属性可以直观精晓您想要什么目的属性,强引用会暴漏一个题材,例如,我们要求从driver引用他正在开的Car对象, 
   首先,大家须求给Person添加一个car属性:

Person.h

#import <Foundation/Foundation.h>

@class Car;

@interface Person : NSObject

@property(nonatomic)NSString *name;
@property(nonatomic,strong)Car *car;

@end

@class Car
是对Car类的前表明,就如它报告编译器,“相信自己,Car类是存在的,所有不要想着去登时找到它”。我们不用#import那样做,因为Car也导入了Person.h,那样大家会深陷无尽的导入循环(编译器不喜欢无穷的循环)。

接下来,添加底下的代码,在honda、driver分配后:

Person *john = [[Person alloc] init];
    john.name = @"John";
    Car *honda = [[Car alloc] init];
    honda.model = @"Honda Civic";
    honda.driver = john;
    john.car = honda;  //添加这行
    NSLog(@"%@ is driving the %@",honda.driver,honda.model);

如此我们明天有一个面貌,就是john拥有honda,honda拥有john。那就表示他们相互拥有,所以即使她们不再实用,内存管理种类也不能自由他们。

 

那名叫 retain
cycle(保持循环),是一种内存走漏的款型,内存走漏是很倒霉的。幸运的是,要想解决那么些艺术很粗略,只必要报告其中一个品质维持一个weak属性引用另一个对象。在Person.h中,改变car的表明:

@property(nonatomic,weak)Car *car;

那种weak(弱)属性会给car成立一个非拥有关系。它同意john有一个honda的引用,同时避免了维持循环。然则,还有一个可能就是honda会被销毁,而那一个时候john正在引用honda,即使这种情状时有爆发,weak属性会很方便地安装car为nil,去防止悬挂指针。

 

一个在Person中弱引用car

一个公用的采纳weak属性例子就是大爷-孩子数据结构,根据约定,父对象应当维持一个强引用对子对象,子对象应该储存一个弱引用父对象。弱引用在代理设计情势中是内在的,也就是自带的。

   
 重点是多少个目的不恩给你都是强引用相互,weak属性让保险一个不经过成立保持循环循环的关联变成可能。

7、copy属性

     
它是strong的替代品,不是保持拥有一个设有的靶子,而是成立一个引用,无论你指定什么性质,都会怀有这么些有着。唯有切合NSCopying
protocol的靶子才能使用这几个特性。

   
 代表值的属性(相对于链接或提到)是一个采纳copy的正确性选拔。例如,开发者寻常复制字符串属性,而不是强引用它们:

//Car.h

@property (nonatomic,copy) NSString *model;

       
 现在Car将会蕴藏一个全新的实例,不管我们指定的model值,倘若您处理可变的值,它会有一个便宜,就是冻结对象无论怎么时候有值当它被指定时。演示如下:

         Car *honda = [[Car alloc] init];
    honda.model = @"Honda Civic";

    NSMutableString *model = [NSMutableString stringWithString:@"Honda Civic"];
    honda.model = model;

    NSLog(@"%@",honda.model);
    [model setString:@"Nissa Versa"];  
    NSLog(@"%@",honda.model); //输出结果还是Honda Civic

NSMutableString
是NSString的一个子类,它可以在自我的功底上修改它的值。假诺model属性不被声称为copy属性,大家将会看到在最终一个NSLog将会输出Nissa
Versa

8、别的品质

地点的的那些@property性质我们需求利用在现行的OC应用中,可是上面的一对属性大家也许会在老得类库或者文档中偶尔境遇。

  •  retain属性

 retain属性是手动释放保留版本的strong,它有纯正一样的震慑:为指定的values声称所有权.ARC环境中不可能使用。

  • unsafe_unretained属性

   
 它相仿与weak,但是即使引用对象销毁,不自行安装nil。使用该属性的绝无仅有原因就是:去让你的类包容不扶助weak属性的代码。

  • assign属性

    
当给一个以此特性指定一个新的value,assign属性不执行此外类型的内存管理调用。那个一个土生土长数据类型的默许行为,它的施用是在iOS5此前去贯彻弱引用,如同retain,现在的application你不应有明了的行使。

总结:

     这些模块教学了独具的@property拔取属性,下面是统计属性:

    1. getter=  让getter方法使用自定义的名字
    2. setter = 让setter方法使用自定义名字
    3. readonly 不合成setter方法
    4. nonatomic
      不有限支撑在四线程环境下存取访问器的完整性,那比原子性尤其高效
    5. strong 在质量和指定value之间创造一个负有关系,那是默许的对象属性
    6. weak
      在性质和制定value之间创设一个不具有关系,使用这么些防护循环引用
    7. copy 创制一个指定值的副本,而不是援引存在的目的实例。

参考自: http://rypress.com/tutorials/cocoa/

相关文章

Your Comments

近期评论

    功能


    网站地图xml地图