黑马程序员——ios开发基础之OC中的面向对象以及对象特性

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

第一讲

1、对象的存储细节

              对象的创建：
               Student 类
           [Student new];
          1)申请存储空间
         2）给类的成员变量初始化（基本数据类型 0 ,NSString null）
         3)返回申请的内存空间的首地址（ 8个）
      //1）创建了一个Student 类型的 指针变量 stu
     //2）使用Student 类创建了一个对象 stu
          Student *stu = [Student new];
              sizeof(stu); //8

2、对象方法和函数之间的区别

       对象方法有归属，方法是属于某一个对象
       每个对象只能调用自己对象方法
       所有函数都是平行的
       只要先声明函数，我可以在任何函数中调用其他函数

3、创建类的时候，常见的错误

       调用了一个 只是定义而没有实现的方法，会报错！

4、对象和方法之间的关系

     （1）对象作为方法的参数
               Person *p = [Person new];
              Person *p1 = [Person new];
             -(void)test:(Person *) person;
                    [p test:p1];
              //p1 -----> person
    （2）对象作为方法的返回值 
            -(Person *)test1{
                   //p3 0x40
               Person *p3 = [Person new];
               p3->_name = @"zhe";
                  return p3;
             }
                 //p4 0x40
           Person *p4 = [p test1];

5、对象作为方法的参数，连续传递

           1)枪作为方法的参数
               -(void)fireByGun:(Gun*) gun;
              -(void)fireByGun:(Gun*) gun{
                      [gun shoot];
               } 
         2）增加了 子弹的类
       -(void)fireByGun:(Gun *) gun andBullet:(Bullet *) bullet;
      -(void)fireByGun:(Gun *) gun andBullet:(Bullet *) bullet{
               [gun shoot:bullet];
          }
            //枪的方法
         -(void)shoot:(Bullet *)bullet;
        -(void)shoot:(Bullet *)bullet{
                  bullet->_bulletCount --;
          }

6、NSString的使用

              C的字符串保存：1）字符数组 2）字符串的指针
              OC中又专门的字符串处理的类（有字符串类型）
               NSString 不可变的字符串
               NSMutableString 可变字符串
               NSString 是OC字符串的类
         1) NSString保存字符串
                 NSString *str = @"abc"; //用str保存字符串常量
                          创建空字符串
                 NSString *str = [NSString new];
                          str = @"xxxx";
                格式化字符串（拼接）
                      stringWithFormat
                         字符串连接
                    NSString *str1="itcast";
                    NSString *str2 = [NSString stringWithForamt:@"welcome to %@",str1];
                   // welcome to itcast
              字符的拼装
                NSString *str3 = [[NSString alloc] initWithFormat:@"welcome %d,%f",20,2.3f];
                     // welcome 10,2.300000
                NSString *str4 = @"welcome 10,2.300000";
         2）计算NSString的字符串的长度
             [str length];
        (1) 纯英文
                NSString *str5 = @"abc"; // 3
        (2）纯中文
                //UTF-8 国际通用编码3 GB2312 国内标准2 GBK
                 NSString *str6 = @"传智播客"; //4
                 char *str7 = "传智播客"; //12 
        (3）中英文混合
                  NSString *str6 = @"传智播客xy"; //6

7、多文件开发

          多文件开发
         C的模块化开发： 把功能相似的函数，写到同一个文件中
                         .h 函数声明
                         .c 函数的实现
         OC 模块化开发： 把功能不同的类放到不同的文件中
               .h 类的声明
               .m 类的实现 （方法的实现）
         多文件开发的好处：提高代码的可读性
          如何进行多文件：
        1）new ---> new File ---> Header file(.h)---> Objective-C file (.m)
               Person.h
              规范  （1) @interface Person :NSObject
                        （2) #import <Foundation/Foundation.h>
             Person.m
                         （3）#import "Person.h" (new Cocoa Class 会自动写这句话)
                                @implmentation Person
                                @end 

        2) new ----> new File ----> Cocoa Class (同时创建.h 和 .m)

8、应用：设计一个学生类

#import <Foundation/Foundation.h>
//定义生日的结构体
typedef struct{
int year;
int month;
int day;
}MyDate;
@interface Person : NSObject
{
	@public
	NSString *_name;//定义姓名
	MyDate _birthday;//定义生日
}
@end
@implementation Person
@end

