2. 程式人生 > >編碼規範 | Java函式優雅之道（下）

編碼規範 | Java函式優雅之道（下）

阿新 • • 發佈：2019-08-12

上文背景

本文總結了一套與Java函式相關的編碼規則，旨在給廣大Java程式設計師一些編碼建議，有助於大家編寫出更優雅、更高質、更高效的程式碼。

 

內部函式引數儘量使用基礎型別

案例一：內部函式引數儘量使用基礎型別

現象描述：

// 呼叫程式碼
double price = 5.1D;
int number = 9;
double total = calculate(price, number);

// 計算金額函式
private double calculate(Double price, Integer number) {
    return price * number;
}

 

建議方案：

// 呼叫程式碼
double price = 5.1D;
int number = 9;
double total = calculate(price, number);

// 計算金額函式
private double calculate(double price, int number) {
    return price * number;
}

 

案例二：內部函式返回值儘量使用基礎型別

現象描述：

// 獲取訂單總額函式
public double getOrderAmount(List<Product> productList) {
    double amount = 0.0D;
    for (Product product : productList) {
        if (Objects.isNull(product) || Objects.isNull(product.getPrice())
            || Objects.isNull(product.getNumber())) {
            continue;
        }
        amount += calculate(product.getPrice(), product.getNumber());
    }
    return amount;
}

// 計算金額函式
private Double calculate(double price, double number) {
    return price * number;
}

 

建議方案：

// 獲取訂單總額函式
public double getOrderAmount(List<Product> productList) {
    double amount = 0.0D;
    for (Product product : productList) {
        if (Objects.isNull(product) || Objects.isNull(product.getPrice())
            || Objects.isNull(product.getNumber())) {
            continue;
        }
        amount += calculate(product.getPrice(), product.getNumber());
    }
    return amount;
}

// 計算金額函式
private double calculate(double price, double number) {
    return price * number;
}

 

此處只是舉例說明這種現象，更好的方式是採用流式(Stream)程式設計。

主要收益

  • 內部函式儘量使用基礎型別，避免了隱式封裝型別的打包和拆包；
  • 內部函式引數使用基礎型別，用語法上避免了內部函式的引數空指標判斷；
  • 內部函式返回值使用基礎型別，用語法上避免了呼叫函式的返回值空指標判斷。

儘量避免返回的陣列和列表為null

案例一：儘量避免返回的陣列為null，引起不必要的空指標判斷

現象描述：

// 呼叫程式碼
UserVO[] users = queryUser();
if (Objects.nonNull(users)) {
    for (UserVO user : users) {
        // 處理使用者資訊
    }
}

// 查詢使用者函式
private UserVO[] queryUser() {
    // 查詢使用者列表
    List<UserDO> userList = userDAO.queryAll();
    if (CollectionUtils.isEmpty(userList)) {
        return null;
    }

    // 轉化使用者陣列
    UserVO[] users = new UserVO[userList.size()];
    for (int i = 0; i < userList.size(); i++) {
        UserDO user = userList.get(i);
        users[i] = new UserVO();
        users[i].setId(user.getId());
        users[i].setName(user.getName());
    }

    // 返回使用者陣列
    return users;
}

 

建議方案：

// 呼叫程式碼
UserVO[] users = queryUser();
for (UserVO user : users) {
    // 處理使用者資訊
}

// 查詢使用者函式
private UserVO[] queryUser() {
    // 查詢使用者列表
    List<UserDO> userList = userDAO.queryAll();
    if (CollectionUtils.isEmpty(userList)) {
        return new UserVO[0];
    }

    // 轉化使用者陣列
    UserVO[] users = new UserVO[userList.size()];
    for (int i = 0; i < userList.size(); i++) {
        UserDO user = userList.get(i);
        users[i] = new UserVO();
        users[i].setId(user.getId());
        users[i].setName(user.getName());
    }

    // 返回使用者陣列
    return users;
}

 

案例二：儘量避免返回的列表為null，引起不必要的空指標判斷

現象描述：

// 呼叫程式碼
List<UserVO> userList = queryUser();
if (Objects.nonNull(userList)) {
    for (UserVO user : userList) {
        // 處理使用者資訊
    }
}

// 查詢使用者函式
private List<UserVO> queryUser(){
    // 查詢使用者列表
    List<UserDO> userList = userDAO.queryAll();
    if(CollectionUtils.isEmpty(userList)) {
        return null;
    }

    // 轉化使用者列表
    List<UserVO> userVoList = new ArrayList<>(userList.size());
    for(UserDO user : userList) {
        UserVO userVo = new UserVO();
        userVo.setId(user.getId());
        userVo.setName(user.getName());
        userVoList.add(userVo);
    }

    // 返回使用者列表
    return userVoList;
}

 

