1）类，对象，方法
类
类名：
1) 类名的第一个字母必须是大写
2) 不能有下划线
3) 多个英文单词，用驼峰标识
类的声明和实现
类的声明
@interface 类名 : NSObject
{
@public
成员变量；
}
方法声明;
@end
类的实现
@implementation 类名
方法实现;
@end
举例说明：
- //Horse类的声明
- @interface Horse : NSObject
- {
- @public //使成员变量可以让外部访问
- //定义成员变量color，weight
- charchar *color;
- int weight;
- }
- //方法声明(方法前必须加减号’-’且数据类型必须加括号())
- - (void)eat;
- @end
- //类的实现
- @implementation Horse
- - (void)eat
- {
- NSLog(@"%s色，体重为%d的马吃草，",color,weight);
- }
常见错误：OC语言编译时与C语言相同，一样是从上到下顺序编译，所以如果 类的声明和实现写在后面会报错，可以将类声明单独提到调用前的位置，也可将类声明和实现都提上去
对象
对象的创建
- //创建一个Horse类的对象s
- Horse *s=[Horse new];
- //给对象s的属性的赋值，用符号：->
- s->color="red";
- s->weight=200;
- <pre name="code" class="objc">//使用对象s调用方法eat
- [s eat];
1) 在OC中，要调用对象，就必须使用指针
创建对象：类名 *p=[类名 new];
- //创建一个Horse类的对象s
- Horse *s=[Horse new];
匿名对象：[[类名 new] 对象方法];红色部分即为匿名对象
- //创建并使用匿名对象调用eat方法
- [[Horse new] eat];
OC语言中，对象分配内存后，系统并不自动回收，直到程序结束或手动回收
2) 在OC中，要执行一些行为（方法），就必须写上一个中括号[行为执行者 行为名称]
- //使用对象s调用方法eat
- [s eat];
方法
方法即对象的行为
1) 方法：方法名、参数、返回值（同样是声明和实现）
2) 只要是OC对象的方法，必须以减号’-’开头
3) OC方法中任何数据类型都必须用小括号()扩住
方法的声明和实现
1) 有返回值无参数的方法
声明：
- - (int)eat; //返回int类型
实现：
- - (int)eat
- {
- 方法体;
- }
2) 带参数且有返回值的方法
- 带一个参数
声明：
- - (double) squre:(double)number;
实现：
- - (double) squre:(double)number
- {
- 方法体;
- }
- 带多个参数
声明：
- -(double)sumOfNum1:(double)number1 andNum2:(double)num2;
实现：
- -(double)sumOfNum1:(double)number1 andNum2:(double)num2
- {
- 方法体;
- }
解读：
- - (double)sumOfNum1:(double)number1andNum2:(double)num2;
方法前减号’-’：表明方法类型，对象方法为减号’-'
减号后double：表示返回数据类型
(sumOfNum1: andNum2:)括号里为方法名，注意包括冒号：
冒号后double：表示参数类型
number1：表示参数名
方法调用
[对象指针 方法名];
如：[c sumOfNum1:10 andNum2：21];
方法总结：
OC方法中，一个参数对应一个冒号
冒号:也是方法名的一部分
方法中有多个参数时，要有多个冒号，且官方标准冒号前应该多写变量注释，即方法名尽量详细描述方法功能
封装
封装基本介绍
set方法
作用：提供一个方法给外界设置成员变量的值，可以在方法里面对参数进行相应过滤
命名规范：
1) 方法名必须以set开头
2) set后面跟上成员变量的名称，成员变量首字母必须大写
3) 返回值一定是void
4) 一定会接受一个参数，且参数类型跟成员变量类型一致
5) 形参名称不能跟成员变量一样
get方法
作用：返回对象内部的成员变量
命名规范：
1) 一定有返回值，返回值类型一定与成员变量类型一致
2) 方法名跟成员变量类型一致（区别于其他语言以get开头，苹果官方不建议如此）
3) 不会接受参数
封装的好处
实现成员变量的只读（即：可以只提供get方法）
成员变量的命名规范
命名规范：一定要以下划线_开头
作用：
1) 让成员变量和get方法的名称区分开
2) 可以跟局部变量区分开，看到下划线开头的变量，一般即为成员变量
弱语法
OC在运行过程中才会检测对象是否实现相应的方法（区别于C语言在链接时检测）
OC语言中，当类和对象方法的声明以及实现在main()函数前面时：
1) 类声明可以缺失，仅报warning
2) 方法声明也可以缺失，正常运行
注：声明在main()前，实现在main()后市，缺失会直接报错
类方法
基本使用
1) 类方法以加号’+’开头
2) 直接用类名调用
类方法与对象方法
对象方法
1) 减号’-’开头
2) 只能由对象调用
3) 对象方法中能访问当前对象的成员变量（实例变量）
类方法
1) 加号’+’开头
2) 只能由类（名）来调用
3) 类方法中不能访问成员变量（实例变量）
类方法的好处和使用场合
好处：
1) 不依赖于对象，执行效率高
2) 能用类方法，尽量用类方法
使用场合：当方法内部不需要使用到成员变量 时，就可以改为类方法
工具类
工具类：基本没有成员变量，里面的方法基本都是类方法的类
self（本质是一个指针）
self概念：指向当前方法调用者（在对象方法中指向当前调用对象，在类方法中指向当前类）
格式：
[self 方法名];
使用时注意死循环（方法内部不能用self调用本身）
继承
基本使用
OC中继承用冒号’:’
继承的好处
1) 抽取重复代码
2) 建立了类之间的关系
3) 子类拥有父类中的所有成员成员变量和方法
重写：
子类重新实现父类中的某个方法，覆盖以前的做法
使用注意：
1) 父类必须声明在子类的前面
2) 子类不能拥有和父类相同的成员变量
3) 调用某个对象方法时，优先去当前对象中找，如果找不到，去父类中找
继承和组合
继承：A是B（类）
组合：A拥有B（类）即：B类为A类的成员变量
继承-super
super的作用
1) 直接调用父类中的某个方法
2) Super在对象方法中，那么就会调用父类的对象方法；super在类方法中时，那么就会调用父类的类方法
3) 使用场合：子类重写父类的方法时想保留父类的一些行为的时候
多态（父类指针指向子类对象）
基本使用
动态绑定：调用方法时会检测指向的真实对象
多态的好处
当多个函数调用多个子类的相同对象方法时，可以利用多态将多个函数写为一个函数
多态的局限性
局限性：不能用父类类型的指针直接调用子类特用的方法（会报warning，可通过强制类型转换后使用）
强制类型转换：
- Animal *a=[Dog new];
- //强制将Animal类型的指针a转换为Dog类型的指针a并赋值给d
- Dog *d=(Dog *)a;
多态总结
1) 没有继承就没有多态
2) 代码体现：父类类型的指针指向子类对象
3) 好处：如果函数/方法参数中使用的是父类类型，既可以传入父类对象，又可以传入子类对象
4) 局限性（同上）
开发技巧
NSSting（NSString是一个字符串类）
基本使用;字符串输出时，格式输出符为’%@’
作业讲解
1.使用类定义对象及参数的时候注意星号’*’。
2.经验写法：方法返回值为 BOOL类型时，方法名一般都以is开头。
3.当类成员变量为对象时，在为这个成员变量初始化赋值时，必须先创建对象并赋值，然后调用set方法将对象传递给该类的对象成员变量。
多文件开发
1. 定义一个类分2个文件：.h声明文件、.m实现文件
.h：包含成员变量、方法的声明（即类声明）
.m：包含方法的实现
2. 如果要使用某一个类，只需要#import类的.h文件即可。
Xcode功能演示
1. Xcode断点调试功能
即：可以在程序代码中任意行设置任意个断点调试程序，可实现代码逐行执行，并能查看执行结果。
2. Xcode代码段保存功能
即：可以将复用频率高的代码块保存起来以便以后直接调用。
长按左键实现
3. Xcode注释标记功能
#pragma mark 注释语句（或作为书签标记用）
对后面的一个方法进行注释
#pragma mark –注释语句
加‘-’ 后Xcode会将后面所有的方法进行注释，直到遇到下一个加‘-’ 的注释，这样即可实现代码的分类注释。
4. Xcode多文件同时查看功能
Xcode可以同时查看多个文件。
如:同时查看.h和.m文件。
核心语法
点语法（编译器特性）
1. 点语法基本使用
本质：点语法本质是调用set和get方法。
2. 点语法使用注意
Person *p=[Person new];
OC中点语法:
p.age=10就等同于[p setAge:10]调用set方法
Int a=p.age等同于[p age]调用get方法
使用过程中set方法和get方法表示上都为p.age，具体调用哪个方法编译器会。通过判断是否赋值区别
由于点语法为方法调用，使用过程中注意不要在方法内使用点语法调用本身方法，会造成死循环
成员变量的作用域
1. OC中，成员变量的作用域分以下四种：
@public (公开的)在有对象的前提下，任何地方都可以直接访问。
@protected （受保护的，默认情况下就是受保护的）只能在当前类和子类的对象方法中访问
@private （私有的）只能在当前类的对象方法中才能直接访问
@package (框架级别的)作用域介于私有和公开之间，只要处于同一个框架中就可以直接通过变量名访问
2. 成员变量作用域使用注意
OC中没有类声明，只有类实现，也可以定义一个类。（知道即可，一般没人这样写），且定义在类实现implementation中的成员变量默认为私有的，即时加上@public也不能在任何地方访问，因为其他文件只导入.h文件，在其他文件中这些成员变量是不可见的（除非类实现implementation写在了main()函数的前面，这时main()函数可以调用）。
类实现implementation中定义成员变量时，不能重复定义声明中的成员变量。
@property和@synthesize
@property
Xcode编译器中使用@property可以自动生成成员变量的set和get方法的声明。
如：成员变量为：int _age;
则@property int age ;语句就表示同时声明了setAge和getAge方法，等价于：
- - (void)setAge:(int)age;
- - (int)age;
解读@property int age ;
int位置为所要声明的成员变量的数据类型
age位置为所要声明的set方法中传入的形参名称
@synthesize
Xcode编译器中使用@sythesize可以自动成员变量的set和get方法的实现。
如：成员变量为：int age;
则@synthesize age=_age;语句表示同时实现了set和get方法，等价于：
- - (void)setAge(int)age
- {
- _age=age;
- }
- - (int)age
- {
- return _age;
- }
解读@synthesize age = _age;
=等号左边的age表示生成声明为age的方法
=等号右边的_age表示访问_age成员变量
@property和@synthesize的最简写法
Xcode4.2以后版本呢，编译器支持一句@property同时完成-成员变量在声明中的定义-成员变量set和get方法的声明-成员变量set和get方法的实现。
如：@interface Car:NSObject
@property int speed;
@end
@implementation Car
@end
则以上代码可正常运行，编译器会自动生成-成员变量在声明中的定义（自动生成_speed变量，但自动生成的变量为私有的private）-成员变量set和get方法的声明-成员变量set和get方法的实现。
使用细节
@synthesize细节
@synthesize speed=_speed;
生成的实现方法访问_speed变量
@synthesize speed;
生成的实现方法默认访问speed变量，如果没有speed变量，编译器会自动生成speed变量，且生成的speed变量默认为private类型
当类中已存在方法实现时，编译器不会生成对应的方法，且如果类中set和get方法同时存在时，编译器将不会自动生成speed变量
@property细节
默认情况下，自动生成的set和get方法访问带下划线_的成员变量
万能指针-id
OC中，id为万能指针，可以指向任何对象。
本质：id相当于(NSObject *)
- id a=[Car new]; //定义了一个指向车对象的指针a
构造方法
1. 基本概念
构造方法：用来初始化对象成员变量的方法，是一个对象方法。
构造方法init存在于NSObject类中
2. 重写构造方法和自定义构造方法
- 重写构造方法：
目的：为了让对象一创建出来，成员变量就有一些固定的值
Person类中：
- - (id) init
- {
- //重写父类NSObject中init方法前，必须先调用父类init方法初始化父类中的一些成员变量和其他属性
- if(self=[super init])
- {
- _age=10;
- }
- return self;
- }
- 自定义构造方法：
目的：可以在自定义一些值，使对象一创建出来，成员变量就拥有这些值
Person中：
- //自定义初始化方法，使人对象一创建出来，就拥有名字和年龄
- - (id)initWithName:(NSString *) name andAge:(int) age
- {
- //必须先调用[super init];
- if(self=[super init])
- {
- _name=name;
- _age=age;
- }
- return self;
- }
- 子类自定义构造方法
Student中（此类继承Person类，_name及_age变量继承之Person，_no为Student自身变量）：
- //自定义初始化方法，使学生对象一创建出来，就拥有名字、年龄和学号
- - (id)initWithName:(NSString *) name andAge(int) age andNo(int)no
- {
- //调用父类的initWithName: andAge方法，将传进来的name和age交给父类处理
- if(self=[super initWithName: name andAge: age])
- {
- _no=no;
- }
- return self;
- }
总结：谁的成员变量，调用谁的自定义构造方法进行初始化
分类（Category）
分类作用：在不改变原来类内容的前提下，为类增加一些方法
基本介绍
分类定义：
//声明
@interface 类名（分类名称）
@end
//实现
@implementation 类名（分类名称）
@end
- //创建类Person的分类
- #import "Person.h"
- //分类声明
- @interface Person (PersonOther)
- @end
- #import "Person+PersonOther.h"
- //分类实现
- @implementation Person (PersonOther)
- @end
分类使用注意：
-
分类只能增加方法，不能增加成员变量
-
分类方法实现中可以访问原来类中声明的成员变量(除private外都可访问)（编程测试是否能访问@property编译自动生成的成员变量---已测不能访问）
-
分类可以重新实现原来类中的方法，但是会覆盖调原来的方法，导致原来方法无法使用（一般不建议这样写）。
-
编译运行时方法调用优先级：分类->原来类->父类
-
一个类有多个分类时，优先级由编译器编译顺序决定
利用分类给系统自带的类增加方法
目前学到的系统的类有：NSString、NSObject
例：给NSSring添加类方法和对象方法
- //给NSString添加计算字符串中数字个数的对象方法和类方法
- #import <Foundation/Foundation.h>
- @interface NSString (NSStringOther)
- //对象方法声明
- - (int)stringOfNumCount;
- //类方法声明
- + (int)stringOfNumCount:(NSString *)str;
- @end
- #import "NSString+NSStringOther.h"
- @implementation NSString (NSStringOther)
- //对象方法实现
- - (int)stringOfNumCount
- {
- int count=0;
- for (int i=0; i<self.length; i++) {
- if ([self characterAtIndex:i]>='1'&&[self characterAtIndex:i]<='9') {
- count++;
- }
- }
- return count;
- }
- //类方法实现
- + (int)stringOfNumCount:(NSString *)str
- {
- int count=0;
- for (int i=0; i<str.length; i++) {
- if ([str characterAtIndex:i]>='1'&&[str characterAtIndex:i]<='9') {
- count++;
- }
- }
- return count;
- }
- @end
注意：
OC中字符串@”zhang123”就是一个对象，可以[@”zhang123” 对象方法]直接调用对象方法
类的本质
- 类的本质：类本身也是一个对象，是一个Class类型的对象，简称类对象
- 类的深入研究---类对象的使用
利用类对象调用class方法创建类
例：Person类
Class c=[Person class]; 则：c现在就等价于Person类
注意：Class本身就包含星号 *
也可以利用Person的实例对象调用class方法创建类
例：Person *p=[[person alloc] init];
Class c1=[p class]; 则：c1现在也等价于Person类
- 类的深入研究---类的加载和初始化
程序一旦启动，就会加载项目中所有的类和分类（加载：自我认为是给类分配内存空间？），而且加载后会调用所有类和分类的+load方法
当第一次使用某个类时，就会调用当前类的+initialize方法（只有第一次会调用，只调用一次）
总是先加载父类，再加载子类（先调用父类的+load方法，再调用子类的+load方法）一定发生
总是先初始化父类，再初始化子类（先调用父类的+initialize方法，再调用子类的initialize方法）用才初始化，当然如果用子类则父类也一定会先初始化，只用父类时，子类并不初始化