【问答】What does a module mean in swift?

# 提问
For example, I have two files called `file1.swift` and `file2.swift`.

`file1.swift`
```swift
import UIKit
class A : B {
	
}
```
`file2.swift`
```swift
import UIKit
class C : A {
	
}
```
I am reading that public class can not subclassed outside of module. Here I have subclass C. I am trying to understand what does module mean here. I imported to same module UIKit for both file. So the both files are of same module? So that I can subclassed. Or both files have different module even I import the same UIKit?
Can anybody explain what is module?

Source:

Classes with public access, or any more restrictive access level, can be subclassed only within the module where they’re defined.

Class members with public access, or any more restrictive access level, can be overridden by subclasses only within the module where they’re defined.

# 回答
> A module is a single unit of code distribution—a framework or application that is built and shipped as a single unit and that can be imported by another module with Swift’s import keyword.

> Each build target (such as an app bundle or framework) in Xcode is treated as a separate module in Swift. If you group together aspects of your app’s code as a stand-alone framework—perhaps to encapsulate and reuse that code across multiple applications—then everything you define within that framework will be part of a separate module when it’s imported and used within an app, or when it’s used within another framework.

As the <a href=https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AccessControl.html target='_blank'>docs</a> indicate, the module is an application or a framework (library). If you create a project with classes `A` and `B`, they are part of the same module. Any other class in the same project can inherit from those classes. If you however import that project to another project, classes from that another project won't be able to subclass `A` nor `B`. For that you would have to add `open` indicator before their declarations.

Basically, if you work on a single app then you are working in one single module and unless declared as private or `fileprivate`, the classes can subclass each other.

**EDIT**
Let us have following class in module (project) *Module1*:
```swift
class A {
}
```
Since this class is not `open`, it can be subclassed only within the same module. That means that following class:
```swift
class B : A {
}
```
Can be written only in the same project, in *Module1*.

If you add Module1 as a dependency to project *Module2*, and try to do this:
```swift
import Module1

class C: A {
}
```
It will not compile. That's because class `A` is not open (in other words it has access public or less) and it does not belong to the same module as `C`. `A` belongs to `Module1`, `C` belongs to *Module2*.

**Note**

`import` keyword imports a dependency module to your current module. If you write `import UIKit` in your project, you are telling the compiler that you want to use module `UIKit` in your module. `import` does not define current module. Current module is the current project.

Adding `import UIKit` at the beginning of the file does not change nor define to which module the file belongs. It just tells the compiler that in that file you want to use code from `UIKit` module.

> REFERENCE
- <a href=https://stackoverflow.com/questions/48426344/what-does-a-module-mean-in-swift target='_blank'>What does a module mean in swift?</a>

如果您对此页面有任何问题或建议，请在本站留言，或联系邮箱me[at]zkk.me
本网站部分内容转载自其他网站，如有侵权，请联系博主

zkk的博客

【问答】What does a module mean in swift?

添加新评论

最新文章

最近回复

分类

标签

其它