【黑马程序员】iOS学习之路——Objective-C之特有语法

1.基本用途
如何在不改变原来类模型的前提下，给类扩充一些方法？有2种方式
继承
分类（Category）

2.格式
分类的声明
@interface 类名 (分类名称)
// 方法声明
@end
分类的实现
@implementation 类名 (分类名称)
// 方法实现
@end

3.好处
一个庞大的类可以分模块开发
一个庞大的类可以由多个人来编写，更有利于团队合作

4.注意
Category可以访问原始类的实例变量，但不能添加变量，只能添加方法。如果想添加变量，可以考虑通过继承创建子类
Category可以实现原始类的方法，但不推荐这么做，因为它是直接替换掉原来的方法，这么做的后果是再也不能访问原来的方法
多个Category中如果实现了相同的方法，只有最后一个参与编译的才会有效

举例
//  main.m
//  04-Category-分类
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

/*
分类的作用：在不改变原来类内容的基础上，可以为类增加一些方法

使用注意：
1.分类只能增加方法，不能增加成员变量
2.分类方法实现中可以访问原来类中声明的成员变量
3.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法，会导致原来的方法没法再使用
4.方法调用的优先级：分类(最后参与编译的分类优先) --> 原来类  --> 父类
*/
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Person+MJ.h"
#import "Person+JJ.h"

int main()
{
Person *p = [[Person alloc] init];
//p.age = 10;

// 优先去分类中查找，然后再去原来类中找，最后再去父类中找
[p test];
// [p study];

return 0;
}

//
//  Person+JJ.h
//  04-Category-分类
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "Person.h"

@interface Person (JJ)
- (void)test2;
@end

//
//  Person+JJ.m
//  04-Category-分类
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "Person+JJ.h"

@implementation Person (JJ)
- (void)test2
{
NSLog(@"-----test2");
}

- (void)test
{
NSLog(@"Person (JJ)-test");
}
@end

//
//  Person+MJ.h
//  04-Category-分类
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "Person.h"

@interface Person (MJ)
- (void)study;
@end

//
//  Person+MJ.m
//  04-Category-分类
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "Person+MJ.h"

@implementation Person (MJ)
- (void)study
{
NSLog(@"学习-----%d", _age);
}

- (void)test
{
NSLog(@"Person (MJ)-test");
}
@end

/*
作者：MJ
描述：
时间：
文件名：Person.h
*/
#import <Foundation/Foundation.h>

@interface Person : NSObject
{
int _age;
}
@property int age;
- (void)test;
@end

/*
作者：MJ
描述：
时间：
文件名：Person.m
*/

#import "Person.h"

@implementation Person
- (void)test
{
NSLog(@"Person-test");
}
@end

5.给系统自带的类添加分类
给NSString增加一个类方法：计算某个字符串中阿拉伯数字的个数
给NSString增加一个对象方法：计算当前字符串中阿拉伯数字的个数
//  main.m
//  05-分类的应用
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "NSString+Number.h"

int main()
// 类库：很多类的集合
{
// int count = [NSString numberCountOfString:@"54d43a43s43dasd"];

int count = [@"9fdsfds543543" numberCount];

NSLog(@"%d", count);
return 0;
}

//
//  NSString+Number.h
//  05-分类的应用
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

/*
给NSString增加一个类方法：计算某个字符串中阿拉伯数字的个数
给NSString增加一个对象方法：计算当前字符串中阿拉伯数字的个数
*/

#import <Foundation/Foundation.h>

@interface NSString (Number)

+ (int)numberCountOfString:(NSString *)str;

- (int)numberCount;

@end

//
//  NSString+Number.m
//  05-分类的应用
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "NSString+Number.h"

@implementation NSString (Number)

//  @"abc434ab43"
+ (int)numberCountOfString:(NSString *)str
{
// 1.定义变量计算数字的个数
//    int count = 0;
//
//    for (int i = 0; i<str.length; i++)
//    {
//        unichar c = [str characterAtIndex:i];
//
//        if ( c>='0' && c<='9')
//        {
//            count++;
//        }
//    }
//    return count;

return [str numberCount];
}

- (int)numberCount
{
int count = 0;

for (int i = 0; i<self.length; i++)
{
// 取出i这个位置对应的字符
unichar c = [self characterAtIndex:i];

// 如果这个字符是阿拉伯数字
if ( c>='0' && c<='9' )
{
count++;
}
}

return count;
}

@end

1.类也是个对象
其实类也是一个对象，是Class类型的对象，简称“类对象”
Class类型的定义
typedef struct objc_class *Class;
类名就代表着类对象，每个类只有一个类对象

