Objective-C

Introduction
Coding Style

数据结构
Basic
id

SEL

String
创建增删

索引遍历

其他操作
Format

NSMutableString

Array
Array
NSArray不可变数组

NSMutableArray可变对象数组

Set
NSSet

NSMutableSet

NSCountedSet

流程控制

函数
代码块Block
变量访问

Block机制

类与对象
定义与实例化
成员变量
延迟实例化

成员方法

实例化

匿名类

Protocol Delegate

Advanced
内存管理
自动释放池

ARC

Introduction

Coding Style

参考资料

objective-c-style-guide

数据结构

Basic

id

id在Objective C中是一个类型，一个complier所认可的Objective C类型，跟void 是不一样的，比如一个 id userName, 和void *pUserName，[userName print] 是可以的，但[pUserName print] 在编译时就会报错，因为ObjeciveC的编译器看到id，会假定它可以接受任何message，虽然在runtime时可能并不是这样的，但pUserName并不是Objective C类型，编译器就会报错，但是void 有可能时可以接收print message的。

/**
* Type for Objective-C objects.
*/
typedef struct objc_object
{
/**
* Pointer to this object's class.  Accessing this directly is STRONGLY
* discouraged.  You are recommended to use object_getClass() instead.
*/
#ifndef __OBJC_RUNTIME_INTERNAL__
__attribute__((deprecated))
#endif
Class isa;
} *id;

SEL

其作用相当于函数指针，现在我看到的大多说用法都是在调用某些函数需要传递一个函数指针参数时，使用@selector。它会在当前类里面查找selector后面所跟的函数，返回一个SEL类型的值。

譬如：

[对象　performSelector:SEL变量　withObject:参数1　withObject:参数2];

既代指使用performSelecor方法来执行。在调用respondsToSelector:@selector(method)时，这个method只有在该方法存在参数时需要 “:”，如果该方法不需要参数就不需要加这个冒号。否则，编译不会报错，只是执行返回的值不对。当然如果方法有多个参数，需要多个冒号，参数有名称的需要带上参数名称。换言之，就是需要带上完整的参数名。

如：有如下方法：

-(NSString*)toXmlString;

此时调用类似于：

[self respondsToSelector:@selector(toXmlString)]

如果toXmlString方法的定义为：

-(NSString*)toXmlString:(NSString*)prefix;

那么调用就必须加上冒号，如：[self respondsToSelector:@selector(toXmlString:)]

String

参考资料

OJC-String教程

//求字符串对象的长度
NSInteger length = [str8 length] ;
NSLog( @"%ld", length ) ;

//判断一个字符串对象是否拥有前缀字符串
BOOL result1 = [str8 hasPrefix:@"If"] ;
NSLog( @"%@", result1 ? @"YES" : @"NO" ) ;

//判断一个字符串对象是否拥有后缀
BOOL result2 = [str8 hasSuffix:@"en"] ;
NSLog( @"%@", result2 ? @"YES" : @"NO" ) ;

//判断一个字符串对象是否和另一个字符串对象相同
BOOL result3 = [str8 isEqualToString:str7] ;
NSLog( @"%@", result3 ? @"YES" : @"NO" ) ;
NSLog( @"%d", result3 ) ;

创建增删

//使用初始化方法创建
//    NSString *str1 = [[NSString alloc] initWithString:@"name"] ;
NSString *str1 = @"name" ;
NSLog( @"%@", str1 ) ;
//    NSString *str2 = [NSString stringWithString:@"name"] ;
NSString *str2 = @"name" ;
NSLog( @"%@", str2 ) ;

char *cStr = "haha" ;
//将C语言字符串转成OC的对象
NSString *str3 = [[NSString alloc] initWithCString:cStr encoding:NSUTF8StringEncoding] ;
NSLog( @"%@", str3 ) ;

NSString *str4 = [NSString stringWithCString:cStr encoding:NSUTF8StringEncoding] ;
NSLog( @"%@", str4 ) ;

//根据指定格式创建字符串
NSString *str5 = [[NSString alloc] initWithFormat:@"%@+%d", @"en", 1001] ;
NSLog( @"%@", str5 ) ;

NSString *str6 = [NSString stringWithFormat:@"%@+%d", @"ne", 10014] ;
NSLog( @"%@", str6 ) ;

