It means a method you’re calling is declared with the throws directive for an exception derived from the Exception class. When a method is declared in this way, you are forced to deal with the exception using a try/catch block or add an identical throws (for the same exception or a super type) statement to your method declaration.
An example.
I want to call some method foo inside my method bar.
Here is foo‘s definition:
public static void foo(String a) throws Exception {
// foo does something interesting here.
}
I want to call foo. If I simply do this:
private void bar() {
foo("test");
}
…then I’ll get the error you are experiencing. foo declares to the world that it really might decide to throw an Exception and you had better be ready to deal with it.
I have two options. I can change bar‘s definition as follows:
private void bar() throws Exception {
foo("test");
}
Now I’ve publicized my own warning that my method or some method I call could throw an Exception that the user of my method should deal with. Since I’ve deferred responsibility to my method’s caller, my method doesn’t have to deal with the exception itself.
It’s often better to deal with the exception yourself, if you can. That brings us to the second option, the try/catch:
private void bar() {
try {
foo("test");
} catch(Exception e) {
Log.wtf("MyApp", "Something went wrong with foo!", e);
}
}
Now I’ve dealt with the potential Exception thrown by foo that the compiler was complaining about. Since it’s been dealt with, I don’t need to add a throws directive to my bar method.