Question

I know this topic has been discussed and killed over and over again, but I still had one doubt which I was hoping someone could help me with or guide me to a pre-existing post on SO.

In traditional C, static variables are stored in data segments and local variables are stored in the stack. Which I would assume will make static variables more expensive to store and maintain when compared to local variables. Right?

When trying to understand in terms of Java or C#, would this be dis-advantage for static classes when compared to singleton class? Since the entire class is loaded into memory before class initialization, I don’t see how it can be an advantage unless we have small inline-able functions.

I love Singleton classes, and would hate to see it become an anti-pattern, I am still looking for all the advantages that come with it…and then loose to the argument of thread-safety among others.

-Ivar

Answer 1

Different from C, the static keyword in Java class definition merely means, This is just a normal class like any other class, but it just happens to be declared inside another class to organize the code. In other words, there is no behavioral difference whatsoever between the following 2 way of declaration*:
a)

class SomeOtherClass {
    static class Me {
        // If you "upgrade" me to a top-level class....
    }
}

b)

class Me {
    // I won't behave any different....
}

Class definitions are loaded to memory when the class is used for the first time, and this is true for both “static” and “non-static” classes. There are no difference in how memory will be used, either. In older JVMs, objects were always stored in heap. Modern JVMs do allocate objects on stack when that is possible and beneficial, but this optimization is transparent to the coder (it is not possible to influence this behavior via code), and use of the static keyword does not have any effect on this behavior.

Now, back to your original question, as we have seen we really can’t compare static classes and Singleton in Java as they are completely different concept in Java (I’m also not sure how static classes would compare with Singleton, but I will focus on Java in this answer). The static keyword in Java is overloaded and has many meanings, so it can be confusing.

Is Singleton automatically an “anti-pattern”? I don’t think so. Abuse of Singleton is, but the Singleton pattern itself can have many good uses. It just happens to be abused a lot. If you have legitimate reason to use the Singleton pattern, there is nothing wrong in using it.

---

*Note: Why write static at all, you might ask. It turns out “non-static” nested classes have their own somewhat complicated memory management implication, and its use is generally discouraged unless you have a good reason (pls refer to other questions for more info).

class SomeOtherClass {
    Stuff stuff;
    class Me {
        void method(){
            // I can access the instance variables of the outer instance 
            // like this:
            System.out.println(SomeOtherClass.this.stuff);
            // Just avoid using a non-static nested class unless you 
            // understand what its use is!
        }
    }
}