Swift中类的初始化器与继承

Safety check 1A designated initializer must ensure that all of the properties introduced by its class are initialized before it delegates up to a superclass initializer.

 

As mentioned above, the memory for an object is only considered fully initialized once the initial state of all of its stored properties is known. In order for this rule to be satisfied, a designated initializer must make sure that all its own properties are initialized before it hands off up the chain.

 

Safety check 2A designated initializer must delegate up to a superclass initializer before assigning a value to an inherited property. If it doesn’t, the new value the designated initializer assigns will be overwritten by the superclass as part of its own initialization.Safety check 3A convenience initializer must delegate to another initializer before assigning a value to any property (including properties defined by the same class). If it doesn’t, the new value the convenience initializer assigns will be overwritten by its own class’s designated initializer.Safety check 4An initializer cannot call any instance methods, read the values of any instance properties, or refer to selfas a value until after the first phase of initialization is complete.

 

The class instance is not fully valid until the first phase ends. Properties can only be accessed, and methods can only be called, once the class instance is known to be valid at the end of the first phase.

 

Here’s how two-phase initialization plays out, based on the four safety checks above:

 

Phase 1

 

• A designated or convenience initializer is called on a class.
• Memory for a new instance of that class is allocated. The memory is not yet initialized.
• A designated initializer for that class confirms that all stored properties introduced by that class have a value. The memory for these stored properties is now initialized.
• The designated initializer hands off to a superclass initializer to perform the same task for its own stored properties.
• This continues up the class inheritance chain until the top of the chain is reached.
• Once the top of the chain is reached, and the final class in the chain has ensured that all of its stored properties have a value, the instance’s memory is considered to be fully initialized, and phase 1 is complete.

Phase 2

 

• Working back down from the top of the chain, each designated initializer in the chain has the option to customize the instance further. Initializers are now able to access self and can modify its properties, call its instance methods, and so on.
• Finally, any convenience initializers in the chain have the option to customize the instance and to work with self.

Here’s how phase 1 looks for an initialization call for a hypothetical subclass and superclass:

 

 

In this example, initialization begins with a call to a convenience initializer on the subclass. This convenience initializer cannot yet modify any properties. It delegates across to a designated initializer from the same class.

 

The designated initializer makes sure that all of the subclass’s properties have a value, as per safety check 1. It then calls a designated initializer on its superclass to continue the initialization up the chain.

 

The superclass’s designated initializer makes sure that all of the superclass properties have a value. There are no further superclasses to initialize, and so no further delegation is needed.

 

As soon as all properties of the superclass have an initial value, its memory is considered fully initialized, and Phase 1 is complete.

 

Here’s how phase 2 looks for the same initialization call:

 

 

The superclass’s designated initializer now has an opportunity to customize the instance further (although it does not have to).

 

Once the superclass’s designated initializer is finished, the subclass’s designated initializer can perform additional customization (although again, it does not have to).

 

Finally, once the subclass’s designated initializer is finished, the convenience initializer that was originally called can perform additional customization.

 

构造器的继承和重写

 

Unlike subclasses in Objective-C, Swift subclasses do not not inherit their superclass initializers by default. Swift’s approach prevents a situation in which a simple initializer from a superclass is automatically inherited by a more specialized subclass and is used to create a new instance of the subclass that is not fully or correctly initialized.

 

If you want your custom subclass to present one or more of the same initializers as its superclass—perhaps to perform some customization during initialization—you can provide an overriding implementation of the same initializer within your custom subclass.

 

If the initializer you are overriding is a designated initializer, you can override its implementation in your subclass and call the superclass version of the initializer from within your overriding version.

 

If the initializer you are overriding is a convenience initializer, your override must call another designated initializer from its own subclass, as per the rules described above in Initializer Chaining.

 

 

NOTE

 

Unlike methods, properties, and subscripts, you do not need to write the override keyword when overriding an initializer.

 

构造器自动继承

 

As mentioned above, subclasses do not not inherit their superclass initializers by default. However, superclass initializers are automatically inherited if certain conditions are met. In practice, this means that you do not need to write initializer overrides in many common scenarios, and can inherit your superclass initializers with minimal effort whenever it is safe to do so.

 

Assuming that you provide default values for any new properties you introduce in a subclass, the following two rules apply:

 

Rule 1If your subclass doesn’t define any designated initializers, it automatically inherits all of its superclass designated initializers.Rule 2If your subclass provides an implementation of all of its superclass designated initializers—either by inheriting them as per rule 1, or by providing a custom implementation as part of its definition—then it automatically inherits all of the superclass convenience initializers.

These rules apply even if your subclass adds further convenience initializers.

 

 

NOTE

 

A subclass can implement a superclass designated initializer as a subclass convenience initializer as part of satisfying rule 2.

 

