干掉 if else！

Love The Way You Lie 2022-08-28 05:57 148阅读 0赞

if…else控制语句，如果代码里滥用会大大降低代码的可读性、可维护性、可扩展性以及灵活性，进而使整个软件系统造成危害。因为在实际的项目中，需求往往是不断变化的，新需求也层出不穷，因此违反了违反单一职责原则和开闭原则，而且有些公司的代码审查会通不过。

所以，if else的替代方案是很有必要的，如位语句，枚举，工厂模式，策略模式，状态模式等等。这里用一个场景详细说明if else的替代方案，大家用支付宝付款的时候，会有多种付款方式，如余额，花呗，余额宝，信用卡，银行卡。

**01. 传统的方式**

public class PayDemo {
    
        public String pay(String payType) {
    
            String pay = "";
            if ("1".equals(payType)) {
                pay = "支付宝余额支付";
            } else if ("2".equals(payType)) {
                pay = "支付宝余额宝支付";
            } else if ("3".equals(payType)) {
                pay = "支付宝花呗支付";
            } else {
                pay = "其他支付";
            }
            //...
            System.out.println(pay);
            return pay;
        }
    }
    
    
    public class PayTest {
        public static void main(String[] args) {
            PayDemo payDemo = new PayDemo();
            payDemo.pay("1");
            payDemo.pay("2");
            payDemo.pay("3");
            payDemo.pay("4");
        }
    }

**枚举第一种**

（1）面向接口编程，首先定义一个支付接口

public interface PayEnum {
        String pay();
    }

（2）定义一个具体的支付宝余额实现

public class PayEnumByBalance implements PayEnum{
    
        @Override
        public String pay() {
            System.out.println("支付宝余额支付");
            return "支付宝余额支付";
        }
    }

（3）定义一个具体的支付宝花呗实现

public class PayEnumByHuabei implements PayEnum {
        @Override
        public String pay() {
            System.out.println("支付宝花呗支付");
            return "支付宝花呗支付";
        }
    }

（4）定义一个具体的支付宝余额宝实现

public class PayEnumByYuEBAO implements PayEnum {
    
        @Override
        public String pay() {
            System.out.println("支付宝余额宝支付");
            return "支付宝余额宝支付";
        }
    }

（5）定义一个枚举类

public enum PayTypeEnum {
    
        PAY_BALANCE("1",new PayEnumByBalance()),
        PAY_HUABEI("2",new PayEnumByHuabei()),
        PAY_YUEBAO("3",new PayEnumByYuEBAO());
    
        private String payType;
        private PayEnum payEnum;
    
        PayTypeEnum(String payType, PayEnum payEnum) {
            this.payType = payType;
            this.payEnum = payEnum;
        }
    
        public static PayEnum getPay(String payType){
            for (PayTypeEnum payTypeEnum : PayTypeEnum.values()) {
                if (payTypeEnum.payType.equals(payType)) {
                    return payTypeEnum.payEnum;
                }
            }
            return new PayEnumByBalance();
        }
    }

（6）客户端

public class PayEnumTest {
        public static void main(String[] args) {
    
            PayEnum payEnum = PayTypeEnum.getPay("1");
            payEnum.pay();
            PayEnum payEnum1 = PayTypeEnum.getPay("2");
            payEnum1.pay();
            PayEnum payEnum2 = PayTypeEnum.getPay("3");
            payEnum2.pay();
        }
    }

（7）结果：

![d36a38b7fd2dcfb3a5e02ad44ea70f82.png][]

（8）总结：完全消除了if else

## **枚举第二种** ##

(1) 面向接口编程，首先定义一个支付接口

public interface PayEnum1 {
        String pay();
    }

（2）定义一个枚举类，并且实现支付接口

public enum PayTypeEnum1 implements PayEnum1{
    
        PAY_TYPE_BALANCE{
            @Override
            public String pay() {
                System.out.println("支付宝余额支付");
                return "支付宝余额支付";
            }
        },
        PAY_TYPE_HUABEI{
            @Override
            public String pay() {
                System.out.println("支付宝花呗支付");
                return "支付宝花呗支付";
            }
        },
        PAY_TYPE_YUEBAO{
            @Override
            public String pay() {
                System.out.println("支付宝余额宝支付");
                return "支付宝余额宝支付";
            }
        };
    }

（3）客户端代码

public class PayEnum1Test {
        
        public static void main(String[] args) {
            PayEnum1Test payEnum1Test = new PayEnum1Test();
            payEnum1Test.pay("PAY_TYPE_BALANCE");
            payEnum1Test.pay("PAY_TYPE_HUABEI");
            payEnum1Test.pay("PAY_TYPE_YUEBAO");
        }
        
        public String pay(String payType){
            return PayTypeEnum1.valueOf(payType).pay();
        }
    }

