因此，在使用 Swift 时，我遇到了这个问题，这让我很困惑。

我有一张类(class)卡片:

class Card {
    var contents = ""
    var chosen = false
    var matched = false

    var description: String {
    get {
        return self.contents
    }
    }

    func match(otherCards: Card[]) -> Int {...}
}

和一个从 Card 子类化的 PlayingCard 类:

class PlayingCard: Card {
    var suit: Suit
    var rank: Rank

    override var contents: String {
    get {
        return "\(rank.description())\(suit.toRaw())"
    }
    set { }
    }

    init(rank: Rank, suit: Suit) {
        self.suit = suit
        self.rank = rank

        super.init()
    }

    override func match(otherCards: Card[]) -> Int {...}
}

如您所见，在 Card 中，description 属性是根据 contents 属性计算的。但是，当我实例化 PlayingCard 时，我有一个计算的 contents 属性，它覆盖了 Card 的存储的 contents 属性。但是，如果我调用我的 PlayingCard 的 description，它会返回卡片存储的内容，而不是 PlayingCard 计算的实际内容。

func testPlayingCardProperties() {
    var card = PlayingCard(rank: .Ace, suit: .Spades)

    XCTAssert(card.contents == "A♠️", "Contents not overriden.") // TRUE
    XCTAssert(card.description == "A♠️", "Description not overriden.") // FALSE??
}

这是怎么回事？注意

func testCardProperties() {
    var card = Card()
    card.contents = "Test Card"

    XCTAssert(card.contents == "Test Card", "Contents getter error.") // TRUE
    XCTAssert(card.description == "Test Card", "Description getter error.") // TRUE
}

按预期工作。

更新

我在 Playground 中运行了以下命令...并且成功了。仍然没有运气。

class Card {
    var contents = ""
    var chosen = false
    var matched = false

    var description: String {
    get {
        return contents
    }
    }

    func match(otherCards: Card[]) -> Int {
        var score = 0

        for card in otherCards {
            if card.contents == contents {
                score += 1
            }
        }

        return score
    }
}

enum Suit: String {
    case Diamonds = "♦️"
    case Hearts = "♥️"
    case Spades = "♠️"
    case Clubs = "♣️"

    static func allSuits() -> Suit[] {
        return [.Diamonds, .Hearts, .Spades, .Clubs]
    }
}

enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King

    func description() -> String {
        switch self {
        case .Ace:
            return "A"
        case .Jack:
            return "J"
        case .Queen:
            return "Q"
        case .King:
            return "K"
        default:
            return String(toRaw())
        }
    }
}

class PlayingCard: Card {
    var suit: Suit
    var rank: Rank

    override var contents: String {
    get {
        return "\(rank.description())\(suit.toRaw())"
    }
    set { }
    }

    let maxRank = 13

    init(rank: Rank, suit: Suit) {
        self.suit = suit
        self.rank = rank
    }

    override func match(otherCards: Card[]) -> Int {
        let allCards = otherCards + [self]
        let testMatches = {
            () -> (Card, Card[])[] in

            var result: (Card, Card[])[] = []

            for i in 0..allCards.count {
                result += (allCards[i], Array(allCards[0..i] + allCards[(i + 1)..allCards.count]))
            }

            return result

            }()

        let scores = testMatches.map({
            (card, otherCards) -> Int in
            if let playingCard = card as? PlayingCard {
                var rankValue = 1.0
                var suitValue = 1.0

                for matchCard in otherCards {
                    if let matchPlayingCard = matchCard as? PlayingCard {
                        if (matchPlayingCard.rank == playingCard.rank) {
                            rankValue *= 8;
                        } else {
                            rankValue /= 2;
                        }

                        if (matchPlayingCard.suit == playingCard.suit) {
                            suitValue *= 2;
                        } else {
                            suitValue /= 2;
                        }
                    }
                }

                if rankValue >= 1.0 {
                    return Int(rankValue)
                } else if suitValue >= 1.0 {
                    return Int(suitValue)
                } else {
                    return 0
                }
            } else {
                return 0
            }
            })

        return scores.reduce(Int.min, combine: { $0 > $1 ? $0 : $1 });
    }
}


var card = PlayingCard(rank: .Jack, suit: .Spades)
card.description

这可能只是 Xcode 错误吗？

最佳答案

似乎发生了一些奇怪的事情，而且很可能是错误的。如果我接受这段代码:

class Base {
    var contents = "Base contents"
    var description: String {
    get {
        return self.contents
    }
    }
}

class Derived : Base {
    override var contents: String {
    get {
        return "Derived contents, dynamically generated"
    }
    set { }
    }
}

let d = Derived()
println(d.contents) 
println(d.description)

...并将其放入单个文件中(在 Playground 上或在命令行 OS X 应用程序中)，然后输出如下(我认为符合预期):

println(d.contents) // Prints "Derived contents, dynamically generated"
println(d.description) // Prints "Derived contents, dynamically generated"

但是，如果我将基类移出到“base.swift”并将派生类移到“derived.swift”，将主要代码留在其自己的文件中，不做其他更改，然后打印出来:

println(d.contents) // Prints "Derived contents, dynamically generated"
println(d.description) // Prints "Base contents"

...这对我来说就像是一个错误。

关于properties - 在 Swift 中调用子类的 getter，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24135741/