指定初始化和便捷初始化的语法

 

Designated initializers for classes are written in the same way as simple initializers for value types:

 

Convenience initializers are written in the same style, but with the convenience keyword placed before the initkeyword, separated by a space:

 

指定初始化和便捷初始化实战

 

下面的例子演示的是指定构造器，便捷构造器和自动构造器继承的实战。例子中定义了三个类分别叫Food，RecipeIngredient和ShoppingListItem，并给出了他们的继承关系。

 

基类叫做Food，是一个简单的类只有一个name属性：

 

下图就是Food类的构造链：

 

 

类不存在成员逐一构造器，所以Food类提供了一个指定构造器，使用参数name来完成初始化：

 

init(name:String)构造器就是Food类中的指定构造器，因为它保证了每一个Food实例的属性都被初始化了。由于它没有父类，所以不需要调用super.init()构造器。

 

Food类也提供了便捷构造器init()，这个构造器没有参数，仅仅只是将name设置为了[Unnamed]：

 

下一个类是Food的子类，叫做RecipeIngredient。这个类描述的是做饭时候的配料，包括一个数量属性Int类型，然后定义了两个构造器：

 

下图表示这两个类的构造链：

 

RecipeIngredient类有它自己的指定构造器init(name: String, quantity:Int)，用来创建一个新的RecipeIngredient实例。在这个指定构造器中它调用了父类的指定构造器init(name:String)。

 

然后它还有一个便捷构造器，init(name)，它使用了同一个类中的指定构造器。当然它还包括一个继承来的默认构造器init()，这个构造器将使用RecipeIngredient中的init(name: String)构造器。

 

RecipeIngredient also defines a convenience initializer, init(name: String), which is used to create aRecipeIngredient instance by name alone. This convenience initializer assumes a quantity of 1 for anyRecipeIngredient instance that is created without an explicit quantity. The definition of this convenience initializer makes RecipeIngredient instances quicker and more convenient to create, and avoids code duplication when creating several single-quantity RecipeIngredient instances. This convenience initializer simply delegates across to the class’s designated initializer.

 

Note that the init(name: String) convenience initializer provided by RecipeIngredient takes the same parameters as the init(name: String) designated initializer from Food. Even though RecipeIngredient provides this initializer as a convenience initializer, RecipeIngredient has nonetheless provided an implementation of all of its superclass’s designated initializers. Therefore, RecipeIngredient automatically inherits all of its superclass’s convenience initializers too.

 

In this example, the superclass for RecipeIngredient is Food, which has a single convenience initializer calledinit(). This initializer is therefore inherited by RecipeIngredient. The inherited version of init() functions in exactly the same way as the Food version, except that it delegates to the RecipeIngredient version of init(name: String) rather than the Food version.

 

上述三种构造器都可以用来创建RecipeIngredient实例：

 

最后一个类是ShoppingListItem继承自RecipeIngredient，它又包括了另外两个属性，是否已购买purchased，描述description，描述本身还是一个计算属性：

 

注意：ShoppingListItem没有定义构造器来初始化purchased的值，因为每个商品在买之前purchased都是默认被设置为没有被购买的。

 

因为ShoppingListItem没有提供其他构造器，那么它就完全继承了父类的构造器，用下图可以说明：

 

你可以在创建ShoppingListItem实例时使用所有的继承构造器：

 

通过输出可以看出所有的实例在创建的时候，属性的默认值都被正确的初始化了。

 

6、通过闭包或者函数来设置一个默认属性值

 

如果存储属性的默认值需要额外的特殊设置，可以使用闭包或者函数来完成。

 

闭包或者函数会创建一个临时变量来作为返回值为这个属性赋值。下面是如果使用闭包赋值的一个示意代码：

 

需要注意的是在闭包结尾有两个小括号，告诉Swift这个闭包是需要立即执行的。

 

注意：如果你时候闭包来初始化一个属性，在闭包执行的时候，后续的一些属性还没有被初始化。在闭包中不要访问任何后面的属性，一面发生错误，也不能使用self属性，或者其它实例方法。

 

下面的例子是一个叫Checkerboard的结构，是由游戏Checkers来的

 

这 个游戏是在一个10×10的黑白相间的格子上进行的。来表示这个游戏盘，使用了一个叫Checkerboard的结构，其中一个属性叫 boardColors，是一个100个Bool类型的数组。true表示这个格子是黑色，false表示是白色。那么在初始化的时候可以通过下面的代码 来初始化：

  

当一个新的Checkerboard实例创建的时候，闭包会执行，然后boardColor的默认值将会被依次计算并且返回，然后作为结构的一个属性。通过使用squareIsBlackAtRow工具函数可以检测是否被正确设置：