``（4）结果：

![c0c664440ee2e9ac3b44344cfdb15fab.png][]（5）总结:

根据业务场景，如果代码业务量少，可以用枚举第二种，如果代码业务量大，可以用枚举第一种。都可以解决if else代码。

**02. 工厂模式**

public interface PayFactory {
        String pay();
    }
    
    public class PayFactoryByBalance implements PayFactory {
    
        @Override
        public String pay() {
            System.out.println("支付宝余额支付");
            return "支付宝余额支付";
        }
    }
    
    public class PayFactoryByHuabei implements PayFactory {
    
        @Override
        public String pay() {
            System.out.println("支付宝花呗支付");
            return "支付宝花呗支付";
        }
    }
    
    public class PayFactoryByYuEBAO implements PayFactory {
    
        @Override
        public String pay() {
            System.out.println("支付宝余额宝支付");
            return "支付宝余额宝支付";
        }
    }

public class PayTypeFactory {
    
        private static Map<String,PayFactory> payTypeMap = new HashMap<>();
    
        static {
            payTypeMap.put("1",new PayFactoryByBalance());
            payTypeMap.put("2",new PayFactoryByHuabei());
            payTypeMap.put("3",new PayFactoryByYuEBAO());
        }
    
        public static PayFactory getPayType(String payType){
            return payTypeMap.get(payType);
        }
    
    }

public class PayFactoryTest {
        public static void main(String[] args) {
            PayTypeFactory.getPayType("1").pay();
            PayTypeFactory.getPayType("2").pay();
            PayTypeFactory.getPayType("3").pay();
        }
    }

结果：

![765f287946c2d5a38ce11d420065153b.png][]

**03. 策略模式+工厂模式**

策略模式一句话就是，定义一系列算法，把他们封装起来，并且使它们可以相互替换。具体来说就说，定义多个策略对象，每个策略对象里面封装好多种算法，再定义一个上下文对象，该上下文对象负责根据传入不同的策略对象，执行不同的行为。

（1）定义一个抽象的公共策略接口Strategy，通常为接口，定义每个策略或算法必须具有的方法和属性。

public interface PayStrategy {
        String pay();
    }

（2）定义一个context对象，即扮演一个上下的文角色，起承上启下的封装作用，其行为随着策略对象改变而改变。

public class PayContext {
    
        private PayStrategy payStrategy;
    
        public PayContext(PayStrategy payStrategy) {
            this.payStrategy = payStrategy;
        }
    
        public String executeStrategy(){
            return payStrategy.pay();
        }
    }

``（3）定义一个具体的余额支付策略

public class PayStrategyByBalance implements PayStrategy {
        @Override
        public String pay() {
            System.out.println("支付宝余额支付");
            return "支付宝余额支付";
        }
    }

（4）定义一个具体的花呗支付策略

public class PayStrategyByHuabei implements PayStrategy {
        @Override
        public String pay() {
            System.out.println("支付宝花呗支付");
            return "支付宝花呗支付";
        }
    }

（5）定义一个具体的余额宝支付策略

public class PayStrategyByYuEBAO implements PayStrategy {
        @Override
        public String pay() {
            System.out.println("支付宝余额宝支付");
            return "支付宝余额宝支付";
        }
    }

（6）客户端

public class PayStrategyTest {
        
        public static void main(String[] args) {
            PayStrategyTest payStrategyTest = new PayStrategyTest();
            payStrategyTest.method("1");
            payStrategyTest.method("2");
            payStrategyTest.method("3");
        }
    
        public void method(String payType){
    
            PayContext payContext;
            if ("1".equals(payType)){
                payContext = new PayContext(new PayStrategyByHuabei());
                payContext.executeStrategy();
    
            }else if ("2".equals(payType)){
                payContext = new PayContext(new PayStrategyByYuEBAO());
                payContext.executeStrategy();
    
            }else if ("3".equals(payType)){
                payContext = new PayContext(new PayStrategyByBalance());
                payContext.executeStrategy();
    
            }
        }
        
    }

（7）结果：

![1401dffb96afb9e6150a11b516f3a7da.png][]此时只有策略模式，还没有加入工厂模式

（8）定义一个策略工厂类

public class PayStrategyFactory {
    
        private static Map<String, PayStrategy> payTypeMap = new HashMap<>();
    
        static {
            payTypeMap.put("1",new PayStrategyByBalance());
            payTypeMap.put("2",new PayStrategyByYuEBAO());
            payTypeMap.put("3",new PayStrategyByHuabei());
        }
    
        public static PayStrategy getPayType(String payType){
            return payTypeMap.get(payType);
        }
    }

（9）再看客户端代码