第二讲

1、类方法

         1）类方法
               对象方法：
              -(返回值类型)方法名:(形参的类型) 形参名;
               类方法
             +(返回值类型)方法名:(形参的类型) 形参名;
        2）类方法怎么去定义
           +(返回值类型)方法名:(形参的类型) 形参名;
       3）类方法的使用
                调用：
                对象方法： [对象名 方法名:实参]
                   类方法： [类名 方法名:实参]
       4）使用类方法的好处
                （1）提高效率
                （2）减少内存空间占用
                （3）代码更加简洁
                缺点：不能访问对象的成员变量
       5）对象方法和类方法的对比
                             类方法                  对象方法
                            以+开头                 以 - 开头
               只能使用 类名 去调用     只能使用对象去调用
               不能访问成员变量           可以访问成员变量
       类方法中可以调用对象方法   在对象方法中，可以直接调用类方法
       （1）对象作为方法的参数传递过来

       （2）在方法中通过创建对象，然后
              再调用

2、匿名对象的使用

                   匿名对象 -
            创建了对象，但是没有指针去指向它
                 [Person new];
            特点： 每次使用都会新申请一块内存空间
               1）可以访问成员变量
                      [Person new]->_name = @"三胖";
                      NSLog(@"%@",[Person new]->_name); //null
              2）可以调用方法
                      [[Person new] run];
              3）可以作为方法的参数
                     [p goHome:[Car new]];

3、面向对象特性-封装

            1) 封装
             把复杂的数据或者操作进行隐藏，只提供操作数据或者方法的接口
              好处：如果要操作数据、方法必须按照要求
                       （1）隐藏数据
                       （2）隔离变化
                       （3）保护数据安全
           2) 不封装有什么缺点

                      对象失去了对对象自己的成员变量的管理权
          3） 如何进行封装
                通过定义相关的方法，去读取或者写入数据到成员变量中，并且成员变量的操作必须通过方法来完成
                 （1）读方法（getter） - 读取成员变量的值
                        OC中的规范：
                               第一、一定是一个对象方法
                               第二、一定有返回值
                               第三、方法名一定是 去掉下划线的 成员变量名
                               第四、一定没有参数
                               第五、方法的实现中：一定是返回值成员变量名
                 （2）写方法（setter） - 给成员变量赋值
                       OC中的规范：
                            第一、一定没有返回值
                            第二、一定是对象方法（ -）
                            第三、方法名一定是以set开头 格式：set + 去掉下划线的成员变量名的首字母大写
                            第四、一定有参数
                            第五、参数的类型一定是和成员变量类型一致
                            第六、形参的名称一般建议是 去掉下划线的成员变量名
                            第七、写方法的实现中，一定是给成员变量赋值

4、对象和对象之间的关系

            1） 组合模式
                         由若干个类型相同或者实现了同一个接口的对象组合到一起
            2）依赖关系
                        A对象作B对象的方法形参或者方法的局部变量使用，B依赖A
           3）关联关系
                       A对象作为B对象的一个成员变量，A和B有关联关系

5、Xcode文档安装方法

           1）在线安装（需要联网，速度慢）
           2）需要自行下载离线文档包（速度快，复制文档到指定目录即可）

6、关于OC中方法重载问题

          1）方法重载，在一个类中定义同名的方法，但是方法的参数类型或者个数不同

                    OC中没有方法重载：因为“方法名:“ 才是真正的方法名

7、OC中的static关键字的使用

           1）static不能修饰类的实例变量
           2）static不能修饰类的方法
           3）static 可以修饰全局变量，但是只能在本文件中使用
           4）static 可以修饰局部变量，在方法中可以保存方法上一次的运行结果（局部变量的生命周期得到延长）

第三讲

1、 self 和 super

          self 可以用在对象和类方法中
              1） self用在对象方法中：指代的是调用当前对象方法的那个对象
              2）self用在类方法中：指代的是当前类（实质是类对象）
         总结：当self在方法中使用，谁调用这个方法， self指代的就是谁
        super

          使用super的地方，一定存在继承关系，super调用父类的方法

