precio - swift sport

Anulación de propiedad de superclase con diferente tipo en Swift

Question

En Swift, ¿alguien puede explicar cómo anular una propiedad en una superclase con otro objeto subclasificado de la propiedad original?

Toma este simple ejemplo:

class Chassis {}
class RacingChassis : Chassis {}

class Car {
    let chassis = Chassis()
}
class RaceCar: Car {
    override let chassis = RacingChassis() //Error here
}

Esto da el error:

Cannot override with a stored property ''chassis''

Si tengo un chasis como ''var'', obtengo el error:

Cannot override mutable property ''chassis'' of type ''Chassis'' with covariant type ''RacingChassis''

Lo único que pude encontrar en la guía en "Propiedades anuladas" indica que debemos anular el captador y el colocador, lo que puede funcionar para cambiar el valor de la propiedad (si es ''var''), pero ¿qué pasa con el cambio de la clase de propiedad? ?

Answer 1

Esto parece funcionar

class Chassis {
    func description() -> String {
        return "Chassis"
    }
}
class RacingChassis : Chassis {
    override func description() -> String {
        return "Racing Chassis"
    }

    func racingChassisMethod() -> String {
        return "Wrooom"
    }
}

class Car {
    let chassis = Chassis()
}
class RaceCar: Car {
    override var chassis: RacingChassis {
    get {
        return self.chassis
    }
    set {
        self.chassis = newValue
    }
    }
}

var car = Car()
car.chassis.description()

var raceCar = RaceCar()
raceCar.chassis.description()
raceCar.chassis.racingChassisMethod()

Answer 2

He visto muchas razones por las que el diseño de una API usando variables en lugar de funciones es problemático y para mí el uso de propiedades calculadas parece una solución alternativa. Hay buenas razones para mantener sus variables de instancia encapsuladas. Aquí he creado un protocolo Automóvil que el coche cumple. Este protocolo tiene un método de acceso que devuelve un objeto Chassis. Dado que Car se ajusta a ella, la subclase RaceCar puede anularla y devolver una subclase Chassis diferente. Esto permite que la clase Car se programe en una interfaz (Automóvil) y la clase RaceCar que conoce sobre RacingChassis puede acceder directamente a la variable _racingChassis.

class Chassis {}
class RacingChassis: Chassis {}

protocol Automobile {
    func chassis() -> Chassis
}

class Car: Automobile {
    private var _chassis: Chassis

    init () {
        _chassis = Chassis()
    }

    func chassis() -> Chassis {
        return _chassis
    }
}

class RaceCar: Car {
    private var _racingChassis: RacingChassis

    override init () {
        _racingChassis = RacingChassis()
        super.init()
    }

    override func chassis() -> Chassis {
        return _racingChassis
    }
}

Otro ejemplo de por qué diseñar una API utilizando variables se descompone es cuando tienes variables en un protocolo. Si desea dividir todas las funciones de protocolo en extensiones, puede hacerlo, excepto que las propiedades almacenadas no se pueden colocar en extensiones y deben definirse en la clase (para que esto se compile, debe descomentar el código en Clase AdaptableViewController y elimine la variable de modo de la extensión):

protocol Adaptable {
    var mode: Int { get set }
    func adapt()
}

class AdaptableViewController: UIViewController {
    // var mode = 0
}

extension AdaptableViewController: Adaptable {

    var mode = 0 // compiler error

    func adapt() {
        //TODO: add adapt code
    }
}

El código anterior tendrá este error de compilación: "Las extensiones pueden no tener propiedades almacenadas". Aquí se explica cómo puede volver a escribir el ejemplo anterior para que todo en el protocolo se pueda separar en la extensión mediante el uso de funciones en su lugar:

protocol Adaptable {
    func mode() -> Int
    func adapt()
}

class AdaptableViewController: UIViewController {
}

extension AdaptableViewController: Adaptable {
    func mode() -> Int {
        return 0
    }
    func adapt() {
        // adapt code
    }
}

Answer 3

Prueba esto:

class Chassis {}
class RacingChassis : Chassis {}
class SuperChassis : RacingChassis {}

class Car {
    private var chassis: Chassis? = nil
    func getChassis() -> Chassis? {
        return chassis
    }

    func setChassis(chassis: Chassis) {
        self.chassis = chassis
    }
}

class RaceCar: Car {
    private var chassis: RacingChassis {
        get {
            return getChassis() as! RacingChassis
        }
        set {
            setChassis(chassis: newValue)
        }
    }

    override init() {
        super.init()

        chassis = RacingChassis()
    }
}

class SuperCar: RaceCar {
    private var chassis: SuperChassis {
        get {
            return getChassis() as! SuperChassis
        }
        set {
            setChassis(chassis: newValue)
        }
    }

    override init() {
        super.init()

        chassis = SuperChassis()
    }
}

Answer 4

Prueba esto:

class Chassis{
     var chassis{
         return "chassis"
     } 
}