2.+load和+initialize
+load
在程序启动的时候会加载所有的类和分类，并调用所有类和分类的+load方法
先加载父类，再加载子类；也就是先调用父类的+load，再调用子类的+load
先加载元原始类，再加载分类
不管程序运行过程有没有用到这个类，都会调用+load加载

+initialize
在第一次使用某个类时（比如创建对象等），就会调用一次+initialize方法
一个类只会调用一次+initialize方法，先调用父类的，再调用子类的

3.获取类对象的2种方式
Class c = [Person class]; // 类方法
或者
Person *p = [Person new];
Class c2 = [p class]; // 对象方法

4.	类对象调用类方法
Class c = [Person class];
Person *p2 = [c new];

//
//  main.m
//  06-类的本质
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Student.h"
#import "GoodStudent.h"
/*
1.当程序启动时，就会加载项目中所有的类和分类，而且加载后会调用每个类和分类的+load方法。只会调用一次。

2.当第一次使用某个类时，就会调用当前类的+initialize方法

3.先加载父类，再加载子类（先调用父类的+load方法，再调用子类的+load方法）
先初始化父类，再初始化子类（先调用父类的+initialize方法，再调用子类的+initialize方法）
*/

int main()
{
// [[GoodStudent alloc] init];

return 0;
}

void test1()
{
Person *p = [[Person alloc] init];

//[Person test];

// 内存中的类对象
// 类对象 == 类
Class c = [p class];
[c test];

Person *p2 = [[c new] init];

NSLog(@"00000");
}

void test()
{
// 利用Person这个类创建了2个Person类型的对象
Person *p = [[Person alloc] init];

Person *p2 = [[Person alloc] init];

Person *p3 = [[Person alloc] init];

// 获取内存中的类对象
Class c = [p class];

Class c2 = [p2 class];

// 获取内存中的类对象
Class c3 = [Person class];

NSLog(@"c=%p, c2=%p, c3=%p", c, c2, c3);

//  类本身也是一个对象，是个Class类型的对象，简称类对象

/*
利用Class 创建  Person类对象

利用 Person类对象 创建 Person类型的对象

*/
}

//
//  Person+MJ.h
//  06-类的本质
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "Person.h"

@interface Person (MJ)

@end

//
//  Person+MJ.m
//  06-类的本质
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import "Person+MJ.h"

@implementation Person (MJ)
+ (void)load
{
NSLog(@"Person(MJ)---load");
}
+ (void)initialize
{
NSLog(@"Person(MJ)-initialize");
}
@end

/*
作者：MJ
描述：
时间：
文件名：Person.h
*/
#import <Foundation/Foundation.h>

@interface Person : NSObject
@property int age;

+ (void)test;

@end

/*
作者：MJ
描述：
时间：
文件名：Person.m
*/

#import "Person.h"

@implementation Person
+ (void)test
{
NSLog(@"调用了test方法");
}

// 当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法
+ (void)load
{
NSLog(@"Person---load");
}

// 当第一次使用这个类的时候，就会调用一次+initialize方法
+ (void)initialize
{
NSLog(@"Person-initialize");
}

@end

/*
作者：MJ
描述：
时间：
文件名：Student.h
*/
#import <Foundation/Foundation.h>
#import "Person.h"

@interface Student : Person

@end

/*
作者：MJ
描述：
时间：
文件名：Student.m
*/

#import "Student.h"

@implementation Student

// 在类被加载的时候调用
+ (void)load
{
NSLog(@"Student---load");
}

+ (void)initialize
{
NSLog(@"Student-initialize");
}

@end

/*
作者：MJ
描述：
时间：
文件名：GoodStudent.h
*/
#import "Student.h"

@interface GoodStudent : Student

@end

/*
作者：MJ
描述：
时间：
文件名：GoodStudent.m
*/

#import "GoodStudent.h"

@implementation GoodStudent
+ (void)load
{
NSLog(@"GoodStudent---load");
}

+ (void)initialize
{
NSLog(@"GoodStudent-initialize");
}

@end

1.-description方法
使用NSLog和%@输出某个对象时，会调用对象的-description方法，并拿到返回值进行输出
2.+ description方法
使用NSLog和%@输出某个类对象时，会调用类对象+description方法，并拿到返回值进行输出
3.修改NSLog的默认输出
重写-description或者+description方法即可
4.死循环陷阱
如果在-description方法中使用NSLog打印self

//
//  main.m
//  07-description方法
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

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

