Swift：在类内声明协议

在java中，我有：

public class Event {

        public enum State {
            PENDING,
            UPCOMING,
            ACTIVE,
            FINISHED,
            FAILURE
        }

        public interface Callback {
            void onUpdated();
            void onStateChanged(State state);
        }

        private State state;
        private Callback mCallback;
    }

如何在Swift中创建类似的内容？似乎我不能在类内声明协议。但当我在外部声明协议时，我无法访问状态枚举。谢谢

我想要像这样的东西

class Event {

    protocol Delegate {
        func onUpdated();
        func onStateChanged(state: State);
    }

    enum State {
        case PENDING
        case UPCOMING
        case ACTIVE
        case FINISHED
        case FAILURE
    }

    var delegate: Delegate?
}

---

您可以使用

className.[entity]

访问类范围的实体，如下例所示：

protocol Callback {
  func onUpdated() -> Void
  func onStateChanged(state: MyClass.State) -> Void
}

class MyClass {
  enum State {
    case PENDING
    case UPCOMING
    case ACTIVE
    case FINISHED
    case FAILURE
  }

  private var state: State
  private var mCallback: Callback
}

然后您可以使用

回调协议扩展任何其他类，如下所示：

class AnyOtherClass {
  ...
}

extension AnyOtherClass: Callback {
  func onUpdated() {
    ...
  }
  ...
}

您可以使用
Event.State

/* delegate protocol */
protocol MyDelegate : class {
    func onStateChanged(state: Event.State) -> ()
}

/* default implementation of onStateChanged */
extension MyDelegate {
    func onStateChanged(state: Event.State) {
        print("State changed to: \(state)")
    }
}

/* your events */ 
class Event {
    enum State {
        case Pending
        case Upcoming
        case Active
        case Finished
        case Failure
    }

    weak var delegate: MyDelegate?

    var state : State {
        didSet {
            // call delegate
            delegate?.onStateChanged(state)
        }
    }

    init(state: State) {
        self.state = state
    }
}

一些简单处理程序的使用示例：

class EventHandler: MyDelegate {
    var myEvent : Event

    init(event: Event) {
        myEvent = event
        myEvent.delegate = self
    }
}

class AnotherHandler: MyDelegate {
    var myEvent : Event

    init(event: Event) {
        myEvent = event
        myEvent.delegate = self
    }

    func onStateChanged(state: Event.State) {
        if state == .Active {
            print("Event is active")
        }
        else {
            print("Event is not active")
        }
    }
}

/* example usage */
let handler1 = EventHandler(event: Event(state: .Pending))
let handler2 = AnotherHandler(event: Event(state: .Pending))

handler1.myEvent.state = .Active 
    /* prints "State changed to: Active" (uses default delegate function) */

handler2.myEvent.state = .Active 
    /* prints "Event is active" (uses custom delegate function) */

您应该包括您迄今为止编写的Swift代码，即使它不起作用。我需要类作用域枚举状态和类委托，如果我有许多具有回调的模型对象，那么看起来我应该对它们进行不同的命名，并且不能保持它们的通用命名…，对吗？您可以重新表述您的问题吗？对不起，我不明白。我有我的1和2，所以我应该有Callback1和Callback2，对吧？在Java中，我可以使用MyClass1.Callback和MyClass2.CallbackWell，如果协议相同，我认为这样做没有问题。如果协议不同，为什么有ProtocolClassA和ProtocolClassB是一个问题？注意，我在MyClass定义之外声明了回调协议。这允许任何其他类实现该功能protocol@pvllnspk你把它整理好了吗？使用相同的
回调实现是否有意义？非常感谢您的详细回答，我已经接受了出现的第一个答案。@pvllnspk很乐意提供帮助。关于您在对另一个答案的评论中提出的问题：请注意，两个不同的类（上面的处理程序）可以符合
MyDelegate
，并选择是实现蓝图委托函数的自定义版本
onStateChanged（event:）
，还是使用默认实现，如
MyDelegate
的扩展中所定义。