contrôle d'accès Swift

Précédent: Swift Générique

Le contrôle d'accès peut être défini dans d'autres fichiers sources ou des modules de code à votre niveau d'accès au code.

Vous pouvez explicitement à un seul type (classe, struct, enum) pour définir les niveaux d'accès, peut également donner à ces types de propriétés, les fonctions, la méthode d'initialisation, le type de base, les indices en indice établissent des niveaux d'accès.

Accord peut également être limitée à une utilisation dans une certaine fourchette, y compris l'accord de constantes globales, variables et fonctions.

Basé sur des modules de contrôle d'accès aux fichiers source.

Les modules sont définis par une unité distincte pour construire et publier cadre ou d'une application. Un module peut être utilisé dans la Swift dans le mot-clé import introduit un autre module.

Le fichier source est un fichier source unique, qui appartient généralement à un module qui contient les fichiers source peuvent définir plusieurs classes et fonctions.

Swift fournit trois niveaux différents de code d'accès entité: public, interne, privé.

Niveau d'accès	Définitions
public	Toute entité qui peut accéder à vos fichiers dans le module source, d'autres peuvent accéder aux fichiers source de toutes les entités à travers la mise en place du module.
interne	: Toute entité qui peut accéder à vos fichiers dans le module source, mais d'autres ne peuvent pas accéder à la source des entités de fichiers de module.
privé	Utilisez seule entité dans le fichier source de courant, connu sous le nom d'une entité privée.

l'accès du public au niveau le plus avancé, privé est le plus bas niveau d'accès.

grammaire

En déclarant modificateurs public, accès privé entités de niveau interne:

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

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

Sauf il y a des instructions spéciales, sinon entités utilisent le niveau d'accès par défaut interne.

Fonction Type d'accès

Les niveaux d'accès en fonction des paramètres fonction dérivés nécessite le type de type de retour de la fonction et le niveau d'accès.

L'exemple suivant définit une fonction globale de someFunction nommé, et ne confirme pas explicitement leur niveau d'accès.

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

Fonction dans l'un des niveaux d'accès aux classes de est interne, l'autre niveau d'accès SomePrivateClass est privé. Par conséquent, selon le principe de l'uplet de niveaux d'accès, le niveau d'accès est nuplet privé.

Parce que la fonction retourne le type du niveau d'accès est privé, vous devez donc utiliser le modificateur privé déclarer explicitement la fonction:

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

Cette fonction est déclarée comme public ou interne, ou utiliser la valeur par défaut des niveaux d'accès internes sont erronés.

Accès type énuméré

membres de l'énumération de niveau d'accès hérités de l'énumération, vous ne pouvez pas énumérer les membres d'une déclaration séparée différents niveaux d'accès.

Exemples

Par exemple, l'exemple suivant, l'étudiant d'énumération est explicitement déclaré que le niveau du public, puis ses membres Nom, le niveau d'accès de Mark est aussi publique:

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)")
}

La sortie de l'exécution du programme ci-dessus est la suivante:

学生成绩: 98,97,95

l'accès sous-classes

sous-classe de niveau d'accès ne doit pas dépasser le niveau d'accès de la classe parent. Par exemple, le niveau de la classe parente d'accès est interne, le niveau de la sous-classe d'accès ne peut pas être déclarée publique.

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

La sortie de l'exécution du programme ci-dessus est la suivante:

超类
子类

Constantes variables, propriétés, accès à l'index

Constantes, les variables, les attributs ne peuvent pas avoir plus que leur type de niveaux d'accès.

Par exemple, vous définissez un niveau de la propriété publique, mais il est le type de niveau privé, ce qui est interdit par le compilateur.

De même, l'indice ne peut pas avoir un rendement plus élevé que le type d'index ou les types de niveaux d'accès.

Si les constantes, les variables, les propriétés, le type indice de l'indice défini est le niveau privé, ils doivent être clairement indiqués le niveau d'accès au privé:

private var privateInstance = SomePrivateClass()

Getter et l'accès Setter

