7

我读了其他一些关于它的主题，但我仍然迷路了。

我想创建 2 种对象，一种只有“只读”属性的不可变对象，一种只有“读写”属性的可变对象。

让我们称它们为 EXCar 和 EXMutableCar。

EXCar 是 NSObject 的子类，EXMutableCar 是 EXCar 的子类。

ExCar 将在其界面中

@property (nonatomic, strong, readonly) NSString *name;

EXMutableCar 将在其界面中

@property (nonatomic, strong) NSString *name;

因此，当我使用它的子类 EXMutableCar 时，我“打开”了 EXCar 的属性。然后它是可变的。问题是在它们之间正确复制。

我在 EXCar 中实现了 mutableCopyWithZone ：

- (id)mutableCopyWithZone:(NSZone *)zone {
    EXMutableCar *mutableCopy = [[EXMutableCar allocWithZone:zone] init];
    mutableCopy.name = _name;

    return mutableCopy;
}

第一个问题，这是做这件事的好方法吗？（我要燕子副本）

问题在于copyWithZone。由于 EXCar 的属性是只读的，我既不能在 EXCar 中创建，也不能在 EXMutableCar 中创建 EXCar 的新实例并像这样填充其属性：

- (id)copyWithZone:(NSZone *)zone {
    EXCar *copy = [[EXCar allocWithZone:zone] init];
    copy.name = _name; // This can't work...

    return copy;
}

而且我真的不想做一个带有 15 个属性的“init”方法来传递（当然，EXCar 就是一个例子，真正的类充满了许多属性）。通常它们是从服务器的 JSON 消息启动的，因此它们不需要复杂的 init 方法。

第二个问题是这样，如何做一个让我的班级不可变的 copyWithZone ？

谢谢你的帮助 ：）

4

1 回答 1

9

代码：

// EXCar.h
#import <Foundation/Foundation.h>

@interface EXCar : NSObject <NSCopying, NSMutableCopying>

@property (nonatomic, strong, readonly) NSString* name;

@end

// EXCar.m
#import "EXCar.h"
#import "EXMutableCar.h"

@implementation EXCar

- (id)copyWithZone:(NSZone *)zone {
  EXCar* car = [[[self class] allocWithZone:zone] init];
  car->_name = [_name copyWithZone:zone];
  return car;
}

- (id)mutableCopyWithZone:(NSZone *)zone {
  EXMutableCar* mutableCar = [[EXMutableCar allocWithZone:zone] init];
  mutableCar.name = [_name mutableCopyWithZone:zone];
  return mutableCar;
}

@end

// EXMutableCar.h
#import "EXCar.h"

@interface EXMutableCar : EXCar

@property (nonatomic, strong) NSString* name;

@end

// EXMutableCar.m
#import "EXMutableCar.h"

@implementation EXMutableCar

@synthesize name = _mutableName;

- (id)copyWithZone:(NSZone *)zone {
  EXMutableCar* car = [super copyWithZone:zone];
  car->_mutableName = [_mutableName copyWithZone:zone];
  return car;
}

- (id)mutableCopyWithZone:(NSZone *)zone {
  EXMutableCar* car = [super mutableCopyWithZone:zone];
  car->_mutableName = [_mutableName mutableCopyWithZone:zone];
  return car;
}

解释：

  • EXCar接口实现了两个“复制”协议；
  • 子类EXMutableCar覆盖相同的属性，使其成为readwrite.

实现的第一件事EXMutableCar：手动@synthesize name，因为 Xcode 给了我们一个警告，因为我们在我们的超类中具有相同的属性（但具有不同的访问说明符）。

请注意，我们可以为实例变量赋予相同的名称，例如_name，但重要的是要理解我们在子类中声明了一个不同的变量，因为_name我们无法从超类访问。

接下来，Apple 文档指出：

如果子类从其超类继承 NSCopying 并声明了额外的实例变量，则子类必须重写copyWithZone:以正确处理其自己的实例变量，首先调用超类的实现。

NSMutableCopying 相同：

如果子类从其超类继承 NSMutableCopying 并声明了其他实例变量，则子类必须重写mutableCopyWithZone:以正确处理其自己的实例变量，首先调用超类的实现。

我们确实声明了额外的实例变量，因此我们也在子类中覆盖了这些方法。

结果：

EXCar* car = [[EXCar alloc]init]; // car.name is (null)
EXCar* carCopy = [car copy]; // we can do this
EXMutableCar* mutableCar = [car mutableCopy]; // and this
mutableCar.name = @"BMW";
car = [mutableCar copy]; // car.name is now @"BMW"
EXMutableCar* anotherMutableCar = [car mutableCopy]; //anotherMutableCar.name is @"BMW"
于 2014-08-07T15:57:37.920 回答