//根据指定路径的文件内容创建字符串对象
NSString *str7 = [[NSString alloc] initWithContentsOfFile:@"/Users/lanouhn/Desktop/test.txt" encoding:NSUTF8StringEncoding error:nil] ;
NSLog( @"%@", str7 ) ;

//    NSError *err = [NSError init] ;
NSString *str8 = [NSString stringWithContentsOfFile:@"/Users/lanouhn/Desktop/words.txt" encoding:NSUTF8StringEncoding error:nil] ;
NSLog( @"%@", str8 ) ;

索引遍历

//字符串比较排序结果
NSComparisonResult result4 = [str8 compare:str7] ;
NSLog( @"%ld", result4 ) ;

//获取子字符串
//从指定下标的字符开始（包含改字符）到字符串结束的子字符串，下标从 0 开始。
NSString *subStr1 = [str8 substringFromIndex:1] ;
NSLog( @"%@", subStr1 ) ;

//从下标为0的字符开始到指定的下标结束 ，此范围内的字符串
NSString *subStr2 = [str8 substringToIndex:2] ;
NSLog( @"%@", subStr2 ) ;

//NSRange 为结构体类型， 成员location描述下标位置，成员length描述需要截取的字符串长度
NSRange rang = NSMakeRange(1, 3) ;
//    rang.length = 4 ;
//    rang.location = 2 ;
NSString *subStr3 = [str8 substringWithRange:rang] ;
NSLog( @"%@", subStr3 ) ;

//字符串拼接
//根据给定的参数字符串拼接并产生新的字符串，不改变原有的字符串。（不可变字符串）
NSString *newString1 = [str8 stringByAppendingString:@"+100"] ;
NSLog( @"%@", newString1 ) ;

//根据给定的格式串以及参数拼接产生新的字符串
NSString *newString2 = [str8 stringByAppendingFormat:@"%d", 1001] ;
NSLog( @"%@", newString2 ) ;

//路径拼接
NSString *newString3 = [str8 stringByAppendingPathComponent:@"xx.avi"] ;
NSLog( @"%@", newString3 ) ;

//字符串替换
//通过给定的第二字符串替换str8中存在的字符串,所有的都替换
NSString *newString4 = [str8 stringByReplacingOccurrencesOfString:@"e" withString:@"呵呵"] ;
NSLog( @"%@", newString4 ) ;

//字符串与数值类型数据的转换
NSString *numString1 = @"1" ;
NSInteger integerValue = [numString1 integerValue] ;
NSLog( @"%ld", integerValue ) ;
float integerValue1 = [numString1 floatValue] ;
NSLog( @"%f", integerValue1 ) ;

//大小写转换
NSString *string = @" i love you" ;
//转成大写字符
NSString *upperCaseStr = [string uppercaseString] ;
NSLog( @"%@", upperCaseStr ) ;
//转成小写字符
NSString *lowercaseStr = [upperCaseStr lowercaseString] ;
NSLog( @"%@", lowercaseStr ) ;

//转成首字母大写字符串(每个字符串的首字母转成大写的)
NSString *capitalString = [string capitalizedString] ;
NSLog( @"%@", capitalString ) ;

其他操作

Format

NSMutableString

NSMutableString *mutableStr1 = [[NSMutableString alloc] init] ;
NSLog( @"%@", mutableStr1 ) ;
NSMutableString *mutableStr2 = [NSMutableString string] ;

//可变字符串的拼接
[mutableStr1 appendString:@"abcdef"] ;
NSLog( @"%@", mutableStr1 ) ;
NSString *resultString = [mutableStr1 stringByAppendingString:@"xxxx"] ;

NSLog( @"%@", resultString ) ;
NSLog( @"%@", mutableStr1 ) ;

//另一个字符串拼接方法
//stringByAppendingFormat : appendFormat
[mutableStr2 appendFormat:@"wang+%d", 1001] ;
NSLog( @"%@", mutableStr2 ) ;

//删除字符串
[mutableStr2 deleteCharactersInRange:NSMakeRange(2, 4)] ;
NSLog( @"%@", mutableStr2 ) ;

//插入字符串
//在给定的下标之前插入指定的字符串（前插）
[mutableStr2 insertString:@"123" atIndex:2] ;
NSLog( @"%@", mutableStr2 ) ;