public class PayStrategyFactoryTest {
        public static void main(String[] args) {
    
            PayContext payContext = new PayContext(PayStrategyFactory.getPayType("1"));
            payContext.executeStrategy();
    
            PayContext payContext2 = new PayContext(PayStrategyFactory.getPayType("2"));
            payContext2.executeStrategy();
    
            PayContext payContext3 = new PayContext(PayStrategyFactory.getPayType("3"));
            payContext3.executeStrategy();
        }
    }

运行结果还是一样的就不看了哈

## **05. 状态模式+工厂模式** ##

状态模式一句话来说就是，允许一个对象在其对象内部状态改变时改变它的行为。具体来讲，定义多种状态对象，和定义一个行为随着状态对象改变而改变的 context 对象。

（1）面向接口编程，定义一个支付接口

public interface PayState {
        String pay(PayContext payContext);
    }

（2）定义一个context上下文

public class PayContext {
    
        private PayState payState;
    
        public PayContext() {
            this.payState = null;
        }
    
        public void setPayState(PayState payState) {
            this.payState = payState;
        }
    
        public PayState getPayState() {
            return payState;
        }
    }

（2）定义具体的状态类

public class PayStateByBalance implements PayState {
        @Override
        public String pay(PayContext payContext) {
            System.out.println("支付宝余额支付");
            payContext.setPayState(this);
            return "支付宝余额支付";
        }
    }

public class PayStateByHuabei implements PayState {
        @Override
        public String pay(PayContext payContext) {
            System.out.println("支付宝花呗支付");
            payContext.setPayState(this);
            return "支付宝花呗支付";
        }
    }

public class PayStateByYuEBAO implements PayState {
    
        @Override
        public String pay(PayContext payContext) {
            System.out.println("支付宝余额宝支付");
            payContext.setPayState(this);
            return "支付宝余额宝支付";
        }
    }

（3）客户端

public class PayStateTest {
        
        public static void main(String[] args) throws InterruptedException {
            
            PayStateTest payStateTest = new PayStateTest();
            payStateTest.method("1");
            payStateTest.method("2");
            payStateTest.method("3");
        }
    
        public void method(String payType){
            PayContext context = new PayContext();
    
            if ("1".equals(payType)) {
                PayStateByBalance payStateByBalance = new PayStateByBalance();
                payStateByBalance.pay(context);
            }else if("2".equals(payType)) {
                PayStateByHuabei payStateByHuabei = new PayStateByHuabei();
                payStateByHuabei.pay(context);
            }else if("3".equals(payType)) {
                PayStateByYuEBAO payStateByYuEBAO = new PayStateByYuEBAO();
                payStateByYuEBAO.pay(context);
            }
        }
    }

（4）结果：

![b03f56c595d97db3baeb9c9b1d3acbd5.png][]

此时仅仅是状态模式，没有彻底取消if else

（5）加入工厂模式

public class PayStateFactory {
        private static Map<String, PayState> payTypeMap = new HashMap<>();
    
        static {
            payTypeMap.put("1",new PayStateByBalance());
            payTypeMap.put("2",new PayStateByYuEBAO());
            payTypeMap.put("3",new PayStateByHuabei());
        }
    
        public static PayState getPayType(String payType){
            return payTypeMap.get(payType);
        }
    }

（6）再看客户端代码

public class PayStateFactoryTest {
        
        public static void main(String[] args) {
            PayContext context = new PayContext();
            PayStateFactory.getPayType("1").pay(context);
            PayStateFactory.getPayType("2").pay(context);
            PayStateFactory.getPayType("3").pay(context);
        }
    }

总结：完全解决了代码中的 if else，本文作者：王德印，欢迎复制下方链接关注博主动态。

链接：https://blog.csdn.net/qq_41889508/article/details/105953114

--------------------

【END】

如果看到这里，说明你喜欢这篇文章，请转发、点赞。微信搜索「web\_resource」，关注后回复「进群」或者扫描下方二维码即可进入无广告交流群。

↓扫描二维码进群↓

![6b7182bdd8ff1cccb60f8c184a15f976.png][]

[d36a38b7fd2dcfb3a5e02ad44ea70f82.png]: /images/20220828/2b42c4698d48473faa331a428514204e.png
[c0c664440ee2e9ac3b44344cfdb15fab.png]: /images/20220828/3a70a63861574620a6b088b891b36143.png
[765f287946c2d5a38ce11d420065153b.png]: /images/20220828/1f2242f0a7514cefb9fe498efc3bd6bc.png
[1401dffb96afb9e6150a11b516f3a7da.png]: /images/20220828/c8075f95f184482c92c7a40bf7204eb2.png
[b03f56c595d97db3baeb9c9b1d3acbd5.png]: /images/20220828/c0ed034717d846df9d1f0ab7e834a6f7.png
[6b7182bdd8ff1cccb60f8c184a15f976.png]: /images/20220828/bb652d4fe943467e9175cfc675acb99f.png