Swift学习笔记-（四）类（Class）的定义使用场景

类（Class）

类（Class） 是面向对象编程的核心概念之一，它提供了一种创建复杂数据结构和行为的蓝图。下面我将从基础概念到实际应用全面解析 Swift 中的类：

一、类是什么？

类是一个自定义的数据类型，它定义了：

1. 属性（Properties）：存储数据的变量/常量（如人的姓名、年龄）

2. 方法（Methods）：操作数据的函数（如人的行走、说话）

3. 初始化器（Initializers）：创建实例的特殊方法（init）

4. 反初始化器（Deinitializers）：清理资源的特殊方法（deinit）

5. // 类的基本定义
   class Person {
       // 属性
       var name: String
       var age: Int
       
       // 初始化器
       init(name: String, age: Int) {
           self.name = name
           self.age = age
       }
       
       // 方法
       func introduce() {
           print("你好，我叫\(name)，今年\(age)岁。")
       }
   }
   
   // 创建实例
   let person = Person(name: "张三", age: 30)
   person.introduce() // 输出：你好，我叫张三，今年30岁。

二、类的作用（为什么需要类？）

三、类与结构体（struct）的关键区别

class ClassExample { var value = 0 }
struct StructExample { var value = 0 }

var a = ClassExample()
var b = a // b和a引用同一个实例
b.value = 10
print(a.value) // 输出：10（值被改变）

var c = StructExample()
var d = c // d是c的副本
d.value = 20
print(c.value) // 输出：0（原始值未变）

四、类的核心特性

1.继承（Inheritance）

class Student: Person { // 继承Person
    var studentID: String
    
    init(name: String, age: Int, studentID: String) {
        self.studentID = studentID
        super.init(name: name, age: age)
    }
    
    // 重写父类方法
    override func introduce() {
        print("我是学生\(name)，学号\(studentID)")
    }
}

2.多态（Polymorphism）

let people: [Person] = [
    Person(name: "李四", age: 40),
    Student(name: "王五", age: 20, studentID: "S12345")
]

for person in people {
    person.introduce() // 不同对象调用相同方法产生不同行为
}
/* 输出：
你好，我叫李四，今年40岁。
我是学生王五，学号S12345
*/

3.引用类型（Reference Type）

let student1 = Student(name: "小明", age: 18, studentID: "S1001")
let student2 = student1 // 复制的是引用，不是值

student2.name = "小红"
print(student1.name) // 输出："小红"（原始对象也被修改）

五、类的使用场景

六、实际应用示例

场景：电商应用中的商品管理

// 基类：商品
class Product {
    let id: String
    var name: String
    var price: Double
    
    init(id: String, name: String, price: Double) {
        self.id = id
        self.name = name
        self.price = price
    }
    
    func displayInfo() {
        print("商品：\(name)，价格：¥\(price)")
    }
}

// 子类：折扣商品
class DiscountedProduct: Product {
    let discountRate: Double
    
    init(id: String, name: String, price: Double, discountRate: Double) {
        self.discountRate = discountRate
        super.init(id: id, name: name, price: price)
    }
    
    // 计算折后价格
    var discountedPrice: Double {
        return price * (1 - discountRate)
    }
    
    // 重写显示方法
    override func displayInfo() {
        super.displayInfo()
        print("折扣：\(discountRate * 100)%，折后价：¥\(discountedPrice)")
    }
}

// 使用
let normalProduct = Product(id: "P001", name: "普通商品", price: 100)
normalProduct.displayInfo()
/* 输出：
商品：普通商品，价格：¥100.0
*/

let specialProduct = DiscountedProduct(id: "P002", name: "特价商品", price: 200, discountRate: 0.3)
specialProduct.displayInfo()
/* 输出：
商品：特价商品，价格：¥200.0
折扣：30.0%，折后价：¥140.0
*/

七、最佳实践建议

1. 优先使用结构体：当不需要继承、不需要引用语义时，使用更轻量的结构体

2. 使用final防止继承：如果不希望类被继承，标记为final class

3. 遵循最小权限原则：

   • 属性用private限制访问

   • 方法用fileprivate限制文件内访问

4. 内存管理：

   • 使用weak打破强引用循环

   • 闭包中使用[weak self]避免循环引用

5. 协议导向编程：优先使用协议定义行为，而非类继承

八、何时选择类 vs 结构体