Swift-Zugriffssteuerung

Die Zugriffskontrolle kann die Zugriffsebene von Code in anderen Quelldateien oder Modulen auf Ihren Code beschränken.

Sie können Zugriffsebenen für einzelne Typen (Klassen, Strukturen, Enumerationen) explizit festlegen und auch Zugriffsebenen für Eigenschaften, Funktionen, Initialisierer, Basistypen, Subscripts usw. dieser Typen festlegen.

Protokolle können auch auf einen bestimmten Gültigkeitsbereich beschränkt werden, einschließlich globaler Konstanten, Variablen und Funktionen im Protokoll.

Die Zugriffskontrolle basiert auf Modulen und Quelldateien.

Ein Modul bezeichnet ein Framework oder eine Anwendung, das bzw. die als unabhängige Einheit erstellt und veröffentlicht wird. In Swift kann ein Modul das Schlüsselwort import verwenden, um ein anderes Modul zu importieren.

Eine Quelldatei ist eine einzelne Quellcodedatei, die normalerweise zu einem Modul gehört. Eine Quelldatei kann Definitionen mehrerer Klassen und Funktionen enthalten.

Swift bietet vier verschiedene Zugriffsebenen für Entitäten im Code:public, internal, fileprivate, private。

Zugriffsebene Definition
public Kann auf jede Entität in Quelldateien innerhalb seines eigenen Moduls zugreifen, und andere können ebenfalls auf alle Entitäten in den Quelldateien zugreifen, indem sie das Modul importieren.
internal Kann auf jede Entität in Quelldateien innerhalb seines eigenen Moduls zugreifen, aber andere können nicht auf Entitäten in den Quelldateien dieses Moduls zugreifen.
fileprivate Privat für die Datei, kann nur in der aktuellen Quelldatei verwendet werden.
private Kann nur innerhalb der Klasse zugegriffen werden; außerhalb des Gültigkeitsbereichs der Klasse oder Struktur kann nicht darauf zugegriffen werden.

public ist die höchste Zugriffsebene, und private ist die niedrigste Zugriffsebene.

Syntax

Verwenden Sie die Modifikatoren public, internal, fileprivate und private, um die Zugriffsebene einer Entität zu deklarieren:

Beispiel

public class SomePublicClass {} internal class SomeInternalClass {} fileprivate class SomeFilePrivateClass {} private class SomePrivateClass {} public var somePublicVariable = 0 internal let someInternalConstant = 0 fileprivate func someFilePrivateFunction() {} private func somePrivateFunction() {}

Sofern nicht anders angegeben, verwenden Entitäten die Standard-Zugriffsebene internal.

Nicht angegebene Zugriffsebene ist standardmäßig internal.

class SomeInternalClass {} // Die Zugriffsebene ist internal let someInternalConstant = 0 // Die Zugriffsebene ist internal

Zugriffskontrolle für Funktionstypen

Die Zugriffsebene einer Funktion wird durch die Zugriffsebenen ihrer Parametertypen und ihres Rückgabetyps bestimmt.

Das folgende Beispiel definiert eine globale Funktion namens someFunction, ohne ihre Zugriffsebene explizit zu deklarieren.

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

Eine der Klassen in der Funktion, SomeInternalClass, hat die Zugriffsebene internal, und eine andere, SomePrivateClass, hat die Zugriffsebene private. Daher ist nach dem Prinzip der Tupel-Zugriffsebene die Zugriffsebene des Tupels private (die Zugriffsebene des Tupels entspricht der niedrigsten Zugriffsebene unter den Typen im Tupel).

Da der Rückgabetyp der Funktion die Zugriffsebene private hat, müssen Sie den private-Modifizierer verwenden, um die Funktion explizit zu deklarieren:

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

Die Funktion als public oder internal zu deklarieren oder die Standard-Zugriffsebene internal zu verwenden, ist falsch, denn wenn Sie dies tun, können Sie nicht auf den Rückgabewert mit der Zugriffsebene private zugreifen.


Zugriffskontrolle für Enumerationstypen

Die Zugriffsebene von Membern in einer Enumeration wird von der Enumeration geerbt; Sie können für Member in der Enumeration nicht individuell unterschiedliche Zugriffsebenen deklarieren.

Beispiel

