Let's say i have a class, and I made only one instance of it and i don't need more than that.
Should i just make the class static ? (not the class itself but the functions and the variables).
In the example below should i make the class static if i won't make more than one instance of it ?
public class Foo { int num1; int num2; public void func() { // Something in here } } public static void main(String[] args) { Foo bar = new Foo(); //I don't need more than one instance of that class. } If your class has no state, say:
class NoState { static int sum(int i1, int i2) { return i1 + i2; } } then it makes sense to use static methods.
If you must ensure that there is only one instance of your class, then you could use a singleton, but be careful: global state can be evil.
Not as bad as a singleton, you could use static fields/methods: it can be useful is some situations but should not be abused.
In any other situations (= most of the time), just use normal instance variables/methods.
You can use an enum to define a singleton.
public enum Foo { INSTANCE; int num1; int num2; public void func() { // Something in here } } public static void main(String[] args) { Foo bar = Foo.INSTANCE; } However, this is only need if you want to enforce one instance. Otherwise, I would just use new Foo(); and call it only once, if you only need one.
You can use Singleton. However, make sure if Singleton is what is really required - sometimes singletons gets overused where simple class with static methods might suffice. There are many ways to create singleton as explained What is an efficient way to implement a singleton pattern in Java?
Note that with Java 5, enum is the preferred way to create singleton.
You say that i don't need more than that so my answer is that not make more than one and if you really like to enforce the instance that it should be only one for class then use the enum best way to implement the singleton in java
for example in datasource one really needs singleton
public enum UserActivity { INSTANCE; private DataSource dataSource; private JdbcTemplate jdbcTemplate; private UserActivity() { this.dataSource = MysqlDb.getInstance().getDataSource(); this.jdbcTemplate = new JdbcTemplate(this.dataSource); } public void dostuff() { ... } } and if you really need that then use it otherwise go with your current logic
A class that must be instantiated once and only once, is called a singleton. That knowledge should help you narrow down your search for information. To give you a head start:
Basically static methods and fields means that you don't need any instances of the class.
In you case you need 'singleton' class, you can either use enum or make it a singleton by yourself, using the specific set of rules.
It really depends on the scope of your application. If you want this object to be used as a singleton you would provide a static method to get the one and only instance of the class.
public class Foo { private static Foo instance .... private Foo() { ..... } public static Foo getInstance() { return instance; } } If you plan to use a framework like spring you would just add one object to the application context.
<bean class="....Foo" id="fooInstance" scope="singleton"> .... </bean> But maybe, you can refractor this class to hold only static methods. Then you can mark the class as final and provide a private constructor.
public final class Utils { private Utils(){} public static .... doFoo(....) { .... } } 