建議方案：

// 呼叫程式碼
List<UserVO> userList = queryUser();
for (UserVO user : userList) {
   // 處理使用者資訊
 }

// 查詢使用者函式
private List<UserVO> queryUser(){
    // 查詢使用者列表
    List<UserDO> userList = userDAO.queryAll();
    if(CollectionUtils.isEmpty(userList)) {
        return Collections.emptyList();
    }

    // 轉化使用者列表
    List<UserVO> userVoList = new ArrayList<>(userList.size());
    for(UserDO user : userList) {
        UserVO userVo = new UserVO();
        userVo.setId(user.getId());
        userVo.setName(user.getName());
        userVoList.add(userVo);
    }

    // 返回使用者列表
    return userVoList;
}

 

主要收益

  • 保證返回的陣列和列表不為null, 避免呼叫函式的空指標判斷。

封裝函式傳入引數

案例一：當傳入引數過多時，應封裝為引數類

Java規範不允許函式引數太多，不便於維護也不便於擴充套件。

現象描述：

// 修改使用者函式
public void modifyUser(Long id, String name, String phone, Integer age, 
    Integer sex, String address, String description) {
    // 具體實現邏輯
}

 

建議方案：

// 修改使用者函式
public void modifyUser(User user) {
    // 具體實現內容
}

// 使用者類
@Getter
@Setter
@ToString
private class User{
    private Long id;
    private String name;
    private String phone;
    private Integer age;
    private Integer sex;
    private String address;
    private String description;
}

 

當傳入成組引數時，應封裝為引數類

既然引數成組出現，就需要封裝一個類去描述這種現象。

現象描述：

// 獲取距離函式
public double getDistance(double x1, double y1, double x2, double y2) {
    // 具體實現邏輯
}

 

建議方案：

// 獲取距離函式
public double getDistance(Point point1, Point point2) {
    // 具體實現邏輯
}

// 點類
@Getter
@Setter
@ToString
private class Point{
    private double x;
    private double y;
}

 

主要收益

  • 封裝過多函式引數為類，使函式更便於擴充套件和維護；
  • 封裝成組函式引數為類，使業務概念更明確更清晰。

儘量用函式替換匿名內部類的實現

Java匿名內部類的優缺點:
在匿名內部類（包括Lambda表示式）中可以直接訪問外部類的成員，包括類的成員變數、函式的內部變數。正因為可以隨意訪問外部變數，所以會導致程式碼邊界不清晰。

首先推薦用Lambda表示式簡化匿名內部類，其次推薦用函式替換複雜的Lambda表示式的實現。

案例一：儘量用函式替換匿名內部類（包括Lambda表示式）的實現

現象描述：

// 傳送結算資料
sendWorkerSettleData(WorkerPushDataType.CHECKER, () -> {
    Date beginDate = DateUtils.addDays(currDate, -aheadDays);
    Date endDate = DateUtils.addDays(currDate, 1);
    return auditTaskDAO.statCheckerSettleData(beginDate, endDate);
});

 

建議方案：

// 傳送結算資料
sendWorkerSettleData(WorkerPushDataType.CHECKER, () -> statCheckerSettleData(currDate, aheadDays));

// 統計驗收員結算資料函式
private List<WorkerSettleData> statCheckerSettleData(Date currDate, int aheadDays) {
    Date beginDate = DateUtils.addDays(currDate, -aheadDays);
    Date endDate = DateUtils.addDays(currDate, 1);
    return auditTaskDAO.statCheckerSettleData(beginDate, endDate);
}

 

其實，還有一個更簡單的辦法。在呼叫函式sendWorkerSettleData（傳送作業員結算資料）之前計算開始日期、結束日期，就直接可以用函式auditTaskDAO.statCheckerSettleData(beginDate, endDate)代替匿名內部類實現。

案例二：拆分複雜匿名內部類實現介面為多個函式類介面

如果一個匿名內部類實現的介面幾個函式間關聯性不大，可以把這個介面拆分為幾個函式式介面，便於使用Lambda表示式。

現象描述：

// 清除過期資料
cleanExpiredData("使用者日誌表", new CleanExpiredDataOperator() {
    @Override
    public List<Date> queryExpiredDate(Integer remainDays) {
        return userDAO.queryExpiredDate(remainDays);
    }
    @Override
    public void cleanExpiredData(Date expiredDate) {
        userDAO.cleanExpiredData(expiredDate);
    }
});

