黑马程序员-OC的核心语法-优快云博客

本文链接：https://blog.youkuaiyun.com/wmxshen00789/article/details/42131833

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一.关键语法
1.点语法
点语法的本质还是方法调用
比如 p.age=10; 就是转换为 [p setAge:10];
int a = p.age 转换为 int a = [p age];

2.成员变量作用域
   1.基本概念
       局部变量、全局变量都有自己的作用域，成员变量也不例外
2.类型
   >@private：只能在当前类的实现@implementation中直接访问
   >@protected:可以在当前类以及子类的实现@implementation中直接访问
   >@public:任何地方都可直接访问
   >@package:同一个“体系内”（框架）可以访问，介于@private@public之间
3.继承补充
   >专业术语父类\超类 superclass 子类 subclass\subclasses 单继承
4.@implementation补充
   没有@interface,只有@implementaton,也可以开发一个类,在.m文件进行声明
   在声明里写的成员变量，默认是private
   实现里面也能写成员变量默认是私有，因为不会被其他文件包含,无法改设置就算写上@public也没用
   (@interface)声明和(@implementation)实现里面不能定义同名的变量
5.成员变量的作用域
   @public:在作何地方都能直接方问对象的成员变量
   @private:只能在当前类的对象方法中直接访问(@implementation默认)
   @protected:可以在当前类及其子类的对象方法中直接访问（@interface默认）
   @package:只要处在同一个框架中，就能直接方问对象的成员变量
   @interface与@implementation中的成员变量不能同名
   子类与父类的成员变量不能同名

二.关键字
1.@property
   在@interface和@end之间
   编译器特性，当遇到@property int age自动生成某个成员变量的setter和getter声明，不能重复声明
   如果使用了@property，但是没有成员变量，则自动生成private类型的成员变量
   缺点，成员变量是死的，无法设置public或protected

2.@synthesize
   在@implementation和@end之间
   自动生用age的setter和getter的实现,并且会访问_age这个成员变量
   @synthesize age = _age;也可以@synthesize age = _age,name = _name;
   如果@synthesize age没有指定，那么默认访问和age一样的成员变量

3.@property新特性
   自从Xcode4.4以后,@property就独揽了@synthesize的功能，也不是说，@property可以同时声明成员变量的声明和实现
   @property(nonatomic,retain) UIWindow *window;

   其中参数主要分为三类：
   读写属性：（readwrite/readonly）
   setter语意：（assign/retain/copy）
   原子性：（atomicity/nonatomic）

4.各参数意义如下：

   readwrite: 产生setter\getter方法
   readonly: 只产生简单的getter,没有setter。
   assign: 默认类型,setter方法直接赋值，而不进行retain操作
   retain: setter方法对参数进行release旧值，再retain新值。
   copy: setter方法进行Copy操作，与retain一样,不对旧值release
   nonatomic: 禁止多线程，变量保护，提高性能

5.id
   id是一种类似如 id d 所以变量名不能叫id，id是关键字
   id是万能指针，能指向\操作任何OC对象
   //id == NSObject *
   typedef struct objc_object{
       Class isa;
   }*id;
   //id后面不加*
   用id调用不存在的方法会报错

三.类的构造方法

1.new的用处
完整地创建一个可用的对象
1.分配存储空间 + alloc
2.初始化 - init
3.释放 - dealloc
Person *p3 = [[Person alloc] init];

2.构造方法：是用来初始化对象的方法，是对象方法 -开头
   重写构造方法的目的：为了让对象创建出来，成员变量就会有一些固定的值
   重写构造方法注意点
       1.先调用父类的构造方法([super init])
       2.再进行子类内部成员变量的初始化

   重写-init方法 - (id)init
       1.一定要调用回super的init方法：初始化父类中声明的一些成员变量和其他属性 self = [super init];//当前对象 self = [父类将isa初始化为当前类]
       2.当前对象指针指向父类构造出来的对象
       3.当前对象指针 self = [父类将isa初始化为当前类]

   init的执行过程，运行原理
   //子类实例被创建的时候会先创建父类实例（调用父类的无参数构造方法），然后再创建子类实例

   重写构造方法的执行顺序
   student init super init
   person init super init
   nsobject init ....被封闭了
   返回一个class

3.自定义构造函数规范
1.一定是对象方法，一定以－开头
2.返回值一般以id类型
3.方法名一般以initWith开头

四.类的扩展
Category分类、类别、类目
   使用分类扩展类，并且不修改类原来的代码
   1.分类只能增加方法，不能增加成员变量，添加成员变量可以使用继承。
   2.分类的方法实现中可以使用成员变量
   3.分类的优先级最高，先去分类中找，再去原来的类中找，最后到父类中去找
   4.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法,会有警告
   5.多个分类实现的方法，最后一个编译的有效

   //声明
   @interface 类名(分类名称)
   @end

   //实现
   @implementation 类名(分类名称)
   @end
   xcode添加分类->项目右键-NewFile OS X->Cocoa->Objective-C category(在Xcode6中已移除，如想使用需要手动添加模版文件)
   xcode6 想要添加分类需要项目右键-NewFile OS X->Cocoa->Objective-C File 然后在弹出窗口中的 File Type:Category然后输入其它之后添加。

