類別（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編程中編寫更強大和靈活的代碼。
