Methods accounting for all input to method

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.