扩展
Extension
   作用：定义私有方法。可以隐藏不对外公布的方法。多用于隐藏一些中间步骤的方法。
   写法：在.m文件中 @implementation 前实现
   例如在 @implementation之前加上
   @interface ViewController ()
   {
       int a;//默认私有
   }
   @end

协议
protocol
   可以实现类似多继承的方法。一个类遵守多个协议<...,...>
   在协议里声明方法来让类遵守
   @required //默认是必须实现的
   - (void)method1;
   - (void)method2;
   @optional //可以选择实现

五.类的深入研究
   1.利用类需要先创建类类型对象
   2.类需要占据存储空间。
   3.每个类对象，占据不同的存储空间
   4.类本身也是一个对像，是Class类型的对象

Class类型的定义
   typedef struct objc_class *Class;
   类名就代表着类对象，每个类只有一个类对象

内存中的类对象
   Person * p = [[Person alloc] init];

获取内存中的类对象
   1.Class c = [p class];
   2.Class c2 = [Person class];

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

   //类对象 == 类
   Class c = [p class];
   [c test];

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

类的加载
   1.当程序启动时，就会加载项目中所有的类和分类，而且加载后会调用每个类和分类的+load方法，只会调用一次.
   2.当第一次使用某个类时，就会调用当前类的+initialize方法，但是会先找分类的，因为有优先级
   3.加载优先级顺序先初始化父类-初始化子类
   4.initialize调用优先级先最后编译的分类-本类-父类

   @implementation Person
   + (void)test
   {
       NSLog(@"test");
   }
   //当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法,加载顺序是先父类后子类
   + (void)load
   {
       NSLog(@"load");
   }
   //当第一次使用这个类的时候,就会调用一次initialize方法
   //当分类和类都有initialize方法时，只会调用分类的initialize方法
   + (void)initialize
   {
       NSLog(@"initialize");
   }

NSLog函数的工作原理
   Person *p = [[Person alloc] init];
   //默认情况下，利用NSLog和%@输出对象时，结果是:<类名:内存地址>
   //1.首先调用对象的-description方法
   //2.拿到-description方法的返回值(NSString *)显示到屏幕上
   //3.-description方法默认返回的是"类名+内存地址"
   //子类会继承重写的方法
   NSLog(@"%@",p);

Class c = [Person class];
   //1.首先调用类的+description方法
   //2.拿到+description方法的返回值(NSString *)显示到屏幕上
   //3.+description方法默认返回的是"类名"
   NSLog(@"%@",c);
   重写-description方法

NSLog的其它功能
   __func__ %s Current function signature.
   __LINE__ %d Current line number in the source code file.
   __FILE__ %s Full path to the source code file.
   __PRETTY_FUNCTION__ %s Like__func__,but includes verbose type information in C++ code.s

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

SEL对象的创建
   [p test:@"123"];
   SEL s = @selector(test:);
   NSString *name = @"test";
   SEL s2 = NSSelectorFromString(@"test");
   [p performSelector:s withObject:@"456"];

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

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

_cmd
   //每个方法内部都有一个_cmd，_cmd代表当前方法
   用法
   NSString *str = NSStringFromSelector(_cmd);
   NSLog(@"调用了方法%@",str);
   //死循环

[self performSelector:_cmd];

1.点语法
点语法的本质还是方法调用
比如 p.age=10; 就是转换为 [p setAge:10];
int a = p.age 转换为 int a = [p age];

xcode - Create a new Xcode project - OS X- Application - Command Line Tool - create

添加类
OS X - Cocoa(Source) - Objective-C class -> Class:Person ->Subclass of :NSObject -> Language:Objective-C - Create
生成Person.h与.m

command+r 运行

xcode6 需要点右下角的[ |]图标(Hide the Console)才能看到控制台

Person.h->

//
//  person.h
//  oc06核心语法
//
//  Created by Whome on 14-10-27.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    int _age;
    NSString * _name;
}

- (void) setAge:(int)age;
- (int) age;
- (void) setName:(NSString *)name;
- (NSString *) name;

@end

Person.m->

//
//  person.m
//  oc06核心语法
//
//  Created by Whome on 14-10-27.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@implementation Person

- (void) setAge:(int)age
{
    //self.age = 10; 是死循环
    _age = age;
    NSLog(@"setAge:%d",self->_age);
}
- (int) age
{
    NSLog(@"age:%d",self->_age);
    return self->_age;
}
- (void) setName:(NSString *)name
{
    _name = name;
    NSLog(@"setName:%@",self->_name);
}
- (NSString *) name
{
    NSLog(@"name:%@",self->_name);
    return self->_name;
}

@end

main.m->

//
//  main.m
//  oc06核心语法
//
//  Created by Whome on 14-10-27.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"
/*
 点语法的本质还是方法调用
 比如 p.age=10; 就是转换为 [p setAge:10];
 int a = p.age 转换为 int a = [p age];
 */