void test9()
{
// 输出当前函数名
NSLog(@"%s\n", __func__);
}

int main()
{
// 输出行号
NSLog(@"%d", __LINE__);

// NSLog输出C语言字符串的时候，不能有中文
// NSLog(@"%s", __FILE__);

// 输出源文件的名称
printf("%s\n", __FILE__);

test9();

Person *p = [[Person alloc] init];

// 指针变量的地址
NSLog(@"%p", &p);
// 对象的地址
NSLog(@"%p", p);
// <类名：对象地址>
NSLog(@"%@", p);

return 0;
}

void test2()
{
Class c = [Person class];

// 1.会调用类的+description方法
// 2.拿到+description方法的返回值（NSString *）显示到屏幕上
NSLog(@"%@", c);
}

void test1()
{
Person *p = [[Person alloc] init];
p.age = 20;
p.name = @"Jack";
// 默认情况下，利用NSLog和%@输出对象时，结果是：<类名：内存地址>

// 1.会调用对象p的-description方法
// 2.拿到-description方法的返回值（NSString *）显示到屏幕上
// 3.-description方法默认返回的是“类名+内存地址”
NSLog(@"%@", p);

//Person *p2 = [[Person alloc] init];
//NSLog(@"%@", p2);

//NSString *name = @"Rose";

//NSLog(@"我的名字是%@", name);

Person *p2 = [[Person alloc] init];
p2.age = 25;
p2.name = @"Jake";

NSLog(@"%@", p2);
}

/*
作者：MJ
描述：
时间：
文件名：Person.h
*/
#import <Foundation/Foundation.h>

@interface Person : NSObject
@property int age;
@property NSString *name;
@end

/*
作者：MJ
描述：
时间：
文件名：Person.m
*/

#import "Person.h"

@implementation Person

// 决定了实例对象的输出结果
//- (NSString *)description
//{
//    // 下面代码会引发死循环
//    // NSLog(@"%@", self);
//    return [NSString stringWithFormat:@"age=%d, name=%@", _age, _name];
//    //return @"3424324";
//}

// 决定了类对象的输出结果
+ (NSString *)description
{
return @"Abc";
}

@end

1.方法的存储位置
每个类的方法列表都存储在类对象中
每个方法都有一个与之对应的SEL类型的对象
根据一个SEL对象就可以找到方法的地址，进而调用方法
SEL类型的定义
typedef struct objc_selector 	*SEL;

2.SEL对象的创建
SEL s = @selector(test);
SEL s2 = NSSelectorFromString(@"test");

3.SEL对象的其他用法
// 将SEL对象转为NSString对象
NSString *str = NSStringFromSelector(@selector(test));

Person *p = [Person new];
// 调用对象p的test方法
[p performSelector:@selector(test)];

//
//  main.m
//  08-SEL
//
//  Created by apple on 13-8-8.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

/*
SEL其实是对方法的一种包装，将方法包装成一个SEL类型的数据，去找对应的方法地址。找到方法地址就可以调用方法

其实消息就是SEL
*/

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

int main()
{
Person *p = [[Person alloc] init];

[p test2];

//    NSString *name = @"test2";
//
//    SEL s = NSSelectorFromString(name);
//
//    [p performSelector:s];

// 间接调用test2方法
//[p performSelector:@selector(test2)];

//[p test3:@"123"];

//    SEL s = @selector(test3:);
//
//    [p performSelector:s withObject:@"456"];

//[p test2];

// 1.把test2包装成SEL类型的数据
// 2.根据SEL数据找到对应的方法地址
// 3.根据方法地址调用对应的方法
return 0;
}

/*
作者：MJ
描述：
时间：
文件名：Person.h
*/
#import <Foundation/Foundation.h>

@interface Person : NSObject

+ (void)test;

- (void)test2;

- (void)test3:(NSString *)abc;

@end

/*
作者：MJ
描述：
时间：
文件名：Person.m
*/

#import "Person.h"

@implementation Person
+ (void)test
{
NSLog(@"test-----");
}

- (void)test2
{
// _cmd代表着当前方法

NSString *str = NSStringFromSelector(_cmd);

// 会引发死循环
// [self performSelector:_cmd];

NSLog(@"调用了test2方法-----%@", str);
}

- (void)test3:(NSString *)abc
{
NSLog(@"test3-----%@", abc);
}
@end

__FILE__ ：源代码文件名
__LINE__ ：NSLog代码在第几行
_cmd ：代表着当前方法的SEL
// 下面的代码会引发死循环
- (void)test {
[self performSelector:_cmd];
}