class RacingChassis:Chassis{
     var racing{
         return "racing"
     } 
}

class Car<Type:Chassis> {
     let chassis: Type
     init(chassis:Type){
        self.chassis = chassis
     }
}

class RaceCar: Car<RacingChassis> {
     var description{
         return self.chassis.racing
     } 
}

Entonces:

let racingChassis = RacingChassis()
let raceCar = RaceCar(chassis:racingChassis)
print(raceCar.description) //output:racing

Detalle en http://www.mylonly.com/14957025459875.html

Answer 5

Puedes lograrlo con el uso de genéricos:

class Descriptor {
    let var1 = "a"
}

class OtherDescriptor: Descriptor {
    let var2 = "b"
}

class Asset<D: Descriptor> {
    let descriptor: D

    init(withDescriptor descriptor: D) {
        self.descriptor = descriptor
    }

    func printInfo() {
        print(descriptor.var1)
    }
}

class OtherAsset<D: OtherDescriptor>: Asset<D> {
    override func printInfo() {
        print(descriptor.var1, descriptor.var2)
    }
}

let asset = Asset(withDescriptor: Descriptor())
asset.printInfo() // a

let otherAsset = OtherAsset(withDescriptor: OtherDescriptor())
otherAsset.printInfo() // a b

Con este enfoque, tendrá un código de seguridad del 100% sin desembalar la fuerza.

Pero eso es una especie de truco, y si necesita redefinir varias propiedades, las declaraciones de clase parecerán un desastre total. Así que ten cuidado con este enfoque.

Answer 6

Simplemente puede crear otra variable de RacingChassis.

class Chassis {}
class RacingChassis : Chassis {}
class Car {
    let chassis: Chassis
    init(){
        chassis = Chassis()
}}

class RaceCar: Car {
let raceChassis: RacingChassis
init(){
        raceChassis = RacingChassis()
}}

Answer 7

Solution Dash siempre funciona bien, excepto que la superclase debe declararse con la palabra clave let en lugar de var. ¡Aquí hay una solución que es posible pero NO RECOMENDADA!

La siguiente solución se compilará con Xcode 6.2, SWIFT 1.1 (si todas las clases están en diferentes archivos rápidos) pero debe evitarse porque PUEDE CONDUCIR COMPORTAMIENTOS INESPERADOS (INCLUYENDO UN ACCIDENTE, especialmente cuando se usan tipos no opcionales). NOTA: ESTO NO FUNCIONA CON XCODE 6.3 BETA 3, SWIFT 1.2

class Chassis {}
class RacingChassis : Chassis {}
class Car {
    var chassis:Chassis? = Chassis()
}

class RaceCar: Car {
    override var chassis: RacingChassis? {
        get {
            return super.chassis as? RacingChassis
        }
        set {
            super.chassis = newValue
        }
    }
}

Answer 8

Swift no le permite cambiar el tipo de clase de ninguna variable o propiedad. En su lugar, puede crear una variable adicional en la subclase que maneja el nuevo tipo de clase:

class Chassis {}
class RacingChassis : Chassis {}

class Car {
    var chassis = Chassis()
}
class RaceCar: Car {
    var racingChassis = RacingChassis()
    override var chassis: Chassis {
    get {
        return racingChassis
    }
    set {
        if newValue is RacingChassis {
            racingChassis = newValue as RacingChassis
        } else {
            println("incorrect chassis type for racecar")
        }
    }
    }
}

Parece que uno no puede declarar una propiedad con la sintaxis let y anularla con var en su subclase o viceversa, lo que puede deberse a que la implementación de la superclase podría no estar esperando que esa propiedad cambie una vez inicializada. Entonces, en este caso, la propiedad necesita ser declarada con ''var'' en la superclase para que coincida con la subclase (como se muestra en el fragmento de arriba). Si no se puede cambiar el código fuente en la superclase, probablemente sea mejor destruir el RaceCar actual y crear un nuevo RaceCar cada vez que el chasis necesite ser mutado.

Answer 9

Teóricamente, puedes hacerlo de esta manera ...

class ViewController {

    var view: UIView! { return _view }

    private var _view: UIView!
}

class ScrollView : UIView {}

class ScrollViewController : ViewController {

    override var view: ScrollView! { return super.view as ScrollView! }
}

class HomeView : ScrollView {}

class HomeViewController : ScrollViewController {

    override var view: HomeView! { return super.view as HomeView! }
}

Esto funciona perfectamente en un patio de Xcode.

Pero , si prueba esto en un proyecto real, un error del compilador le dice:

La ''vista'' de declaración no puede anular más de una declaración de superclase

Solo he comprobado Xcode 6.0 GM a partir de ahora.

Desafortunadamente, tendrás que esperar hasta que Apple solucione esto.

También envié un informe de error. 18518795

Answer 10

simplemente configure la propiedad de la nueva imagen con diferentes convenciones de nomenclatura como imgview porque imageView ya es de su propiedad y no podemos asignar 2 propiedades fuertes.