Swift Language => Contrôle d'accès

Syntaxe

Projet de classe privée
let car = Car ("Ford", modèle: "Escape") // par défaut interne
enum public
func calcaire à calculerMarketCap ()
remplacer la configuration interne du func setupView ()
private (set) var area = 0

Remarques

Remarque de base:

Vous trouverez ci-dessous les trois niveaux d'accès du plus haut accès (le moins restrictif) au plus faible accès (le plus restrictif).

L' accès public permet d'accéder aux classes, aux structures, aux variables, etc. à partir de n'importe quel fichier du modèle, mais plus important encore en dehors du module si le fichier externe importe le module contenant le code d'accès public. Il est populaire d'utiliser l'accès public lorsque vous créez un cadre.

L' accès interne permet aux fichiers uniquement avec le module des entités d'utiliser les entités. Toutes les entités ont un niveau d'accès interne par défaut (à quelques exceptions près).

L' accès privé empêche l'entité d'être utilisée en dehors de ce fichier.

Sous-classement Remarque:

Une sous-classe ne peut pas avoir un accès plus élevé que sa super-classe.

Getter & Setter Remarque:

Si le setter de la propriété est privé, le getter est interne (qui est la valeur par défaut). Vous pouvez également attribuer un niveau d'accès à la fois au getter et au setter. Ces principes s’appliquent également aux indices

Remarque générale:

Les autres types d'entité incluent: les initialiseurs, les protocoles, les extensions, les génériques et les alias de type.

Exemple de base utilisant une structure

3.0

Dans Swift 3, il y a plusieurs niveaux d'accès. Cet exemple les utilise tous sauf pour open :

public struct Car {
    
    public let make: String
    let model: String //Optional keyword: will automatically be "internal"
    private let fullName: String
    fileprivate var otherName: String
    
    public init(_ make: String, model: String) {
        self.make = make
        self.model = model
        self.fullName = "\(make)\(model)"
        self.otherName = "\(model) - \(make)"
    }
}

Supposons que myCar été initialisé comme ceci:

let myCar = Car("Apple", model: "iCar")

Car.make (public)

print(myCar.make)

Cette impression fonctionnera partout, y compris les cibles qui importent de la Car .

Car.model (interne)

print(myCar.model)

Cela compilera si le code est dans la même cible que Car .

Car.otherName (fichierprivate)

print(myCar.otherName)

Cela ne fonctionnera que si le code est dans le même fichier que Car .

Car.fullName (privé)

print(myCar.fullName)

Cela ne fonctionnera pas dans Swift 3. Les propriétés private ne sont accessibles que dans la même struct / class .

public struct Car {

    public let make: String       //public
    let model: String             //internal
    private let fullName: String! //private 

    public init(_ make: String, model model: String) {
        self.make = make
        self.model = model
        self.fullName = "\(make)\(model)"
    }
}

Si l'entité a plusieurs niveaux d'accès associés, Swift recherche le niveau d'accès le plus bas. Si une variable privée existe dans une classe publique, la variable sera toujours considérée comme privée.

Exemple de sous-classement

public class SuperClass {
    private func secretMethod() {}
}
 
internal class SubClass: SuperClass {
    override internal func secretMethod() {
        super.secretMethod()
    }
}

Exemple de Getters et Setters

struct Square {
    private(set) var area = 0

    var side: Int = 0 {
        didSet {
            area = side*side
        }
    }
}

public struct Square {
    public private(set) var area = 0
    public var side: Int = 0 {
        didSet {
            area = side*side
        }
    }
    public init() {}
}

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

Swift Language
Contrôle d'accès

Recherche…