//替换字符串
//根据给定的字符串的替换指定范围的字符们
[mutableStr2 replaceCharactersInRange:NSMakeRange(0, 3) withString:@"xxx"] ;
NSLog( @"%@", mutableStr2 ) ;

Array

Array

NSArray:不可变数组

[array count] : 数组的长度。

[array objectAtIndex 0]: 传入数组脚标的id 得到数据对象。

[arrayWithObjects; …] :向数组对象初始化赋值。这里可以写任意对象的指针,结尾必须使用nil。

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])
{

@autoreleasepool {
NSObject *obj = [[NSObject alloc]init];
NSArray *array = [NSArray arrayWithObjects:
@"a",
obj,
@"c",nil];
NSLog(@"array Count:%lu",[array count]);
//遍历数组
for (NSObject *object in array) {
NSLog(@"数组对象:%@", object);
}
[obj release];
}

return 0;
}

NSMutableArray可变对象数组

创建增删

[NSMutableArray arrayWithCapacity:6] :初始化可变数组对象的长度，如果后面代码继续添加数组超过长度6以后NSMutableArray的长度会自动扩充，6是自己可以设置的颗粒度。

[array addObject:…] : 向可变数组尾部添加数据对象。

[array addObjectsFromArray:..] :向可变数组尾部添加一个数组对象。

[array removeObject:(id)] :删除数组中指定元素，根据对象isEqual消息判断。

[array removeObjectIdenticalTo:(id)] : 删除数组中指定元素,根据对象的地址判断

[array removeObjectIdenticalTo:(id) inRange:(NSRange)] : 在指定范围内删除指定的元素。

[array removeObjectsInArray:(NSArray *)] :删除一个数组的元素。

索引遍历

for (NSObject * object in muArray) {
NSLog(@"数组对象:%@", object);
}

Set

NSSet

NSSet是Objective-C中的不可变集合。

// 两种初始化方式
NSSet *set1 = [[NSSet alloc] initWithObjects:@"1", @"2", @"3", nil] ;
NSLog( @"%@", set1 ) ;

NSSet *set2 = [NSSet setWithObjects:@"12", @"23", @"34", nil] ;
NSLog( @"%@", set2 ) ;

//用数组对象来创建集合对象
NSArray *array = @[@1, @2, @2] ;
//initWithArray 和 setWithArray 将数组对象转换成集合对象，这样能将数组中重复的对象过滤掉
NSSet *set3 = [[NSSet alloc] initWithArray:array] ;
NSLog( @"%@", set3 ) ;
NSSet *set4 = [NSSet setWithArray:array] ;
NSLog( @"%@", set4 ) ;

//获取集合中对象的个数
NSLog( @"%ld", [set4 count] ) ;

//获取集合中的对象(返回的是任意一个对象，如果集合中没有对象，则返回nil)
id object1 = [set4 anyObject] ;
NSLog( @"%@", object1 ) ;

//判断一个给定的对象是否包含在指定的集合中
NSString *result1 = [set4 containsObject:@2] ? @"YES" : @"NO" ;
NSLog( @"%@ is contained int set %@", @2, result1 ) ;
//        @2  换成  @"2" 结果打印的是  NO
//        NSString *result1 = [set4 containsObject:@"2"] ? @"YES" : @"NO" ;
//        NSLog( @"%@ is contained int set %@", @"2", result1 ) ;

NSMutableSet

NSMutableSet是可变集合。

//初始化
NSMutableSet *mutableSet1 = [[NSMutableSet alloc] init] ;
NSLog( @"%@", mutableSet1 ) ;
NSMutableSet *mutableSet2 = [NSMutableSet set] ;
NSLog( @"%@", mutableSet2 ) ;
//通过不可变对象创建
NSMutableSet *mutableSet3 = [[NSMutableSet alloc] initWithSet:set1] ;
NSLog( @"%@", mutableSet3 ) ;
NSMutableSet *mutableSet4 = [NSMutableSet setWithSet: set1] ;
NSLog( @"%@", mutableSet4 ) ;

//添加集合元素(注意：@4 和 @"4"不一样)
[mutableSet4 addObject:@4] ;
NSLog( @"%@", mutableSet4 ) ;

