是否有两个版本的相同方法只有不同的签名（方法名称和'throws'属性）被认为是糟糕的设计？

Question

I would like to design an API where I have two versions of the same method, extractLastElement() :

1. First version will not have a throws attribute: Object extractLastElementSafe(); Will be used when the client 'knows for sure' there are elements inside the collection, for example he've just added some elements, so no need for try-catch boilerplate code.

2. Second version will throw a Checked Exception: Object extractLastElement() throws NoMoreElementsException ; Will be used by the client when he isn't sure if there are still elements left in the collection, for example inside a loop.

Is this considered bad design? Is there any alternative for emulating this behavior?

public class SomeCollection {

  private List<String> arr;

  public SomeCollection(List<String> arr) {
      this.arr = arr;
  }

  public String extractLastElementSafe() {
      return arr.remove(arr.size() - 1);
  }

  public String extractLastElement() throws NoElementsLeftException {
      try {
          return arr.remove(arr.size() - 1);
      } catch (IndexOutOfBoundsException e) {
          throw new NoElementsLeftException(e); // throwing a checked exception
      }
  }
}

class NoElementsLeftException extends Exception {
  public NoElementsLeftException(Throwable cause) {
      super(cause);
  }
}

Answer 1

It is always questionable to give users the ability to do the same thing in different ways. It is also not elegant to force the client to worry about that last element being there or not.

But in the end, that is more of a style thing, and your approach can be regarded okay. Nonetheless you expose your clients to call the "safe" method and to end up with a runtime exception. So there are actually two different error scenarios in the end.

The one subtle thing to definitely change: avoid the code duplication! The method that does the try/catch to throw that exception should simply invoke the "safe" method!

Having said all of that: I would personally offer only one method that throws some runtime exception. Standard Java collections use unchecked exceptions, and so should you.

To quote Robert Martin: "the war between checked and unchecked exceptions is over, and unchecked won". And he wrote that more than 10 years ago.

Answer 2

If you have well-defined usage scenarios for each version of the method, it makes sense to have both. An example of such a design decision can be found in class Queue , which works in two modes when eg, trying to remove an element from an empty queue: one method ( poll ) returns null, and another ( remove ) throws an exception.