0

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.

  • 2
    Why do you think it is a problem for a function to ignore something it doesn't care about? – Steven Burnap Feb 28 '15 at 3:13
  • I guess my question may be more "Why does most code accept input that it will never use/ignore?". I'm not saying it's all code, but most the code I've encountered is this way. It's like if you received a free gallon of milk each week, put it in your fridge, and poured it out when it went bad because you're lactose-intolerant. – Zymus Feb 28 '15 at 5:07
  • It is a classical example where the refactoring of replace type code with class is applicable. – rwong Mar 1 '15 at 18:41
  • Data isn't a consumable resource the way milk is. There are many cases where trying to "not waste data" in the way you mean would directly conflict with making code modular. The obvious example is if doSomething is a virtual method and each subclass does something different with the data. – Steven Burnap Mar 1 '15 at 19:26
1

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:

  1. Look up the thing to do
  2. 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.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.