Swift 中 class 和 struct 关于使用上面的异同

1. 可以声明静态的变量和常量，声明的同时必须进行初始化；
2. 可以声明实例变量和常量；
3. 可以声明存储属性也可以声明计算属性；
4. 可以声明初始化方法，但是在初始化方法中需要初始化全部的存储属性；
5. 都可以声明实例方法；
6. 实例方法中都可以修改全局变量和实例属性；

// 全局变量
var sum = 99
struct Egg {
    // 静态成员变量(静态成员变量在声明的时候必须进行初始化)
    static var num1 = 10
    static let num2 = 10

    // 存储属性
    var size: Float,
        length: Int

    // 可选属性如果没有初始化，默认值为 nil
    var age: Int?,
        brith: Int?

    let value: Int

    // 计算属性不能使用 let 关键字
    var virtualAge: Int {
        get {
            return age!
        }
        set (myValue) {
            age = myValue * 4
        }
    }

    /// 计算属性(只读)，计算属性需要声明类型
    var actualAge: Int? {
        get {
            return age! * 8
        }
    }

    /// 计算属性(只读)，计算属性需要声明类型
    /// 省略 get
    var virtual: Int {
        return age! * 8
    }

    /// 计算属性(只读)，计算属性需要声明类型
    /// 省略 return
    var actual: Int {
        age! * 8
    }

    // 初始化方法(必须初始化全部的存储属性的值, Swift 中的初始化方法不需要有返回值)
    init(_ size: Float, length: Int, value: Int) {
        self.size = size
        self.length = length
        self.value = value
    }

    // 实例方法
    func say() {
        // struct 中的成员变量的值是不能在实例方法中被修改的，可以在外部修改
//        size = 9.9
//        length = 10
//        value = 9
        //virtualAge = 10
        // struct 中可以修改全局变量
        sum = 100
        print(size)
        print(length)
        print(value)
        print(sum)
    }
}

// 全局变量
var sum = 99
// 全局常量在声明的时候就必须初始化
//let sum1: Int
// 无法声明全局静态变量或常量
//static var sum1 = 10.0
//static let sum2 = 99
/// 类中如果有非可选属性，要么声明的时候就直接初始化，要么提供初始化方法来初始化声明的非可选变量。
class Animal: NSObject {
    // 静态成员变量(静态成员变量在声明的时候必须进行初始化)
    static var num1 = 10
    static let num2 = 10

    /// 存储属性：值的获取和存储通过自身完成，不依赖其他的变量
    // 名字
    var name: String,
        age: Int = 0
    
    var address: String?,
        postCode: Int?

    /// 计算属性(读、写)：不通过变量自己本身进行值的获取和存储，值的获取和存储依赖其他变量，计算属性需要声明类型
    var virtualAge: Int {
        get {
            return age
        }
        set (myValue) {
            age = myValue * 4
        }
    }

    /// 计算属性(只读)，计算属性需要声明类型
    var actualAge: Int {
        get {
            return age * 8
        }
    }

    /// 计算属性(只读)，计算属性需要声明类型
    /// 省略 get
    var virtual: Int {
        return age * 8
    }

    /// 计算属性(只读)，计算属性需要声明类型
    /// 省略 return
    var actual: Int {
        age * 8
    }

    // 初始化方法
    init(_ nameStr: String) {
        self.name = nameStr
//        super.init()
    }

    // 实例方法
    func say() {
        // 实例方法中无法修改静态变量
        //self.num1 = 99
        // 修改实例变量
        self.name = "say"
        sum = 100
        // 调用 virtualAge 的 set 方法
        self.virtualAge = 100
        print(self.name)
        print(sum)
    }
}

