Latest web development tutorials

Swift kontrola dostępu

Kontrola dostępu może być zdefiniowana w innych plikach źródłowych lub moduły kodu do swojego poziomu dostępu kodu.

Można wyraźnie do jednego typu (klasa, struct, enum), aby ustawić poziom dostępu, może dać tego typu właściwości, funkcji, sposobu inicjalizacji, podstawowy typ, indeksy indeksie dolnym ustawić poziom dostępu.

Umowa może być również ograniczone do wykorzystania w pewnym zakresie, w tym umowy w stałych globalnych, zmiennych i funkcji.

Moduł kontroli dostępu oparty na plikach źródłowych.

Moduły są zdefiniowane przez oddzielną jednostkę do tworzenia i publikowania Framework lub aplikacji. Moduł może być stosowany w Swift kluczowym importu wprowadza inny moduł.

Plik źródłowy jest pojedynczy plik źródłowy, który zazwyczaj należy do modułu, który zawiera pliki źródłowe można zdefiniować wiele klas i funkcji.

Swift oferuje trzy różne poziomy dostępu do kodu jednostki Publiczna wewnętrzna, prywatna.

Poziom dostępu definicje
publiczny Każdy podmiot, który może uzyskać dostęp do plików w module źródłowym, inni mogą uzyskać dostęp do plików źródłowych wszystkich podmiotów poprzez wprowadzenie modułu.
wewnętrzny : Każdy podmiot, który może uzyskać dostęp do plików w module źródłowym, ale inni nie mogą uzyskać dostęp do plików podmioty Moduł źródła.
prywatny Używaj tylko podmiot w pliku źródłowym prąd, znany jako prywatny podmiot.

Publiczny dostęp do najbardziej zaawansowanym poziomie, prywatna jest najniższy poziom dostępu.

gramatyka

Deklarując modyfikatorów publiczną, wewnętrznych podmioty prywatne na poziomie dostępu: 

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

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

O ile nie ma specjalnych instrukcji, w przeciwnym razie podmioty użyć domyślny poziom dostępu wewnętrznego.

Typ funkcji Dostęp

Poziomy dostępu w oparciu o parametry funkcji pochodnych wymaga typ typ zwracany przez funkcję, a poziom dostępu.

Poniższy przykład definiuje funkcję o nazwie someFunction globalny, a nie jednoznacznie potwierdzają ich poziom dostępu. 

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

Funkcja w jednym poziomie dostępu klasach SomeInternalClass ma charakter wewnętrzny, drugi poziom dostępu SomePrivateClass jest prywatny. Dlatego, zgodnie z zasadą poziom dostępu krotki, poziom dostępu krotka jest prywatny.

Ponieważ funkcja zwraca typ poziom dostępu jest prywatny, więc trzeba korzystać z prywatnej modyfikator jawnie zadeklarować funkcję: 
private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // 函数实现
}

Ta funkcja jest zadeklarowana jako publiczne lub wewnętrzne lub użyj domyślnego wewnętrzne poziomy dostępu są błędne.

Dostęp typu wyliczeniowego

członkowie wyliczenia poziomu dostępu dziedziczona z wyliczeniem, nie można wyliczyć członków oddzielnej deklaracji różnych poziomów dostępu.

Przykłady

Na przykład, następujący przykład Student wyliczenie jest jawnie zadeklarowane jako poziomie publicznym, to jego członkowie Name poziom Marka dostępu jest także publiczna: 

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

Wyjście powyżej wykonywanie programu jest: 

学生成绩: 98,97,95

Dostęp do podklasy

Poziom dostępu podklasa nie przekracza poziomu dostępu klasy nadrzędnej. Na przykład, poziom dostępu klasy dominującej jest wewnętrzne, poziom dostępu z podklasy nie mogą być zadeklarowane jako publiczne. 

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

Wyjście powyżej wykonywanie programu jest: 

超类
子类

Stałe, zmienne, właściwości, dostęp do indeksu

Stałe, zmienne, atrybuty nie mogą mieć więcej niż ich rodzaju poziomów dostępu.

Na przykład, można zdefiniować poziom własności publicznej, ale jest to rodzaj poziomie prywatnym, co jest niedozwolone przez kompilator.