2、面向对象的其他特性：继承

          继承概念：
            假设有两个类： A B
           继承是两个类之间的关系
           假设声明B类的时候，
               1）导入父类的头文件
               2）设定继承关系
            @interface B : A ----> B类继承了A类
            @end
       关于继承注意事项：
              1）单一继承（一个类只能继承另外一个类）
              2）OC支持多层继承（ Animal <-----Dog <------BigYellowDog）
             3) 子类可以继承父类所有的属性和方法，使用@private 修饰的成员变量 可以被子类继承，但是不能访问
             4）子类可以直接使用从父类继承过来的属性和方法

                   子类可以调用子类的方法，也可以调用从父类的方法（super）
                   子类可以使用super调用父类的方法 
            5）父类只能调用父类自己的方法
            6）子类可以定义和父类同名的方法(方法的重写)
            7）子类不能定义和父类同名的变量
            8）方法的执行的顺序：先执行子类的--->找父类--->父。。。 -->NSObject-->报错

3、成员变量修饰符的使用

            成员变量修饰符有4个
            @public 共有的，作用域：在任何类中都可以通过对象使用成员变量
            @protected 受保护的，默认修饰，作用域：只能在当前类或者子类中使用
            @private 私有的，作用域：只能在本类（本文件）使用，可以被子类继承，但是不能在子类中使用
            @package 框架级别，只能在框架中使用

4、私有方法

         私有方法的实现：
               1）通过类别
               2）常见的书写私有方法
                 定义： .m中定义一个方法，但是没有.h中声明，那这个时候，该方法就是一个私有方法(不是真正的私有，只是被隐藏了)
       调用：在类中 [self  私有方法名];
               3）私有的变量
                  定义： 1） .m中声明的变量，是不能被继承的
                               2）
                                    @implementation xxx
                                       {
                                           //私有的成员变量
                                       }

5、 description 使用

             NSLog(@"%@",dog);
            descriptioin 方法，在我们每次以%@的形式打印对象的时候， 会默认调用的方法 
           方法有两个：
          1)-(NSString *)description;
            对象方法：
              Person *p = [Person new];
              NSLog(@"%@",p); //会调用 description 对象方法
              description应用场景：
             在子类中重写该方法，输出该对象的成员变量值。
             -(NSString *)description{
                 return [NSString stringWithFormat:@"age=%d,name=%@",_age,_name];
               }
              NSLog(@"%@",p); // age=18,name=zhangsan
          2)+(NSStiring *)description{
               }
              // [p class]----->Person(类对象)
                   NSLog(@"%@",[p class]);

6、面向对象特性:多态

           多态的概念：
                           不同的对象以自己的方式响应父类的一个方法
           多态的前提：
                            1）要有继承关系 
                            2）要有同名方法
                            3）要存在方法的重写
          多态的核心：
                     用父类的指针指向子类的对象
                 Animal *ani = [Dog new];
                   [ani run]; // dog run
         多态的注意点：
               1）如果存在多态，父类是可以访问子类特有的方法
                       假设 子类 Dog 有一个特有的方法bark
                          [dog bark];
                         Animal *an2 = [Dog new];
                         [(Dog*)an2 bark]; //把父类的指针，强制类型转换
              2）如果不存在多态，父类是不可以访问子类特有的方法的
                        Animal *an3 = [Animal new];
                       [(Dog*)an3 bark]; //错误的，不能强制转换

7、类的本质

               类的本质也是一个类类型对象（类对象）
               Person *p = [Person new]; //p是一个实例对象， p是Person类型
               Person 实质也是一个对象,又称为 类对象 
               类对象应该有类型，是Class类型的
              获取类对象的方法：
            1）Class c1 = [Person class];
                     c1 就是 Person 类对象
            2） Class c2 = [p class];

8、SEL 是一种类型

          选择器类型： 可以把一个方法包装成此类型
         通过SEL类型，可以找到 在代码区的方法的地址
         SEL s1 =@selector(eat); //把eat方法，包装成SEL类型了

第四讲

1、 OC中的点语法

             点语法： 对象名.成员变量名 （点语法不是访问成员变量，而是方法的调用）
             它是一个编译器特性
             点语法作用：可以替换传统的get和set方法的调用
         点语法的前提：首先得先有get和set方法
             点语法实质：调用get和set方法
        如果点语法出现在 = 的左边，表示设置值，相当于调用了set方法
              p.age = 10;         替换为： [p setAge:10];
        如果点语法出现在 = 的右边，表示获取值，相当于调用了get方法
             int age = p.age;      替换为： int age = [p age];
            [p dispAge:p.age];   替换为：[p dispAge:[p age]];
        注意：
            点语法实质是调用get和set方法，所以，如果没有定义成员变量的get和set方法，这个时候，是不能使用点语法的。

