Tutorial kontrol akses cepat Terbaik Pada tahun 2024, Dalam tutorial ini Anda dapat mempelajari Fungsi Jenis Akses,Akses Jenis disebutkan,akses subclass,Konstanta, variabel, properti, akses Indeks,Getter dan akses Setter,Konstruktor dan konstruktor default akses,Perjanjian akses,akses diperpanjang,Akses generik,Jenis alias,
kontrol akses dapat didefinisikan dalam file sumber atau modul kode lain untuk tingkat akses kode Anda.
Anda dapat secara eksplisit untuk satu jenis (kelas, struct, enum) untuk mengatur tingkat akses, juga dapat memberikan jenis properti, fungsi, metode inisialisasi, jenis dasar, indeks subscript mengatur tingkat akses.
Perjanjian juga dibatasi untuk menggunakan dalam jarak tertentu, termasuk kesepakatan di konstanta global, variabel dan fungsi.
Berdasarkan modul kontrol akses dengan file sumber.
Modul didefinisikan oleh unit yang terpisah untuk membangun dan mempublikasikan Kerangka atau Aplikasi. Sebuah modul dapat digunakan di Swift di kunci impor memperkenalkan modul lain.
File sumber file sumber tunggal, yang biasanya dimiliki sebuah modul yang berisi file sumber dapat menentukan beberapa kelas dan fungsi.
Swift menyediakan tiga tingkat akses yang berbeda kode entitas: public internal, pribadi.
| Tingkat akses | definisi |
|---|---|
| publik | Setiap entitas yang dapat mengakses file Anda dalam modul sumber, orang lain dapat mengakses file sumber dari semua entitas melalui pengenalan modul. |
| intern | : Setiap entitas yang dapat mengakses file Anda dalam modul sumber, tetapi yang lain tidak dapat mengakses sumber entitas berkas modul. |
| pribadi | Gunakan hanya entitas dalam file sumber arus, dikenal sebagai badan swasta. |
akses publik ke tingkat yang paling canggih, swasta adalah tingkat terendah dari akses.
Dengan menyatakan pengubah publik, internal akses pribadi entitas tingkat:
public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}
public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}
Kecuali ada instruksi khusus, jika entitas menggunakan tingkat akses standar internal.
tingkat akses berdasarkan parameter yang berasal fungsi memerlukan jenis jenis kembali fungsi dan tingkat akses.
Contoh berikut mendefinisikan bernama someFunction fungsi global, dan tidak secara eksplisit menegaskan tingkat akses mereka.
func someFunction() -> (SomeInternalClass, SomePrivateClass) {
// 函数实现
}
Fungsi di salah satu tingkat akses kelas SomeInternalClass internal, tingkat akses SomePrivateClass lainnya adalah swasta. Oleh karena itu, menurut prinsip tingkat akses tuple, tingkat akses tuple pribadi.
Karena fungsi mengembalikan jenis tingkat akses pribadi, sehingga Anda harus menggunakan pengubah swasta secara eksplisit menyatakan fungsi:private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
// 函数实现
}
Fungsi ini dinyatakan sebagai publik maupun internal, atau menggunakan default tingkat akses internal salah.
anggota pencacahan tingkat akses diwarisi dari pencacahan, Anda tidak dapat menghitung anggota deklarasi tingkat yang berbeda yang terpisah dari akses.
Sebagai contoh, berikut contoh, Mahasiswa pencacahan secara eksplisit dinyatakan sebagai tingkat masyarakat, maka anggotanya Nama, tingkat Markus akses juga publik:
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)")
}
Output di atas eksekusi program adalah:
学生成绩: 98,97,95
tingkat akses subclass tidak akan melebihi tingkat akses dari kelas induk. Misalnya, tingkat akses dari kelas induk internal, tingkat akses subclass tidak dapat dinyatakan sebagai publik.
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()
Output di atas eksekusi program adalah:
超类 子类
Konstanta, variabel, atribut tidak dapat memiliki lebih dari jenis mereka dari tingkat akses.
Misalnya, Anda menentukan tingkat milik umum, tetapi adalah jenis tingkat pribadi, yang tidak diperbolehkan oleh kompilator.
Demikian pula, indeks tidak dapat memiliki pengembalian yang lebih tinggi dibandingkan dengan jenis indeks atau jenis tingkat akses.
Jika konstanta, variabel, properti, jenis indeks subscript didefinisikan adalah tingkat pribadi, mereka harus jelas dinyatakan tingkat akses ke pribadi:
private var privateInstance = SomePrivateClass()
Getter dan konstanta setter tingkat akses, variabel, properti, indeks subscript diwarisi dari tingkat akses mereka milik anggota.
tingkat akses setter mungkin lebih rendah dari tingkat akses yang sesuai Getter, sehingga Anda dapat mengontrol variabel, properti atau indeks subscript membaca dan menulis perizinan.
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
Output di atas eksekusi program adalah:
计数器: 100 新增加数量 100 计数器: 800 新增加数量 700
Kami dapat menyesuaikan metode inisialisasi untuk menyatakan tingkat akses, tapi milik kelas atau tingkat yang lebih tinggi dari akses. Tapi perlu konstruktor pengecualian, itu harus mengakses tingkat dan akses ke tingkat yang sama dari kelas mereka.
Sebagai fungsi atau metode parameter, metode parameter inisialisasi tingkat akses tidak bisa kurang dari metode inisialisasi tingkat akses.
Swift adalah struktur, kelas menyediakan metode inisialisasi default tanpa parameter, untuk semua properti mereka untuk memberikan tugas, tetapi tidak memberikan nilai tertentu.
Metode inisialisasi standar milik tingkat akses yang sama dan jenis tingkat akses.
Gunakan pernyataan kunci diperlukan sebelum metode akses () init di setiap subclass.
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()
Output di atas eksekusi program adalah:
10 30 10
Jika Anda ingin kesepakatan yang jelas menegaskan tingkat akses, kita perlu dicatat bahwa Anda ingin memastikan perjanjian hanya digunakan dalam peran tingkat akses yang menyatakan domain.
Jika anda mendefinisikan protokol tingkat akses publik, untuk mencapai fungsi yang diperlukan dari perjanjian itu akan disediakan oleh tingkat akses publik. Hal ini berbeda dari jenis lain, seperti jenis lain dari tingkat akses publik, tingkat akses untuk anggota internal mereka.
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)")
Output di atas eksekusi program adalah:
res is: 20 res is: 30 res is: 50
Anda dapat bawah kondisi memungkinkan kelas, struktur, ekspansi pencacahan. anggota diperpanjang dari anggota kelas yang asli harus memiliki tingkat akses yang sama. Misalnya, Anda memperpanjang jenis umum, maka Anda menambahkan anggota baru harus memiliki anggota yang sama dari tingkat akses internal default asli.
Atau, Anda dapat secara eksplisit menyatakan tingkat diperpanjang akses (seperti penggunaan ekstensi swasta) dalam ekstensi untuk semua anggota menegaskan tingkat akses default baru. Tingkat akses standar baru masih dapat ditegaskan anggota individu ditutupi oleh tingkat akses.
tingkat akses generik jenis atau fungsi generik untuk mengambil jenis generik, fungsi itu sendiri, jenis parameter generik dari tiga tingkat akses terendah.
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()
Output di atas eksekusi program adalah:
["Swift"] ["Swift", "泛型"] ["Swift", "泛型", "类型参数"] ["Swift", "泛型", "类型参数", "类型参数名"]
Apa pun yang Anda ketik alias akan didefinisikan sebagai jenis yang berbeda, dalam rangka memfasilitasi akses kontrol. tingkat akses dari jenis jenis alias tidak bisa lebih tinggi dari tingkat asli dari akses.
Misalnya, pribadi jenis kelas alias dapat ditugaskan ke internal, jenis public private, namun jenis tingkat publik alias hanya dapat diatur untuk jenis tingkat masyarakat tidak dapat diatur untuk jenis tingkat internal maupun swasta .
Catatan: Aturan ini juga berlaku untuk kasus ini dalam rangka memenuhi protokol kesesuaian dengan nama jenis relevan dan alias.
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 0id<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)
Output di atas eksekusi program adalah:
["Swift"] ["Swift", "泛型"] ["Swift", "泛型", "Where 语句"] ["Swift", "泛型", "Where 语句"]