Переопределение свойства суперкласса другим типом в Swift

Может ли кто-нибудь объяснить в Swift, как переопределить свойство суперкласса другим объектом, унаследованным от исходного свойства?

Возьмем этот простой пример:

class Chassis {}
class RacingChassis : Chassis {}

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

Это дает ошибку:

Cannot override with a stored property 'chassis'

Если вместо этого у меня есть шасси как var, я получаю сообщение об ошибке:

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

Единственное, что я смог найти в руководстве в разделе «Переопределение свойств», указывает на то, что мы должны переопределить методы получения и установки, которые могут работать для изменения значения свойства (если это 'var'), но как насчет изменения класса свойства ?

Swift не позволяет изменять тип класса каких-либо переменных или свойств. Вместо этого вы можете создать дополнительную переменную в подклассе, которая обрабатывает новый тип класса:

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 let newRacingChassis = newValue as? RacingChassis {
                racingChassis = newRacingChassis
            } else {
                println("incorrect chassis type for racecar")
            }
        }
    }
}

Кажется, нельзя объявить свойство с синтаксисом let и переопределить его с помощью var в его подклассе или наоборот, что может быть связано с тем, что реализация суперкласса может не ожидать, что это свойство изменится после инициализации. Таким образом, в этом случае свойство должно быть объявлено с помощью 'var' в суперклассе, чтобы соответствовать подклассу (как показано во фрагменте выше). Если нельзя изменить исходный код в суперклассе, то, вероятно, лучше всего уничтожить текущую RaceCar и создавать новую RaceCar каждый раз, когда требуется мутировать шасси.

Кажется, это работает

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()

Попробуй это:

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
     } 
}

Затем:

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

Подробно на http://www.mylonly.com/14957025459875.html.

Предоставленный Solution Dash работает хорошо, за исключением того, что суперкласс должен быть объявлен с ключевым словом let, а не var. Вот решение, которое возможно, но НЕ РЕКОМЕНДУЕТСЯ!

Приведенное ниже решение будет компилироваться с Xcode 6.2, SWIFT 1.1 (если все классы находятся в разных быстрых файлах), но его следует избегать, потому что ЭТО МОЖЕТ ПРИВЕСТИ К НЕОЖИДАННОМУ ПОВЕДЕНИЮ (ВКЛЮЧАЯ АВАРИЯ, особенно при использовании необязательных типов). ПРИМЕЧАНИЕ: ЭТО НЕ РАБОТАЕТ С 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
        }
    }
}

Теоретически можно так делать ...

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! }
}

Это отлично работает на игровой площадке Xcode.

Но если вы попробуете это в реальном проекте, ошибка компилятора сообщит вам:

Объявление 'view' не может перекрывать более одного объявления суперкласса

На данный момент я проверял только Xcode 6.0 GM.

К сожалению, вам придется подождать, пока Apple исправит это.

Я тоже отправил отчет об ошибке. 18518795

Я видел множество причин, по которым разработка API с использованием переменных вместо функций является проблематичной, и для меня использование вычисленных свойств кажется обходным решением. Есть веские причины держать переменные экземпляра инкапсулированными. Здесь я создал автомобильный протокол, которому соответствует автомобиль. У этого протокола есть метод доступа, который возвращает объект Chassis. Поскольку Car соответствует ему, подкласс RaceCar может переопределить его и вернуть другой подкласс Chassis. Это позволяет классу Car программировать интерфейс (автомобиль), а класс RaceCar, который знает о RacingChassis, может напрямую обращаться к переменной _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
    }
}

Еще один пример того, почему разработка API с использованием переменных не работает, - это когда у вас есть переменные в протоколе. Если вы хотите разбить все функции протокола на расширения, вы можете, за исключением того, что сохраненные свойства не могут быть помещены в расширения и должны быть определены в классе (чтобы это скомпилировалось, вам нужно раскомментировать код в AdaptableViewController и удалите переменную режима из расширения):

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
    }
}

В приведенном выше коде будет ошибка компилятора: «Расширения могут не иметь сохраненных свойств». Вот как вы можете переписать приведенный выше пример, чтобы все в протоколе можно было отделить в расширении, используя вместо этого функции:

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

class AdaptableViewController: UIViewController {
}

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

Вы можете добиться этого с помощью дженериков:

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

При таком подходе у вас будет 100% безопасный код без принудительных развертываний.

Но это своего рода уловка, и если вам нужно будет переопределить несколько свойств, то объявления классов будут выглядеть как полный беспорядок. Так что будьте осторожны с этим подходом.

В зависимости от того, как вы планируете использовать свойство, самый простой способ сделать это - использовать дополнительный тип для вашего подкласса и переопределить didSet {}метод для супер:

class Chassis { }
class RacingChassis: Chassis { }

class Car {
    // Declare this an optional type, and do your 
    // due diligence to check that it's initialized
    // where applicable
    var chassis: Chassis?
}
class RaceCar: Car {
    // The subclass is naturally an optional too
    var racingChassis: RacingChassis?
    override var chassis: Chassis {
        didSet {
            // using an optional, we try to set the type
            racingChassis = chassis as? RacingChassis
        }
    }
}

Очевидно, вам нужно потратить некоторое время на проверку, чтобы убедиться, что классы могут быть инициализированы таким образом, но, установив для свойств значение optional, вы защитите себя от ситуаций, когда приведение больше не работает.

Вы можете просто создать другую переменную RacingChassis.

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

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

Попробуй это:

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()
    }
}

class Chassis {}
class RacingChassis : Chassis {}

class Car {
    fileprivate let theChassis: Chassis
    var chassis: Chassis {
        get {
            return theChassis
        }
    }
    fileprivate init(_ chassis: Chassis) {
        theChassis = chassis
    }
    convenience init() {
        self.init(Chassis())
    }
}
class RaceCar: Car {
    override var chassis: RacingChassis {
        get {
            return theChassis as! RacingChassis
        }
    }
    init() {
        super.init(RacingChassis())
    }
}

Следующее позволяет использовать один объект в базовом и производном классах. В производном классе используйте свойство производного объекта.

class Car {
    var chassis:Chassis?

    func inspect() {
        chassis?.checkForRust()
    }
}

class RaceCar: Car {
    var racingChassis: RacingChassis? {
        get {
            return chassis as? RacingChassis
        } 
    }

    override func inspect() {
        super.inspect()
        racingChassis?.tuneSuspension()
    }
}

Небольшое изменение других ответов, но проще и безопаснее с некоторыми приятными преимуществами.

class Chassis {}
class RacingChassis : Chassis {}

class Car {
    let chassis = Chassis()
}
class RaceCar: Car {
    var racingChassis: RacingChassis? {
        get {
            return chassis as? RacingChassis
        }
    }
}

Преимущества заключаются в том, что нет ограничений на то, какое шасси должно быть (var, let, optional и т. Д.), А также легко создать подкласс RaceCar. Подклассы RaceCar могут иметь собственное вычисленное значение для шасси (или racingChassis).

просто установите новое свойство imageview с другим соглашением об именах, например imgview, потому что imageView уже является собственным свойством, и мы не можем назначить 2 сильных свойства.