// 清除過期資料函式
private void cleanExpiredData(String tableName, CleanExpiredDataOperator ,
cleanExpiredDataOperator) {
    // 功能實現程式碼
}

// 清除過期操作介面
interface CleanExpiredDataOperator {
    // 查詢過期日期
    public List<Date> queryExpiredDate(Integer remainDays);
    // 清除過期資料
    public void cleanExpiredData(Date expiredDate);
}

 

建議方案：

// 清除過期資料
cleanExpiredData("使用者日誌表", userDAO::queryExpiredDate,userDAO::cleanExpiredData);

// 清除過期資料函式
private void cleanExpiredData(String tableName, QueryExpiredDateOperator queryExpiredDateOperator, CleanExpiredDataOperator cleanExpiredDataOperator) {
    // 功能實現程式碼
}

// 查詢過期日期介面
interface QueryExpiredDateOperator {
    // 查詢過期日期
    public List<Date> queryExpiredDate(Integer remainDays);
}

// 清除過期操作介面
interface CleanExpiredDataOperator {
    // 清除過期資料
    public void cleanExpiredData(Date expiredDate);
}

 

主要收益

  • 定義函式並指定引數，明確規定了匿名內部類的程式碼邊界；
  • 利用Lambda表示式簡化匿名內部類實現，使程式碼更簡潔。

利用return精簡不必要的程式碼

案例一：刪除不必要的if

現象描述：

// 是否通過函式
public boolean isPassed(Double passRate) {
    if (Objects.nonNull(passRate) && passRate.compareTo(PASS_THRESHOLD) >= 0) {
        return true;
    }
    return false;
}

 

建議方案：

// 是否通過函式
public boolean isPassed(Double passRate) {
    return Objects.nonNull(passRate) && passRate.compareTo(PASS_THRESHOLD) >= 0;
}

 

案例二：刪除不必要的else

現象描述：

// 結算工資函式
public double settleSalary(Long workId, int workDays) {
    // 根據是否合格處理
    if (isQualified(workId)) {
        return settleQualifiedSalary(workDays);
    } else {
        return settleUnqualifiedSalary(workDays);
    }
}

 

建議方案：

// 結算工資函式
public double settleSalary(Long workId, int workDays) {
    // 根據是否合格處理
    if (isQualified(workId)) {
        return settleQualifiedSalary(workDays);
    }
    return settleUnqualifiedSalary(workDays);
}

 

案例三：刪除不必要的變數

現象描述：

// 查詢使用者函式
public List<UserDO> queryUser(Long id, String name) {
    UserQuery userQuery = new UserQuery();
    userQuery.setId(id);
    userQuery.setName(name);
    List<UserDO> userList = userDAO.query(userQuery);
    return userList;
}

 

建議方案：

// 查詢使用者函式
public List<UserDO> queryUser(Long id, String name) {
    UserQuery userQuery = new UserQuery();
    userQuery.setId(id);
    userQuery.setName(name);
    return userDAO.query(userQuery);
}

 

主要收益

  • 精簡不必要的程式碼，讓程式碼看起來更清爽

利用臨時變數優化程式碼

在一些程式碼中，經常會看到a.getB().getC()...getN()的寫法，姑且叫做“函式的級聯呼叫”，程式碼健壯性和可讀性太差。建議：杜絕函式的級聯呼叫，利用臨時變數進行拆分，並做好物件空指標檢查。

案例一：利用臨時變數釐清邏輯

現象描述：

// 是否土豪使用者函式
private boolean isRichUser(User user) {
    return Objects.nonNull(user.getAccount())
        && Objects.nonNull(user.getAccount().getBalance())
        && user.getAccount().getBalance().compareTo(RICH_THRESHOLD) >= 0;
}

 

這是精簡程式碼控的最愛，但是可讀性實在太差。

建議方案：

// 是否土豪使用者函式
private boolean isRichUser(User user) {
    // 獲取使用者賬戶
    UserAccount account = user.getAccount();
    if (Objects.isNull(account)) {
        return false;
    }

    // 獲取使用者餘額
    Double balance = account.getBalance();
    if (Objects.isNull(balance)) {
        return false;
    }

    // 比較使用者餘額
    return balance.compareTo(RICH_THRESHOLD) >= 0;
}

 

這個方案，增加了程式碼行數，但是邏輯更清晰。
有時候，當代碼的精簡性和可讀性發生衝突時，個人更偏向於保留程式碼的可讀性。

案例二：利用臨時變數精簡程式碼

現象描述：

