编码思路

编码，应按照总-分的思路编写：先写整体的大框架，后续再实现具体细节。
假设要实现用户登录判断的需求，其中需要判断验证码、用户名、密码等是否合法及用户名与密码是否匹配，那么我们第一步的代码应如下：

第一步：编写整体框架

public class LoginService {

    public String login(UserInfo userInfo) {
        boolean codeIsLegal = verifyCode(userInfo.getCode());
        if (!codeIsLegal) {
            return "验证码错误！";
        }
        boolean nameIsLegal = verifyName(userInfo.getName());
        if (!nameIsLegal) {
            return "用户名不合法！";
        }
        boolean passIsLegal = verifyPass(userInfo.getPassword());
        if (!passIsLegal) {
            return "密码不合法";
        }
        boolean nameMatchedPass = verifyNameNPass(userInfo.getName(), userInfo.getPassword());
        if (!nameMatchedPass) {
            return "用户名与密码不匹配！";
        }
        return "登录成功";
    }

}

class UserInfo {
    private String name;
    private String password;
    private String code;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

第二步：实现具体判断逻辑

public class LoginService {

    public String login(UserInfo userInfo) {
        boolean codeIsLegal = verifyCode(userInfo.getCode());
        if (!codeIsLegal) {
            return "验证码错误！";
        }
        boolean nameIsLegal = verifyName(userInfo.getName());
        if (!nameIsLegal) {
            return "用户名不合法！";
        }
        boolean passIsLegal = verifyPass(userInfo.getPassword());
        if (!passIsLegal) {
            return "密码不合法";
        }
        boolean nameMatchedPass = verifyNameNPass(userInfo.getName(), userInfo.getPassword());
        if (!nameMatchedPass) {
            return "用户名与密码不匹配！";
        }
        return "登录成功";
    }

    private boolean verifyCode(String code) {
        return code.equals("6666");
    }

    private boolean verifyName(String name) {
        return name.equals("admin");
    }

    private boolean verifyPass(String password) {
        return password.equals("admin");
    }
    
    private boolean verifyNameNPass(String name, String password) {
        return true;
    }
}

class UserInfo {
    private String name;
    private String password;
    private String code;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

酱紫写，思路清晰代码层次分明，易于阅读及维护。
但代码层次太分明时，也会有弊端。如下所示：模拟请求API接口

public class HttpService {

    public JSONObject queryData(RequestVO vo) {
        Map<String, String> header = buildHeader(vo);
        JSONObject body = buildBody(vo);
        String result = exeHttpRequest(header, body);
        return JSON.parseObject(result);
    }

    private String exeHttpRequest(Map<String, String> header, JSONObject body) {
        return "{\"code\":0,\"msg\":\"请求成功\"}";
    }

    private JSONObject buildBody(RequestVO vo) {
        String sign = generateSign(vo);
        JSONObject body = new JSONObject();
        body.put("name", vo.name);
        body.put("phone", vo.phone);
        body.put("sign", sign);
        return body;
    }

    private Map<String, String> buildHeader(RequestVO vo) {
        String sign = generateSign(vo);
        Map<String, String> header = new HashMap<>(2);
        header.put("content-type", "application/json");
        header.put("sign", sign);
        return header;
    }

    private String generateSign(RequestVO vo) {
        return MD5Encoder.encode((vo.name + vo.phone).getBytes());
    }
}

class RequestVO {
    String name;
    String phone;
}

从代码中可看出，sign被计算了两次。但假如为了复用header中生成的sign，整个代码就不会这么清晰了。
具体实践中，应根据实际情况权衡是否要做到如此层次分明：
当sign的计算较简单时，可以重复计算；
当sign的计算较耗费资源时，则应复用。