Self类型的存储变量尤其是在子类化时 此数据模型从根本上被破坏

如何解决Self类型的存储变量尤其是在子类化时 此数据模型从根本上被破坏

class LinkedNode<T> {
    var value: T
    var next: Self?
    
    required init(_ value: T) {
        self.value = value
    }
}

class DoublyNode<T>: LinkedNode<T> {
    weak var previous: DoublyNode?
    override var next: Self? {
        didSet { next.previous = self }
    }
}

我希望它能像这样编译。但事实并非如此。

存储的属性不能具有协变“ Self”类型

我必须重写代码以使其编译和工作：

class LinkedNode<T> {
    var value: T
    var next: LinkedNode?
    
    required init(_ value: T) {
        self.value = value
    }
}

class DoublyNode<T>: LinkedNode<T> {
    weak var previous: DoublyNode?
    override var next: LinkedNode<T>? {
        didSet { (next as! Self).previous = self }
    }
}

在每次引用next属性之后，在以后的代码中的每个地方，我都必须手动将其强制转换为DoublyNode（当我使用DoublyNode时），因为它始终具有LinkedNode类型。
这是可管理的，但令人讨厌又丑陋。

解决方法

Swift的子类不允许协变地覆盖属性（即，该类型具有该属性的super类型的子类型）。

这是一个更简单的示例，没有泛型：

class Animal {}
class Bird: Animal {}

class AnimalFeeder {
    var animalToFeed: Animal
    
    init() { fatalError("not relevant to the example") }
}

class BirdFeeder: AnimalFeeder {
    override var animalToFeed: Bird // error: cannot override mutable property 'animalToFeed' of type 'Animal' with covariant type 'Bird'
}

除了Self以此类比同时扮演动物角色和动物饲养者角色之外，您几乎拥有示例示例。

此数据模型从根本上被破坏

它受square-rectangle problem的影响。除非next和prev指针被紧密封装，并且仅通过受控函数公开，否则此类将破坏LSP。

如果要将DoublyNode<T>传递给期望LinkedNode<T>的算法，该算法可以对链接列表的结构进行操作，则仅将其视为单链接，而忽略{{1 }}参考。这样做从根本上破坏了双向链表的不变性，并使之无效。

prev观察者可以提供帮助，但不会在初始化时触发（因此对象从一开始就可能是错误的）。我认为这可以通过添加更多封装来解决，并使该对象的属性更具权威性，以便它们可以确保它们保持有效。但是我认为这是有争议的，因为还有一个更深层次的问题：

“这两个类共享3个字段中的2个”不是继承的好动机。真的，您从继承中还能得到什么？我认为，通过拥有两个分别由didSet和struct SinglyLinkedList<T>拥有的分别分别与struct DoublyLinkedList<T>和Collection符合的BidirectionalCollection和{{1}}拥有的链接节点类，您会获得更多的价值。定义向前和向后的迭代）

,

让我演示一下为什么Swift不允许这样做。如果确实允许您像这样使用Self，则理论上您可以这样做：

let doublyNode = DoublyNode(1)
let linkedNode: LinkedNode<Int> = doublyNode // this assignment should work,right?
linkedNode.next = LinkedNode(2) // "linkedNode" is of type LinkedNode,so Self is LinkedNode,so I can do this assignment,right?

现在会发生什么？ didSet中next中的DoublyNode被调用，并尝试访问previous中的LinkedNode(2)。事实是，LinkedNode甚至没有previous属性！因此，允许您以这种方式使用Self是不安全的。

我不认为DoublyNode应该完全继承自LinkedNode。亚历山大的答案很好地说明了这一点，即它违反了LSP。可以将这两个类关联起来的一件事是使用协议：

protocol LinkedNodeProtocol {
    associatedtype Data
    
    var value: Data { get set }
    var next: Self? { get set }
    
    init(_ value: Data)
}

final class LinkedNode<Data>: LinkedNodeProtocol {
    var value: Data
    var next: LinkedNode?
    
    init(_ value: Data) {
        self.value = value
    }
}

final class DoublyNode<Data>: LinkedNodeProtocol {
    var value: Data
    weak var previous: DoublyNode?
    var next: DoublyNode? {
        didSet { next?.previous = self }
    }
    
    init(_ value: Data) {
        self.value = value
    }
}