标签：
------- IOS培训、android培训、java培训、期待与您交流！ ----------
封装：
将实现细节进行隐藏，将属性私有化，通过公共的方法访问私有的属性，这个过程就是对对象的封装
好处：1.给数据进行了过滤，保证数据的正确性
2.增加了代码的重用性
3.将属性进行了私有化，可以保证属性的安全性
set方法
1、作用：提供一个方法给外界设置成员变量值，可以在方法里面对参数进行相应过滤
2、命名规范：
1、方法名必须以set开头
2、set后面跟上成员变量的名称，成员变量的首字母必须大写
3、返回值一定是void
4、一定要接收一个参数，而且参数类型跟成员变量类型一致
5、形参的名称不能跟成员变量名一样
1 -(void)setAge:(int)newAge;
get方法
1、作用：返回对象内部的成员变量
2、命名规范：
1、肯定有返回值，返回值类型肯定与成员变量类型一致
2、方法名跟成员变量名一样
3、不需要接收任何参数
成员变量的命名规范
成员变量都以下划线 _ 开头
可以跟get方法的名称区分开
可以跟其他局部变量区分开，一看到下划线开头的变量，肯定是成员变量
代码编写：
1 #import <Foundation/Foundation.h> 2 3 // 声明 4 5 @interface Car : NSObject 6 7 { 8 9 int _wheels; // 轮子个数 10 11 } 12 13 // set方法 14 15 - (void)setWheels: (int)wheels; 16 17 // get方法 18 19 - (int)wheels; 20 21 22 23 @end 24 25 @implementation Car 26 27 // set方法的实现 28 29 - (void)setWheels: (int)wheels 30 31 { // 对外面传进来的轮子进行过滤 32 33 if(wheels<=0) 34 35 { 36 37 wheels = 1; 38 39 } 40 41 _wheels = wheels; 42 43 } 44 45 // get方法的实现 46 47 - (int)wheels 48 49 { 50 51 return _wheels; 52 53 } 54 55 @end 56 57
匿名对象代码编写：
1 int main(int argc, const char * argv[]) 2 3 { 4 5 //实名对象，用同类的指针保存了对象的地址 6 7 Cat *cat1 = [Cat new]; 8 9 [Cat new];//匿名对象，只是通过new创建了一个对象出来 10 11 12 13 cat1->_name = @"加菲猫"; 14 15 [Cat new]->_name = @"好猫"; 16 17 //打印的是空，因为每new一次创建一个新的对象 18 19 [[Cat new] lookMyCat]; 20 21 22 23 //匿名对象的作用 24 25 //1.当调用使用次数很少的方法的时候，就直接使用匿名对象调用。 26 27 Cat *cat2 = [Cat new]; 28 29 [cat2 lookMyCat]; 30 31 32 33 [[Cat new] lookMyCat]; 34 35 36 37 //2.匿名对象可以作为参数传递，当不需要给传递的对象的成员变量赋值的时候，就使用匿名对象作为参数传递 38 39 //Cat *cat3 = [Cat new]; 40 41 // cat3->_name = @"xiao"; 42 43 Person *person1 = [Person new]; 44 45 [person1 feedCat:[Cat new]]; 46 47 48 49 //作用：节省代码，节省内存 50 51 return 0; 52 53 } 54 55
继承：
定义:有两个类A类与B类，如果说A类继承了B类，就说A类拥有了B类的所有属性和方法。
继承者叫子类 被继承者叫父类（超类）
继承是单继承，只有一个直接的父类，一个父类可以有多个子类
优点：
1、节省代码，抽取重复代码。
2、建立了类之间的关系。
3、子类可以拥有父类中的所有成员变量和方法。
由于对象之间有了继承关系，才会有多态。
缺点：耦合性太强（依赖性太高）
重写：继承中，子类重新写父类中的方法，重写只存在于继承中
注意点：
1、父类必须声明在子类的前面
2、子类不能拥有和父类相同的成员变量
3、调用某个方法时，优先去当前类中找，如果找不到，去父类中找。
继承的使用场合：
1、当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取到一个父类中
2、当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类
组合模式：
一个对象作为另一个对象的成员变量
优点：节省了代码，使两个类产生了关系
缺点：依赖性太高（耦合性太高）
场合：当可以用“谁属于谁”这种方式来表述的时候，就可以用组合模式
利用代码块儿快速生成代码
方法：< + # +代替的部分+#+> 这样这一部分就会变成可编辑的
继承跟组合的区别：
1 @interface Score : NSObject 2 3 { 4 5 int _cScore; 6 7 int _ocScore; 8 9 } 10 11 @end 12 13 @implementation Score 14 15 @end 16 17 18 19 // 继承：*** 是 *** 20 21 // 组合：*** 拥有 *** 22 23 @interface Student : NSObject 24 25 { 26 27 //组合 28 29 Score *_score; 30 31 // int _cSore; 32 33 // int _ocScore; 34 35 int _age; 36 37 } 38 39 @end 40 41
多态：
1、没有继承就没有多态
2、代码的体现：父类类型的指针指向子类对象
3、好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象
4、局限性：
父类类型的变量不能直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法。
1 int main() 2 3 { 4 5 // 多态：父类指针指向子类对象 6 7 Animal *a = [Dog new]; 8 9 //[a run]; 不能指向子类方法 10 11 return 0; 12 13 }
动态绑定：调用方法时会检测对象的真实形象。
代码编写：
1 int main() 2 3 { 4 5 // Dog *d = [Dog new]; //Dog类型 6 7 8 9 // 多态：父类指针指向子类对象 10 11 Animal *a = [Dog new]; 12 13 14 15 // 动态绑定：调用方法时会检测对象真实形象 16 17 [a eat]; 18 19 return 0; 20 21 }
标签：
原文地址：http://www.cnblogs.com/zhangxining/p/4198068.html