// 構建使用者函式
public UserVO buildUser(UserDO user) {
    UserVO vo = new UserVO();
    vo.setId(user.getId());
    vo.setName(user.getName());
    if (Objects.nonNull(user.getAccount())) {
        vo.setBalance(user.getAccount().getBalance());
        vo.setDebt(user.getAccount().getDebt());
    }
    return vo;
}

 

這麼寫，大約是為了節約一個臨時變數吧。

建議方案：

// 構建使用者函式
public UserVO buildUser1(UserDO user) {
    UserVO vo = new UserVO();
    vo.setId(user.getId());
    vo.setName(user.getName());
    UserAccount account = user.getAccount();
    if (Objects.nonNull(account)) {
        vo.setBalance(account.getBalance());
        vo.setDebt(account.getDebt());
    }
    return vo;
}

 

主要收益

  • 利用臨時變數釐清邏輯，顯得業務邏輯更清晰；
  • 利用臨時變數精簡程式碼，看變數名稱即知其義，減少了大量無用程式碼；
  • 如果獲取函式比較複雜耗時，利用臨時變數可以提高執行效率；
  • 利用臨時變數避免函式的級聯呼叫，可有效預防空指標異常。

僅保留函式需要的引數

在一些程式碼中，經常會看到a.getB().getC()...getN()的寫法，姑且叫做“函式的級聯呼叫”，程式碼健壯性和可讀性太差。建議：杜絕函式的級聯呼叫，利用臨時變數進行拆分，並做好物件空指標檢查。

案例一：刪除多餘的引數

現象描述：

// 修改使用者狀態函式
private void modifyUserStatus(Long userId, Integer status, String unused) {
    userCache.modifyStatus(userId, status);
    userDAO.modifyStatus(userId, status);
}
其中，unused引數是無用引數。

建議方案：

// 修改使用者狀態函式
private void modifyUserStatus(Long userId, Integer status) {
    userCache.modifyStatus(userId, status);
    userDAO.modifyStatus(userId, status);
}

 

案例二：用屬性取代物件

現象描述：

// 刪除使用者函式
private void deleteUser(User user) {
    userCache.delete(user.getId());
    userDAO.delete(user.getId());
}

 

建議方案：

// 刪除使用者函式
private void deleteUser(Long userId) {
    userCache.delete(userId);
    userDAO.delete(userId);
}

 

建議方案：

呼叫函式時，引數物件不需要專門構建，而函式使用其屬性超過3個，可以不必使用該規則。

主要收益

僅保留函式需要的引數，明確了呼叫時需要賦值的引數，避免了呼叫時還要去構造些無用引數。

後記

"眾人拾柴火焰高"。如果有更多更好的觀點，亦或有更好的程式碼案例，歡迎大家進行補充說明。筆者希望以此文拋磚引玉，如果最終形成一套完善的Java編碼規範，善莫大焉。

關注高德技術，找到更多出行技術領域專業

相關推薦

編碼規範 | Java函式優雅之道（下）

上文背景 本文總結了一套與Java函式相關的編碼規則，旨在給廣大Java程式設計師一些編碼建議，有助於大家編寫出更優雅、更高質、更高效的程式碼。   內部函式引數儘量使用基礎型別 案例一：內部函式引數儘量使用基礎型別 現象描述： // 呼叫程式碼 double price = 5.1D; int

編碼規範 | Java函式優雅之道（上）

導讀 隨著軟體專案程式碼的日積月累，系統維護成本變得越來越高，是所有軟體團隊面臨的共同問題。持續地優化程式碼，提高程式碼的

java中文亂碼解決之道（三）-----編碼詳情：偉大的創想---Unicode編碼

隨著計算機的發展、普及，世界各國為了適應本國的語言和字元都會自己設計一套自己的編碼風格，正是由於這種亂，導致存在很多種編碼方式，以至於同一個二進位制數字可能會被解釋成不同的符號。為了解決這種不相容的問題

行java之道（一）學習的方法

行java之道（一）學習的心得 自序 我是一名普通的JAVA開發從業者，接下來一段時間我會更新一些自己的心得體會，之所以想要這麼做，一是因為自己早有將自己的心得體會記錄下來的願景；二是因為自己在近來招聘中所遇見的應聘者誇誇其談框架，卻對基礎答非所問

Numpy 修煉之道 （12）—— genfromtxt函式

定義輸入 genfromtxt的唯一強制引數是資料的源。它可以是字串，字串列表或生成器。如果提供了單個字串，則假定它是本地或遠端檔案或具有read方法的開啟的類檔案物件的名稱，例如檔案或StringIO.StringIO物件。如果提供了字串列表或返回字串的生成器，則每個字串在檔案中被視為一行。當傳遞

Numpy 修煉之道 （8）—— 常用函式

