Erro na classe Swift: propriedade não inicializada na chamada super.init

Eu tenho duas aulas ShapeeSquare

class Shape {
    var numberOfSides = 0
    var name: String
    init(name:String) {
        self.name = name
    }
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class Square: Shape {
    var sideLength: Double

    init(sideLength:Double, name:String) {
        super.init(name:name) // Error here
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Com a implementação acima, recebo o erro:

property 'self.sideLength' not initialized at super.init call
    super.init(name:name)

Por que eu tenho que definir self.sideLengthantes de ligar super.init?

Cite a linguagem de programação Swift, que responde sua pergunta:

“O compilador da Swift realiza quatro verificações de segurança úteis para garantir que a inicialização em duas fases seja concluída sem erros:”

Verificação de segurança 1 “Um inicializador designado deve garantir que todas as“ propriedades introduzidas por sua classe sejam inicializadas antes de delegar um inicializador de superclasse ”.

Trecho de: Apple Inc. “A linguagem de programação Swift”. iBooks. https://itunes.apple.com/us/book/swift-programming-language/id881256329?mt=11

O Swift tem uma sequência muito clara e específica de operações que são feitas nos inicializadores. Vamos começar com alguns exemplos básicos e avançar até um caso geral.

Vamos pegar um objeto A. Vamos defini-lo da seguinte forma.

class A {
    var x: Int
    init(x: Int) {
        self.x = x
    }
}

Observe que A não possui uma superclasse, portanto, não pode chamar uma função super.init () porque ela não existe.

OK, agora vamos subclassificar A com uma nova classe chamada B.

class B: A {
    var y: Int
    init(x: Int, y: Int) {
        self.y = y
        super.init(x: x)
    }
}

Este é um desvio do Objective-C, onde [super init]normalmente seria chamado primeiro antes de qualquer outra coisa. Não é assim em Swift. Você é responsável por garantir que suas variáveis ​​de instância estejam em um estado consistente antes de fazer qualquer outra coisa, incluindo métodos de chamada (que incluem o inicializador da sua superclasse).

Dos documentos

Verificação de segurança 1

Um inicializador designado deve garantir que todas as propriedades introduzidas por sua classe sejam inicializadas antes de delegar um inicializador de superclasse.

Por que precisamos de uma verificação de segurança como esta?

Para responder a isso, vamos rapidamente ao processo de inicialização.

Inicialização bifásica

A inicialização de classe no Swift é um processo de duas fases. Na primeira fase, cada propriedade armazenada recebe um valor inicial pela classe que a introduziu. Depois que o estado inicial de cada propriedade armazenada é determinado, a segunda fase começa e cada classe recebe a oportunidade de personalizar ainda mais suas propriedades armazenadas antes que a nova instância seja considerada pronta para uso.

O uso de um processo de inicialização em duas fases torna a inicialização segura, enquanto ainda oferece flexibilidade completa a cada classe em uma hierarquia de classes. A inicialização em duas fases impede que os valores de propriedade sejam acessados ​​antes de serem inicializados e impede que valores de propriedade sejam configurados para um valor diferente por outro inicializador inesperadamente.

Portanto, para garantir que o processo de inicialização em duas etapas seja realizado conforme definido acima, há quatro verificações de segurança, uma delas é,

Verificação de segurança 1

Um inicializador designado deve garantir que todas as propriedades introduzidas por sua classe sejam inicializadas antes de delegar um inicializador de superclasse.

Agora, a inicialização em duas fases nunca fala sobre ordem, mas essa verificação de segurança é introduzida super.initapós a inicialização de todas as propriedades.

A verificação de segurança 1 pode parecer irrelevante, pois a inicialização em duas fases impede que os valores das propriedades sejam acessados ​​antes de serem inicializados , sem essa verificação de segurança 1.

Como nesta amostra

class Shape {
    var name: String
    var sides : Int
    init(sides:Int, named: String) {
        self.sides = sides
        self.name = named
    }
}

class Triangle: Shape {
    var hypotenuse: Int
    init(hypotenuse:Int) {
        super.init(sides: 3, named: "Triangle") 
        self.hypotenuse = hypotenuse
    }
}

Triangle.initfoi inicializado, todas as propriedades antes de serem usadas. Portanto, a verificação de segurança 1 parece irrelevante,

Mas então pode haver outro cenário, um pouco complexo,

class Shape {
    var name: String
    var sides : Int
    init(sides:Int, named: String) {
        self.sides = sides
        self.name = named
        printShapeDescription()
    }
    func printShapeDescription() {
        print("Shape Name :\(self.name)")
        print("Sides :\(self.sides)")
    }
}

class Triangle: Shape {
    var hypotenuse: Int
    init(hypotenuse:Int) {
        self.hypotenuse = hypotenuse
        super.init(sides: 3, named: "Triangle")
    }

    override func printShapeDescription() {
        super.printShapeDescription()
        print("Hypotenuse :\(self.hypotenuse)")
    }
}

let triangle = Triangle(hypotenuse: 12)

Resultado :

Shape Name :Triangle
Sides :3
Hypotenuse :12

Aqui, se tivéssemos chamado o super.initantes de definir o hypotenuse, a super.initchamada então chamaria o printShapeDescription()e, uma vez que isso foi substituído, ele retornaria primeiro à implementação da classe Triangle de printShapeDescription(). A printShapeDescription()classe of Triangle acessa hypotenuseuma propriedade não opcional que ainda não foi inicializada. E isso não é permitido, pois a inicialização em duas fases impede que os valores de propriedade sejam acessados ​​antes de serem inicializados.

Portanto, verifique se a inicialização em duas fases é feita conforme definido, precisa haver uma ordem específica de chamada super.init, ou seja, depois de inicializar todas as propriedades introduzidas pela selfclasse, precisamos de uma verificação de segurança 1

O "super.init ()" deve ser chamado depois que você inicializar todas as suas variáveis ​​de instância.

No vídeo "Intermediate Swift" da Apple (você pode encontrá-lo na página de recursos de vídeo do desenvolvedor Apple https://developer.apple.com/videos/wwdc/2014/ ), por volta das 28:40, é explícito que todos os inicializadores em superclasse deve ser chamado DEPOIS de inicializar suas variáveis ​​de instância.

No Objetivo-C, foi o contrário. No Swift, como todas as propriedades precisam ser inicializadas antes de serem usadas, precisamos inicializar as propriedades primeiro. Isso visa impedir que uma chamada para a função substituída seja do método "init ()" da superclasse, sem inicializar as propriedades primeiro.

Portanto, a implementação do "Square" deve ser:

class Square: Shape {
    var sideLength: Double

    init(sideLength:Double, name:String) {
        self.sideLength = sideLength
        numberOfSides = 4
        super.init(name:name) // Correct position for "super.init()"
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Desculpe pela formatação feia. Basta colocar um caractere de pergunta após a declaração e tudo ficará bem. Uma pergunta informa ao compilador que o valor é opcional.

class Square: Shape {
    var sideLength: Double?   // <=== like this ..

    init(sideLength:Double, name:String) {
        super.init(name:name) // Error here
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Edit1:

Existe uma maneira melhor de ignorar esse erro. De acordo com o comentário do jmaschad, não há razão para usar o opcional no seu caso, pois os opcionais não são confortáveis ​​no uso e você sempre deve verificar se o opcional não é nulo antes de acessá-lo. Então, tudo que você precisa fazer é inicializar o membro após a declaração:

class Square: Shape {
    var sideLength: Double=Double()   

    init(sideLength:Double, name:String) {
        super.init(name:name)
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Edit2:

Depois de dois pontos negativos nessa resposta, encontrei um caminho ainda melhor. Se você deseja que um membro da classe seja inicializado em seu construtor, deve atribuir um valor inicial a ele dentro do contratante e antes da chamada super.init (). Como isso:

class Square: Shape {
    var sideLength: Double  

    init(sideLength:Double, name:String) {
        self.sideLength = sideLength   // <= before super.init call..
        super.init(name:name)
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Boa sorte em aprender Swift.

O swift obriga a inicializar cada var de membro antes que ele seja usado. Uma vez que não se pode ter certeza do que acontece quando é a hora da virada, ocorre um erro: é melhor prevenir do que remediar

Edward,

Você pode modificar o código no seu exemplo assim:

var playerShip:PlayerShip!
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerLayerNode.addChild(playerShip)        
}

Isso está usando um opcional implicitamente desembrulhado.

Na documentação, podemos ler:

"Assim como os opcionais, se você não fornecer um valor inicial ao declarar uma variável ou propriedade opcional implicitamente desembrulhada, seu valor será padronizado automaticamente como nulo".

Swift não permitirá que você inicialize superclasse sem inicializar as propriedades, ao contrário do Obj C. Portanto, você deve inicializar todas as propriedades antes de chamar "super.init".

Acesse http://blog.scottlogic.com/2014/11/20/swift-initialisation.html . Dá uma boa explicação para o seu problema.

Adicione zero ao final da declaração.

// Must be nil or swift complains
var someProtocol:SomeProtocol? = nil

// Init the view
override init(frame: CGRect)
    super.init(frame: frame)
    ...

Isso funcionou para o meu caso, mas pode não funcionar para o seu

Você está apenas começando na ordem errada.

     class Shape2 {
        var numberOfSides = 0
        var name: String
        init(name:String) {
            self.name = name
        }
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) sides."
        }
    }

    class Square2: Shape2 {
        var sideLength: Double

        init(sideLength:Double, name:String) {

            self.sideLength = sideLength
            super.init(name:name) // It should be behind "self.sideLength = sideLength"
            numberOfSides = 4
        }
        func area () -> Double {
            return sideLength * sideLength
        }
    }

Provavelmente vou receber alguns votos negativos, mas, para ser sincero, a vida é mais fácil assim:

class CSListServerData<ListItem: CSJsonData>: CSServerData {
    var key: String!
    var type: ListItem.Type!
    var property: CSJsonDataList<ListItem>!

    func construct(_ key: String, _ type: ListItem.Type) -> Self {
        self.key = key
        self.type = type
        property = CSJsonDataList(self, type, key)
        return self
    }

    func construct(_ type: ListItem.Type) { construct("list", type) }

    var list: [ListItem] { property.list }
}

É um design incrivelmente estúpido.

Considere algo como isto:

.
.
.
var playerShip:PlayerShip
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerShip = PlayerShip(pos: CGPointMake(self.size.width / 2.0, 100))
    playerLayerNode.addChild(playerShip)        
}
.
.
.

Isso é inválido, conforme observado acima. Mas assim é:

.
.
.
var playerShip:PlayerShip = PlayerShip(pos: CGPointMake(self.size.width / 2.0, 100))
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerLayerNode.addChild(playerShip)        
}
.
.
.

Porque 'self' não foi inicializado.

Espero sinceramente que esse bug seja corrigido em breve.

(Sim, eu sei que eu poderia criar um objeto vazio e depois definir o tamanho, mas isso é estúpido).