int main() {
    
    Person *p = [Person new];
    
    p.age = 10;
    int a = p.age;
    NSLog(@"a:%d",a);
    p.name = @"is name";
    NSString *s = p.name;
    
    NSLog(@"s:%@",s);
    
    return 0;
}

控制台输出
2014-10-27 06:42:57.278 oc06核心语法[502:303] setAge:10
2014-10-27 06:42:57.287 oc06核心语法[502:303] age:10
2014-10-27 06:42:57.288 oc06核心语法[502:303] a:10
2014-10-27 06:42:57.294 oc06核心语法[502:303] setName:is name
2014-10-27 06:42:57.302 oc06核心语法[502:303] name:is name
2014-10-27 06:42:57.303 oc06核心语法[502:303] s:is name
Program ended with exit code: 0

2.成员变量作用域
1.基本概念
局部变量、全局变量都有自己的作用域，成员变量也不例外
2.类型
>@private：只能在当前类的实现@implementation中直接访问
>@protected:可以在当前类以及子类的实现@implementation中直接访问
>@public:任何地方都可直接访问
>@package:同一个“体系内”（框架）可以访问，介于@private@public之间
3.继承补充
>专业术语父类\超类 superclass 子类 subclass\subclasses 单继承
4.@implementation补充
没有@interface,只有@implementaton,也可以开发一个类,在.m文件进行声明
在声明里写的成员变量，默认是private
实现里面也能写成员变量默认是私有，因为不会被其他文件包含,无法改设置就算写上@public也没用
(@interface)声明和(@implementation)实现里面不能定义同名的变量

添加类
OS X - Cocoa(Source) - Objective-C class -> Class:Person ->Subclass of :NSObject -> Language:Objective-C - Create
生成Person.h与.m

Person.h->

//
//  Person.h
//  02成员变量的作用域
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//


#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    int _no;
    
    @public //在作何地方都能直接方问对象的成员变量
    int _age;
    
    @private//只能在当前类的对象方法中直接访问
    int _height;
    
    @protected //可以在当前类及其子类的对象方法中直接访问
    int _weight;
}
- (void)setHeight:(int) height;
- (int)height;
- (void)test;
@end

Person.m->

//
//  Person.m
//  02成员变量的作用域
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@implementation Person
{
    int _aaa;//默认就是私有
    
    @public
    int _bbb;
    
}
- (void)test
{
    _age = 19;
    _height = 20;
    _weight = 50;
    _aaa = 10;
}
- (void)setHeight:(int)height{
    _height = height;
}
- (int)height
{
    return _height;
}
@end

Student.h->

//
//  Student.h
//  02成员变量的作用域
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@interface Student : Person
- (void)study;
@end

Student.m->

//
//  Student.m
//  02成员变量的作用域
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Student.h"

@implementation Student
- (void)study
{
    //_height = 10;
    [self setHeight:10];
    
    int h = [self height];
    
    _weight = 100;
    
    NSLog(@"h:%d",h);
}
@end

Car.m->

//
//  <pre name="code" class="objc">Car .m
//  02成员变量的作用域
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//
#import "Person.h"
#import "Student.h"
@implementation Car : NSObject
{
    @public
    int _speed;
}
- (void)setSpeed:(int)speed
{
    _speed = speed;
}
- (int)speed
{
    return _speed;
}
- (void) test{
    NSLog(@"speed:%d",_speed);
}
@end

main.m->

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Student *stu = [Student new];
        
        [stu setHeight:10];
        
        NSLog(@"%d",[stu height]);
        
        Car *c = [Car new];
        c->_speed = 250;
        c.speed = 10;
        
        NSLog(@"speed:%d",c.speed);
        
        Person *p = [Person new];
        //私有的private
      //  p->_bbb = 10;
        p->_age = 100;
        //私有的private
     //   p->_height = 20;
        
    }
    return 0;
}

控制台:
2014-10-28 07:55:13.150 02成员变量的作用域[630:303] 10
2014-10-28 07:55:13.153 02成员变量的作用域[630:303] speed:10
Program ended with exit code: 0

1.@property
在@interface和@end之间
编译器特性，当遇到@property int age自动生成某个成员变量的setter和getter声明，不能重复声明
如果使用了@property，但是没有成员变量，则自动生成private类型的成员变量
缺点，成员变量是死的，无法设置public或protected

2.@synthesize
在@implementation和@end之间
自动生用age的setter和getter的实现,并且会访问_age这个成员变量
@synthesize age = _age;也可以@synthesize age = _age,name = _name;
如果@synthesize age没有指定，那么默认访问和age一样的成员变量

@property新特性
自从Xcode4.4以后,@property就独揽了@synthesize的功能，也不是说，@property可以同时声明成员变量的声明和实现

@property(nonatomic,retain) UIWindow *window;

其中参数主要分为三类：

读写属性：（readwrite/readonly）
setter语意：（assign/retain/copy）
原子性：（atomicity/nonatomic）

各参数意义如下：

