Swift入門-Day8：物件導向

類別（Class）

在Swift中，類別是一種用來定義屬性和方法的模板，可以創建和管理對象。

建構子（Constructor）

建構子（初始化方法）用來初始化類別的實例。在Swift中，建構子使用init關鍵字。

class Person {
    var name: String

    init(name: String) {
        self.name = name
    }
}

let person = Person(name: "Alice")
print(person.name) // Alice

公開（Public）

使用public關鍵字可以使屬性和方法在模組外部可見和可訪問。

public class Person {
    public var name: String

    public init(name: String) {
        self.name = name
    }

    public func greet() {
        print("Hello, \\\\(name)!")
    }
}

let person = Person(name: "Bob")
person.greet() // Hello, Bob!

私有（Private）

使用private關鍵字可以將屬性和方法限制在類別內部。

class Person {
    private var name: String

    init(name: String) {
        self.name = name
    }

    func greet() {
        print("Hello, \\\\(name)!")
    }
}

let person = Person(name: "Charlie")
// print(person.name) // Error: 'name' is inaccessible due to 'private' protection level
person.greet() // Hello, Charlie!

受保護（Protected）

Swift中沒有受保護（protected）關鍵字，通常使用fileprivate或internal來實現類似功能。

fileprivate：在同一文件內可見。

class Person {
    fileprivate var name: String

    init(name: String) {
        self.name = name
    }

    func greet() {
        print("Hello, \\\\(name)!")
    }
}

let person = Person(name: "David")
person.greet() // Hello, David!

繼承（Inheritance）

繼承允許一個類別繼承另一個類別的屬性和方法。

class Animal {
    var name: String

    init(name: String) {
        self.name = name
    }

    func makeSound() {
        print("Some generic sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Bark")
    }
}

let dog = Dog(name: "Buddy")
dog.makeSound() // Bark

多型（Polymorphism）

多型允許子類別以父類別的型別出現，並在運行時調用適當的子類別方法。

class Animal {
    func makeSound() {
        print("Some generic sound")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow")
    }
}

let animals: [Animal] = [Dog(name: "Buddy"), Cat()]
for animal in animals {
    animal.makeSound()
}
// Output:
// Bark
// Meow

封裝（Encapsulation）

封裝是將數據和方法組合在一起，並隱藏內部實現的技術。使用private或fileprivate可以實現封裝。

class Person {
    private var name: String

    init(name: String) {
        self.name = name
    }

    func getName() -> String {
        return name
    }
}

let person = Person(name: "Eve")
print(person.getName()) // Eve

介面（Interface）

Swift使用協議（protocol）來實現介面。協議定義了一組方法和屬性，類別可以遵循這些協議並實現其中的要求。

protocol Greetable {
    func greet()
}

class Greeter: Greetable {
    func greet() {
        print("Hello!")
    }
}

let greeter = Greeter()
greeter.greet() // Hello!

抽象類別（Abstract Class）

Swift不支持抽象類別，但可以使用協議和擴展來實現類似功能。

protocol Animal {
    var name: String { get set }
    func makeSound()
}

class Dog: Animal {
    var name: String

    init(name: String) {
        self.name = name
    }

    func makeSound() {
        print("Bark")
    }
}

let dog = Dog(name: "Buddy")
dog.makeSound() // Bark

靜態類別（Static Class）

Swift不支持靜態類別，但可以使用結構體（struct）和靜態屬性來模擬。

struct Math {
    static func square(_ number: Int) -> Int {
        return number * number
    }
}

print(Math.square(4)) // 16

列舉（Enumerations）

列舉是一種定義相關值組合的型別。

enum Direction {
    case north
    case south
    case east
    case west
}

let direction = Direction.north
switch direction {
case .north:
    print("Going north")
case .south:
    print("Going south")
case .east:
    print("Going east")
case .west:
    print("Going west")
}
// Going north

委派（Delegates）

委派是一種設計模式，允許類別將某些任務委託給其他類別來完成。

protocol PrinterDelegate {
    func printMessage()
}

class Printer {
    var delegate: PrinterDelegate?

    func print() {
        delegate?.printMessage()
    }
}

class ConsolePrinter: PrinterDelegate {
    func printMessage() {
        print("Printing to console")
    }
}

let printer = Printer()
let consolePrinter = ConsolePrinter()
printer.delegate = consolePrinter
printer.print() // Printing to console

Lambda 表達式

Swift中的閉包類似於其他語言中的Lambda表達式。

let add = { (a: Int, b: Int) -> Int in
    return a + b
}

print(add(2, 3)) // 5

泛型（Generics）

泛型允許你編寫靈活且可重用的代碼。

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 5
var y = 10
swapValues(&x, &y)
print("x: \\\\(x), y: \\\\(y)") // x: 10, y: 5

反射（Reflection）

Swift的反射允許你檢查和修改運行時的類型和對象。

import Foundation

class Person: NSObject {
    @objc var name: String
    @objc var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

let person = Person(name: "Alice", age: 30)
let mirror = Mirror(reflecting: person)

for child in mirror.children {
    print("\\\\(child.label!): \\\\(child.value)")
}
// Output:
// name: Alice
// age: 30

這些是Swift中的一些面向對象和高級特性。理解並掌握這些特性將幫助你在Swift編程中編寫更強大和靈活的代碼。