Spammy Java

Compare these two code snippets, they both do the same thing.

Minimalist

public static <T> Comparator<T> reverse(final Comparator<T> forward) {
  Preconditions.checkNotNull(forward, "forward");
  return new Comparator<T>() {
    public int compare(T a, T b) {
      return forward.compare(b, a);
    }
  };
}

Complete

/**
 * Returns a comparator that's the reverse of
 * {@code forward}.
 *
 * @param forward the forward comparator
 * @return the reversed comparator
 * @throws NullPointerException if {@code forward} is null
 */
public static <T> Comparator<T> reverse(final Comparator<T> forward) {
  return new ReverseComparator<T>(forward);
}

/**
 * A comparator that reverses another comparator.
 *
 * @param <T> the type to compare
 */
private static class ReverseComparator<T> implements Comparator<T> {
  private final Comparator<T> forward;

  public ReverseComparator(final Comparator<T> forward) {
    super();
    Preconditions.checkNotNull(forward, "forward");
    this.forward = forward;
  }

  @Override
  public int compare(final T a, final T b) {
    return forward.compare(b, a);
  }
}

Clearly, some people's spamis other people's ham. For your entertainment, here's my views:

Redundant Javadoc: spam. It decreases the signal-to-noise ratio of your docs, and tends to grow out-of-date. I've ranted about this before.

@throws NullPointerException Javadoc: okay. But I'd prefer to just have package-level or project doc that says "all parameters and return values will not be null unless otherwise specified".

'final' on parameters: spam. I almost never reassign parameter values, so the keyword doesn't say much.

'final' on fields: ham. Immutability is great, and I like to be explicit about it.

Named classes instead of anonymous ones: spam. Named classes require extra code for fields and a constructor. What a waste of code!

@Override: When I override a non-abstract method, I really want to make sure the name doesn't change - ham. But for abstract methods and interface methods, it doesn't pull it's weight for me - spam.

super() with 0 args: spam. Especially when the superclass doesn't have another constructor that takes parameters.

'public' on interface methods: okay, but I don't use it. The problem here is that 'public' implies that some other modifier could be appropriate here.

Disagree? Tell me why in the comments.