readwrite: 产生setter\getter方法
readonly: 只产生简单的getter,没有setter。
assign: 默认类型,setter方法直接赋值，而不进行retain操作
retain: setter方法对参数进行release旧值，再retain新值。
copy: setter方法进行Copy操作，与retain一样,不对旧值release
nonatomic: 禁止多线程，变量保护，提高性能

3.id
id是一种类似如 id d 所以变量名不能叫id，id是关键字
id是万能指针，能指向\操作任何OC对象
//id == NSObject *
typedef struct objc_object{
Class isa;
}*id;
//id后面不加*
用id调用不存在的方法会报错

Person.h->

//
//  Person.h
//  03关键字
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Person : NSObject
{
   
    int _age;
     @private
    int _width;
}
//自动生成getter和setter及private类型的成员变量
@property int height;
@property NSString* name;
//自动生成getter和setter
@property int age;

- (void)setWidth:(int)width;
- (int)width;

@end

Person.m->

//
//  Person.m
//  03关键字
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@implementation Person

//自动实现setter和getter
@synthesize height = _height;

//没有@property int width会报错
//@synthesize width = _widht;

- (void)setWidth:(int)width{
    _width = width;
}

- (int)width{
    return _width;
}

@end

Student.h->

//
//  Student.h
//  03关键字
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@interface Student : Person

@end

Student.m->

//
//  Student.m
//  03关键字
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Student.h"

@implementation Student

@end

main.m->

//
//  main.m
//  03关键字
//
//  Created by Whome on 14-10-28.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Student.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        Person *p = [Person new];
        
        //只手动声明了成员变量
        p.age = 10;
        //纯@property
        p.height=10;
        //纯@property
        p.name = @"is name";
        //纯手动
        p.width = 10;
        
        NSLog(@"p.age:%d",p.age);
        NSLog(@"p.height:%d",p.height);
        NSLog(@"p.name:%@",p.name);
        NSLog(@"p.width:%d",p.width);
        
        Student *s = [Student new];
        
        
        //父类的成员变量是私有的无法－>调用，但是setter/getter可以用
        //只手动声明了成员变量
        s.age = 10;
        //纯@property
        s.height=10;
        //纯@property
        s.name = @"is name";
        //纯手动
        s.width = 10;
        
        
        NSLog(@"s.age:%d",s.age);
        NSLog(@"s.height:%d",s.height);
        NSLog(@"s.name:%@",s.name);
        NSLog(@"s.width:%d",s.width);

        
        //id是一种类似如 id d 所以变量名不能叫id，id是关键字
        //id是万能指针，能指向\操作任何OC对象
        
        id d = [Student new];
        //无法直接用.语法来调用
        //d.age = 10;
        [d setAge:10];
        NSLog(@"d.age:%d",[d age]);
        
    }
    return 0;
}

控制台输出:
2014-10-29 00:10:15.692 03关键字[690:303] Hello, World!
2014-10-29 00:10:15.695 03关键字[690:303] p.age:10
2014-10-29 00:10:15.696 03关键字[690:303] p.height:10
2014-10-29 00:10:15.697 03关键字[690:303] p.name:is name
2014-10-29 00:10:15.698 03关键字[690:303] p.width:10
2014-10-29 00:10:15.699 03关键字[690:303] s.age:10
2014-10-29 00:10:15.700 03关键字[690:303] s.height:10
2014-10-29 00:10:15.701 03关键字[690:303] s.name:is name
2014-10-29 00:10:15.706 03关键字[690:303] s.width:10
2014-10-29 00:10:15.706 03关键字[690:303] d.age:10

1.new的用处
完整地创建一个可用的对象
1.分配存储空间 +alloc
2.初始化 -init
3.释放 -dealloc
Person *p3 = [[Person alloc] init];

//构造方法：是用来初始化对象的方法，是对象方法 -开头
//重写构造方法的目的：为了让对象创建出来，成员变量就会有一些固定的值
重写构造方法注意点
1.先调用父类的构造方法([super init])
2.再进行子类内部成员变量的初始化

//重写-init方法 - (id)init
//1.一定要调用回super的init方法：初始化父类中声明的一些成员变量和其他属性 self = [super init];//当前对象 self = [父类将isa初始化为当前类]

init的执行过程，运行原理
//子类实例被创建的时候会先创建父类实例（调用父类的无参数构造方法），然后再创建子类实例

自定义构造函数规范
1.一定是对象方法，一定以－开头
2.返回值一般以id类型
3.方法名一般以initWith开头

Person.h->

//
//  Person.h
//  04构造方法
//
//  Created by Whome on 14-10-29.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Person : NSObject
{
   // int _age;
   // NSString* _name;
}
@property int age;
@property NSString* name;
- (id)init;
/*
 自定义构造函数规范
 1.一定是对象方法，一定以 － 开头
 2.返回值一般以id类型
 3.方法名一般以initWith开头
 */
- (id)initWithName:(NSString *) name andAge:(int) age;
@end

Person.m->

