Question

By now my average class contains about 500 lines of code and about 50 methods.
IDE is Eclipse, where I turned “Save Actions” so that methods are sorted in alphabetical order, first public methods, and then private methods.
To find any specific method in the code I use “Quick Outline”. If needed, “Open Call Hierarchy” shows the sequence of methods as they called one by one.

This approach gives following advantages:

• I can start typing new method without thinking where to place it in the code, because after save it will be placed by Eclipse to appropriate place automatically.
• I always find public methods in the upper part of the code (don’t have to search the whole class for them)

However there are some disadvantages:

When refactoring large method into smaller ones I’m not very satisfied that new private methods are placed in different parts of code and therefore it’s little bit hard to follow the code concept. To avoid that, I name them in some weird way to keep them near each one, for example: showPageFirst(), showPageSecond() instead of showFirstPage(), showSecondPage().

May be there are some better approaches?

Answer 1

Well, naming your methods so that they’ll be easier to spot in your IDE is really not good. Their name should reflect what they do, nothing more.

As an answer to your question, probably the best thing to do is to split you class into multiple classes and isolate groups of methods that have something in common in each of such classes. For example , if you have

public void largeMethodThatDoesSomething() {
 //do A
 //do B
 //do C
}

which then you’ve refactored such that:

public void largeMethodThatDoesSomething() {
 doA();
 doB();
 doC();
}

private void doA() {};
private void doB() {};
private void doC() {};

you can make a class called SomethingDoer where you place all these 4 metods and then use an instance of that class in your original class.