2、 @property使用、增强

    1） @property 在Xcode4.4之前的使用方法
            (1)只是用@property作为方法的声明
            格式： @property int age; 表示帮我们生成一个get和set age的方法
                            {
                                            int age;
                                          int _age;
                                     NSString *_name;
                              }
                        @property int age;
                          -(void)setAge:(int) age;
                           -(int)age;
                         //手工实现 get和set方法
                        -(void)setAge:(int) age{
                                    self->age = age;
                           }
                        -(int)age{
                                return age;
                          }
                      @property int _age;
                       - (void)set_age:(int) _age;
                       -(int)_age;
                     @property NSString *name;
                       -(void)setName:(NSString*) name;
                       -(NSString*)name;
        （2） @synthesize 关键字
                        @synthesize 变量名; 
                     自动帮我们实现对应的get和set方法
                       @synthesize age,_age;
                       @synthesize 相当于帮我们实现了下面的方法
                          -(void)setAge:(int) age{
                                             self->age = age;
                             }
                         -(int)age{
                                            return age;
                            }
                        @synthesize name;
        （ 3） @synthesize name = _b;
                         {
                                NSString *name;
                                NSString *_b;
                         }
                    @property NSString *name;
                    @synthesize name; // get和set方法设定的是 name的值
                    @synthesize name = _b; //相当于操作_b的值
                     -(void)setName:(NSString *) name{
                                         _b = name;
                        }
                     -(NSString *)name{
                                 return _b;
                        }
            注意：在4.4之前， @property和@synthesize成对出现 
    2） @property 在Xcode4.4之后（ @property增强）
                 增强使用：
                       @property int score;
                 1）.h文件中 帮我们声明 setScore（ setter） 和 score（ getter）方法
                 2）.m 中帮我们生成 _score的私有变量（在外部不能访问，不能被子类继承）
                 3）.m 中帮我们实现 get和set方法

3、动态类型&id类型

            动态类型：程序在运行的时候，才能确定对象属于什么类型
            静态类型：程序编译的时候，就确定了对象的类型
            动态类型的体现： 多态，父类指针可以指向子类对象
            NSObject 是所有类的基类
                  NSObject *obj = [Dog new];
                                     obj = [Person new];
              父类调用子类特有的方法
             [(Person *)obj eat];
             //id类型， id类型又被称为 万能指针。
              id obj; //运行时检查
              obj = [Car new]; //实例变量 _speed
             [obj stop];

4、动态类型检测的方法

       7个方法
            1)对象所属关系判断
                      对象是否是指定类或者子类的实例对象
                              isKindofClass
                      对象是否是指定类的实例对象
                              isMemberOfClass
                     类是否是另外一个类的子类
                              isSubclassOfClass
                               [Dog class]; Dog;
                               [d class];
           2)判断能否响应方法
                   对象是否能够响应方法
                         respondsToSelector:
                   类是否能够响应方法
                         instranceRespondsToSelector:
                          类去响应方法
          3）响应方法
                    传参数 

5、构造方法的使用

                    [Person new];
                    -> [Person alloc]; //空间申请完后，不能立即使用，有可能会导致意想不到的错误
                    -> [[Person alloc] init];
                   [Person new]; 会把我们的成员变量的值，默认的设置为0
                   init 是我们OC类的一个构造方法
                 构造方法是类创建的时候，默认调用的
                 init 是继承自 NSObject 的
                 在子类中通过重写父类的init方法，指定成员变量初始化值
                 init方法的固定格式：
                 -(id)init{
                      //初始化父类的
                     //判断是否初始化成功
                  if(self = [super init]){
                 //初始化自己的信息
                       _age = 10;
                      }
                     //返回
                   return self;
                  }

6、自定义构造方法

             如果要指定成员变量值的初始化，需要自定义构造方法 
               1）一定是对象方法
               2）返回值 一般是 id类型
               3）一定是以initWith开头
              -(id)initWithName:(NSString *) name{
                      //判断是否初始化成功
                      if(self = [super init]){
                     //初始化自己的信息
                      _name = name;
                      }
                    //返回
                  return self;
               }