//
//  Person.m
//  04构造方法
//
//  Created by Whome on 14-10-29.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@implementation Person
//重写重构方法
- (id)init
{
    //当前对象指针指向父类构造出来的对象
    //当前对象指针 self = [父类将isa初始化为当前类]
    self = [super init];
    
    //如果self不为0
    if(self){
        //初始化成员变量
        _age = 10;
    }
    return self;
}
- (id)initWithName:(NSString *)name andAge:(int)age
{
    if(self = [super init])
    {
        _name = name;
        _age = age;
    }
    return self;
}
@end

Student.h->

//
//  Student.h
//  04构造方法
//
//  Created by Whome on 14-10-29.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@interface Student : Person
{
    int _no;
}
@property int no;
- (id)init;
- (id)initWithName:(NSString *) name andAge:(int) age andNo:(int) no;
@end

Student.m->

//
//  Student.m
//  04构造方法
//
//  Created by Whome on 14-10-29.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Student.h"

@implementation Student
//重写重构方法
- (id)init
{
    //当前对象指针指向父类构造出来的对象
    //当前对象指针 self = [父类将isa初始化为当前类]
    //一定要调用父类的init方法，初始化一些父类声明的成员变量和方法
    self = [super init];
    
    //如果self不为0，如果对象初始化成功，能有必要进行接下来的初始化
    if(self){
        //初始化成员变量
        _no = 50;
    }
    //返回一个已初始化完毕的对象
    return self;
}
- (id)initWithName:(NSString *)name andAge:(int)age andNo:(int)no
{
    
    if(self = [super initWithName:name andAge:age ])
    {
        //如果_name是子类可继随的那么
        //_name = name;
        //如果_name是私有的那么
        //self.name = name;
        //如果想在父类构造时就初始化，而且并不关心父类的成员变量那么
        //[super initWithName:name andAge:age ]
        
        _no = no;
    }
    return self;
}

@end

main.m->

//
//  main.m
//  04构造方法
//
//  Created by Whome on 14-10-29.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

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

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        /*
        1.new的用处
        完整地创建一个可用的对象
        1.分配存储空间 +alloc
        2.初始化 -init
        */
        Student *s = [[Student alloc] init];
        NSLog(@"age:%d,no:%d",s.age,s.no);
        
        /*
         重写构造方法的执行顺序
         student init super init
         person init super init
         nsobject init ....被封闭了
         返回一个class
         */
        /*
         自定义构造函数规范
         1.一定是对象方法，一定以 － 开头
         2.返回值一般以id类型
         3.方法名一般以initWith开头
         */
         s = [[Student alloc] initWithName:@"is name" andAge:10 andNo: 20];
         NSLog(@"age:%d,no:%d,name:%@",s.age,s.no,s.name);
    }
    return 0;
}

控制台->

2014-10-30 06:24:35.326 04构造方法[398:303] Hello, World!
2014-10-30 06:24:35.332 04构造方法[398:303] age:10,no:50
2014-10-30 06:24:35.336 04构造方法[398:303] age:10,no:20,name:is name

Category分类、类别、类目
/*使用分类扩展类，并且不修改类原来的代码
1.分类只能增加方法，不能增加成员变量，添加成员变量可以使用继承。
2.分类的方法实现中可以使用成员变量
3.分类的优先级最高，先去分类中找，再去原来的类中找，最后到父类中去找
4.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法,会有警告
5.多个分类实现的方法，最后一个编译的有效
*/
//声明
@interface 类名(分类名称)
@end

//实现
@implementation 类名(分类名称)
@end

xcode添加分类->项目右键-NewFile OS X->Cocoa->Objective-C category(在Xcode6中已移除，如想使用需要手动添加模版文件)
xcode6 想要添加分类需要项目右键-NewFile OS X->Cocoa->Objective-C File 然后在弹出窗口中的 File Type:Category然后输入其它之后添加。

扩展
Extension
作用：定义私有方法。可以隐藏不对外公布的方法。多用于隐藏一些中间步骤的方法。
写法：在.m文件中 @implementation 前实现
例如在 @implementation之前加上
@interface ViewController ()
{
int a;//默认私有
}
@end

协议
protocol
可以实现类似多继承的方法。一个类遵守多个协议<...,...>
在协议里声明方法来让类遵守
@required //默认是必须实现的
- (void)method1;
- (void)method2;
@optional //可以选择实现

给系统自带类添加分类
1.给NSString增加一个类方法：计算某个字符串中阿拉伯数字的个数
2.给NSString增加一个对象方法：计算当前字符串中阿拉伯数字的个数

Person.h->

#import <Foundation/Foundation.h>

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

Person.m->

#import "Person.h"

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

Person+sum.h->

#import "Person.h"

@interface Person (sum)
- (int)sumWithAge:(int)age1 andAge2:(int)age2;
- (void)test;
@end

Person+sum.m->

#import "Person+sum.h"

@implementation Person (sum)
- (int)sumWithAge:(int)age1 andAge2:(int)age2
{
    self.age = age2+age2;
    NSLog(@"self.age:%d",self.age);
    //出错，因为没有在类声明变量。
    //_age = 0;
    //age = 0;
    //self->_age=0;
    //self->age =0;
    /*
    self->age =age+age2;
    return self->_age;
     */
    return self.age;
}
- (void)test
{
    NSLog(@"person+sum");
}
@end

