简单工厂模式

​ 根据常见支付方式的选择来体现简单工厂模式

1.支付枚举类

每种支付方式对应int类型的payType

import java.util.HashMap;
import java.util.Map;

/**
 * @author : zhaoxuan
 */
public enum PayTypeEnum {
    WECHAT(1,"微信支付"),
    ALIPAY(2,"支付宝支付"),
    ;

    private int payType;
    private String payName;

    PayTypeEnum(int payType,String payName){
        this.payType = payType;
        this.payName = payName;
    }

    public static Map<Integer,String> toPair(){
        HashMap pairs = new HashMap<Integer, String>();
        for (PayTypeEnum value : PayTypeEnum.values()) {
            pairs.put(value.payType,value.payName);
        }
        return pairs;
    }

    public int getPayType() {
        return payType;
    }

    public String getPayName() {
        return payName;
    }

    public static PayTypeEnum getByType(int payType){
        for (PayTypeEnum value : PayTypeEnum.values()) {
            if (value.payType == payType) {
                return value;
            }
        }
        return null;
    }
}

2.抽象支付类

/**
 * @author : zhaoxuan
 */
public abstract class AbstractPay {
    abstract void anOrder();
}

3.具体支付类(微信支付)

/**
 * @author : zhaoxuan
 */
public class WeChatPay extends AbstractPay{
    void anOrder() {
        System.out.println("微信支付!");
    }
}

4.具体支付类(支付宝支付)

/**
 * @author : zhaoxuan
 */
public class AlipayPay extends AbstractPay {
    void anOrder() {
        System.out.println("支付宝支付!");
    }
}

5.支付工厂

/**
 * @author : zhaoxuan
 */
public class PayFactory {
    public static AbstractPay getPay(int payType){
        PayTypeEnum typeEnum = getByType(payType);
        AbstractPay pay = null;
        if (typeEnum!=null) {
            switch (typeEnum) {
                case WECHAT:
                    pay = new WeChatPay();
                    break;
                case ALIPAY:
                    pay = new AlipayPay();
                    break;
                default:
            }
        }
        return pay;
    }
}

6.测试

import java.util.Map;

/**
 * @author : zhaoxuan
 */
public class Test {
    public static void main(String[] args) {
        //前端获取支付方式
        Map map = PayTypeEnum.toPair();
        System.out.println(map.toString());
        //客户选择支付方式
        int payType = PayTypeEnum.WECHAT.getPayType();
        System.out.println("客户第一次选择:" + payType);
        //根据客户选择的支付方式
        AbstractPay pay = PayFactory.getPay(payType);
        pay.anOrder();

        //客户选择支付方式
        int payType1 = PayTypeEnum.ALIPAY.getPayType();
        System.out.println("客户第二次选择:" + payType1);
        //根据客户选择的支付方式
        AbstractPay pay2 = PayFactory.getPay(payType1);
        pay2.anOrder();
    }
}

测试结果:

{1=微信支付, 2=支付宝支付}
客户第一次选择:1
微信支付!
客户第二次选择:2
支付宝支付!

7.应用场景

​ 根据以上的测试不难发现，简单工厂的业务场景还是很多的，也是比较简单

​ 当业务中需要创建某个对象，而该对象的子类或者实现类数目较少，仅需一个具体的工厂根据某个标识来创建具体的实现类，这种情况下，简单工厂最为合适