Objective-C学习笔记

时间 2019-11-17

标签 objective 学习笔记栏目 C&C++ 繁體版

原文原文链接

1、语法基础objective-c

1.OC的语法数组

　　关键字基本上都是以@开头，特例：self super id 等等；多线程

　　字符串以@开始；框架

　　BOOL： YES、NO；空：nil；函数

　　NSLog(@"Hello");性能

2.包含框架的主头文件就能够包含全部的.H，及.*的做用。ui

3.方法与对象：this

　　对象的方法都是以减号-开始；atom

　　对象方法的声明必须在@interface和@end之间；url

　　对象方法的实现必须在@implementation和@end之间；

　　函数能够写在任意位置；

4.方法的参数

　　OC方法中，一个参数对应一个冒号;

　　冒号前须要加个说明；

　　冒号也是方法名的一部分；

　　- (int)pingFang:(int)num;

　　-(int)sumWithNum1:(int)num1 andNum2:(int)num2;

　　int n =[object pingFang:10];

　　int m = [object sumWithNum1:10 andNum2:5];

5.self

　　self 表明当前调用的对象或者类；this只能用在对象方法中；

6.多态

　　父类指针指向子类对象；

　　父类类型的变量，不能用来调用子类的方法；

7.字符串NSString

NSString *str = @"itcast";
NSLog(@"我在%@上课",str);

int age =15;
int no= 5;
NSString *name = @"Andy";

NSString *newStr = [NSString stringWithFormat:@"My age is %d and no is %d",age,no];

int size = [name length];

8.注释：

　　#pragma mark 注释标签

9.点语法

　　点语法的本质是方法调用；

　　stu.age=10;

　　编译器：[stu setAge:10];

　　int nAge=stu.age;

　　编译器：int nAge = [stu age];

10.set get的编译化

　　XCode 4.4之后 @property 独揽了@synthesize的功能

#import<Foundation/Foundtation.h>

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

@property int age;
@property NSString* name;

@end;

@implementation Person
@synthesize age=_age;
@synthesize name = _name;
@end

11. id类型

　　id 至关于 NSObject*

　　id 是万能指针；能指向和操做任何OC对象；

　　id d = [Person new];

12.构造方法

　　完成的建立一个可用的对象须要两部：

　　1.分配存储空间 +alloc;

　　2.初始化 -init　　

Person *p=[Person new];
//1.分配存储空间
Person *p1 = [Person alloc];
//2.使用-init进行初始化
Person *p2 = [p1 init];

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

//重写Person的init方法
-(id) init
{
    //必定要调用super的init方法：初始化父类的其余的成员变量和属性
    //self = [super init];
    if(self = [super init])
        {
           //初始化成功
          _age = 10;
        }
return self;
}

3.自定义构造方法规范

　　a.必定是对象方法；

　　b.返回类型通常是id类型；

　　c.方法名通常以init开头

13.Category 分类

　　不改变原来类的基础上，添加类的方法；

　　　　//声明

　　　　@interface 类名(分类名称)

　　　　@end

　　　　//实现

　　　　@implementation 类名(分类名称)

　　　　分类只能增长方法，不能增长成员变量；

　　　　分类方法实现中能够访问原来类的中成员变量；

　　　　分类方法的实现优先级最高，而后是原来类，而后是父类，这样会致使原来的方法失效；

14.类的加载和初始化

　　a.当程序启动时，就会加载项目中全部的类和分类，并且加载后会调用每一个类和分类的+load

方法；

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

c.先加载父类，再加载子类；

d.先初始化子类，再初始化子类；

15.description方法

　　默认状况下，NSLog和%@输出对象时，结果是:<类名：内存地址>

　　1.会调用对象的p的-description方法；

　　2.拿到-description方法的返回值(NSString *)显示到屏幕上

16. SEL

　　-(void) test;

　　-(void) test2:(NSString *)str;

　　[p test];　　

　　1.把方法包装成SEL类型的数据；

　　2.根据SEL数据找到test方法；

　　3.根据方法地址调用对应的方法；

　　[p performSelector:@selector(test)];

　　[p performSelector：@selector(test2:) withObject:@"123"];

2、内存管理

　　1.引用计数器

　　　　给对象发送retain消息，可使引用计数器+1；

