การลบล้างคุณสมบัติระดับซุปเปอร์คลาสด้วยประเภทต่างๆใน 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'

สิ่งเดียวที่ฉันพบในคำแนะนำภายใต้ "คุณสมบัติการแทนที่" ระบุว่าเราต้องแทนที่ getter และ setter ซึ่งอาจใช้ได้กับการเปลี่ยนค่าของคุณสมบัติ (ถ้าเป็น '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 ในคลาสย่อยหรือในทางกลับกันซึ่งอาจเป็นเพราะการนำ superclass ไปใช้อาจไม่ได้คาดหวังว่าคุณสมบัตินั้นจะเปลี่ยนแปลงเมื่อเริ่มต้นแล้ว ดังนั้นในกรณีนี้จำเป็นต้องประกาศคุณสมบัติด้วย '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 ที่จัดเตรียมไว้ให้ใช้งานได้ดียกเว้นว่าต้องประกาศ super class ด้วยคีย์เวิร์ด 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' การประกาศไม่สามารถแทนที่การประกาศ superclass มากกว่าหนึ่งรายการ

ฉันตรวจสอบเฉพาะ Xcode 6.0 GM ณ ตอนนี้

น่าเสียดายที่คุณต้องรอจนกว่า Apple จะแก้ไขปัญหานี้

ฉันได้ส่งรายงานข้อบกพร่องด้วย 18518795

ฉันได้เห็นเหตุผลมากมายว่าทำไมการออกแบบ API โดยใช้ตัวแปรแทนฟังก์ชันจึงเป็นปัญหาและสำหรับฉันที่ใช้คุณสมบัติที่คำนวณแล้วรู้สึกเหมือนเป็นวิธีแก้ปัญหา มีเหตุผลที่ดีที่จะเก็บตัวแปรอินสแตนซ์ของคุณไว้ ที่นี่ฉันได้สร้างโปรโตคอลรถยนต์ที่สอดคล้องกับรถยนต์ โปรโตคอลนี้มีวิธีการเข้าถึงที่ส่งคืนอ็อบเจ็กต์ Chassis เนื่องจากรถเป็นไปตามนั้นคลาสย่อย RaceCar จึงสามารถแทนที่และส่งคืนคลาสย่อยแชสซีอื่นได้ สิ่งนี้ทำให้คลาส 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 {}เมธอดสำหรับ super:

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

เห็นได้ชัดว่าคุณต้องใช้เวลาในการตรวจสอบเพื่อให้แน่ใจว่าสามารถเริ่มต้นคลาสได้ด้วยวิธีนี้ แต่การตั้งค่าคุณสมบัติเป็นทางเลือกคุณจะป้องกันตัวเองจากสถานการณ์ที่การร่ายไม่ได้ผลอีกต่อไป

คุณสามารถสร้างตัวแปรอื่นของ 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, etc) และเป็นคลาสย่อย RaceCar ได้ง่าย คลาสย่อยของ RaceCar สามารถมีค่าที่คำนวณได้เองสำหรับแชสซี (หรือ racingChassis)

เพียงตั้งค่าคุณสมบัติ imageview ใหม่ด้วยรูปแบบการตั้งชื่อที่แตกต่างกันเช่น imgview เนื่องจาก imageView เป็นคุณสมบัติของตัวเองอยู่แล้วและเราไม่สามารถกำหนดคุณสมบัติที่แข็งแกร่ง 2 คุณสมบัติได้