这是在Java中执行以下任务的最佳方法

Question

I have more than 20 commonly used methods in my application. I would like to move that 20 methods into a common class.

Here my doubt is, define all the methods are static or normal method and create a global object to access that normal methods.

class Common {

public String method1() {........}
public String method2() {........}
public String method3() {........}
public String method4() {........}
public String method5() {........}
...

}

Creating object.

class CommonService {
    private static Common common;

    public static Common getCommon() {
    if(null == common) {
    common = new common();
    }
    return common;
    }
}

If we create all the methods using static means, all 20 methods are stored in PermGen section of the heap.

But if we follow above method means, only one object can be created and stored in java heap.

Please clarify which one is the best way.

Answer 1

"Common functions" is not quite accurate. It really depends on what you want to do, for example when I make some string utils I make StringUtils class and it has what I need. Whether to make it static or not depends on data to be processed, if one information might be used more than once for a call then answer is simple - use instances.

Answer 2

You should think about the "best" way in terms of design.

If the methods are used for general purposes, making them static is preferable, as you won't have any state to store and you'll save memory this way.

You should consider other things before deciding if you want to use static methods in your utility class or not. On one hand the utility class will be very easy to test, and it's highly accessible. On the other hand, it's very hard to mock static methods in your test.

If I have a utility class, I would write it as follows:

public final class Common {

    private Common() { }

    public static int method1() { }
    public static int method2() { }
    // ...

}

Answer 3

If we create all the methods using static means, all 20 methods are stored in PermGen section of the heap.

Methods are not data, but code. Where code is stored does not depend on whether a method accepts an implicit this parameter or not. If you use the singleton approach, method code will still occupy storage and additionally there will be an instance on the heap.

However, all of the above is irrelevant and you are focusing on a completely wrong aspect of your design. What matters is how the decision will affect the code which uses these methods:

• static methods are simple and a great choice for pure functions (which don't depend on any external state);
• singletons allow polymorphism, therefore make the methods easier to mock for testing.

Answer 4

That depends on what the methods do.

If those methods are just helper methods, that do not alter state then static is probably better because that way you do not have to create an object every time you want to use one of the methods. You can just call Common.method()

However, if the object has state then you should rater use object methods and create a new object when you want to use the methods.

Hope this helps.

Answer 5

If sense of this method is "execute pure function" like mathematical sin(x), cos(x) etc static method is the best.

They belongs to one domain? (range of themats) or to different? (then create more "utility classes" with correct name)

If have state (like many people say) maybe better is singleton.

Shape of the question "i have 20 method in application" and name Common suggest previous (older) design problem, I say "procedural thinking", poor vision of OOP.

Hard to say without code.