Zum Beispiel wird im folgenden Beispiel die Enumeration Student explizit als public deklariert, daher haben ihre Member Name und Mark ebenfalls die Zugriffsebene public:

Beispiel

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("Student name:\(studName).") case .Mark(let Mark1, let Mark2, let Mark3): print("Student score:\(Mark1),\(Mark2),\(Mark3)") }

Die Ausgabe der obigen Programmausführung ist:

学生成绩: 98,97,95

Zugriffssteuerung für Unterklassen

Die Zugriffsebene einer Unterklasse darf nicht höher sein als die ihrer Superklasse. Wenn die Superklasse beispielsweise die Zugriffsebene internal hat, kann die Unterklasse nicht als public deklariert werden.

Beispiel

public class fileprivate { fileprivate func show() { print("Superclass") } } // Die Zugriffsebene darf nicht höher sein als die der Superklasse: public > internal class SubClass: SuperClass { override internal func show() { print("Subclass") } } let sup = SuperClass() sup.show() let sub = SubClass() sub.show()

Die Ausgabe der obigen Programmausführung ist:

Superclass

Zugriffssteuerung für Konstanten, Variablen, Eigenschaften und Subscripts

Konstanten, Variablen und Eigenschaften dürfen keine höhere Zugriffsebene haben als ihre Typen.

Wenn Sie beispielsweise eine Eigenschaft mit öffentlicher Zugriffsebene definieren, ihr Typ aber privat ist, lässt der Compiler dies nicht zu.

Ebenso kann ein Subscript keine höhere Zugriffsebene als sein Indextyp oder Rückgabetyp haben.

Wenn der definierte Typ einer Konstante, Variablen, Eigenschaft oder eines Subscript-Index privat ist, müssen sie ihre Zugriffsebene explizit als privat deklarieren:

private var privateInstance = SomePrivateClass()

Zugriffssteuerung für Getter und Setter

Die Zugriffsebenen von Gettern und Settern für Konstanten, Variablen, Eigenschaften und Subscript-Indizes werden von der Zugriffsebene des Members geerbt, zu dem sie gehören.

Die Zugriffsebene eines Setters kann niedriger sein als die Zugriffsebene des entsprechenden Getters, sodass Sie die Lese- und Schreibberechtigungen von Variablen, Eigenschaften oder Subscript-Indizes steuern können.

Beispiel

class Samplepgm { fileprivate var counter: Int = 0{ willSet(newTotal){ print("Zähler:\(newTotal)") } didSet{ if counter > oldValue { print("Neuer Inkrementbetrag\(counter - oldValue)") } } } } let NewCounter = Samplepgm() NewCounter.counter = 100 NewCounter.counter = 800

Die Zugriffsebene von counter ist fileprivate, daher kann innerhalb der Datei darauf zugegriffen werden.

Die Ausgabe der obigen Programmausführung ist:

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

Zugriffskontrolle für Initialisierer und Standardinitialisierer

Initialisierung

Wir können Zugriffsebenen für benutzerdefinierte Initialisierer deklarieren, aber sie dürfen nicht höher sein als die Zugriffsebene der Klasse, zu der sie gehören. Erforderliche Initialisierer sind jedoch eine Ausnahme; ihre Zugriffsebene muss mit der Zugriffsebene der Klasse, zu der sie gehören, übereinstimmen.

Genau wie bei Funktions- oder Methodenparametern dürfen die Zugriffsebenen von Initialisiererparametern nicht niedriger sein als die Zugriffsebene des Initialisierers.

Standardinitialisierermethoden

Swift stellt für Strukturen und Klassen einen Standardinitialisierer ohne Parameter bereit, um Zuweisungsoperationen für alle ihre Eigenschaften bereitzustellen, aber er vergibt keine spezifischen Werte.

Die Zugriffsebene eines Standardinitialisierers entspricht der Zugriffsebene seines enthaltenden Typs.

Beispiel

Verwenden Sie das Schlüsselwort required vor der init()-Methode jeder Unterklasse, um Zugriffsberechtigungen zu deklarieren.

Beispiel

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()

Die Ausgabe der obigen Programmausführung ist:

10
30
10

Zugriffssteuerung für Protokolle

