程式設計範式是程式設計的基本風格或方法論。理解不同範式的核心思想，能幫助我們選擇最適合問題的解決方案，並寫出更優雅、更可維護的程式碼。

程式設計範式概覽#

程式設計範式主要分為以下幾種：

範式核心思想典型語言
物件導向編程 (OOP)封裝、繼承、多型Java, C++, Python
函式式編程 (FP)不可變性、純函式、高階函式Haskell, Scala, Clojure
泛型編程類型參數化、程式碼重用C++, Java, Go
過程式編程順序執行、狀態修改C, Pascal

現代語言往往支持多種範式，不同範式可以混合使用。關鍵是理解每種範式的優勢，在適當的場景下選擇合適的方式。

物件導向編程#

物件導向編程（Object-Oriented Programming）以「物件」作為程式的基本單元，將資料和操作封裝在一起。

三大核心特性#

1. 封裝（Encapsulation）

  • 將資料和行為綁定在一起
  • 隱藏實現細節，暴露介面
  • 降低耦合度，提高可維護性

2. 繼承（Inheritance）

  • 子類繼承父類的屬性和方法
  • 實現程式碼重用
  • 建立類型層次結構

3. 多型（Polymorphism）

  • 同一介面，不同實現
  • 執行時動態綁定
  • 提高程式的靈活性和可擴展性

面向介面編程#

Program to an interface, not an implementation. （面向介面編程，而非面向實現編程）

這是物件導向編程的黃金法則。

Go 語言介面編程示例
type Country struct {
    Name string
}

type City struct {
    Name string
}

type Stringable interface {
    ToString() string
}

func (c Country) ToString() string {
    return "Country = " + c.Name
}

func (c City) ToString() string {
    return "City = " + c.Name
}

func PrintStr(p Stringable) {
    fmt.Println(p.ToString())
}

// 使用
d1 := Country{"USA"}
d2 := City{"Los Angeles"}
PrintStr(d1)
PrintStr(d2)

這樣設計的好處是：

  • 「業務類型」（Country、City）和「控制邏輯」（PrintStr）解耦
  • 只要實現了 Stringable 介面，都可以傳給 PrintStr 使用

函式式編程#

函式式編程（Functional Programming）強調使用純函式和不可變資料來構建程式。

核心概念#

1. 純函式（Pure Function）

  • 相同的輸入永遠得到相同的輸出
  • 沒有副作用（不修改外部狀態）
  • 易於測試和推理

2. 不可變性（Immutability）

  • 資料一旦創建就不能修改
  • 需要修改時創建新的副本
  • 避免狀態相關的 Bug

3. 高階函式（Higher-Order Function）

  • 函式可以作為參數傳遞
  • 函式可以作為回傳值
  • 實現程式碼抽象和復用

Functional Options 模式#

這是函式式編程在實際應用中的優雅案例，在 Go 語言中非常流行。

Functional Options 模式詳解

問題場景： 創建物件時需要組態多個可選參數

傳統方案的問題：

// 方案一：多個構造函式
func NewDefaultServer(addr string, port int) (*Server, error)
func NewTLSServer(addr string, port int, tls *tls.Config) (*Server, error)
func NewServerWithTimeout(addr string, port int, timeout time.Duration) (*Server, error)
// 組合爆炸...

// 方案二：Config 物件
func NewServer(addr string, port int, conf *Config) (*Server, error)
// 需要判斷 nil 或空 Config{}

Functional Options 解決方案：

// 定義 Option 類型
type Option func(*Server)

// 定義各種組態函式
func Protocol(p string) Option {
    return func(s *Server) {
        s.Protocol = p
    }
}

func Timeout(timeout time.Duration) Option {
    return func(s *Server) {
        s.Timeout = timeout
    }
}

func MaxConns(maxconns int) Option {
    return func(s *Server) {
        s.MaxConns = maxconns
    }
}

// 構造函式
func NewServer(addr string, port int, options ...func(*Server)) (*Server, error) {
    srv := Server{
        Addr:     addr,
        Port:     port,
        Protocol: "tcp",
        Timeout:  30 * time.Second,
        MaxConns: 1000,
    }
    for _, option := range options {
        option(&srv)
    }
    return &srv, nil
}