//删除单个集合元素
[mutableSet4 removeObject:@4] ;
NSLog( @"%@", mutableSet4 ) ;

//删除所有集合元素
[mutableSet4 removeAllObjects] ;
NSLog( @"%@", mutableSet4 ) ;

NSCountedSet

NSCountedSet 是 NSSet的子类，能记录集合中的元素的重复次数。

NSCountedSet *countSet1 = [NSCountedSet set] ;
[countSet1 addObject:@1] ;
[countSet1 addObject:@2] ;
[countSet1 addObject:@3] ;
[countSet1 addObject:@2] ;
NSLog( @"%@", countSet1 ) ;

//单独获取某个对象在集合中出现过多少次
//        NSLog( @"%ld", [countSet1 countOfObjc:@3] ) ;
NSLog( @"%ld", [countSet1 countForObject:@5] ) ;

流程控制

函数

代码块（Block）

代码块本质上是和其他变量类似。不同的是，代码块存储的数据是一个函数体。使用代码块是，你可以像调用其他标准函数一样，传入参数数，并得到返回值。脱字符（^）是块的语法标记。按照我们熟悉的参数语法规约所定义的返回值以及块的主体（也就是可以执行的代码）。下图是如何把块变量赋值给一个变量的语法讲解：



类比而言，可以认为Block就是声明了一个匿名函数。

void (^printBlock)(NSString *x);
printBlock = ^(NSString* str)
{
NSLog(@"print:%@", str);
};
printBlock(@"hello world!");

一般来说，建议把某个代码块声明为变量类型进行使用：’

typedef void (^printBlock)(NSString *x);

变量访问

Block编程值得注意的那些事儿（使用）

ios之Block研究 （Block内部数据结构）

谈Objective-C Block的实现 （Block内部数据结构）

对Objective-C中Block的追探 （Block内部数据结构，讲得很好）

TestBlock.h与TestBlock.m的实现

//
//  TestBlock.m
//  BlockDemo
//
//  Created by fenglh on 14-8-18.
//  Copyright (c) 2014年 yons. All rights reserved.
//

#import "TestBlock.h"

@implementation TestBlock
@synthesize m_age;

//初始化
- (id) init:(int)age
{
self = [super init];
if (nil != self) {
m_age = age;
}
return self;
}

- (void)AccessVarInBlock
{
typedef void ( ^ MyBlock )(void);

int outside_age=20;         //Block 外部的整形变量
int *p_age = &outside_age;  //Block 外部的指针变量

MyBlock aBlock = ^(){       //start Block
NSLog(@" class member variable:\tm_age = %d", self.m_age);
NSLog(@" outside variable: \t\toutside_age = %d", outside_age);
NSLog(@" outside point variable:p_age = %d", *p_age);
}; //end Block

self.m_age = 100; //语句1
*p_age = 100;     //语句2
outside_age = 100;//语句3

aBlock();

}

@end

main函数

//
//  main.m
//  BlockDemo
//
//  Created by fenglh on 14-8-18.
//  Copyright (c) 2014年 yons. All rights reserved.
//

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

int main(int argc, const char * argv[])
{
TestBlock *test = [[TestBlock alloc ] init:10];
[test AccessVarInBlock];

}

输出结果：

2014-08-18 23:40:35.334 BlockDemo[2136:303]  class member variable: m_age = 100
2014-08-18 23:40:35.336 BlockDemo[2136:303]  outside variable:      outside_age = 20
2014-08-18 23:40:35.337 BlockDemo[2136:303]  outside point variable:p_age = 100

先看，AccessVarInBlock方法，如果把代码1、2、3（即aBlock(); 上面三句）都**注释掉**的话，其输出结果为：

2014-08-18 23:35:06.513 BlockDemo[2111:303]  class member variable: m_age = 10
2014-08-18 23:35:06.516 BlockDemo[2111:303]  outside variable:      outside_age = 20
2014-08-18 23:35:06.517 BlockDemo[2111:303]  outside point variable:p_age = 20

可得出以下结论：

指针变量和类成员变量，在Block的内部实现中，是一种引用而非拷贝。

其他基本类型的变量，在Block的内部实现中，是一种拷贝。

Block机制

将以下Objective-C文件进行Clang编译：

include <stdio.h>
int main()
{
int i = 10;
intint *p =&i;
typedef void (^ typeBlock )(void);
typeBlock aBlock = ^{
printf("i = %d\n", i);
printf("*p = %d", *p);
} ;
aBlock();
return 0;
}

可以发现：

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int i;// 定义一个整形变量（并非引用）
int *p; //定义了一个指针变量，也就是一个引用
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int *_p, int flags=0) : i(_i), p(_p) {//构造函数，赋值
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};

可以发现：

1）原本的变量i,在block的内部重新定义了一个i并且在该结构体的构造函数进行赋值，也就是对i进行了一份拷贝。

2）指针变量p ，在block内部也有一个变量p，但是在构造函数的时候，它是指针地址的赋值，也就是说是一份引用。

3）可以猜测，类成员变量，在block的内部数据结构中也是类似一个指针的这样的实现！

类与对象

定义与实例化

Objective-C类的定义中需要在.h文件中定义@interface,在.m文件中也存在有@interface与@implementation。在.h文件的@interface中定义的属性是公有属性，可以被外部文件访问。而.m文件的@interface中定义的属性是私有属性，只可以被内部文件访问。譬如在.h文件中：

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@end

在.m文件中：

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, weak) IBOutlet UIView *referencedView;

@end

@implementation ViewController

- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
}

- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
}

@end

成员变量

在成员变量的管理上主要是依靠手动计数与ARC这两大机制，详情可以查看下文的Advanced-内存管理这一章节。

基本的成员变量的声明方式为：

@property int age; // 默认是赋值
@property(retain) Book * book; // retain 参数实现内存管理

成员变量的相关属性有：

（1）内存管理的相关参数

参数名	说明
retain	release旧值，retain新值
assign	直接赋值，默认就是这个，适用于非OC对象类型
copy	release旧值，copy新值

retain是指针拷贝，copy是内容拷贝。

（2）是否要生成set方法

@property (readonly) int age; // 只读，只生成getter方法
@property (readwrite) int name; // 读写,默认是读写

（3）多线程管理

参数名	说明
nonautomic	性能高，
automic	性能低（默认）

　　@property  (nonautomic , assign) int age; // 以后这样写,默认的assign也要写出来，这样比较明显
　　@property  (setter = myAge：) int age; // setter = set方法名 ，自定义setter方法名，不要忘记冒号
　　@property  (getter = getAge) int age; // getter = get方法名 ，自定义getter方法名
　　@property  (getter = isRich) BOOL rich; // 一般这个会用在BOOL类型的变量声明，getter方法名以is开头

（4）指针类型

iOS常见的指针类型有strong与weak两种，二者的区别可以借鉴于StackOverflow上的这篇文章，简而言之：weak和strong不同的是 当一个对象不再有strong类型的指针指向它的时候 它会被释放 ，即使还有weak型指针指向它。一旦最后一个strong型指针离去 ，这个对象将被释放，所有剩余的weak型指针都将被清除。

可能有个例子形容是妥当的。想象我们的对象是一条狗，狗想要跑掉（被释放）。strong型指针就像是栓住的狗。只要你用牵绳挂住狗，狗就不会跑掉。如果有5个人牵着一条狗（5个strong型指针指向1个对象），除非5个牵绳都脱落 ，否着狗是不会跑掉的。weak型指针就像是一个小孩指着狗喊到：“看！一只狗在那” 只要狗一直被栓着，小孩就能看到狗，（weak指针）会一直指向它。只要狗的牵绳脱落，狗就会跑掉，不管有多少小孩在看着它。

只要最后一个strong型指针不再指向对象，那么对象就会被释放，同时所有的weak型指针都将会被清除。

（5）读写属性

Objective-C语言关键词，@property与@synthesize配对使用。@synthesize可以为某个属性方法。

延迟实例化

对于复杂数据类型的类的成员变量而言，往往面临着一个分配与实例化的要求。如果把这种实例化全部写入init方法中，无疑会导致极大的内存消耗。很多成员变量可能并不需要被实例化，OJC提供了一种类似于Getter/Setter的方法来进行延迟实例化：

//.h
@property (nonatomic, strong) NSMutableArray* myArray;

//.m
@synthesize myArray = _myArray;//新版Xcode中自动会加上这句话

