Singleton pattern vs Static Class (a
class, having all static methods) is another interesting questions, which I
missed while blogging about Interview questions on Singleton pattern
in Java. Since both Singleton pattern and static class provides
good accessibility, and they share some similarities e.g. both can be used
without creating object and both provide only one instance, at very high level
it looks that they both are intended for same task. Because of high level
similarities, interviewer normally ask questions like, Why you use Singleton instead of Static Methods, or Can you replace
Singleton with static class, and what
are differences between Singleton pattern and static in Java. In order to
answer these question, it’s important to remember fundamental difference
between Singleton pattern and static class, former gives you an Object, while later just
provide static methods. Since an object is always much more capable than a
method, it can guide you when to use Singleton pattern vs static methods.
In this Java article we will learn, where to use Singleton pattern in
Java, and when static class is better alternative. By the way, JDK has examples
of both singleton and static, and that too very intelligently e.g. java.lang.Math is a final class with full of static methods, on the other
hand java.lang.Runtime is a Singleton class in Java. For those who are not
familiar with Singleton design pattern or static class, static class is a Java class, which only
contains static methods, good examples of static class is java.lang.Math,which
contains lots of utility methods for various maths function e.g. sqrt(). While Singleton classes are those,
which has only one instance during application life cycle like java.lang.Runtime.
When to use Static Class in place of
Singleton in Java
Indeed there are some situations, where static classes makes sense thanSingleton. Prime example of this is java.lang.Math which is
not Singleton, instead a class with all static methods. Here are few situation
where I think using static class over Singleton pattern make sense:
1) If your Singleton is not maintaining any state, and just providing
global access to methods, than consider using static class, as static methods are
much faster than Singleton, because of static binding during compile
time. But remember its not advised to maintain state inside static class, especially
in concurrent environment, where it could lead subtle race conditions when modified
parallel by multiple threads without adequate synchronization.
You can also choose to use static method, if you need to combine bunch of
utility method together. Anything else, which requires singles access to some
resource, should use Singleton design pattern.
Difference between Singleton vs Static in
Java
This is answer of our second interview question about Singleton over
static. As I said earlier, fundamental difference between them is, one
represent object while other represent a method. Here are few more differences
between static and singleton in Java.
1) Static class provides better performance than Singleton pattern, because
static methods are bonded on compile time.
2) One more difference between Singleton and static is, ability to
override. Since static methods in Java cannot be overridden, they leads to inflexibility. On the other hand, you can
override methods defined in Singleton class by extending it.
3) Static classes are hard to mock and consequently hard to test than
Singletons, which are pretty easy to mock and thus easy to test. It’s easier to
write JUnit test for Singleton than
static classes, because you can pass mock object whenever Singleton is
expected, e.g. into constructor or as method arguments.
4) If your requirements needs to maintain state than Singleton pattern is
better choice than static class, because
maintaining state in later case is
nightmare and leads to subtle bugs.
5) Singleton classes can be lazy loaded if its an heavy object,
but static class doesn't have such advantages and always eagerly loaded.
6) Many Dependency Injection framework
manages Singleton quite well e.g. Spring, which makes using them very easy.
These are some differences between static class and singleton pattern,
this will help to decide between two, which situation arises. In next section
we will when to choose Singleton pattern over static class in Java.
Advantage of Singleton Pattern over Static Class
in Java
Main advantage of Singleton over static is that former is more object
oriented than later. With Singleton, you can use Inheritance and Polymorphism to extend a base
class, implement an interface and capable of providing different
implementations. If we talk about java.lang.Runtime, which is a
Singleton in Java, call to getRuntime() method return
different implementations based on different JVM, but guarantees only one
instance per JVM, had java.lang.Runtime an static class, it’s not
possible to return different implementation for different JVM.
That’s all on difference between Singleton and static class in Java. When
you need a class with full OO capability , chose Singleton, while if you just
need to store bunch of static methods together, than use static class.
Other Java Design Pattern Tutorials from Javarevisited Blog
Source:http://javarevisited.blogspot.com/2013/03/difference-between-singleton-pattern-vs-static-class-java.html
Tidak ada komentar:
Posting Komentar