Swift项目中的代码复用策略

在Swift项目中，代码复用是提高开发效率和可维护性的关键。以下是一些常见的代码复用策略：

1. 继承（Inheritance）

通过继承，子类可以复用父类的代码。Swift支持多重继承，但通常建议使用组合而不是继承，因为Swift不支持多继承。

class Animal {
    func makeSound() {
        print("The animal makes a sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("The dog barks")
    }
}

2. 组合（Composition）

通过组合，可以将多个对象组合在一起，从而实现代码复用。

class Engine {
    func start() {
        print("Engine starts")
    }
}

class Car {
    var engine: Engine
    
    init(engine: Engine) {
        self.engine = engine
    }
    
    func startCar() {
        engine.start()
        print("Car starts")
    }
}

3. 扩展（Extensions）

通过扩展，可以为现有类型添加新的功能，而不改变其原始定义。

extension Array {
    func firstElement() -> Any? {
        return self.first
    }
}

let array = [1, 2, 3]
print(array.firstElement()) // 输出: Optional(1)

4. 协议（Protocols）

通过定义协议，可以确保类型遵循相同的接口，从而实现代码复用。

protocol Printable {
    func printDescription()
}

class Dog: Printable {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func printDescription() {
        print("Dog: \(name)")
    }
}

class Cat: Printable {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func printDescription() {
        print("Cat: \(name)")
    }
}

func printAllDescriptions(items: [Printable]) {
    for item in items {
        item.printDescription()
    }
}

let dog = Dog(name: "Buddy")
let cat = Cat(name: "Whiskers")
printAllDescriptions(items: [dog, cat])

5. 工厂模式（Factory Pattern）

通过工厂模式，可以创建对象而不需要指定具体的类。

class CarFactory {
    static func createCar(type: String) -> Car {
        switch type {
        case "Sedan":
            return Sedan()
        case "SUV":
            return SUV()
        default:
            return Car()
        }
    }
}

class Sedan: Car {
    func drive() {
        print("Sedan drives")
    }
}

class SUV: Car {
    func drive() {
        print("SUV drives")
    }
}

let sedan = CarFactory.createCar(type: "Sedan")
let suv = CarFactory.createCar(type: "SUV")
sedan.drive() // 输出: Sedan drives
suv.drive() // 输出: SUV drives

6. 单例模式（Singleton Pattern）

通过单例模式，可以确保一个类只有一个实例，并提供一个全局访问点。

class Singleton {
    static let shared = Singleton()
    
    private init() {}
    
    func printMessage() {
        print("Hello from Singleton")
    }
}

Singleton.shared.printMessage() // 输出: Hello from Singleton

7. 泛型（Generics）

通过使用泛型，可以编写可重用的代码，而不需要为每种类型编写特定的代码。

func printArray<T>(array: [T]) {
    for item in array {
        print(item)
    }
}

let intArray = [1, 2, 3]
let stringArray = ["Hello", "World"]
printArray(array: intArray) // 输出: 1 2 3
printArray(array: stringArray) // 输出: Hello World

8. 委托（Delegates）

通过使用委托，可以将行为委托给其他对象，从而实现代码复用。

protocol GreetingDelegate {
    func greeting()
}

class Person {
    var delegate: GreetingDelegate?
    
    func greet() {
        delegate?.greeting()
    }
}

class Employee: Person {
    override func greet() {
        print("Hello, I am an employee")
    }
}

class Manager: Person {
    override func greet() {
        print("Hello, I am a manager")
    }
}

let employee = Employee()
employee.delegate = employee // 设置委托
employee.greet() // 输出: Hello, I am an employee

let manager = Manager()
manager.delegate = manager // 设置委托
manager.greet() // 输出: Hello, I am a manager

通过这些策略，可以在Swift项目中实现高效的代码复用，从而提高开发效率和代码的可维护性。