if-else，這是個再正常不過的coding習(xí)慣，當(dāng)我們代碼量小的時候用來做條件判斷是再簡單不過的了。但對于優(yōu)秀程序員來說，這卻不是好代碼。不信你往下看…

1. 衛(wèi)語句提前return

假設(shè)有如下代碼

if (condition) { // do something } else { return xxx; }

通過對判斷條件取反，代碼在邏輯表達上會更加清晰

if (!condition) { return xxx; } // do something 

2. 使用Optional簡化if判空

2.1 簡化1級判空

假設(shè)有如下代碼

if (input != null) { // return value 1 } else { // return value 2 }

使用Optional后

return Optional.ofNullable(input).map(value1).orElse(value2);

2.2 簡化多級判空

假設(shè)有如下代碼

if (input != null && input.getUser() != null && input.getUser().getName() != null) { // do action 1 } else { // do action 2 }

使用Optional后

Optional.ofNullable(input) .map(Input::getUser) .map(User::getName) .map(action1) .orElse(action2);

對于沒有else的場景，使用ifPresent即可

if (input != null && input.getUser() != null && input.getUser.getName() != null) { // do action }

Optional.ofNullable(input) .map(Input::getUser) .map(User::getName) .ifPresent(action); 

3. 策略模式

假設(shè)有如下代碼：

if ("dog".equals(petType)) { // 處理dog } else if ("cat".equals(petType)) { // 處理cat } else if ("pig".equals(petType)) { // 處理pig } else if ("rabbit".equals(petType)) { // 處理rabbit } else { throw new UnsupportedOperationException();

這就是不要根據(jù)不同的參數(shù)類型走不同的代碼邏輯，這種場景很常見，他還會以switch-case的方式出現(xiàn)：

switch (petType) { case "dog": // 處理dog break; case "cat": // 處理cat break; case "pig": // 處理pig break; case "rabbit": // 處理rabbit break; default: throw new UnsupportedOperationException(); }

不同的代碼邏輯就代表了不同的策略，我們可以通過如下幾個方式改寫。

3.1 多態(tài)

public interface Strategy { void invoke(); // 處理各個邏輯 }

public class DogStrategy implements Strategy { @Override public void invoke() { // 處理dog } }

public class CatStrategy implements Strategy { @Override public void invoke() { // 處理cat } 

public class PigStrategy implements Strategy { @Override public void invoke() { // 處理pig } }

public class RabbitStrategy implements Strategy { @Override public void invoke() { // 處理rabbit } }

具體的策略對象可以放在一個Map中，優(yōu)化后的實現(xiàn)類似如下

Strategy strategy = map.get(petType); stratefy.invoke();

關(guān)于如何存放到Map中也兩個可以參考的方式。

3.1.1 靜態(tài)表

Map<String, Strategy> map = ImmutableMap.<String, Strategy>builder() .put("dog", new DogStrategy()) .put("cat", new CatStrategy()) .put("pig", new PigStrategy()) .put("rabbit", new RabbitStrategy()) .build();

3.1.2 Spring托管下的動態(tài)注冊

定義一個注冊中心用于接受注冊信息

public enum StrategyMapping { INSTANCE;  private final Map<String, Classextends Strategy>> map = new ConcurrentHashMap<>();  public void register(String type, Classextends Strategy> clazz) { map.put(type, clazz); }  public Strategy getStrategy(String type) { Classextends Strategy> clazz = map.get(type); if (clazz == null) { throw new UnregisteredException(); } return SpringContextHolder.getBean(clazz); } }

將每個Strategy交由Spring管理，并在構(gòu)造后注冊

@Component public class DogStrategy implements Strategy { @PostConstruct public void init() { StrategyMapping.INSTANCE.register("dog", this.getClass()); }  @Override public void invoke() { // 處理dog } }

使用方式就變成了

Strategy strategy = StrategyMapping.INSTANCE.getStrategy(petType); stratefy.invoke();

3.2 枚舉

采用多態(tài)會額外產(chǎn)生很多策略類，如果我們已經(jīng)預(yù)先將petType定義成了枚舉，就會發(fā)現(xiàn)可以把Strategy中的invoke()方法放到枚舉中，從而完成了一種映射關(guān)系。

public enum PetType { DOG { @Override public void invoke() { // 處理dog } }, CAT { @Override public void invoke() { // 處理cat } }, PIG { @Override public void invoke() { // 處理pig } }, RABBIT { @Override public void invoke() { // 處理rabbit } };  public abstract void invoke(); }

這樣在調(diào)用時的代碼就類似如下：

PetType petType = PetType.valueOf(type.toUpperCase(Locale.ROOT)); petType.invoke();

3.3 函數(shù)式簡化策略

同樣面對多態(tài)會額外產(chǎn)生很多策略類的問題，除了枚舉我們還可以使用函數(shù)式的方式來改寫，這里有個前提最好是策略的內(nèi)容不會過于復(fù)雜，不然在代碼的可讀性上會比較差。同樣我們會有一個map靜態(tài)表，不過map里面存放的是lambda

Map<String, Runnable> map = ImmutableMap.<String, Runnable>builder() .put("dog", () -> { // 處理dog }) .put("cat", () -> { // 處理cat }) .put("pig", () -> { // 處理pig }) .put("rabbit", () -> { // 處理rabbit }) .build();

使用方式則變成了

Runnable task = map.get(petType); task.run();