What is the difference between a Singleton pattern and a static class in Java? [duplicate]

by

Almost every time I write a static class, I end up wishing I had implemented it as a non-static class. Consider:

  • A non-static class can be extended. Polymorphism can save a lot of repetition.
  • A non-static class can implement an interface, which can come in handy when you want to separate implementation from API.

Because of these two points, non-static classes make it possible to write more reliable unit tests for items that depend on them, among other things.

A singleton pattern is only a half-step away from static classes, however. You sort of get these benefits, but if you are accessing them directly within other classes via `ClassName.Instance’, you’re creating an obstacle to accessing these benefits. Like ph0enix pointed out, you’re much better off using a dependency injection pattern. That way, a DI framework can be told that a particular class is (or is not) a singleton. You get all the benefits of mocking, unit testing, polymorphism, and a lot more flexibility.

More Related Contents:

  1. Finding a good design pattern for Java
  2. What is an efficient way to implement a singleton pattern in Java? [closed]
  3. Design Patterns web based applications [closed]
  4. Implementing Singleton with an Enum (in Java)
  5. What is the “Execute Around” idiom?
  6. What is the solution for the N+1 issue in JPA and Hibernate?
  7. Subclassing a Java Builder class
  8. What’s Alternative to Singleton
  9. Marker Interfaces in Java?
  10. Why do we need immutable class?
  11. why business logic should be moved out of JSP?
  12. Best way to build a Plugin system with Java
  13. How to avoid ‘instanceof’ when implementing factory design pattern?
  14. Replacing if else statement with pattern
  15. Java – Learning MVC [closed]
  16. Visitor pattern’s purpose with examples [duplicate]
  17. Using Command Design pattern
  18. How to get all classes names in a package? [duplicate]
  19. Benefits and drawbacks of method chaining and a possibility to replace all void return parameters by the object itself
  20. Parcelable and inheritance in Android
  21. should a db connection be a singleton?
  22. Advantages of Java’s enum over the old “Typesafe Enum” pattern?
  23. Creation of Objects: Constructors or Static Factory Methods
  24. Java collections covariance problem
  25. Why use a singleton instead of static methods?
  26. The builder pattern and a large number of mandatory parameters
  27. What is the difference between Factory and Strategy patterns?
  28. What is the difference between a fluent interface and the Builder pattern?
  29. How to create a singleton class
  30. How to hide the internal structure of a Java API to the rest of the world

Leave a Comment