　　　　给对象发送release消息，可使引用计数器-1；

　　　　能够给对象发送retainCount消息得到当前的引用计数器值；

　　2.对象的销毁

　　　　一个对象的引用计数器为0时；那么它将被销毁；

　　　　当一个对象被销毁时，系统会自动向对象发送一条dealloc方法；　　　　

Person类的实现

-(void) dealloc
{
      NSLog("对象被销毁");
      [super dealloc];    
}

//alloc 和release要成对出现；
//retain和release需成对出现；

　　3.OC不存在空指针错误，给空指针发送消息不报错；

　　4.retain方法会返回对象自己；

　　5.set方法的内存管理

　　　　基本数据类型，直接复制；

- (void) setCar:(Car*) car
{
    if(car != _car)
        {
         [_car release];
         _car = [car retain];  
        }
}

- (void)dealloc
{
    [_car release];
}

　　6.@property参数

　　　　1.set方法内存管理相关参数

　　　　　　a.@property (retain) Book *book; retain：release旧值，retain新值；

　　　　　　b.assign：直接赋值，适用于非OC对象类型；

　　　　　　c.copy：release旧值，copy新值；

　　　　2.是否生成set方法

　　　　　　readwrite：同时生成setter，getter的声明、实现；(默认)

　　　　　　readonly：只会生成getter的声明、实现；

　　　　3.多线程管理

　　　　　　 nonatomic:不加锁；性能高，必定要加。

　　　　　　 atomic:加锁，默认

　　　　4.setter和getter方法的名称

　　　　　　@property （getter=methodName,setter=setName:）int height;

　　　　　　setter方法必定要有冒号:，不经常使用;

　　　　　　通常经常使用于BOOL 类型的getter方法名的修改

　　　　　　@property (getter=isRich) BOOL rich;

　　7.循环retain和@class

　　　　　　循环retain的解决方案：

　　　　　　　　一端用retain，一端用assign；

　　　　　　@property(nonatomic,retain) Card *card;

　　　　　　@property(nonatomic,assign) Person* person;

　　8.autorelease　　　　　　

//autorelease方法会返回对象自己
//autorelease会将对象放到一个自动释放池；
//当自动释放池被销毁时，会对池子的全部对象作一次release操做；
//建立对象时，不要直接用类名；通常用self代替。
int main()
{
    @autoreleasepool
    {//开始表明建立了释放池  
        Person *p = [[[Person alloc] init] autorelease];
        return 0;  
    }//结束表明销毁释放池
}

+ (id)person
{
      //使用Person会出现子类调用时，返回的指针类型仍是父类的问题
      //return [[[Person alloc] init] autorelease] ;
     return [[[self alloc] init] autorelease] ;
}

+(id)personWithAge:(int) age
{
    //Person*p = [[[Person alloc] init] autorelease] ;
    Person*p =[self person];
    p.age =age;
    return p;
}

　　9.ARC机制　　

//ARC
ARC的判断准则：
只要没有强指针指向对象，就会释放对象；
        指针分2种：
            1.强指针：默认状况下，全部指针都是强指针 __strong
            2.弱指针:__weak

//strong 等价于以前的 retain
//
@property (nonatomic,strong) Dog *dog;
@property (nonatomic,weak) Dog *dog;

ARC的特色：
1.不容许调用release、retain、retainCount；
2.容许重写dealloc，可是不容许调用[super dealloc]
3.@property的参数
    *strong：成员变量是强指针(适用于OC对象类型)；
    *weak：成员变量是弱指针；
    * assign:适用于非OC对象类型；
4.之前的retain，修改成strong，其余一切不变。
5.若是两端互相引用，一端用strong，一端用weak；

3、其余数据类型

　　1.Block

　　　　Block的做用是来封装代码，能够在任什么时候候执行；

#import <Foundation/Foundation.h>

typedef int(*Sump) (int,int);

typedef int(^MyBlock)(int,int);

int main()
{
    
    int(^sumBlock)(int,int);
    
    sumBlock = ^(int a,int b){
        return a+b;
    };
    
    MyBlock sum2Block = ^(int a,int b){
        return a+b;
    };
    
    return 0;
}