NSString+count.h->

#import <Foundation/Foundation.h>


/*
 给系统自带类添加分类
 1.给NSString增加一个类方法：计算某个字符串中阿拉伯数字的个数
 2.给NSString增加一个对象方法：计算当前字符串中阿拉伯数字的个数
 */
@interface NSString (count)
+ (int) numberCountOfString:(NSString *)str;
- (int)numberCount;
@end

NSString+count.m->

#import "NSString+count.h"

@implementation NSString (count)
// 计算某个字符串中阿拉伯数字的个数
+ (int) numberCountOfString:(NSString *)str
{
    int count=0;
    //获取长度并循环
    for(int i=0;i<str.length;i++)
    {
        //获取字符
        unichar c = [str characterAtIndex:i];
        //将数字挑选出来
        if(c>'0' && c<'9')
        {
            count++;
            NSLog(@"%c",c);
        }
    }
    return count;
}
//计算当前字符串中阿拉伯数字的个数
- (int)numberCount
{
    int count=0;
    for(int i=0;i<self.length;i++)
    {
        unichar c = [self characterAtIndex:i];
        if(c>'0' && c<'9')
        {
            count++;
            NSLog(@"%c",c);
        }
    }
    return count;
}
@end

main.m->

#import <Foundation/Foundation.h>

#import "Person.h"
#import "Person+sum.h"
#import "NSString+count.h"

/*
 Category分类 、类别、类目
 使用分类扩展类，并且不修改类原来的代码
 1.分类只能增加方法，不能增加成员变量，添加成员变量可以使用继承。
 2.分类的方法实现中可以使用成员变量
 3.分类的优先级最高，先去分类中找，再去原来的类中找，最后到父类中去找
 4.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法,会有警告
 5.多个分类实现的方法，最后一个编译的有效
 */
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        Person *p = [[Person alloc]init];
        
        int age = [p sumWithAge:10 andAge2:20];
        NSLog(@"age:%d",age);
        
        [p test];
        
       
        
        int count = [NSString numberCountOfString:@"a12d5x778" ];
        NSLog(@"count:%d",count);

        NSString *s = @"ab234x278";
        count = [s numberCount];
        NSLog(@"count:%d",count);

        count = [@"asdf2ssdf2" numberCount];
        NSLog(@"count:%d",count);


    }
    
    return 0;
}

控制台:
2014-11-09 19:43:05.706 05类的分类[852:303] Hello, World!
2014-11-09 19:43:05.709 05类的分类[852:303] self.age:40
2014-11-09 19:43:05.710 05类的分类[852:303] age:40
2014-11-09 19:43:05.710 05类的分类[852:303] person+sum
2014-11-09 19:43:05.711 05类的分类[852:303] 1
2014-11-09 19:43:05.711 05类的分类[852:303] 2
2014-11-09 19:43:05.712 05类的分类[852:303] 5
2014-11-09 19:43:05.712 05类的分类[852:303] 7
2014-11-09 19:43:05.714 05类的分类[852:303] 7
2014-11-09 19:43:05.714 05类的分类[852:303] 8
2014-11-09 19:43:05.715 05类的分类[852:303] count:6
2014-11-09 19:43:05.717 05类的分类[852:303] 2
2014-11-09 19:43:05.718 05类的分类[852:303] 3
2014-11-09 19:43:05.719 05类的分类[852:303] 4
2014-11-09 19:43:05.719 05类的分类[852:303] 2
2014-11-09 19:43:05.720 05类的分类[852:303] 7
2014-11-09 19:43:05.721 05类的分类[852:303] 8
2014-11-09 19:43:05.721 05类的分类[852:303] count:6
2014-11-09 19:43:05.722 05类的分类[852:303] 2
2014-11-09 19:43:05.723 05类的分类[852:303] 2
2014-11-09 19:43:05.727 05类的分类[852:303] count:2

可能性
我觉得跟权限没关系应该是分类在调用这个变量的时候property还没有生成
那么就只有一个原因, 分类可以重写setAge和(get)age方法.
又因为set get 这两个方法一旦重写那property 就不在会生成_age变量;

所以OC为了避免这种情况直接限制在有分类的情况必须自己书写变量不能用property 这样就不会导致重写set get会让property失效了
你可以在正常情况下写了property 然后在重写set get方法你会发现找不到变量

类的深入研究
1.利用类需要先创建类类型对象
2.类需要占据存储空间。
3.每个类对象，占据不同的存储空间
4.类本身也是一个对像，是Class类型的对象

Class类型的定义
typedef struct objc_class *Class;
类名就代表着类对象，每个类只有一个类对象

内存中的类对象
Person * p = [[Person alloc] init];

获取内存中的类对象
1.Class c = [p class];
2.Class c2 = [Person class];

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

//类对象 == 类
Class c = [p class];
[c test];

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

类的加载
1.当程序启动时，就会加载项目中所有的类和分类，而且加载后会调用每个类和分类的+load方法，只会调用一次.
2.当第一次使用某个类时，就会调用当前类的+initialize方法，但是会先找分类的，因为有优先级
3.加载优先级顺序先初始化父类-初始化子类
4.initialize调用优先级先最后编译的分类-本类-父类

