OC-2-类方法、匿名类、封装、组合、依赖、关联、重载（对象特征）

OC中可以声明两种方法：-实例方法（对象方法）和 +类方法

对象方法：[对象名称 对象方法名称];

类方法的调用：[类名称 类方法名称]；

注意事项：

1、类方法和对象方法可以同名

2、类方法可以从父类继承，子类可以重写该方法

3、在类方法中，不能访问实例变量

4、对象方法可以调用其他的对象方法：1）当前方法中创建对象，使用对象调用

                                                                2）可以使用self

                                                                3）对象作为方法的参数传递过来

5、类方法中调用其他类方法：1）直接类名调用

                                                  2）self调用

6、类方法中调用对象方法：1）对象作为参数传递过来

                                               2）可以创建对象

7、类方法不能调用自己，会造成死循环（无限循环）

类方法优点：1、节省了内存空间， 类方法不需要使用对象，直接调用方法，节省内存

                    2、提高了效率

                    3、作为工具方法

如果我们调用一个方法，该方法不需要使用成员变量，name我们把该方法声明为类方法

---

匿名类：实质上是匿名对象

使用方法：1、使用匿名类访问实例变量（能，只能正确访问一次，以后再次访问，实际上是NEW出来的新空间）

                   2、使用匿名类，调用方法 [[类名 new] 方法]；

OC中常见的创建对象的方法

            [[Car alloc] init];        等价于  [Car new];

使用上述对象调用方法： [ [[Car alloc] init] 方法名 ]；

---

封装

面向对象四大特征：继承，封装，多态，抽象

不封装的缺点：当一个类把自己的属性暴露 （@public） 给外部的时候，那么该类就失去对属性的管理权。将数据隐藏起来，只能用此类的方法函数才可以访问或者设置数据，不可被外部任意存储是面向对象的本质，降低了数据被无用的可能！

@interface就是暴露在外面的接口，而@implementation就是隐藏内部的构造实现，把具体的实现封装起来。

封装的原理：实例变量默认只能被当前对象方法访问

封装的实现步骤：定义设置实例变量（setter）和访问实例变量（getter）的方法

1、setter方法（设置器）

     在开发过程中，不使用@public、@protected等关键字修饰，而是使用setter方法

     作用：为外界提供一个设置成员变量的方法,一定是一个对象方法

     命名规范：

          1）方法名必须以set开头

          2）set后面跟上成员变量的名称，去掉下划线，首字母大写    _age     setAge

          3）返回值void

          4）一定要接受一个参数，而且参数类型要和成员变量的类型一致

          5）形参名不能和成员变量名一样（苹果官方推荐成员变量前加_以示区分）

          6）set方法实现中，一样要用形参给实例变量赋值_age = age

     好处：1、不让数据暴露在外，保证数据的安全性

               2、对设置的数据进行过滤

#import <Foundation/Foundation.h>

typedef enum {kSexMan, kSexWoman, kSexYao} Sex;
@interface Person : NSObject
{
    // 姓名
    NSString *_name;
    // 年龄
    int _age;
    // 性别
    Sex _sex;
    // 身高
    float _height;
}
// 给每一个实例变量定义两个方法：设置变量的方法（ set ）和获取变量值的方法（ get ）
//set 设置
-( void ) setName:( NSString *) name;
-( void ) setAge:( int ) age;
-( void ) setSex:( Sex ) sex;
-( void ) setHeight:( float ) height;
//get 获取
-( NSString *) name;
-( int ) age;
-( Sex ) sex;
-( float ) height;

@end

2、getter方法（访问器）

     Get方法作用：为调用者返回对象内部的成员变量

     命名规范：1、一定有返回值，返回值类型与成员变量类型一致

                        2、方法名与成员变量名一样（去掉_的成员变量名）

                        3、不需要接受任何参数

                          4、get方法实现中，一定是返回实例变量值

#import "Person.h"

@implementation Person
// 实现
// 给每一个实例变量定义两个方法：设置变量的方法（ set ）和获取变量值的方法（ get ）
//set 设置
-( void ) setName:( NSString *) name {
    // 给实例变量赋值
    _name = name;
}
-( void ) setAge:( int ) age {
   
    _age = age;
}
-( void ) setSex:( Sex ) sex {
   
    _sex = sex;
}
-( void ) setHeight:( float ) height {
   
    _height = height;
}
//get 获取
-( NSString *) name {
   
    return _name ;
}
-( int ) age {
   
    return _age ;
}
-( Sex ) sex {
   
    return _sex ;
}
-( float ) height {
   
    return _height ;
}

@end

调用：

#import <Foundation/Foundation.h>
#import "Person.h"

int main( int argc, const char * argv[]) {
    @autoreleasepool {
       
        Person *p = [[ Person alloc ] init ];
       
        // 设置名称
        [p setName : @" 陈子超 " ];
        NSLog ( @"%@" , [p name ]);
       
        [p setAge : 24 ];
        NSLog ( @"%d" , [p age ]);
       
        [p setSex : kSexMan ];
        NSLog ( @"%d" , [p sex ]);
       
        [p setHeight : 1.70 ];
        NSLog ( @"%.2f" , [p height ]);
       
    }
    return 0 ;

}

---

对象与对象之间的关系：组合，依赖，关联

组合模式

组合关系：把具有相同基类类型的对象组合到树形结构中，以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

