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項目中實現高效的代碼復用，從而提高開發效率和代碼的可維護性。