Swift 内部类可以访问外部类的 self 吗？

Question

我来自 Java 背景，当您声明内部类时，它要么是静态的，并且无法访问外部类的实例，要么它不是静态的，并且可以访问外部类的实例正在运行的类。见http://en.wikipedia.org/wiki/Inner_class#Types_of_nested_classes_in_Java

Swift 有这方面的概念吗？根据我的测试，我似乎无法访问Outer 的self 对象，但我肯定做错了什么。

class Outer {
    let value = ""
    class Inner {
        func foo() {
            let bar = value // 'Outer.Type' does not have a member named 'value'
        }
    }
}

Answer 1

AFAIK，您无法开箱即用地访问外部类。

但你能做的是：

class Outer {

    let value = ""
    var inner = Inner()

    class Inner {

        weak var parent: Outer! = nil

        func foo() {
            let bar = parent.value
        }

    }

    init() {
        inner.parent = self
    }

}

或者：

class Outer {

    class Inner {

        unowned let parent: Outer

        init(parent: Outer) {
            self.parent = parent
        }

    }

    let value = ""
    var inner: Inner! = nil

    init() {
        inner = Inner(parent: self)
    }

}

Answer 2

嵌套类型对包含它们的类型没有任何特殊访问权限。但我不认为这就是这里发生的一切。您似乎对类与实例有点模糊。

value 是 Outer 类的属性。这意味着每个 Outer 实例都有自己的value。 Inner 是一个单独的类，存在于 Outer 的命名空间中。所以当你写let bar = value时，没有value这样的东西可以访问，因为它只存在于Outer的实例中，而我们手头没有任何实例。如果它是一个类属性，你可以使用let bar = Outer.value。

Answer 3

不，要在 Swift 中拥有类似的功能，您需要对其进行硬编码。

class Outer {
    var value = 0

    init(_ value: Int) {
        self.value = value
    }

    func inner() -> Inner {
        return Inner(self)
    }

    class Inner {
        let outer: Outer
        var value = 1

        init(_ outer: Outer) {
            self.outer = outer
        }

        func doSomething() {
            print("Outer ", outer.value, " Inner ", value)
        }
    }
}

let i1 = Outer(1).inner()
i1.doSomething() // Outer 1 Inner 1

let i2 = Outer(2).inner()
i2.doSomething() // Outer 2 Inner 1

Answer 4

任何语言的内部类都是一个非常无用的结构。它们对关注点分离没有任何作用。它们仅提供包装类内部的可视化分组，但代码仍然高度纠缠于各处的交叉依赖关系。

抽象的正确做法是隔离处理尽可能少的一组问题（理想情况下是一个）的部分。隔离意味着不可能有交叉依赖，这在推理代码时意义重大。

问问你自己：你真正需要这个外部类的引用是为了什么？ 唯一可能的答案是仅访问其 API 的某些特定部分。 事实证明，这就是将内部类专门化为特定外部类的原因。

考虑以下示例：

class CustomSectionContentController : UIViewController {

  @IBOutlet weak var webView: UIWebView!

  lazy var webViewDelegate: WebViewDelegate = WebViewDelegate()

  override func viewDidLoad() {
    super.viewDidLoad()
    webView.delegate = webViewDelegate
  }

  class WebViewDelegate: NSObject, UIWebViewDelegate {

    var overlay: ProgressOverlay?

    func webViewDidStartLoad(webView: UIWebView) {
      // Here I want to access the 'view' of the outer class:
      overlay = ProgressOverlay.cover(outerSelf.view)
    }

    func webViewDidFinishLoad(webView: UIWebView) {
      overlay?.remove()
    }

  }
}

当然，您可以使用其他答案中建议的多种方法中的任何一种来解决缺少的outerSelf 功能，但此示例实际上表明存在一段易于区分的代码，可以将其隔离。考虑以下替代方案：

class CustomSectionContentController : UIViewController {

  @IBOutlet weak var webView: UIWebView!

  lazy var webViewDelegate: ProgressOverlayWebViewDelegate =
    ProgressOverlayWebViewDelegate(view: self.view)

  override func viewDidLoad() {
    super.viewDidLoad()
    webView.delegate = webViewDelegate
  }

}

class ProgressOverlayWebViewDelegate: NSObject, UIWebViewDelegate {

  let view: UIView

  init(view: UIView) {
    self.view = view
  }

  var overlay: ProgressOverlay?

  func webViewDidStartLoad(webView: UIWebView) {
    overlay = ProgressOverlay.cover(view)
  }

  func webViewDidFinishLoad(webView: UIWebView) {
    overlay?.remove()
  }

}

看到区别了吗？我们的控制器现在根本不处理 WebView 委托的问题区域。我们现在还有一个孤立的将军ProgressOverlayWebViewDelegate，它对使用它的控制器一无所知。这意味着我们可以在其他控制器中重用这个委托。

一开始你可能不相信，但事实证明，上述方法适用于所有涉及内部类的场景。一般而言，关注点的隔离是抽象和编程良好实践的基石，因此每当您遇到此类问题时，请重新考虑。

Answer 5

您可以像这样解决这个问题：

class Outer {
    let value = ""
    class Inner {
        func foo(outer: Outer) {
            let bar = outer.value
        }
    }
}

或者，您可以将其传递给Inner 的初始化程序，而不是将Outer 实例传递给foo 方法。但是，如果 Inner 是 enum，则该技巧将不起作用，因为 Swift enum 不能具有属性（除了关联值，它们类似于属性）。

此解决方法等效于 Java 为内部类隐式执行的操作，以避免繁琐的传递参数和显式引用的工作给您带来负担。

IMO Java 内部类特性的基本原理类似于闭包的基本原理：该特性允许代码隐式使用环境中的变量（在这种情况下，环境是Outer 类实例）。我不知道为什么 Swift 缺少内部类。如果 Swift 被增强以执行内部类，则必须更改许多现有的 Swift 代码以将 static 放在类声明的前面。值得，IMO。

Answer 6

好吧，您可以使用继承，以便将外部用作内部的超类。

class Outer {
    let value = ""
    class Inner: Outer {
        func foo() {
            let bar = value //value is now accessable as it has internal access from the superclass
        }
    }
}

Answer 7

如果您有很多内部类并且想要编写更少的代码行，那么您可以使用接受 Outer 实例的初始化程序创建基类并从中继承所有内部类：

class Outer {
    func testInner() {
        print("test")
    }

    class InnerBase {
        let outer: Outer

        init(outer: Outer) {
            self.outer = outer
        }
    }

    class Inner1: InnerBase {
        func test() {
            outer.testInner()
        }
    }

    class Inner2: InnerBase {
        func test() {
            outer.testInner()
        }
    }

    func test() {
        Inner1(outer: self).test()
        Inner2(outer: self).test()
    }
}

Outer().test()