Access Control

Hello,

Access Control restricts access to some of your code from code in other source files or modules.

Module: A module is a framework or application code distribution unit /

A module contains several source code files.

Source File:

The source file is a single source code file within the module.

If the AL(Access Level) of a type is defined as private, the AL of all items belonging to the type will be private.

The private access identifier, the variable we have defined in front of it, the method, etc. makes it fully available in scope.

The purpose of the fileprivate access specifier is to be accessed by another class (class) / extension (extension) defined in the same file, except for the scope in which the variable is defined.

Especially when the extension is defined in the same source file, you cannot access the objects defined as private, while using fileprivate is a good option for this.

The public access delimiter is accessible across the entire module, but can be restrictive on subclasses and scopes when two modules are used.

And you may not be able to access variables and methods that you define with public access delimiter.

A class defined with public cannot be a subclass (superclass) in another module (ie it cannot be extended) and does not allow the methods it contains to be overridden.

So we need a more flexible access specifier than public.

In short, we can say open access limiter "more public than public".

Therefore, if you will use two modules and you want to access variables and methods in one module from another module, what you will do is simple: you will include the open-access provider at the beginning of the class you set as a superclass,

Likewise, it will be sufficient to define the method you want to override.

In types other than enum, if the type is defined as public, the items are automatically internal. However, if the Enum type is defined publicly, the elements of the Enum will be public.

public enum Direction { case North, South, East, West } 
//each case is also has public access level.

Subclassing

We can create a subclass of any class. It is sufficient for the class to be accessible from the relevant context.

A subclass cannot have more access levels than its upper class. Because the upper class wraps the lower class.

The overridden method may be more accessible than the overridden method in the upper class.

public class ClassA {

//method private tanimlanmis
private func aPrivateMethod() {}

internal func anInternalMethod() {}

}

internal class ClassB: ClassA {

// The overridden method is defined internally. Access level has increased even more.
override internal func anInternalMethod() {}

}

Constants, Variables, Properties, and Subscripts Access Level

A constant, variable, or property cannot need less restricted access than the type it is linked to. Public property is like public class.

Getters and setters for constants, variables, properties, and subscripts also have the same access level as the type they belong to, like constantly or variables.

Congratulations 🎉

In this lesson, we learned Access Control on Swift.

We have now completed the Swift for Beginners course.

Let's start the exam and get our certificate. 🌟