When doing small, single class programs should I make everything static or or instantiate a copy of itself in main?

Question

When I'm working on homework assignments for class it is typically beneficial if the programs are small to keep the problem to a single class (easy to submit with our script).

For these one-off programs does it make more sense to declare all methods and instance variables as static or does it make more sense to declare an instance of the class itself in the main method?

So, for example:

A.

public class MergeSort
{
   public static Scanner input = new Scanner(System.in);

    public static void main(String[] args)
    {
        int[] randData = getRandomData();
        int[] sortedData = mergeSort(randData);
    }

    public static int[] mergeSort(int[] unsortedData)
    {
        // ...
    }

    public static int[] merge(int[] data, int a, int b, int c)
    {
        // ...
    }
}

vs

B.

public class MergeSort  
{  
   public Scanner input = new Scanner(System.in);

    public static void main(String[] args)
    {
        MergeSort ms = new MergeSort();
        int[] randData = ms.getRandomData();
        int[] sortedData = ms.mergeSort(randData);
    }

    public int[] mergeSort(int[] unsortedData)
    {
        // ...
    }

    public int[] merge(int[] data, int a, int b, int c)
    {
        // ...
    }
}

Answer 1

Personally I'd go with B, it's a good habit to get into.

Answer 2

static should be only used when you want to use the method without needing a class instance. The static methods should also be independent from any instance variable (only use local or static variables)

Answer 3

this is really a matter of style. it's usually easier to instantiate inside main because then you don't need to keep mentioning everything as static later on.

Answer 4

I would make those methods static since they don't depend on the state of the object in any way. After all the sort methods in the Arrays and Collections classes are static too.

Answer 5

For homework, it's really a matter of taste. For real projects, you should instantiate the class and wrap that in try/catch so you can print the full stack trace if something goes wrong during construction of the class.

The default printStackTrace() of Java sometimes omits the nested exceptions, so you'll end up with "there was an error, see next exception" but you can't see it.

Answer 6

For homework, I would make it a habit of doing everything "by the book". If you don't, you may pick up bad habits and introduce bugs into your code in the future when working on more complicated assignments/projects. Good practice starts early and really shines through as you develop your skills in whatever language (it's what makes sometimes makes the difference between an 'ok' programmer and a 'good' programmer, in my opinion).

I associate it with any other subject in school; if you were learning English (for example) it makes sense to properly spell words, rather than replace them with say internet acronyms.

Answer 7

If you are in fact using the class as a collection of algorithms/methods that act on external data without reference to any fields that are part of a specific instantiation of the class, then yes, the methods should be static. That's the point of static methods.

However, there a lot of nuances that make several of the existing answers (i.e., don't use static methods) the better pragmatic advice. For example, if these classes might be used later as a particular instance of a Strategy interface/abstract class, all the static markers would have to be removed. Of course, it's all advice - both A and B are suitable answers.

If your instructor says only one is correct, then s/he is enforcing other requirements (e.g., coding standards to support later refactoring) beyond the here-and-now design requirement. Those other requirements are also a learning opportunity, so make sure the instructor explains the wherefores.