将Java中的“主要”方法及其“辅助”方法分组在一起

Question

Avoiding large, monolithic methods is considered a good practice. I, personally, like to identify all pieces of code that serve a unique, unambiguous purpose and refactor them into a method. This way, the code reads more like a book.

The obvious problem with this approach is that my class ends up having a large number of methods available outside their intended scope, which I find highly undesirable.

There are ways to create nested functions in Java, but since the feature is not directly supported by the language, the resulting code is generally unfathomably ugly --at least, to me.

One could also use nested classes. What I don't like about this solution is that it's somewhat clumsy --is it?-- when some of the involved methods in the "grouping together" are overridden methods.

Rather vague question, but anyway I'd like to know how people go about doing this.

EDIT: Example of what I mean:

public class ClassWithTwoMainMethods {

    private int var1;
    private int var2;

    public void doSomething(int a) {
        if (conditionToCheck(a)) {
            doSomethingSpecific();
        }
    }

    private void doSomethingSpecific() {
        ...
    }

    private boolean conditionToCheck(int a) {
        ...
    }

    public void doSomethingElse(int a, int b) {
        doSomethingElseHelper1(a+b);
        doSomethingElseHelper2();
        doSomethingElseHelper3();
    }

    private void doSomethingElseHelper1(int arg) {
        ...
    }

    private void doSomethingElseHelper2() {
        ...
    }

    private void doSomethingElseHelper3() {
        ...
    }

}

At first glance, it isn't obvious that the class above has one "main" method with two "helpers" that should not be used anywhere else, and another "main" method with three helpers.

Answer 1

I use "worker objects" for this. A worker object exists only inside of a method and helps to achieve a goal. A typical example for this is String except that this worker is so useful that methods often return it.

So what I do is I group methods in a worker object, create it in a public API method (ie something is supposed to be used and documented in the public API) and let it do it's thing:

public void doSomethingElse(int a, int b) {
    new Worker( a, b ).run();
}

This approach has some benefits:

1. You can test those workers in isolation.
2. It keeps code together that belongs together
3. It helps to avoid cluttering the namespace of a class. It does pollute the global namespace somewhat, though.
4. It allows you to reuse workers in different classes.
5. I can lessen the restrictions on fields for workers. For main classes, I prefer fields that don't change. In workers, fields are often more like local variables. That way, I can reduce the number of method parameters but I need to write more unit tests.