blocks|key|148580|text|不，你没必要这么做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|148581|假设您有以下类。|148582|class+a+{
++++let+name:+String

++++init()+{
++++++++name+=+"james"
++++}
}

class+b:+a+{
++++let+title:+String

++++override+init()+{
++++++++title+=+"supervisor"
++++}
}|code-block|syntax|javascript|148583|如果使用实例化变量|148584|let+myVar+=+b()|offset|length|style|CODE|148585|然后,|148586|b中的|148587|override+init()将称为|unordered-list-item|148588|，而a中的init()将称为|148589|148590|即使您没有显式调用super.init()。|148591|148592|Chris+Laettner在快速用户的电子邮件列表中证实了这一点。当你的超类只有一个带有零参数初始化的指定初始化器时，它就开始起作用了。这就是为什么从NSObject派生时不必调用super.init()的原因。|148593|*感谢Wingzero在下面的评论|148594|entityMap^0|0|0|0|0|0|F|0|0|0|1|0|0|F|0|2|1|5|6|0|0|9|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1C|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1D|8|@$M|1E|N|1F|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1H|8|@$M|1I|N|1J|O|P]]|9|@]|A|$]]|$1|U|3|V|5|W|7|1K|8|@$M|1L|N|1M|O|P]]|9|@]|A|$]]|$1|X|3|Y|5|W|7|1N|8|@$M|1O|N|1P|O|P]|$M|1Q|N|1R|O|P]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1T|8|@$M|1U|N|1V|O|P]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|1X|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|18|$]]

No, you don't have to.

Assume you have the following classes.

<pre><code>class a {
 let name: String

 init() {
 name = "james"
 }
}

class b: a {
 let title: String

 override init() {
 title = "supervisor"
 }
}
</code></pre>

If you instantiate a variable with 

<code>let myVar = b()</code>

Then,

<ul>
<li><code>override init()</code> in <code>b</code> will be called</li>
<li>then the <code>init()</code> in <code>a</code> will be called</li>
</ul>

Even though you didn't explicitly call <code>super.init()</code>.

<hr>

This has been confirmed by Chris Laettner on the swift-user's email list.
It kicks in when your super class has a single designated initializer with a zero-argument init. This is why you don’t have to call super.init() when deriving from NSObject.

*Thanks to Wingzero's comment below

blocks|key|151353|text|从文档中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|151354|151355|指定的初始值设定项必须从其直接超类调用指定的初始值设定项。|blockquote|151356|151357|151358|另外，关于自动初始化器继承：|151359|151360|假设您为在子类中引入的任何新属性提供默认值，则适用以下两个规则：|151361|151362|规则1如果你的子类没有定义任何指定的初始值设定项，它会自动继承所有超类指定的初始值设定项。|offset|length|style|BOLD|151363|规则2如果您的子类提供其所有超类指定的初始化器的实现-通过按照规则1继承它们，或者通过提供自定义实现作为其定义的一部分-那么它将自动继承所有超类便利初始化器。|151364|即使您的子类添加了更方便的初始值设定项，这些规则也适用。|151365|151366|因此，你的问题的答案如下：|151367|您的子类将始终调用您的父类的指定初始值设定项。如果您没有编写初始化器，并且编译器没有错误，那么它使用了自动初始化器继承。如果你写了一个初始化器，但它没有显式地调用相关的上游(或侧流)初始化器，那么它将在你的初始化器结束时自动为你完成。|151368|此外，链式初始化器的工作方式是一个两阶段的过程。在第一阶段，它从子类开始到超类，为任何参数分配默认值。在第二阶段，该过程向后运行，从超类开始，以子类结束，在子类中完成参数的自定义并被覆盖。|151369|这意味着您必须首先在每个init()中设置变量，然后可以自由调用(或不调用)+super.init()并运行自定义代码。因此，正如你上面所问的，如果你想让超级程序的初始化在开始时运行，那么“开始”就在你创建变量之后：|CODE|151370|class+a+{
++++var+name:+String

++++init()+{
++++++++name+=+"james"
++++++++println("a")
++++}
}

class+b:+a+{
++++let+title:+String

++++override+init()+{
++++++++title+=+"supervisor"
++++++++super.init()
++++++++self.name+=+"john"
++++++++println("b")
++++}
}

let+x+=+b()|code-block|syntax|javascript|151371|这将打印a，然后打印b。|151372|entityMap^0|0|0|0|0|0|0|0|0|0|0|3|0|0|3|0|0|0|0|0|0|C|6|13|C|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1L|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|K|3|L|5|E|7|1N|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1P|8|@$P|1Q|Q|1R|R|S]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1S|8|@$P|1T|Q|1U|R|S]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1V|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1X|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|20|8|@$P|21|Q|22|R|16]|$P|23|Q|24|R|16]]|9|@]|A|$]]|$1|17|3|18|5|19|7|25|8|@]|9|@]|A|$1A|1B]]|$1|1C|3|1D|5|6|7|26|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|1F|$]]