- (NSMutableArray*) myArray
{
if (!_myArray){
_myArray = [[NSMutableArray alloc] initWithCapacity:2];
}
return _myArray;
}

成员方法

Objective-C中，调用方法被称为发送消息，通知对象执行某种操作。语法如下：[shape draw]

（1）类声明（接口）：

一般公开方法的声明会放置在.h文件的@interface中，隐私方法的声明放在.m文件的@interface中。方法也可以不需要声明而直接实现。

@interface TestCoop : NSObject {
int iMonth;
int iYear;
int iDay;
}

- (void) setYear: (int) iYear;
- (void) primalSetData: (int)iYear :(int)iMonth :(int)iDay;
- (void) setData: (int)Year iMonth:(int)iMonth iDay:(int)iDay;
- (void) displayDateInfo;

@end

1、前面的短线/- 表示这是Objective-C方法的声明，用来区分函数原型（C语言中）与（Objective—C中）方法声明的方式。短线后面是方法的返回类型/比如(void) ，位于圆括号中。方法名字前面的单个减号(-)表明该方法是一个实例方法。如果方法名字前面是一个加号(+)，则表明该方法是一个类（static）方法。

1.1 注意，方法的声明在括号后面，@end之前 {}区域里只有变量的定义，这点和C++很不一样。

2、返回类型后面自然是函数名字，和C语言一样的，不同的是参数声明方法

2.1、无参数的函数后面不需要加括号和冒号，直接是函数名结束加分号，比如：

- (void) displayDateInfo;

2.2、有参数的后面加冒号和参数类型名字，比如：

- (void) setDay: (int) iDay; //单个参数
- (void) primalSetData: (int)iYear :(int)iMonth :(int)iDay;//多个参数

objective还提供一种中缀符的语法，方法的名称和参数都是和在一起的：

参数前面多加一个标识符，通常和变量名一样，如下：

- (void) setData: (int)Year iMonth:(int)iMonth iDay:(int)iDay;//多个参数

实例化

TestCoop *ptest = [TestCoop new];
TestCoop *ptest = [[TestCoop alloc] init];

苹果推荐使用第二种方法，虽然繁琐点。

匿名类

譬如

id<NSObject>

这样的就是代表一个匿名类。

Protocol & Delegate

Protocol类似C++中的抽象类和Java中的interface。分为Formal protocol和informal protocol两种，其中在Objective C 2.0之前，informal protocol是Cocoa中实现delegate的重要基础。因为Objective C 2.0引入了@optional和@required关键字。delegate是一种常用的设计模式，而不是Objective C或者Cocoa的feature，也没有任何关键字是给delegate用的。Delegate其实表示的是一种代理模式，

举例而言，这叫好比我想买个手机，所以我有个buyIphone 方法,但是我不知道谁那买手机,所以把这个需求发布出去(比如公布在网站上),如果有卖手机的商人(也就是说他能实现buyIphone这个方法)看到，他就会接受我的委托,(在商人自己的类中实现),那么我的委托对象就指向了这个商人..当我要买手机的时候，直接找他就行了.

@protocol MyDelegate
-(void)buyIphone:(NSString *)iphoneType money:(NSString *)money;

@end
@interface My : NSObject
{
id<MyDelegate> deleage;
}
@property(assign,nonatomic)id<MyDelegate> delegate;
@end

代码中声明了一个协议 名叫Mydelegate,在其中有一个buyIphone方法，即一个委托项。当我要购买手机的时候只需要通过delegate 调用 BuyIphone方法即可.

如下:

delegate = [[Business alloc] init]

-(void)willbuy
{
[delegate buyIphone:@"iphone 4s" money:@"4888"];

}

例如:商人类实现了这一委托(用表示实现)

#import <Foundation/Foundation.h>
#import "My.h"
@interface Business : NSObject<MyDelegate>
@end

然后在 @implementation Business 中调用 buyIphone方法

#import "Business.h"

@implementation Business

-(void)buyIphone:(NSString *)iphoneType money:(NSString *)money
{
NSLog(@"手机有货，这个价钱卖你了，发货中!!");
}
@end

Advanced

内存管理

苹果的内存管理从早期的手动的引用计数到后面的autoreleasepool，以及到现在的ARC。

参考资料

Objective-C 内存管理的历史和参考资料

自动释放池

ARC