Access Control Levels in Swift

Access control levels in Swift determine the scope and visibility of classes, structures, functions, properties, and other entities in your code. They define who can access or modify a particular piece of code, helping you manage code organization, security, and modularity.

---

Access Control Levels in Swift

1. Open (Most Permissive)

• Scope: Available to any module or file, including subclasses outside the module.
• Usage: Used for public APIs or frameworks where entities must be subclassable and overridden outside the module.

Example:

open class OpenClass {
    open func greet() {
        print("Hello!")
    }
}

class Subclass: OpenClass {
    override func greet() {
        print("Hi!")
    }
}

This allows OpenClass and its greet() method to be subclassed and overridden in other modules.

2. Public

• Scope: Accessible in any module but not subclassable or overridable outside the module.
• Usage: Used for exposing interfaces or functionality to other modules without subclassing.

Example:

public class PublicClass {
    public func greet() {
        print("Hello!")
    }
}

3. Internal (Default)

• Scope: Accessible only within the same module (e.g., app target or framework).
• Usage: The default access level for most entities unless explicitly specified.

Example:

class InternalClass {
    func greet() {
        print("Hello!")
    }
}

4. Fileprivate

• Scope: Accessible only within the same source file.
• Usage: Used when you want to restrict access to helper methods or properties within a single file.

Example:

fileprivate class FileprivateClass {
    fileprivate func greet() {
        print("Hello!")
    }
}

class AnotherClassInSameFile {
    func sayHi() {
        let instance = FileprivateClass()
        instance.greet()
    }
}

5. Private (Most Restrictive)

• Scope: Accessible only within the same enclosing declaration (e.g., class, struct).
• Usage: Used to encapsulate implementation details and restrict access within a specific declaration.

Example:

class PrivateClass {
    private var secretMessage = "Hidden!"

    private func showSecret() {
        print(secretMessage)
    }

    func revealSecret() {
        showSecret() // Accessible within the same class.
    }
}

---

Why Are Access Control Levels Useful?

1. Encapsulation:
   Access control enforces the principle of hiding implementation details, exposing only what is necessary for use.

2. Code Modularity:
   Helps in creating modular and reusable code by defining clear boundaries for access.

3. Security:
   Restricts access to sensitive data or critical code sections to prevent misuse or unintended modifications.

4. API Design:
   Public or open access levels allow you to define APIs for other developers while keeping the implementation private or internal.

5. Code Maintenance:
   Prevents accidental access or modifications to parts of code that are not meant to be externally visible.

---

Choosing the Right Access Level

• Use private for implementation details you don’t want accessed outside a class/struct.
• Use fileprivate sparingly, typically for testing or tightly related logic.
• Use internal by default for most app logic.
• Use public or open only for entities that need external visibility, such as APIs or framework components.

---

Understanding and using access control effectively helps build secure, modular, and maintainable Swift applications.

Happy Coding!