Java – Design Pattern For Util Classes and General Static Variables

design-patternsjava

I am developing a Mojo(think it as just a usual class) for my custom Maven Plugin. There is an Abstract Mojo at top. I have some other custom Mojos in example which makes server side includes. I have some static variables and some util methods in example get operating system name, fix file separator in order to used operating system etc. I have created an abstract Base Mojo that extends Abstract Mojo and put every common things inside it. When I create a Mojo (i.e. server side includer) I extend it from my Base Mojo. However should I think that I should separate variables and util methods or not and what kind of pattern I should follow.

To make it clear there is:

AbstractMojo at top by default (I can not change it)
BaseMojo an abstract class that extends AbstractMojo that has util methods and static system variables
CustomMojo extends BaseMojo and does its responsibility.

Any ideas how to implement a design for my needs?

Best Answer

I'm wondering, why this was migrated. But anyway:

You shouldn't put everything in a base mojo. That practically makes reusing that code impossible. Just think of the mojo growing and you need to split that mojo up into separate classes. You can't do that if that code has a dependency on the base class of the mojo.

You should create services that provide the functionality you currently have in your base mojo. They are reusable and therefore accessible from other places.

As a general rule of thumb:
YAGNI - You aint gonna need a member declaration in a class that is only intendend to be used by deriving classes. How do you know that it is really used?

Related Solutions

Java – Why were default and static methods added to interfaces in Java 8 when we already had abstract classes

A good motivating example for default methods is in the Java standard library, where you now have

list.sort(ordering);

instead of

Collections.sort(list, ordering);

I don't think they could have done that otherwise without more than one identical implementation of List.sort.

Java – the process of determining which method in a class hierarchy should execute known as

The question asks "which process determines which method should execute?"

This is a bad question.

But, we can immediately eliminate three of the choices: Is-A, Has-A, and Parent Class, since those are object-oriented, but not certainly not processes. Even if Is-A and Has-A were processes, they would be processes regarding class and composition, as you said, not method execution.

Inheritance is a process (also a concept), a process of inheriting the traits of the parent class. By that definition alone, we can eliminate it.

That leaves us with only Polymorphism, which is part of why this is a bad question. Polymorphism sounds like a concept, more than a process. However, if considered to be a process, it would be a process of "polymorphing" or "taking a different shape". An answer on Stack Overflow says:

So polymorphism is the ability (in programming) to present the same interface for differing underlying forms (data types).

By that definition, we're talking about a process where an object can act as one or more underlying real types. You have an interface, and the underlying data types determine which method should actually be called.

We're looking for a process that matches the statement "determining which method in a class hierarchy should execute", and I think that matches pretty well.

It's also a bad question because that statement could mean many other things, and I don't think many people would really described the "determining" part to be the polymorphism -- instead, I'd consider polymorphism to be the definition part.

Best Answer

Related Solutions

Java – Why were default and static methods added to interfaces in Java 8 when we already had abstract classes

Java – the process of determining which method in a class hierarchy should execute known as

Related Topic