0

I wonder what considerations I should make, when I have to decide whether to take an interface or a class to place my static helper method in.

Concrete example: I want to provide a little method, that I can call from the main method in Swing components, so I can faster iterate the development on them.

Should I place it in an interface or in a class?

public final class SwingDevHelper {
    public static void startSwingContainer(Container container) {
        ...
    }
}

public interface SwingDevHelper {
    static void startSwingContainer(Container container) {
        ...
    }
}

Do I have to consider semantical or technical points, e.g. performance or visibility?

Florian Bachmann
  • 532
  • 6
  • 14
  • 2
    Do you then need concrete implementations of `SwingDevHelper` that implement other methods from that interface? If the answer is "no" then you most probably don't need an interface. – Federico klez Culloca Feb 10 '23 at 07:56
  • So you only see semantical difference? There would be no technical difference, e.g. in performance or visibility? – Florian Bachmann Feb 10 '23 at 08:41
  • There shouldn't be any difference in performance. If you are not sure, try both approaches and do actual measurements. About visibility, both methods would be public, they're functionally identical. – Federico klez Culloca Feb 10 '23 at 08:53
  • method implement should be in class, interface only method abstract without body ```java void startSwingContainer(Container container) ``` – taismile Feb 10 '23 at 09:03

2 Answers2

1

The difference comes in the instantiability of SwingDevHelper.

If you need to instantiate SwingDevHelper, it can be either an interface or a (final) class.

If you don't need to (and/or don't want to) instantiate SwingDevHelper, make it a class with a private constructor:

public final class SwingDevHelper {
    private SwingDevHelper() {}  // Prevents instantiation outside this class.

    public static void startSwingContainer(Container container) {
        ...
    }
}

Making the class non-instantiable is a good idea where possible (i.e. when an instance of that class is meaningless/useless) because it simplifies the reasoning about the code: you never have to worry about what to do when you encounter an instance of it.

There is an item specifically about this in Effective Java: it's Item 22 in 3rd Ed: "Use interfaces only to define types". TL;DR: if SwingDevHelper isn't a meaningful type, don't use an interface.

Andy Turner
  • 137,514
  • 11
  • 162
  • 243
0

If this question is raised then this method does not belong to an interface ('interface' in broad meaning, not just Java). So it is always better to put it as low as possible. In other words, if it is possible -- keep it in a class, and move to interface only essential members.

Max Farsikov
  • 2,451
  • 19
  • 25