在瞭解了 Numpy 的基本運算操作，下面來看下 Numpy常用的函式。 數學運算函式    add（x1，x2 [，out]）                      

HT圖形組件設計之道（三）

忘記 ive 設計架構 垃圾回收 喜歡 進行 src 支持 優秀 上篇我們通過定制了CPU和內存展示界面，體驗了HT for Web通過定義矢量實現圖形繪制與業務數據的代碼解耦及綁定聯動，這類案例興許文章還會繼續以便大家掌握很多其它的矢量應用場景，本篇我們先切換個話題

Mybbatis學習之道（一）

org unit primary sas oca manage result ava namespace 本例子為采用的mysql+maven+mybatis構建。 　　初步學習mybatis： 　　　　mybatis為一個半自動框架，相對於hibernate來說他更加輕巧

java虛擬機之GC（轉）

reg 建立 行高 resize 組合 完成 player 操作 出棧 垃圾回收主要內容： 　　1. 那些內存需要回收？ 　　2. 什麽時候回收？ 　　3. 如何回收？ 垃圾回收主要針對運行時數據區那些區域？ 　　運行時數據區的線程私有區域有：虛擬機棧，本地方法棧，程序計數

JAVA基礎學習之路（一）

個人理解 整形 之路 boolean mman 類型 布爾 屬性 註釋 JAVA基礎概念： PATHl: path屬於操作系統的屬性，是系統用來搜尋可執行文件的路徑，個人理解是類似於linux中的全局變量 CALSSPATH:java程序解釋類文件時加載文件的路徑 註釋

JAVA基礎學習之路（五）數組的定義

對象 ava void 數據類型 class 語法 info int .com 什麽是數組：就是一堆相同類型的數據放一堆（一組相關變量的集合） 定義語法： 聲明並開辟數組 　　　　數據類型 數組名[] = new 數據類型[長度]； 分布完成 聲明數組：數據類型

JAVA基礎學習之路（六）數組與方法參數的傳遞

就是 .com 另一個 AS oid span 參數 spa nbsp 通常，向方法中傳遞的都是基本數據類型，而向方法中傳遞數組時，就需要考慮內存的分配 public class test2 { public static void main(String a

JAVA基礎學習之路（七）對象數組的定義及使用

get system turn book code null 實例 urn TE 兩種定義方式： 動態初始化： 定義並開辟數組：類名稱 對象數組名[] = new 類名稱[長度] 分布按成：類名稱 對象數組名[] = null； 對象數組名 = new 類名稱[長度]

JAVA基礎學習之路（十）this關鍵字

代碼 學習之路 ava 老人與海 color 問題 turn urn println class Book { String name; int price; int num;//構造方法之間的互相調用解決了代碼的重復問題，但是一定要留出口

Java SSM框架之MyBatis3（八）MyBatis之動態SQL

one uniq div mapper ODB when rop mail con 前言： 　　mybatis框架中最具特色的便是sql語句中的自定義，而動態sql的使用又使整個框架更加靈活。 創建User表 /*Table structure for tab

dotNet程序員的Java爬坑之旅（一）

是我 方法 轉java 自己的 java pri 也好 工作 計劃 　　　　仔細想了下還是轉java吧，因為後期不管是留在北京也好還是回老家也好，java的工作都會好找一點。現在的工作主要還是寫.net，目標是下一次離職的時候可以找到一份全職的java工作，我一直都覺得實踐

dotNet程序員的Java爬坑之旅（二）

模式 最好的 https servlet 很多 過濾器 () 被調用 回調 　　囉裏囉唆的寫了一大堆，最後還是全刪除了。哎~ 　　言歸正傳，最近因爲發生了很多事情，所以更新的有嗲晚了，最近也一直在學習，但是感覺效率什麼的不是很高，這是不對的，反思一下，從這篇博文開始，打起精

dotNet程序員的Java爬坑之旅（三）之spring MVC篇一

www. let ref ide filter ESS pro enc require 使用maven構建springMVC項目，開發工具為IDEA 一、構建Maven項目，模板為WebApp 二、在pom文件中配置SpringMvc配置（springMvc需要以來serv

thinking in java (九) ----- 陣列之二（Array）

效能 在java中有一系列的方式可以用來作為存放物件的容器，並且有很多在操作上比陣列要簡單。但是我們仍然會使用陣列。因為陣列有自己的優點，效率，型別和儲存基本型別的能力。在java中，陣列是效率最高的儲存和隨訪問物件引用序列的方式。 在一般的專案中，確實陣列是咩有List,Ma

Java學習筆記之FreeTTS（語音）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！