剖析Swift中static和class关键字的奥秘

2023-11-22 21:34:15

Swift中的static和class深入解析类型属性与类型方法

Swift语言中的static和class都是用来被修饰的属性或方法是类型(class/struct/enum)的，而不是类型实例的。它们在Swift中扮演着重要的角色，帮助我们更好地组织代码，提高代码的可读性和可维护性。

1. static关键字：类型属性和类型方法

static关键字用于声明类型属性和类型方法。类型属性属于类型本身，而不属于任何特定的实例。类型方法也属于类型本身，可以在不创建类型实例的情况下调用。

类型属性

类型属性可以用static关键字声明，它与实例属性不同，类型属性不属于任何特定的实例，而是属于整个类型。类型属性可以通过类型名称直接访问，也可以通过实例名称访问，但实例名称访问的本质是通过类型名称访问。

class Person {
    static let species = "Homo sapiens"
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

let person1 = Person(name: "John")
print(Person.species) // "Homo sapiens"
print(person1.species) // "Homo sapiens"

类型方法

类型方法可以用static关键字声明，它与实例方法不同，类型方法不属于任何特定的实例，而是属于整个类型。类型方法可以通过类型名称直接调用，也可以通过实例名称调用，但实例名称调用的本质是通过类型名称调用。

class Person {
    static func greet() {
        print("Hello, world!")
    }
    
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

Person.greet() // "Hello, world!"
person1.greet() // "Hello, world!"

2. class关键字：类型属性和类型方法

class关键字与static关键字类似，也可以用于声明类型属性和类型方法。但是，class关键字的语义与static关键字略有不同。

类型属性

class关键字声明的类型属性与static关键字声明的类型属性类似，它们都属于类型本身，而不属于任何特定的实例。但是，class关键字声明的类型属性只能在类型内部访问，而static关键字声明的类型属性可以在类型内部和类型外部访问。

class Person {
    class var species = "Homo sapiens"
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

// 在类型内部访问类型属性
class func greet() {
    print("Hello, \(species)!")
}

// 在类型外部访问类型属性
print(Person.species) // "Homo sapiens"

类型方法

class关键字声明的类型方法与static关键字声明的类型方法类似，它们都属于类型本身，可以在不创建类型实例的情况下调用。但是，class关键字声明的类型方法只能在类型内部调用，而static关键字声明的类型方法可以在类型内部和类型外部调用。

class Person {
    class func greet() {
        print("Hello, world!")
    }
    
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    // 在类型内部调用类型方法
    func sayHello() {
        Person.greet()
    }
}

// 在类型外部调用类型方法
Person.greet()

3. 单例模式

static和class关键字可以用于实现单例模式。单例模式是一种设计模式，它确保某一类只有一个实例存在。

class Singleton {
    static let shared = Singleton()
    private init() {}
}

let singleton1 = Singleton.shared
let singleton2 = Singleton.shared

print(singleton1 === singleton2) // true

4. 命名空间

static和class关键字可以用于创建命名空间。命名空间是一种组织代码的方式，它可以防止不同模块或类中的符号相互冲突。

class MyClass {
    static let myProperty = 10
    static func myMethod() {
        print("Hello, world!")
    }
}

struct MyStruct {
    static let myProperty = 20
    static func myMethod() {
        print("Hello, Swift!")
    }
}

// 在命名空间中访问属性和方法
print(MyClass.myProperty) // 10
MyClass.myMethod() // "Hello, world!"

print(MyStruct.myProperty) // 20
MyStruct.myMethod() // "Hello, Swift!"

5. 内存管理

static和class关键字可以影响类型的内存管理行为。static关键字声明的属性和方法存储在类型的元数据中，而class关键字声明的属性和方法存储在类型的实例中。这意味着static关键字声明的属性和方法在类型加载时分配内存，而class关键字声明的属性和方法在创建类型实例时分配内存。

6. 访问控制

static和class关键字可以用于控制属性和方法的访问权限。static关键字声明的属性和方法只能在类型内部访问，而class关键字声明的属性和方法可以在类型内部和类型外部访问。

class Person {
    private static let secret = "I am a secret"
    public class var name = "John"
    
    private func sayHello() {
        print("Hello, world!")
    }
    public class func greet() {
        print("Hello, \(name)!")
    }
}

// 在类型内部访问私有属性和方法
class func getSecret() {
    return secret
}

// 在类型外部访问公有属性和方法
print(Person.name) // "John"
Person.greet() // "Hello, John!"

7. 继承

static和class关键字可以用于控制属性和方法的继承行为。static关键字声明的属性和方法不会被子类继承，而class关键字声明的属性和方法会被子类继承。

class Person {
    static let species = "Homo sapiens"
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func sayHello() {
        print("Hello, world!")
    }
}

class Student: Person {
    var major: String
    
    init(name: String, major: String) {
        self.major = major
        super.init(name: name)
    }
    
    override func sayHello() {
        print("Hello, I am a student!")
    }
}

let person = Person(name: "John")
let student = Student(name: "Jane", major: "Computer Science")

print(person.species) // "Homo sapiens"
print(student.species) // "Homo sapiens"

person.sayHello() // "Hello, world!"
student.sayHello() // "Hello, I am a student!"