Java Coding Style – Should Classes Be Created Within Methods?

coding-standardscoding-stylejava

I have made a program using Java that is an implementation of this project: http://nifty.stanford.edu/2009/stone-random-art/sml/index.html. Essentially, you create a mathematical expression and, using the pixel coordinate as input, make a picture. After I initially implemented this in serial, I then implemented it in parallel due to the fact that if the picture size is too large or if the mathematical expression is too complex (especially considering the fact that I made the expression recursively), it takes a really long time. During this process, I realized that I needed two classes which implemented the Runnable interface as I had to put in parameters for the run method, which you aren't allowed to do directly. One of these classes ended up being a medium sized static inner class (not large enough to make an independent class file for it though). The other though, just needed a few parameters to determine some indexes and the size of the for loop that I was making run in parallel – here it is:

class DataConversionRunnable implements Runnable
    {
        int jj, kk, w;

        DataConversionRunnable(int column, int matrix, int wid)
        {
            jj = column;
            kk = matrix;
            w = wid;
        }

        public void run()
        {
            for(int i = 0; i < w; i++)
                colorvals[kk][jj][i] = (int) ((raw[kk][jj][i] + 1.0) * 255 / 2.0);
            increaseCounter();
        }
    }

My question is should I make it a static inner class or can I just create it in a method? What is the general programming convention followed in this case?

Best Answer

Jon Lin's got the solution you want. (+1 to Jon) An anonymous class is the way to go. Otherwise: if you want to use the same class more than once, a named local class can be used, just as you have it in your question. If you need it in more than one method, switch to a private inner class. If it helps other classes work with the parent class, then use a public inner class. If it's not tightly tied to its parent, put it in its own file.

The basic idea is encapsulation of the class (as opposed to data--a variable or field). The class itself should be known only to the code that needs to know about it. If you make it a nested class, someone looking at the reference has to go look for the class code and someone looking at the nested class code has to go looking for a reference. With a good IDE this is not too hard, but with local/anonymous classes its easy even when looking at the code in Notepad. And then there's the problem of getting data to and from the class....

Java is really good with this. Some other languages don't allow local classes. To be fair, they don't require them, either--a lot of standard Java classes are written with the idea the user can easily generate swarms of local, temporary classes. But, as in your case, local classes are quite handy even without the system classes that want them.

Related Topic