Question

我想知道是否有办法在简单的java方法中减少代码冗余。我最近一直在处理以下问题：

public String myMethod() {
     String errorMsg = null;

     //Do bunch of stuff, that might set errorMsg

     if (errorMsg != null) {
      return errorMsg + somethingElse;
     }

     //Do bunch of stuff, that might set errorMsg

     if (errorMsg != null) {
      return errorMsg + somethingElse;
     }

     //Do bunch of stuff, that might set errorMsg

     if (errorMsg != null) {
      return errorMsg + somethingElse;
     }
}

有没有办法可能只写一次冗余代码？可能写一个会返回调用方法的方法？或者这只是一个糟糕的设计？ Ovsiouly这个代码有很多维护，有更好的方法吗？

Answer 1

您想要清理代码。以下作品。你可以在课堂上使errorMsg全球化。您可以根据需要创建自定义Exception。

    public String myMethod() {
        try {
            doBunchOfStuff1();
            doBunchOfStuff2();
            doBunchOfStuff3();
        } catch (Exception e) {
            return e.getMessage();
        }
        return "OK";
    }

    public void doBunchOfStuff1() throws Exception {
        //
        checkError(errorMsg,somethingElse);
    }

    public void doBunchOfStuff2() throws Exception {
        //
        checkError(errorMsg,somethingElse);
    }

    public void doBunchOfStuff3() throws Exception {
        //
        checkError("Error ","something else");
    }

    public void checkError(String errorMsg, String somethingElse) throws Exception {
        if (errorMsg != null) {
            throw new Exception(errorMsg + somethingElse);
        }
    }
}

Answer 2

首先，我认为将错误消息作为String返回并不是一个好主意（否则为null，是否正确？）。创建一个名为Result或其他东西的自定义类（可能包含类似布尔成功和错误消息的字段），或者抛出Exception一些消息。

Exceptions表现得像你所描述的那样，但它们不仅仅是＆＃34;还原调用方法＆＃34;但是通过整个调用堆栈。你可以使用它的功能，而不是重复if (error = null)构造，你可以做任何事情（让它们进一步使用相同的错误信息和参数），或者在一个大try-catch内逐个处理或全部处理阻止，取决于您的应用程序的设计。

Answer 3

您可以创建一个在需要时调用的方法：

void error(String errorMSG, Object somethingElse){
    System.err.println(errorMSG + somethingElse); //I put a syserr, but put whatever
}

然后在以下情况下调用您的方法：

error("This a error", /*Something*/);

Answer 4

Over Engineered

abstract class Filter {
    public static String errorMsg = null;
    public abstract boolean check();
}

class CheckError extends Filter {
    @Override
    public boolean check() {
        return (errorMsg != null);
    }
}

abstract class DoBunchOfStuff {

    public String somethingElse = null;
    private static int counter = 0;

    public DoBunchOfStuff() {
        somethingElse = "doBunch" + ++counter;
    }

    public abstract void ofStuff(Filter filter);
}

class Follower {
    private Filter filter;
    private List<DoBunchOfStuff> stuff = new ArrayList<>();

    public Follower(Filter filter) {
        this.filter = filter;
    }

    public void add(DoBunchOfStuff bunchOf) {
        stuff.add(bunchOf);
    }

    public String call() {
        for (DoBunchOfStuff doBunch : stuff) {
            doBunch.ofStuff(filter);
            if (filter.check()) {
                return filter.errorMsg + doBunch.somethingElse;
            }
        }     
        return "OK";
    }
}

public class YourClass {

    public String myMethod() {

        Follower executor = new Follower(new CheckError());   

        DoBunchOfStuff doBunch1 = new DoBunchOfStuff() {
            @Override
            public void ofStuff(Filter filter) {
                //
            }
        };

        DoBunchOfStuff doBunch2 = new DoBunchOfStuff() {
            @Override
            public void ofStuff(Filter filter) {
                //
            }
        };

        DoBunchOfStuff doBunch3 = new DoBunchOfStuff() {
            @Override
            public void ofStuff(Filter filter) {
                //
                filter.errorMsg = "Error !!! ";
            }
        };
        executor.add(doBunch1);
        executor.add(doBunch2);
        executor.add(doBunch3);
        return executor.call();

    }

java中方法内的冗余代码

4 个答案:

Over Engineered