il controllo di accesso Swift
Controllo di accesso può essere definito in altre sorgenti o moduli di codice al livello di accesso di codice.
È possibile in modo esplicito ad un unico tipo (classe, struct, enum) per impostare i livelli di accesso, può anche dare questi tipi di proprietà, funzioni, metodo di inizializzazione, il tipo di base, gli indici pedice impostare i livelli di accesso.
Accordo può anche essere limitato all'uso entro un certo intervallo, compreso l'accordo di costanti globali, variabili e funzioni.
Sulla base del modulo di controllo di accesso con i file di origine.
I moduli sono definiti da una unità separata per costruire e pubblicare Framework o applicazione. Un modulo può essere utilizzato nel Swift la parola import introduce un altro modulo.
Il file sorgente è un singolo file sorgente, che di solito appartiene a un modulo che contiene i file di origine possono definire più classi e funzioni.
Swift offre tre diversi livelli di accesso entità codice: pubblico, interno, privato.
| Livello di accesso | definizioni |
|---|---|
| pubblico | Qualsiasi entità che possono accedere ai file nel modulo di origine, altri possono accedere ai file di origine di tutte le entità attraverso l'introduzione del modulo. |
| interno | : I soggetti che possono accedere ai file nel modulo di origine, ma gli altri non possono accedere le entità di file del modulo di sorgenti. |
| privato | Utilizzare solo entità nel file sorgente di corrente, conosciuto come un ente privato. |
l'accesso del pubblico al livello più avanzato, privato è il più basso livello di accesso.
grammatica
Dichiarando modificatori pubblico, privato, accesso entità interne livello:
public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}
public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}
A meno che non ci sono istruzioni speciali, altrimenti soggetti utilizzano il livello di accesso predefinito interno.
Tipo Funzione Accesso
Livelli di accesso basati su parametri funzione derivati richiede il tipo di tipo di ritorno della funzione e il livello di accesso.
L'esempio seguente definisce una funzione globale chiamato someFunction, e non afferma esplicitamente il loro livello di accesso.
func someFunction() -> (SomeInternalClass, SomePrivateClass) {
// 函数实现
}
Funzione in una delle classi SomeInternalClass livello di accesso è interno, l'altro livello di accesso SomePrivateClass è privato. Pertanto, secondo il principio del livello di accesso tupla, il livello di accesso tupla è privato.
Poiché la funzione restituisce il tipo di livello di accesso è privata, quindi è necessario utilizzare il modificatore privato dichiarare esplicitamente la funzione:
private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
// 函数实现
}
Questa funzione è dichiarata come pubblico o interna, o utilizzare il valore di default livelli di accesso interne sono sbagliate.
Accesso tipo enumerato
i membri di enumerazione livello di accesso ereditati dalla enumerazione, non è possibile enumerare i membri di una separata dichiarazione diversi livelli di accesso.
Esempi
Ad esempio, il seguente esempio, lo studente di enumerazione è esplicitamente dichiarato come livello di pubblico, quindi i suoi membri Nome, livello di accesso di Marco è anche pubblico:
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)")
}
L'output sopra l'esecuzione del programma è il seguente:
学生成绩: 98,97,95
accesso sottoclassi
Livello di accesso sottoclasse non deve superare il livello di accesso della classe padre. Ad esempio, il livello di accesso della classe padre è interno, il livello di accesso della sottoclasse non può essere dichiarato come pubblico.
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()
L'output sopra l'esecuzione del programma è il seguente:
超类 子类
Costanti, variabili, le proprietà, l'accesso indice
Costanti, variabili, gli attributi non possono avere più di loro tipo di livelli di accesso.
Ad esempio, si definisce un livello di proprietà pubblica, ma è il tipo di livello privato, che non è consentita dal compilatore.
Analogamente, l'indice non può avere un rendimento superiore al tipo di indice o tipi di livelli di accesso.
Se le costanti, variabili, le proprietà, il tipo di indice pedice definito sia a livello privato, essi devono essere chiaramente indicati il livello di accesso a privati:
private var privateInstance = SomePrivateClass()
Getter e l'accesso Setter
Getters e costanti del livello di accesso Setter, le variabili, le proprietà, l'indice pedice ereditati dal livello di accesso a cui appartengono i membri.
livelli di accesso Setter possono essere inferiori al livello di accesso corrispondente Getter, in modo da poter controllare le variabili, le proprietà o di un indice indice di lettura e scrittura.
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
L'output sopra l'esecuzione del programma è il seguente:
计数器: 100 新增加数量 100 计数器: 800 新增加数量 700
Costruttore e costruttore di default l'accesso
inizializzazione
Possiamo personalizzare il metodo di inizializzazione di dichiarare il livello di accesso, ma appartiene alla classe oppure più alto livello di accesso. Ma deroga necessaria costruttore, deve accedere livello e l'accesso allo stesso livello della loro classe.
Come una funzione o metodo parametri, metodo di parametri di inizializzazione del livello di accesso non può essere inferiore al metodo di inizializzazione livello di accesso.
Il metodo di inizializzazione di default
Swift è una struttura, la classe fornisce un metodo di inizializzazione predefinito senza parametri, per tutte le loro proprietà di fornire assegnazione, ma non fornisce un valore specifico.
Il metodo di inizializzazione predefinito appartiene allo stesso livello di accesso e il tipo di livello di accesso.
Esempi
Utilizzare l'istruzione parola chiave richiesto prima metodo di accesso init () in ogni sottoclasse.
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()
L'output sopra l'esecuzione del programma è il seguente:
10 30 10
accordo di accesso
Se si desidera un chiaro accordo afferma il livello di accesso, dobbiamo notare che si vuole fare in modo che l'accordo viene utilizzato solo nel ruolo di livello di accesso avete dichiarato dominio.
Se si definisce un protocollo di livello di accesso pubblico, per realizzare la funzione necessaria dell'accordo sarà fornito dal livello di accesso pubblico. Questo è diverso da altri tipi, come altri tipi di livello di accesso pubblico, il livello di accesso per i membri della loro interno.
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)")
L'output sopra l'esecuzione del programma è il seguente:
res is: 20 res is: 30 res is: 50
accesso esteso
È possibile nelle condizioni di permettere la classe, la struttura, l'espansione enumerazione. i membri estesi dei membri della classe originali dovrebbero avere lo stesso livello di accesso. Ad esempio, si estende un tipo comune, poi si aggiungono i nuovi membri dovrebbero avere gli stessi membri del livello di accesso interno predefinito originale.
In alternativa, è possibile dichiarare in modo esplicito il livello esteso di accesso (ad esempio l'uso di estensione privata) entro l'estensione a tutti i membri affermare un nuovo livello di accesso predefinito. Il nuovo livello di accesso predefinito può ancora affermare singolo membro coperto dal livello di accesso.
Generic Access
tipo generico livello di accesso o funzioni generiche per prendere il tipo generico, la funzione stessa, il tipo di parametro generico dei tre livelli più bassi di accesso.
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()
L'output sopra l'esecuzione del programma è il seguente:
["Swift"] ["Swift", "泛型"] ["Swift", "泛型", "类型参数"] ["Swift", "泛型", "类型参数", "类型参数名"]
alias Tipo
Tutto ciò che si digita alias sarà definito come un tipo differente, in modo da facilitare il controllo degli accessi. Livello di accesso di tipo tipo alias non può essere superiore al livello originale dell'accesso.
Ad esempio, un tipo di classe privata alias possono essere assegnati a un tipo privato interno nel settore pubblico, ma un tipo livello pubblico alias possono essere impostati solo ad un tipo di livello di pubblico non può essere impostato a livello di tipo interno o privato .
Nota: Questa regola vale anche per il caso al fine di soddisfare la conformità del protocollo per il nome del tipo pertinente e un alias.
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)
L'output sopra l'esecuzione del programma è il seguente:
["Swift"] ["Swift", "泛型"] ["Swift", "泛型", "Where 语句"] ["Swift", "泛型", "Where 语句"]