// 使用
s1, _ := NewServer("localhost", 1024)
s2, _ := NewServer("localhost", 2048, Protocol("udp"))
s3, _ := NewServer("0.0.0.0", 8080, Timeout(300*time.Second), MaxConns(1000))

優點：

  • 直覺式的編程
  • 高度可組態化
  • 容易維護和擴展
  • 自文檔
  • 新來的人很容易上手
  • 沒有 nil 還是空的困惑

泛型編程#

泛型編程（Generic Programming）通過類型參數化，實現程式碼的高度復用。

核心價值#

  • 程式碼復用：同一套邏輯可以處理不同類型
  • 類型安全：編譯期檢查類型錯誤
  • 效能：避免執行時類型檢查和轉換

類型系統的本質#

泛型的本質是對類型的抽象，讓演算法和資料結構可以獨立於具體類型。

常見泛型應用：

  • 集合框架（List、Map、Set）
  • 演算法庫（排序、搜索）
  • 工具類（Optional、Future）

控制反轉與委託#

控制反轉（Inversion of Control，IoC）是一種重要的設計思想，其核心是把控制邏輯與業務邏輯分開。

核心思想#

不要在業務邏輯里寫控制邏輯。 讓業務邏輯依賴控制邏輯，而非讓控制邏輯依賴業務邏輯。

比喻： 開關和電燈

  • 開關是控制邏輯
  • 電燈是業務邏輯
  • 不要在電燈中實現開關，而是把開關抽象成協定，讓電燈依賴它

實現方式：依賴反轉#

控制反轉示例：Undo 功能

傳統做法（控制邏輯依賴業務邏輯）：

type UndoableIntSet struct {
    IntSet    // 嵌入業務邏輯
    functions []func()
}

func (set *UndoableIntSet) Add(x int) {
    // Undo 邏輯和 IntSet 業務邏輯緊密耦合
    if !set.Contains(x) {
        set.data[x] = true
        set.functions = append(set.functions, func() { set.Delete(x) })
    }
}

控制反轉做法（業務邏輯依賴控制邏輯）：

// 定義控制邏輯（協定）
type Undo []func()

func (undo *Undo) Add(function func()) {
    *undo = append(*undo, function)
}

func (undo *Undo) Undo() error {
    // ... 純粹的 Undo 邏輯
}

// 業務邏輯依賴控制邏輯
type IntSet struct {
    data map[int]bool
    undo Undo  // 嵌入控制邏輯
}

func (set *IntSet) Add(x int) {
    if !set.Contains(x) {
        set.data[x] = true
        set.undo.Add(func() { set.Delete(x) })
    }
}

好處： Undo 程式碼可以復用，因為它不再依賴特定的業務邏輯。

各範式的適用場景#

選擇指南#

場景推薦範式原因
建模複雜業務領域物件導向物件和類自然對應現實世界的概念
資料轉換和處理函式式純函式和不可變性讓資料流清晰
建立可復用的資料結構和演算法泛型類型參數化實現高度復用
簡單腳本和工具過程式直接、簡單、易理解
並行編程函式式不可變性避免競態條件

混合使用#

在實際項目中，往往需要混合使用多種範式。關鍵是：

  1. 理解每種範式的優缺點
  2. 根據具體問題選擇最適合的方式
  3. 保持程式碼風格的一致性

Java 中的範式混合示例：

  • 使用類和物件建模業務（OOP）
  • 使用 Stream API 處理集合（FP）
  • 使用泛型定義類型安全的容器（Generic）

學習建議#

  1. 深入理解原理：不只學習語法，更要理解每種範式背後的設計哲學

  2. 對比學習：同一個問題，嘗試用不同範式解決，比較優缺點

  3. 閱讀優秀程式碼：研究開源項目中範式的實際應用

  4. 動手實踐：在日常工作中刻意練習不同範式的應用

  5. 關注演進：現代語言不斷融合各種範式的優點，保持學習

Backward Code Review 職涯發展 Forward