Question

我方法的片段下面使用了很多if和else condtitions。我想用某种方式避免它。如何通过为每种类型使用HashMap配置来实现以下功能？

        boolean success = true;
        if (source.isTypeA()) {
            if (!model.getPermission || !source.hasAccess) {
                success = false;
            }
        } else if (source.isTypeB()) {
            if (source.condition() && (!model.getPermission() || !source.hasAccess)) {
                success = false;
            }
        } else if (source.isTypeC() && (!source.isMobile || !model.getPermission)) {
            success = false;
        } else if ((source.isTypeD() && source.condition) && (!source.isMobile || !model.getPermission)) {
            success = false;
        }
        return success;

Answer 1

您可以尝试使用更多的多态解决方案。使用isSuccess方法将source作为接口。 TypeA，TypeB，TypeC和TypeD是该接口的实现，都实现了自己的isSuccess版本。那么你根本不需要整个if语句。

return source.isSuccess(model);

class TypeA {
    public boolean isSuccess(Model model) {
        return model.getPermission() && hasAccess();
    }
 ....
}

Answer 2

假设类型不重叠，那么switch语句结合Jon Skeet关于中间函数返回的建议就可以得到：

switch (source.getType()) {
    case TYPE_A:
        return model.getPermission() && source.hasAccess;
    case TYPE_B:
        return !source.condition() || (model.getPermission() && source.hasAccess);
    case TYPE_C:
        return model.getPermission() && source.isMobile;
    case TYPE_D:
        return !source.condition() || (model.getPermission() && source.isMobile);
    default:
        return false;
}

Answer 3

第一种方式：

private boolean codeUsingALotOfIfElse(Source source, Model model) {
    if (source.isTypeA() && (!model.getPermission || !source.hasAccess)) return false;
    if (source.isTypeB() && (source.condition() && (!model.getPermission() || !source.hasAccess))) return false;
    if (source.isTypeC() && (!source.isMobile || !model.getPermission)) return false;
    if ((source.isTypeD() && source.condition) && (!source.isMobile || !model.getPermission)) return false;
    return true;
}

第二种方式：

private boolean codeUsingALotOfIfElse(Source source, Model model) {
    int caseInt = getIntMappingFromSourceType(source); //This function returns a value that can be used for switching.
    switch(caseInt) {
    case *intA*: 
        return (model.getPermission && source.hasAccess));
    case *intB*:
        return !(source.condition() && (!model.getPermission() || !source.hasAccess));
    case *intC*:
        return source.isMobile && model.getPermission;
    case *intD*:
        return !(source.condition && (!source.isMobile || !model.getPermission));
    default:
        return true;
}

Answer 4

您应使用策略设计模式根据您的source类型创建不同的策略类，并根据不同策略类的不同标准确定success。通过这种方式，你能够符合开放/封闭原则。

代码示例如下。您可以查看wikibook策略模式。

interface SuccessInterface{
    boolean IsSuccess(Object model);
}

interface SuccessFactoryInterface{
    SuccessInterface Create(Object source) throws Exception;
}

class SuccessTypeFactory implements SuccessFactoryInterface{

    @Override
    public SuccessInterface Create(Object source) throws Exception {
        switch (source.getType()) {
            case typeA:
                return new TypeA();
            case typeB:
                return new TypeB();
            case typeC:
                return new TypeC();
            case typeD:
                return new TypeD();
            default:
                throw new Exception();
        }
    }
}

class TypeA implements SuccessInterface {
    private Object _source;

    public TypeA(Object source) {
        _source = source;
    }

    @Override
    public boolean IsSuccess(Object model) {
        return model.getPermission() && _source.hasAccess();
    }
}

class TypeB implements SuccessInterface {
    private Object _source;

    public TypeB(Object source) {
        _source = source;
    }

    @Override
    public boolean IsSuccess(Object model) {
//        add your criteria here
        return false;
    }
}

class TypeC implements SuccessInterface {...}

class TypeD implements SuccessInterface {...}

通过删除if和else条件来重构

4 个答案: