This is more of a conceptual question. Let’s say that you had the following enum
public enum FooEnum {
ALPHA,
BETA,
GAMMA,
DELTA;
}
And let’s say you have the following method:
public void doSomething(FooEnum value) {
if (value == FooEnum.ALPHA) {
// print something to the console
}
// other values ignored
}
Now, this example seems a little bit odd to me, as we’re completely disregarding every other value of FooEnum. Think of it not restricted to just enums, but let’s say something like
public class Person {
public void doSomething(String s) {
if (s.equals("asdf") {
System.out.println("something");
}
// disregard all other values
}
}
To me it seems like we should be at least doing something about other values we don’t care about. I’ve often done input validation before hand to get something like
public void doSomething(String s) {
if (s == null) {
throw new IllegalArgumentException();
}
// do stuff
}
but what happens in this example
public void doSomething(FooEnum value) {
if (value == null) {
throw new IllegalArgumentException();
}
if (value == FooEnum.ALPHA) {
// do something ALPHA specific
}
// ignore other logically grouped values in FooEnum
}
What is the (or are some) suggested ways to avoid/refactor this? The primary way I could think of is to either log that it was intentionally ignored. What other patterns could be used.
4
I think you’re looking for 2 things, but I answered this question a while ago
This is a very clear example of the Command Pattern
Basically it goes like this:
- Look up the thing to do
- Do it
If you use a defaulting map (there are implementations around) then, in the event the command was not found, you can do the default which can use the Null Object Pattern
As for the part about validation: Precondition checking is such a simple but effective way to eliminate bugs that it has it’s own Java spec JSR 303. That spec allows you to do something like:
public void doSomething(@NotNull String name, @Range(min = 0, max = 125) int age) {
}
and the infrastructure built into the running environment of your code will throw exceptions for you if these preconditions fail.
Oh, by the way: Ada was able to do this sort of thing decades ago.