stored - swift 4 constructor

Overriding getter en Swift

Question

Tengo una situación en la que necesito anular el administrador de una propiedad.

Digamos que tenemos:

public class MyBaseClass {
    private var _name: String
    public internal(set) var name: String {
        get {
            return self._name
        }
        set {
            self._name = newValue
        }
    }
}

Nada realmente lujoso, supongo.

Ahora, si intento anular el getter en una clase derivada:

public class MyDerivedClass: MyBaseClass {
    public var name: String {
        get {
            return "Derived - /(super.name)"
        }
    }
}

Recibo el error de compilación: no se puede anular la propiedad mutable con la propiedad ''solo nombre'' .

Si intento agregar el setter y anularlo:

public class MyDerivedClass: MyBaseClass {
    public internal(set) var name: String {
        get {
            return "Derived - /(super.name)"
        }
        set {
            super.name = newValue
        }
    }
}

Me sale el error: Setter of overriding var debe ser tan accesible como la declaración que invalida .

Y si intento lo siguiente:

public class MyDerivedClass: MyBaseClass {
    public internal(set) var name: String {
        get {
            return "Derived - /(super.name)"
        }
    }
}

Entonces, el compilador se bloquea ...

¿Cómo puedo lograr anular solo el getter?

Answer 1

Problema 1

MyBaseClass no compila porque:

1. tiene una propiedad almacenada (_nombre)
2. esta propiedad almacenada no es opcional por lo que no puede ser nula
3. no hay inicializador para poblarlo

Primero que todo, necesitamos agregar un inicializador adecuado a MyBaseClass

public class MyBaseClass {
    private var _name: String
    public internal(set) var name: String {
        get { return self._name }
        set { self._name = newValue }
    }
    init(name : String){
        _name = name
    }
}

Problema 2

Ahora podemos declarar MyDerivedClass que reemplaza la propiedad calculada:

1. Necesitamos usar la palabra clave mágica anular
2. Necesitamos proporcionar tanto al colocador como al captador.

Aquí está el código:

public class MyDerivedClass: MyBaseClass {
    public override var name: String {
        get { return "Derived - /(super.name)" }
        set { super.name = newValue }
    }
}

Prueba

Desde mi patio de recreo:

let somethingWithAName = MyDerivedClass(name: "default name")
println(somethingWithAName.name) // > "Derived - default name"
somethingWithAName.name = "another name"
println(somethingWithAName.name) // > "Derived - another name"

Answer 2

Esto funciona para mí:

    public class MyBaseClass {
        private var _name: String = "Hi"
        public internal(set) var name: String {
            get {
                return self._name
            }
            set {
                self._name = newValue
            }
        }
    }

    public class MyDerivedClass:MyBaseClass {
        override public var name: String {
            get {
                return "Derived - /(super.name)"
            }
            set {
                super._name = newValue
            }
        }
    }

    MyDerivedClass().name

EDITAR

Este código funciona para mí en un área de juegos, colocándolo en el archivo Sources -> SupportCode.swift

    public class MyBaseClass {
    private var _name: String = "Hi"
    public internal(set) var name: String {
        get {
            return self._name
        }
        set {
            self._name = newValue
        }
    }
    public init() {

    }

    }

    public class MyDerivedClass:MyBaseClass {
        override public var name: String {
            get {
                return "Derived - /(super.name)"
            }
            set {
               // do nothing
            }
        }
       public override init() {

        }
    }

Es un poco extraño porque recibo la misma advertencia que usted de que internal(set) no puede colocarse antes de la variable de subclase anulada. Bien puede ser un error. Y también estoy engañando para asegurarme de que el establecedor de la clase derivada no haga nada.

Un uso más común de internal(set) o private(set) es tener un código como este, que es similar al de la documentación:

public class MyBaseClass {
    public private(set) var _name: String = "Hi"
    public var name: String {
        get {
            return self._name
        }
        set {
            self._name = newValue
        }
    }
    public init() {

    }

}

public class MyDerivedClass:MyBaseClass {
    override public var name: String {
        get {
            return "Derived - /(super.name)"
        }
        set {
           super._name = newValue
        }
    }
   public override init() {

    }
}

Aquí, el definidor se puede leer directamente con MyDerivedClass()._name pero no se puede modificar, por ejemplo, MyDerivedClass()._name = "Fred" generaría un error pero MyDerivedClass().name = "Fred" estaría bien.