From the docs:

<blockquote>
 Designated initializers must call a designated initializer from their immediate superclass.
</blockquote>

Also, regarding automatic initializer inheritance:

<blockquote>
 Assuming that you provide default values for any new properties you
 introduce in a subclass, the following two rules apply:
 
 Rule 1 If your subclass doesn’t define any designated initializers, it
 automatically inherits all of its superclass designated initializers.
 
 Rule 2 If 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.
</blockquote>

So the answer to your question is as follows:

Your subclass will always call a designated initializer of your superclass. If you don't write an initializer and the compiler doesn't complain, then it has used automatic initializer inheritance. And if you do write an initializer but it doesn't explicitly call a relevant upstream (or sidestream) initializer, it will be done for you automatically at the end of your initializer.

Furthermore, the way chained initializers work is in a 2-phase process. In the first phase, it starts from the subclasses towards superclasses, assigning default values to any parameters. In the second phase, the process is run backwards, starting with superclasses and ending with your subclass, where the customization of parameters is done and overridden.

This means that you must absolutely first in each <code>init()</code> set your variables, and then you're free to call (or not) the <code>super.init()</code> and run custom code. So as you asked above, if you want the super's init to run at the beginning, consider the 'beginning' to be just after your creating your variables:

<pre><code>class a {
 var name: String

 init() {
 name = "james"
 println("a")
 }
}

class b: a {
 let title: String

 override init() {
 title = "supervisor"
 super.init()
 self.name = "john"
 println("b")
 }
}

let x = b()
</code></pre>

This will print a, then b.

blocks|key|152722|text|是的，指定的初始化器需要向上委托，所以它必须调用super.init()。如果您不编写这行代码，编译器将为您编写代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|152723|因此，您不必显式编写super.init(...)，但子类必须显式编写，即使只是在幕后。|offset|length|style|CODE|152724|但请记住，在第一阶段中，您需要设置子类中的属性，然后必须调用super.init()。在第二阶段，您可以更改所有继承的属性。我认为super.init()是第一阶段和第二阶段之间的完美分隔符。|152725|从文档中：|152726|152727|安全检查2|blockquote|152728|152729|在为继承的属性赋值之前，指定的初始值设定项必须将委托给超类初始值设定项。如果不为，则指定的初始化器分配的新值将被超类覆盖为，作为其自身初始化的一部分。|BOLD|152730|entityMap^0|0|A|F|0|1T|C|0|0|0|0|0|C|C|14|L|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|14|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|16|8|@$D|17|E|18|F|S]|$D|19|E|1A|F|S]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|U|$]]

Yes the designated initializer need to delegate up, so it must call the super.init().
If you don't write the line, the compiler will do it for you.
So you do not have to explicitly write <code>super.init(...)</code>, but the subclass has to, even if only behind the curtain.
But remember, in the first phase you need to set the properties in the subclass, then the super.init() must be called. In the second phase you may change all the inherited properties. I think <code>super.init()</code> is a perfect separator between phase 1 and phase 2.
From the docs:
<blockquote>
Safety check 2
A 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.
</blockquote>

blocks|key|149963|text|我觉得你没必要打电话给超级。我试着模拟如下场景：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|149964|class+Animal+{
}

class+Parrot:+Animal+{

++++override+init()+{
++++++++//+Some+code+(super+not+called)
++++}
}|code-block|syntax|javascript|149965|但是，我建议始终在实际应用中调用super.init，就像您在Objective-C中所做的那样。|149966|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think you don't have to call super. I tried to simulate situation as follow:

<pre><code>class Animal {
}

class Parrot: Animal {

 override init() {
 // Some code (super not called)
 }
}
</code></pre>

However, i would recommend to always call super.init in real app, like you use to do in Objective-C.

If I have a swift subclass that: 

<ol>
<li>doesn't need to access <code>self</code> </li>
<li>doesn't need to access any properties on <code>self</code></li>
</ol>

Do I still have to call <code>super.init()</code> in the subclass's <code>init()</code> method?

*Note: This is a different question than the one asked and answered <a href="https://stackoverflow.com/questions/24021093/error-in-swift-class-property-not-initialized-at-super-init-call?rq=1">here on SO</a> because of the specifics listed in 1 and 2 above.

Does a swift subclass *always* have to call super.init()

Objective-C

编译器

如果我有一个swift子类：无需访问self 无需访问self上的任何属性我还需要在子类的init()方法中调用super.init()吗？*注意:由于上面1和2中列出的细节，这是一个与问答不同的问题。

问swift子类“总是”必须调用super.init()吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问swift子类“总是”必须调用super.init()吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问swift子类“总是”必须调用super.init()吗？
EN