Wenn Sie explizit eine Zugriffsebene für ein Protokoll deklarieren möchten, beachten Sie, dass Sie sicherstellen müssen, dass das Protokoll nur innerhalb des von Ihnen deklarierten Zugriffsebenenbereichs verwendet wird.

Wenn Sie ein Protokoll mit einer öffentlichen Zugriffsebene definieren, haben die erforderlichen Funktionen, die das Protokoll implementieren, ebenfalls eine öffentliche Zugriffsebene. Dies unterscheidet sich von anderen Typen. Zum Beispiel haben bei anderen Typen mit einer öffentlichen Zugriffsebene deren Member eine interne Zugriffsebene.

Beispiel

public protocol TcpProtocol { init(no1: Int) } public class MainClass { var no1: Int // lokaler Speicher init(no1: Int) { self.no1 = no1 // Initialisierung } } class SubClass: MainClass, TcpProtocol { var no2: Int init(no1: Int, no2 : Int) { self.no2 = no2 super.init(no1:no1) } // Erfordert nur einen Parameter für eine komfortable Methode 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 ist: \(res.no1)") print("res ist: \(show.no1)") print("res ist: \(show.no2)")

Die Ausgabe der obigen Programmausführung ist:

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

Zugriffskontrolle bei Erweiterungen

Sie können Klassen, Strukturen und Enumerationen erweitern, wenn die Bedingungen es zulassen. Mitglieder einer Erweiterung sollten dieselbe Zugriffsebene wie die Mitglieder der ursprünglichen Klasse haben. Wenn Sie beispielsweise einen öffentlichen Typ erweitern, sollten Ihre neu hinzugefügten Mitglieder standardmäßig dieselbe interne Zugriffsebene wie die ursprünglichen Mitglieder haben.

Alternativ können Sie die Zugriffsebene der Erweiterung explizit deklarieren (z. B. durch die Verwendung von private extension), um eine neue Standard-Zugriffsebene für alle Mitglieder der Erweiterung festzulegen. Diese neue Standard-Zugriffsebene kann weiterhin durch Zugriffsebenen überschrieben werden, die von einzelnen Mitgliedern deklariert werden.


Generische Zugriffskontrolle

Die Zugriffsebene eines generischen Typs oder einer generischen Funktion ist die niedrigste Zugriffsebene unter dem generischen Typ, der Funktion selbst und den generischen Typparametern.

Beispiel

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("Generisch") print(tos.items) tos.push("Typparameter") print(tos.items) tos.push("Name des Typparameters") print(tos.items) let deletetos = tos.pop()

Die Ausgabe der obigen Programmausführung ist:

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

Typaliase

Jeder Typalias, den Sie definieren, wird für Zugriffssteuerungszwecke als ein anderer Typ behandelt. Die Zugriffsebene eines Typalias darf nicht höher sein als die Zugriffsebene des ursprünglichen Typs.

Beispielsweise kann ein Typalias mit privater Zugriffsebene für einen öffentlichen, internen oder privaten Typ festgelegt werden, aber ein Typalias mit öffentlicher Zugriffsebene kann nur für einen öffentlichen Typ festgelegt werden und nicht für interne oder private Typen.

Hinweis: Diese Regel gilt auch, wenn Aliase für zugehörige Typen benannt werden, um Protokollkonformität zu erfüllen.

Beispiel

public protocol Container { typealias ItemType mutating func append(item: ItemType) var count: Int { get } subscript(i: Int) -> ItemType { get } } struct Stack<T>: Container { // ursprüngliche Stack<T>-Implementierung var items = [T]() mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } // Konformität mit dem Container-Protokoll 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 { // prüfen, ob beide Container die gleiche Anzahl von Elementen enthalten if someContainer.count != anotherContainer.count { return false } // jedes Paar von Elementen darauf prüfen, ob sie äquivalent sind for i in 0..<someContainer.count { if someContainer[i] != anotherContainer[i] { return false } } // alle Elemente stimmen überein, also true zurückgeben return true } var tos = Stack<String>() tos.push("Swift") print(tos.items) tos.push("Generic") print(tos.items) tos.push("Where-Anweisung") print(tos.items) var eos = ["Swift", "Generic", "Where-Anweisung"] print(eos)

Die Ausgabe der obigen Programmausführung ist:

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