7

I am trying to refactor a project in which there are same methods which are spread across various classes. To reduce code duplication, should I move the common code to an abstract superclass or should I put it in a static method in a utility class?

EDIT Some of the methods are for generic stuff which I believe can be made static. While there are others which refer to attributes of the class, in which case I think it makes more sense to make it as an abstract super class.

  • 2
    Impossible to answer without context; a lot depends on how closely related the existing classes are, how the classes and methods are used, etc. – Dave Newton Dec 16 '11 at 05:26
  • 1
    You have to tell us more about these methods - if they share the same behavior and could act independently of any classes, then having utility classes with static methods would make sense. If you're thinking of using abstract classes/base classes/interfaces, you have to consider whether that class hierarchy would make sense, and whether these functions are really behavior intrinsic to those classes or, as mentioned earlier, those methods don't care about the class they're part of. – wkl Dec 16 '11 at 05:27
  • Can you explain what the method does and if all those classes are related? – Bhesh Gurung Dec 16 '11 at 05:27
  • give some more information related what is actually you try to do. – Sumit Singh Dec 16 '11 at 05:28
  • 1
    I asked almost same question: http://stackoverflow.com/questions/5312193/base-class-vs-utility-class. See if it helps. – Azodious Dec 16 '11 at 05:31

7 Answers7

6

Well, I follow a rule: Don't use base class to remove code duplication, use utility class.

For inheritance, ask question to yourself: Does Is-A relationship exist?

Another rule, which most of the times is correct, is: Prefer composition over inheritance

using static utility class is NOT true composition but it can be called a derivation of it.

Apply these rules to your secenrios and take a decision keeping in mind maintanence and scalability. However it will be good if you could add more details to your quesiton.

Azodious
  • 13,752
  • 1
  • 36
  • 71
2

It depends on what your code is doing. Are they utility methods? Are they specific/specialized class methods? Is this a heavy multithreaded application?

Keep in mind that if you make them static and your application is multithreaded, you will have to protect them w locks. This, in turn, reduces concurrency. In this case, depending on how many threads call that same piece of code, you might consider moving it (the code) to a super class.

Adrian
  • 5,603
  • 8
  • 53
  • 85
1

Another point to consider may be the type of work these functions do. If that is scattered, you should create a facade / helper / util class with static methods.

Nrj
  • 6,723
  • 7
  • 46
  • 58
1

As others have mentioned the answer to this depends on the context of the problem and the duplicated code.

Some things to consider

  • Does the duplicated code mutate the instance of the object. In this case a protected method in a common abstract class
  • Instead of Static utility class consider a singleton, Static methods can be problematic for pure unit testing although testing frameworks are getting better at this.
  • Inheritance can be tricky to get right, think about if these objects from the different classes are really related and require some OO re-factoring ? or are they disjoint pieces of domain logic that happen to require similar bits of code.
bluphoenix
  • 338
  • 2
  • 6
  • 12
0

If it does not use any class members you might do it static!

But you should do it in a abstract class or mother class

Matthias Bruns
  • 899
  • 8
  • 13
0

If the methods use many fields or methods of the class they should not be static. If they are something that a subclass might want to modify they should not be static. If the methods should be part of an Interface they cannot be static.

Otherwise it's your call and you will probably change your mind later. :-)

user949300
  • 15,364
  • 7
  • 35
  • 66
0

At first glance, I would say that it would be better to make the common code as a public static method in a public class. This will make the method useful to any class just by using 

    UtilityClassName.methodName();

This is better then making it a concrete method in an abstract super-class because then you will always need to extend this super-class in all the classes where you want to use this one single method.

But now, as you said that the method's behavior depends on some variables. Now, if it depends on the instance variables of different classes, then better add this method in an interface and let all your classes implement this interface and have their own implementation of the same.

But again if these variables are constant values, then have these constant values in an interface. Implement these interface in your utility class. And again make it a static method in that utility class which will directly use these constants.

For e.g. Consider foll. common code of returning area of a circle.

    public interface TwoDimensional{
        double PI = 3.14;
    }

    public class MyUtility implements TwoDimensional{
        public static double getCircleArea(double radius){
            return PI*radius*radius;
        } 
    }

Here, you can see that method getCircleArea() depends on the radius which will be different for different classes but still I can pass this value to the static method of myUtility class.

whitehat
  • 2,381
  • 8
  • 34
  • 47