1. 規則

1.1. 傳遞參數，返回結果

1.1.1. 異常和中斷都不算返回結果

1.2. 減少共用的可變數據結構能幫助你降低維護和調試程式的代價

2. 耦合性

2.1. 軟體系統中各組件之間是否相互獨立

3. 內聚性

3.1. 系統的各相關部分之間如何協作

4. 無狀態的行為

4.1. 流水線中的函數不會由於需要等待從另一個方法中讀取變數，或者由於需要寫入的變數同時有另一個方法正在寫而發生中斷

4.2. 無須擔心鎖引起的各種問題

4.3. 充分發掘系統的併發能力

5. 副作用

5.1. 函數的效果已經超出了函數自身的範疇

5.2. 除了構造器內的初始化操作，對類中數據結構的任何修改，包括欄位的賦值操作

5.3. 拋出一個異常

5.4. 進行輸入/輸出操作

6. 無副作用

6.1. 純粹的

6.2. 如果一個方法既不修改它內嵌類的狀態，也不修改其他對象的狀態，使用return返回所有的計算結果

6.3. 如果構成系統的各個組件都能遵守這一原則，該系統就能在完全無鎖的情況下，使用多核的併發機制，因為任何一個方法都不會對其他的方法造成干擾

6.4. 瞭解程式中哪些部分是相互獨立的

7. 不可變對象

7.1. 一旦完成初始化就不會被任何方法修改狀態

7.2. 一旦一個不可變對象初始化完畢，它永遠不會進入到一個無法預期的狀態

7.3. 線程安全的

8. 聲明式編程

8.1. 關註要做什麼

8.2. 更加接近問題陳述

9. 命令式編程

9.1. 指令和電腦底層的辭彙非常相近

9.2. 專註於如何實現

10. 引用透明性

10.1. 沒有可感知的副作用

10.1.1. 不改變對調用者可見的變數

10.1.2. 不拋出異常

10.1.3. 不進行I/O

10.2. 如果一個函數只要傳遞同樣的參數值，總是返回同樣的結果，那這個函數就是引用透明的

11. 記憶化

11.1. 緩存

11.2. 對代價昂貴或者需長時間計算才能得到結果的變數值的優化

11.2.1. 通過保存機制而不是重覆計算

12. 函數式編程

12.1. 程式有一定的副作用

12.1.1. 該副作用不會被其他的調用者感知

12.1.1.1. 如果沒人能感知的話，函數式也允許進行變更，這意味著可以修改局部變數

12.1.2. 調用者不需要知道，或者完全不在意這些副作用

12.2. 如果有副作用

12.2.1. 必須設法隱藏它們的非函數式行為

12.2.2. 否則就不能調用這些方法

12.2.3. 需要確保它們對數據結構的任何修改對於調用者都是不可見的，可以通過首次複製，或者捕獲任何可能拋出的異常實現這一目的

12.3. 函數式的函數或方法都只能修改本地變數

12.3.1. 所有的欄位都為final類型

12.3.2. 所有的引用類型欄位都指向不可變對象

12.3.3. 引用的對象都應該是不可修改的對象

12.4. 選擇使用引用透明的函數

12.5. 不應該拋出任何異常

12.5.1. 選擇在本地局部地使用異常，避免通過介面將結果暴露給其他方法，這種方式既取得了函數式的優點，又不會過度膨脹代碼

13. 局部函數式（partial function）

13.1. 大多數的輸入值都返回一個確定的結果

13.2. 對另一些輸入值，它的結果是未定義的，甚至不返回任何結果

13.2.1. 除法，如果除法的第二操作數是0

13.2.2. 開平方運算，開平方的參數為負數

13.2.3. 使用Optional類型

14. 純粹的函數式編程

14.1. 不提供像while或者for這樣的迭代結構

14.1.1. 這種結構經常隱藏著陷阱，誘使你修改對象

15. 遞歸recursion

15.1. 函數式編程特別推崇的一種技術

15.2. 培養你思考要“做什麼”的編程風格

15.3. 每個程式都能使用無須修改的遞歸重寫，通過這種方式避免使用迭代

15.3.1. 採用遞歸可以取代迭代式的結構，比如while迴圈

15.3.2. 使用遞歸，可以消除每步都需更新的迭代變數

15.4. 遞歸的形式通常效率都更差一些

15.4.1. 因為每次執行遞歸方法調用都會在調用棧上創建一個新的棧幀，用於保存每個方法調用的狀態（即它需要進行的乘法運算），這個操作會一直指導程式運行直到結束

15.4.2. 很容易遭遇StackOverflowError異常

15.5. 大多數時候編程的效率要比細微的執行時間差異重要得多

15.6. 尾調優化（tail-call optimization）

15.6.1. 編寫方法的一個迭代定義，不過迭代調用發生在函數的最後

15.6.1.1. 調用發生在尾部

15.6.2. Java不支持這種優化

15.6.3. Scala、Groovy和Kotlin，支持對這種形式的遞歸的優化

15.6.3.1. 最終實現的效果和迭代不相上下（它們的運行速度幾乎是相同的）