高效代碼：軟件編程實踐原則

第1章 直面軟件復雜性 ·······················.1
1.1 代碼為什麼會越來越混亂 ···········.1
1.2 復雜性的真相 ··························.1
1.3 復雜性無處不在 ·······················.3
1.4 你的代碼正在失控 ····················.4
1.5 為什麼簡單的代碼會變復雜 ········.6
1.6 控制復雜性的策略 ····················.7
1.7 小結 ····································.10
第2章 遵循設計原則 ························.11
2.1 單一職責原則 ························.11
2.1.1 未遵循單一職責原則的代碼示例 ·····················.12
2.1.2 遵循單一職責原則的代碼示例 ···························.14
2.2 開放封閉原則 ························.17
2.2.1 未遵循開放封閉原則的代碼示例 ·····················.17
2.2.2 遵循開放封閉原則的代碼示例 ···························.18
2.3 裏氏替換原則 ························.20
2.3.1 未遵循裏氏替換原則的代碼示例 ·····················.21
2.3.2 遵循裏氏替換原則的代碼示例 ···························.22
2.4 接口隔離原則 ························.23
2.4.1 未遵循接口隔離原則的代碼示例 ·····················.24
2.4.2 遵循接口隔離原則的代碼示例 ···························.25
2.5 依賴倒置原則 ························.27
2.5.1 未遵循依賴倒置原則的代碼示例 ·····················.28
2.5.2 遵循依賴倒置原則的代碼示例 ···························.29
2.6 迪米特法則 ···························.30
2.6.1 未遵循迪米特法則的代碼示例 ···························.32
2.6.2 遵循迪米特法則的代碼示例 ···························.33
2.7 設計原則並非教條 ......................... 36
2.8 小結 ................................................. 36
第3章 遵守編程規範 ·························.38
3.1 編程規範的多維內涵 ···············.38
3.2 編程規範的重要性 ··················.39
3.3 編程規範核心要素解析 ············.41
3.4 制定高效編程規範 ··················.43
3.5 規範執行比規範本身更重要 ······.47
3.6 解讀業界優秀編程規範 ············.49
3.7 小結 ····································.50
第4章 編寫可維護性代碼 ···················.51
4.1 為什麼“代碼可運行”遠遠不夠 ··.51
4.2 什麼是可維護性代碼 ···············.52
4.3 如何編寫可維護性代碼 ············.55
4.3.1 命名的藝術：讓變量和函數自述身份 ·····················.55
4.3.2 掌控邏輯控制流程和數據流向 ···························.60
4.3.3 設計包結構 ··················.67
4.3.4 異常管理 ·····················.76
4.3.5 提高代碼的可測試性 ······.80
4.3.6 使用設計模式 ···············.85
4.4 代碼評審 ······························.86
4.5 小結 ····································.89
第5章 模塊化編程 ···························.90
5.1 模塊：分而治之 ·····················.90
5.2 接口：連接的橋梁 ··················.91
5.3 抽象：提取共性，減少重復 ······.95
5.4 深模塊和淺模塊 ·····················.96
5.4.1 深模塊 ························.96
5.4.2 淺模塊 ························.97
5.5 封裝和信息隱藏 ·····················.98
5.6 組合優於繼承 ························.99
5.7 依賴註入和控制反轉 ··············.103
5.8 小結 ···································.108
第6章 代碼是數據的映射 ·················.109
6.1 以業務邏輯為核心的編程 ········.109
6.2 以數據結構為核心的編程 ········.111
6.3 應用數據結構優化代碼 ···········.114
6.3.1 基本數據結構 ··············.115
6.3.2 高效使用Map結構 ·······.119
6.3.3 使用結構體優化重復代碼 ··························.121
6.3.4 使用接口優化代碼擴展性 ·······················.122
6.4 業務邏輯驅動編程和數據結構驅動編程 ·····························.124
6.5 小結 ............................................... 124
第7章 選擇編程範式 ·······················.125
7.1 什麼是編程範式 ····················.125
7.2 為什麼要掌握編程範式 ···········.125
7.3 編程範式分類 ·······················.126
7.4 主流編程範式解析 ·················.128
7.4.1 過程式編程 ·················.128
7.4.2 面向對象編程 ··············.132
7.4.3 函數式編程 ·················.137
7.4.4 邏輯式編程 ·················.142
7.4.5 編程範式對比 ··············.145
7.5 對編程範式的思考 ················.146
7.6 小結 ··································.147
第8章 分離業務邏輯和技術實現 ········. 148
8.1 業務邏輯和技術實現 ·············.148
8.2 分離業務邏輯代碼和技術實現代碼 ··································.150
8.3 關註點分離 ·························.151
8.4 領域驅動設計：解耦業務邏輯的利器 ··································.153
8.4.1 什麼是領域驅動設計 ····.153
8.4.2 領域驅動設計的關鍵概念 ·························.153
8.4.3 應用領域驅動設計分離業務邏輯和技術實現 ····.156
8.5 實踐中的挑戰和解決方案 ·······.162
8.6 小結 ··································.163
第9章 測試驅動開發 ·······················. 165
9.1 軟件測試概述 ······················.165
9.2 讓測試成為編碼的起點 ··········.168
9.3 單元測試實踐 ······················.169
9.3.1 單元測試的優勢 ··········.169
9.3.2 如何編寫單元測試 ·······.170
9.4 小結 ··································.182
第10章 優化代碼性能 ·····················.183
10.1 性能優化時機 ·····················. 183
10.2 數據驅動的優化決策 ············. 184
10.3 性能優化策略 ·····················. 186
10.4 性能優化實踐 ·····················. 188
10.4.1 優化計算效率············.189
10.4.2 優化內存資源············.193
10.4.3 優化I/O操作 ············.197
10.5 代碼可維護性和性能的平衡 ···. 202
10.6 小結 ·································. 202
第11章 持續重構代碼 ·····················.204
11.1 重構為代碼註入生命力 ·········. 204
11.2 為什麼重構不可忽視 ············. 205
11.3 何時重構 ···························. 206
11.4 重構實踐 ···························.209
11.5 識別代碼的“壞味道” ·········.211
11.5.1 重復代碼 ··················.211
11.5.2 長函數 ·····················.214
11.5.3 過長的參數列表 ·········.216
11.5.4 過大的類 ··················.217
11.5.5 過長的消息鏈 ············.219
11.5.6 冗余類 ·····················.220
11.5.7 過度抽象 ··················.222
11.5.8 神秘命名 ··················.223
11.5.9 隱式依賴 ··················.224
11.6 重構和重寫 ························.225
11.7 小結 ·································.225
第12章 文檔、註釋和知識共享 ··········.226
12.1 讓文檔成為團隊的知識庫 ······.226
12.1.1 文檔的必要性 ············.226
12.1.2 明確文檔類型 ············.227
12.1.3 文檔的結構和組織······.234
12.1.4 文檔的維護和更新······.236
12.1.5 提高文檔的可訪問性和易用性·····················.236
12.2 讓註釋為代碼加分 ···············. 237
12.2.1 統一註釋格式············.238
12.2.2 註釋闡明代碼意圖，而非代碼內容············.240
12.2.3 註釋描述代碼中不明顯的部分·····················.242
12.2.4 區分低級註釋和高級註釋························.244
12.2.5 同步更新註釋和代碼···.246
12.3 知識共享和團隊協作 ············. 247
12.3.1 促進知識共享············.247
12.3.2 提高團隊協作效率······.249
12.4 小結 ·································. 250