@implementation Person
+ (void)test
{
   NSLog(@"test");
}
//当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法,加载顺序是先父类后子类
+ (void)load
{
   NSLog(@"load");
}
//当第一次使用这个类的时候,就会调用一次initialize方法
//当分类和类都有initialize方法时，只会调用分类的initialize方法
+ (void)initialize
{
   NSLog(@"initialize");
}

NSLog函数的工作原理
Person *p = [[Person alloc] init];
//默认情况下，利用NSLog和%@输出对象时，结果是:<类名:内存地址>
//1.首先调用对象的-description方法
//2.拿到-description方法的返回值(NSString *)显示到屏幕上
//3.-description方法默认返回的是"类名+内存地址"
//子类会继承重写的方法
NSLog(@"%@",p);

Class c = [Person class];
//1.首先调用类的+description方法
//2.拿到+description方法的返回值(NSString *)显示到屏幕上
//3.+description方法默认返回的是"类名"
NSLog(@"%@",c);
重写-description方法

NSLog的其它功能
__func__ %s Current function signature.
__LINE__ %d Current line number in the source code file.
__FILE__ %s Full path to the source code file.
__PRETTY_FUNCTION__ %s Like__func__,but includes verbose type information in C++ code.s

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

SEL对象的创建
[p test:@"123"];
SEL s = @selector(test:);
NSString *name = @"test";
SEL s2 = NSSelectorFromString(@"test");
[p performSelector:s withObject:@"456"];

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

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

_cmd
//每个方法内部都有一个_cmd，_cmd代表当前方法
用法
NSString *str = NSStringFromSelector(_cmd);
NSLog(@"调用了方法%@",str);
//死循环
[self performSelector:_cmd];

main.m->

//
//  main.m
//  06类的深入
//
//  Created by Whome on 14-11-7.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

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


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        
        /*
         Class类型的定义
         typedef struct objc_class *Class;
         类名就代表着类对象，每个类只有一个类对象
         */
        
        //获取内存中的类对象
        Person *p = [[Person alloc]init];
        Class c = [p class];
        Class c1 = [Person class];
        
        NSLog(@"c=%p,c1=%p",c,c1);
        
        //类对象 == 类
        Class c2 = [p class];
        [c test];
        
        Person *p1 = [[c2 new] init];
        [p1 test];
        
        /*
         类的加载
         1.当程序启动时，就会加载项目中所有的类和分类，而且加载后会调用每个类和分类的+load方法，只会调用一次.
         2.当第一次使用某个类时，就会调用当前类的+initialize方法，但是会先找分类的，因为有优先级
         3.加载优先级 顺序 先初始化父类-初始化子类
         4.initialize调用优先级 先最后编译的分类-本类-父类
         */
        
        
        /*
         %@ 对象
         %d, %i 整数
         %u,%z 无符整形
         %f 浮点/双字
         %x, %X 十六进制整数
         %o 八进制整数
         %zu size_t
         %p 指针
         %e 浮点/双字 （科学计算）
         %g 浮点/双字
         %s C字符串
         %.*s Pascal字符串
         %c 字符
         %C unichar
         %lld 64位长整数（long long）
         %llu 无符64位长整数
         %Lf 64位双字
         %hhd    BOOL布尔类型
         __func__ %s  Current function signature.
         __LINE__ %d  Current line number in the source code file.
         __FILE__ %s Full path to the source code file.
         __PRETTY_FUNCTION__ %s Like__func__,but includes verbose type information in C++ code.s
         */
        NSLog(@"__func__:%s",__func__);
        NSLog(@"__LINE__:%d",__LINE__);
        NSLog(@"__FILE__:%s",__FILE__);
        NSLog(@"__PRETTY_FUNCTION__:%s",__PRETTY_FUNCTION__);
       // NSLog函数的工作原理
        Student *p2 = [[Student alloc] init];
        //默认情况下，利用NSLog和%@输出对象时，结果是:<类名:内存地址>
        //1.首先调用对象的-description方法
        //2.拿到-description方法的返回值(NSString *)显示到屏幕上
        //3.-description方法默认返回的是"类名+内存地址"
        NSLog(@"p2:%@",p2);
        
        
        Class c3 = [Student class];
        //1.首先调用类的+description方法
        //2.拿到+description方法的返回值(NSString *)显示到屏幕上
        //3.+description方法默认返回的是"类名"
        NSLog(@"c3:%@",c3);
        //重写-description方法

        /*
        SEL
        每个SEL对应一个方法地址
        每个类的方法列表都存储在类对象中
        根据一个SEL对象就可以找到方法的地址，进而调用方法
        SEL类型的定义
        typedef struct objc_selector *SEL
        */
        //SEL对象的创建
        [p testStr:@"123"];
        SEL s = @selector(testStr:);
        NSString *name = @"testStr:";
        //SEL s2 = NSSelectorFromString(@"testStr");
        SEL s2 = NSSelectorFromString(name);
        
        [p performSelector:s withObject:@"456"];
        [p performSelector:s2 withObject:@"56"];
        
        
        //SEL对象的其他用法
        //将 SEL对象转为NSString对象
        NSString *str  =NSStringFromSelector(@selector(test));
        
        NSLog(@"str%@:",str);
        
        //间接调用对象p的test方法
        s = @selector(test);
        [p performSelector:s];
        //不知道为什么调用test报错
    /*
    保留test对象方法在编辑时报Multiple methods named 'test' found with mismatched result,parameter type or attributes
    只保类test类方法在编译时报*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[Person test]: unrecognized selector sent to instance 0x100104fd0'
    */
        [p performSelector:@selector(test2)];
       
    }
    return 0;
}

