Swift контроля доступа

Контроль доступа может быть определено в других исходных файлов или модулей кода вашего уровня доступа к коду.

Вы можете явно к одному типу (класс, структура, перечислений), чтобы установить уровни доступа, также может дать эти типы свойств, функций, метод инициализации, базовый тип, индексы подстрочные установить уровни доступа.

Соглашение также может быть ограничено использованием в пределах определенного диапазона, в том числе соглашения в глобальные константы, переменные и функции.

На основе модуля контроля доступа с исходными файлами.

Модули определяются отдельным блоком для создания и публикации Framework или приложения. Модуль может быть использован в Swift в импорте ключевое слово вводит еще один модуль.

Исходный файл представляет собой один исходный файл, который обычно относится к модулю, который содержит исходные файлы можно определить несколько классов и функций.

Swift обеспечивает три различных уровней кода субъекта доступа: общественный, внутренний, частный.

Уровень доступа	Определения
общественного	Любой объект, который может получить доступ к файлам в исходном модуле, другие могут получить доступ к исходным файлам всех субъектов путем внедрения модуля.
внутренний	: Любой объект, который может получить доступ к файлам в исходном модуле, но другие не могут получить доступ к сущности модуль исходных файлов.
частный	Используйте только объект в текущем исходном файле, известном как частное юридическое лицо.

доступ общественности к наиболее продвинутого уровня, частный самый низкий уровень доступа.

грамматика

Объявив модификаторы общественности, внутренние, объекты на уровне частного доступа:

public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}

public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}

Если нет специальных указаний, в противном случае объекты используют уровень доступа по умолчанию внутренний.

---

Функция Тип доступа

Уровни доступа на основе параметров, полученных функции требуется тип возвращаемого типа функцию и уровня доступа.

Следующий пример определяет названный SomeFunction глобальную функцию, и не явным образом подтвердить их уровень доступа.

func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // 函数实现
}

Функция в одном из классов SomeInternalClass уровня доступа является внутренним, а другой уровень доступа SomePrivateClass является частным. Поэтому, в соответствии с принципом уровня доступа кортежа, уровень доступа кортеж является частным.

Поскольку функция возвращает тип уровня доступа является частным, поэтому вы должны использовать частный модификатор явно объявить функцию:

private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // 函数实现
}

Эта функция объявлена ​​как общий или внутренний, или использовать по умолчанию внутренние уровни доступа неправильно.

---

Доступ к перечислимого типа

Члены перечисления уровня доступа, унаследованные от перечисления, вы не можете перечислить членов отдельной декларации различных уровней доступа.

примеров

Например, в следующем примере, перечисление Student явно объявлен как публичный уровень, то ее члены имя, уровень Марка доступа также общественности:

public enum Student {
    case Name(String)
    case Mark(Int,Int,Int)
}

var studDetails = Student.Name("Swift")
var studMarks = Student.Mark(98,97,95)

switch studMarks {
case .Name(let studName):
    print("学生名: \(studName).")
case .Mark(let Mark1, let Mark2, let Mark3):
    print("学生成绩: \(Mark1),\(Mark2),\(Mark3)")
}

Выход выше выполнение программы:

学生成绩: 98,97,95

---

Подклассы доступ

Уровень доступа подкласс не должен превышать уровень доступа родительского класса. Например, уровень доступа родительского класса является внутренним, уровень доступа подкласса не может быть объявлен как общественности.

public class SuperClass {
    private func show() {
        print("超类")
    }
}

// 访问级别不能低于超类 internal > public
internal class SubClass: SuperClass  {
    override internal func show() {
        print("子类")
    }
}

let sup = SuperClass()
sup.show()

let sub = SubClass()
sub.show()

Выход выше выполнение программы:

超类
子类

---

Константы, переменные, свойства, доступ индекс

Константы, переменные, атрибуты не могут иметь больше, чем их типа уровней доступа.

Например, можно определить уровень общественной собственности, но это тип частного уровня, который не допускается компилятором.

Аналогичным образом, индекс не может иметь более высокую доходность, чем тип индекса или типов уровней доступа.

Если константы, переменные, свойства, индекс индекс определен тип частного уровня, они должны быть четко определены уровень доступа к частному:

private var privateInstance = SomePrivateClass()

---

Getter и Setter доступ

Геттеры и константы уровня доступа сеттеры, переменные, свойства, индекс индекс унаследовал от уровня доступа к которой они принадлежат членам.

Сеттер уровни доступа могут быть ниже уровня доступа, соответствующей Getter, так что вы можете контролировать переменные, свойства или индекс индекс разрешения чтения и записи.