void test2()
{
    int (^sumBlock)(int,int)=
    ^(int a,int b)
    {
        return a+b;
    };
    int c = sumBlock(10,11);
    NSLog(@"%d",c);
    
    
    //用一个block输入n条横线
    
    void (^lineBlock)(int)=
    ^(int n)
    {
        for (int i=0; i<n; i++) {
            NSLog(@"------------");
        }
    };
    
    lineBlock(5);
}

void test()
{
    //block用来保存一段代码
    //block的标识：^
    /*
     block跟函数很像：
     1.能够保存代码
     2.有返回值
     3.有形参
     
     block访问外边的变量：
     1.默认状况下，block能够访问外面的变量；
     2。默认状况下，block不能修改外面的变量
     3.给局部变量加上__block关键字，这个局部变量能够在内部修改；
     
     利用typedef定义block类型
     typedef int(^MyBlock)(int,int);
     之后利用MyBlock来定义block变量
     MyBlock sum2Block = ^(int a,int b){
     return a+b;
     };

     */
    
    //定义block变量
    //若是block没有形参，后面的括号能够省略
    
    
    void (^myblock)()=
    ^{
        NSLog(@"test-----------");
    };
    
    //利用block变量调用block内部的代码
    myblock();
}

2.@protocol 协议

#import <Foundation/Foundation.h>

//定义了一个名叫MyProtocol的协议
@protocol MyProtocol <NSObject>
//@required 要求实现，不实现就会发出警告；默认
//@optional 不要求实现。
//一个协议遵照了某一份协议，就能够拥有另外一个协议中的全部声明方法
//NSObject 是全部类的基类，也是基协议
//要求某个对象遵照这个协议
// NSObject<MyProtocol> *obj = 遵照该协议的类的对象;

/*
 1.协议的定义：
    @protocol 协议名称 <NSObject>
    //方法声明列表...
    @end
 2.如何遵照协议：
    1>类遵照协议：
    @interface 类名:父类名  <协议名称1,协议名称2>
 
    @end
    2>协议遵照协议：
    @protocol 协议名称 <其余协议名称1,其余协议名称2>
 
    @end
 3.协议中方法声明的关键字：
    1>@required 要求实现，不实现就会发出警告；默认
    2>@optional 不要求实现。
 4.定义一个变量的时候，限制这个变量的对象遵照某个协议
    类名<协议名称> *变量名；或者
    id<协议名称> 变量名；
 5.@property中声明的属性也可用作一个遵照协议的限制
    @property(nonatomic,strong) 类名<协议名称> *属性名；
    @property(nonatomic,strong) id<协议名称> 属性名；
 6.协议可定义在其余单独文件中， 也能够定义在某个类中
    1>若是这个协议只用在某个类中，则定义在该类中；
    2>若是用在多个多个类中，则定义在单独文件种。
 
 */

@required
- (void)test;

@optional
- (void)test2;

@end

4、Foundation框架

　　一、结构体

int main()
{
    /*
     NSRange(location,length)
     NSPoint\CGPoint
     NSSize\CGSize
     NSRect\CGRect
     */
    
    CGPoint point = NSMakePoint(10, 10);
    CGPoint point2 = CGPointMake(10, 10);//经常使用
    
    
    CGSize size = NSMakeSize(10, 10);
    CGSize size2 = CGSizeMake(10, 10);
    
    CGRect rect1 = CGRectMake(10, 10, 50, 50);
    CGRect rect2 = {{0,0},{50,50}};
    CGRect rect3 = {point,size};
    CGRect rect4 = {CGPointZero,CGSizeMake(100, 90)};
    
    NSString *str = NSStringFromPoint(point);
    
    //比较两个点是否相同
    BOOL bIsSame =CGPointEqualToPoint(point, point2);
    
    BOOL bIsContain = CGRectContainsPoint(rect1, point);
    

    return 0;
}

void testRange()
{
    //@“i love oc”；
    //    NSRange r1={2,4};//不用
    //    NSRange r2={.location=2,.length=4};//不经常使用
    //    NSRange r3 = NSMakeRange(2, 4);//经常使用
    
    NSString *str=@"i love oc";
    
    //查找字符串在str中的范围
    //若是找不到，length=0；location=NSNotFound==-1
    NSRange range=[str rangeOfString:@"love"];
    
    NSLog(@"loc=%ld,length=%ld",range.location,range.length);
}

