Swift Language => Control de acceso

Sintaxis

Proyecto de clase privada
let car = Car ("Ford", modelo: "Escape") // predeterminado interno
Enumeración pública Género
función privada calculaMarketCap ()
anular la función interna setupView ()
área de var privado (conjunto) = 0

Observaciones

Observación básica:

A continuación se muestran los tres niveles de acceso desde el acceso más alto (menos restrictivo) al acceso más bajo (más restrictivo)

El acceso público permite acceder a clases, estructuras, variables, etc. desde cualquier archivo dentro del modelo, pero más importante fuera del módulo si el archivo externo importa el módulo que contiene el código de acceso público. Es popular utilizar el acceso público al crear un marco.

El acceso interno permite que los archivos solo con el módulo de las entidades utilicen las entidades. Todas las entidades tienen un nivel de acceso interno por defecto (con algunas excepciones).

El acceso privado evita que la entidad se use fuera de ese archivo.

Observación de subclases:

Una subclase no puede tener un acceso más alto que su superclase.

Observación de Getter & Setter:

Si el establecedor de la propiedad es privado, el captador es interno (que es el predeterminado). También puede asignar un nivel de acceso para el getter y el setter. Estos principios también se aplican a los subíndices también

Observación General:

Otros tipos de entidades incluyen: Inicializadores, Protocolos, Extensiones, Genéricos y Alias de Tipo

Ejemplo básico usando un Struct

3.0

En Swift 3 hay múltiples niveles de acceso. Este ejemplo los usa a todos excepto para 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)"
    }
}

Supongamos que myCar se inicializó así:

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

Car.make (público)

print(myCar.make)

Esta impresión funcionará en todas partes, incluidos los objetivos que importan Car .

Car.model (interno)

print(myCar.model)

Esto se compilará si el código está en el mismo objetivo que Car .

Car.otherName (fileprivate)

print(myCar.otherName)

Esto solo funcionará si el código está en el mismo archivo que Car .

Car.fullName (privado)

print(myCar.fullName)

Esto no funcionará en Swift 3. Las propiedades private solo se pueden acceder dentro de la misma 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 la entidad tiene múltiples niveles de acceso asociados, Swift busca el nivel de acceso más bajo. Si existe una variable privada en una clase pública, la variable aún se considerará privada.

Ejemplo de subclasificación

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

Getters and Setters Ejemplo

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

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

Swift Language
Control de acceso

Buscar..