How do you decide whether to add an exception to the method signature or handle it in the method?

This question is a little difficult to answer.

Let's say you go to the market to buy something, but you don't have cash in your valet. You have an ATM card from a bank, but again, you are not sure if you have enough money in your account to make purchases.

Now you can do two things. Or,

1) First you make sure you have enough money in your account before going to market, OR

2) Go to the market and then see if you can buy any items.

Likewise, there are two types of exceptions in java

Checked Exception which is a sub-class of java.lang.Exception, and 
Unchecked Exception which is a sub-class of java.lang.RuntimeException.

      

        
        
        
      

    

Checked Exceptions can be considered synonymous with the first case when you are about to shop. Here, upon finding that you do not have enough balance to make purchases, you can decide to take it from someone or do nothing, that is, exit the purchase plan for the time being.

Likewise, Unchecked Exception can be thought of as you go to market without knowing about the balance in your account. Now on the account counter, your transaction will be successful OR it will be rejected because you do not have enough balance in your account. Here, too, you can decide to just apologize to the store clerk and leave, or you can call someone to bring the necessary money to the store.

As you can see, what you can do in these situations is entirely up to you.

Likewise, when programming with Java, there isn't much of a difference between Fixed and Unchecked Exception and what you want to do if Exceptions happened is entirely up to your personal / organizational policies.

The Java compiler only enforces this if, in the case of a method that threw Checked Exception, your code using that method must catch the Exception OR throw it up one level. Although in the case of Unchecked Exceptions, this is optional.

Take the following method as an example, which throws a Checked Exception:

// Here compiler makes sure that you either catch exception OR declare it to be thrown
public void storeDataFromUrl(String url){
    try {
         String data = readDataFromUrl(url); 
    } catch (BadUrlException e) {
         e.printStackTrace();
    }
}

// Here BadUrlException is a subclass of Exception    
public String readDataFromUrl(String url) throws BadUrlException{
    if(isUrlBad(url)){
        throw new BadUrlException("Bad URL: " + url);
    }
    String data = null;
    //read lots of data over HTTP and return it as a String instance.
    return data;
}

      

        
        
        
      

    

Now your storDataFromUrl () method can either catch a BadUrlException or it can declare it as a throw, in which case the code using the storeDataFromUrl () method will have to do the same. That is, either catch the exception or throw it for someone above to deal with it the way they would like.

And now the same example that throws an Unchecked exception;

// Here compiler does not force you to either catch exception OR declare it to be thrown
public void storeDataFromUrl(String url){
         String data = readDataFromUrl(url); 
}

// Here BadUrlException is a subclass of RuntimeException    
public String readDataFromUrl(String url) { // Notice, it does not have a throws clause
    if(isUrlBad(url)){
        throw new BadUrlException("Bad URL: " + url);
    }
    String data = null;
    //read lots of data over HTTP and return it as a String instance.
    return data;
}

      

        
        
        
      

    

SEVERAL POINTS . Most books advise you to use checked exceptions for all errors from which the application can be recovered, and unrecoverable exceptions for errors from which the application cannot recover.

In reality, most applications will have to recover almost all exceptions, including NullPointerException, IllegalArgumentExceptions, and many other unchecked exceptions. The action / transaction could not be completed, but the application should stay alive and ready to perform the next action / transaction. The only time it is usually legal to close an application is during startup. For example, if there is no configuration file and the application cannot do anything reasonable without it, then it is legal to close the application.

The EDIT: . I can read these two articles to learn more about the topic: Three Rules for Effective Exception Handling and Best Practices for Exception Handling