二、字符串　　

/*
     1.字符串建立
     */
    NSString *str1=@"hello";
    NSString *str2=[[NSString alloc] initWithFormat:@"age is %d",10];
    
    NSString *str3 = [[NSString alloc] initWithUTF8String:"abc"];
    const char *cs = [str3 UTF8String];
    
    //从文件中读取
    NSString *str4 = [[NSString alloc] initWithContentsOfFile:@"/Users/chenwei/Desktop/objective-c-01.m" encoding:NSUTF8StringEncoding error:nil];
//    NSLog(@"%@",str4);
    
    //URL:资源路径
    //协议头://路径
    //本地文件，协议头 file://
    NSURL *url = [[NSURL alloc] initWithString:@"file:///Users/chenwei/Desktop/objective-c-01.m"];
    NSString *str5 = [[NSString alloc] initWithContentsOfURL: url encoding:NSUTF8StringEncoding error:nil];
    NSLog(@"%@",str5);
    
    
    //经常使用方法.通常都用一个类方法与对象方法对应。
    NSString *str6 = [NSString stringWithFormat:@"age is %d",10];
    NSURL *str7 = [NSURL URLWithString:@""];

三、数组

/*
 NSArray： 不可变数组
 NSMutableArray：可变数组
 
 @[] 只建立不可变数组NSArray
 */
int main(int argc, const char * argv[])
{
    
    NSMutableArray *array=[NSMutableArray array];
    [array addObject:@"Jack"];
    [array addObject:@"Rose"];
    //nil不能添加
    //[array addObject:nil];
    
    //删除元素
    //[array removeAllObjects];
    
    return 0;
}

void useArray()
{
    /*
     1.NSArray 建立
     */
    //OC数组只能存放OC对象、不能放非OC对象，好比int、struct等
    //NSArray *array = [NSArray array];
    NSArray *array2 = [NSArray arrayWithObject:@"jack"];
    //nil是数组元素结束的标记
    NSArray *array3=[NSArray arrayWithObjects:@"jack", @"Rose",nil];
    //快速建立数组的方式
    NSArray *array4=@[@"jack",@"rose",@"others"];
    /*
     2.NSArray 个数
     */
    int nCount = array2.count;
    
    /*
     3.NSArray 遍历
     */
    
    for (int i=0; i<array4.count; i++) {
        NSLog(@"%@",array4[i]);
    }
    
    for(id obj in array4)
    {
        NSUInteger nIndex = [array4 indexOfObject:obj];
        NSLog(@"%ld---%@",nIndex,obj);
    }
    
    //NSLog(@"%ld",array3.count);
    
    [array4 enumerateObjectsUsingBlock:
     //没遍历到一个元素，就会调用一次block
     //而且当前元素和索引位置当作参数传递给block
     ^(id obj, NSUInteger idx, BOOL *stop) {
         
         NSLog(@"%ld---%@",idx,obj);
         if (idx == 0) {
             //中止遍历
             *stop = YES;
         }
     }];
    
    void (^myBlock)(id,NSUInteger,BOOL *) = ^(id obj, NSUInteger idx, BOOL *stop) {
        
        NSLog(@"%ld---%@",idx,obj);
        if (idx == 0) {
            //中止遍历
            *stop = YES;
        }
    };
    
    for (int i=0; i<array4.count; i++) {
        BOOL bIsStop = NO;
        id obj = array4[i];
        myBlock(obj, i, &bIsStop);
        if (bIsStop) {
            break;
        }
    }

}

四、字典

int main(int argc, const char * argv[])
{
    /*
     字典:
        key------>value
        索引------>文字内容
     里面存储的都是键值对
     
     */
    NSDictionary *dict4=@{@"name": @"jack",@"address":@"北京"};
    
    NSArray *keys = [dict4 allKeys];
    for (int i=0; i<dict4.count; i++) {
        NSString *key = keys[i];
        NSString *object = dict4[key];
        NSLog(@"%@------%@",key,object);
    }
    
    [dict4 enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
        NSLog(@"%@------%@",key,obj);
    }];
    
    return 0;
}

void useMutableDictionary()
{
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    
    [dict setObject:@"Jack" forKey:@"name"];
    [dict setObject:@"北京" forKey:@"address"];
    [dict setObject:@"Rose" forKey:@"name"];
    
    //[dict removeAllObjects];
    NSLog(@"%@",dict);
}

void userDictionary()
{
    NSDictionary *dict = [NSDictionary dictionaryWithObject:@"jack" forKey:@"name"];
    id obj = [dict objectForKey:@"name"];
    
    NSArray *keys=@[@"name",@"address"];
    NSArray *objects=@[@"jack",@"北京"];
    NSDictionary *dict2 = [NSDictionary dictionaryWithObjects:keys forKeys:objects];
    
    NSDictionary *dict3 = [NSDictionary dictionaryWithObjectsAndKeys:
                           @"jack",@"name",
                           @"beijng",@"address",
                           nil];
    
    //经常使用方式
    NSDictionary *dict4=@{@"name": @"jack",@"address":@"北京"};
    
    id obj2 = [dict4 objectForKey:@"name"];
    
    id obj3 = dict4[@"name"];
    
    NSLog(@"%@",obj2);
    NSLog(@"%@",obj3);
    
    //返回键值对的个数
    NSLog(@"%ld",dict4.count);
}

五、NSNumber和NSValue

int main(int argc, const char * argv[])
{
    //NSNumber之因此能包装基本数据类型为对象，是由于集成了NSValue
    
    NSNumber *num = [NSNumber numberWithInt:10];
    NSDictionary *dict=
    @{
      @"name":@"jack",
      @"age":num,
    
    };
    
    NSNumber *num2 = dict[@"age"];
    int nNum = [num2 intValue];
    
    NSLog(@"%d",nNum);
    
    //@20将20包装成一个NSNumber对象
    NSDictionary *dict2=
    @{
      @"name":@"jack",
      @"age":@20,
      };
    
    int age = 10;
    NSNumber *ageNum= @(age);
    
    //将结构体包装成OC对象，使用NSValue。
    
    CGPoint p = CGPointMake(10, 10);
    NSValue *pValue = [NSValue valueWithPoint:p];
    
    NSArray *array =@[pValue];
    //将value转换成对应的结构体
    NSPoint newPoint = [pValue pointValue];
    
    return 0;
}

六、日期

int main(int argc, const char * argv[])
{
    //建立一个时间对象
    NSDate *date = [NSDate date];
    
    NSLog(@"%@",date);
    
    //oc的时间都为秒
    NSDate *date2 = [NSDate dateWithTimeInterval:5 sinceDate:date];
    
    //从1970年开始走过的秒数
    NSTimeInterval secondsFrom1970 = [date2 timeIntervalSince1970];
    
    
    //日期格式化类
    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    // y 年 M 月 d 日
    // m 分 s 秒 H（24小时） h(12小时)
    formatter.dateFormat = @"yyyy-MM-dd HH:mm:ss";
    NSString *str = [formatter stringFromDate:date];
    
    NSLog(@"%@",str);
    
    
    //字符串，转换成NSDate
    NSString *str2 = @"2011/09/10 18:56";
    NSDateFormatter *formatter2 = [[NSDateFormatter alloc] init];
    formatter2.dateFormat = @"yyyy/MM/dd HH:mm";
    NSDate *date3 = [formatter2 dateFromString:str2];
    
    return 0;
}

七、Copy

@interface Person : NSObject <NSCopying>

//copy表明set方法会release旧对象、copy新对象
//修改外面的变量，并不会影响到内部的成员变量
//建议：NSString通常用copy策略，其余对象通常用retain

@property (nonatomic,copy) NSString *name;

+ (id) personWithName:(NSString *)name;

@end



#import "Person.h"

@implementation Person

+ (id) personWithName:(NSString *)name
{
    Person *person = [[[self class] alloc] init];
    person.name = name;
    return person;
}
- (id)copyWithZone:(NSZone *)zone
{
    //这里建立的copy对象不要求释放
    Person *copy = [[[self class] allocWithZone:zone] init];
    copy.name = self.name;
    return copy;
}
@end

8.反射

NSString *str = @"Person";
Class class = NSClassFromString(str);
Person *person = [[Class alloc] init];
NSLog(@"%@",person);

NSString *name = NSStringFromClass([Person class]);

//方法反射
NSString *method = @"test";
SEL selector = NSSelectorFromString(method);
[person performSelector:selector];