黑马程序员技术交流社区
标题: 指针的艺术 [打印本页]
作者: l_15562009298 时间: 2015-8-30 11:59
标题: 指针的艺术
大家谈谈指针的深刻见解
作者: l_15562009298 时间: 2015-8-30 12:00
import和class关键字的区别
1.import方式会包含被引用类的所有信息，包括被引用类的成员变量和方法
2.class方式知识告诉编译器在当前这个文件中有另一个类的声明，
具体这个类有什么信息，这里不需要知道，
等到实现文件中真正要用到时再去查看另一个类中的信息
3.class可以解决两个类循环引用的问题
作者: l_15562009298 时间: 2015-8-30 12:01
OC中的注释
1.单行注释 ：//
2.多行注释：/* */
3.方法的注释：＃pragma mark 解释（这中方式可以快速定位到方法，但是第一个方法到注释不会出现）
4.用注释给方法分组：＃pragma mark － 解释
作者: l_15562009298 时间: 2015-8-30 12:03
本帖最后由 l_15562009298 于 2015-8-30 12:05 编辑
OC中的构造方法和description方法，变量的作用域，
1.构造方法的声明和实现
[url=]
[/url]
//声明－ (id) initWithAge:(int) age andNo: (int) no;//实现－ (id) initWithAge:(int) age andNo: (int) no{
self=[super init];//调用父类的init方法初始化
//判断对象是否为空 也可以直接写if(self) 或 if(self=[super init])
if(self!=nil) {
_age=age; _no=no;
} return self; }
//调用
Student *stu=[[Student alloc] initWithAge:20 andNo:1][url=][/url]
2.description方法相当于java中的toString方法，用来打印对象的，一般都是重写的
- (void) description{ NSLog();}
只要类重写了这个方法用@打印对象时，就会自动调用这个方法。
3.oc中变量的作用域有：
@public 公共的，没有访问权限，
@private：私有的，仅当前类可以访问，
@protected：受保护的，仅当前类和其子类可以访问
oc中默认的访问权限是@protected
作者: l_15562009298 时间: 2015-8-30 12:06
@property关键字的使用
1.作用：@property是用来快速生成属性和属性的getter，setter方法的
2.用法1.当类有声明属性时，可以用@property 生成属性的get，set方法
[url=][/url]
@interface Student{int age;}@end//该句就相当于原始的get，set方法@property int age;[url=][/url]
此时类的实现中实现get，set方法就得使用@syhthesize关键字
@implementation Studen//代表了getset 方法的实现，@syhthesize age;@end
此处注意：关键字@systhesize会默认访问其后的成员变量
当@systhesize后面的成员变量在类中没有声明的时候，他会自动在类的实现中生成一个私有的成员量，名称和systhesize后面的成员变量一致
3.一般在声明成员变量时以下划线开头，但是systhesize生成的getset方法中是去访问他后面的成员变量，但是我们又不能把其后的变量名称加上下划线，
因为加上下划线，方法名就变成set _成员名了，所以我们用
@systhesize 数据类型 变量名1＝变量名2
这样生产的方法名称就是变量名1，访问的成员变量就是变量名2，如果类没有声明成员变量名为变量2的，编译器也会自动生成一个私有的成员变量
4.但是在Xcode4.5以上就不再使用以上的方式了，property关键字就能完成成员变量和get，set方法的声明和实现了，而且生成对成员变量默认以
下划线开头的
@interface Student @property int age;@end
5.只要没有手动编写get和set方法时，编译器默认会生成@systhesize关键字的，仅仅写了其中的一个，编译器也会生成另外的一个方法的
6.property的参数，atomic：代表给方法进行加锁，保证线程安全，是一种线程保护技术，防止写入未完成时，被另一个线程操作，
导致数据不完整nonatomic不会自动加锁，这样效率还是比较高的
作者: l_15562009298 时间: 2015-8-30 12:08
oc中的点语法讲解
1.类的属性都有对应的getter和setter方法，
我们可以通过 ［对象 setXxx:22］／［对象 xxx］方式调用setter方法和getter方法
但是也可以用 对象.Xxx＝22 ／int a＝对象.xxx
这种方式编译器会自动帮我们判断是要get还是set，
当用这个点语法的时候，对象访问的并不是属性，而是去调用了get或set方法
作者: l_15562009298 时间: 2015-8-30 12:09
黑马程序员－－oc基础－－分类 category
1.声明和实现
[url=][/url]
@interface 主类名称 （分类名称）// 声明一些方法@end@implementation 主类名称 （分类名称）// 实现一些方法@end[url=][/url]
2.分类若失单独的文件，那么文件多名称格式 ： 主类名＋分类名.h eg, NSString+test.h
3.作用：可以动态的为已经实现了的类扩展新的方法
4.好处：保证类的原始设计规模较小，功能增加时再逐步扩展，实现了类的相关方法的模块化
使用category对类进行扩展时，不需要创建子类
方便团队开发
5.注意：分类文件中不能使用@class关键字导入相关的类文件，因为在分类中是要新增方法的，那么得判断原始类中已经存在的类
分类只能扩展方法，不能扩展成员变量
分类可以在任何地方声明和实现
作者: l_15562009298 时间: 2015-8-30 12:10
黑马程序员－－oc基础－－oc字符串的使用
创建一个字符串对象
NSstring * str1 = @"hello";
NSString * str = [[NSString alloc]initWithString:@"hello world!"];
NSString * str_1 = [[NSString alloc]initWithUTF8String:"hello world"];//把C的字符串转化为OC的字符串
int a = 123;
NSString * str_3 = [[NSString alloc]initWithFormat:@"a = %d %s%@", a, "abcd", @"efg"];//用格式化字符串初始化
//可完成字符串的拼接以及完成C的字符串与OC的字符串的转化
NSString * str1 = [NSString stringWithString:@"hello world"];
NSString * str2 = [NSString stringWithUTF8String:"hello world"];
NSString * str3 = [NSString stringWithFormat:@"%s","hello world"];
字符串转化
NSString * str = @"hello";
const char *p = [str UTF8String];将OC字符串转化为C的字符串
str = @"123";
int a = [str intValue];//将数字串转化成整型数据
[str floatValue];//将数字串转化成float型
[str doubleValue];//将数字串转化成double型
常用的NSString Message(OC 的字符 :typedef unsigned short unichar)
NSLog(@"%ld",[str1 length]); //求字符串长度
NSLog(@"%c", [str1 characterAtIndex:1]);//获取字符串中的字符
BOOL ret = [str1 isEqualTo:str2];//比较两个字符串是否相等,相等返回YES(1),不相等返回NO(0) (BOOL YES(1) NO(0))
long ret1 = [str1 compare:str2];//比较两个字符串的大小,str1大于 返回1 相等返回0 小于返回-1
long ret2 = [str1 caseInsensitiveCompare:str2];//不区分大小写比较字符串大小
NSString * ptr = [str2 uppercaseString];//将字符串中的所有小写字符转换成大写 不改变原来的字符串
ptr = [str1 lowercaseString];//将字符串中的所有大写字符转换成小写 不改变原来的字符串
ptr = [str3 capitalizedString];//将字符串中出现的第一个字母转换成大写，其余字母小写
NSString * str4 = @"hello world";
NSRange range = [str4 rangeOfString:@"wr"];//查找子串，找不到返回NSNotFound 找到返回location和length
if (range.location != NSNotFound) {
NSLog(@"%ld %ld",range.location, range.length);
}
NSString * str5 = @"helloworld";
NSString * ptr1 = [str5 substringToIndex:4];//字符串抽取 从下标0开始到4 不包括4
NSString * ptr2 = [str5 substringFromIndex:5];//从下标5开始抽取到字符串结束 包括5
NSRange range1 = {4,3};//结构体初始化
NSString * ptr3 = [str5 substringWithRange:range1];//在range指定范围内抽取
NSString * ptr4 = [str5 substringWithRange:NSMakeRange(4,3)];//NSMakeRange可以生成一个结构体
NSString * str = @"www.1000phone.com";
BOOL ret = [str hasPrefix:@"www"];//判断字符串是否以指定字符串开头
NSString * str1 = @"1.txt";
BOOL ret1 = [str hasSuffix:@".txt"];//判断字符串是否以指定的字符串结尾
NSMutableString可变字符串(动态增加和减少的) 继承于NSString可以使用NSString的所有方法
NSMutableString * str = [[NSMutableString alloc]initWithString:@"hello"];//将不可变的字符串转换为可变的字符串
[str insertString:@"123" atIndex:1];//在指定下标(不要越界)位置插入NSString类型字符串
[str appendString:@"123"];//在字符串末尾追加字符串
[str deleteCharactersInRange:NSMakeRange(0, 2)];//从指定下标删除length个字符
[str setString:@"qianfeng"];//修改字符串亦称对该可变字符串赋值
[str replaceCharactersInRange:NSMakeRange(3, 1) withString:@"ios"];//将指定下标位置的length个字符替换为指定的字符串
作者: l_15562009298 时间: 2015-8-30 12:12
黑马程序员－－c基础－－强处理指令
1.强处理指令：是在程序编译前执行的命令
2.强处理指令包括：宏定义（或带参数的宏定义），条件编译，文件包含
a.宏定义：
作用：将define关键字后的表达式替换成第二个表达式,不参与任何计算，只负责替换
定义：#define 表达式 值 （所有的宏定义都以＃开头）
作用域：默认从定义开始到文件结尾，除非有＃undef
b.带参数的宏定义：
定义：＃define 函数((参数1)(参数2)) （表达式）
注意：参数和表达式都尽量用（），避免因为计算顺序导致结果出错
eg.直接将sum（1，2）替换成 （1+2）
[url=][/url]
#include <stdio.h>#define sum((a),(b)) ((a)+(b))//宏定义两个数的和int main(){ printf("1和2的和是：%d\n",sum(1,2)); return 0;}[url=][/url]
c.条件编译
作用：用于判断代码是否将要执行编译
定义：注意＃if 和＃endif是固定搭配
＃if（条件1）｛｝＃elif（条件2）｛｝＃else｛｝＃endif
d.文件包含
定义；＃include "自定义文件"
作用：会把引用的文件的内容拷贝到当前文件中
注意：include 是不可循环包含的,即a.c中包含b.h,但是b.c中不能包含a.h
[url=][/url]
#include <stdio.h>#include "string.h"int main(){ return 0;}[url=][/url]
作者: l_15562009298 时间: 2015-8-30 12:13
黑马程序员－－c基础－－指针
1.指针的定义： 数据类型 *指针变量名
2.指针的赋值：指针变量名＝&... 或者 指针变量名 ＝数组名
注意：定义的时候 * 仅代表这是在定义一个指针变量，没有其他的意义
eg.
[url=][/url]
int main(){ int *p;//定义指针变量 int a=10; p=&a;//给指针变量赋值，给的是变量a的地址符 printf("%d",*p);//获取指针变量的值 }[url=][/url]
3.指针操作数组时，因为数组是属于引用类型的，所以将数组名直接赋值给指针，就相当于把数组的地址给了指针
eg .
[url=][/url]
int main(){ char *p;//定义指针变量 char arr[]={'a','b','c','\0'}; p=arr;//给指针变量赋值 也可以 p ＝arr[0] //利用指针访问数组 printf("%c",*(p+1)); //代表获取数组从0+1位置点元素 printf("%c",*p); //访问的是数组的第0个元素 return 0;}[url=][/url]
4.指针指向函数
定义要指向函数的指针： 函数的返回值 （＊指针变量名）（参数类型，...）
给指针变量赋值：指针变量名＝函数名称
调用指针（相当于调用函数）：指针变量名（参数值，...）或者（＊指针变量名）（参数值,...）
作用：这个指针就是用来间接调用函数的
eg.
[url=][/url]
#include <stdio.h>//声明函数int test(int,int);int main(){ //定义指向函数的指针 int (*p)(int,int); //给指针赋值 p=test; //利用指针调用函数,并接受返回值 int sum= p(1,2); int sum2= (*p)(10,20); //输出 printf("sum=%d,sum2=%d",sum,sum2); return 0;}//定义函数int test(int a,int b){ return a+b;}[url=][/url]
5.返回指针的函数
定义函数：返回值类型 *函数名（）｛｝
[url=][/url]
#include <stdio.h>//声明函数char *test();int main(){ //调用指针函数 char *result=test(); //输出 printf("%s",result); return 0;}//定义函数char *test(){ return "abc";}[url=][/url]
6.指向指针的指针
定义：数据类型 **指针变量名
赋值：指针变量名＝&变量
[url=][/url]
int main(){ int a=10; //定义指针，指向a int *p=&a; //定义指向指针的指针 int **p2; //给p2赋值 p2=&p; //利用指针指向a改变a的值 *p=20; printf("p改变：a=%d\n",a); //利用指向指针的指针改变a的值 *(*p2)=30; //*p2 就代表指向指针p ，然后再加上 * 就相当于利用指针p去访问a printf("p2改变：a=%d",a); return 0;}[url=][/url]
作者: l_15562009298 时间: 2015-8-30 12:14
黑马程序员－－c基础－－运算符
运算符分为：关系运算符，算术运算符，逻辑运算符，三目运算符
1.关系运算符：>,>=,<',<=,==,!=
2.优先级：>,>=,<',<= 优先级高于 ==,!=
eg：2=3>1 结果是0，相当于2=1，先计算3>1
4>3>2 结果是0 ，相当于1>2，先计算4>3
2.计算顺序：
不同级运算：由优先级高到优先级低。
同级运算：从做到右，依次计算
2.算术运算符：+，-，*，/
1.计算顺序：先乘除后加减
3.逻辑运算符：&&，|| ，！
&&：逻辑与，只要左边的表达式不成立，那么就不计算右边的表达式
|| ：逻辑或，只要左边的成立，那么就不计算右边的表达式
！：逻辑非，将表达式结果取反
4.关系运算符，算术运算符，逻辑运算符优先级关系：算术运算符 > 关系运算符 > 逻辑运算符
注：逻辑非的优先级高于算术运算符 ， 关系运算符 ，和其它逻辑运算符
5.三目运算符
格式：变量=表达式2 > 表达式3 ？值1：值2
解析：如果表达式2 > 表达式3 成了，那么就将 ：左边的值赋给变量，否则将 ： 右边的赋值给变量
6.在有（）的情况下，都是先计算（）里面的表达式
作者: l_15562009298 时间: 2015-8-30 12:16
黑马程序员－－c 基础 －－位的一些计算
1.十进制转二进制：67=2的6次方 + 2 + 1，即1+000000+1*2的1次方 + 1*2的0次方 =100000011
2.n位二进制的取值范围：0 ~2的n次方 -1 eg 101,：110,011,
3.二级制之间的一些计算：
a.按位与 “&”
规则：两个二进制位都是1，那么就给是1，否则结果是0
作用：可以精确的判对比二进制位，只和1作对比就可以了，可以判断奇偶性（x位与1结果为1，那么x是奇数，结果为0，x是偶数）
eg. 00101
10100
---------------------
00100
b.按位或 “|”
规则：两个二进制位只要有一个是1，那么结果就是1
eg. 00101 | 10100 结果是：10101
c.按位异或 “^”
规则： 两个二进制位不相同，结果为1，否则结果是0
结论：相同的两个是异或，结果为0
异或可以交换 9^5^6=9^6^5
任何数值跟0异或，结果还是原来的数，9^0=9
综合应用：a ^ b ^ a=b
eg. 00101 ^ 10100 结果是：10001
d.按位取反 “~”
规则：一个二进制位上取反
eg. ~10100 = 01011
e.左移 “<<”
规则：二进制位向左移 n 位，高位舍去，低位0补齐,
结论：a << n ,结果是a*2的n次方
作用：用于计算次方，性能比直接循环乘的方式好
f.右移 “>>”
规则：符号位不变，其它位向右移，舍去低位，一般用符号位值补齐高位
结论：a >> n ，结果是：a除以2的n次方
作者: l_15562009298 时间: 2015-8-30 12:19
黑马程序员－－oc基础－－NSFileManage对文件的操作
1.NSFileManage是一个单例类，也就是一个文件中仅有一个该对象，不管创建多少次
创建：NSFileManage ＊fm［NSFileManage defaultManager］
2.判断是否是文件夹
Bool dir＝NO; Bool exists＝［fm fileExistsAtPath:@"/user/.." isDirectory:&dir］;
若发哦路径下不存在则exists＝NO，如果路径存在，并且dir＝YES 表示该路径下时一个文件夹
3.获取路径下的所有的目录（文件／文件夹）的名称
NSArray ＊arr＝[fm contentOfDirectory:@"/User/.." error:nil]；
4.获取文件的扩展名
NSString ＊str＝[@"/User/../abc.txt" pathExtension];//结果是 txt ，并不包含 .
5.练习：获取某个路径下的所有的文件
思路：判断这个路径是否存在，不存在返回空，存在继续
如果这个路径下是文件，就返回该文件名称
如果这个路径下时文件夹，则先获取这个文件夹中的所有的目录名称
拼接这些目录的完整路径
利用递归思想，再次调用当前这个函数，将目录路径作为参数传人
作者: l_15562009298 时间: 2015-8-30 12:20
黑马程序员－－oc基础－－NSDate基本用法
1.一些基本方法
[url=][/url]
[NSDate date];表示当前时间[NSDate dateWithTimeInterval:5 sinceDate:date];//返回比date晚5秒点时间[date timeIntervalSince1970];//返回1970到date时间之间的秒数，返回NSTimeInterval类型[date timeIntervalSinceNow];//返回从date当前时间之间的秒数[url=][/url]
5.NSDate和NSString之间的转换
NSDate －》NSString
NSDateFormatter ＊format＝[[NSDateFormatter alloc]init];//创建时间格式化对象format.dataFormat=@"yyyy-MM-dd HH:mm:ss"; //设置转化的格式NSString ＊str＝[format stringFromDate:[NSDate date]];//将NSDate对象转成NSString
NSString －》NSDate
[url=][/url]
NSString ＊str＝@"2015-2-2";NSDateFormatter ＊format＝[[NSDateFormatter alloc]init]//创建时间格式化对象format.dataFormat=@"yyyy-MM-dd HH:mm:ss"; //设置转化的格式[format dateFromString:str];[url=][/url]
作者: l_15562009298 时间: 2015-8-30 12:21
黑马程序员－－oc基础－－NSNumber和NSValue的使用
1.在往oc的集合中存数据的时候，只能是放oc类型的值，那么就会涉及到将值类型对转化成oc数据类型的
基本数据类型（int char double）－》oc数据类型
[url=][/url]
//方式一 [NSNumber numberWithInt: 10]//将int类型的数据转成NSNumber类型 [NSNumber numberWithDouble: 10.2] [NSNumber numberWithChar: 'A']//方式二[NSString stringWithFormat:@"%d",12]//将int转化成NSString类型//方式三 @"29" @"adc" //转化成NSString类型//方式四 //@值 ; @10 @22.2 @'A' @YES //方式五 int age=12; NSNumber * a=@(age) //注意此次必须用（）将变量扩住，不然编译器会认为是一个关键字[url=][/url]
NSNumber／NSString类型 －》c数据类型
int num=@12;［num intValue］;［num charValue］ ; //num是NSNumber／NSString对象
2.NSNumber是继承自NSValue的，NSValue可以将结构体转化成oc类型
结构体 －》oc类型
CGPoint ＊p＝CGPointMake(10,12)//CGSize，CGRect 结构体也类似，也有valueWithSize，valueWithRect 方法 NSValue *value=[NSValue valueWithPoint:p]
oc类型 －》结构体
［value pointValue］ //类似，也有sizeValue，rectValue方法
作者: l_15562009298 时间: 2015-8-30 12:23
黑马程序员－－oc基础－－oc中集合的总结
NSArray／NSMutableArray：有顺序的，NSArray有快速创建方式，NSMutableArray没有
NSSet／NSMutableSet：无序的，两个都没有快速创建方式
NSDictionary／NSMutableDictionary ：无序的，NSDictionary有快速创建方式，NSMutableDictionary没有快速创建方式
共同点：
都是集合，都能存放多个oc类型对象
都只能存放oc类型对象，不能存放非oc类型对象，如：基本数据类型（int char doble...）,结构体，枚举
都有一个可变和不可变的集合
作者: l_15562009298 时间: 2015-8-30 12:24
黑马程序员－－oc基础－－oc之集合NSDictionary，NSMutableDictionary
NSMutableDictionary继承自NSDictionary ，字典，NSMutableDictionary 可变集合 ，都是无序的
NSDictionary
1.创建方式
[url=][/url]
[NSDictionary dictionaryWithObject:@"value" forKey:@"key"] [NSDictionary dictionaryWithObjects:值集合 forKeys: 键集合]//值集合和键集合用NSArray定义 [NSDictionary dictionaryWithObjectsAndKeys: @"value1",@"key1", @"value2",@"key2",...,nil]//这种方式可读性非常差，不建议使用 @{@"key1":@"value1",@"key2":@"value2",...}//这个事快速创建方式，但是只能用在不可变字典上[url=][/url]
2.获得字典的长度：［dic count］返回NSUIntger
3.获取值 ：
id obj＝[dict objectForKey:@"key"]//原始的获取方式id obj=dict[@"key"] /xcode重新封装的 快速获取方式
4.遍历：
[url=][/url]
//方式1.NSArray *keys=[dict allKeys];//获得字典所有的键集合 for(int i=0;i<dic.count;i++) { NSString *key=dic; NSLog(@"%@",dic[key]); }
//方式2
[dict enumerateKeysAndObjectsUsingBlock:^(id key,id obj, Bool *stop) { }]；
[url=][/url]
NSMutableDictionary
1.创建方式和NSDictionary一样，但是不能使用@｛｝快速创建对象，
另外还有一种NSDictionary不使用的方式：［NSMutableDictionary dictionary］
2.新增的方法
［dict setObject:@"value" forKey:@"key"］//新增元素 [dict removeObjectForKey:@"key"]//根据键移除指定的元素
注意：字段允许值相同，不允许键相同
作者: l_15562009298 时间: 2015-8-30 12:26
黑马程序员－－oc基础－－oc中之集合NSSet，NSMutableSet
NSMutableSet继承自NSSet，NSSet是不可变集合，NSMutableSet是可变集合，两者存放都是无序的
NSSet：
1.创建方式
［NSSet setWithObjects:@"123",@"abc"］
[NSSet setWithObject:@""]
2. 获取集合的个数：［set count］
3.获取集合中的元素：［set anyObject］（因为该集合时无序的，取得的值也是随机的）
NSMutableSet
1创建方式和NSSet一样，另外还有一种NSSet不用的：［NSMutableSet set］
2.新增的方法：
［set addObject:@"daf"］//新增元素
[set removeAllObject] //移除所有元素
[set removeObject:@"aa"] //移除指定元素
作者: l_15562009298 时间: 2015-8-30 12:28
黑马程序员－－oc基础－－oc中之集合NSArray，NSMutableArray
1.NSArray 不可变集合（仅在初始化时赋值），NSMutableArray 可变集合，两者的元素都是有顺序存放的
NSArray：
创建方式
[NSArray arraywithObject:@"abcde"]
[NSArray arrayWithObjects:@"abc",@"123",...]
@[@"abc",@"123"]//该方式是快速创建方式
2.获取集合的长度：［arr count］或 arr.count
3.获取集合中的元素：［arr objectAtIndex：下标］或 arr[下标] （该方式是xcode封装了前一个方法的，通常使用这个）
4.遍历集合
1 //方式一2 for(int i=0;i<arr.count;i++)3 {4 NSLog(@"%@",arr);5 }
//方式二for(id obj in arr)//因为集合可以存任何类型的数据，所有用id{ NSLog(@"%@",obj);}
[url=][/url]
//方式三 [arr enumerateObjectsUsingBlock：^(id obj ,NSUIntger idx ,Bool *stop){ //obj表示某个元素，idx表示这个元素点下标，stop表示是否停止遍历 //每遍历一次，都会调用一次block，并把当前元素，索引，和一个bool类型的变量地址作为参数传给block //因为在这个方法内，有可能改变stop的值，而bool是基本数据类型，所以穿对事变量的地址 //stop为YES时，表示停止遍历并跳出方法，＊stop＝YES}];[url=][/url]
NSMutableArray 可变集合（初始化是可以赋值空的）
1.创建方式和NSArray一样，但是不能使用快速创建方式，因为@［］，返回的是NSArray对象
另外还有NSArray不用的方法：［NSMutableArray array］
2.新增的方法
[url=][/url]
[arr addObject:@"jack"]//添加元素 [arr removeAllObjects] //移除所有的元素 [arr removeObject:@"jack"] //移除指定的元素 [arr removeObjectAtIndex:0] //根据元素的下标移除元素[url=][/url]
作者: l_15562009298 时间: 2015-8-30 12:35
黑马程序员－－oc基础－－NSString和NSMutableString区别
1.NSMutableString是NSString的子类，NSString有的方法NSMutableString也有
2.NSMutableString是可变的字符串，NSString是不可变字符串
NSMutableString可以对字符串进行增删改操作，NSString不可以（仅在初始化的时候赋值）
[url=][/url]
NSMutableString ＊s＝@""; [s appendString:@"123"]//在原来s字符串基础上追加一个字符串 NSRange *r=[s rangeOfString:@"2" ];//获取某个字符串的范围 [s deleteCharactersInRange:r]//在原来的s字符串中删除某个范围的字符串[url=][/url]
3.NSString也有一个增加的方法，但是喝NSSMutableString增加的原理不一样
NSString ＊s1=[s stringByAppendingString:@"adf"]
4.区别解析：
NSString的调方法增加字符串，会先拿到原理的字符串，然后复制一份，再在新复制的那个对象上进行修改，
实质返回的是一个新对象，原来的字符串并没有变化。
NSMutableString修改字符串，就是在原来的字符串上进行修改的，操作的是同一个对象
所有称NSString是不可变的，NSMutableString时可变的
作者: l_15562009298 时间: 2015-8-30 12:36
黑马程序员－－oc基础－－foundation框架中的常用结构体
1.CGPoint/NSPoint ：表示坐标点的
创建：
CGPoint ＊cp＝NSMakePoint(10,10); //x,yNSPonit ＊cp＝CGPointMake(10,10);
2.CGSize/NSSize : 用来表示尺寸的
创建：
CGSize ＊s＝NSMakeSize(100,100) ;//width,heightNSSize *s=CGSizeMake(100,100);
3.CGRect/NSRect :用来描述控件的具体位置
创建：
CGRect ＊r＝NSMakeRect(0,0,100,50); // x,y,width,heightNSRect *r=CGRectMake(0,0,100,50);CGRect ＊r＝｛CGPoint，CGSize｝;//直接根据结构体原理初始化｛｛0，0｝，｛100，100｝｝也可以
CGRect中的参数是由两个结构体组成的
取得CGRect中的参数值：r.orgin.x, r.orgin.y , r.size.width, r.size.height
4. 两个点／尺寸／位置进行比较
Bool b＝CGPointEqualToPoint（CGPoint1，CGPoint2）Bool b＝CGSizeEqualToSize（CGSize1，CGSize2）Bool b＝CGRectEqualToRect（CGRect1，CGRect2）
5.判断点是否在某个范围
CGRectContainPoint（CGRect，CGPoint）
6.原点表示：
CGpointMake（0，0）或 CGPointZero
类似，另外两个结构体也有改表示方法：CGSizeZero，CGRectZero
7.CG开头的这些结构体所用的函数，必须导入CoreGraphicsFrameWork框架，里面有函数的实现，在Foundation中仅时对函数做了声明
作者: l_15562009298 时间: 2015-8-30 12:37
黑马程序员－－oc基础－－设计代理模式理解
通常情况下，一个类引用了另一个类时，都会有一个相关联待属性，比如person类中有一个student类型的属性，这样使用导致代码的耦合性
太高，一旦我不想使用student作为该属性的类型时，即这个类型是个代理类，修改起代码十分的麻烦，
所有我们就直接将这个属性定义成id类型的（NSObject ＊），可以是任意类型，但是此时当类型实质是没有明确的的，那么就会导致我们无法
使用该属性，
所有我们又让这个id类型去遵守某个协议，那么这样我们就知道这个id类型的实质是要干啥，也就是我们能够清楚知道这个类型下可以调用哪些
方法，
同时在给该属性赋值的时候，这个值对象也是必须遵守了这个协议的
换句话说：找个人替我办事，这个人可以是任何人，但是这个人必须得遵守我们之间的协议
作者: l_15562009298 时间: 2015-8-30 12:38
黑马程序员－－oc基础－－protocol协议的使用
1.协议：就是用来声明一大堆方法的，供遵守这个协议的对象使用的
2.语法：
@protocol 协议名称 <NSObject,其他协议> //定义方法（仅时方法的声明） @end
NSObject是所有协议的基协议，最好是所有协议都遵守基协议
3.类遵守协议，那么这个类默认情况下，就会拥有这个协议内的所有的方法
语法
@interface 类名: 父类 < 协议名1,...>@end
4.协议遵守协议
语法
@protocol 协议名 <其他协议,...>@end
5.协议中声明方法的关键字
@required：在遵守某个协议时，必须实现该关键字修饰对方法（字面上是必须的，实际要求没那么严格），否则会有警告的（默认的）
@optional：可以实现也可以不实现该关键字修饰的方法
eg.@required
- (void) xxx;
6.在定义变量时，可以限制这个变量保存的对象去遵守某个协议
类名 <协议名称> ＊变量名 ； ＝》也就是说这个变量必须是某个类型的，并且这个类还必须遵守了这个协议的
id <协议名称> 变量名 ； ＝》id表示任意的oc对象类型，相当于NSObject ＊类型，
7.property声明属性时，也可也用协议限制该属性
@property(nonatomic,strong) id<协议名> 属性名； ＝》这是一种设计模式，这样这个属性类型可以是遵守了这个协议的任何一种类型
@property(nonatomic,strong) 类名<协议名> 属性名； ＝》定死是哪个类型的了，并且这个类必须遵守这个协议
8.定义协议的位置；可以是在一个单独的.h文件中定义（一般会有多个类去遵守的情况），也可以直接定义在摇遵守的那个类的.h文件中
9.@protocol：用于声明一个协议
类似于@class，仅时做一个声明，在编译的时候告诉编译器，并不包含文件里的内容，在需要使用文件的时候才import 文件
作者: l_15562009298 时间: 2015-8-30 12:40
block关键字的使用
1.block 是oc的一个数据类型
2.作用：用了封装一段代码，可以在任何时候调用执行。即在编译的时候忽略block修饰的代码段，在调用这个代码时，也就是运行时，
编译器会自动加载这个代码， so这样的程序，效率非常高
3.语法：
定义一个block类型的变量：有参－》返回值类型 (^变量名) (参数类型1,参数类型2) 。eg. void (^myblock)(int,int)
无参－》返回值类型 (^变量名) eg. void (^myblock)
定义一个block代码段： 有参－》^(参数类型1 参数名称，参数类型2 参数名称)｛// 代码，也可以有返回值｝
无参－》^(){//代码}或 ^{//代码}
调用一个block代码段：变量名（参数值...）
4.用typedef 定义一个bolck类型的变量：
定义： typedef 返回值类型 (^自定义类型名) (参数类型,...)
使用： 自定义类型名 变量名＝^(参数类型 参数名称,...)`{//代码}
这个使用类似指向函数的指针：定义－》返回值 (*指针名) （参数类型,...)，赋值－》指针名＝函数名称，调用－》指针名（参数值,...）
5.block代码段内，可以访问该代码段外的变量，但是默认不能修改外部的变量，
使用 __block 关键字修饰的变量，在block代码段内就可以修改了
eg. __block int a=0;
作者: l_15562009298 时间: 2015-8-30 12:41
黑马程序员－－oc基础－－ARC的使用
1.ARC 作用：在编译的时候，编译器自动生成一下release代码，
2.ARC是否生成release代码的判断准则：只要没有强指针指向对象，那么对象就会release
3.强指针：默认情况下，指针都是强指针，用 __strong修饰符修饰的
弱指针：就是用 __weak 修饰的指针
__weak Dog dog*;
注意：弱指针对象创建后，就会马上被释放
4.在arc模式下的property使用：
此时property的set内存管理的参数：
strong：用于强指针上（oc类型的），通常用这个参数值
weak：用于弱指针上（oc类型）
assign：用于非oc对象类型
注：在arc模式下，retain，release，retaincount，都不能由程序员手动调用，但是dealloc方法还是可以重写的，［super dealloc］却不能再调用
5.arc模式中解决循环引用：两个类中任意一个中的相关的属性property参数用weak
作者: l_15562009298 时间: 2015-8-30 12:42
@atuoreleases 关键字的使用
1.作用；实质是延长对象的release时间
2. 语法：
[url=][/url]
@autoreleasepool｛ 类型 变量＊＝[[[类型 alloc] init] autorelease]; //....｝//或NSSAutoreleasePool *pool=[[NSSAutoreleasePool alloc] init];//代码[pool release];[url=][/url]
解析：第一种，首先会创建一个autorelease的池子（autoreleasepool），待创建变量的时候就将创建的对象放入autorelease池子中
最后当｛｝结束时，就将池子和池子中的所有对象release一次
第二种：在ios5.0 之前使用的方式
先定义一个自动释放池，将代码写在这个池子对象创建和release之间，当池子对象release了，里面的oc对象也跟着release
3.在实际的开发中，通常将创建一个autorelease对象封装到类方法中，这样能够快速的调用方法创建对象，不用编写长长的定义
代码，但是创建对象的时候最好不用类名，用self这样更佳灵活，谁调用这个方法，就创建谁的对象
［［self alloc］init］autorelease］
4.注意：ARC模式下不能使用NSAutoReleasePool方式
在自动释放池中间不要用循环去创建对象，这样会导致内存峰值上升
尽量避免对大内存使用该方法，这种延迟机制，还是尽量少用
sdk中的静态方法一般是自动释放的，不用我们自己在release
作者: l_15562009298 时间: 2015-8-30 12:43
黑马程序员－－oc基础－－oc中的内存管理arc
1.有alloc，new，copy创建出来的对象就必须有release，在类中是retain对oc类型对成员在该类对dealloc方法中也要release
2.一旦对象直接有引用关系，那么就一定有retain，同时在主对象销毁时，也必须对其引用对对象release。但是对象引用时，在retain时
注意是否引用对时同一个对象，若是不同对象就得先release旧对象，再retain新对象
代码：
[url=][/url]
－（void）setDog:Dog dog｛ if(dog!=_dog) { [_dog release]; [dog ratain]; _dog=dog; }｝[url=][/url]
举例：一个人买了一辆车，那么现在这个人拥有了这辆车，也就是车的retain一次，当这个人买了新车了，那么之前那辆车就和这个人没有关系了
那么就的release一次旧车，然后再retain一次新车，若这辆车没有换，那么就不做任何操作。如果人挂了的话，这辆车就会可能给别人，所
以，必须再人挂的时候，将车release一次，相当于解除了这个人和这辆车的关系了
3.@property关键字，用于简化我们频繁的写set，get的代码，他将会自动生产对于的方法，和字段（都是有一定的命名规范的，setXx ，xx，_xx）
@property的参数：
a.set方法内存管理的参数（各参数不能同时有）
retain：会自动release旧对象，retain新对象，适用于oc类型对象，如2代码
assign：直接赋值给对象成员，适用于非oc类型的对象
copy：release旧值，copy新值
b.是否生成set方法 （各参数不能同时有）
readwrite：可读可写，即set和get方法都会生成
readonly：只读，只生成get方法
c.多线程管理（各参数不能同时有）
nonatomic：性能高，通常都是用该参数
atomic：性能低，默认的参数
d.setter和getter重设方法的名称
setter：给set方法重命名，但是必须有冒号 ' : '
getter：给get方法重命名，一般用在bool类型的属性上
eg。 @property (nonatomic,readwrite,assign,setter=abc: ) int age
@property (nonatomic,retain) Dog dog
当用了setter或getter重命名方法时，再使用该对象时可以直接用 对象.成员名称 来取值或赋值，工具会自动检测时再用get还是
set方法的
4.@class 关键字：声明一个类，但是没有类里的实现，仅仅时做一个声明，给编译器看的，再运行的时候才去找实现
代替的import导入文件
使用的好处：解决里两个类互相引用的问题（import时不能互相导入的）
提高类程序的性能（用import的话，每次被导入的文件被改动，都会重新复制一份到当前类中，消耗性能，而class不用管）
5.当两个类互相引用时，再各自当dealloc方法中就必须对引用对对象release一次，这样就导致两个对象被咬死，无法释放内存，
解决方案：再其中任意一个类中，将引用另一个类对熟悉对property参数写成assign
作者: l_15562009298 时间: 2015-8-30 12:44
ORM_mybatis 讲解
batis 是一个ORM框架，MyBatis作为持久层框架，其主要思想是将程序中的大量sql语句剥离出来，配置在配置文件中，实现sql的灵活配置。这样做的好处是将sql与程序代码分离，可以在不修改程序代码的情况下，直接在配置文件中修改sql。下面给个简单的入门例子。
工作流程：
(1)加载配置并初始化
触发条件：加载配置文件
将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。
(2)接收调用请求
触发条件：调用Mybatis提供的API
传入参数：为SQL的ID和传入参数对象
处理过程：将请求传递给下层的请求处理层进行处理。
(3)处理操作请求 触发条件：API接口层传递请求过来
传入参数：为SQL的ID和传入参数对象
处理过程：
(A)根据SQL的ID查找对应的MappedStatement对象。
(B)根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。
(C)获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。
(D)根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。
(E)释放连接资源。
(4)返回处理结果将最终的处理结果返回。
我们把Mybatis的功能架构分为三层：
(1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
(2)数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
(3)基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。
4，在DAO层添加基于每个dao文件的**DAO.config配置文件，在这个文件里标注类型别名和书写要操作的sql语句：
其中：parameterClass用来指定入参，resultClass指定出参
5，此时可以再DAO层直接使用了：
using IBatisNet.DataMapper;
SqlMap.QueryForList<TaskEntity>("SSL.Entity.SelectTask", 12);
返回id=12的实体。
4，在DAO层添加基于每个dao文件的**DAO.config配置文件，在这个文件里标注类型别名和书写要操作的sql语句：
其中：parameterClass用来指定入参，resultClass指定出参
5，此时可以再DAO层直接使用了：
using IBatisNet.DataMapper;
SqlMap.QueryForList<TaskEntity>("SSL.Entity.SelectTask", 12);
返回id=12的实体。
1，引入类库：IBatisNet.DataMapper.dll、IBatisNet.Common.dll
2，添加配置文件：Providers.config（连接数据库配置，包含对各种数据库的字符串配置）
Properties.config（配置登陆的数据库，用户、密码）
SqlMap.config（Ibatis核心配置文件，包含上边两个文件的指定，同时还定义了其它的DataMapper配置选项，如缓存等，在其<sqlMaps>中添加对每个数据源配置文件的配置）
3，在web.config中将上一步的sqlmap.config文件配置为对象添加到spring的上下文容器中，以作为属性向DAO文件注入。
4，在DAO层添加基于每个dao文件的**DAO.config配置文件，在这个文件里标注类型别名和书写要操作的sql语句：
其中：parameterClass用来指定入参，resultClass指定出参
5，此时可以再DAO层直接使用了：
using IBatisNet.DataMapper;
SqlMap.QueryForList<TaskEntity>("SSL.Entity.SelectTask", 12);
返回id=12的实体。
作者: l_15562009298 时间: 2015-8-30 12:45
软件开发的生命周期描述
软件项目的生命周期:
项目计划
需求分析
设计(概要设计和详细设计)
编码
测试
发布
维护
项目计划阶段：走访客户，进行交流沟通，获得客户原始需求。
对客户的需求和市场等进行调研，分析，编写可行性分析报告。
通过不断的与客户沟通，找客户不同环节的用户进行交流来获取需求。召开评审会议，报告可行性分析，报告用户原始需求，报告项目远景规化。
需求分析阶段：
在客户原始需求的基础上不断与客户沟通，充分的熟悉和深入客户业务，获得充分的业务需求，完善用户需求和功能性需求，了解客户的相关约束而获得非功能性需求。最终编写《需求规格说明书》；召开需求评审会议，客户确定需求，并签定合同；编写项目计划说明书；编写测试计划；召开项目启动会议，项目正式启动。
概要设计阶段：根据《需求分析说明书》，进行用例分析,获得充分而有效的用例。编写界面原型，编写编码规范和界面风格规范,数据库设计规范。用uml工具画用例图，编写有效的用例规约文档。划分项目功能模块.评审用例及用例规约文档。
详细设计阶段：根据完整的用例及需求进行分析，获得数据库所需的相关信息,画数据库E-R图，编写数据设计说明书.进行数据库建模。进行详细的分析，用uml工具画类图，确定每个功能模块的子功能，抽取项目的公共部分成为一个公共模块。确定项目的架构基础。确定需要用到的类及类成员和方法。确定一些辅助类及方法。对每一个用例都用uml工具画出顺序图。编写详细设计说明书，评审详细设计说明书, 进行基础框架搭建。列出任务清单，进行任务分配。
编码阶段：以小组的形式进行代码编写，编写单元测试用例，每完成一个类都要进行单元测试。每完成一个功能点和模块都要进行集成测试。确保每一个功能点和模块完成后都是一个可以看得见、摸得着的产品。而不是等到最后才进行统一的调试和搭配。每天都要对代码进行检查和优化，也就是所谓的重构。
测试阶段：根据测试计划对项目进行系统测试，以及用户的验收测试
产品发布：交付完整的产品和设计文档。把产品布署到客户的计算机上,确保产品的正常运行。客户签收。
维护阶段：为客户提供技术保障，对产品进行相应的维护和升级工作
软件常见开发模型
瀑布模型：最经典的过程模型，适用于需求明确，规模较小的项目
喷泉模型：迭代，无间隙特点，适用于面向对象的软件开发过程
螺旋模型：
MSF模型：微软解决方案过程模型
什么是极限(XP)编程：极限编程是对敏捷软件开发方法的一种实现。它强调测试先行，也就是在编写代码的时候先编写测试用例;循环迭代，每一次迭代都是一个可用的产品；重构，不断的对代码进行优化；结对编程，两个人为一对共同进行代码编写；它强调团队之间的知识传播，让团队的每个人都能熟悉软件开发的各种技术。如：支持熟悉数据库的人去做界面，做界面的人去做数据库等，通过不定期的角色转换来增强团队的能力。要求客户参与到软件开发中来,开发出最适合客户需求的产品。
单元测试一般是在编码的时候同步进行的，一般是以类为单位进行测试，当一个类完成了编码，并编译正确后才进行的测试，测试这个类是否已经能够实现指定的功能。一个类能够正常的编译成功并不意味着这个类就已经完成了，还要通过测试，设置断言来确定他是否已经达到了预期的效果，实现了特定的功能。调试，编译通过只能证明代码的语法没有错误。
单元测试由程序员自己来进行，也可以在项目小组内交互进行。单元测试是采用白盒测试
集成测试一般指实现了一个功能点或一个模块后,为了测试这个模块是否已经实现了需求要求的功能。集成测试可能需要对多个类进行组装，也可能需要与以前已经测试通过的模块进行组装，是对产品组件的系统整合和执行。集成测试可以根据模块的大小分不同的级别，在现行的软件开发中，每完成一个功能模块都必须要进行一次集成测试，使得你完成的模块是一个可以运行的产品。集成测试一般可以由项目小组的负责人（或指定一个小组成员）来完成。集成测试采用白盒式测试和黑盒测试
系统测试一般指项完代码已经全部完成，交给测试小组来进行测试。进行系统测试的人员独立于开发小组，系统测试人员把完成的产品布署在相应的计算机环境中，按照测试计划进行测试，验证系统是否满足了指定的需求。系统测试除了测试产品应满足基本的功能需求外，还要对产品的性能，用户界面，安全性，压力，可靠性，安装和反安装等几个方面进行测试
系统测试采用黑盒测试
验收测试一般指产品交付给客户，负责把产品布署在指定的计算机环境中。由用户根据需求文档，进行的总体测试。验收测试的内容和系统测试一样，只是执行者不同。都是除了测试系统完成基本功能外还要对性能，安全性，可靠性等进行测试。验收测试也是采用黑盒测试
作者: l_15562009298 时间: 2015-8-30 12:51
log4net介绍及使用
1 简介
1.1 Log4net的优点：
几乎所有的大型应用都会有自己的用于跟踪调试的API。因为一旦程序被部署以后，就不太可能再利用专门的调试工具了。然而一个管理员可能需要有一套强大的日志系统来诊断和修复配置上的问题。
经验表明，日志记录往往是软件开发周期中的重要组成部分。它具有以下几个优点：它可以提供应用程序运行时的精确环境，可供开发人员尽快找到应用程序中的Bug；一旦在程序中加入了Log 输出代码，程序运行过程中就能生成并输出日志信息而无需人工干预。另外，日志信息可以输出到不同的地方（控制台，文件等）以备以后研究之用。
Log4net就是为这样一个目的设计的，用于.NET开发环境的日志记录包。
1.2 Log4net的安装：
用户可以从http://logging.apache.org/log4net/下载log4net的源代码。解压软件包后，在解压的src目录下将log4net.sln载入Visual Studio .NET，编译后可以得到log4net.dll。用户要在自己的程序里加入日志功能，只需将log4net.dll引入工程即可。
作者: l_15562009298 时间: 2015-8-30 12:53
2 Log4net的结构
log4net 有四种主要的组件，分别是Logger（记录器）, Repository（库）, Appender（附着器）以及 Layout（布局）.
2.1 Logger
2.1.1 Logger接口
Logger是应用程序需要交互的主要组件，它用来产生日志消息。产生的日志消息并不直接显示，还要预先经过Layout的格式化处理后才会输出。
Logger提供了多种方式来记录一个日志消息，你可以在你的应用程序里创建多个Logger，每个实例化的Logger对象都被log4net框架作为命名实体(named entity)来维护。这意味着为了重用Logger对象，你不必将它在不同的类或对象间传递，只需要用它的名字为参数调用就可以了。log4net框架使用继承体系，继承体系类似于.NET中的名字空间。也就是说，如果有两个logger,分别被定义为a.b.c和a.b，那么我们说a.b是a.b.c的祖先。每一个logger都继承了祖先的属性
Log4net框架定义了一个ILog接口，所有的logger类都必须实现这个接口。如果你想实现一个自定义的logger，你必须首先实现这个接口。你可以参考在/extension目录下的几个例子。
ILog接口的定义如下：
public interface ILog
{
void Debug(object message);
void Info(object message);
void Warn(object message);
void Error(object message);
void Fatal(object message);
//以上的每一个方法都有一个重载的方法，用来支持异常处理。
//每一个重载方法都如下所示，有一个异常类型的附加参数。
void Debug(object message, Exception ex);
// ...
//Boolean 属性用来检查Logger的日志级别
//（我们马上会在后面看到日志级别）
bool isDebugEnabled;
bool isInfoEnabled;
//… 其他方法对应的Boolean属性
}
Log4net框架定义了一个叫做LogManager的类，用来管理所有的logger对象。它有一个GetLogger()静态方法，用我们提供的名字参数来检索已经存在的Logger对象。如果框架里不存在该Logger对象，它也会为我们创建一个Logger对象。代码如下所示：
log4net.ILog log = log4net.LogManager.GetLogger("logger-name");
通常来说，我们会以类（class）的类型（type）为参数来调用GetLogger()，以便跟踪我们正在进行日志记录的类。传递的类(class)的类型(type)可以用typeof(Classname)方法来获得，或者可以用如下的反射方法来获得：
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType
尽管符号长了一些，但是后者可以用于一些场合，比如获取调用方法的类(class)的类型(type)。
2.1.2 日志的级别
正如你在ILog的接口中看到的一样，有五种不同的方法可以跟踪一个应用程序。事实上，这五种方法是运作在Logger对象设置的不同日志优先级别上。这几种不同的级别是作为常量定义在log4net.spi.Level类中。你可以在程序中使用任何一种方法。但是在最后的发布中你也许不想让所有的代码来浪费你的CPU周期，因此，框架提供了7种级别和相应的Boolean属性来控制日志记录的类型。
Level有以下几种取值
级别 | 允许的方法 | Boolean属性 | 优先级别 |
OFF | | | Highest |
FATAL | void Fatal(...); | bool IsFatalEnabled; | |
RROR | void Error(...); | bool IsErrorEnabled; | |
WARN | void Warn(...); | bool IsWarnEnabled; | |
INFO | void Info(...); | bool IsInfoEnabled; | |
DEBUG | void Debug(...); | bool IsDebugEnabled; | |
ALL | | | Lowest |
表1 Logger的日志级别
作者: l_15562009298 时间: 2015-8-30 12:55
在log4net框架里，通过设置配置文件，每个日志对象都被分配了一个日志优先级别。如果没有给一个日志对象显式地分配一个级别，那么该对象会试图从他的祖先继承一个级别值。
ILog接口的每个方法都有一个预先定义好了的级别值。正如你在表1看到的，ILog的Inof()方法具有INFO级别。同样的，以此类推，Error()方法具有ERROR级别。当我们使用以上的任何一种方法时，log4net框架会检查日志对象logger的级别和方法的级别。只有当方法的级别高于日志级别时，日志请求才会被接受并执行。
举例说明，当你创建了一个日志对象，并且把他的级别设置为INFO。于是框架会设置日志的每个Boolean属性。当你调用相应的日志方法时，框架会检查相应的Boolean属性，以决定该方法能不能执行。如下的代码：
Logger.Info("message");
Logger.Debug("message");
Logger.Warn("message");
对于第一种方法，Info()的级别等与日志的级别（INFO），因此日志请求会被传递，我们可以得到输出结果”message”。
对于第二种方法，Debug()的级别低于日志对象logger的日志级别(INFO)，因此，日志请求被拒绝了，我们得不到任何输出。同样的，针对第三行语句，我们可以很容易得出结论。
在表1中有两个特殊的级别：ALL和OFF。ALL表示允许所有的日志请求。OFF是拒绝所有的请求。
你也可以显式地检查Logger对象的Boolean属性，如下所示：
if (logger.IsDebugEnabled)
{
Logger.Debug("message");
}
2.2 Repository
Repository主要用于负责日志对象组织结构的维护。在log4net的以前版本中，框架仅支持分等级的组织结构(hierarchical organization)。这种等级结构本质上是库的一个实现，并且定义在log4net.Repository.Hierarchy 名字空间中。要实现一个Repository，需要实现log4net.Repository.ILoggerRepository 接口。但是通常并不是直接实现该接口，而是以log4net.Repository.LoggerRepositorySkeleton为基类继承。体系库 (hierarchical repository )则由log4net.Repository.Hierarchy.Hierarchy类实现。
如果你是个log4net框架的使用者，而非扩展者，那么你几乎不会在你的代码里用到Repository的类。相反的，你需要用到LogManager类来自动管理库和日志对象。
2.3 Appender
一个好的日志框架应该能够产生多目的地的输出。比如说输出到控制台或保存到一个日志文件。log4net 能够很好的满足这些要求。它使用一个叫做Appender的组件来定义输出介质。正如名字所示，这些组件把它们附加到Logger日志组件上并将输出传递到输出流中。你可以把多个Appender组件附加到一个日志对象上。Log4net框架提供了几个Appender组件。关于log4net提供的Appender组件的完整列表可以在log4net框架的帮助手册中找到。有了这些现成的Appender组件，一般来说你没有必要再自己编写了。但是如果你愿意，可以从log4net.Appender.AppenderSkeleton类继承。
2.4 Appender Filters
一个Appender 对象缺省地将所有的日志事件传递到输出流。Appender的过滤器(Appender Filters) 可以按照不同的标准过滤日志事件。在log4net.Filter的名字空间下已经有几个预定义的过滤器。使用这些过滤器，你可以按照日志级别范围过滤日志事件，或者按照某个特殊的字符串进行过滤。你可以在API的帮助文件中发现更多关于过滤器的信息。
2.5 Layout
Layout 组件用于向用户显示最后经过格式化的输出信息。输出信息可以以多种格式显示，主要依赖于我们采用的Layout组件类型。可以是线性的或一个XML文件。Layout组件和一个Appender组件一起工作。API帮助手册中有关于不同Layout组件的列表。一个Appender对象，只能对应一个Layout对象。要实现你自己的Layout类，你需要从log4net.Layout.LayoutSkeleton类继承，它实现了ILayout接口。
作者: l_15562009298 时间: 2015-8-30 12:56
3 在程序中使用log4net
3.2 使用配置文件
3.2.1 关联配置文件
当我们创建了上面的配置文件后，我们接下来需要把它和我们的应用联系起来。缺省的，每个独立的可执行程序集都会定义它自己的配置。log4net框架使用 log4net.Config.DOMConfiguratorAttribute在程序集的级别上定义配置文件。
例如：可以在项目的AssemblyInfo.cs文件里添加以下的语句
[assembly:log4net.Config.DOMConfigurator(ConfigFile="filename",
ConfigFileExtension="ext",Watch=true/false)]
l ConfigFile:指出了我们的配置文件的路径及文件名，包括扩展名。
l ConfigFileExtension:如果我们对被编译程序的程序集使用了不同的文件扩展名，那么我们需要定义这个属性，缺省的，程序集的配置文件扩展名为”config”。
l Watch (Boolean属性): log4net框架用这个属性来确定是否需要在运行时监视文件的改变。如果这个属性为true,那么FileSystemWatcher将会被用来监视文件的改变，重命名，删除等事件。
其中：ConfigFile和ConfigFileExtension属性不能同时使用，ConfigFile指出了配置文件的名字，例如，ConfigFile=”Config.txt”
ConfigFileExtension则是指明了和可执行程序集同名的配置文件的扩展名，例如，应用程序的名称是”test.exe”,ConfigFileExtension=”txt”,则配置文件就应该是”test.exe.txt” ；
也可以不带参数应用DOMConfiguratio():
[assembly: log4net.Config.DOMConfigurator()]
也可以在程序代码中用DOMConfigurator类打开配置文件。类的构造函数需要一个FileInfo对象作参数，以指出要打开的配置文件名。 这个方法和前面在程序集里设置属性打开一个配置文件的效果是一样的。
log4net.Config.DOMConfigurator.Configure(
new FileInfo("TestLogger.Exe.Config"));
DOMConfigurator 类还有一个方法ConfigureAndWatch(..), 用来配置框架并检测文件的变化。
以上的步骤总结了和配置相关的各个方面，下面我们将分两步来使用logger对象。
3.2.2 创建或获取日志对象
日志对象会使用在配置文件里定义的属性。如果某个日志对象没有事先在配置文件里定义，那么框架会根据继承结构获取祖先节点的属性，最终的，会从根日志获取属性。如下所示：
Log4net.ILog log = Log4net.LogManager.GetLogger("MyLogger");
3.2.3 输出日志信息
可以使用ILog的几种方法输出日志信息。你也可以在调用某方法前先检查IsXXXEnabled布尔变量，再决定是否调用输出日志信息的函数，这样可以提高程序的性能。
因为框架在调用如ILog.Debug(…)这样的函数时，也会先判断是否满足Level日志级别条件。
if (log.IsDebugEnabled) log.Debug("message");
if (log.IsInfoEnabled) log.Info("message);
作者: l_15562009298 时间: 2015-8-30 12:58
3.3 在程序中配置log4net
除了前面讲的用一个配置文件来配置log4net以外，还可以在程序中用代码来配置log4net框架。如下面的例子:
// 和PatternLayout一起使用FileAppender
log4net.Config.BasicConfigurator.Configure(
new log4net.Appender.FileAppender(
new log4net.Layout.PatternLayout("%d
[%t]%-5p %c [%x] - %m%n"),"testfile.log"));
// using a FileAppender with an XMLLayout
log4net.Config.BasicConfigurator.Configure(
new log4net.Appender.FileAppender(
new log4net.Layout.XMLLayout(),"testfile.xml"));
// using a ConsoleAppender with a PatternLayout
log4net.Config.BasicConfigurator.Configure(
new log4net.Appender.ConsoleAppender(
new log4net.Layout.PatternLayout("%d
[%t] %-5p %c - %m%n")));
// using a ConsoleAppender with a SimpleLayout
log4net.Config.BasicConfigurator.Configure(
new log4net.Appender.ConsoleAppender(new
log4net.Layout.SimpleLayout()));
尽管这里用代码配置log4net也很方便，但是你却不能分别配置每个日志对象。所有的这些配置都是被应用到根日志上的。
log4net.Config.BasicConfigurator 类使用静态方法Configure 设置一个Appender 对象。而Appender的构造函数又会相应的要求Layout对象。你也可以不带参数直接调用BasicConfigurator.Configure()，它会使用一个缺省的PatternLayout对象，在一个ConsoleAppender中输出信息。如下所示：
log4net.Config.BasicConfigurator.Configure();
在输出时会显示如下格式的信息：
0 [1688] DEBUG log1 A B C - Test
20 [1688] INFO log1 A B C - Test
当log4net框架被配置好以后，就可以如前所述使用日志功能了。
在开始对你的程序进行日志记录前，需要先启动log4net引擎。这意味着你需要先配置前面提到的三种组件。你可以用两种方法来设定配置：在单独的文件中设定配置或在代码中定义配置。
因为下面几种原因，推荐在一个单独的文件中定义配置：
l 你不需要重新编译源代码就能改变配置；
l 你可以在程序正运行的时候就改变配置。这一点在一些WEB程序和远程过程调用的程序中有时很重要；
考虑到第一种方法的重要性，我们先看看怎样在文件中设定配置信息。
作者: l_15562009298 时间: 2015-8-30 12:59
3.1 定义配置文件
配置信息可以放在如下几种形式文件的一种中。
在程序的配置文件里，如AssemblyName.config 或web.config.
在你自己的文件里。文件名可以是任何你想要的名字，如AppName.exe.xyz等.
log4net框架会在相对于AppDomain.CurrentDomain.BaseDirectory 属性定义的目录路径下查找配置文件。
框架在配置文件里要查找的唯一标识是<log4net>标签。一个完整的配置文件的例子如下：
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="log4net"
type="log4net.Config.Log4NetConfigurationSectionHandler,
log4net-net-1.0"
/>
</configSections>
<log4net>
<root>
<level value="WARN" />
<appender-ref ref="LogFileAppender" />
<appender-ref ref="ConsoleAppender" />
</root>
<logger name="testApp.Logging">
<level value="DEBUG"/>
</logger>
<appender name="LogFileAppender"
type="log4net.Appender.FileAppender" >
<param name="File" value="log-file.txt" />
<param name="AppendToFile" value="true" />
<layout type="log4net.Layout.PatternLayout">
<param name="Header" value="[Header]\r\n"/>
<param name="Footer" value="[Footer]\r\n"/>
<param name="ConversionPattern"
value="%d [%t] %-5p %c [%x] - %m%n"
/>
</layout>
<filter type="log4net.Filter.LevelRangeFilter">
<param name="LevelMin" value="DEBUG" />
<param name="LevelMax" value="WARN" />
</filter>
</appender>
<appender name="ConsoleAppender"
type="log4net.Appender.ConsoleAppender" >
<layout type="log4net.Layout.PatternLayout">
<param name="ConversionPattern"
value="%d [%t] %-5p %c [%x] - %m%n"
/>
</layout>
</appender>
</log4net>
</configuration>
你可以直接将上面的文本拷贝到任何程序中使用，但是最好还是能够理解配置文件是怎样构成的。
只有当你需要在应用程序配置文件中使用log4net配置时，才需要在<configSection>标签中加入<section>配置节点入口。
对于其他的单独文件，只有<log4net>标签内的文本才是必需的，这些标签的顺序并不是固定的。
作者: l_15562009298 时间: 2015-8-30 13:01
下面我们依次讲解各个标签内文本的含义：
3.1.1 <root>
<root>
<level value="WARN" />
<appender-ref ref="LogFileAppender" />
<appender-ref ref="ConsoleAppender" />
</root>
在框架的体系里，所有的日志对象都是根日志(root logger)的后代。
因此如果一个日志对象没有在配置文件里显式定义，则框架使用根日志中定义的属性。
在<root>标签里，可以定义level级别值和Appender的列表。
如果没有定义LEVEL的值，则缺省为DEBUG。
可以通过<appender-ref>标签定义日志对象使用的Appender对象。
<appender-ref>声明了在其他地方定义的Appender对象的一个引用。
在一个logger对象中的设置会覆盖根日志的设置。而对Appender属性来说，子日志对象则会继承父日志对象的Appender列表。
这种缺省的行为方式也可以通过显式地设定<logger>标签的additivity属性为false而改变。
<logger name="testApp.Logging" additivity="false">
</logger>
Additivity的值缺省是true.
3.1.2 <Logger>
<logger name="testApp.Logging">
<level value="DEBUG"/>
</logger>
<logger> 元素预定义了一个具体日志对象的设置。
然后通过调用LogManager.GetLogger(“testAPP.Logging”)函数，你可以检索具有该名字的日志。
如果LogManager.GetLogger(…)打开的不是预定义的日志对象，则该日志对象会继承根日志对象的属性。
知道了这一点，我们可以说，其实<logger>标签并不是必须的。
3.1.3 <appender>
<appender name="LogFileAppender"
type="log4net.Appender.FileAppender" >
<param name="File" value="log-file.txt" />
<param name="AppendToFile" value="true" />
<layout type="log4net.Layout.PatternLayout">
<param name="Header" value="[Header]\r\n" />
<param name="Footer" value="[Footer]\r\n"/>
<param name="ConversionPattern"
value="%d [%t] %-5p %c - %m%n"
/>
</layout>
<filter type="log4net.Filter.LevelRangeFilter">
<param name="LevelMin" value="DEBUG" />
<param name="LevelMax" value="WARN" />
</filter>
</appender>
在<root>标签或单个的<logger>标签里的Appender对象可以用<appender>标签定义。
<appender>标签的基本形式如上面所示。
它定义了appender的名字和类型。 另外比较重要的是<appender>标签内部的其他标签。
不同的appender有不同的<param>标签。在这里，为了使用FileAppender,你需要一个文件名作为参数。
另外还需要一个在<appender>标签内部定义一个Layout对象。
Layout对象定义在它自己的<layout>标签内。
<layout>标签的type属性定义了Layout的类型(在本例里是PatternLayout)，同时也确定了需要提供的参数值。
Header和Footer标签提供了一个日志会话(logging session)开始和结束时输出的文字。
有关每种appender的具体配置的例子，可以在log4net\doc\manual\example-config-appender.html中得到。
3.1.4 log4net.Layout.PatternLayout中的转换模式(ConversionPattern)
%m(message):输出的日志消息，如ILog.Debug(…)输出的一条消息
%n(new line):换行
%d(datetime):输出当前语句运行的时刻
%r(run time):输出程序从运行到执行到当前语句时消耗的毫秒数
%t(thread id):当前语句所在的线程ID
%p(priority): 日志的当前优先级别，即DEBUG、INFO、WARN…等
%c(class):当前日志对象的名称，例如：
模式字符串为：%-10c -%m%n
代码为：
ILog log=LogManager.GetLogger(“Exam.Log”);
log.Debug(“Hello”);
则输出为下面的形式：
Exam.Log - Hello
%L：输出语句所在的行号
%F：输出语句所在的文件名
%-数字：表示该项的最小长度，如果不够，则用空格填充
例如，转换模式为%r [%t]%-5p %c - %m%n 的 PatternLayout 将生成类似于以下内容的输出：
176 [main] INFO org.foo.Bar - Located nearest gas station.
3.1.5 <filter>
最后，让我们看看在Appender元素里的<filter>标签。它定义了应用到Appender对象的过滤器。
本例中，我们使用了LevelRangeFilter过滤器,它可以只记录LevelMin和LevelMax参数指定的日志级别之间的日志事件。
可以在一个Appender上定义多个过滤器（Filter）,这些过滤器将会按照它们定义的顺序对日志事件进行过滤。
其他过滤器的有关信息可以在log4net的SDK文档中找到。
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |
