OC的类、构造方法、单利对象总结

1、 类的优雅使用。（类方法不能访问成员变量、不能调用对象的方法）

先来简单区分一下：

//对象的方法
- (void)print;
//类的方法
+ (void)print;

一般创建类，我们都是为了更加好用的调用该类里面的方法。

一般使用是先 #import "xxxx.h" ，引入。然后 ，初始化。像下面这样：

  Cal *cal = [[Cal alloc] init];
  // 调用方法
  int suq1 = [cal mulNum1:5 widthNum2:6];

这样使用是OK 的。那么 有没有一种 更加优雅的 调用方式呢？
有！
使用类方法。

下面使用一个：求 2个数的和 、乘积！说明。
我们可以定义一个类， 里面定义好方法。（它的优雅在于：在本类里 自己就初始化了）。

- (int)pushNum1:(int)num1 andNum:(int)num2
{
    return num1+num2;
}
- (int)mulNum1:(int)num1 widthNum2:(int)num2
{
    return num2*num2;
}

+ (int)sumOfSquareWithNum1:(int)num1 andNum2:(int)num2
{
    Cal *cal = [[Cal alloc] init];
    int squl1 = [cal mulNum1:num1 widthNum2:num2];
    int squl2 = [cal mulNum1:num2 widthNum2:num2];
    int sum = [cal pushNum1:squl1 andNum:squl2];
    return sum;
}
 

那么这样有什么好处？

#import "Cal.h"
// 调用 类方法
int sum = [Cal sumOfSquareWithNum1:5 andNum2:6];

看到了吗，这样写起来是不是很简洁，而且还可以保持调用的类里面会比较简洁。

2、 构造方法的使用。

构造：就是 创建一个可以实例化自己的所有属性使用的方法，并且把自己返回。

那么它的好处又是什么？
先来看一下这个写发吧！看了你就知道了。

- (Cat *)init
{
    // 调用父类的方法
    self = [super init];
    // [super init] 是用于初始化父类那一部分成员变量
    // 如果初始化失败就会返回nil,否则返回当前对象的地址
    if (self != nil) {
        _name = "晓";
    }
    
    return self;
}

- (Cat *)initWithColor:(char *)color
{
    self = [super init];
    if (self != nil) {
        _color = color;
    }
    return self;
}
- (Cat*)initWithName:(char *)name andColor:(char*)color
{

    self = [super init];
    if (self != nil) {
        _name = name;
        _color = color;
    }
    
    return self;
}

- (void)printInfo
{
    NSLog(@"颜色：%s 颜色：%s",_name,_color);
}

怎么使用呢？
直接使用改类调用（苹果的官网的api封装也类似）。

  Cat *cat = [[Cat alloc] init];

  // 构造方法，在初始化的时候 调用(在类创建对象时调用。这里和set 方法不同)
  Cat *langMao = [[Cat alloc] initWithName:"langMao" andColor:"Blue"];
  [langMao printInfo];

3、单利对象（传值）离不开的 static

要记得：
你要创建一个(静态的类)，并且初始化。（和构造方法不一样哦！[super init]）

+ (Class *)defaultCar
{
    //class 指针创建时为nil
    static Class * class;
    if (car == nil) {
        class = [[Class alloc] init]; // 初始化
    }
    return class;
}

作用：创建单例对象,单例对象可以用于传值。或者创建某个对象太耗费资源又经常使用时，也会创建单例对象。

static 声明静态变量，生命周期整个程序运行期间都可以使用

这个有点像 前端 Vuex 的原理。
就是先 创建一个 “商店”。然后，引入 需要的“商品”。最后，拿去交换（买卖）。

1、创建商店 CarStore

// 引入“商品”
#import "Car.h"
// 有类方法
+ (void)printBrand;

2、创建商品 (丰富多彩) Car

@interface Car : NSObject
{
    char * _brand;
}
+ (Car*)defaultCar;
- (void)setBrand:(char*)brand;
- (void)printInfo;
@end

实现“商品”的属性、用途（方法）。

@implementation Car
+ (Car *)defaultCar
{
    //car指针创建时为nil
    static Car * car;
    if (car == nil) {
        car = [[Car alloc] init];
    }
    return car;
}
- (void)setBrand:(char *)brand
{
    _brand = brand;
}
- (void)printInfo
{
    NSLog(@"cat's brand is %s",_brand);
}

3、拿去买卖.(各种买卖法)

        // 在 摆摊位（交易）
        Car * car1 = [Car defaultCar]; // defaultCar 已经封装了实例化（所以可直接调用）
        [car1 setBrand:"bmw"];
        [car1 printInfo];

        Car * car2 = [Car defaultCar];
        [car2 printInfo];        

        // 更加优雅 的使用方式（在商店里交易）
        [CarStore printBrand]; // 相当于 car2