依赖关系：A对象作为B对象的局部变量或是方法的形参，B依赖与A，这时A与B是一种依赖关系

//Girl类

#import <Foundation/Foundation.h>
#import "Iphone.h"

@interface Girl : NSObject
-( void ) callPhoneToTuHao:( Iphone *) iphone;
-( void ) sendMessageToHao:( Iphone *) iphone;

@end

#import "Girl.h"

@implementation Girl
-( void ) callPhoneToTuHao:( Iphone *) iphone {
   [iphone setPhoneNum : @"18611865797" ];
}
-( void ) sendMessageToHao:( Iphone *) iphone {
   [iphone setPhoneNum : @"18611865797" ];
}

@end

//Iphone类

#import <Foundation/Foundation.h>

@interface Iphone : NSObject
{
    NSString *_phoneNum;
}
-( void ) setPhoneNum:( NSString *) phoneNum;

// 打电话
-( void ) callPhone;
// 发短信
-( void ) sendMessage;

@end

#import "Iphone.h"

@implementation Iphone
-( void ) setPhoneNum:( NSString *) phoneNum {
    _phoneNum = phoneNum;
}

// 打电话
-( void ) callPhone {
    NSLog ( @" 美女给土豪 %@ 打电话，说： FUCK me!" , _phoneNum );
}
// 发短信
-( void ) sendMessage {
    NSLog ( @" 美女给土豪 %@ 发短信，说： Go on!" , _phoneNum );
}

@end

//调用

Iphone *iphone7Plus = [ Iphone new ];
       
        Girl *girl = [ Girl new ];
       
        // 美女使用电话
        //girl 依赖电话
        [girl callPhoneToTuHao :iphone7Plus];
       
        // 电话取去打电话、发短信
        [iphone7Plus callPhone ];

        [iphone7Plus sendMessage];

面向对象设计中：

1、耦合度：当修改一个对象的时候，对另一个对象影响的程度

2、低耦合：当修改一个对象的时候对其他对象影响比较小

3、高内聚：一个对象仅仅做自己相关的事情

4、面向对象设计原则：单一职责原则

关联关系：HasA关系，当一个对象拥有另一个对象的时候。 B对象为A对象的成员变量的时候，B与A之间存在一种关联关系。

     例如：人拥有一条狗对象

关联关系是面向对象中最常用一种关系。关联关系的耦合度要高于依赖关系。

1、一对一：一夫一妻制

2、一对多：班级与学生，一个班级可以有多个学生

3、多对多：学生与课程，一个学生可以学习夺门课程，一门课程可以被多个学生选择

#import <Foundation/Foundation.h>
#import "Ipad.h"

/*
 Person 类
  属性：姓名   iPad 对象
  方法：设置姓名，设置 iPad ，听歌
 */
@interface Person : NSObject
{
    NSString *_name;
   
    // 人有一台 ipad
    Ipad *_ipad;
}
// 设置姓名
-( void ) setName:( NSString *) name;
//ipad
-( void ) setIpad:( Ipad *) ipad;
// 听音乐
-( void ) listenMusic;

@end

#import "Person.h"

@implementation Person
// 设置姓名
-( void ) setName:( NSString *) name {
    _name = name;
}
//ipad
-( void ) setIpad:( Ipad *) ipad {
    _ipad = ipad;
}
// 听音乐
-( void ) listenMusic {
    [ _ipad playMusic ];
}

@end

#import <Foundation/Foundation.h>

/*
 ipad 类
  属性：名称
  方法：设置名称，播放音乐，播放视频，玩游戏
 */
@interface Ipad : NSObject
{
    NSString *_name;
}
-( void ) setName:( NSString *) name;
//iPad 功能
-( void ) playMusic;
-( void ) playMovie;
-( void ) playGame;

@end

#import "Ipad.h"

@implementation Ipad
-( void ) setName:( NSString *) name {
    _name = name;
}
//iPad 功能
-( void ) playMusic {
    NSLog ( @" 正在用 %@ 播放音乐 " , _name );
}
-( void ) playMovie {
    NSLog ( @" 正在用 %@ 播放视频 " , _name );
}
-( void ) playGame {
    NSLog ( @" 正在用 %@ 玩游戏 " , _name );
   
}

@end

//调用

#import <Foundation/Foundation.h>
#import "Person.h"

int main( int argc, const char * argv[]) {
    @autoreleasepool {
       
        // 创建 ipad
        Ipad *ipad5 = [ Ipad new ];
        [ipad5 setName : @"ipad5" ];
       
        // 创建人
        Person *p = [[ Person alloc ] init ];
        [p setName : @" 陈子超 " ];
        [p setIpad :ipad5];
        [p listenMusic ];
    }
    return 0 ;

}

---

Xcode文档在线安装： Xcode→reference→Download

xcode文档（后缀：.docset）离线安装：Contents-Developer-Documentation-Docsets复制过来

---

方法的重载：指在一个类中定义多个同名的方法，但要求每个方法具有不用的参数类型或参数个数。方法重载通常用于创建完成一组任务相似单参数类型或个数不同的方法。

OC中没有方法重载

OC中static关键字的使用：

1、在C中，没有初始化的静态变量存在BSS段，初始化的静态变量存在数据区。

2、修饰静态局部变量可以延长生命周期。

3、静态全局变量只能在当前文件中使用

误区：1、在OC中，继承了C的使用

2、实例变量不能用static修饰

3、方法也不可以用static修饰