Swift說話中的一些拜訪掌握設置詳解。本站提示廣大學習愛好者：（Swift說話中的一些拜訪掌握設置詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是Swift說話中的一些拜訪掌握設置詳解正文
限制拜訪代碼塊，模塊和籠統經由過程拜訪掌握來完成。類，構造和列舉可以依據本身的屬性，辦法，初始化函數和下標來經由過程拜訪掌握機制停止拜訪。常量，變量和函數的協定限制，並許可經由過程拜訪掌握來拜訪全局和部分變量。運用於屬性，類型及函數的拜訪掌握可以被稱為“實體”。
拜訪掌握模子是基於模塊和源文件的。
模塊界說為代碼分派一個零丁的單位，而且可使用import 症結字導入。源文件被界說為一個單一的源代碼文件，模塊可拜訪多品種型和函數。
三種分歧的拜訪級別是由 Swift 說話供給。它們分離是 Public, Internal 和 Private 拜訪。
語法
public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}
public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}
關於函數類型的拜訪掌握
某些函數能夠有參數在函數聲明中但沒有任何前往值。上面的法式聲明 a 和 b 作為參數傳遞給sum()函數。外部函數自己為參數a和b的值是經由過程挪用所述經由過程挪用函數 sum()，其值被打印從而不消前往值。為了使函數的前往類型為公有，聲明函數應用 private 潤飾全體拜訪級別。
private func sum(a: Int, b: Int) {
let a = a + b
let b = a - b
println(a, b)
}
sum(20, 10)
sum(40,10)
sum(24,6)
當我們應用 playground 運轉下面的法式，獲得以下成果
(30, 20) (50, 40) (30, 24)
關於列舉類型的拜訪掌握
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):
println("Student name is: \(studName).")
case .Mark(let Mark1, let Mark2, let Mark3):
println("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")
default:
println("Nothing")
}
當我們應用 playground 運轉下面的法式，獲得以下成果
Student Marks are: 98,97,95
列舉在Swift說話中將主動吸收列舉個別並都具有雷同的拜訪級別。例如，斟酌拜訪固定於三個科目列舉稱號，先生的名字和標志被聲明為 student 而存在於列舉類中的成員都屬於字符串數據類型稱號，標志表現為 mark1, mark2 和 mark3 數據類型為整數。要拜訪不管是先生稱號或標志分數。 如今，假如被履行 Switch case 塊將打印先生姓名，不然它將打印由先生固定的標志。假如這兩個前提都掉敗默許塊將被履行。
子類拜訪掌握
Swift 許可用戶子類，可以在以後拜訪高低文存取的任何類。子類不克不及比其超類有更高的拜訪級別。 用戶限制一個公共子類寫入一個外部超類。
public class cricket {
private func print() {
println("Welcome to Swift Super Class")
}
}
internal class tennis: cricket {
override internal func print() {
println("Welcome to Swift Sub Class")
}
}
let cricinstance = cricket()
cricinstance.print()
let tennisinstance = tennis()
tennisinstance.print()
當我們應用 playground 運轉下面的法式，獲得以下成果
Welcome to Swift Super Class Welcome to Swift Sub Class
常量，變量，屬性和下標拜訪掌握
Swift 常量，變量或屬性不克不及被界說比其類型更地下。這是有效一個 public 屬性與 private 類型的寫法。異樣，下標不克不及跨越其索引或前往類型更地下。
當一個常量，變量，屬性或下標應用了一個公有類型，則常量，變量，屬性或下標，也必需標志為公有：
private var privateInstance = SomePrivateClass()
Getters 和 Setterslet NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800
當我們應用 playground 運轉下面的法式，獲得以下成果
Total Counter is: 100 Newly Added Counter 100 Total Counter is: 800 Newly Added Counter 700
拜訪掌握的初始化和默許初始化器
自界說初始化函數可分派的接入級別小於或等於它們初始化的類型。一個必須的初始化必需具有雷同的拜訪級別，由於它們和類雷同。一個初始化的參數的類型不克不及比初始化本身的拜訪級別更私密（更高）。
聲明每一個和初始化每一個子類， “required” 症結字須要在init()函數之前界說。
class classA {
required init() {
var a = 10
println(a)
}
}
class classB: classA {
required init() {
var b = 30
println(b)
}
}
let res = classA()
let print = classB()
當我們應用 playground 運轉下面的法式，獲得以下成果
10 30 10
默許初始化具有雷同的拜訪級別，由於它初始化，除非該類型被界說為公共類型。 當默許初始化界說為公共它被以為是外部的。當用戶須要一個公共類型在另外一個模塊中的一個無參數初始化停止初始化，明白供給一個公共的無參數初始化作為類型界說的一部門。
關於協定的拜訪掌握
當我們界說一個新的協定，從現有的協定繼續的功效，既有聲明雷同的拜訪級別以互相繼續屬性。Swift 拜訪掌握許可用戶界說 “public” 協定，它繼續自 “internal” 的協定。
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 print = subClass(no1: 30, no2: 50)
println("res is: \(res.no1)")
println("res is: \(print.no1)")
println("res is: \(print.no2)")
當我們應用 playground 運轉下面的法式，獲得以下成果
res is: 20 res is: 30 res is: 50
擴大拜訪掌握
當用戶應用擴大來添加協定的分歧性，Swift 不許可用戶為擴大供給一個明白的拜訪級別潤飾符。關於在每一個協定的擴大，請求完成的默許拜訪級別設置本身的協定拜訪級別。
關於泛型拜訪掌握
泛型許可用戶指定最小拜訪級別來拜訪類型束縛其類型參數。
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")
println(tos.items)
tos.push("Generics")
println(tos.items)
tos.push("Type Parameters")
println(tos.items)
tos.push("Naming Type Parameters")
println(tos.items)
let deletetos = tos.pop()
當我們應用 playground 運轉下面的法式，獲得以下成果
[Swift] [Swift, Generics] [Swift, Generics, Type Parameters] [Swift, Generics, Type Parameters, Naming Type Parameters]
關於類型別號拜訪掌握
用戶可以界說類型別號看待分歧的拜訪掌握類型。 雷同的拜訪級別或分歧的拜訪級別可以由用戶界說。當類型別號為 “private” 及其相干成員可以聲明為 “private，外部 public 類型 ”。當類型別號是公共成員不克不及是別號為 “internal” 或 “private” 的稱號
界說任何類型別號被視為用於分歧類型的拜訪掌握的目標。一個類型別號可以具有小於或等於它的一個拜訪級別別號的類型的拜訪級別。例如，private類型別號可以別號為 private, internal, 或 public，而 public 類型別號不克不及別號為 internal 或 private 類型。
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")
println(tos.items)
tos.push("Generics")
println(tos.items)
tos.push("Where Clause")
println(tos.items)
var eos = ["Swift", "Generics", "Where Clause"]
println(eos)
當我們應用 playground 運轉下面的法式，獲得以下成果
[Swift] [Swift, Generics] [Swift, Generics, Where Clause] [Swift, Generics, Where Clause]
