一、点语法
（一）认识点语法
声明一个Fraction类:
#import <Foundation/Foundation.h>
@interface Fraction : NSObject
{
int _numerator;
int _demominator;
}
- (void) setNumerator:(int)numerator;
- (int) numerator;
- (void) setDemominator:(int)demominator;
- (int) demominator;
@end
Fraction类的实现：
#import "Fraction.h"
@implementation Fraction
- (void) setNumerator:(int)numerator
{
_numerator = numerator;
}
- (int) numerator
{
return _numerator;
}
- (void) setDemominator:(int)demominator
{
_demominator = demominator;
}
- (int) demominator
{
return _demominator;
}
@end
点语法的使用：
#import <Foundation/Foundation.h>
#import "Fraction.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
Fraction *fraction = [[Fraction allo] init];
fraction.numerator = 10;//点语法，等效与[Fraction setNumerator:10];
//这里并不是给fraction的属性赋值，而是调用fraction的setNumerator方法
int num = fraction.numerator;//等效与int num = [fraction numerator]
NSLog(@"num is %i", num);
}
return 0;
}
（二）点语法的作用
OC设计点语法的目的，是为了让其他语言的开发者可以很快的上手OC语言开发，使用点语法，让它和其他面向对象的语言如java很像。
（三）点语法的本质
点语法的本质是方法的调用，而不是访问成员变量，当使用点语法时，编译器会自动展开成相应的方法。切记点语法的本质是转换成相应的set和get方法，如果没有set和get方法，则不能使用点语法。
如：
fraction.numerator = 10;展开为：[fraction setNumerator:10];
int num=fraction.numerator;展开为：int num = [fraction numerator];
编译器如何知道是set方法还是get方法？主要是看赋值（可以使用断点调试来查看）。
在OC中访问成员变量只有一种方式即使用-> 如fraction->_numerator，这种情况要求在@public的前提下。
（四）点语法的使用注意
下面的使用方式是一个死循环：
(1)在set方法中，self.numeraor=numerator;
相当于是[self setNumerator:numerator];
(2)在get方法中，return self.numerator;相当于是[self numerator];
二、变量作用域
（一）变量的作用域主要分为四种：
（1）@public (公开的)在有对象的前提下，任何地方都可以直接访问。
（2）@protected （受保护的）只能在当前类和子类的对象方法中访问
（3）@private （私有的）只能在当前类的对象方法中才能直接访问
（4）@package (框架级别的)作用域介于私有和公开之间，只要处于同一个框架中就可以直接通过变量名访问
（二）使用注意和补充
（1）在类的实现即.m文件中也可以声明成员变量，但是因为在其他文件中通常都只是包含头文件而不会包含实现文件，所以在这里声明的成员变量是@private的。在.m中定义的成员变量不能喝它的头文件.h中的成员变量同名，在这期间使用@public等关键字也是徒劳的。
（2）在@interface @end之间声明的成员变量如果不做特别的说明，那么其默认是protected的。
（3）一个类继承了另一个类，那么就拥有了父类的所有成员变量和方法，注意所有的成员变量它都拥有，只是有的它不能直接访问。
类的三大特性
1，类的封装
类的封装可以理解为：
一块表，我们只要能从中获取时间值对我门来说便已经足够，我们不必要知道它内部的运行方式。同理，我们设计一个类，没有必要让外界知道我们的内部实现，只要能满足外部需要的功能即可。
类封装的好处：
第一:重用;
我们可以在封装方法后，对象可以多次调用方法，而不用每次都去写该方法。
第二:不必关心具体的实现;
程序员只管直接使用。
第三:面向对象三大特征之一，
模块化，可以很好的区分及应用。类的封装时面向对象的基础概念风格，就是把每个对象的东西装在一起，如果像某些人说的把说有对象方法，都放在一个箱子里的话，那么将很难团队合作分工，改需求时也很难改。
第四,具有安全性
封装好后，我们并不知道类中是怎么实现的。只是简单的使用了该方法。
第五：
封装后可以修改类的内部实现，而无需修改使用了该类的客户代码（即坏了容易替换，不影响全局）
第六：
封装后可以对成员进行更精确的控制，例如将某个成员设置为只读的。
2.类的继承
继承的基本概念
我们想要创建一个猫类和一个狗类。猫类和狗类有一些相同的成员变量和对象方法，这种情况下，我们可以创建一个动物对象，让猫和狗都继承这个对象
声明部分如下：
#import <Foundation/Foundation.h>
@interface Animal : NSObject
{
double _weight;
int age;
}
- (void) setWeight:(double) weight andAge:(int)age;
- (void) print;
@end
#import "Animal.h"
@interface Dog : Animal
- (double) weight;
@end
#import "Animal.h"
@interface Cat : Animal
- (int) age;
@end
在狗类中增加了获取体重的方法，在猫类中增加了获取年龄的方法
继承的使用注意
（1）编译器从上往下执行，所以在子类前面至少应该要有父类的声明；
（2）OC中不允许子类和父类拥有相同名称的成员变量名；
（3）OC中的子类可以拥有和父类相同名称的方法，在子类调用时，优先去自己的内部寻找，如果没有则一层一层的往上找；
重写即子类重新实现了父类中的某个方法，覆盖了父类以前的实现。
继承和组合
继承的适用场合：
（1）当两个类拥有相同的属性和方法时，就可以将相同的属性和方法抽取到一个父类中。
（2）当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类（考虑），在这种情况下，也可以考虑使用组合。
继承：###是xxx,如狗是动物，可以让狗继承动物类
组合：###拥有xxx，如学生有书，可以让书这个类作为学生类的属性
关键字super
Super关键字，在子类中重写方法时，可以让调用者跳过这一层而调用父类中的方法。
作用：
（1）直接调用父类中的某一个方法
（2）Super处在对象方法中，那么就会调用父类的对象方法；super处于类方法中，那么就会调用父类的类方法。
使用场景：子类在重写父类方法时，想要保留父类的一些行为。
抽象类
有时，创建类知识使创建子类更容易。因此，这些类名为抽象类。比如，Foundation框架里的NSNumber类是为了将数字作为对象处理而创建的抽象类
三，类的多态
一、基本概念
多态在代码中的体现，即为多种形态，必须要有继承，没有继承就没有多态。
在使用多态是，会进行动态检测，以调用真实的对象方法。
多态在代码中的体现即父类指针指向子类对象。
#import <Foundation/Foundation.h>
@interface Animal : NSObject
- (void)eat;
@end
@implementation Animal
- (void)eat
{
NSLog(@"吃东西");
}
@end
@interface Dog : Animal
- (void)eat;
@end
@implementation Dog
- (void)eat
{
NSLog(@"狗在吃东西");
[super eat];
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
//父类执政指向子类对象
Animal *a = [[Dog alloc] init];
[a eat];
}
return 0;
}
多态使用总结
（1）没有继承就没有多态
（2）代码的体现：父类类型的指针指向子类对象
（3）好处：如果函数方法参数中使用的是父类类型，则可以传入父类和子类对象，而不用再去定义多个函数来和相应的类进行匹配了。
（4）局限性：父类类型的变量不能直接调用子类特有的方法，如果必须要调用，则必须强制转换为子类特有的方法。