自己学习中总结的 比较零散,见谅
1 。错误问题
1. // error:instance variable 'age' accessed in class method
// 实例变量age不能在类方法中访问
2. //-[Person test]: unrecognized selector sent to instance 0x7fd2ea4097c0
//给Person对象发送了一个不能识别的消息:test
3.//-[Person printClassName]: unrecognized selector sent to instance 0x7fa520c0b370
// 系统会认为现在调用的printClassName是个对象方法
//[p printClassName];
4.//EXC_BAD_ACCESS : 访问了一块坏的内存(已经被回收、已经不可用的内存
5.//-[Person setAge:]: message sent to deallocated instance 0x100109a10 给已经释放的对象发送了一条-setAge:消息:
@:在OC语言中可以代表对象的格式占位符号
self:指向了方向调用者,代表着当前对象
//判断stu是不是Student这个类的实例
BOOL b =[stu isKindOfClass:[Student class]];
//枚举遍历,快速遍历出value值
NSDictionary *dictionary = [[NSDictionary alloc]initWithObjectsAndKeys: @25,@"number",
@23.4,@"numberfloat",
@YES,@"bool",
@"a",@"ocstring",
@'a',@"oString",
nil];
NSEnumerator *enu = [dictionary objectEnumerator];
id obj;
while (obj = [enu nextObject]) {
NSLog(@"%@",obj);
}
//字符串常量,存在只读数据区
char *c = "helloworld";
//字符数组,字符串常量需要在运行时拷贝到数组中
char ch[] = "helloworld";
voaltile说明符和const 正好相反,明确告诉编译器,指定类型变量的值会改变。(I/O端口) 比如要将输出端口的地址存储在 outPort 的变量中。
volatile char *outPort;
*outPort = 'O';
*outPort = 'N';
这样就可以避免编译器将第一个赋值语句从程序中删除
创建的类对象包含了指向超类的指针、 类名和指向类方法的列表的指针。 类对象还包含一个long 的数据, 为新创建的类对象指定大小。
//逐个字符比较 不区分大小写的比较. 注意:NSComparisonResult 是一个枚举值
-(NSComparisonResult)compare :(NSString *)string;
-(NSComparisonResult)compare :(NSString *)string options:(unsigned)mask;
//将字符串切分成数据
使用 componentsSeparatedByString : 来切分 NSArray,
NSString *string = @"oop : ack : bork : greeble : ponies" ;
NSArray *chunks = [string componentsSeparatedByString : @":"];
//将数组合并成字符串
使用 componentsJoinedByString : 来合并 NSArray 中的元素并创建字符串 string = [chunks componentsJoinedByString :@":-)"] ;
//typedef可以嵌套定义
typedef int Integer;
Integer i = -10;
typedef Integer MyInteger;
char names[2][10] = {"jack","rose"};
char *names[2] = {"jack","rose"};
//类方法中不能访问成员变量(实例变量)
//使用场合:当方法内部不需要使用到成员变量时,就可以改为类方法
//可以允许类方法和对象方法同名
//()取值
int age = 19;
@(age);//age为nsnumber
@28;
@23.3;//把double型转为double对象
@YES;
@"a"; //字符串 对象
@'a'; //char类型的对象
//完整地写一个类:类的声明和实现
[行为执行者 行为名称]
[类名 new];//创建一个新对象
//int a = (int)1.22
Animal *aa =[Dog new];
Dog *dd = (Dog *)aa ; //Dog *dd = aa //编译器警告
//c语言字符串和oc字符串互转
NSString *s = [NSString stringWithUTF8String:"chen"];
const char *c = [s UTF8String];
self的用途:
1> 谁调用了当前方法,self就代表谁
* self出现在对象方法中,self就代表对象
* self出现在类方法中,self就代表类
2> 在对象方法利用"self->成员变量名"访问当前对象内部的成员变量
3> [self 方法名]可以调用其他对象方法\类方法//???
A//方法是描述类的行为
{
int _age;//成员变量---->的作用是描述类的状态
int _no;
}
B : A
{
int _weight;
}
// 继承:xx 是 xxx
// 组合:xxx 拥有 xxx
2.组合
A
{
int _age;
int _no;
}
B
{
A *_a;
int _weight;
}
super的作用:
1.直接调用父类中的某个方法
2.super处在对象方法中,那么就会调用父类的对象方法
super处在类方法中,那么就会调用父类的类方法
3.使用场合:子类重写父类的方法时想保留父类的一些行为
多态:
1.没有继承就没有多态
2.代码的体现:父类类型的指针指向子类对象
3.好处:如果函数\方法参数中使用的是父类类型,可以传入父类、子类对象
4.局限性:
1> 父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后,才能直接调用子类特有的方法
重写-init方法
- (id)init
{
// 1.一定要调用回super的init方法:初始化父类中声明的一些成员变量和其他属性
self = [super init]; //self 当前对象
// 2.如果对象初始化成功,才有必要进行接下来的初始化
if (self != nil)
{ // 初始化成功
_age = 10;
}
// 3.返回一个已经初始化完毕的对象
return self;
}
// 父类的属性交给父类方法去处理,子类方法处理子类自己的属性
- (id)initWithName:(NSString *)name andAge:(int)age andNo:(int)no
{
// 将name、age传递到父类方法中进行初始化
if ( self = [super initWithName:name andAge:age])
{
_no = no;
}
return self;
}
@property int age ;
//- (void)setAge:(int)age ;
//- (int)age;
@synthesize age = _age;
id == NSObject *
// 万能指针,能指向/操作任何oc对象
id类型的定义
typedef struct objc object{
class isa;
}*id;
/*
分类的作用:在不改变原来类内容的基础上,可以为类增加一些方法
使用注意:
1.分类只能增加方法,不能增加成员变量
2.分类方法实现中可以访问原来类中声明的成员变量
3.分类可以重新实现原来类中的方法,但是会覆盖掉原来的方法,会导致原来的方法没法再使用
4.方法调用的优先级:分类(最后参与编译的分类优先) --> 原来类 --> 父类
*/
// 取出i这个位置对应的字符
unichar c = [self characterAtIndex:i];
/*
1.当程序启动时,就会加载项目中所有的类和分类,而且加载后会调用每个类和分类的+load方法。只会调用一次。
2.当第一次使用某个类时,就会调用当前类的+initialize方法
3.先加载父类,再加载子类(先调用父类的+load方法,再调用子类的+load方法)
先初始化父类,再初始化子类(先调用父类的+initialize方法,再调用子类的+initialize方法)
*/
/*
SEL其实是对方法的一种包装,将方法包装成一个SEL类型的数据,去找对应的方法地址。找到方法地址就可以调用方法
SEL:全称selector 表示方法的存储位置
其实消息就是SEL
*/
重写description的类方法//实现打印对象的所有属性,默认打印<类名 :内存地址>
+ (NSString *)description
{
return [NSString stringWithFormat:@"age=%@,name=%@",_age,_name];
}
调用方法
[p test];
[p performSeletor :@selector(test)];
[p performSeletor :@selector(test:) withBbject:@"123"];//test后面有:
sel s =@selector(test:);//定义一个sel的数据
NSString *name = @"test2";
SEL s = NSSelectorFromString(name);
[p performSelector:s];
- (void)test2
{
_cmd == @selector(test2);//_cmd调表当前方法
NSString *str=NSStringFromSelector(_cmd);
nslog(@"调用了test2方法--%@",str);
}
---》输出结果 :调用了test2方法--test2
//分类引入
#import "NSObject+ClassName.h"
//分类声明
@interface NSObject (ClassName)
@end
//分类方法实现
@implementation NSObject (className)
- (void)outPutClassName
{
NSLog(@"%@",self);//self代表调用方法的对象
}
+ (void)outPutClassName
{
NSLog(@"%@",[self class]);//调用class方法生成类
}
@end
/*
1.方法的基本使用
1> retain :计数器+1,会返回对象本身
2> release :计数器-1,没有返回值
3> retainCount :获取当前的计数器
4> dealloc
* 当一个对象要被回收的时候,就会调用
* 一定要调用[super dealloc],这句调用要放在最后面
2.概念
1> 僵尸对象 :所占用内存已经被回收的对象,僵尸对象不能再使用
2> 野指针 :指向僵尸对象(不可用内存)的指针,给野指针发送消息会报错(EXC_BAD_ACCESS)
3> 空指针 :没有指向任何东西的指针(存储的东西是nil、NULL、0),给空指针发送消息不会报错
*/
1.你想使用(占用)某个对象,就应该让对象的计数器+1(让对象做一次retain操作)
2.你不想再使用(占用)某个对象,就应该让对象的计数器-1(让对象做一次release)
3.谁retain,谁release
4.谁alloc,谁release
/*
_speed :直接访问成员变量
self->_speed :直接访问成员变量
self.speed : get方法
[self speed] : get方法
*/
_book = [book retain];//person中的setBook
- (void)dealloc//person中的dealloc
{
[_book release];
NSLog(@"person被回收");
[super dealloc];
}
内存管理代码规范:
1.只要调用了alloc,必须有release(autorelease)
对象不是通过alloc产生的,就不需要release
2.set方法的代码规范
1> 基本数据类型:直接复制
- (void)setAge:(int)age
{
_age = age;
}
2> OC对象类型
- (void)setCar:(Car *)car
{
// 1.先判断是不是新传进来对象
if ( car != _car )
{
// 2.对旧对象做一次release
[_car release];
// 3.对新对象做一次retain
_car = [car retain];
}
}
3.dealloc方法的代码规范
1> 一定要[super dealloc],而且放到最后面
2> 对self(当前)所拥有的其他对象做一次release
- (void)dealloc
{
[_car release];
[super dealloc];
}
// retain : 生成的set方法里面,release旧值,retain新值
@property (retain) Book *book;
/*
1.set方法内存管理相关的参数
* retain : release旧值,retain新值(适用于OC对象类型)
* assign : 直接赋值(默认,适用于非OC对象类型)
* copy : release旧值,copy新值
2.是否要生成set方法
* readwrite : 同时生成setter和getter的声明、实现(默认)
* readonly : 只会生成getter的声明、实现
3.多线程管理
* nonatomic : 性能高 (一般就用这个)
* atomic : 性能低(默认)
4.setter和getter方法的名称
* setter : 决定了set方法的名称,一定要有个冒号 :
* getter : 决定了get方法的名称(一般用在BOOL类型)
* @property (getter = isRich) BOOL rich;//设值bool值
*/
1.@class的作用:仅仅告诉编译器,某个名称是一个类
@class Person; //仅仅告诉编译器,Person是一个类
2.开发中引用一个类的规范
1> 在.h文件中用@class来声明类
2> 在.m文件中用#import来包含类的所有东西
3.两端循环引用解决方案
1> 一端用retain
2> 一端用assign
/*
1.autorelease的基本用法
1> 会将对象放到一个自动释放池中
2> 当自动释放池被销毁时,会对池子里面的所有对象做一次release操作
3> 会返回对象本身
4> 调用完autorelease方法后,对象的计数器不变
2.autorelease的好处
1> 不用再关心对象释放的时间
2> 不用再关心什么时候调用release
3.autorelease的使用注意
1> 占用内存较大的对象不要随便使用autorelease
2> 占用内存较小的对象使用autorelease,没有太大影响
4.错误写法
1> alloc之后调用了autorelease,又调用release
2> 连续调用多次autorelease
5.自动释放池
1> 在iOS程序运行过程中,会创建无数个池子。这些池子都是以栈结构存在(先进后出)
2> 当一个对象调用autorelease方法时,会将这个对象放到栈顶的释放池
6.自动释放池的创建方式
1> iOS 5.0前
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
[pool release]; // [pool drain];
2> iOS 5.0 开始
@autoreleasepool
{
}
*/
1.系统自带的方法里面没有包含alloc、new、copy,说明返回的对象都是autorelease的
2.开发中经常会提供一些类方法,快速创建一个已经autorelease过的对象
1> 创建对象时不要直接用类名,一般用self
+ (id)person
{
return [[[self alloc] init] autorelease];
}
/*
ARC的判断准则:只要没有强指针指向对象,就会释放对象
1.ARC特点
1> 不允许调用release、retain、retainCount
2> 允许重写dealloc,但是不允许调用[super dealloc]
3> @property的参数
* strong(retain) :成员变量是强指针(适用于OC对象类型)
* weak :成员变量是弱指针(适用于OC对象类型)
* assign : 适用于非OC对象类型
* copy : release旧值,copy新值
4> 以前的retain改为用strong
指针分2种:
1> 强指针:默认情况下,所有的指针都是强指针 __strong
2> 弱指针:__weak
分别在两个文件的.h文件中写@class Dog; @class Person;
当两端循环引用的时候,解决方案:
1> ARC
1端用strong,另1端用weak
2> 非ARC
1端用retain,另1端用assign
*/
block要掌握的东西
1> 如何定义block变量
int (^sumBlock)(int, int);
void (^myBlock)();
2> 如何利用block封装代码
^(int a, int b) {
return a - b;
};
^() {
NSLog(@"----------");
};
^ {
NSLog(@"----------");
};
3> block访问外面变量
* block内部可以访问外面的变量
* 默认情况下,block内部不能修改外面的局部变量
* 给局部变量加上__block关键字,这个局部变量就可以在block内部修改
4> 利用typedef定义block类型
typedef int (^MyBlock)(int, int);
// 以后就可以利用MyBlock这种类型来定义block变量
MyBlock block;
MyBlock b1, b2;
b1 = ^(int a, int b) {
return a - b;
};
// 给局部变量加上__block关键字,这个局部变量就可以在block内部修改
// block用来保存一段代码
// block的标志:^
/*
block跟函数很像:
1.可以保存代码
2.有返回值
3.有形参
4.调用方式一样
*/
定义block变量
/*
void (^myblock)() = ^(){
NSLog(@"----------------");
NSLog(@"----------------");
};*/
/*
1.协议的定义
@protocol 协议名称 <NSObject>
// 方法声明列表....
@end
2.如何遵守协议
1> 类遵守协议
@interface 类名 : 父类名 <协议名称1, 协议名称2>
@end
2> 协议遵守协议
@protocol 协议名称 <其他协议名称1, 其他协议名称2>
@end
3.协议中方法声明的关键字
1> @required (默认)
要求实现,如果没有实现,会发出警告
2> @optional
不要求实现,怎样不会有警告
4.定义一个变量的时候,限制这个变量保存的对象遵守某个协议
类名<协议名称> *变量名;
id<协议名称> 变量名;
NSObject<MyProtocol> *obj;
id<MyProtocol> obj2;
如果没有遵守对应的协议,编译器会警告
5.@property中声明的属性也可用做一个遵守协议的限制
@property (nonatomic, strong) 类名<协议名称> *属性名;
@property (nonatomic, strong) id<协议名称> 属性名;
@property (nonatomic, strong) Dog<MyProtocol> *dog;
@property (nonatomic, strong) id<MyProtocol> dog2;
6.协议可用定义在单独.h文件中,也可用定义在某个类中
1> 如果这个协议只用在某个类中,应该把协议定义在该类中
2> 如果这个协议用在很多类中,就应该定义在单独文件中
7.分类可用定义在单独.h和.m文件中,也可用定义在原来类中
1> 一般情况下,都是定义在单独文件
2> 定义在原来类中的分类,只要求能看懂语法
*/
NSRange(location length)
NSPoint\CGPoint
NSSize\CGSize
NSRect\CGRect (CGPint CGSize)
// 使用这些CGPointEqualToPoint、CGRectContainsPoint等函数的前提是添加CoreGraphics框架
typedef struct _QFposition{
int row,
int column
};
_QFposition _postion;//定义
NSRange r1 = {2,3};
NSRange r2 = {.location = 2,.length = 2};
NSRange r3 = NSMakeRange(2, 4);
CGPoint p1 = NSMakePoint(12, 14);
NSPoint p2 = CGPointMake(12, 14);
NSSize s1= CGSizeMake(-1, -1);
NSSize s2 = NSMakeSize(2, 4);
CGSize s3 = NSMakeSize(2, 3);
CGSize s4 = CGSizeMake(2, 3);
CGRect r1= CGRectMake(0, 0, 2, 3);
CGRect r2 ={{0,0},{100,23}};
CGRect r3 = {p1,s2};
// 使用CGPointZero等的前提是添加CoreGraphics框架
CGRect r4 = {CGPointZero,s2};
BOOL b2 = CGRectContainsPoint(CGRectMake(50, 40, 100, 50), CGPointMake(60, 45));
[array enumerateObjectsUsingBlock:
// 每遍历到一个元素,就会调用一次block
// 并且当前元素和索引位置当做参数传给block
^(id obj, NSUInteger idx, BOOL *stop)
{
NSLog(@"%ld - %@", idx, obj);
if (idx == 0)
{
*stop = YES;// 停止遍历
}
}
];
/*
NSSet和NSArray的对比
1> 共同点
* 都是集合,都能存放多个OC对象
* 只能存放OC对象,不能存放非OC对象类型(基本数据类型:int、char、float等,结构体,枚举)
* 本身都不可变,都有一个可变的子类
2> 不同点
* NSArray有顺序,NSSet没有顺序
NSString *str1 = [s2 anyObject];//随机拿出一个元素
*/
集合
1.NSArray\NSMutableArray
* 有序
* 快速创建(不可变):@[obj1, obj2, obj3]
* 快速访问元素:数组名[i]
2.NSSet\NSMutableSet
* 无序
3.NSDictionary\NSMutableDictionary
* 无序
* 快速创建(不可变):@{key1 : value1, key2 : value2}
* 快速访问元素:字典名[key]
/*
字典:
key ----> value
索引 ----> 文字内容
里面存储的东西都是键值对
*/
// @20 将 20包装成一个NSNumber对像
// 将age变量包装成NSNumber对象
int age = 100;
@(age);
//[NSNumber numberWithInt:age];
// 结构体--->OC对象
CGPoint p = CGPointMake(10, 10);
// 将结构体转为Value对象
NSValue *value = [NSValue valueWithPoint:p];
// 将value转为对应的结构体
// [value pointValue];
NSArray *array = @[value ]
[ i stringVilue];
点语法,@property 和@synthesize 是成对出现的
//@property 是声明set和get方法
//@synthesize 是实现set和get方法
//把一个结构体转化为对象 NSvalue 存储到NSarray中
typedef struct Person
{
int age,
float height
}Person;
Person zhangshang = {18,1.77};
//作用:把c的类型的数据转化为NSvalve类型
//参数1 :数组的地址
//参数2 :数组的类型
//@encode作用是把类型转化为字符串
NSValue *value =[ [NSValue alloc]initWithBytes:&zhangshang objCType:@encode(Person)];
NSMutableArray *marr = [[NSMutableArray alloc]init];
[marr addObject:value];
Person newperson;
//从nsvalue转换出存储的数据
[value getValue:&newperson];
NSLog(@"%d---%f",newperson.age,newperson.height);
}
//copy把传入的字符串拷贝一份新的(字符串,字典,数组)
@property (copy) NSString *type;
//assign表示直接赋值,不retain也不copy(默认)
@property (assign) float price;
//retain表示实现的setter和getter中添加retain
@property (retain)Engine *engine;
//代理的属性修饰符必须是assgin。不能是retain,否则会引起无法释放的问题
@property (assign) id delegate;
//类中对象指针一般在init中申请对象,在dealloc中释放对象
NSMutableString *name = [[NSMutableString alloc]initWithString:@"ling er"];
//问题 ---->两个指针,只有一个对象
//copy返回不可变对象, ,mutablestring返回可变对象
NSMutableString *pName = [name mutableCopy];
name.string = @"er ling";
NSLog(@"pName = %@",pName);
//类方法创建的字符串对象,无需释放,自动释放。通过alloc创建的字符串对象需要release
//对象加入到数组中
//数组会对持有之中对象,数组会给每个加入他得对象发送retain消息
NSString *strw = @"2323";
NSLog(@"%lu",strw.retainCount);//18446744073709551615
NSString *st = [[NSString alloc]initWithString:strw];//18446744073709551615
NSLog(@"%lu",st.retainCount);
NSString *st1 = [[NSString alloc]initWithFormat:@"%@",strw];
NSLog(@"%lu",st1.retainCount);//1
//以alloc创建的字符串最后使用release释放
//以类方法和字符串常量创建的字符串不需要释放
NSString *str1 = [[NSString alloc]initWithUTF8String:"123"];
NSLog(@"'1 = %lu",str1.retainCount);//1
NSString *str2 = [[NSString alloc]initWithString:@"2345"];
NSLog(@"2 = %lu",str2.retainCount);//18446744073709551615
//如何利用协议实现不同对象的排序(c语言:冒泡,快排,选择)
//oc中nsarray用sortUseingSelector
[marr sortUsingSelector:@selector(myCompare:)];
for (id obj in marr) {
[obj showMe];
}
//类别/分类(category)---->给某个类添加方法
@interface NSMutableString (Extension)
- (void)reverserString;
@end
@implementation NSMutableString (Extension)
- (void)reverserString
{}//增加单词逆转功能
@end
//协议(protocol)---->强制性让某个对象拥有某方法
@protocol MyProtocol <NSObject>
- (void)sayHello;
@end
//遵守一个协议(先引入,后在类的后天添加,可以不声明协议的方法,但必须实现)
#import "MyProtocol.h"
@interface Test : NSObject <MyProtocol>
- (void)show;
@end
//一般,哪个对象给其他对象发送消息,这个对象指定协议(规范:xxxxDelegate)
995



被折叠的 条评论
为什么被折叠?