Absorbantes et des constantes de niveau d'accès Setters, les variables, les propriétés, l'indice de l'indice héritées du niveau d'accès appartiennent aux membres.

les niveaux d'accès Setter peut être inférieur au niveau d'accès Getter correspondant, de sorte que vous pouvez contrôler les variables, les propriétés ou de l'indice de l'indice autorisations de lecture et d'écriture.

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

La sortie de l'exécution du programme ci-dessus est la suivante:

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

accès Constructor et constructeur par défaut

Initialisation

Nous pouvons personnaliser la méthode d'initialisation de déclarer le niveau d'accès, mais il appartient à la classe ou encore niveau d'accès. Mais le constructeur nécessaire exception, il doit accéder au niveau et l'accès au même niveau de leur classe.

En fonction des paramètres ou méthode, la méthode de paramètres d'initialisation du niveau d'accès ne peut pas être inférieure à la méthode d'initialisation du niveau d'accès.

Le procédé d'initialisation par défaut,

Swift est une structure, la classe fournit une méthode d'initialisation par défaut sans paramètres, pour l'ensemble de leurs biens pour fournir cession, mais ne donne pas une valeur spécifique.

La méthode d'initialisation par défaut appartient au même niveau d'accès et le type de niveau d'accès.

Exemples

Utilisez l'instruction mot-clé nécessaire avant la méthode d'accès () init dans chaque sous-classe.

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

La sortie de l'exécution du programme ci-dessus est la suivante:

10
30
10

Accord d'accès

Si vous voulez un accord clair affirme le niveau d'accès, il faut noter que vous voulez vous assurer que l'accord est utilisé uniquement dans le rôle du niveau d'accès que vous avez dit domaine.

Si vous définissez un protocole de niveau d'accès public, pour réaliser la fonction nécessaire de l'accord, il sera fourni par le niveau d'accès public. Ceci est différent des autres types, tels que d'autres types de niveau d'accès du public, le niveau d'accès pour les membres de leur intérieur.

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

La sortie de l'exécution du programme ci-dessus est la suivante:

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

accès étendu

Vous pouvez dans les conditions permettent la classe, la structure, l'expansion de l'énumération. membres étendus des membres originaux de la classe doivent avoir le même niveau d'accès. Par exemple, vous étendez un type commun, alors vous ajoutez les nouveaux membres devraient avoir les mêmes membres du niveau d'accès interne par défaut d'origine.

Alternativement, vous pouvez déclarer explicitement le niveau d'accès (tels que l'utilisation de l'extension privée) dans le prolongement étendu à tous les membres affirment un nouveau niveau d'accès par défaut. Le nouveau niveau d'accès par défaut peut encore être affirmé membre individuel couvert par le niveau d'accès.

Generic Access

Niveau d'accès de type générique ou fonctions génériques de prendre le type générique, la fonction elle-même, le type paramètre générique des trois niveaux les plus bas d'accès.

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

La sortie de l'exécution du programme ci-dessus est la suivante:

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

alias Type

Tout ce que vous tapez alias sera défini comme un type différent, afin de faciliter le contrôle d'accès. niveau d'un type type d'alias d'accès ne peut pas être plus élevé que le niveau initial de l'accès.

Par exemple, un alias de type classe privée peuvent être affectés à un, de type privé public interne, mais un alias de type niveau public ne peuvent être réglées à un type de niveau publique ne peut pas être réglé sur le type de niveau interne ou privé .

Note: Cette règle vaut également pour le cas afin de répondre protocole conformité au nom du type pertinent et un pseudonyme.

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)

La sortie de l'exécution du programme ci-dessus est la suivante:

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

Précédent: Swift Générique

Swift cours

contrôle d'accès Swift

grammaire

Fonction Type d'accès

Accès type énuméré

Exemples

l'accès sous-classes

Constantes variables, propriétés, accès à l'index

Getter et l'accès Setter

accès Constructor et constructeur par défaut

Initialisation

Le procédé d'initialisation par défaut,

Exemples

Accord d'accès

accès étendu

Generic Access

alias Type