Ios 协议继承+；斯威夫特的代表们

我有一个班级，有一个代表。我创建了一个子类，它也有一个委托。我想让第二个代理使用的协议扩展第一个代理使用的协议：

protocol MySuperClassProtocol {
    func foo()
}

class MySuperClass {
    var delegate:MySuperClassProtocol?
}

protocol MySubClassProtocol:MySuperClassProtocol {
    func bar()
}

class MySubClass: MySuperClass {
    override var delegate:MySubClassProtocol? // compiler error - "cannot override..."

    func test() {
        delegate?.foo()
        delegate?.bar()
    }
}

class UserClass:MySubClassProtocol {
    func foo() {
        println("foo!")
    }
    func bar() {
        println("bar")
    }
} 

有办法解决这个问题吗？我看到的唯一可能的解决方案是使这两个协议相互独立，并使用不同的名称。像这样：

protocol MySuperClassProtocol {
    func foo()
}

class MySuperClass {
    var mySuperClassDelegate:MySuperClassProtocol?
}

protocol MySubClassProtocol {
    func bar()
}

class MySubClass: MySuperClass {
    var mySubClassDelegate:MySubClassProtocol?

    func test() {
        mySuperClassDelegate?.foo()
        mySubClassDelegate?.bar()
    }
}

class UserClass:MySuperClassProtocol, MySubClassProtocol {
    func foo() {
        println("foo!")
    }
    func bar() {
        println("bar")
    }
}

---

但这看起来有点奇怪+不允许我为委托使用命名约定-“委托”。

您可以用另一种方法，您可以在子类中添加

delegate

变量，并使用它访问

超类协议

，还可以使用

delegate？.foo（）

但是这种方法的问题是，除非创建一个新的
MySuperClass
子类，仅用于声明
delegate
变量，否则您永远无法独立使用
mysuperclasprotocol
。

protocol BaseDelegateProtocol: class { }

class BaseDelegate: BaseDelegateProtocol { }

class BaseActor {
    weak var delegate: BaseDelegate? = nil
}

// MARK: -

protocol ConcreteDelegateProtocol: class {
    func doSomething()
}

class ConcreteDelegate: BaseDelegate, ConcreteDelegateProtocol {
    func doSomething() {
        // Do something
    }
}

class ConcreteActor: BaseActor {
    private weak var concreteDelegate: ConcreteDelegateProtocol? = nil

    override var delegate: BaseDelegate? {
        didSet {
            concreteDelegate = delegate as? ConcreteDelegateProtocol
        }
    }
}

以上在XCode 7/Swift 2中工作


此模式允许在继承
BaseDelegate
的过程中采用越来越多的协议
不需要从一个协议继承另一个协议，这有助于保持隔离
didSet
observer on
delegate
属性会自动为超类调用，因此无需显式调用
super.
，这样做也不会“忘记”风险
具体的委托属性可以在每个继承级别上保持私有，从而减少混乱
很抱歉，我找到的唯一解决方案是：

protocol SuperClassDelegate {
    func first_method()
}

class SuperClass {
    var delegate: SuperClassDelegate?

    func do_something() {
        delegate?.first_method()
    }
}

protocol SubClassDelegate: SuperClassDelegate {
    func second_method()
}

class SubClass: SuperClass {
    private var subDelegate: SubClassDelegate?
    override var delegate: SuperClassDelegate? {
        get { return self.subDelegate }
        set { self.subDelegate = newValue as! SubClassDelegate? }
    }

    //override func do_something() {
    //  super.do_something()
    //  subDelegate?.second_method()
    //}

    func do_something_other() {
        //subDelegate?.first_method()
        self.do_something()
        subDelegate?.second_method()
    }
}

class InheritanceAndDelegation: SubClassDelegate {
    let obj = SubClass()

    init() {
        obj.delegate = self
    }

    internal func first_method() {
        print("Hello from SuperClass")
    }

    internal func second_method() {
        print("Hello from SubClass")
    }

    func check() {
        obj.do_something_other()
    }
}

let inheritanceAndDelegation = InheritanceAndDelegation()
inheritanceAndDelegation.check()
//prints:
//Hello from SuperClass
//Hello from SubClass

注释代码也可以工作。希望它对某些人有用。
为什么需要一个超类和超类协议？因为我在超类中加入了许多类的通用功能，还有一个“通用委托”。这不是我需要的。。。拥有超类委托的想法是任何子类都将拥有它。有了这个，我必须在每个子类中声明委托。@ixx:然后呢？不能使用基类指针调用子类方法，除非将其放在基类中（在基类或基类属性中声明）。这是纯面向对象的概念。除了你在问题中定义的1和我在这里提到的1之外，没有其他方法。在目标c中也不能这样做。所以你在寻找一些甚至不可能的东西。好吧，这就是我在寻找的，一种将基本委托放在基类中的方法，这样我就可以在任何地方调用它。我还担心唯一的办法是我在问题中提出什么。“你在寻找甚至不可能的东西”，这是你在提问时不知道的；）这种模式非常有效，如果您为每个超类委托方法提供实现并将它们的调用转发给您的子类委托，它甚至允许您的子类充当它自己的超类的委托。这对于我的
UIScrollView
子类来说非常方便。你甚至可以在你的故事板上连接代理插座，一切都按照你的预期进行。这是完美的。有一个场景，我想在我自己的类中为自定义协议使用
delegate
关键字，该类继承自UISearchBar。完美地工作
protocol SuperClassDelegate {
    func first_method()
}

class SuperClass {
    var delegate: SuperClassDelegate?

    func do_something() {
        delegate?.first_method()
    }
}

protocol SubClassDelegate: SuperClassDelegate {
    func second_method()
}

class SubClass: SuperClass {
    private var subDelegate: SubClassDelegate?
    override var delegate: SuperClassDelegate? {
        get { return self.subDelegate }
        set { self.subDelegate = newValue as! SubClassDelegate? }
    }

    //override func do_something() {
    //  super.do_something()
    //  subDelegate?.second_method()
    //}

    func do_something_other() {
        //subDelegate?.first_method()
        self.do_something()
        subDelegate?.second_method()
    }
}

class InheritanceAndDelegation: SubClassDelegate {
    let obj = SubClass()

    init() {
        obj.delegate = self
    }

    internal func first_method() {
        print("Hello from SuperClass")
    }

    internal func second_method() {
        print("Hello from SubClass")
    }

    func check() {
        obj.do_something_other()
    }
}

let inheritanceAndDelegation = InheritanceAndDelegation()
inheritanceAndDelegation.check()
//prints:
//Hello from SuperClass
//Hello from SubClass