class - gratis - ¿Por qué los inicializadores Swift no pueden llamar a los inicializadores convenientes en su superclase?

swift 4 tutorial español

Question

Considera las dos clases:

class A {
var x: Int
init(x: Int) {
self.x = x
}
convenience init() {
self.init(x: 0)
}
}
class B: A {
init() {
super.init() // Error: Must call a designated initializer of the superclass ''A''
}
}

No veo por qué esto no está permitido. Finalmente, se llama al inicializador designado de cada clase con cualquier valor que necesiten, entonces ¿por qué necesito repetirme en el init B especificando un valor predeterminado para x otra vez, cuando la conveniencia init en A bien?

Answer 1

¿Por qué no tienes dos inicializadores, uno con un valor predeterminado?

class A {
var x: Int
init(x: Int) {
self.x = x
}
init() {
self.x = 0
}
}
class B: A {
override init() {
super.init()
// Do something else
}
}
let s = B()
s.x // 0

Answer 2

Considerar

class A
{
var a: Int
var b: Int
init (a: Int, b: Int) {
print("Entering A.init(a,b)")
self.a = a; self.b = b
}
convenience init(a: Int) {
print("Entering A.init(a)")
self.init(a: a, b: 0)
}
convenience init() {
print("Entering A.init()")
self.init(a:0)
}
}
class B : A
{
var c: Int
override init(a: Int, b: Int)
{
print("Entering B.init(a,b)")
self.c = 0; super.init(a: a, b: b)
}
}
var b = B()

Debido a que todos los inicializadores designados de la clase A son anulados, la clase B heredará todos los inicializadores de conveniencia de A. Así que ejecutar esto dará como resultado

Entering A.init()
Entering A.init(a:)
Entering B.init(a:,b:)
Entering A.init(a:,b:)

Ahora, si el inicializador designado B.init (a: b :) podría llamar al inicializador de conveniencia de clase base A.init (a :), esto daría como resultado una llamada recursiva a B.init (a:, b: )

Answer 3

Considere la posibilidad de extraer el código de inicialización de su conveniente init() a una nueva función auxiliar foo() , invocar foo(...) para realizar la inicialización en su subclase.

Answer 4

Encontré un trabajo alrededor para esto. No es súper bonito, pero resuelve el problema de no conocer los valores de una superclase o querer establecer valores predeterminados.

Todo lo que tienes que hacer es crear una instancia de la superclase, usando la conveniencia init , justo en el init de la subclase. Luego llamas al init designado del super usando la instancia que acabas de crear.

class A {
var x: Int
init(x: Int) {
self.x = x
}
convenience init() {
self.init(x: 0)
}
}
class B: A {
init() {
// calls A''s convenience init, gets instance of A with default x value
let intermediate = A()
super.init(x: intermediate.x)
}
}

Answer 5

Es porque puedes terminar con una recursión infinita. Considerar:

class SuperClass {
init() {
}
convenience init(value: Int) {
// calls init() of the current class
// so init() for SubClass if the instance
// is a SubClass
self.init()
}
}
class SubClass : SuperClass {
override init() {
super.init(value: 10)
}
}

y mira:

let a = SubClass()

que llamará a SubClass.init() que llamará a SuperClass.init(value:) que llamará a SubClass.init() .

Las reglas de inicio designadas / de conveniencia están diseñadas para que la inicialización de una clase siempre sea correcta.

Answer 6

Esta es la Regla 1 de las reglas de "Encadenamiento del inicializador" tal como se especifica en la Guía de programación Swift, que dice:

Regla 1: los inicializadores designados deben llamar a un inicializador designado de su superclase inmediata.

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html

Énfasis mío Los inicializadores designados no pueden llamar a los inicializadores de conveniencia.

Hay un diagrama que va junto con las reglas para demostrar qué "indicaciones" de inicialización están permitidas:

Answer 7

Mire el video WWDC "403 Swift intermedio" a las 18:30 para una explicación detallada de los inicializadores y su herencia. Como lo entendí, considere lo siguiente:

class Dragon {
var legs: Int
var isFlying: Bool
init(legs: Int, isFlying: Bool) {
self.legs = legs
self.isFlying = isFlying
}
convenience initWyvern() {
self.init(legs: 2, isFlying: true)
}
}

Pero ahora considere una subclase Wyrm: Un Wyrm es un dragón sin patas ni alas. ¡Entonces el Inicializador para un Wyvern (2 patas, 2 alas) está equivocado! Ese error se puede evitar si no se puede invocar la conveniencia de Wyvern-Initializer, sino solo el inicializador completo designado:

class Wyrm: Dragon {
init() {
super.init(legs: 0, isFlying: false)
}
}