Java 函數優雅之道
導讀
隨着軟件項目代碼的日積月累，系統維護成本變得愈來愈高，是全部軟件團隊面臨的共同問題。持續地優化代碼，提升代碼的質量，是提高系統生命力的有效手段之一。軟件系統思惟有句話「Less coding, more thinking（少編碼、多思考）」，也有這麼一句俚語「Think more, code less（思考越多，編碼越少）」。因此，咱們在編碼中多思考多總結，努力提高本身的編碼水平，才能編寫出更優雅、更高質、更高效的代碼。
本文總結了一套與Java函數相關的編碼規則，旨在給廣大Java程序員一些編碼建議，有助於你們編寫出更優雅、更高質、更高效的代碼。這套編碼規則，經過在高德採集部門的實踐，已經取得了不錯的成效。程序員
1.使用通用工具函數
案例1: 字符串比較
現象描述：
不完善的寫法：數據庫
thisName != null && thisName.equals(name);
更完善的寫法：apache
(thisName == name) || (thisName != null && thisName.equals(name));
建議方案：
Objects.equals(name, thisName);
案例2: 判斷列表爲空
現象描述：
!(list == null || list.isEmpty());
建議方案：
import org.apache.commons.collections4.CollectionUtils; CollectionUtils.isNotEmpty(list);
主要收益
- 函數式編程，業務代碼減小，邏輯一目瞭然；
- 通用工具函數，邏輯考慮周全，出問題機率低。
2.拆分超大函數
當一個函數超過80行後，就屬於超大函數，須要進行拆分。編程
案例1: 每個代碼塊均可以封裝爲一個函數
每個代碼塊必然有一個註釋，用於解釋這個代碼塊的功能。
若是代碼塊前方有一行註釋，就是在提醒你——能夠將這段代碼替換成一個函數，並且能夠在註釋的基礎上給這個函數命名。若是函數有一個描述恰當的名字，就不須要去看內部代碼到底是如何實現的。數組
現象描述：
// 每日生活函數
public void liveDaily() {
// 吃飯
// 吃飯相關代碼幾十行
// 編碼
// 編碼相關代碼幾十行
// 睡覺
// 睡覺相關代碼幾十行
}
建議方案：
// 每日生活函數
public void liveDaily() {
// 吃飯
eat();
// 編碼
code();
// 睡覺
sleep();
}
// 吃飯函數
private void eat() {
// 吃飯相關代碼
}
// 編碼函數
private void code() {
// 編碼相關代碼
}
// 睡覺函數
private void sleep() {
// 睡覺相關代碼
}
案例2: 每個循環體均可以封裝爲一個函數
現象描述：
// 生活函數
public void live() {
while (isAlive) {
// 吃飯
eat();
// 編碼
code();
// 睡覺
sleep();
}
}
建議方案：
// 生活函數
public void live() {
while (isAlive) {
// 每日生活
liveDaily();
}
}
// 每日生活函數
private void liveDaily() {
// 吃飯
eat();
// 編碼
code();
// 睡覺
sleep();
}
案例3: 每個條件體均可以封裝爲一個函數
現象描述：
// 外出函數
public void goOut() {
// 判斷是否週末
// 判斷是否週末: 是週末則遊玩
if (isWeekday()) {
// 遊玩代碼幾十行
}
// 判斷是否週末: 非週末則工做
else {
// 工做代碼幾十行
}
}
建議方案：
// 外出函數
public void goOut() {
// 判斷是否週末
// 判斷是否週末: 是週末則遊玩
if (isWeekday()) {
play();
}
// 判斷是否週末: 非週末則工做
else {
work();
}
}
// 遊玩函數
private void play() {
// 遊玩代碼幾十行
}
// 工做函數
private void work() {
// 工做代碼幾十行
}
主要收益
- 函數越短小精悍，功能就越單一，每每生命週期較長；
- 一個函數越長，就越不容易理解和維護，維護人員不敢輕易修改；
- 在過長函數中，每每含有難以發現的重複代碼。
3.同一函數內代碼塊級別儘可能一致
案例1: 代碼塊級別儘可能保持一致
現象描述：
// 每日生活函數
public void liveDaily() {
// 吃飯
eat();
// 編碼
code();
// 睡覺
// 睡覺相關代碼幾十行
}
很明顯，睡覺這塊代碼塊，跟eat（吃飯）和code（編碼）不在同一級別上，顯得比較突兀。若是把寫代碼比做寫文章，eat（吃飯）和code（編碼）是段落大意，而睡覺這塊代碼塊屬於一個詳細段落。而在liveDaily（每日生活）這個函數上，只須要寫出主要流程（段落大意）便可。框架
建議方案：
public void liveDaily() {
// 吃飯
eat();
// 編碼
code();
// 睡覺
sleep();
}
// 睡覺
private void sleep() {
// 睡覺相關代碼
}
主要收益
- 函數調用代表用途，函數實現表達邏輯，井井有條便於理解；
- 不用層次的代碼塊放在一個函數中，容易讓人以爲代碼頭重腳輕。
4.封裝相同功能代碼爲函數
案例1: 封裝相同代碼爲函數
現象描述：
// 禁用用戶函數
public void disableUser() {
// 禁用黑名單用戶
List<Long> userIdList = queryBlackUser();
for (Long userId : userIdList) {
User userUpdate = new User();
userUpdate.setId(userId);
userUpdate.setEnable(Boolean.FALSE);
userDAO.update(userUpdate);
}
// 禁用過時用戶
userIdList = queryExpiredUser();
for (Long userId : userIdList) {
User userUpdate = new User();
userUpdate.setId(userId);
userUpdate.setEnable(Boolean.FALSE);
userDAO.update(userUpdate);
}
}
建議方案：
// 禁用用戶函數
public void disableUser() {
// 禁用黑名單用戶
List<Long> userIdList = queryBlackUser();
for (Long userId : userIdList) {
disableUser(userId);
}
// 禁用過時用戶
userIdList = queryExpiredUser();
for (Long userId : userIdList) {
disableUser(userId);
}
}
// 禁用用戶函數
private void disableUser(Long userId) {
User userUpdate = new User();
userUpdate.setId(userId);
userUpdate.setEnable(Boolean.FALSE);
userDAO.update(userUpdate);
}
案例2: 封裝類似代碼爲函數
封裝類似代碼爲函數，差別性經過函數參數控制。less
現象描述：
// 經過工單函數
public void adoptOrder(Long orderId) {
Order orderUpdate = new Order();
orderUpdate.setId(orderId);
orderUpdate.setStatus(OrderStatus.ADOPTED);
orderUpdate.setAuditTime(new Date());
orderDAO.update(orderUpdate);
}
// 駁回工單函數
public void rejectOrder(Long orderId) {
Order orderUpdate = new Order();
orderUpdate.setId(orderId);
orderUpdate.setStatus(OrderStatus.REJECTED);
orderUpdate.setAuditTime(new Date());
orderDAO.update(orderUpdate);
}
建議方案：
// 經過工單函數
public void adoptOrder(Long orderId) {
auditOrder(orderId, OrderStatus.ADOPTED);
}
// 駁回工單函數
public void rejectOrder(Long orderId) {
auditOrder(orderId, OrderStatus.REJECTED);
}
// 審覈工單函數
private void auditOrder(Long orderId, OrderStatus orderStatus) {
Order orderUpdate = new Order();
orderUpdate.setId(orderId);
orderUpdate.setStatus(orderStatus);
orderUpdate.setAuditTime(new Date());
orderDAO.update(orderUpdate);
}
主要收益
- 封裝公共函數，減小代碼行數，提升代碼質量；
- 封裝公共函數，使業務代碼更精煉，可讀性可維護性更強。
5.封裝獲取參數值函數
案例1: 把獲取參數值封裝爲函數
現象描述：
// 是否經過函數
public boolean isPassed(Long userId) {
// 獲取經過閾值
double thisPassThreshold = PASS_THRESHOLD;
if (Objects.nonNull(passThreshold)) {
thisPassThreshold = passThreshold;
}
// 獲取經過率
double passRate = getPassRate(userId);
// 判讀是否經過
return passRate >= thisPassThreshold;
}
建議方案：
// 是否經過函數
public boolean isPassed(Long userId) {
// 獲取經過閾值
double thisPassThreshold = getPassThreshold();
// 獲取經過率
double passRate = getPassRate(userId);
// 判讀是否經過
return passRate >= thisPassThreshold;
}
// 獲取經過閾值函數
private double getPassThreshold() {
if (Objects.nonNull(passThreshold)) {
return passThreshold;
}
return PASS_THRESHOLD;
}
主要收益
- 把獲取參數值從業務函數中獨立，使業務邏輯更清晰；
- 封裝的獲取參數值爲獨立函數，能夠在代碼中重複使用。
6.經過接口參數化封裝相同邏輯
案例1: 經過接口參數化封裝相同邏輯
現象描述：
// 發送審覈員結算數據函數
public void sendAuditorSettleData() {
List<WorkerSettleData> settleDataList = auditTaskDAO.statAuditorSettleData();
for (WorkerSettleData settleData : settleDataList) {
WorkerPushData pushData = new WorkerPushData();
pushData.setId(settleData.getWorkerId());
pushData.setType(WorkerPushDataType.AUDITOR);
pushData.setData(settleData);
pushService.push(pushData);
}
}
// 發送驗收員結算數據函數
public void sendCheckerSettleData() {
List<WorkerSettleData> settleDataList = auditTaskDAO.statCheckerSettleData();
for (WorkerSettleData settleData : settleDataList) {
WorkerPushData pushData = new WorkerPushData();
pushData.setId(settleData.getWorkerId());
pushData.setType(WorkerPushDataType.CHECKER);
pushData.setData(settleData);
pushService.push(pushData);
}
}
建議方案：
// 發送審覈員結算數據函數
public void sendAuditorSettleData() {
sendWorkerSettleData(WorkerPushDataType.AUDITOR, () -> auditTaskDAO.statAuditorSettleData());
}
// 發送驗收員結算數據函數
public void sendCheckerSettleData() {
sendWorkerSettleData(WorkerPushDataType.CHECKER, () -> auditTaskDAO.statCheckerSettleData());
}
// 發送做業員結算數據函數
public void sendWorkerSettleData(WorkerPushDataType dataType, WorkerSettleDataProvider dataProvider) {
List<WorkerSettleData> settleDataList = dataProvider.statWorkerSettleData();
for (WorkerSettleData settleData : settleDataList) {
WorkerPushData pushData = new WorkerPushData();
pushData.setId(settleData.getWorkerId());
pushData.setType(dataType);
pushData.setData(settleData);
pushService.push(pushData);
}
}
// 做業員結算數據提供者接口
private interface WorkerSettleDataProvider {
// 統計做業員結算數據
public List<WorkerSettleData> statWorkerSettleData();
}
主要收益
- 把核心邏輯從各個業務函數中抽析，使業務代碼更清晰更易維護；
- 避免重複性代碼屢次編寫，精簡重複函數越多收益越大。
7.減小函數代碼層級
若是要使函數優美，建議函數代碼層級在1-4之間，過多的縮進會讓函數難以閱讀。ide
案例1: 利用return提早返回函數
現象描述：
// 獲取用戶餘額函數
public Double getUserBalance(Long userId) {
User user = getUser(userId);
if (Objects.nonNull(user)) {
UserAccount account = user.getAccount();
if (Objects.nonNull(account)) {
return account.getBalance();
}
}
return null;
}
建議方案：
// 獲取用戶餘額函數
public Double getUserBalance(Long userId) {
// 獲取用戶信息
User user = getUser(userId);
if (Objects.isNull(user)) {
return null;
}
// 獲取用戶帳戶
UserAccount account = user.getAccount();
if (Objects.isNull(account)) {
return null;
}
// 返回帳戶餘額
return account.getBalance();
}
案例2: 利用continue提早結束循環
現象描述：
// 獲取合計餘額函數
public double getTotalBalance(List<User> userList) {
// 初始合計餘額
double totalBalance = 0.0D;
// 依次累加餘額
for (User user : userList) {
// 獲取用戶帳戶
UserAccount account = user.getAccount();
if (Objects.nonNull(account)) {
// 累加用戶餘額
Double balance = account.getBalance();
if (Objects.nonNull(balance)) {
totalBalance += balance;
}
}
}
// 返回合計餘額
return totalBalance;
}
建議方案：
// 獲取合計餘額函數
public double getTotalBalance(List<User> userList) {
// 初始合計餘額
double totalBalance = 0.0D;
// 依次累加餘額
for (User user : userList) {
// 獲取用戶帳戶
UserAccount account = user.getAccount();
if (Objects.isNull(account)) {
continue;
}
// 累加用戶餘額
Double balance = account.getBalance();
if (Objects.nonNull(balance)) {
totalBalance += balance;
}
}
// 返回合計餘額
return totalBalance;
}
特殊說明：
其它方式：在循環體中，先調用案例1的函數getUserBalance(獲取用戶餘額)，再進行對餘額進行累加。
在循環體中，建議最多使用一次continue。若是須要有使用屢次continue的需求，建議把循環體封裝爲一個函數。函數式編程
案例3: 利用條件表達式函數減小層級
請參考下一章的"案例2: 把複雜條件表達式封裝爲函數"函數
主要收益
- 代碼層級減小，代碼縮進減小；
- 模塊劃分清晰，方便閱讀維護。
8.封裝條件表達式函數
案例1: 把簡單條件表達式封裝爲函數
現象描述：
// 獲取門票價格函數
public double getTicketPrice(Date currDate) {
if (Objects.nonNull(currDate) && currDate.after(DISCOUNT_BEGIN_DATE)
&& currDate.before(DISCOUNT_END_DATE)) {
return TICKET_PRICE * DISCOUNT_RATE;
}
return TICKET_PRICE;
}
建議方案：
// 獲取門票價格函數
public double getTicketPrice(Date currDate) {
if (isDiscountDate(currDate)) {
return TICKET_PRICE * DISCOUNT_RATE;
}
return TICKET_PRICE;
}
// 是否折扣日期函數
private static boolean isDiscountDate(Date currDate) {
return Objects.nonNull(currDate) &&
currDate.after(DISCOUNT_BEGIN_DATE)
&& currDate.before(DISCOUNT_END_DATE);
}
案例2: 把複雜條件表達式封裝爲函數
現象描述：
// 獲取土豪用戶列表
public List<User> getRichUserList(List<User> userList) {
// 初始土豪用戶列表
List<User> richUserList = new ArrayList<>();
// 依次查找土豪用戶
for (User user : userList) {
// 獲取用戶帳戶
UserAccount account = user.getAccount();
if (Objects.nonNull(account)) {
// 判斷用戶餘額
Double balance = account.getBalance();
if (Objects.nonNull(balance) && balance.compareTo(RICH_THRESHOLD) >= 0) {
// 添加土豪用戶
richUserList.add(user);
}
}
}
// 返回土豪用戶列表
return richUserList;
}
建議方案：
// 獲取土豪用戶列表
public List<User> getRichUserList(List<User> userList) {
// 初始土豪用戶列表
List<User> richUserList = new ArrayList<>();
// 依次查找土豪用戶
for (User user : userList) {
// 判斷土豪用戶
if (isRichUser(user)) {
// 添加土豪用戶
richUserList.add(user);
}
}
// 返回土豪用戶列表
return richUserList;
}
// 是否土豪用戶
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;
}
以上代碼也能夠用採用流式(Stream)編程的過濾來實現。
主要收益
- 把條件表達式從業務函數中獨立，使業務邏輯更清晰；
- 封裝的條件表達式爲獨立函數，能夠在代碼中重複使用。
9.儘可能避免沒必要要的空指針判斷
本章只適用於項目內部代碼，而且是本身瞭解的代碼，纔可以儘可能避免沒必要要的空指針判斷。對於第三方中間件和系統接口，必須作好空指針判斷，以保證代碼的健壯性。
案例1: 調用函數保證參數不爲空，被調用函數儘可能避免沒必要要的空指針判斷
現象描述：
// 建立用戶信息
User user = new User();
... // 賦值用戶相關信息
createUser(user);
// 建立用戶函數
private void createUser(User user){
// 判斷用戶爲空
if(Objects.isNull(user)) {
return;
}
// 建立用戶信息
userDAO.insert(user);
userRedis.save(user);
}
建議方案：
// 建立用戶信息
User user = new User();
... // 賦值用戶相關信息
createUser(user);
// 建立用戶函數
private void createUser(User user){
// 建立用戶信息
userDAO.insert(user);
userRedis.save(user);
}
案例2: 被調用函數保證返回不爲空，調用函數儘可能避免沒必要要的空指針判斷
現象描述：
// 保存用戶函數
public void saveUser(Long id, String name) {
// 構建用戶信息
User user = buildUser(id, name);
if (Objects.isNull(user)) {
throw new BizRuntimeException("構建用戶信息爲空");
}
// 保存用戶信息
userDAO.insert(user);
userRedis.save(user);
}
// 構建用戶函數
private User buildUser(Long id, String name) {
User user = new User();
user.setId(id);
user.setName(name);
return user;
}
建議方案：
// 保存用戶函數
public void saveUser(Long id, String name) {
// 構建用戶信息
User user = buildUser(id, name);
// 保存用戶信息
userDAO.insert(user);
userRedis.save(user);
}
// 構建用戶函數
private User buildUser(Long id, String name) {
User user = new User();
user.setId(id);
user.setName(name);
return user;
}
案例3: 賦值邏輯保證列表數據項不爲空，處理邏輯儘可能避免沒必要要的空指針判斷
現象描述：
// 查詢用戶列表
List<UserDO> userList = userDAO.queryAll();
if (CollectionUtils.isEmpty(userList)) {
return;
}
// 轉化用戶列表
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);
}
// 依次處理用戶
for (UserVO userVo : userVoList) {
// 判斷用戶爲空
if (Objects.isNull(userVo)) {
continue;
}
// 處理相關邏輯
...
}
建議方案：
// 查詢用戶列表
List<UserDO> userList = userDAO.queryAll();
if (CollectionUtils.isEmpty(userList)) {
return;
}
// 轉化用戶列表
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);
}
// 依次處理用戶
for (UserVO userVo : userVoList) {
// 處理相關邏輯
...
}
案例4: MyBatis查詢函數返回列表和數據項不爲空，能夠不用空指針判斷
MyBatis是一款優秀的持久層框架，是在項目中使用的最普遍的數據庫中間件之一。經過對MyBatis源碼進行分析，查詢函數返回的列表和數據項都不爲空，在代碼中能夠不用進行空指針判斷。
現象描述：
這種寫法沒有問題，只是過於保守了。
// 查詢用戶函數
public List<UserVO> queryUser(Long id, String name) {
// 查詢用戶列表
List<UserDO> userList = userDAO.query(id, name);
if (Objects.isNull(userList)) {
return Collections.emptyList();
}
// 轉化用戶列表
List<UserVO> voList = new ArrayList<>(userList.size());
for (UserDO user : userList) {
// 判斷對象爲空
if (Objects.isNull(user)) {
continue;
}
// 添加用戶信息
UserVO vo = new UserVO();
BeanUtils.copyProperties(user, vo);
voList.add(vo);
}
// 返回用戶列表
return voList;
}
建議方案：
// 查詢用戶函數
public List<UserVO> queryUser(Long id, String name) {
// 查詢用戶列表
List<UserDO> userList = userDAO.query(id, name);
// 轉化用戶列表
List<UserVO> voList = new ArrayList<>(userList.size());
for (UserDO user : userList) {
UserVO vo = new UserVO();
BeanUtils.copyProperties(user, vo);
voList.add(vo);
}
// 返回用戶列表
return voList;
}
主要收益
- 避免沒必要要的空指針判斷，精簡業務代碼處理邏輯，提升業務代碼運行效率；
- 這些沒必要要的空指針判斷，基本屬於永遠不執行的Death代碼，刪除有助於代碼維護。
10.內部函數儘可能使用基礎類型
案例1: 內部函數參數儘可能使用基礎類型
現象描述：
// 調用代碼
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;
}
案例2: 內部函數返回值儘可能使用基礎類型
現象描述：
// 獲取訂單總額函數
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)編程。
主要收益
- 內部函數儘可能使用基礎類型，避免了隱式封裝類型的打包和拆包；
- 內部函數參數使用基礎類型，用語法上避免了內部函數的參數空指針判斷；
- 內部函數返回值使用基礎類型，用語法上避免了調用函數的返回值空指針判斷。
11.儘可能避免返回的數組和列表爲null
案例1: 儘可能避免返回的數組爲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;
}
案例2: 儘可能避免返回的列表爲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, 避免調用函數的空指針判斷。
12.封裝函數傳入參數
案例1: 當傳入參數過多時，應封裝爲參數類
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;
}
案例2: 當傳入成組參數時，應封裝爲參數類
既然參數成組出現，就須要封裝一個類去描述這種現象。
現象描述：
// 獲取距離函數
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;
}
主要收益
- 封裝過多函數參數爲類，使函數更便於擴展和維護；
- 封裝成組函數參數爲類，使業務概念更明確更清晰。
13.儘可能用函數替換匿名內部類的實現
Java匿名內部類的優缺點:
在匿名內部類（包括Lambda表達式）中能夠直接訪問外部類的成員，包括類的成員變量、函數的內部變量。正由於能夠隨意訪問外部變量，因此會致使代碼邊界不清晰。
首先推薦用Lambda表達式簡化匿名內部類，其次推薦用函數替換複雜的Lambda表達式的實現。
案例1: 儘可能用函數替換匿名內部類（包括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)代替匿名內部類實現。
案例2: 拆分複雜匿名內部類實現接口爲多個函數式接口
若是一個匿名內部類實現的接口幾個函數間關聯性不大，能夠把這個接口拆分爲幾個函數式接口，便於使用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表達式簡化匿名內部類實現，使代碼更簡潔。
14.利用return精簡沒必要要的代碼
案例1: 刪除沒必要要的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;
}
案例2: 刪除沒必要要的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);
}
案例3: 刪除沒必要要的變量
現象描述：
// 查詢用戶函數
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);
}
主要收益
- 精簡沒必要要的代碼，讓代碼看起來更清爽。
15.利用臨時變量優化代碼
在一些代碼中，常常會看到a.getB().getC()...getN()的寫法，姑且叫作「函數的級聯調用」，代碼健壯性和可讀性太差。建議：杜絕函數的級聯調用，利用臨時變量進行拆分，並作好對象空指針檢查。
案例1: 利用臨時變量釐清邏輯
現象描述：
// 是否土豪用戶函數
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;
}
這個方案，增長了代碼行數，可是邏輯更清晰。
有時候，當代碼的精簡性和可讀性發生衝突時，我的更偏向於保留代碼的可讀性。
案例2: 利用臨時變量精簡代碼
現象描述：
// 構建用戶函數
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 buildUser(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;
}
主要收益
- 利用臨時變量釐清邏輯，顯得業務邏輯更清晰；
- 利用臨時變量精簡代碼，看變量名稱即知其義，減小了大量無用代碼；
- 若是獲取函數比較複雜耗時，利用臨時變量能夠提升運行效率；
- 利用臨時變量避免函數的級聯調用，可有效預防空指針異常。
16.僅保留函數須要的參數
案例1: 刪除多餘的參數
現象描述：
// 修改用戶狀態函數
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);
}
案例2: 用屬性取代對象
現象描述：
// 刪除用戶函數
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個，能夠沒必要使用該規則。
主要收益
- 僅保留函數須要的參數，明確了調用時須要賦值的參數，避免了調用時還要去構造些無用參數。
17.僅在須要時才定義變量
案例1: 僅在須要時才定義變量
一些具備VB、C++、PLSQL編程經驗的人，習慣於把函數所需的變量定義在函數體最前面。
現象描述：
// 冒泡排序函數
public void bubbleSort(int[] array) {
// 定義相關變量
boolean flag;
int i, j, length, temp;
// 檢查不用排序
if (Objects.isNull(array) || array.length <= 1) {
return;
}
// 進行冒泡排序
length = array.length;
for (i = 0; i < length; ++i) {
flag = false;
for (j = 0; j < length - i - 1; ++j) {
if (array[j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = true;
}
}
if (!flag) {
break;
}
}
}
建議方案：
// 冒泡排序函數
public void bubbleSort(int[] array) {
// 檢查不用排序
if (Objects.isNull(array) || array.length <= 1) {
return;
}
// 進行冒泡排序
int length = array.length;
for (int i = 0; i < length; ++i) {
boolean flag = false;
for (int j = 0; j < length - i - 1; ++j) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = true;
}
}
if (!flag) {
break;
}
}
}
主要收益
- 變量在使用時定義，更容易讓人理解變量的含義；
- 若是函數存在提早返回語句，避免了一些沒必要要的變量定義和初始化。
18.後記
"衆人拾柴火焰高"。若是有更多更好的觀點，亦或有更好的代碼案例，歡迎你們進行補充說明。
筆者但願以此文拋磚引玉，若是最終造成一套完善的Java編碼規範，善莫大焉。
本文做者：陳昌毅，花名常意，高德地圖技術專家，2018年加入阿里巴巴，一直從事地圖數據採集的相關工做。
本文爲雲棲社區原創內容，未經容許不得轉載。
相關文章
- 1. Java 函數優雅之道
- 2. Java函數優雅之道（上）
- 3. [阿里雲]Java 函數優雅之道
- 4. Java函數優雅之道（下）
- 5. 編碼規範 | Java函數優雅之道（上）
- 6. 編碼規範 | Java函數優雅之道（下）
- 7. Java代碼優雅之道-Guava
- 8. 代碼整潔之道（二）優雅註釋之道
- 9. 平常 Python 編程優雅之道
- 10. Async：簡潔優雅的異步之道
- 更多相關文章...
- • MySQL的優勢（優點） - MySQL教程
- • SQLite - Java - SQLite教程
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
- • 算法總結-廣度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java 函數優雅之道
- 2. Java函數優雅之道（上）
- 3. [阿里雲]Java 函數優雅之道
- 4. Java函數優雅之道（下）
- 5. 編碼規範 | Java函數優雅之道（上）
- 6. 編碼規範 | Java函數優雅之道（下）
- 7. Java代碼優雅之道-Guava
- 8. 代碼整潔之道（二）優雅註釋之道
- 9. 平常 Python 編程優雅之道
- 10. Async：簡潔優雅的異步之道