Are there any Java method ordering conventions? [closed]

Question

I've got a large-ish class (40 or so methods) that is part of a package I will be submitting as course-work. Currently, the methods are pretty jumbled up in terms of utility public/private etc. and I want to order them in a sensible way. Is there a standard way of doing this? E.g. normally fields are listed before methods, the constructor(s) are listed before other methods, and getters/setters last; what about the remaining methods?

Answer 1

1. Class (static) variables: First the public class variables, then the protected, and then the private.

2. Instance variables: First public, then protected, and then private.

3. Constructors

4. Methods: These methods should be grouped by functionality rather than by scope or accessibility. For example, a private class method can be in between two public instance methods. The goal is to make reading and understanding the code easier.

Source: https://www.oracle.com/java/technologies/javase/codeconventions-fileorganization.html

Answer 2

Some conventions list all the public methods first, and then all the private ones - that means it's easy to separate the API from the implementation, even when there's no interface involved, if you see what I mean.

Another idea is to group related methods together - this makes it easier to spot seams where you could split your existing large class into several smaller, more targeted ones.

Answer 3

The more precise link to «Code Conventions»: «Class and Interface Declarations»

Answer 4

Not sure if there is universally accepted standard but my own preferences are;

• constructors first
• static methods next, if there is a main method, always before other static methods
• non static methods next, usually in order of the significance of the method followed by any methods that it calls. This means that public methods that call other class methods appear towards the top and private methods that call no other methods usually end up towards the bottom
• standard methods like toString, equals and hashcode next
• getters and setters have a special place reserved right at the bottom of the class

Answer 5

40 methods in a single class is a bit much.

Would it make sense to move some of the functionality into other - suitably named - classes? Then it is much easier to make sense of.

When you have fewer, it is much easier to list them in a natural reading order. A frequent paradigm is to list things either before or after you need them , in the order you need them.

This usually means that main() goes on top or on bottom.

Answer 6

My "convention": static before instance, public before private, constructor before methods, but main method at the bottom (if present).

Answer 7

Also, eclipse offers the possibility to sort class members for you, if you for some reason mixed them up:

Open your class file, the go to "Source" in the main menu and select "Sort Members".

taken from here: Sorting methods in Eclipse

Answer 8

Are you using Eclipse? If so I would stick with the default member sort order, because that is likely to be most familiar to whoever reads your code (although it is not my favourite sort order.)