class Samplepgm {
    private var counter: Int = 0{
        willSet(newTotal){
            print("计数器: \(newTotal)")
        }
        didSet{
            if counter > oldValue {
                print("新增加数量 \(counter - oldValue)")
            }
        }
    }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

Выход выше выполнение программы:

计数器: 100
新增加数量 100
计数器: 800
新增加数量 700

---

Конструктор и по умолчанию конструктор доступа

инициализация

Мы можем настроить метод инициализации объявить уровень доступа, но он относится к классу или еще более высокий уровень доступа. Но необходимо конструктор исключения, он должен получить доступ к уровню и доступ к такому же уровню своего класса.

В качестве функции или метода параметров, метод инициализации параметров уровня доступа не может быть меньше, чем метод инициализации уровня доступа.

Способ инициализации по умолчанию

Swift представляет собой структуру, класс предоставляет метод инициализации по умолчанию без параметров, для всех их имущества, чтобы обеспечить назначение, но не дает конкретного значения.

Метод инициализации по умолчанию, относится к тому же уровню доступа и типа уровня доступа.

примеров

Используйте оператор ключевое слово, необходимое до того метода доступа () инициализации в каждом подклассе.

class classA {
    required init() {
        var a = 10
        print(a)
    }
}

class classB: classA {
    required init() {
        var b = 30
        print(b)
    }
}

let res = classA()
let show = classB()

Выход выше выполнение программы:

10
30
10

---

соглашение о доступе

Если вы хотите, четкое соглашение подтверждает уровень доступа, необходимо отметить, что вы хотите, чтобы убедиться, что соглашение используется только в роли уровня доступа вы заявили домен.

Если определить протокол уровня общественного доступа, для достижения необходимой функции соглашения будет обеспечено на уровне общественного доступа. Это отличается от других типов, таких как другие типы уровня общественного доступа, уровень доступа для членов их внутреннего.

public protocol TcpProtocol {
    init(no1: Int)
}

public class MainClass {
    var no1: Int // local storage
    init(no1: Int) {
        self.no1 = no1 // initialization
    }
}

class SubClass: MainClass, TcpProtocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }
    
    // Requires only one parameter for convenient method
    required override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}

let res = MainClass(no1: 20)
let show = SubClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(show.no1)")
print("res is: \(show.no2)")

Выход выше выполнение программы:

res is: 20
res is: 30
res is: 50

---

Расширенный доступ

Вы можете в соответствии с условиями позволяют класс, структуру, расширение перечисления. Расширенные члены первоначальных членов класса должны иметь одинаковый уровень доступа. Например, вы расширяете общий тип, то вы добавляете новые члены должны иметь те же члены уровня доступа к внутренним элементам оригинала по умолчанию.

В качестве альтернативы, вы можете явно объявить расширенный уровень доступа (например, использование частного расширения) в рамках расширения, чтобы все члены утвердить новый уровень доступа по умолчанию. Новый уровень доступа по умолчанию все еще может быть подтвержден индивидуальный элемент, покрытый уровнем доступа.

---

Generic Access

Уровень доступа универсального типа или функции взять общий тип, саму функцию, а общий тип параметра из трех самых низких уровней доступа.

public struct TOS<T> {
    var items = [T]()
    private mutating func push(item: T) {
        items.append(item)
    }
    
    mutating func pop() -> T {
        return items.removeLast()
    }
}

var tos = TOS<String>()
tos.push("Swift")
print(tos.items)

tos.push("泛型")
print(tos.items)

tos.push("类型参数")
print(tos.items)

tos.push("类型参数名")
print(tos.items)
let deletetos = tos.pop()

Выход выше выполнение программы:

["Swift"]
["Swift", "泛型"]
["Swift", "泛型", "类型参数"]
["Swift", "泛型", "类型参数", "类型参数名"]

---

Тип псевдонима

Все что вы псевдонимами будет определяться как другой тип, с тем чтобы облегчить управление доступом. Уровень доступа типа псевдоним типа не может быть выше, чем исходный уровень доступа.

Например, личный тип класса псевдонимы могут быть отнесены к государственным, частным, внутренним типа, а тип общественного уровня псевдонимы могут быть установлены только на тип общественного уровня не может быть установлен на внутренней или частного типа уровня ,

Примечание: Это правило также применимо к случаю, в целях удовлетворения протокола соответствия соответствующему имени типа и псевдонима.

public protocol Container {
    typealias ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

struct Stack<T>: Container {
    // original Stack<T> implementation
    var items = [T]()
    mutating func push(item: T) {
        items.append(item)
    }
    
    mutating func pop() -> T {
        return items.removeLast()
    }
    
    // conformance to the Container protocol
    mutating func append(item: T) {
        self.push(item)
    }
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> T {
        return items[i]
    }
}

func allItemsMatch<
    C1: Container, C2: Container
    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
    (someContainer: C1, anotherContainer: C2) -> Bool {
        // check that both containers contain the same number of items
        if someContainer.count != anotherContainer.count {
            return false
        }
        
        // check each pair of items to see if they are equivalent
        for i in 0..<someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }
        
        // all items match, so return true
        return true
}

var tos = Stack<String>()
tos.push("Swift")
print(tos.items)

tos.push("泛型")
print(tos.items)

tos.push("Where 语句")
print(tos.items)

var eos = ["Swift", "泛型", "Where 语句"]
print(eos)

Выход выше выполнение программы:

["Swift"]
["Swift", "泛型"]
["Swift", "泛型", "Where 语句"]
["Swift", "泛型", "Where 语句"]