Java: When to make methods static v. instance [closed]

Answer 1

I would like to start answering on your question with the new one: What your class Gene is responsible for? May be you have heard about the 'Single-Responsibility Principle': A class should have only one reason to change. So, I believe if you answer this question you will be able to decide how your application should be designed. In this particular case, I would not use neither the first approach nor the second one. In my opinion it is much better to define new responsibility and encapsulate it in a separate class or may be a function.

Answer 2

Here's a meta-answer, and a fun exercise: survey a bunch of the Java SDK's library classes and see if you can categorize the commonalities between static methods in different classes.

Answer 3

IMO there is no absolute "better", but public int geneDistance(Gene other) is stylistically more similar to other methods in Java (e.g. Object.equals, Comparable.compareTo), so I'd go that way.

Answer 4

My answer is very opinionated.

I would go the same way as one of the StringUtils.getLevenshteinDistance implementation in StringUtils.

    public interface GeneDistance{
        public int get();
    }

    public class GeneDistanceImpl implements GeneDistance{
        public int get(){ ... }
    }

    public class GeneUtils{
        public static int geneDistance(Gene g0, Gene g1){
            return new GeneDistanceImpl(g0, g1).get();
        }
    }

Some points for doing it this way

• There might be several distance implementations, so an utility method is more preferable than g0.distanceTo(g1)
• I can static-import it for a short notation
• I can test my implementation

• I can also add this:

  class Gene{
      // ... Gene implementation ...
  
      public int distanceTo(Gene other){
          return distance.get(this, GeneUtils.getDefaultDistanceImpl());
      }
  
      public int distanceTo(Gene other, GeneDistance distance){
          return distance.get(this, other);
      }
  }
  

One of the reasons to make a complex method completely static is the performance. static keyword is a hint for a JIT compiler that the method can be inlined. In my opinion you s/he don't need to bother about such things unless their method calls are almost instantaneous - less than a microsecond, i.e. a few string operations or a simple calculation. This might be the reason why Levenshtein distance was made completely static in the latest implementation.