Person.h->

//
//  Person.h
//  06类的深入
//
//  Created by Whome on 14-11-7.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Person : NSObject
+ (void)test;
- (void)test;
- (void)test2;
- (void)testStr:(NSString*)str;
@end

Person.m->

//
//  Person.m
//  06类的深入
//
//  Created by Whome on 14-11-7.
//  Copyright (c) 2014年 Whome. All rights reserved.
//

#import "Person.h"

@implementation Person
+ (void)test
{
    NSLog(@"Person test");
}
- (void)test
{
    NSLog(@"Person -test");
    /*
     _cmd
     每个方法内部都有一个_cmd，_cmd代表当前方法
     用法
     */
    NSString *str = NSStringFromSelector(_cmd);
    NSLog(@"调用了方法%@",str);
    //死循环
    //[self performSelector:_cmd];
}
//当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法,加载顺序是先父类后子类
+ (void)load
{
    NSLog(@"Person load");
}
//当第一次使用这个类的时候,就会调用一次initialize方法
//当分类和类都有initialize方法时，只会调用分类的initialize方法
+ (void)initialize
{
    NSLog(@"Person initialize");
}
//默认情况下，利用NSLog和%@输出对象时，结果是:<类名:内存地址>
//1.首先调用对象的-description方法
//2.拿到-description方法的返回值(NSString *)显示到屏幕上
//3.-description方法默认返回的是"类名+内存地址"
//子类会继承这个方法
- (NSString*)description
{
    return @"NSLog description 返回值";
}
- (void)testStr:(NSString*)str{
    NSLog(@"%@",str);
}
- (void)test2{
    NSLog(@"- test2");
    NSString *str = NSStringFromSelector(_cmd);
    NSLog(@"调用了方法%@",str);
}
+ (void)test2{
    NSLog(@"+ test2");
}
@end

Person+Mj.h->

#import "Person.h"

@interface Person (MJ)

@end

Person+Mj.m->

#import "Person+MJ.h"

@implementation Person (MJ)
//当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法,加载顺序是先父类后子类
+ (void)load
{
    NSLog(@"Person+MJ load");
}
//当第一次使用这个类的时候,就会调用一次initialize方法
//当分类和类都有initialize方法时，只会调用分类的initialize方法
+ (void)initialize
{
    NSLog(@"Person+MJ initialize");
}
@end

Student.h->

#import "Person.h"

@interface Student : Person
+ (void)test;
@end

Student.m->

#import "Student.h"

@implementation Student
+ (void)test
{
    NSLog(@"Student test");
}
//当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法,加载顺序是先父类后子类
+ (void)load
{
    NSLog(@"Student load");
}
//当第一次使用这个类的时候,就会调用一次initialize方法
//当分类和类都有initialize方法时，只会调用分类的initialize方法
+ (void)initialize
{
    NSLog(@"Student initialize");
}
@end

控制台

2014-11-09 07:41:25.908 06类的深入[894:303] Person load
2014-11-09 07:41:25.911 06类的深入[894:303] Student load
2014-11-09 07:41:25.912 06类的深入[894:303] Person+MJ load
2014-11-09 07:41:25.913 06类的深入[894:303] Hello, World!
2014-11-09 07:41:25.913 06类的深入[894:303] Person+MJ initialize
2014-11-09 07:41:25.914 06类的深入[894:303] c=0x1000026d0,c1=0x1000026d0
2014-11-09 07:41:25.915 06类的深入[894:303] Person test
2014-11-09 07:41:25.916 06类的深入[894:303] - test2
2014-11-09 07:41:25.916 06类的深入[894:303] 调用了方法test2
2014-11-09 07:41:25.919 06类的深入[894:303] __func__:main
2014-11-09 07:41:25.919 06类的深入[894:303] __LINE__:73
2014-11-09 07:41:25.921 06类的深入[894:303] __FILE__:
2014-11-09 07:41:25.921 06类的深入[894:303] __PRETTY_FUNCTION__:int main(int, const char **)
2014-11-09 07:41:25.922 06类的深入[894:303] Student initialize
2014-11-09 07:41:25.923 06类的深入[894:303] p2:NSLog description 返回值
2014-11-09 07:41:25.924 06类的深入[894:303] c3:Student
2014-11-09 07:41:25.925 06类的深入[894:303] 123
2014-11-09 07:41:25.925 06类的深入[894:303] strtest:
Program ended with exit code: 0

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------