1. struct 中不能声明类方法，只能声明实例方法和静态方法；class 中可以声明实例方法、类方法和静态方法；
2. struct 中实例方法、静态方法都可以修改全局变量，实例变量只能在实例方法中修改，静态方法不能修改实例变量；
3. class 中实例方法、类方法、静态方法都可以修改全局变量，实例变量只能在实例方法中修改，类方法、静态方法都不能修改实例变量；
4. 一个 struct 实例如果被声明为了 let，那么它里面的成员不管是不是 var 类型的都不能被修改，但是如果是 class 实例的话，不管是声明为 var 还是 let，它里面的成员都是可以修改的；

struct Egg {
    // 静态成员变量(静态成员变量在声明的时候必须进行初始化)
    static var num1 = 10
    static let num2 = 10

    // 存储属性
    var size: Float,
        length: Int

    // 可选属性如果没有初始化，默认值为 nil
    var age: Int?,
        brith: Int?

    let value: Int

    // 初始化方法(必须初始化全部的存储属性的值, Swift 中的初始化方法不需要有返回值)
    init(_ size: Float, length: Int, value: Int) {
        self.size = size
        self.length = length
        self.value = value
    }

    // 实例方法
    func say() {
        // struct 中的成员变量的值是不能在实例方法中被修改的，可以在外部修改
//        size = 9.9
//        length = 10
//        value = 9
        //virtualAge = 10
        // struct 中可以修改全局变量
        sum = 100
        print(size)
        print(length)
        print(value)
        print(sum)
    }

    // struct 中没有类方法，只有静态方法
    static func run() {
        // struct 静态方法中不能修改实例变量
        //size = 9.9
        // struct 静态方法中可以修改全局变量
        sum = 100
        print("run")
        print(sum)
    }
}

class Animal: NSObject {
    // 静态成员变量(静态成员变量在声明的时候必须进行初始化)
    static var num1 = 10
    static let num2 = 10

    /// 存储属性：值的获取和存储通过自身完成，不依赖其他的变量
    // 名字
    var name: String,
        age: Int = 0
    
    var address: String?,
        postCode: Int?

    // 实例方法
    func say() {
        // 实例方法中无法修改静态变量
        //self.num1 = 99
        // 修改实例变量
        self.name = "say"
        sum = 100
        // 调用 virtualAge 的 set 方法
        self.virtualAge = 100
        print(self.name)
        print(sum)
    }

    // 类方法
    class func run() {
        // 类方法中可以修改静态变量
        self.num1 = 99
        // 类方法中不能修改实例变量
        //self.name = "run"
        // 类方法中可以修改全局变量
        sum = 100
        print("run")
        print(sum)
    }

    // 静态方法
    static func smile() {
        // 类静态方法中可以修改静态变量
        self.num1 = 99
        // 类静态方法中不能修改实例变量
        //virtualAge = 100
        // 类静态方法中可以修改全局变量
        sum = 100
        print("run")
        print(sum)
    }
}

// class 的实例对象
var animal = Animal("")
animal.virtualAge = 10
    
// 可以修改变量 animal 的值，即使 animal 的值已经被初始化过了
animal = Animal("0")
    
// 如果是类实例，那么即使声明为常量，类中的成员变量的值也是可以修改的
let animal1 = Animal("")
animal1.name = "animal1"
animal1.age = 99
    
// 不能修改常量 animal1 的值，因为 animal1 的值已经被初始化过了
//animal1 = Animal("1")

// struct 的实例对象     
var egg = Egg(10.0, length: 10, value: 10)
// 可以修改 struct 的实例对象成员的值
egg.size = 99
egg.length = 10
egg.virtualAge = 100
egg.age = 99
    
// 可以修改
egg = Egg(9.0, length: 9, value: 9)
    
// struct 跟 class 的区别之一就是：如果一个 struct 实例如果被声明为了 let，那么它里面的成员变量不管是不是 var 类型的都不能被修改
let egg1 = Egg(9.0, length: 9, value: 9)
// 不能修改 struct 的实例对象成员的值
//egg1.size = 10.0
//egg1.length = 20
//egg1.age = 99
    
// 不可以修改
//egg1 = Egg(9.0, length: 9, age: 9, brith: 9, value: 9)