Podobnie, indeks nie może mieć wyższy zwrot niż indeksu lub rodzaje poziomów dostępu.

Jeśli stałe, zmienne, właściwości, indeks dolny typ zdefiniowany jest poziom prywatnych, muszą być jasno określone poziom dostępu do prywatnych: 

private var privateInstance = SomePrivateClass()

Getter i Setter dostępu

Pobierające i stałe poziomu dostępu setery, zmienne, właściwości, indeks dolny dziedziczone z poziomu dostępu należą do członków.

Setter poziomów dostępu może być niższy niż poziom dostępu odpowiadającego Getter, dzięki czemu można kontrolować zmienne, właściwości lub indeks dolny odczytu i zapisu. 

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

Wyjście powyżej wykonywanie programu jest: 

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

Konstruktor i konstruktor domyślny dostęp

Inicjowanie

Możemy dostosować metody inicjalizacji zadeklarować poziom dostępu, ale to należy do klasy lub innego wyższego poziomu dostępu. Ale konieczne Konstruktor wyjątku, musi przejść poziom i dostęp do tego samego poziomu swojej klasie.

Ponieważ funkcja lub metoda parametrów metody parametrów inicjalizacji poziom dostępu nie może być mniejsza niż metoda inicjalizacji poziom dostępu.

Domyślna metoda inicjalizacji

Swift jest strukturą, klasa stanowi domyślną metodę inicjalizacji bez parametrów, dla wszystkich ich własności świadczenia zadanie, ale nie daje konkretną wartość.

Sposób inicjalizacji domyślnie należy do tego samego poziomu dostępu i rodzaju poziomu dostępu.

Przykłady

Użyj słowa kluczowego wymaganego oświadczenia przed metody dostępu () inicjujący każdej podklasy. 

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

Wyjście powyżej wykonywanie programu jest: 

10
30
10

Umowa dostępu

Jeśli chcesz wyraźna zgoda potwierdza poziom dostępu, musimy pamiętać, że chcesz, aby upewnić się, że umowa jest używany tylko w roli poziomu dostępu podanej domeny.

Jeśli zdefiniować protokół poziomu dostępu publicznego, w celu osiągnięcia wymaganego funkcję umowy zostanie dostarczone przez poziom dostępu publicznego. To różni się od innych typów, takich jak inne typy poziomu dostępu publicznego, poziom dostępu dla członków ich wewnętrzna. 

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

Wyjście powyżej wykonywanie programu jest: 

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

Rozszerzony dostęp

Można na warunkach pozwalają danej klasy, struktury, ekspansję wyliczenia. Rozszerzone członkowie oryginalnych członków klasy powinny mieć ten sam poziom dostępu. Na przykład rozszerzyć wspólny typ, a następnie dodać nowych członków powinny mieć takie same członków oryginalna domyślnego poziomu dostępu wewnętrznego.

Alternatywnie, można jawnie zadeklarować rozszerzony poziom dostępu (takich jak korzystanie z rozszerzeniem prywatnym) w ramach rozszerzenia do wszystkich członków potwierdzają nowy domyślny poziom dostępu. Nowy domyślny poziom dostępu może być jeszcze potwierdzone indywidualny członkowskich objętych poziomem dostępu.

Generic Access

Poziom dostępu rodzajowe funkcje rodzajowe typu lub podjąć typu rodzajowego, samą funkcję, rodzajowego parametr typu z trzech najniższych poziomów dostępu. 

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

Wyjście powyżej wykonywanie programu jest: 

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

Rodzaj alias

Cokolwiek wpiszesz aliasy zostaną zdefiniowane jako innego typu, w celu ułatwienia kontroli dostępu. Poziom dostępu typu typu alias nie może być wyższa niż początkowy poziom dostępu.

Na przykład, aliasy typu private klasy może być przypisany do publicznej wewnętrznej, prywatnej typu, ale aliasy typu poziom publicznego można ustawić tylko do rodzaju poziomu publicznego nie może być ustawiony na wewnętrznej lub prywatnego typu szczebla ,

Uwaga: Ta zasada odnosi się również do przypadku, w celu zaspokojenia protokołu zgodności do odpowiedniej nazwy typu i pseudonimu. 

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)

Wyjście powyżej wykonywanie programu jest: 

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